"particle

generate


générer

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        normal        normal vertex
particle        particle vol        pers        pixel brush        pixel image
rand        radius
segment        speed        spring        spring vertex        stock        stock audio
texture        time
vol        view
Voir aussi

generate acc

acc image

generate acc image(id)

Génère l´accélération de l´image id.
Options:
acc(k): k*acc image(id)

generate alea

col        particule

generate alea col fac vol(id)

        Génère aléatoirement, et de façon reproductible, les couleurs aux facettes du volume id.

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

        Génère aléatoirement les couleurs aux facettes du volume id dans la l´intervalle (r1,v1,b1,r2,v2,b2).
Voir aussi generate rand col vertex vol(id).

generate alea col vertex vol(id)

        Génère aléatoirement les couleurs aux sommets du volume id.

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

        Génère aléatoirement les couleurs aux sommets du volume num dans la fourchette (r1,v1,b1,r2,v2,b2).

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

        Génère n individus aléatoires de taille t de la génétique id. Cet aléatoire est reproductible.
Voir aussi generate rand particle genetic.

generate alea particle genetic(id)

        Regénère aléatoirement les individus existants.

generate axis

generate poi anc vol(id)

        énère les coordonnées des sommets du volume id transformées par sa matrice.
poi(num)anc vol(id) returns the anchored points num of volume id.

generate axis

generate axis vol(id)

        Génère le repère local attaché au volume id par la donnée des 3 vecteurs:
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)

        Génère les boites englobantes des facettes du volume id.
Remarque: Cette génération ne prend pas en compte les transformations matricielles, cependant attach displ box fac vol(id) les prend en compte.
/*??? A VERIFIER ???*/

generate(n)box grid vol(id)

        Génère une grille 3D de n*n*n mailles englobant le volume et contenant pour chaque maille: box(x1,y1,z1,x2,y2,z2)(numéros des facettes intérieures).
Remarques:
1) Permet d´accélérer les calculs de collision.
2) Par défaut une boite de taille optimale est automatiquement générée.
3) Si n est absent ou si n=0: génère la boite par défaut.

generate(n)box vertex vol(id)

        Génère une grid 3D de n*n*n mailles englobant le volume id et contenant pour chaque maille: box(x1,y1,z1,x2,y2,z2)(numéros des sommets intérieurs)
Remarques:
1) Permet d´accélérer les calculs de collision
2) Par défaut une box de taille optimale est automatiquement générée.
3) Si n est absent ou si n=0: Genere la box par défaut

generate box vol(id)

        Génère la boite (x1,y1,z1,x2,y2,z2) du volume id.
Remarque: Cette génération ne prend pas en compte les transformations matricielles, cependant attach displ box vol(id) les prend en compte.

generate box secx vol(id)

        Génère les boites (x1,y1,z1,x2,y2,z2) des sections en x du volume id.

generate box secy vol(id)

        Génère les boites (x1,y1,z1,x2,y2,z2) des sections en y du volume id.

generate ball

generate ball fac vol(id)

        Génère les boules englobantes des facettes du volume id (centre et rayon).
Remarque: Cette génération ne prend pas en compte les transformations matricielles, cependant attach displ ball fac vol(id) les prend en compte.

generate ball vol(id)

        Génère la boule englobante du volume id (centre et rayon).
Remarque: Cette génération ne prend pas en compte les transformations matricielles, cependant attach displ box vol(id) les prend en compte.

generate CG

generate CG fac vol(id)

        Génère les centres de gravités des facettes du volume id.
Options:
anc; en tenant compte des transformations de la matrix du volume id.

generate coord

generate coord vertex vol(id)

        Génère les coordonnées de texture2D des sommets du volume id.
Remarques:
1) Le volume id doit être isomorphe à une grille.
2) A chaque sommet sont associées ses coordonnées (normalisées entre 0 et 1).
3) Utile pour la texture2D temps réel.

generate col

col_fac
col_vertex

generate col fac vol(id)

        Génère les col fac vol(id) avec le couleur du volume id. (blanc par défaut).

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

        Génère les col fac vol(id) avec des couleurs aléatoires reproductibles dans les intervalles [r1,r2] [v1,v2] [b1,b2] ([0,1] par défaut).

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

        Génère les col fac vol(id) avec des couleurs aléatoires non reproductibles dans les intervalles [r1,r2] [v1,v2] [b1,b2] ([0,1] par défaut).

generate col vertex vol(id)

        Génère les col vertex vol(id) avec la couleur de vol(id) (blanc par défaut).

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

        Génère les col vertex vol(id) avec des couleurs aléatoires reproductibles dans les intervalles [r1,r2] [v1,v2] [b1,b2] ([0,1] par défaut).

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

        Génère les col vertex vol(id) avec des couleurs aléatoires non reproductibles dans les intervalles [r1,r2] [v1,v2] [b1,b2] ([0,1] par défaut).

generate depth

generate depth vol(id1,id2)

       Si le volume id1 est isomorphe à une grille, génère le volume id2 dont les points sont:
1) Ceux du volume id1.
2) et les mêmes points déplacés de 100 sur leur normale.
Options:
depth(d): déplacement de d (100 par défaut).
close(f): si f = 1 volume fermé, sinon ouvert (par défaut).

generate displ

generate displ vol(id)

Génère les informations temps réel du volume .

generate dynamic

generate dynamic image(id)

       Fait de l´image id une image de type dynamic en initialisant ses buffers:
im(0): image initiale (unsigned char).
im(t): image actuelle (au temps t) (float).
im(t-1): image précédente (au temps t-1) (float).
vit: speed image (float).
Options:
dynamic(0): détruit la propriété dynamic de l´image.
utilisés par les calculs de dynamique.
       Si l´image id est déjà de type dynamique cette commande initialise sa vitesse, elle l´est automatiquement en mode interaction.

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

generate envelope

generate envelope(L)abs number(num)

        Génère le volume num à facettes triangulaires joignant tous les triplets de points de la ligne L.

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

        Génère le volume num, envelope convexe des points L=x1,y1,z1,x2,y2,z2,..., d´axis la ligne w et de nx points par section.

generate envelope vol(id)

        Génère les arêtes du contour apparent du volume id.

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

        Génère le volume num avec un Laser virtuel dont le rayon est issu de chaque sommet des sections en y du volume ne et regarde vers le CG de ces sections.
Remarques:
1) generate envelope(ne) line(L) vol(n1,n2,...) number(num); La ligne L définit les points de visées.
2) generate envelope(ne) vol(n1,n2,...) line(L) ext(e,c,f) number(num);
Les ajustements sont courbes.
3) generate envelope(ne) vol(n1,n2,..) secy(a1,b1,a2,b2,...) number(num);
Seules les facettes comprises entre les secy (ai,bi) du volume ni seront traitées (ai et bi normalisés entre 0 et 1).
4) generate envelope(ne) vol(n1,n2,...) dist(d) number(num);
Ne traite que les facettes des volumes ni situées à une distance inférieure à d des points de visée.
5) generate envelope(ne) vol(n1,n2,...) precision(p) number(num);
Calcule les intersections à p près (.0001 par defaut).

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

generate fac

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

       Génère les volumes n3,n3+1,... construits sur les facettes n1,n1+1,... du volume id.
Remarques:
1) Si n1 est absent, toutes les facettes sont générées
2) Si n3 est absent, les numéros courants sont créés

generate frac

generate frac vol(id)

       Génère le fractal du volume id comportant un fractal.
Les points, les facettes, les propriétes des facettes et des points (normales, coe, illum, col, ...) sont étendues.
A faire chaque fois que l´on change le fractal ou que sont modifiés des points de contrôle.
Remarques:
1) Le fractal peut être générée automatiquement en faisant attach generate frac vol(id), mais cela risque de ralentir considérablement les temps de calcul.
2) Les extensions courbes et les fractals sont incompatibles, le fractal étant prioritaire sur l´extension.

generate field(id)

        Calcule des informations sur le champ id.
Remarque:
Nécessaire pour un champ de type image quand l´image associée a été modifiée.

generate force

force vol
force vertex
force pixel

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

Initialise la force vol(id) à (x, y, z, v) (0,0,0,0 par défaut).

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

Initialise les force vertex vol(id) à (x, y, z, v) (0,0,0,0 par défaut).

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

        Initialie les force vertex vol(id) à (x+dx, y+dy, z+dz, v+dv) avrc dx=alea(x1,x2), dy=alea(y1,y2), dz=alea(z1,z2), dv=alea(v1,v2) (aléatoire reproductible).

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

        Initialise les force vertex vol(id) à (x+dx, y+dy, z+dz, v+dv) evec dx=random(x1,x2), dy=random(y1,y2), dz=random(z1,z2), dv=random(v1,v2) (aléatoire non reproductible).

generate force pixel image(id)

        Initialise à zéro les ofrces appliquées aux pixels de l´image id.

generate ext

generate ext vol(id)

       Génère les extensions du volume id comportant une extension.
Les points, les facettes, les propriétes des facettes et des points (normal, coe, illum, col, ...) sont étendues.
A faire chaque fois que l´on change l´extension ou que sont modifiés des points de contrôle.
Remarques:
1) L´extension n´est générée que si yes ext est actif, mais:
generate(1)ext vol(id);
le fait même si no ext est actif.
2) L´extension peut être générée automatiquement en faisant attach generate ext vol(id).
3) Les extensions courbes et les fractals sont incompatibles, le fractal détruisant l´extension.

generate genetic

generate(n) genetic(id)

        Regénère la population génétique id par sélections, croisements et mutations en privilegiant les individus les mieux évalués par la fonction func genetic(g).
Options:
adjust(min,max,muta,k): retourne et ajuste automatiquement la mutation muta dans [min,max] (0.0001 et 0.001 par défaut) de façon à faire décroitre l´error (voir un exemple dans le fichier demo1_genetic.func dans la fonction func_EXPL2_GENERATE()).
       Dans ce cas meta genetic(id) retourne la moyenne des notes. Lorsque muta atteint max elle prend la valeur k*max.
error(e): avec l´option generate(n) sort lorsque toutes les erreurs sont < e.
generate(n): réalise n générations successives.

generate illum

illum_fac
illum_vertex

generate illum fac vol(id)

        Génère les illum fac vol(id) avec l´illumination du volume id. (1,1,0,0,0 par défaut).

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

        Génère les illum fac vol(id) avec des illuminations aléatoires reproductibles dans les intervalles [i1,r1,s1,b1,t1, i2,r2,s2,b2,t2] ([0,1] par défaut).

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

        Génère les illum fac vol(id) avec des illuminations aléatoires non reproductibles dans les intervalles [i1,r1,s1,b1,t1, i2,r2,s2,b2,t2] ([0,1] par défaut).

generate illum vertex vol(id)

        Génère les illum vertex vol(id) avec l´illumination de vol(id) (1,1,0,0,0 par défaut).

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

        Génère les illum vertex vol(id) avec des illuminations aléatoires reproductibles dans les intervalles [i1,r1,s1,b1,t1, i2,r2,s2,b2,t2] ([0,1] par défaut).

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

        Génère les illum vertex vol(id) avec des illuminations aléatoires non reproductibles dans les intervalles [i1,r1,s1,b1,t1, i2,r2,s2,b2,t2] ([0,1] par défaut).

generate image

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


Remarque préliminaire
Il est toujours préférable de manipuler les images en mode interaction.
Cependant la commande displ image graphic permet de le faire.

generate image

        Sauvegarde l´image courante dans l´image 0. Elle pourra être restituée par displ image.
Options:
abs: en coordonnées d´image).
dim(nx,ny): change la taille de l´image en (nx,nt) (plein écran par défaut).
exp: change les dimensions de l´image en puissances de 2 les plus proches de nx,ny, (ceci en vue de faire de cette image une texture).
format("f"): the image is stored according to the format "f" ("RGBA" default).
generate(1): pour faire de cette image une mappe.
image(id): sauve dans l´image id au lieu de 0.
normal: coordonnées normalisées (entre 0.0 et 1.1).
win(x1,y1,x2,y2): sauvegarde la fenÍcirc;tre (x1,y1,x2,y2) (plein écran par défaut).
Remarque:
L´image sauvée peut être affichée par displ image.

automappe

Voir automappe.func pour mapper récursivement une image sur elle-même.

generate image(id)

Équivallant à generate image(0,id).

generate bitmap image(id)

Génère la bitmap(-1) de l´image id qui est which la copie de l´image originale.
displ bitmap(-1)image(id) permet de l´afficher.
Automatiquement génère par read image(id)name("...")

generate image brush(id)

Si le pinceau id est de type image initialise à 0 l´image du pinceau de dimensions radius brush.
Options:
radius(dimx,dimy): redéfinit les rayons du pinceau et génère l´image.
Pour désigner la fenêtre à la souris: generate image(id)mouse ou, mieyx, better, palette.

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

Génère l´image id2 de dimensions (nx2,ny2) à partir d'une analyse des variations dynamiques de l´image id1:
Options:
alea(a): perturbations aléatoires reproductibles d´amplitude a normalisé entre 0.0 et 1.0 (0.01 par défaut).
col: variations dynamiques des couleurs.
luminance: variations dynamiques des luminances (par défaut).
rand(r): perturbations aléatoires non reproductibles d´amplitude r normalisé entre 0.0 et 1.0 (0.01 par défaut).
speed(v): traite la vitesse en les multipliant par v (0.01 par défaut).
Remarque:
Il faut que yes image soit actif pour que la dynamique des images soit prise en compte en mode interaction.
Sinon, hors interaction, il faut faire exec dynamic pour que les images soient modifiées en fonction de leur dynamique.

generate image(id)ext

       Génèrates l´image id en remplaçant chaque pixel par la moyenne des 4 pixels (gauche, dessus, droite et dessous).

generate image(id1,id2)ext

       Génèrates l´image id2 en remplaçant chaque pixel de l´image id1 par la moyenne des 4 pixels (gauche, dessus, droite et dessous).
Options:
dim(nx,ny): taille de l´image id2 (la même que celle de id1 par défaut).
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)

       Génè,re l´image du champ id de type image, doit être fait si l´image a été modifiée.

generate image interpol

generate image(i1,i2,...,in)interpol(ni)number(i0)
       Génère nb=n+(n-1)*(ni+1) images (i0,i0+1,...,i0+nb-1) numérotées à partir de i0 en intercalant ni images interpolées entre i1 et i2, ni images entre i2 et i3 , ... et retourne nb.
Remarque:
Peut être utiliser pour obtenir une animation de mappes, voir un exemple dans la fonction INTERPOL() de la démo demo1_texture.func.


interpol read read
interpol read col
interpol read read

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

Crée les images c en interpolant les fichiers images Aa.eee et Bb.eee avec a dans [na,na+ni[, b dans [nb,nb+ni[ rt c dans [nc,nc+ni[.
image center radius transp normal sont disponibles.

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

Crée les images c en interpolant les fichiers images Aa.eee et la coleur(r,g,b) avec a dans [na,na+ni[, et c dans [nc,nc+ni[ (fade out).

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

Crée les images c en interpolant la coleur (r,g,b) et les fichiers image Aa.eee avec a dans [na,na+ni[, et c dans [nc,nc+ni[ (fade in).

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

Écrit les fichiers image Cc.eee au lieu de générer les images c.
Options:
number(n,dn): dn = incrément du numéro d´image (1 par défaut).

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

        Calcule les couleurs des pixels de l´image par la formule
(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,...)

        Calcule les couleurs des pixels de l´image par la formule des textures à centre de couleur.

generate image(id)mouse

        Cliquer 2 points.
Remarque: L'affichage passe en mode interaction le temps de la saisie, si bien que la fenêtre de l´interpréteur semble perdue. Faies Alt tab et cliquer sur l´icone anyflo pour la retrouver. Mieux utiliser palette.

generate image(id)texture

Génère l´image id depuis la fenêtre de l´image courante de dimensions les puissances de 2 les plus proches des dimensions de l´image courante.
Options:
dim(nx,ny): puissances de 2 les plus proches de nx, ny.
poi(x,y): coin bas gauche de la fenêtre en (x,y) (-DX/2,DY/2 par défaut avec DX et DY étant les dimensions de l´écran).

generate image time

generate image(id1,id2)time
        Génère dynamiquement l´image id2 à partir des pixels de l´image id1 considérés comme champs centraux de forces.
Options:
coe(f): coefficients des champs(default 1).
dim(nx2,ny2): dimensions de l´image id2 (par défaut celles de l´image id1).
luminance(lum1,lum2): interval of active pixel luminance of image id1 (default 0,1).
spring(t,v): met un ressort de raideur t et de viscosité v entre chaque pixel et sa position originale.
time(t): sur un temps t (1 par défaut).
Remarques:
il faut:
       masse image(id1)=m
       generate pixel image(id1)
les blocs luminance pixel image(id1), pixel image(id2), force pixel image(id2) et speed pixel image(id2) sont automatiquement générés.
Exemple:
generate image(id1,id2)time(1)luminance(0,.5)dim(100,100);

generate texture

generate texture image(id)

       Construit la texture 2D associée à l´image id.
Options:
generate(1): si les dimensions ont changées.

generate(0): ne fait rien si generate(g)texture image(id) a déjà été invoqué.

g=1: fait:
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, nx, ny, GL_RGBA, GL_UNSIGNED_BYTE, prvba);
Peut être employé après modification de l´image d´une texture pour la régénérer.

g=2: fait:
glGenTextures(1, &ind);
glBindTexture(GL_TEXTURE_2D, ind);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, nx, ny, GL_RGBA, GL_UNSIGNED_BYTE, prvba);
A invoquer lors de la construction d´une image référencée comme texture.

generate intersection

generate intersection vol(id)

Génère les informations d´intersection du volule id (utilisé par put et shadow).

generate inv

generate inv network(id1)network(id2)

Génère le réseau id2 inverse inverse du réseau id1:
les motifs de id2 sont les lois de id1.
les lois de id2 sont les motifs de id1.
les facettes sont réarrangées et la matrice est recalculée.

generate mass

network
vertex

generate mass(m)network(id)

       Génère les masses du réseau neuronal id à la valeur m (0.0 par défaut).

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

        Génère aléatoirement (reproductible) la matrice des poids synaptiques du réseau id entre m1 et m2 (0.1,1.0 par défaut), ind est le germe de l´aléatoire (0 default).

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

        Génère aléatoirement (non reproductible) la matrice des poids synaptiques du réseau id entre m1 et m2 (0.1,1.0 par défaut).

generate mass(m)vertex vol(id)

Initialise les masses des sommets du volume id à la valeur m (1 par défaut).

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

Initialise les masses des sommets du volume id aux valeurs m+dm avec dm=random(m1,m2) (aléatoire reproductible).

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

Initialise les masses des sommets du volume id aux valeurs m+dm avec dm=random(m1,m2) (aléatoire non reproductible).
Options
vertex(num): only vertex number num.
/*??? A FAIRE ???*/

generate matrix

generate matrix vol

        Génère les matrices d´ancrage de tous les volumes.

generate meta

meta_box

generate(g)meta box vol(id)

        Si g = 0 génère la boite englobante du volume id.
        Si g > 0 génère aussi les méta boites selon le plus grand axe du volume id.
Est utilisé pour la detection de collision (g = 1 par défaut).
NP meta box vol(num) retourne le nombre de méta boites générées.

generate normal

generate normal fac vol(id)

        Génère les normales aux facettes du volume id.
Options:
anc: génère un bloc ´normal fac anc´ et un bloc ´normal vertex anc´ en tenant compte des ancrages.
generate(1): génère effectivement.
inv: inverse le sens des normales.

generate normal vertex vol(id)

        Génère les normales aux points du volume id.
Options:
anc: en tenant compte des ancrages.
generate(1): génère effectivement.

generate particle

generate particle vol(id)

Génère la propriété property particles du volume id de type particle à partir de la propriété poi.

generate particle vol

generate particle vol(id1)vol(id2)

Construit vol particle(id2) de m&ecirec;me nombre de points que le volume id1 et fait automatiquement:
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): la taille des particles dépend de la profondeur. (example: disk(100,1000,5,0))
ext(1): si yes extet ext vol(id1) les extensions sont prises en compte.
illum vol(id2)=ill,ref,spe,bri,tran
light(idL): les particles sont éclairées de la même façon que les sommets correspondants du volume id1.
rand(s1,v1,s2,v2): generate spring vertex rand(s1,v1,s2,v2)vol(id2)

generate pers

generate pers vertex vol(id)


        Génère les perspectives des sommets du volume id.
Remarques:
1) Permet d´accélérer les calculs d´affichage.
2) Il faut faire yes anc avant ´generate pers vertex vol´ si le volume id est ancré.
3) Il faut faire generate pers vertex vol(id) après tout changement de la vue ou des sommets du volume id, ou après tout réancrage.

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

        Charge la matrice 4*4 (p0,p1,...,p15) comme matrice de changement du repère de l´oeil dans le repère de la perspective.
Remarques:
1) les autres matrices sont automatiquement calculées.
2) Rappeler cette fonction après un changement de ´eye´, ´aim´, ´foc´ ou ´roll´

generate network

generate network(id)

        Génère automatiquement les propriétés:
func network(num)
matrix network(num)
neurone network(num)
Options:
fac(nh): génère automatiquement nh+2 couches (une d´entrée, nh couches cachées et une de sortie), il doi y avoir au moins un motif et une loi (nh=1 par défaut).

generate pixel brush

generate brush(id1)pixel(id2)

       Remplit la propriété pixel du pinceau id1 avec les pixels de l´image id2.
Remarque:
meilleur que pixel brush(id1)=pixel image(id2) qui peut provoquer un débordement.

generate pixel

generate pixel image(id)

       Génère un bufer 2D des positions des pixels (quand l´image est dynamique).

generate poi

generate poi vol(id)

       Génère les points du volume id transformé par sa matrice.

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

       Génère aléatoirement (reproductible) les points de l´objet id de type obj.

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

       Génère aléatoirement (non reproductible) les points de l´objet id.

generate poi anc vol(id)

       Génère les points ancrés (c´est à dire transformés par la matrice) du volume id (tous par défaut).

generate rand

rand_col        alea_particle

generate rand col fac vol(id)

        Génère aléatoirement, et de façon non reproductible, les couleurs aux facettes du volume id.

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

        Génère aléatoirement, et de façon reproductible, les couleurs aux facettes du volume id dans la l´intervalle (r1,v1,b1, r2,v2,b2).
Voir aussi generate rand col vertex vol(id).

generate rand col vertex vol(id)

        Génère aléatoirement, et de façon non reproductible, les couleurs aux sommets du volume id.

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

        Génère aléatoirement, et de façon non reproductible, les couleurs aux sommets du volume id dans la fourchette (r1,v1,b1, r2,v2,b2).
Voir aussi generate alea col.

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

       Génère n individus aléatoires de façon non reproductible de taille t de la génétique id. Cet aléatoire est non reproductible.
Voir aussi generate alea particle genetic.

generate rand particle genetic(id)

        Regénère aléatoirement les individus existants.

generate radius

generate radius near vertex vol(id)

        Génère les distances maximum de chaque sommet à ses voisins.

generate spring

generate spring vol(id)

        Equivalent spring vol(id)=0.02,-0.0001

generate spring vertex vol(id)

        Equivalent 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 à spring rota vol(id)=raid,visc

generate spring rota vertex vol(id)

        Equivalent à spring rota vertex vol(id)=raid,visc
Remarque:
raid et visc sont calculés automatiquement en fonction de NP vol(id).

generate stock

generate stock(id)

        Génère les propriétés dynamiques de stock id:
acc: accélération.
speed: vitesse.
rota: courbure.
radius: radius de courbure.

generate stock audio

generate stock audio(id)

        Génère la propriété stock de l´objet de type 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)

        Génère une texture de "réaction diffusion" sur le volume id
Remarques:
Voir Structures de Turing
Le volume id doit être isomorphe à une grille.
n = Nombre de générations.
v = valeur initiale des concentrations.
s contrôle la grosseur des taches:
        s=0.05: Grosses taches, s=0.075: Petites taches
Dx = vitesse de diffusion du 1er reactif
Dy = vitesse de diffusion du 2eme reactif
[v_min,v_max] = intervalle des valeurs de v
a = perturbation déposée au point numéro ni (si ni est absent il est choisi au hasard).
Si ´ini´ est absent: Reprend n générations
Si col(kx,ky) est présent, la texture est colorée avec les couleurs kx=rx,vx,bx et ky=ry,vy,by proportionnellement aux concentrations des réactifs x et y.
Exemple:
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)

        Génère les arêtes (couples de sommets adjacents sur une facette) du volume id.
edit segment vol(id): édite les couples.

generate time

generate time vol(id)

        Initialise les time vertex du volume id (s´il est un système de particules) à une naissance immediate et à une vie infinie.

generate triangulate

generate triangulate vol(id)

        Triangule le volume id (sans supprimer les facettes d´origine, à la différence de triangulate vol(id)).

generate speed

speed_image
speed_vertex        speed_vol

generate speed image(id)

       Calcule l´image vitesse de l´image id (doit être fait à chaque image pour une image non dynamic).
Options:
alea(a1,a2): vitesse aléatoire (reproductible) entre a1 et a2.
generate(g): initialise la vitesse à g.
Les images de luminance inférieure à p sont ignorées pendant t images (permet d´éliminer les parasites).
puls(x,y1,y2,p,phi,e): applique la commande puls aux pixels de l´image vitesse de l´image id0 avec les paramètres (x,y1,y2,p,phi,e).
rand(r1,r2): vitesse aléatoire (non reproductible) entre r1 et r2.

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

       Affecte l´image id0 aux vitesses des images idi.
Remarques:

Les images idi doivent Ítre isomorphes (mêmes nombres de lignes et de colonnes).
Les images id1,id2,... doivent être de type dynamic.
Options:
coe(c): l´image id0 est multipliée par c.

generate speed image(id1)speed image(id2)

       affecte la vitesse de l´image id1 à celle de l´image id2.

generate speed pixel image(id)

        Initialise les vitesses des pixels de l´image id.

generate speed vertex vol(id)

       Rend nulles les vitesses des sommets du volume id.
Options:
alea(x,y,z); aléatoires reproductibles (-x,x),(-y,y),(-z,z).
inv(x,y,z); speed vertex vol(id)=(x,y,z)*(vitessed précédente), permet d´enchainer un contre mouvement.
vertex(s): seulement les sommets numéros s.
speed(x,y,z): speed vertex vol(id)=x,y,z.
rand(x,y,z); aléatoires non reproductibles (-x,x),(-y,y),(-z,z).

generate speed vol(id)

       Rend nulle la vitesse du volume id.

generate near

generate near fac fac vol(id)

        Génère les numéros des facettes voisines de chaque facette du volume id.

generate near fac vertex vol(id)

        Génère les numéros des facettes contenant chaque sommet du volume id.
Remarque:
Cette commande permet d´accélérer les calculs d´affichage.

generate near vertex vertex vol(id)

        Génère les numéros des sommets voisins de chaque sommet du volume id.
Remarque:
Cette commande permet d´accélérer l´execution de pull vertex vol.

generate vol

vol        ext        frac        vol_precision

generate vol(id1) number(id2)

        Génère le volume id2 à partir du volume id1 en tenant compte:
des extensions
des fractals
des motifs
des vertex
des treillis
Remarques:
1) Si id2 = id1, le volume id1 est modifié.
2) Syntaxe analogue pour:
generate light
generate view

generate vol(id)ext

        Si ext vol(id) a été défini génère la propriété poi generate du volume id, points de l´extension.

generate vol(id)frac

        Si frac vol(id) a été défini génère la propriété poi generate du volume id, points de l´extension fractale.

generate vol(id)precision(p)

        Simplifie le volume id en prenant une facette sur p*p.

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

        Génère le volume id2, simplification du volume id1.
Remarques:
1) Le volume id1 doit être isomorphe à une grille.
2) generate precision(p) vol(id) simple: Ne génère que les points et les facettes.

generate ´propriété´


Remarque:
generate propr vertex vol(id)
        Génère la propriété "propr" pour tous les sommets du volume id.
generate(n) propr vertex vol(od)
        Réserve n floats pour la propriété ´propr vertex´ du volume id.
generate propr fac vol(id)
        Génère la propriété "propr" pour toutes les facettes du volume id.
Remarque: Afin de minimiser les temps de stockage (pour les gros volumes) il est conseiller de faire ´generate propr vertex vol(id)´ avant de faire une série de ´propr vertex(n1)vol(id)=expr´
Exemple:
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)

        Génère la vue id (toutes si id est absent).
A appeler chaque fois que la vue est changée (par exemle pour inv pers win.

Voir aussi:

fac generate
NF generate
NP generate
poi generate