image processing

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

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

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 saved on the disk (useful for example for an delayed animation).
        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] ([0,0,0] X [1,1,1] by default).
center(x,y) center(x,y) (0.5,0.5 by default).
coe(c): nx *= c, ny *= c.
col(r,v,b): (r,v,b) color.
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(nx,nby,nz): dimension (128,128,1 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.
image(id)interpol col: builds 3D image id size (256,256,25) interpolated betwee blcka and white.
image(id)interpol dim(nx,ny,nz)col(r1,g1,b1,r2,g2,b2): builds 3D image id size (nx,ny,nz) interpolated betwee (r1,g1,b1) and (r2,g2,b2).
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] ([0,0,0] X [1,1,1] by default).
screen(r,g,b): color (r,g,b) (black default).
sin(s1,s2,s3): sinusoidal variation (.01,.01,.01 by default).
sphere(r,dr): for a 3D image fills the buffer with a r1,g1,b1,r2,g2,b2 color sphere radius r (default .25) and dr patterns (default 1). (default (dimx+dimy)/4).
tran(p1,p2,p3): phases variations (.01,.01,.01 by default).
var(t1,t2,t3): time variations (.001,.001,.001 by default).
with options din(nx,ny,nz>1) builds an interpolated 3D image bitmaps.
validate(v): validate image(id)=v (0 default).

screen;for(i=0,.2,.01){image(1)sin(i,i,i);displ image(1);wait(1/25);}

image(1)sin rand dim(256,256,50);screen;displ image(1)bitamp period(1/25);

screen;displ image(1)bitamp wait(1/25);


        Copies image id1 in image id2.
abs: without resizing (if image(id2) already exists with different size).
acc: Copies acceleration of image id1 in image id2.
center(x,y): a href="#center">medallion.
coe(c): resizing coefficient.
col(r,g,b): (r,g,b) * color.
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.


Copies image id1 in the center of image id2.
dim(nx,ny): size of image id2 (screen size by default).
poi(x,y): at point (x,y) of image id2.


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:
may be read by:
read image bitmap
written by:
write image(id)name("nnn.ima")
and can been concatened by:
3D texture.
interactive animation in real time.


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 and returns secz 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.


if images idi are 3d images the same secx and secy, image id0 is built as the concatenation of images idi.


fills bitmap number num with color (r,g,b).

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          alea          average
back          bitmap          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)          image image bitmap
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 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)normal;
        ellipso´dal fuzzy medal
        crown medal


transp col
transp format
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(0,0,0)col(.5,.5,.5); extracts the color pixels clear.
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.

sets transparency of pixels whose component c is between c1 and c2:
t1 + (c - c1) * (t2 - t1) / (c2 - c1).
f="R": red
f="G": green

f="B": blue
Allows remove pixels of particular color.
Example: read image(1)name("A0589.bmp")coe(.5);
screen;displ image(1)poi(0,.1)normal;displ image(2)poi(.5,.1)normal;

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.


To save an image with transparency use ima or tga extension.

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 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 described in format
bmp: non compressed Windows' bitmap.
flo: anyflo format:
       xxxxxx yyyyyy c \n: width, height and code (0: non compressed, 1: compressed)
       rgba, rgba, ...: pixels RGBA
jpg: JPEG.
tga: TGA.
ima: 3D image (secz=bitmaps' number).

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 genetic

image genetic(id)

Returns the property image of genetic id

image genetic(id)=idi

Changes this property.
property pixel is a randomly generated pixels size of image idi.
property pixel dup is a copy of pixels of image idi.
When genetic id is generated those pixels are closest of pixel dup according of notes of particles of that genetic id.

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

bitmap interpol
dim texture
secx secy

image image add


Builds image(id0) = average images(idi).
add(c1,c2,...): image(id0) = sum(ci * image(idi)).
dim(nx,ny): for images not the same sizes, forces the sizes to (nx,ny).
limit: avoids color overflow.
normal: normalizes the coefficients ci.

image image bitmap add


Builds image(id0) = average bitmap(bi)image(id1).
add(c1,c2,...): image(id0) = sum(ci * bitmap(bi)).
limit: avoids color overflow.
normal: normalizes the coefficients ci.

image image average


id0=sum(idi*ci)/sum(ci) as barycenter of images idi with coefficients ci.
image(1,2)image(3)avarage(.5,.5); image(3) = average of images 1 and 2.


        Performs an animation of images idi in the n bitmaps of image id0.

image(id1,id2)image(id0)bitmap interpol(ni)

        Performs an animation interpolating images idi and id2 with ni steps writing the results in bitmaps of image id0 (images id1 and id2 must be the same size).


        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).
col(r,g,b): multiplying the colors of image id1(r,g,b).
dim(nx,ny): resizing.
limit: evoides color overflow.


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

image(id1)image(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);

image(a)image(b)dim texture(d)

builds grid -12344 size d texture a.
When this grid is displayed image b is generated around it, then the grid becomes invisible.
image(a1,...,an)image(b1,...,bn)for n images.
number(num): number of the grid (-12344 by default).
Allows build texture of any size.
yes illum and yes texture must be active.
Works only in interaction mode.
bloc texture generate vol(num)=n1,n0 is built.

image(id1,id2,...)image(id0)interpol coe(c1,c2,...)

Does image(id0)=sum(ci*image(idi)).
limit: evoides color overflow.
normal: normalizes the ci.


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 rand


Builds image id dim(128,128) and random colors.
dim(nx,ny>: size nx,ny (128,128 by defalut).
coe(c): base image size c*(nx,ny).
col(r1,g1,b1,r2,g2,b2) random colors between r1,g1,b1 and r2,g2,b2.


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 vertex

image vertex vol(id)

Returns property image vertex of volume id.

image vertex vol(id)=id1

Changes this property.
Note: image id1 is displayed at each vertex of volume id.
vertex(num): for this vertex

image vertex col vol(id)

Returns property image vertex col vol id.

image vertex col vol(id)=r,g,b

Changes this property.
does: col image(id)*=r,g,b
=r,g,b,1 colors limited.

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(x1,x2,...,xn) and size sqrt(n);
dim(nx,ny): size (nx,ny), must nx * ny = n.


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

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        read write image        rectangle image        rem image        rotx image        roty image        rotz image
screen image        secx image        secy image        segment image        sphere image        stock image        symx image        symy image
traj image        tran image        transp image
write image
yes image