GridFlow 0.7.3 - index of this page:

Objects for making grids and breaking them down

This object allows you to import non-grid jMax data, such as integers and lists of integers. This object also reframes/resyncs integers and grids so that multiple grids may be joined together, or single grids may be split.

this object is the opposite of @import.

this object is another opposite of @import, which puts all of its values in a jMax list.

this object is another opposite of @import, which puts all of its values in a jMax list.

holds two values, defaulting to (0,0). each time one is changed (by sending an integer in that inlet), a Dim(2) grid of those values is sent through the outlet.

holds three values, defaulting to (0,0,0). each time one is changed (by sending an integer in that inlet), a Dim(3) grid of those values is sent through the outlet.

holds four values, defaulting to (0,0,0,0). each time one is changed (by sending an integer in that inlet), a Dim(4) grid of those values is sent through the outlet.

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 is a massively parallel version of jMax's builtin arithmetic operators. In case you wonder, it's only parallel in the sense that all those computations are independent; there's no guarantee about how many of them will actually be computed at once.

This object computes a grid by computing "in parallel" a same operation on each element of the grid.

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, 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.

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.

@inner2 is a variant on @inner; used to be called @inner (GF-0.4.1 and before); the right-hand "matrix" is transposed upon reception (the last dimension is swapped with the rest of the dimensions, so that the last becomes first and the others stay in order)

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.

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.

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.

Special Objects

WARNING: this class does not work as advertised.

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.

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.

Counterpart of jmax_udpsend

GridFlow 0.7.3 Documentation
by Mathieu Bouchard matju@artengine.ca and
Alexandre Castonguay acastonguay@artengine.ca