image processing

image in memory
static image
dynamic image
D2 image
3D image

brush        bitmap
col        coordinates
image        inclu
See also

Image in memory

       By default anyflo has an image memory of a given size by the option win processed by the functions of OpenGL.
        It is possible to define memory image of any size and unlimited. These memories can be processed in real time or soft (allowing much more programmable graphics effects).
        They can be viewed and / or parked on the disk (useful for example for an animation delayed).
        They can be animated using trajectories or dynamic.

Static image

        By default an given image id is static.

Dynamic image

        Like any object of anyflo an image can be made dynamic by:
dynamic image(id)=1
mass image(id)=m
yes dynamic

color dynamic
generate image time
dynamic pixel

Color dynamic

That is one of the commands:
dynamic image(id)=1 or
generate dynamic image(id)
3 buffers floats im (t), im (t-1), and vit storing the image at time t (current), t-1, and speeds of pixels, are automatically maintained and used for the calculations of the dynamic.
Some commands allow you to control parameters variations:
generate speed image(id)
limit acc image
limit col image
limit speed image
See an example in sub menu IMA() of file demo1_dynamic.func.
A brush dynamic can be associated to an dynamic image to build a dynamic palette.

Dynamic pixel

generate pixel image(id)
        generates a buffer of pixels (float positions).
mass image(id)=m
        sets a mass.
yes dynamic
        activates the dynamic.
Therefore the pixels are dynamically displaced according to the parameters.
More options:
CG(n): the center of gravity of the n*n sub images are considered as center of fields attracting the pixels.
generate force pixel image(id)
        generates a buffer of forces.
generate speed pixel image(id)
        generates a buffer of speedes.
mass image(id)=m
        assignes a amsse.
field image(id)=id2
        sets a field id2.
To change the center of field id2:
        meta field poi image(id)=x,y;
To change the coefficient of field id2:
        meta field coe image(id)=c;
spring image(id)=stiffness,viscosity         sets springs on every pixel.
yes dynamic


Fills the image id with a curve.
dim(dx,dy): size (128,128 par défaut).
pixel(np): number of pixels (dimx*dimy par défaut).
screen(r,v,b): first erases the image with color (r,v,b).

image col


returns (r,xr,yr, g,xg,yg, b,xb,yb) with:
       r = average red, xr,yr = pixel centroid coefficient red.
       g = average green, xg,yg = pixel centroid coefficient green.
       b = average blue, xb,yb = pixel centroid coefficient blue.
normal: r,xr,yr, v,xv,yv, b,xb,yb in [0,1];


Builds image(id) size (nx,ny) and color (r,g,b).


       Image command lets you define a memory monochrome image of any size.
        The generate image command allows to copy a picture window of the image displayed in an image memory.
        The read image command is used to load image file in an image memory.
        Image processing commands allow manipulated images.




        Build the black image id dimensioned 128 by 128.

alea(r1,g1,b1,r2,g2,b2): reproductible random colors in interval [r1,g1,b1] X [r2,g2,b2].
cube(x,y,z): for a 3D image fills the buffer with a r,g,b colored cube dimensions x,y,z (default dimx/2+dimy/2,dimz/2).
dim(dimx,dimy): dimensioned (dimx,dimy) (128,128 default).
dim(dimx,dimy,dimz): 3D image.
image(id1,id2)col: only rgba information.
image(id)ini: restitue l´image id depuis sa copie originale.
limit: avoides colour overflow.
luminance(lum): luminance.
rand(r1,g1,b1,r2,g2,b2): no reproductible random colors in interval [r1,g1,b1] X [r2,g2,b2].
screen(r,g,b): color (r,g,b) (black default).
sin(omega,phi,dt): varies the curve.
sphere(x,y,z,r): for a 3D image fills the buffer with a r1,g1,b1,r2,g2,b2 color sphere center x,y,z (default dimx/2,dimy/2,dimz/2) radius r (default (dimx+dimy)/4).


        Copies image id1 in image id2.
abs: without resising (if image(id2) already exists with different size).
acc: Copies acceleration of image id1 in image id2.
center(x,y): a href="#center">medallion.
col(r,g,b): color (r,g,b).
debug(c)debug(g): creates cube c (bitmapes of 3D image id1) and grid g (plan xy) which can be viewed (by interaction and right clic rotxy(eye) or rotxz(eye) or tran(eye)) (default c=-1 g=-2).
dim(nx,ny,nz): resazing image id2.
luminance: image(id2)=luminance(image(id1)).
matrix(m): if id1 in a
3D image, the image id2 will be the intersection of image id1 with the transform by matrix m of plan(x,y).
normal: coordinates are normalized (between 0.0 and 1.0).
poi(x0,y0): assuming that image id1 is displayed at (x0,y0), the absolute coordinates are transformed in image coordinates.
radius(rx,ry): a href="#radius">medallon.
rota(an)axis(as,ay,az): rotates plan xy of angle an around axis (ax,ay,az).
speed: Copies speed of image id1 in image id2.
transf(p): transformes the plan xy by transformation transf with parameters p.
Examples: rotx(an, dila(x,y,z), dilx(x), ...
with any arrangement of transformations.
win(x1,y1,x2,y2) copies window (x1,y1,x2,y2) of image id1 in image id2.
Note: image(0,id) stores the current image in image id (only in interaction mode).
win(x1,y1,x2,y2,x3,y3,x4,y4)dim(dx2,dy2): copies polygon (x1,y1,x2,y2,x3,y3,x4,y4) of image id1 in image id2 dimensioned (dx2,dy2).
usefull to insert a part of an image in another.
display image(1)poi(200,100);

When clicking a frame in image 1 this window whille be copied in image 2.


writes image id1 at point (x,y) of image id2.

2D image

By default an image is a two dimensional bufer of RGBA pixels.

3D image

An image of size nx,ny may be a 3D image by adding nz RGBA pixels buffers the same size.
Such an image may be generated by read image with option:
       name("name1 name2 ...")


If image id1 is a 3D image of sizes dx,dy,dz image id2 is build with the buffer num (0 <= num < dz) of image id1.
dim(dimx,dimy): resizing image id2 to (dimx,dimy).
inv: the layer number num of image id1 is a copy of image id2.

image(id1,id2)bitmap poi(p1,p2,p3,p4)

Image id2 is build with the intersection of polygon (p1,p2,p3,p4 with the image id1 (where pi=xi,yi,zi).

image(id1,id2)bitmap rotx(an)

Image id2 is build with the intersection of bitmap 0 rotated by an about x axis with the image id1.

image(id1,id2)bitmap roty(an)

Image id2 is build with the intersection of bitmap 0 rotated by an about y axis with the image id1.

image(id1,id2)bitmap rotz(an)

Image id2 is build with the intersection of bitmap 0 rotated by an about z axis with the image id1.
tran(x,y,z): the resulting image ie translated by (x,y,z).

image coordinates

(0,0) is the lower left corner.
(DX-1,DY-1) is the upperer right corner (where DX,DY are the screen size given by dim screen.


adhere          add          alea          average
back          brush
center          CG          coe          contour          cut
device          dim          disk          dynamic
format          frame
generate image interpol          generate image time          graphic
image image          incrustation          image(id1,id2)
line          limit
pixel          precision          product
radius          read          rectangle
screen          segment          speed
video          vol

image adhere

image(id1,id2) adhere col(r1,g1,b1)col(r2,g2,b2)

        Replaces pixels of image id2 whose color is between (r1,g1,b1) and (r2,g2,b2) by corresponding pixels of image id1.

image(id1,id2) adhere luminance(c1)luminance(c2)

        Replaces pixels of image id2 whose lumunance is between c1 et c2 by corresponding pixels of image id1.

image add

image(id1,id2,id3) add(v1,v2)

        Do id3 = v1 * id1 + v2 * id2.
By default v1=v2=1.
If id3 is absent, id3=id2.
Both images id1 and id2 must have the same dimensions.

image(id1,id2,id3) add(v1,v2)limit

        Do id3 = v1 * id1 + v2 * id2 with colors (between 0 et 1).

image(id1,id2) add(r,g,b)

        Do id =id1 + (r,g,b).
limit: avoids color overflow.

image alea

image(id)dim(dx,dy)alea col(r1,v1,b1,r2,v2,b2)

        Build image id dimensioned (dx,dy) and random color between (r1,v1,b1) and (r2,v2,b2).

image center radius transp

center        col        luminance


        Writes elliptic disk (x1,y1,rx,ry) of image id1 on disk (x1,y1,rx,ry) of image id2, the default is the center of the image.

: on disk (x2,y2,rx,ry) of image id2 (default x2=x1 et y2=y1).
law(t1,x1,t1,x2,0,...): allows to control the transparency variation according to a law.
normal: values are normalized between 0 and 1.
radius(rx,ry): default rx=ry=0.5
transp(t1,t2): varying transparency from t1 to t2.

       circular net medal
image(1,2) center(.25,.25,.75,.75) radius(.5);
        ellipso´dal fuzzy medal
image(1,2) radius(.5) law(0,0,0,.5,1,0,1,0,0);
        crown medal


transp col
transp luminance

        Copies image id1 in image id2 by assigning the transparency t to pixels whose color is (r, g, b) (t = 0 opaque, t = 1 transparent).
dim(nx,ny): resizes the image (nx,ny).
col(r1,g1,b1)col(r2,g2,b2): for pixels whose color is between (r1,g1,b1) and (r2,g2,b2).
col(-1): automatically compute r1,v1,b1=image(id)average col and r2=v2=b2=1.
poi(x,y): center of rotation (x et y normalized between 0.0 and 1.0, 0.5 default).
rotz(an): rotates the image of the angle an around the point (x,y).
transp(t1)transp(t2): transparency of pixels whose color is betwen (r1,g1,b1) and (r2,g2,b2) is set to t1, transparency of others pixels is t2 (0 default).
transp(t1)transp(t2)transp(t3)tranps(t4): transparency varying from t3 at center to t4 on edge (0 default).
image(1,2)transp(0)transp(1)col(.25,.5,.25)col(1,1,1); extracts the color pixels hot.
image(1,2)transp(1)transp(0)col(.25,.5,.25)col(1,1,1); extracts the color pixels cold. image(id1,id2) transp(t)luminance(lum)
        Copies image id1 in image id2 assigning transparency t to pixel whose luminance is lum (t=0 opaque, 1 transparent).
luminance(lum1,lum2): for pixels whose luminance is between lum1 and lum2.
lum(-1): automatically compute lum1=image(id)average luminance and lum2=1.
transp(t1)transp(t2): for pixels whose transparency is between t1 and t2.
image(1,2)transp(0)transp(1)luminance(.5,1); extracts the bright pixels.
image(1,2)transp(1)transp(0)luminance(.5,1); extract the dark pixels.

image cut dim

image(id1,id2)cut dim(x1,y1,x2,y2)

        Copies window (x1,y1,x2,y2) of image id1in image id2.
Requires: 0 <= x1 < dx1, 0 <= y1 < dy1, 0 <= x2 < dx1, 0 <= y2 < dy1

image cut coe

image(id1,id2)cut coe(cx1,cy1,cx2,cy2)
        Copies window (cx1*dx1,cy1*dy1,cx2*dx2,cy2*y2) of image id1 in image id2.
Requires: 0 <= c[xy][12] <= 1

image dim


        Build black image id dimesnsion (nx,ny).
col(r,g,b): pixels color (r,g,b).
col(r1,g1,b1,r2,g2,b2): pixels random color between (r1,g1,b1) and (r2,g2,b2).


        Applies imageid1 on image id2 dimensioned (dx,dy).
If image id2 already exists, it is possibly resized (dx, dy).
If id2 is greater than id1, it is smoothed by default (unless (0) is present).
format("f"): specifies the format.
inv(1): inverses the luminances.
normal: nx = nx * dimx(id1) ny = ny * dimx(id1)
precision(p): the image is thresholded with respect to p.
image(1,2)dim(200); copies image 1 in image 2 dimensioned 200*200.
image(1,1)dim(300,200); resizes the image to 300*200.

image screen


        Clears the image id with the background color.
Options: screen(r,g,b): with color (r,g,b). screen(r,g,b,a): with transparency a (0 default).


The extension eee of image file name.eee can be
bmp: uncompressed Windows bitmap.
flo: anyflo format:
       xxxxxx yyyyyy c\n: width, height and code (0: uncompresed, 1: compressed)
       rgba, rgba, ...: RGBA pixels
jpg: compressed format JPEG.
tga: compressed format TGA.

image format


       Returns the pixels list of image id according to format "f".
For large images result may go beyond the stack size and give an error. Use image(id)pixel(x1,y1,x2,y2) to extract a window.


       Builds image id with pixels p according to format "f".
dim(nx,ny): nx columnss and ny lignes, requires: dim(p) = nx * ny * dimf, with dimf = number of bytes coding.


       Loading buffer pixel p in image id according to format "f".


       Loading image id1 in image id2 according to format "f".
var: returns image.
Exemple: image(1,1)format("L"); transforms the image 1 into luminance image.


       f=L: luminance.
       f=R: red.
       f=G: green.
       f=B: blue.
       f=A: alpha.
       f=LA: luminance,alpha.
       f=RGB: red,green,blue.
       f=RGBA: red,green,blue,alpha (default).

image back


The color k of image id is amended by:
if((er = k - kc) < 0) then er = 0.0;
if (er > error) then k = kf;

By default kf = background color, kc = current color courante and er=0.0.

image generate

generate_format        generate_speed

image(id)generate format("A")

        Generates the alpha layer of image id:
alpha = 0 if black pixel.
alpha = 1 if pixel color is other.
image(id)generate format("A")col(r,v,b)
        Generates the alpha layer of image id:
alpha = 0 if pixel color is (r,v,b).
alpha = 1 if pixel color is other.
image(id)generate format("A")col(r1,v1,b1,r2,v2,b2)
        Generates the alpha layer of image id:
alpha = 0 if pixel color is between (r1,v1,b1) and (r2,v2,b2).
alpha = 1 if pixel color is outside.

image graphic

Returns pixels of a window.
dim(dx,dy): dimensions (15,15 default).
image(id): returns result in image id (possibly built or modified).
format("fff"): according to format.
poi(x,y): bottom left corner (0,0 default).

image haute definition

Launche anyflowith option:
        anyflo hau=2
image in memory is 4 times video size. write image processes the image at video size.
It will be necessary to build databases depending on the size of the memory image. For example:
d=dim screen;D=.1*d[0]:Provides a basis independent of image.
You can specify the image size anti-aliased (dimx,dimy) and the antialiasing factor k:
        anyflo x=dimx y=dimy gra=0 mem=1 hau=k

image image

secx secy


        Performs thresholding: id2 = (id1<c) ? 0 : 1.


        Do id2 = abs(c1*(luminance(id1) + c2*(luminance(id2))). For c1=1 et c2=-1 realizes an extraction of the contour.


c = R, r: does image(id2) = red component of image(id1).
c = G, g, V, v: does image(id2) = green component of image(id1).
c = B, b: does image(id2) = blue component of image(id1).
dim(nx,ny): resizing.


does image(id2) = r * (red component) + g * (green component) b * (blue component) of image(id1).

image(id1,id2)contour smooth(smo) precision(prec)coe(c1,c2)

        Extract the contours of the image id1 in the image id2 by subtracting the luminance of image id1 and image id1 smoothed order smo and then thresholding the result in relation to previous id2 in relation to prec, by default: smo=3 prec=0.05, c1=1, c2=-1.
Both images must have the same dimensions (id2 is created by default) and smo > 1.
contour("R"):: red component.
contour("G"):: green component.
contour("B"):: blue component.
contour(r,g,b):: r * red, g * green, b * blue.
Example: image(1,2)contour(.6,.3,.1)smooth(3) precision(.5)coe(1,2);


Does image(id2) = luminance image(id1).
dim(nx,ny): resizing.


Concatenates images idi in the image id0 with nx images online and ny images column, must be exactly n=nx*ny images of the same dimensions.
This command allows to generate a high resolution image from sub-images.

image smooth


Smoothes image id1 in image id2 on a matrix np * np (np odd default 3).


Smooth image id1 in image id2 on the matrix mat (odd dimension).
normal: normalizes matrix mat.
Note: The two images must have the same dimensions, if id2 does not exist is created.

image incrustation

displ image(id1,id2);

image line

image line(L)

        Changes the current image to transparent pixels outside the 3D line L.
adjust: change the size to visible pixels only.
format(n): specifies the dimension of vectors (3 default).
inv: making transparent the pixels inside the 3D line L.
poi(x1,y1): lower left corner coordinates of image id1.
tran(xt,yt): the image id2 will be translated of (xt,yt).
1) Requires, in interaction mode, to do no screen so that the current image is not cleared.
2) The image can be saved in memory by generate image, displayed by displ image, and saved on the disk by write image name("nnn.eee").
Options abs and inv are incompatible.


       Copies image id1 in image id2, the pixels outside the 3D line being transparent.
abs: image id2 is cropped around the line L.
adjust: change the size to visible pixels only.
tran(dx,dy): displaced (dx,dy) in image id2(0,0 default).
poi(x,y): coordinates of bottom left corner of image (0,0 default).
1) error if NP(Ligne) < 3.
2) Requires id1 != id2.


        If the brush id2 is of type image this command builds the imag of the brush by extracting, in the imageid displayed at (x, y), the 3D window framing line L, the interior pixels in the line being transparent.
inv: extracting exterior pixels.

image limit

image(id)limit col(r1,v1,b1,r2,v2,b2)

        Returns the box (x1, y1, x2, y2) defining the image idwhose pixels havecolorbetween (r1,g1,b1) and (r2, v2, b2) (0,0,0,1,1,1 default).

image(n)limit luminance(lum1,lum2)

        Returns the box (x1, y1, x2, y2) defining the image idwhose pixels have luminance between lum1 and lum2 (0,1 default).
precision(p): image is reduced by p (entre 0 et 1).
normal: box is normalized (between 0,0 and 1,1).


image read

image read number write number ext format

image read("A")number(i1,i2)write("B")ext("jpg")format("y")
        Generates images B[i2,i2+dimy-1] obtained by scanning the animation A[i1,i1+dimy-1] according to y.

image device(id)dim(dx,dy)=p

        loads the image device(id) with p dimensions dx = dy = sqrt (dim (p) / 4). p must contain np = dx * dy quadruplets (r, g, b, a) normalized between 0.0 and 1.0.
Options: dim(dx,dy): requires dim(p)=4*dx*dy.

image average

average col
average luminance
average transp


        Builds n block internal of image id.
If n=0 removes this property.


        Replaces cyclically one of the n internal images of the image by the image id and recalculates it as average of them.
Remarque: smoothes the image changes.


        Replaces cyclically one of the n internal images of the image id1 by the image id1 and recalculates it as average of them in the image id2.


        Computes image(id3) = a1 * image(id1) + a2 * image(id2)
a1 = a2 = 0.5 by default.

image(id)average col

        Returns the average color of image id.

image(id)average luminance

        Returns the average luminance of image id.

image(id)average transp

        Returns the average transparency of image id (0: opaque, 1: transparency).

image brush

image brush(id1)

Returns the image identifier of the image on which the brush id1 operates.

image brush(id1)=id2

Changes this identifier.
For a brush associated to a neural network, this brush takes his pixel information in image id2 instead of the screen.
if id2==0 this brush takes his pixel information from the screen (default).

image pixel


        Assigns the value (r,g,b,a) to the pixels of the window (x1, y1, x2, y2) (full image default) of the image according to the format "f, " (RGB default) with:
       r = red component, between 0.0 and 1.0.
       g = green component, between 0.0 and 1.0.
       b = blue component, between 0.0 and 1.0.
       a = transparency,between 0.0 and 1.0.

/*??? A FAIRE ???*/
image(n)pixel col(r1,v1,b1,r2,v2,b2)
        Returns the list of points (x, y, ...) of the contour defined by a color range (r1,g1,b1) and (r2,g2,b2).
image pixel col simple
        Returns the simplified outline.
image pixel col contour
        Returns the ordered contour.
image pixel dim
if dim(3) is present, the datas are 3-dimensional. Example:
image(n) pixel dim(3)=x1,y1,0,x2,y2,0,...

image precision


       Thresholds image id1 in the image id2 according to the format "f".
1) image(id1,id2)precision(p)format("L")
        For each pixel:
                if(luminance < p)luminance = 0
                if(luminance >= p)luminance = 1
2) image(id1,id2)precision(r,v,b)format("RGB")
        For each pixel:
                if(r < r1)r =0;if(v < v1)v = 0;if(b < b1)b = 0;
                if(r >= r2)r = 1;if(v >= 1)v = v2;if(b >= b2)b = 1;
inv(1): thresholding is reversed.

image product


        Do id3 = p * id1 * id2.
If id3 is absent, id3=id2.
p=1 by default.
3 images must have the same dimensions.
image(id1,id2,id3) product limit
        Avoid overflows for p > 1.

image video

        Performs a convolution from the image id1 in a video image id2 sized (768,576)

image(id1,id2)speed format("f")[var]

        Generates the absolute value of the speed of image id1 in image id2 according to the format "f".

image speed


        Initializes the pixels of the image id2 to the values of speed of the image id1..
speed(c): multiplying the speed byc (1 default).

image luminance


returns (lum,x,y) with:
       lum = average luminance, x,y = pixel centroid coefficient luminance.
normal: lum,x,y in [0,1];


Builds image(id) luminance(lum).


To assign an image i as a texture to a volume v, must be:
texture vol(v)=i
generate(2)texture image(i)

image vol(id)

image vol

image vol(id)

returns the property image of volume id.

image vol(id)=seq,d,s

change this property.
Note: if interaction image has been invoked the texture of volume id will be automatically interpolated between the images of sequence with seq=ni,im1,im2,i1,i2 and texture number+=s*d (s=1 or -1).
Pratically a sensor may be connected to d.

image vol(id)number(num)

returns the property image number of volume id.

image vol(id)number(num)=t0,seq,ni,cpt

changes this property.
: t0=start texture, seq=target sequence number, ni=number of interpolated images, cpt in [0,ni-1].
See: interaction image vol(id)number(seq)animate(ni).


        Performs an extrusion of volume id2 by dilating the vertices k * (cx, cy, cz) and moving them k * (dx, dy, dz), with k = luminance (pixel).
See an example in function func_VOL()of file demo1_image.func.


        Performs an extrusion of volume id2 by seting forces k * (fx, fy, fz) to the vertices with k = luminance (pixel).


       Realizes the extrusion by assigning to vertices of volume id2 the corresponding pixel colors of the image.
Do before:
generate col vertex vol(id2) and
illum vol(id2)=2,ref,spe,bri,transp


Default images created or played are invalides, they are hidden. In order to display them do displ image in function F4 (before volumes, so behind them) or F5 (after volumes and therefore forehead).
validate image(id)=1 transforms the image id into a displayed object, each step, before the volumes acording, to its properties.

dila image(id)=r,g,b

The color components of pixels of the image id are multiplied by (r,v,b).


The lower left corner of the image id is displayed in (x,y).


The image id is made periodic in x.


The image id is made periodic in y.


The image id is rotated id angle an around its.
poi(x,y): around point (x,y) (normalized coordinates between 0 and 1).
rotz(an1,an2): defines a vortex (interpolated rotation between an1 and an2).
All options displ image except the ini option is always enabled (ie transformations that are made from the original image).


The image id is displaced (x,y).

See also:

audio image        adjust image        alea image        alex imagelimite        aley image
CG image        col image
dila image        dim image        displ image        displ image(id)speed
edit image        exec audio image
field image        frame image
hole image
generate image        generate bitmap image(id).        generate speed image(id).
ini image        interpol image        inv image
limit image        luminance image
module image        morphing image
no image
period image        pixel image
read image        rectangle image        rem image        rotx image        roty image        rotz image
screen image        segment image        sphere image        stock image        symx image        symy image
traj image        tran image        transp image
write image
yes image