image processing
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
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.
Notes:
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
image(id)pixel(np)sin(s)
Fills the image id with a curve.
Options:
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
image(id)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.
Options:
normal: r,xr,yr, v,xv,yv, b,xb,yb in [0,1];
image(id)dim(nx,ny)col(r,g,b)
Builds image(id) size (nx,ny) and color (r,g,b).
Generation
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.
image
image(id)
Build the black image id dimensioned 128 by 128.
Options:
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).
Examples:
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);
n=25;c1=.01;c2=.03;c3=.05;dc1=.05/n;dc2=.075/n;dc3=.02/n;
image(1)sin(c1,c2,c3,dc1,dc2,dc3)dim(256,256,50);
screen;displ image(1)bitamp wait(1/25);
image(id1,id2)
Copies image id1 in image id2.
Options:
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.
transp(t1,t2): medallion.
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).
Notes:
usefull to insert a part of an image in another.
Example:
display image(1)poi(200,100);
if((m=mouse(0)poi(2))!=NIL)
image(1,2)win(m)poi(200,100);
When clicking a frame in image 1 this window whille be copied in image 2.
image(id1,id2)adjust
Copies image id1 in the center of image id2.
Options:
dim(nx,ny): size of image id2 (screen size by default).
poi(x,y): at point (x,y) of image id2.
image(id1,id2)inclu(x,y)
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:
image(id1,id2,...)image(id0)bitmap
image(id)sin(...)dim(nx,ny,nz)...
may be read by:
read image bitmap
written by:
write image(id)name("nnn.ima")
and can been concatened by:
interpol(ni)image(id1)image(id2);
Use:
3D texture.
interactive animation in real time.
image(id1,id2)bitmap(num)
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.
Options:
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,...)image(id0)
if images idi are 3d images the same
secx and secy, image id0
is built as the concatenation of images idi.
image(id)bitmap(num)col(r,g,b)
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.
Options:
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.
Processing
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
image(id1,id2)center(x1,y1)radius(rx,ry)
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.
Options:
: 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.
Examples:
image(1,2)center(.5,.5)radius(.5)law(0,0,0,1,0,0)normal;
circular net medal
image(1,2) center(.25,.25,.75,.75)radius(.5)normal;
ellipsoïdal fuzzy medal
image(1,2)center(.5,.5)radius(.5)law(0,0,0,.5,1,0,1,0,0)normal;
crown medal
image(id1,id2)transp
transp col
transp format
transp luminance
image(id1,id2)transp(t)col(r,v,b)
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).
Options:
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).
Examples:
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.
image(id1,id2)format(f)col(c1,c2)transp(t1,t2)
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);
image(1,2)format("B")col(c1,c2)transp(t1,t1);
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).
Options:
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.
Examples:
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.
Note
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
image(id)dim(nx,ny)
Build black image id dimesnsion (nx,ny).
Options:
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).
image(id1,id2)dim(nx,ny)
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).
Options:
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.
Examples:
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
image(id)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).
Extension
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
image(id)format("f")
Returns the pixels list of image id according to format "f".
Note:
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.
image(id)format("f")=p
Builds image id with pixels p according to format "f".
Options:
dim(nx,ny): nx columnss and ny lignes, requires:
dim(p) = nx * ny * dimf, with dimf = number of bytes coding.
image(id)format("f")=p
Loading buffer pixel p in image id according to
format "f".
image(id1,id2)format("f")[var]
Loading image id1 in image id2 according to
format "f".
Options:
var: returns image.
Exemple: image(1,1)format("L"); transforms the image 1 into luminance image.
Format
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
image(id)back(rf,vf,bf)col(rc,vc,bc)error(er)
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.
Note
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.
Options:
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).
DEVELOPING
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
image image add
image(id1,id2,...)image(id0)add
Builds image(id0) = average images(idi).
Options:
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
image(id1)bitmap(b1,b2,...)image(id0)add
Builds image(id0) = average bitmap(bi)image(id1).
Options:
add(c1,c2,...): image(id0) = sum(ci * bitmap(bi)).
limit: avoids color overflow.
normal: normalizes the coefficients ci.
image image average
image(id1,id2,...,idn)image(id0)average(c1,c2,...,cn
id0=sum(idi*ci)/sum(ci) as barycenter of images idi with coefficients ci.
Example:
image(1,2)image(3)avarage(.5,.5); image(3) = average of images 1 and 2.
image(id1,id2,...,idn)image(id0)bitmap
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).
image(id1)image(id2)coe(c)
Performs thresholding: id2 = (id1<c) ? 0 : 1.
image(id1)image(id2)coe(c1,c2)
Do id2 = abs(c1*(luminance(id1) + c2*(luminance(id2))). For c1=1 et c2=-1
realizes an extraction of the contour.
image(id1)image(id2)col("c")
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).
Options:
col(r,g,b): multiplying the colors of image id1(r,g,b).
dim(nx,ny): resizing.
limit: evoides color overflow.
image(id1)image(id2)col(r,g,b)
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.
Options:
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.
Options:
image(a1,...,an)image(b1,...,bn)for n images.
number(num): number of the grid (-12344 by default).
Note:
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)).
Options:
limit: evoides color overflow.
normal: normalizes the ci.
image(id1)image(id2)luminance
Does image(id2) = luminance image(id1).
Options:
dim(nx,ny): resizing.
image(id1,id2,...,idn)image(id0)secx(nx)secy(ny)
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
image(id1)image(id2)smooth(np)
Smoothes image id1 in image id2 on a matrix np * np (np odd default 3).
image(id1)image(id2)smooth(mat)
Smooth image id1 in image id2 on the matrix mat (odd dimension).
Options:
normal: normalizes matrix mat.
Note: The two images must have the same dimensions, if id2 does not exist is created.
image incrustation
image(id1,id2)transp(1)luminance(lum1)luminance(lum2);
displ image(id1,id2);
image line
image line(L)
Changes the current image to transparent pixels outside the 3D line L.
Options:
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).
Notes:
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.
image(id1,id2)line(L)
Copies image id1 in image id2, the pixels outside the 3D line being transparent.
Options:
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).
Notes:
1) error if NP(Ligne) < 3.
2) Requires id1 != id2.
image(id1)line(L)brush(id2)poi(x,y)
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.
Options:
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).
Options:
precision(p): image is reduced by p (entre 0 et 1).
normal: box is normalized (between 0,0 and 1,1).
image rand
image(id)rand
Builds image id dim(128,128) and random colors.
Options:
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.
DEVELOPING
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
image(id)average(n)
Builds n block internal of image id.
If n=0 removes this property.
image(id)average
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.
image(id1,id2)average
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.
image(id1,id2,id3)average(a1,a2)
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.
Notes:
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
image(id)pixel(x1,y1,x2,y2)format("f")=r,g,b,a
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
image(id1,id2)precision(p)format("f")
Thresholds image id1 in the image id2 according to the format "f".
Examples:
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;
Options:
inv(1): thresholding is reversed.
image product
image(id1,id2,id3)product(p)
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.
Options:
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.
Note
does: col image(id)*=r,g,b
Options:
=r,g,b,1 colors limited.
image video
image(id1,id2)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
image(id1,id2)speed
Initializes the pixels of the image id2 to the values of speed
of the image id1..
Options:
speed(c): multiplying the speed byc (1 default).
image luminance
image(id)luminance
returns (lum,x,y) with:
lum = average luminance, x,y = pixel centroid coefficient luminance.
Options:
normal: lum,x,y in [0,1];
image(id)luminance(x1,x2,...,xn)
Builds image(id) luminance(x1,x2,...,xn) and size sqrt(n);
Options:
dim(nx,ny): size (nx,ny), must nx * ny = n.
texture
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.
Note:
: 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).
image(id1)vol(id2)dila(cx,cy,cz)tran(x,y,z)
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.
image(id1)vol(id2)force(fx,fy,fz)
Performs an extrusion of volume id2 by seting forces k * (fx, fy, fz) to the vertices
with k = luminance (pixel).
image(id1)vol(id2)coe(c)col
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: