generate acc
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
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
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(n) genetic(id)
Regenerates n (1 by default) times 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.
Options:
luminance(lum1,lum2): if genetic id has a property image(idi) the relevant
pixels are those whose luminance is in [lum1,lum2].
generate illum
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 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 illum vertex vol(id)interpol
Generates illum vertex vol(id) with transparency 1 on edge.
Options:
illum(ill,ref,spe,bri): specific illumination
interpol(t1,t2): specific transparencies.
generate image
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).
center: centres the window.
dim(nx,ny): change the image size in (nx,ny) (x2-x1+1,y2-y1+1 default).
exp: dim is transformed in 2 power (for textures).
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).
poi(x,y): center(x,y) (x=0, y=0 by default: centered).
win(x1,y1,x2,y2): save the window (x1,y1,x2,y2) (full screen default)
in image coordinates.
Note:
the saved image may be returned by displ image.
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)exp
changes the image sizes to powers of 2 <= screen size (this in order to make this image a
texture).
Options:
format("f"): the image is stored according to the
format "f" ("RGBA" default).
generate(1): in order to make this image a texture mapping.
poi(x,y): origine (center by default).
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.
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)
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 <= to the size of the current image.
Options:
dim(nx,ny): powers of 2 <= 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 interaction
generate interaction meta(id1,id2,...)image(ima,inc)
Generates objects interaction meta id2,... as
copies of id1.
generate interaction time
Builds real time informations for all volumes, allows accelerate computation times with
less functionalities.
generate interaction time vol(id)
Builds those informations for volume id.
edit interaction time shows those informations.
rem interaction time deletes those informations.
generate interaction meta(id1,id2,...)image(ima,inc)
Generates objects interaction meta id2,... as
copies of id1.
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
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.
generate matrix
generate matrix vol
Generates matrices anchor for all volumes.
generate matrix vol(id)
Generates matrices for volume id and its followers.
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.
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).
Options:
generate(1): does generate poi anc vol for every
follow of vol id.
generate poi screen vol(id)
Generates points in screen coordinates of volumeid.
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
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 simple
generate simple vol(id)
Generates the simple parameters of volume id in order
to accelerate the animation.
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: