generate

acc        alea        anc        axis
ball        bitmap        box
CG        coord        col
depth        displ        dynamic
envelope        ext
field        force        frac
genetic
image        illum        intersection        inv
mass        matrix        meta
near        network        network fac        normal        normal vertex
particle        pers        pixel brush        pixel image        poi
rand        radius
segment        speed        spring        spring vertex        stock        stock audio
texture        time
vol        view
Voir aussi

generate acc

acc image

generate acc image(id)

Generates acceleration of image id.
Options:
acc(k): k*acc image(id)

generate alea

col        particle

generate alea col fac vol(id)

        Generates random, and reproducibly, the colors of facets of volume id.

generate alea(r1,g1,b1,r2,g2,b2) col fac vol(id)

        Generates random, and not reproducibly, the colors of facets of volume id in the interval (r1,g1,b1, r2,g2,b2).
See also generate rand col vertex vol(id).

generate alea col vertex vol(id)

        Generates random, and reproducibly, the colors of vertices of volume id.

generate rand(r1,v1,b1,r2,v2,b2)col vertex vol(id)

        Generates random, and no reproducibly, the colors of vertices of volume id in the interval (r1,g1,b1, r2,g2,b2).

generate alea particle(n,t) genetic(id)

        Generates n random individuals of size t of genetic id. This is reproducible random
Voir aussi generate rand particle genetic.

generate alea particle genetic(id)

        Randomly regenerates existing individuals.

generate axis

generate poi anc vol(id)

        Generates the vertices coordinates of volume id processed by its matrix.
poi(num)anc vol(id) returns the anchored points num of volume id.

generate axis

generate axis vol(id)

        Generates the local coordinate system attached to the volumeid given by the three vectors
1.0, 0.0, 0.0
0.0, 1.0, 0.0
0.0, 0.0, 1.0

generate box

generate box fac vol(id)

        Generates bounding boxes facets volume id.
Note: This generation does not take into account the matrix transformations, however, attach displ box fac vol(id) take them into account.
/*??? A VERIFIER ???*/

generate(n)box grid vol(id)

        Generates a 3D grid of n * n * n meshes including the volume and for each cell containing: box (x1, y1, z1, x2, y2, z2) (numbers inner facets)
Notes:
1) Accelerates calculations collision.
2) By default, a box of optimal size is automatically generated.
3) If n is absent o if n=0: generates the default box.

generate(n)box vertex vol(id)

        Generates a 3D grid n*n*n bounding the volume id and containing box(x1,y1,z1,x2,y2,z2)(numbers of the inside vertices)
Remarques:
1) allows accelating the collision calculus.
2) By default, a box of optimal size is automatically generated..
3) If n is absent or if n=0: generates the default box.

generate box vol(id)

        Generates the box (x1,y1,z1,x2,y2,z2) of volume id.
Remarque: This generation does not take into account the matrix transformations, however, attach displ box vol(id) take them into account.

generate box secx vol(id)

        Generates boxes (x1,y1,z1,x2,y2,z2) of x sections of volume id.

generate box secy vol(id)

        Generates boxes (x1,y1,z1,x2,y2,z2) of y sections of volume id.

generate ball

generate ball fac vol(id)

        Generates bounding ball of facets ofvolume id (center and radius).
Notee: This generation does not take into account the matrix transformations, however attach displ ball fac vol(id) take them into account.

generate ball vol(id)

        Generates bounding boxe of volume id (center and radius).
Remarque: This generation does not take into account the matrix transformations, however attach displ box vol(id) take them into account.

generate CG

generate CG fac vol(id)

        Generates the centers of gravity of facets of volume id.
Options:
anc; taking into account the matrix transformations of volume id.

generate coord

generate coord vertex vol(id)

        Generates the coordinates 2D texture of vertices of the volume id.
Notes:
1) Volume id must be isomorphic to a grid.
2) At each vertex are associated its coordinates (normalized between 0 and 1).
3) Useful for real time 2D textures.

generate col

col fac
col vertex
col vertex vol image

generate col fac vol(id)

        Generates col fac vol(id) with the color of volume id. (white default).

generate col alea(r1,v1,b1,r2,v2,b2)fac vol(id)

        Generates col fac vol(id) with random colors reproductible in the intervals [r1,r2] [v1,v2] [b1,b2] ([0,1] default).

generate col rand(r1,v1,b1,r2,v2,b2)fac vol(id)

        Generates col fac vol(id) with random no reproductible colors in the intervals [r1,r2] [v1,v2] [b1,b2] ([0,1] default).

generate col vertex vol(id)

        Generates col vertex vol(id) with color of volume id (white default).

generate col alea(r1,v1,b1,r2,v2,b2) vertex vol

        Generates col vertex vol(id) with random reproductible colorss in the intervals [r1,r2] [v1,v2] [b1,b2] ([0,1] default).

generate col rand(r1,v1,b1,r2,v2,b2) vertex vol(id)

        Generates col vertex vol(id) with random no reproductible colors in the intervals [r1,r2] [v1,v2] [b1,b2] ([0,1] default).

generate col vertex vol(id1)image(id2)

        Generates col vertex vol(id1) with color of image id2 (must be: number of vertices of volume id1 = number of pixelss of image id2).

generate depth

generate depth vol(id1,id2)

       If volume id1 is isomorphic to a grid, generate volume id2 which points are:
1) Those of volume id1.
2) and the same points displaced 100 on their normal.
Options:
depth(d): displacement d (100 default).
close(f): if f = 1 volume closed, otherwise open (default).

generate displ

generate displ vol(id)

Generates the real time informations of volume .

generate dynamic

generate dynamic image(id)

       Gives the dynamic type to image id initializing its buffers:
im(0): original image (unsigned char).
im(t): current image (at time t) (float).
im(t-1): previous image (at time t-1) (float).
vit: speed image (float).
Options:
dynamic(0): destroys the dynamic property of the image.
used by dynamic calculus.
       If the image id id already dynamic type this command initializes its speed, automatically in interaction interaction mode.

/*??? A FAIRE ???*/

generate envelope

generate envelope(L)abs number(num)

        Generates the faceted triangular volume num joining all triplets of points on the line L.

generate envelope(L) secx(nx) line(w) number(num)

        Generates the volume num, convex hull of points L=x1,y1,z1, x2,y2,z2, ..., of the axis line w and nx points per section.

generate envelope vol(id)

        Generates the edges of the apparent contour volume id.

generate envelope(ne) vol(n1,n2,...) number(num)

        generates volume num with a virtual laser beam which is output from each vertex of y sections of the volume ne and looking towards the CG of the sections.
Notes:
1) generate envelope(ne) line(L) vol(n1,n2,...) number(num); The line L defines the aim points.
2) generate envelope(ne) vol(n1,n2,...) line(L) ext(e,c,f) number(num);
Adjustments are curve.
3) generate envelope(ne) vol(n1,n2,..) secy(a1,b1,a2,b2,...) number(num);
Only facets between the secy (ai, bi) of volume ni will be processed (ai and bi normalized between 0 and 1).
4) generate envelope(ne) vol(n1,n2,...) dist(d) number(num);
Processes only facets of volume ni located at distance < d from the aim points.
5) generate envelope(ne) vol(n1,n2,...) precision(p) number(num);
Calculates the intersections with approimation p (.0001 default).

/*??? A FAIRE ???*/

generate fac

generate fac(n1) vol(id) number(n3)

       Generates volumes n3, n3 +1, ... constructed on facets n1, n1 +1, ... of volume id.
Notes:
1) If n1 is absent, all faces are generated.
2) If n3 is absent, current numbers are created.

generate frac

generate frac vol(id)

       Generates volumeid with a fractal.
Points, facets, point properties and facets properties (normales, coe, illum, col, ...) are extended.
To do whenever you change the fractal or are modified control points.
Notes:
1) The fractal can be generated automatically by attach generate frac vol(id), but it may slow considerably the computation time.
2) Extensions curves and fractals are incompatible, the fractal is prioritary.

generate field(id)

        Compute informations concerning the field id.
Note:
Requiried for a field type image when the associated image has been modified.

generate force

force vol
force vertex
force pixel

generate force(x,y,z,v)vol(id)

Initializes force vol(id)) to (x, y, z, v) (0,0,0,0 default).

generate force(x,y,z,v)vertex vol(id)

Initializes the force vertex vol(id) to (x, y, z, v) (0,0,0,0 default).

generate alea(x1,y1,z1,v1,x2,y2,z2,v2)force(x,y,z,v)vertex vol(id)

        Initializes the force vertex vol(id) to (x+dx, y+dy, z+dz, v+dv) with dx=alea(x1,x2), dy=alea(y1,y2), dz=alea(z1,z2), dv=alea(v1,v2) (reproductible random).

generate rand(x1,y1,z1,v1,x2,y2,z2,v2)force(x,y,z,v)vertex vol(id)

        Initializes the force vertex vol(id) to (x+dx, y+dy, z+dz, v+dv) with dx=random(x1,x2), dy=random(y1,y2), dz=random(z1,z2), dv=random(v1,v2) (not reproductible random).

generate force pixel image(id)

        Initializes to zero the 2D forces applied to the pixels of image id.

generate ext

generate ext vol(id)

       Generates extension of volume id containing a extension property.
Points, facets, point properties and facets properties (normales, coe, illum, col, ...) are extended.
To do whenever you change the extension or are modified control points.
Notes:
1) The extension is only generated if yes ext is active,
generate(1)ext vol(id);
does even if
generate(1)ext vol(id); is active.
2) The extension can be generated automatically by attach generate ext vol(id).
3) Extensions curves and fractals are incompatible, the fractal is prioritary.

generate genetic

generate(n) genetic(id)

       Regenerates the population genetic id by selections, crossovers and mutations in privileging the individuals best assessed by func genetic(g).
Options:
adjust(min,max,muta,k): returns and automatically adjusts the mutation muta in [min, max] (0.0001 and 0.001 by default) so as to decrease the error (see an example in file demo1_genetic.func, function func_EXPL2_GENERATE()).
       In this case meta genetic(id) returns the average notes. When muta reaches max it takes the value k*max.
error(e): with the option generate(n) out when all errors are < e.
generate(n): realizes n uccesive generations.

generate illum

illum fac
illum vertex

generate illum fac vol(id)

        Generates illum fac vol(id) with the illumination of volume id. (1,1,0,0,0 default).

generate illum alea(i1,r1,s1,b1,t1, i2,r2,s2,b2,t2)fac vol(id)

        Generates illum fac vol(id) with random illuminations reproductible in the intervals [i1,r1,s1,b1,t1, i2,r2,s2,b2,t2] ([0,1] default).

generate illum rand(i1,r1,s1,b1,t1, i2,r2,s2,b2,t2)fac vol(id)

        Generates illum fac vol(id) with random no reproductible illuminations in the intervals [i1,r1,s1,b1,t1, i2,r2,s2,b2,t2] ([0,1] default).

generate illum vertex vol(id)

        Generates illum vertex vol(id) with illumination of volume id (0,1,0,0,0 default).

generate illum alea(i1,r1,s1,b1,t1, i2,r2,s2,b2,t2) vertex vol

        Generates illum vertex vol(id) with random reproductible illuminations in the intervals [i1,r1,s1,b1,t1, i2,r2,s2,b2,t2] ([0,1] default).

generate illum rand(i1,r1,s1,b1,t1, i2,r2,s2,b2,t2) vertex vol(id)

        Generates illum vertex vol(id) with random no reproductible illuminations in the intervals [i1,r1,s1,b1,t1, i2,r2,s2,b2,t2] ([0,1] default).

generate image

automappe
bitmap
brush
dynamic
ext
field
interpol
line
mouse
texture
time
options


preliminary remark
It is always better to manipulate images in interaction mode.
Meanwhile the command displ image graphic allows do it.

generate image

        Saves the current image frame 0.
Options:
abs: in image coordinates).
dim(nx,ny): change the image size in (nx,ny) (x2-x1+1,y2-y1+1 default).
exp: changes the image sizes to powers of 2 closest nx,ny (this in order to make this image a texture).
format("f"): the image is stored according to the format "f" ("RGBA" default).
generate(1): in order to make this image a texture mapping.
image(id): saves in image id instead of 0.
normal: normalized coordinates (between 0.0 and 1.1).
win(x1,y1,x2,y2): save the window (x1,y1,x2,y2) (full screen default).
Note:
the saved image may be returned by displ image.

automappe

Voir automappe.func for recursively mapping an image on itself.

generate image(id)

Equivalent to generate image(0,id).

generate bitmap image(id)

Generates the bitmap(-1) of image id which is the copy of the original image.
displ bitmap(-1)image(id) allows display it.
Automatically generated by read image(id)name("...")

generate image brush(id)

If the brush id is type image, initializes to 0 the image of the brush dimension radius brush.
Options:
radius(dimx,dimy): redefines the brush radius and generates the image.
To designate the window with the mouse: generate image(id)mouse.

generate image(id1,id2)dim(nx2,ny2)dynamic

Generates the image id2 size (nx2, ny2) from an analysis of the dynamic variations of the image id1:
Options:
alea(a): random disturbances reproducible amplitude a normalized between 0.0 and 1.0 (default 0.01).
col: dynamic variations of color.
luminance: dynamic variations of luminance (default).
rand(r): random disturbances no reproducible amplitude a normalized between 0.0 and 1.0 (default 0.01).
speed(v): multiplying the speed by v (0.01 by default).
Note:
yes image must be active for the dynamic images to be taken into account in interaction mode.
Otherwise, interaction off, do exec dynamic for the images are modified according to their dynamic.

generate image(id)ext

       Generates image id by replacing each pixel by the average of the 4 pixels (left, hight, right and below).

generate image(id1,id2)ext

       Generates image id2 by replacing each pixel of image id1 by the average of the 4 pixels (left, hight, right and below).
Options:
dim(nx,ny): size of image id2 (same as id1 by default).
inv(cr,cg,cb,ca): if(cr) r=cr-r, if(cg) g=cg-g, if(cb) b=cb-b, if(a)a=ca-a (default: cr=cg=cb=ca=0);

generate image field(id)

       Generates the image of the field id type image, must be done if the image have been modified.


interpol read read
interpol read col
interpol read read

generate image interpol

generate image(i1,i2,...,in)interpol(ni)number(i0)
       Generates nb=n+(n-1)*(ni+1) images (i0, i0+1, ..., i0+nb-1) numbered from i0 by inserting interpolated ni images between i1 and i2, ni images between i2 and i3 , ... and returns nb.
Note:
May be used to obtain texture animation, see an example in function INTERPOL() of file demo1_texture.func.

generate image read("A.eee")number(na)read("B.eee")number(nb) interpol(ni)number(nc)

Creates images c by interpolating images files Aa.eee anb Bb.eee with a in [na,na+ni[, b in [nb,nb+ni[ and c in [nc,nc+ni[.
image center radius transp normal are available.

generate image read("A.eee")number(na)col(r,g,b)number(nb) interpol(ni)number(nc)

Creates images c by interpolating images files Aa.eee anb colour(r,g,b) with a in [na,na+ni[, and c in [nc,nc+ni[ (fade out).

generate image col(r,g,b)read("A.eee")number(na)number(nb) interpol(ni)number(nc)

Creates images c by interpolating colour (r,g,b) and images files Aa.eee with a in [na,na+ni[, and c in [nc,nc+ni[ (fade in).

generate image read("A.eee")number(na)read("B.eee")number(nb) interpol(ni)write("C.eee")num¨ber(nc)

Writes image files Cc.eee instead of generating images c.
Options:
number(n,dn): dn = increment of the image number (1 default).

generate image line(x1,y1,z1,r1,v1,b1,x2,...)

        Calculates the pixel colors of the image by the formula:
(r,v,b) = (SIGMA dist(pixel,xi,yi,zi) * (ri,vi,bi)) / (SIGMA dist)

generate image line(x1,y1,z1,r1,v1,b1,x2,...) texture(a1,f1,a2,f2,...)

        Calculates the pixel colors of the image by the formula of color centers texture.

generate image mouse

generate image(id)mouse
        Click 2 points.
Options:
coe(c): frame(d,coe*d).
limit(x1,y1,x2,y2): input is limite to window (x1,y1,x2,y2) displayed green.
exp: adjusting the sizes to powers of 2.

generate image(id)texture

Generates image id from the window of the current image size powers of 2 closest to the size of the current image.
Options:
dim(nx,ny): powers of 2 closest to nx, ny.
poi(x,y): window left lower corner at (x,y) (-DX/2,DY/2 default where DX and DY are the screen sizes).

generate image time

generate image(id1,id2)time
        Dynamically generate image id2 from pixels of image id1 considered as center of fields.
Options:
coe(f): coefficient of fields (default 1).
dim(nx2,ny2): size of image id2 (default size of image id1).
luminance(lum1,lum2): interval of active pixel luminance of image id1 (default 0,1).
spring(t,v): sets springs with stiffness t and viscosity v between every pixel and its original position.
time(t): over time t (default 1).
Notes:
requires:
       masse image(id1)=m
       generate pixel image(id1)
blocks luminance pixel image(id1), pixel image(id2), force pixel image(id2) and speed pixel image(id2) are automatically generated.
Example:
generate image(id1,id2)time(1)luminance(0,.5)dim(100,100);

generate texture

generate texture image(id)

       Builds 2D texture associated with the image id.
Options:
generate(1): if the dimensions have changed.

generate(0): do nothing if generate(g)texture image(id) has already been invoked.

g=1: does:
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, nx, ny, GL_RGBA, GL_UNSIGNED_BYTE, prvba); Can be used after changing the image of a texture to regenerate.

g=2: does:
glGenTextures(1, &ind);
glBindTexture(GL_TEXTURE_2D, ind);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, nx, ny, GL_RGBA, GL_UNSIGNED_BYTE, prvba);
To invoke when building an image referenced as texture.

generate intersection

generate intersection vol(id)

Generates the intersection informations about volule id (used by put and shadow).

generate inv

generate inv network(id1)network(id2)

Generates the network id2 inverse of the network id1:
the motifs of id2 are the laws of id1.
the laws of id2 are the motifs of id1.
the facets are rearranged and the matrix is recomputed.

generate mass

network
vertex

generate mass(m)network(id)

       Generates the masses of the neural network id to the value m (0.0 by default).

generate(ind)mass(m1,m2)alea network(id)

        Randomly (reproductible) generates the matrix of synaptic weights of the network id between m1 and m2 (0.1,1.0 default), ind is the seed of randoms (0 default).

generate mass(m1,m2)rand network(id)

        Randomly (no reproductible) generates the matrix of synaptic weights of the network id between m1 and m2 (0.1,1.0 defult).

generate mass(m)vertex vol(id)

Initializes the masses of vertices of volume id to m value (1 default).

generate mass(m)alea(m1,m2)vertex vol(id)

Initializes the masses of vertices of volume id to m+dm value with dm=random(m1,m2) (reproductible random).

generate mass(m)rand(m1,m2)vertex vol(id)

Initializes the masses of vertices of volume id to m+dm value with dm=random(m1,m2) (not reproductible random).
Options
vertex(num): only vertex number num.
/*??? A FAIRE ???*/

generate matrix

generate matrix vol

        Generates matrices anchor for all volumes.

generate meta

meta_box

generate(g)meta box vol(id)

        If g=0 generates the bounding box of volume id.
        If g > 0 generates also the meta boxes along the greatest axis of volume id.
Is used in the collision detection (g=1 default).
NP meta box vol(num) returns the number of meta boxes generated.

generate normal

generate normal fac vol(id)

        Generates normal to facets of volume id.
Options:
anc: generates block normal fac ext and block normal vertex ext taking into account ancrages.
generate(1): actually generates.
inv: inverses the normals orientation.

generate normal vertex vol(id)

        Generates normals to vertices of volume id.
Options:
anc: inverses normals ancrages.
generate(1): actually generates.

generate particle

generate particle vol(id)

Generates property particles of volume id type particle from property poi.

particle image
particle vol

generate particle image

generate particle image(id0)vol(id1)vol(id2)

Builds grid id1 and vol particle(id2) isomorphic to image id0 according to generate particle vol(id1)vol(id2).
Options:
dim(dx,dy): size of the grid 5100 default).
secx(nx secyt(ny): resizing image id0 to (nx,ny) (size of the image by default).
see generate col vertex vol(id1)image(id0) for generate pixels' color of volume id1 with that of pixels of image id0

generate particle vol

generate particle vol(id1)vol(id2)

Builds vol particle(id2) the same number of points as volume id1 and automatically does:
generate force(0,0,0,0)vertex vol(id2)
mass vol(id2)=1
vol vertex vol(id2)=id1
generate spring vertex rand(.01,.015,-0.0015)vol(id2)
meta normal vol(id2)=id1
Options:
disk(d1,d2,a1,a2): the size of the particles is function of the depth (exemple: disk(100,1000,5,0))
ext(1): if yes ext and ext vol(id1) the extensions are taken into account.
illum(ill,ref,spe,bri,tran): illum vol(id2)=ill,ref,spe,bri,tran
light(idL): particles are illuminated the same way as the corresponding vertex of volume id1.
mass(m): mass vol(id2)=m
rand(s1,v1,s2,v2): generate spring vertex rand(s1,v1,s2,v2)vol(id2)
spring(s,v): spring vol(id2)=s,v

Note:
vol vol(id2)=id3 allows repleace particles by volume id3.

generate pers

generate pers vertex vol(id)

        Generates perspectives of vertices of volume id.
Notes:
1) accelerates the display calculus.
2) yes anc must be done before generate pers vertex vol if volume id is anchored.
3) generate pers vertex vol num must be done after change in the view or the vertices of the volume id, or after any reanchorage.

generate pers(p0,p1,...,p15) view(id)

        Stores the matrix 4 * 4 (p0, p1, ..., p15) as a matrix of coordinates system change from eye to perspective.
Notes:
1) Other matrices are automaticalled computed.
2) Call this function after eye aim foc or roll change.

generate network

generate network(id)

        Automatically generates properties:
func network(num)
matrix network(num)
neural network(num)
Options:
fac(nh): automatically generates nh+2 layers (one input, nh hidden layers and one output), must be at least one motif and one law (default nh=1).

generate network(id)fac(nh)

        Changes the number of hidden layers.

generate pixel brush

generate brush(id1)pixel(id2)

       Fills the pixel property of brush id1 with the pixels of image id2.
Note:
better than pixel brush(id1)=pixel image(id2) which may give an overflow.

generate pixel

generate pixel image(id)

       Initializess the positions (float)of the pixels (when the image is dynamic).

generate poi

generate poi vol(id)

       Generates the points of volume id transformed by its matrix.

generate poi alea(x1,y1,z1,x2,y2,z2)vol(id)

       Generates randomly (reproductible) the points of object id type obj.

generate poi rand(x1,y1,z1,x2,y2,z2)vol(id)

       Generates randomly (not reproductible) the points of object id.

generate poi anc vol(id)

       Generates points anchored (transformed by the matrix) of volume id (all by default).

generate rand

rand_col        alea_particle

generate rand col fac vol(id)

        Randomly (no reproductible) the colors of facets of volume id.

generate alea(r1,g1,b1,r2,g2,b2) col fac vol(id)

        Randomly (no reproductible) the colors of facets of volume id in interval (r1,g1,b1, r2,g2,b2).
See also generate rand col vertex vol(id).

generate rand col vertex vol(id)

        Randomly generates the colors of vertices of volume id.

generate rand(r1,g1,b1,r2,g2,b2)col vertex vol(id)

        Randomly generates the colors of vertices of volume id in the interval (r1,g1,b1, r2,g2,b2).
See also generate alea col.

generate rand particle(n,t) genetic(id)

       Randomly (no reproductible) generates n individuals size t of genetic id.
See also generate alea particle genetic.

generate rand particle genetic(id)

        Randomly regenerates existing individuals.

generate radius

generate radius near vertex vol(id)

        Generates the maximum distances from each vertex of volume id to its neighbors.

generate spring

generate spring vol(id)

        equivalent to spring vol(id)=0.02,-0.0001

generate spring vertex vol(id)

        equivalent to spring vertex vol(id)=0.02,-0.0001
Options
rand(s1,v1, s2,v2): spring vertexi)vol(id)=rand2f(s1,s2),rand2f(v1,v1)

generate spring rota vol(id)

        equivalent to spring rota vol(id)=raid,visc

generate spring rota vol(id)

        equivalent to spring rota vol(id)=raid,visc

generate spring rota vertex vol(id)

        equivalent to spring rota vertex vol(id)=raid,visc
Note:
raid and visc are automatically computed according to NP vol(id).

generate stock

generate stock(id)

        Generates the dynamic properties stock id:
acc: acceleration.
speed: speed.
rota: courbure.
radius: radius of curvature.

generate stock audio

generate stock audio(id)

        Generates the stock propertie of objetc type audio(id).

generate texture

generate(n) texture(v,s,Dx,Dy,db,v_min,v_max)ini(a,ni)vol(id)col(kx,ky)

        Generates a "reaction diffusion" texture on volume id
Notes:
see Structures de Turing
1) volume id must be isomorphic to a grid.
2) n = number of generations.
3) v = concentration initial values.
s control the size of the spots:
        s = 0.05: larges spots, s=0.075:small spots.
Dx = diffusion speed of the first reagent.
Dy = diffusion speed of the second reagent.
[v_min,v_max] = intervall of v values.
a = disturbance filed at point numbered ni (if absent is selected at random).
4) if ini is absent: takes n generations.
5) if col(kx,ky): the texture is colored with colors kx = rx, vx, bx and ky = ry, vy, by proportionally to the concentrations of reagents x and y.
Example:
generate(2000)texture(4,0.075,0.25,0.0625,0.05,0,8)vol(1)col(1,.7,.5,.5,1,.7);

generate segment

generate segment vol(id)

        Generates the segments (joigning pairs of adjacent vertices on a facet) of volume id.

generate time

generate time vol(id)

        Initializes time vertex of volume id (if is particle system) to an immediate birth and infinite life.

generate time(birth,life)vol(id)

        Initializes time vertex of volume id (if is particle system) to birth and life.

generate time(birth,life)alea(b1,l1,b2,l2)vol(id)

        Initializes time vertex of volume id (if is particle system) to birth+db and life+dl with db=random(b1,b2) and dl=random(l1,l2) (reproductible random).

generate time(birth,life)rand(b1,l1,b2,l2)vol(id)

        Initializes time vertex of volume id (if is particle system) to birth+db and life+dl with db=random(b1,b2) and dl=random(l1,l2) (not reproductible random).

generate triangulate

generate triangulate vol(id)

        Triangulates volume id (without remove original facets) unlike triangulate vol(id)).

generate speed

speed_image
speed_vertex        speed_vol

generate speed image(id)

       Computes the image id speed (must be done for each no dynamic) image).
Options:
alea(a1,a2): random speed (reproductible) between a1 and a2.
generate(g): initializes speed to g.
The images whose luminance is below p are ignored during t images (eliminates parasites).
puls(x,y1,y2,p,phi,e): applies the commande puls to the pixels of the image speed id0 with the parameters (x,y1,y2,p,phi,e).
rand(r1,r2): random speed (no reproductible) between r1 and r2.

generate speed image(id0)image(id1,id2,...)

       Assignes image id0 to speed of images idi.
Notes:
Images idi must be isomorpic (same lignes number and same columns number).
Images id1,id2,... must be of type dynamic.
Options:
coe(c): image id0 is multiplied by c.

generate speed image(id1)speed image(id2)

       Assignes speed of image id1 to speed of image id2.

generate speed pixel image(id)

        Initializes the speeds of the pixels of image id.

generate speed vertex vol(id)

       Nullifies the speed of the vertices of volume id.
Options:
alea(x,y,z); reproductible random (-x,x),(-y,y),(-z,z).
inv(x,y,z); speed vertex vol(id)=(x,y,z)*(previous speed), allows one to chain cons-movement.
vertex(s): only vertices numbered s.
speed(x,y,z): speed vertex vol(id)=x,y,z.
rand(x,y,z); no reproductible random (-x,x),(-y,y),(-z,z).

generate speed vol(id)

       Nullifies the speed of volume id.

generate near

generate near fac fac vol(id)

        Generates the numbers of adjacent facets of every facet of the volume id.

generate near fac vertex vol(id)

        Generates the numbers of facets containing each vertex of the volume id.
Note:
This command allows to accelerate the rendering calculations.

generate near vertex vertex vol(id)

        Generates the numbers of vertices neighboring each vertex volume id.
Note:
This command allows to accelerate the execution of pull vertex vol.

generate vol

vol        ext        frac        vol_precision

generate vol(id1) number(id2)

        Generates the volume id2 from id1 volume taking into account
extensions
fractals
motifs
vertices
latice
Notes:
1) If id2 = id1, the volume id1 is modified.
2) Syntax similar to:
generate light
generate view

generate vol(id)ext

        If ext vol(id) was defined, property poi generate of volume id

generate vol(id)frac

        If frac vol(id) was defined generates poi generate property of volume id, is the fractal extension points.

generate vol(id)precision(p)

        Simplifies volume id by taking one facet on p * p.

generate precision(p) vol(id1) number(id2)

        Generates volume id2, simplification of volume id1.
Notes:
1) Volume id1 must be isomorphic to a grid.
2) generate precision(p)vol(id)simple; generates only points and facets.

generate property

Note:

generate propr vertex vol(id)
        Generates "propr" property for all vertices of volume id.
generate(n) propr vertex vol(id)
        Reserves n floats for the "propr vertex" property of volume id.
generate propr fac vol(id)
        Generates "propr" property for all facets of volume id.
Note: To minimize storage time (for large volumes) it is advisable to do generate propr vertex vol(id) before doing series of propr vertex(n1)vol(id)=expr
Example:
ball(200,40) number 1;
generate col vertex vol(1);
col vertex[1,40]vol 1=1,.7,.5;
generate(2) spring vertex vol(1);
spring vertex[1,40]vol 1=.02,-.0001;

generate view

generate view(id)

        Generates view id (all if id is absent).
call whenever the view is ch(for example for inv pers win.

See also:

fac generate
NF generate
NP generate
poi generate