"particle
générer
generate acc
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
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 col vertex vol(id1)image(id2)
Génère col vertex vol(id1) avec les couleurs de
l´image id2.
(il faut: nombre de sommets du volume id1 = nombre de pixels de l´imageid2).
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
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(n) genetic(id)
Regénère n fois (1 par défaut) 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.
luminance(lum1,lum2): si la génétique id une propriété
image(idi) les pixels pertinents sont ceux dont la luminosité appartient à [lum1,lum2].
generate illum
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 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 illum vertex vol(id)interpol
Génère illum vertex vol(id) transparents
sur les bords.
Options:
illum(ill,ref,spe,bri): specific illumination
interpol(t1,t2): specific transparencies.
generate image
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).
center: centre la fenétre.
dim(nx,ny): change la taille de l´image en (nx,nt) (plein écran
par défaut).
exp: transforme dim en puissances de 2 (pour les textures).
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).
poi(x,y): center(x,y) (x=0, y=0 par défaut): centré).
win(x1,y1,x2,y2): sauvegarde la fenêcirc;tre (x1,y1,x2,y2)
(plein écran par défaut), en coordonnées d´image.
Remarque:
L´image sauvée peut être affichée par displ image.
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.
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)exp
exp: change les dimensions de l´image en
puissances de 2 <= nx,ny, (ceci en vue de faire de cette image une
texture).
Options:
format("f"): the image is stored according to the
format "f" ("RGBA" default).
generate(1): pour faire de cette image une mappe.
poi(x,y): origine (centre par défaut).
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.
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)
Calcule les couleurs des pixels de l´image par la formule des
textures à centre de couleur.
generate image(id)mouse
Cliquer 2 points.
Options:
coe(c): frame(d,coe*d).
limit(x1,y1,x2,y2): la saisie est limitée à la fenêtre
(x1,y1,x2,y2) affichée en vert.
exp: en ajustant les dimensions à des puissances de 2.
generate image(id)texture
Génère l´image id depuis la fenêtre de l´image courante
de dimensions les puissances de 2 <= aux dimensions de l´image courante.
Options:
dim(nx,ny): puissances de 2 <= 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 interaction
generate interaction meta(id1,id2,...)image(ima,inc)
Génèrate les objets interaction meta id2,...
vomme copies de id1.
generate interaction time
Construit les informations pour le temps réel pour tous les volumes, permet
d´accélérer les temps de calculs, avec moins de fonctionnalités.
generate interaction time vol(id)
Construit ces informations pour le volume id.
edit interaction timemontre ces informations.
rem interaction timesupprime ces informations.
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
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.
generate matrix
generate matrix vol
Génère les matrices d´ancrage de tous les volumes.
generate matrix vol(id)
Génère les matrices d´ancrage du volume id et de ses suiveurs..
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 image
generate particle image(id1)vol(id2)
Construit la grille id1 et vol particle(id2)
isomorphes à l´image id0 selon
generate particle vol(id1)vol(id2).
Options:
dim(dx,dy): taille de la grille (100 par défaut).
dim(nx,ny): redimensonnne l´image id0 à (nx,ny)
(taille de l´image par défaut).
see generate col vertex vol(id1)image(id0) pour
générer la couleur des sommets du volume id1 avec celle
des pixels de l´image id0.
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(ill,ref,spe,bri,tran): 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.
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 permet de remplacer les particules
par le volume id3.
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 network(idfac(nh)
Change le nombre de couches cachées.
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).
Options:
generate(1): fait generate poi anc vol pour tous les
follow du volume id.
generate poi screen vol(id)
Génère les points en coordonnées d´écran du
volume id
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
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 simple
generate simple vol(id)
Génère les paramètres de simple pour le volume id
afin d´accérer l´animation.
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: