this object is the opposite of #import.

this object is not configurable because there isn't anything that could possibly be configured here. transforms this grid into a sequence of integer messages. elements of the incoming grid.

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

transforms this grid into a single message containing a list of integers. elements of the incoming grid.

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.

transforms this grid into a single message containing a list of integers. generated symbol

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

The value "any" (and the only available value for now) causes an output to produced when an integer is received thru any inlet, contrary to most other object classes, that only act upon reception of a value thru inlet 0. how many inlets the object should have. combination of inputs given in all inlets. this is produced according to the value of the trigger attribute.

Triple slider for the selection of RGB values.

changes all three values (R,G,B). The grid must be a Dim(3). sends the rest of the message to each of the three sliders. this relies on the fact that [#color] is implemented using three [hsl] and this might not still work in the far future. Produces a Dim(3) grid of RGB values. how many outlets the object should have. (depending on the version of the software, the number of visible outlets may have been frozen to 4. If it is so, then the value of this argument must not exceed 4; and if it is below 4, then don't use the extraneous outlets.) the input vector is split in N parts containing one number each. numbers are sent left-to-right, that is, outlet 0 is triggered first, then outlet 1, etc. will compute the centroid of the given grid, which is a weighted average, namely, the average position weighted by the pixel values. result

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.

replaces the "from" value and produces output. replaces the "to" value. replaces the "step" value. where size is floor((to-from+1)/step) [for scalar bounds] where *size is floor((to-from+1)/step) [for vector bounds]

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

on each element of this grid, perform the operation together with the corresponding element of inlet 1. in the table of operators (at the top of this document) elements of inlet 0 are called "A" and elements of inlet 1 are called "B". the resulting grid is the same size as the one in inlet 0. any grid, preferably shaped like the one that will be put in the left inlet, or like a subpart of it (anyway the contents will be redim'ed on-the-fly to fit the grid of inlet-0, but the stored grid will not be modified itself) stores a single int in the right inlet; the same int will be applied in all computations; this is like sending a Dim(1) or Dim() grid with that number in it.

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.

[#fold +] computes totals

[#fold inv+] is an alternated sum (+/-)

[#fold * 1] can compute the size of a grid using its dimension list

[#fold & 1] can mean "for all"

[#fold | 0] can mean "there exists (at least one)"

[#fold ^ 0] can mean "there exists an odd number of..."

[#fold ^ 1] can mean "there exists an even number of...".

replaces every Dim(last) subgrid by the result of a cascade on that subgrid. Doing that with seed value 0 and operation + on grid "2 3 5 7" will compute ((((0+2)+3)+5)+7) find the total "17". produces a Dim(dims) grid.

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

replaces every Dim(last) subgrid by all the results of cascading the operator on that subgrid, producing a Dim(dims,last) grid. For example, with base value 0 and operation + on grid "2 3 5 7" will compute 0+2=2, 2+3=5, 5+5=10, 10+7=17, and give the subtotals "2 5 10 17". the operator must be picked from the table of two-input operators. the grid is optional and corresponds to inlet 1. produces a grid of size Dim(anyA..., anyB...), where numbers are the results of the operation on every element of A and every element of B. the resulting array can be very big. Don't try this on two pictures (the result will have 6 dimensions) stores the specified grid, to be used when inlet 0 is activated.

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.

Splits the Dim(anyA...,lastA) left-hand grid into Dim(anyA...) pieces of Dim(lastA) size. Splits the Dim(firstB,anyB...) right-hand grid into Dim(anyB...) pieces of Dim(firstB) size. On every piece pair, does [#] using the specified op_para operation, followed by a [#fold] using the specified op_fold operator and base value. creates a Dim(anyA...,anyB...) grid by assembling all the results together. (note: lastA must be equal to firstB.) the operation that combines the values from the two grids together. this defaults to "*" (as in the matrix product) the operation that combines the result of the "op" operations together. this defaults to "+" (as in the matrix product) changes the base value to that. changes the right-hand side grid to that. Which_dim is the number of the dimension by which the join will occur. For N-dimensional grids, the dimensions are numbered from 0 to N-1. In addition, negative numbers from -N to -1 may be used, to which N will be added. The left grid and right grid must have the same number of elements in all dimensions except the one specified. The result will have the same number of elements in all dimensions except the one specified, which will be the sum of the two corresponding one.

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.

any grid a bang is emitted every time a grid transmission ends. any grid a grid of the same shape containing all the same values after type conversion. note that while casting to a smaller type, values that are overflowing will be truncated. any grid like [#redim] but always produce a 1-D grid with the same total number of elements. any grid

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.

any grid

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...(!)

swaps the two specified dimensions; dimension numbers are as in [#join]. produces on outlet 0 a linear recurrent fading according to the flow of incoming messages. For example, if rate=5, then 20% (one fifth) of each new message will be blended with 80% of the previous output. produces on outlet 0 a piecewise-linear nonrecurrent fading according to the flow of incoming messages. For example, if maxraise=2 and maxdrop=4, then with each new message an output is produced that is at most 2 more or 4 less than the previous output. Whichdim is the number of the dimension by which the reverse will occur. For N-dimensional grids, the dimensions are numbered from 0 to N-1. In addition, negative numbers from -N to -1 may be used, to which N will be added.

a list specifying a grid shape that the numbers will fit into. (same as with [#import]) the elements of this grid are serialized. if the resulting grid must be larger, the sequence is repeated as much as necessary. if the resulting grid must be smaller, the sequence is truncated. then the elements are deserialized to form the resulting grid. this grid is a dimension list that replaces the one specified in the constructor. (same as with [#import]) redimensioned grid potentially containing repeating data.

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.

the stored grid is fully sent to the outlet. in this grid, the last dimension refers to subparts of the stored grid. sending a Dim(200,200,2) on a [#store] that holds a Dim(240,320,3) will cause the [#store] to handle the incoming grid as a Dim(200,200) of Dim(2)'s, where each Dim(2) represents a position in a Dim(240,320) of Dim(3)'s. therefore the resulting grid will be a Dim(200,200) of Dim(3) which is a Dim(200,200,3). in practice this example would be used for generating a 200*200 RGB picture from a 200*200 XY map and a 240*320 RGB picture. this object can be logically used in the same way for many purposes including color palettes, tables of probabilities, tables of statistics, whole animations, etc. replace the whole grid, or a subpart of it (see other options on inlet 1) (Future Use): makes it so that sending a grid to inlet 1 detaches the old buffer from [#store] and attaches a new one instead. This is the default. (Future Use): makes it so that sending a grid to inlet 1 writes into the existing buffer of [#store].

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.

grids as stored, as indexed, or as assembled from multiple indexings. {height width} pair. a 3-channel picture to be scaled. a {height width} pair. a scaled 3-channel picture. factor is optional (default is 2). if it's a single value, then that factor is to be used for both rows and columns. duplicates each pixel several times in width and several times in height, where the number of times is determined by the factor described above. twice those of the incoming grid. It is several times faster. sets factor factor is optional (default is 2). if it's a single value, then that factor is to be used for both rows and columns. Scales down picture by specified amount. (See scale factor above) sets scale factor

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.

same as inlet 1 a coordinate map. a spread factor. a coordinate map.

[#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.

rotation angle; 0...36000

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.

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.

no arguments. ignores any data contained within. sends a grid dim(length of dims) containing dims. the list of dimensions of the incoming grid.

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

GUI object equivalent to [print] and [#print]. Displays the received message in the box, resizing the box so that the message fits exactly.

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.

picture colormap ("palette") picture

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

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

splits the incoming grid into dim(rest...) parts. for each of those parts at (y,x), a rectangle of such parts, centered around (y,x), is combined with the convolution grid like a [#] of operation op_para. Then each such result is folded like [#fold] of operation op_fold and specified base. the results are assembled into a grid that is sent to the outlet. near the borders of the grid, coordinates wrap around. this means the whole grid has to be received before production of the next grid starts. this is the convolution grid and it gets stored in the object. if rows2 and/or columns2 are odd numbers, then the centre of convolution is the middle of the convolution grid. if they are even numbers, then the chosen centre will be slightly more to the left and/or to the top, because the actual middle is between cells of the grid. same as inlet 1. same as inlet 2. produces a grid like the incoming grid but with different constrast.

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

this is the secondary contrast (inverse whiteness). it makes the incoming black correspond to a certain fraction between output black and the master contrast value. no effect is 256. default value is 256. this is the master contrast. it makes the incoming white correspond to a certain fraction between output black and output white. no effect is 256. default value is 256.

[#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.

same as inlet 1 produces a posterized picture from the input picture. this is the number of possible levels per channel. the levels are equally spaced, with the lowest at 0 and the highest at 255. the minimum number of levels is 2, and the default value is 2.

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.

result from a [#for {0 0} {height width} {1 1}] checkered pattern of 50%/75% greys in 8x8 squares a picture that has an opacity channel. will be used as foreground. a picture that has NO opacity channel. will be used as background. a picture that has NO opacity channel. the opacity channel of the foreground is used as a weighting of how much of either picture is seen in the result. Normally you would use the "put" operator here; but abnormally I recommend + and ^ for psychedelic effects. picture onto which another picture will be superimposed. if enabled, inlet 1 picture will be repeated to cover the inlet 0 picture. if enabled, inlet 1 picture will be combined with inlet 0 picture using the selected operator, and then blended with inlet 0 picture according to transparency of the inlet 1 picture, and then inserted in the result. if disabled, the blending doesn't occur, as the transparency level is considered to be "opaque". note that with alpha enabled, the last channel of inlet 1 picture is considered to represent transparency. picture that will be superimposed onto another picture. position of the inlet 0 picture corresponding to top-left corner of inlet 1 picture. resulting picture. Normally you would use the "put" operator here; but abnormally I recommend + and ^ for psychedelic effects. picture on which the polygon will be superimposed. color of each pixel vertices of the polygon. modified picture. note: starting with 0.7.2, drawing a 1-by-1 square really generates a 1-by-1 square, and so on. This is because the right-hand border of a polygon is excluded, whereas it was included before, leading to slightly-wider-than-expected polygons.

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.

Transforms linear counting (0, 1, 2, 3, 4, ...) into a back-and-forth counting (0, 1, 2, 1, 0, ...) from 0 to a specified upper bound. a value to be transformed. If, for example, top=10, then values 0 thru 10 are left unchanged, values 11 thru 19 are mapped to 9 thru 1 respectively, and 20 thru 30 are mapped to 0 thru 10, and so on. which clock to use. "real" uses wallclock time. "user" uses the amount of time spent in the process. "system" uses the amount of time spent in the kernel on behalf of the process. "cpu" uses the Pentium clock, which is like a more precise version of "real" if you have a Pentium. optional Times at which bangs are received are stored until a large enough sample of those is accumulated. Large enough is defined to be whenever the timespan exceeds one second. Then a report is made through the outlet. messages other than bangs are ignored. non-detailed mode only. this is the messages-per-second rating. detailed mode only. this is: messages-per-second, followed by five values of milliseconds-per-message: minimum, median, maximum, average, standard deviation. (the average happens to be simply 1000 divided by the messages-per-second, but it is convenient to have it anyway)

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.

Outputs the time and date in ASCII format Outputs the Unix timestamp in seconds Outputs the fractions of a second up to 10 microseconds (?) (actual precision is platform-dependent afaik)

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

Outputs the HPGL commands in ASCII format

those classes emulate jMax functionality, for use within PureData.

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.

Outputs N messages, one per list element, in order. outputs the number of elements in the incoming list. Outputs one element of the list, as selected by "index". Also accepts negative indices (e.g.: -1 means "last"), unlike jMax. Outputs consecutive elements of the list, as selected by "index" and "length". Also accepts negative indices (e.g.: -1 means "last"), but unlike jMax. Outputs the stored list followed by the incoming list, all in one message. Outputs the incoming list followed by the stored list, all in one message. Outputs the incoming list, from last element to first element. Like [spigot], but turns itself off after each message, so you have to turn it on again to making it pass another message. outputs b-a outputs b/a (This is not in jMax, but is there to help port $* messageboxes) Like [listprepend], but operates on whole messages, that is, including the selector. (This is not in jMax, but is there to help port $* messageboxes) Like [listappend], but operates on whole messages, that is, including the selector. Compatible with jMax's [demux]. number of outlets initial selected outlet Routes a message to the active outlet. Selects which outlet is active. please use shunt instead (name conflict with another Pd external) a value to be sent to one of the outlets. The first outlet is for values smaller than the first argument; else the second outlet is for values smaller than the second argument; and so on; and the last outlet is for values greater or equal to the last argument. sets the corresponding separator in the separator list.