GridFlow 0.8.4 - Reference Manual: Flow Classes

Objects for making grids and breaking them down

This object allows you to produce grids from non-grid data, such as integers and lists of integers. This object also reframes/resyncs grids so that multiple grids may be joined together, or single grids may be split. That kind of operation is already done implicitly in many cases (e.g. sending an integer or list to a grid-receiving inlet), but using this object you have greater flexibility on the conversion.

this object is the opposite of #import.

this object is another opposite of [#import], which puts all of its values in a list.

this object is another opposite of #import, which constructs a symbol from its input. The values are expected to be valid ASCII codes, but no check will be performed for that, and additionally, no check will be made that the generated symbol only contains characters that can be put in a symbol.

Similar to [#join], but takes individual integers, and builds a Dim(N) vector out of it.

Triple slider for the selection of RGB values.

when given scalar bounds, works like a regular [for] object plugged to a [#import] tuned for a Dim(size) where size is the number of values produced by a bang to that [for].

when given vector bounds, will work like any number of [for] objects producing all possible combinations of their values in the proper order. This replaces the old [#identity_transform] object.

Objects for Computing

This object outputs a grid by computing "in parallel" a same operation on each left-hand element with its corresponding right-hand element.

this object computes the square of complex numbers. If seeing imaginary as Y and real as X, then this operation squares the distance of a point from origin and doubles the angle between it and the +X half-axis clockwise. (fun, eh?)

used on an indexmap, this makes each thing appear twice, each apparition spanning half of the original angle.

• 1 : [#fold +] computes totals
• 2 : [#fold inv+] is an alternated sum (+/-)
• 3 : [#fold * 1] can compute the size of a grid using its dimension list
• 4 : [#fold & 1] can mean "for all"
• 5 : [#fold | 0] can mean "there exists (at least one)"
• 6 : [#fold ^ 0] can mean "there exists an odd number of..."
• 7 : [#fold ^ 1] can mean "there exists an even number of...".

[#scan +] computes subtotals; this can be used, for example, to convert a regular probability distribution into a cumulative one. (or in general, discrete integration)

When given a grid of Dim(3) and a grid of Dim(5) [#outer] will produce a grid of Dim(3,5) with the selected two-input operation applied on each of the possible pairs combinations between numbers from the left grid and the ones from the right. for example : (10,20,30) [#outer +] (1,2,3) will give : ((11,12,13),(21,22,23),(31,32,33))

think of this one as a special combination of [#outer], [#] and [#fold]. this is one of the most complex operations. It is very useful for performing linear transforms like rotations, scalings, shearings, and some kinds of color remappings. A linear transform is done by something called matrix multiplication, which happens to be [#inner * + 0]. [#inner] also does dot product and other funny operations.

For example, joining a RGB picture Dim[y,x,3] and a greyscale picture Dim[y,x,1] on dimension 2 (or -1) could make a RGBA picture Dim[y,x,4] in which the greyscale image becomes the opacity channel.

splits a Dim[A...,B] grid into Dim[B] vectors, producing new Dim[B] vectors that each contain numbers from 0 to B-1 indicating the ordering of the values. The result is a Dim[A...,B] grid.

for example, connecting a [#grade] to a [#outer ignore {0}] to a [#store] object, storing a single vector into [#store], and sending the same vector to [#grade], will sort the values of the vector. however for higher-dimensional grids, what should go between [#store] and [#grade] to achieve the same result would be more complex.

you may achieve different kinds of sorting by applying various filters before [#grade]. the possibilities are unlimited.

if you plug [#grade] directly into another [#grade], you will get the inverse arrangement, which allows to take the sorted values and make them unsorted in the original way. note that this is really not the same as just listing the values backwards.

transforms a Dim[A...,B] grid into a Dim[A...,B-1] grid. There is a projection plane perpendicular to the last axis and whose position is given by the "depth" parameter. Each vector's length is adjusted so that it lies onto that plane. Then the last dimension of each vector is dropped.

useful for converting from 3-D geometry to 2-D geometry. Also useful for converting homogeneous 3-D into regular 3-D, as homogeneous 3-D is really just regular 4-D...(!)

Objects for Coordinate Transforms

example: with a 240 320 RGB image, [#redim 120 640 3] will visually separate the even lines (left) from the odd lines (right). contrary to this, [#redim 640 120 3] will split every line and put its left half on a even line and the right half on the following odd line. [#redim] 480 320 3 will repeat the input image twice in the output image. [#redim] 240 50 3 will only keep the 50 top lines.

A [#store] object can store exactly one grid, using the right inlet. You fetch it back, or selected subparts thereof, using the left inlet.

example: suppose you have [#store {10 240 320 3}]. then "put_at 3" will allow to write a Dim[240,320,3] grid in indices (3,y,x,c) where y,x,c are indices of the incoming grid; in other words, if that's a buffer of 10 RGB frames, you'd be replacing frame #3. Furthermore, it also allows you to write a Dim[n,240,320,3] grid at (3+f,y,x,c) where f,y,x,c are indices of the incoming grid, replacing frame #3, #4, ... up to #3+n-1. Here n is at most 7 because the last frame in the buffer is #9.

that way of working extends to other kinds of data you'd put in Grids, in any numbers of dimensions; because, as usual, [#store] wouldn't know the difference.

typically you plug a [#for] into this object, and you plug this object into the left side of a [#store]. it will scatter pixels around, giving an "unpolished glass" effect.

if you put a picture in it, however, it will add noise. The resulting values may be out of range, so you may need to clip them using min/max.

[#spread] scatters the pixels in an image. Not all original pixels will appear, and some may get duplicated (triplicated, etc) randomly. Some wrap-around effect will occur close to the edges.

Sending an integer to inlet 1 sets the amount of spreading in maximum number of pixels + 1. even values translate the whole image by half a pixel due to rounding.

performs rotations on indexmaps and polygons and such.

if you chain indexmap (coordinate) transformations from outlet 1 to inlet 1, then sending an image in inlet 0 will emit its deformation out of outlet 0.

Objects for Reporting

Returns list of dimensions as a grid. Given a grid sized like Dim(240,320,4), [#dim] will return a grid like Dim(3), whose values are 240, 320, 4.

gives a symbol representing the numeric type of the grid received.

Objects for Color Conversion

This object is useful for color correction. For each pixel it takes it apart, looks up each part separately in the colormap, and constructs a new pixel from that. You may also color-correct colormaps themselves.

Only works for things that have 3 channels.

Note: if you just need to apply a palette on an indexed-color picture, you don't need this. Just use #store instead.

note: may change slightly to adapt to actual video standards.

note: may change slightly to adapt to actual video standards.

Objects for Miscellaneous Picture Processing

this is the object for blurring, sharpening, finding edges, embossing, cellular automata, and many other uses.

[#contrast] adjusts the intensity in an image. resulting values outside 0-255 are automatically clipped.

[#posterize] reduces the number of possible intensities in an image; it rounds the color values.The effect is mostly apparent with a low number of levels.

example: simulate the 216-color "web" palette using 6 levels. simulate a 15-bit display using 32 levels.

makes medium intensities brightest; formerly brightest colours become darkest; formerly darkest stays darkest. This filter is linear: it's like a 200% contrast except that overflows are mirrored instead of clipped or wrapped.

inlet 2 receives a font grid, for example, [#in grid file lucida-typewriter-12.grid.gz]

inlet 1 receives a 2 by 3 matrix representing the colours to use (e.g. (2 3 # 0 170 0 255 255 0) means yellow on green)

inlet 0 receives a bang, transforming the data into an image suitable for #draw_image.

inlet 1 receives an angle (0..36000)

inlet 0 receives a RGB picture that gets hueshifted by a rotation in the colorwheel by the specified angle; it gets sent to outlet 0.

Other Objects

sets the receive-symbol for the Pd patcher it is in.

has no inlets, no outlets.

EXPERIMENTAL.

objects of this class do nothing by themselves and are just an access point to features that don't belong to any object in particular.

This object returns the Unix timestamp. The first outlet does so with ASCII, the second in seconds and the third outlet outputs the fractions of seconds up to 1/100 000 th of a second which is useful for creating filenames.

This object is similar to the Unix list command 'ls'. It returns the names of files in a given directory. May be used with [listlength] to retrieve the number of files. Hidden files are displayed.

This object launches a Unix shell program or script.

This object accepts a list of two elements as arguments. The current file name being the first and the second is the desired change in name.

This object produces HPGL instructions in ASCII form that can be sent to the comport object in order to control an HPGL compatible plotter.

inlet 0 float : sends the specified array entry to outlet 0

inlet 1 list: writes that list as an array entry in position last specified by inlet 0.

inlet 0 save(symbol filename): writes the array contents to a file of the given filename as a CSV

inlet 0 save(symbol filename, symbol format): same thing but using a sprintf string such as %x,%f or whatever

inlet 0 load(symbol filename): replace all array contents by the contents of a CSV file

jMax emulation

those classes emulate jMax functionality, for use within PureData and Ruby.

Every incoming message is sent to inlet 1 and then sent to inlet 0 as well. Messages remain completely unaltered. Contrast with PureData's "t a a" objects, which have the same purpose but transform bangs into zeros and such.

GridFlow 0.8.4 Documentation
Copyright © 2001-2006 by Mathieu Bouchard matju@artengine.ca