traitement des images
image en mémoire
Par défaut une mémoire d´image de dimension donnée
par l´option win est traitée par
les fonctions d´OpenGL.
Il est possible définir des mémoires d´image de dimensions quelconques et en nombre illimité.
Ces mémoires peuvent être traitées temps réel ou en soft (permettant beaucoup plus d´effets graphiques
programmables).
Elles peuvent être affichées et/ou garées sur le disque (utile par exemple pour une animation
en temps différé).
Elles peuvent être animées au moyen de trajectoires ou de la
dynamic.
Image statique
Par défaut une image donnée id est statique.
Image dynamic
Comme tout objet
d'anyflo une image peut être rendue dynamique. par:
dynamic image(id)=1
mass image(id)=m
yes dynamic
Dynamique de couleur
Ce que fait l´une des commandes:
dynamic image(id)=1 ou
generate dynamic image(id)
le calcul de sa dynamique sera effectué si yes dynamic et
yes image sont actifs.
3 buffers floats im(t), im(t-1), et vit stockant l´image aux temps t (actuel), t-1, et
les vitesses des pixels, sont maintenus
automatiquement et servent aux calculs de la dynamique.
Certaines commandes permettent de contrôler les variations des paramètres:
generate speed image(id)
limit acc image
limit col image
limit speed image
Voir un exemple dans le sous menu IMA() du fichier
demo1_dynamic.func.
Un pinceau dynamic peut être associé à une image
dynamique pour construire une palette dynamic.
Dynamique de pixel
generate pixel image(id)
génère un buffer pixels (positins floats).
mass image(id)=m
affecte une masse.
yes dynamic
active la dynamique.
En conséquence les pixesl sont dynamiquement déplacés en fonction des paramètres.
Plus d´options:
CG(n): les centres de gravité des n*n sous images
sont considérés comme les centres de champs attirant les pixels.
generate force pixel image(id)
génère un buffer 2D de forces floats.
generate speed pixel image(id)
nbsp;
génère un buffer 2D de vitesses floats.
mass image(id)=m
affecte une amsse.
field image(id)=id2
affecte un champ id2.
Remarques:
Pour changer le centre du champ id2:
meta field poi image(id)=x,y;
Pour changer le coefficient du champ id2:
meta field coe image(id)=c;
spring image(id)=thickness,viscosity
affecte des ressorts sur tous les pixels.
image(id)pixel(np)sin(s)
Remplit l´image id avec une courbe.
Options:
dim(dx,dy): taille de l´image (128,128 par défaut).
pixel(np): nombre de pixels (dimx*dimy par défaut).
screen(r,v,b): efface d´abord l´image avec la couleur (r,v,b).
sin(omega,phi,dt): varie la courbe.
image col
image(id)col
retourne (r,xr,yr, v,xv,yv, b,xb,yb) avec:
r = moyenne du rouge, xr,yr = centre de gravité des pixels rouges.
v = moyenne du vert, xv,yv = centre de gravité des pixels verts.
b = moyenne du bleu, xb,yb = centre de gravité des pixels bleus.
Options:
normal: r,xr,yr, v,xv,yv, b,xb,yb dans [0,1];
image(id)dim(nx,ny)col(r,g,b)
Construit l´image(id) de dimension (nx,ny)
et de couleur (r,g,b).
Génération
La commande image permet de définir une mémoire d´image monochrome de dimension quelconque.
La commande generate image permet de copier une fenêtre de l´image affichée dans
une mémoire d´image.
La commande read image permet de charger dans une mémoire d´image un fichier image.
Des commandes traitements d´image permettent de manipuler des images.
image
image(id)
Construit l´image id noire de dimensions 128 et 128.
Options:
alea(r1,g1,b1,r2,g2,b2): couleurs aléatoires reproductible dans l´intervalle
[r1,g1,b1] X [r2,g2,b2] ([0,0,0] X [1,1,1] par défaut).
center(x,y) center(x,y) (0.5,0.5 par défaut).
coe(c): nx *= c, ny *= c.
col(r,v,b): (r,v,b) couleur.
cube(x,y,z): pour une image 3D image remplit le buffer avec un cube de
couleur r,g,b et de dimensions x,y,z (dimx/2,dimy/2,dimz/2 par défaut).
dim(nx,ny,nz): dimensioned (128,128,1 par défaut).
dim(dimx,dimy,dimz): image 3D.
image(id1,id2)col: copie seulement l'information couleur.
image(id)ini: resrores the image id from its initial value.
image(id)interpol col: construit l´image 3D id de
taille (256,256,25) interpolée entre blanc et noir.
image(id)interpol dim(nx,ny,nz)col(r1,g1,b1,r2,g2,b2): construit l´image 3D id
de taille (nx,ny,nz) interpolée entre (r1,g1,b1) et (r2,g2,b2).
limit: évite les débordement de couleur.
luminance(lum): luminance.
rand(r1,g1,b1,r2,g2,b2): couleurs aléatoires non reproductible dans l´intervalle
[r1,g1,b1] X [r2,g2,b2] ([0,0,0] X [1,1,1] par défaut).
screen(r,g,b): couleur (r,g,b) (noir par défaut).
sin(s1,s2,s3): variation sinusoidale (.01,.01,.01 par défaut).
sphere(r,dr): pour une image 3D remplit le buffer avec une sphère
de couleur r1,g1,b1,r2,g2,b2, de rayon r (0.25 par défaut) et dr motifs
(1 par défaut).
tran(p1,p2,p3): variations des phases (.01,.01,.01 par défaut).
var(t1,t2,t3):variations des temps (.001,.001,.001 par défaut).
rand(r,g,b, p1,p2,p3, t1,t2,t3): aléatoires (.1,.1,.1, .1,.1,.1, .01,.01,.01 par défaut).
with options din(nx,ny,nz>1) construit une image 3D interpolée.
bitmaps.
validate(v): validate image(id)=v (0 par défaut).
Exemples:
screen;for(i=0,.2,.01){image(1)sin(i,i,i);displ image(1);wait(1/25);}
image(1)sin rand dim(256,256,50);screen;displ image(1)bitamp period(1/25);
n=25;c1=.01;c2=.03;c3=.05;dc1=.05/n;dc2=.075/n;dc3=.02/n;
image(1)sin(c1,c2,c3,dc1,dc2,dc3)dim(256,256,50);
screen;displ image(1)bitamp wait(1/25);
image(id1,id2)
Copie l´image id1 dans l´image id2.
Options:
abs: sans redimensionner (si image(id2) existe déjà avec des
dimensions différentes).
acc: Copie l´accélération de
l´image id1 dnas l´image id2.
center(x,y): a href="#center">medallion.
coe(c): coefficient de redimension.
col(r,v,b): (r,v,b) * couleur.
debug(c)debug(g): cré le cube c (bitmapes de l´image
3D id1) et la grille g (plan xy) qui peuvent &ecire;tre vus
(par interaction et clic droit rotxy(eye) ou rotxz(eye) ou tran(eye))
(c=-1 g=-2 par défaut).
dim(nx,ny,nz): redimentionnant l´image id2.
inclu(x,y): write image id1 at point (x,y) of image iud2.
luminance: image(id2)=luminance(image(id1)).
matrix(m): si id1 est une image 3D, l´image
id2 sera l´intersection de l´image id1 avec le
transformé par la matrice m du plan(x,y).
normal: les coordonnées (x1,y1,x2,y2) sont normalisées
(entre 0.0 et 1.0).
poi(x0,y0): l´image id1 est affichée en (x0,y0),
les coordonnées absolues (x1,y1,x2,y2) sont transforméeacute;es en
coordonnées d´image.
radius(rx,ry): a href="#radius">medallion.
rota(an)axis(as,ay,az): tourne le plan xy d´un angle an
autour de l´axe (ax,ay,az).
speed: Copie la vitesse de l´image id1 dans l´image id2.
transf(p): transforme le plan xy par la transformation transf de
parametres p.
transp(t1,t2): medallion.
Exemples: rotx(an, dila(x,y,z), dilx(x), ...
avec toute combinaison de transformations.
Remlarque:
image(0,id) copie l´image courante dans l´ image id
(seulement en mode interaction).
win(x1,y1,x2,y2) copie la fenêtre (x1,y1,x2,y2) de
l´image id1 dans l´image id2.
win(x1,y1,x2,y2,x3,y3,x4,y4)dim(dx2,dy2): copie le polygone
(x1,y1,x2,y2,x3,y3,x4,y4) de l´image id1 dans l´image
id2 de dimension (dx2,dy2).
Remarque: peut être utilisé pour insérer une portion d´image dans
une autre.
Exemple:
display image(1)poi(200,100);
if((m=mouse(0)poi(2))!=NIL)
image(1,2)win(m)poi(200,100);
Quand on clique un cadre dans l´image 1 cette fenêtre sera copiée dnas
l´image 2.
image(id1,id2)adjust
Copie l´image id1 au centre de l´image id2.
Options:
dim(nx,ny):taille de l´image id2 (taille de l´écran
par défaut).
poi(x,y): au point (x,y) de l´image id2.
image(id1,id2)inclu(x,y)
écrit l´image id1 au point (x,y) de l´image id2.
image 2D
Une image de dimension nx,ny peut être une image 3D en ajoutant nz
buffers de pixels RGBA de même dimension.
read image avec l´option:
name("name1 name2 ...")
ou:
name("name")number("4D",num,nb
image 2D
Par défaut une image est un buffer bi dimensionelde pixels RGBA.
image 3D
Une image de dimension nx,ny peut être une image 3D en ajoutant nz
buffers de pixels RGBA de même dimension.
Une telle image peut être générée par:
image(id1,id2,...)image(id0)bitmap
image(id)sin(...)dim(nx,ny,nz)...
peut être lue par:
read image bitmap
être écrite par:
write image(id)name("nnn.ima")
et être concaténée par:
interpol(ni)image(id1)image(id2);
Utilisation:
texture 3D.
animation interactive en temps réel.
image(id1,id2)bitmap(num)
Si l´image id1 est une image 3D de dimensions dx,dy,dz l´image
id2 est construite avec le buffer num (0 <= num < dz) de l´image id1
et retourne secz of image id1.
Options:
dim(dimx,dimy): resizing image id2 to (dimx,dimy).
inv: la couche numéro num de l´image id1 est une copie
de l´image id2.
image(id1,id2,...)image(id0)
si les images idi sont des images 3D de mêe;mes
secx et secy, l´image id0
est construite comme concatenation des images idi.
image(id)bitmap(num)col(r,v,b)
remplit la bitmap numéro num avec la couleur (r,v,b).
image(id1,id2)bitmap poi(p1,p2,p3,p4)
L´image id2 est construite avec l´intersection du polygone
(p1,p2,p3,p4 avec l´image id1 (où pi=xi,yi,zi).
image(id1,id2)bitmap rotx(an)
L´image id2 est construite par l´intersection de la bitmap 0
tournée de an autour de l´axe x avec l´image id1.
image(id1,id2)bitmap roty(an)
L´image id2 est construite par l´intersection de la bitmap 0
tournée de an autour de l´axe y avec l´image id1.
image(id1,id2)bitmap rotz(an)
L´image id2 est construite par l´intersection de la bitmap 0
tournée de an autour de l´axe z avec l´image id1.
Options:
tran(x,y,z): l´image résultante est translatée de (x,y,z).
Coordonnées d´image
(0,0) est le coin bas gauche.
(DX-1,DY-1) est le coin haut droite (où DX,DY sont les dimensions de l´écran
données par dim screen.
Traitement
image adhere
image(id1,id2) adhere col(r1,v1,b1)col(r2,v2,b2)
Remplace les pixels de l´image id2 dont la couleur est comprise entre (r1,v1,b1) et
(r2,v2,b2) par les pixels correspondants de l´image id1.
image(id1,id2) adhere luminance(c1)luminance(c2)
Remplace les pixels de l´image id2 dont la lumunance est comprise entre c1 et c2 par les
pixels correspondants de l´image id1.
image alea
image(id)dim(dx,dy)alea col(r1,v1,b1,r2,v2,b2)
Construit l´image id de dimensions (dx,dy) et de couleurs aléatoires
entre (r1,v1,b1) et (r2,v2,b2).
image frame
frame(x1,y1,x2,y2)image(id)
Trace le cadre (x1,y1,x2,y2) dans l´image id.
Options:
col(r,v,b,a): dans la couleur (r,v,b,a) (1,1,1,0 par défaut).
image center radius transp
center
col
luminance
image(id1,id2)center(x1,y1)radius(rx,ry)
Ecrit le disque elliptique (x1,y1,rx,ry) de l´image id1 sur le disque
(x1,y1,rx,ry) de l´image id2, par défaut le centre ded l´image.
Options:
: sur le disque (x2,y2,rx,ry) de l´image id2
(par dédaut x2=x1 et y2=y1).
law(t1,x1,t1,x2,0,...) permet de contrôler la variation de la transparence selon une
law.
normal: valeurs sont normalisées entre 0 et 1.
radius(rx,ry): par défaut rx=ry=0.5
transp(t1,t2): en variant la transparence de t1 à t2.
Exemples:
image(1,2) center(.5,.5) radius(.5) law(0,0,0,1,0,0)center;
Médaillon circulaire net
image(1,2) center(.25,.25,.75,.75) radius(.5)normal;
Médaillon ellipsoïdal flou
image(1,2)center(.5,.5)radius(.5) law(0,0,0,.5,1,0,1,0,0)normal;
Médaillon en couronne
Par défaut le centre est celui de l´image (0.5,0.5).
image(id1,id2)transp
image(id1,id2)transp
transp col
transp format
transp luminance
image(id1,id2) transp(t)col(r,v,b)
Copie l´image id1 dans l´image id2 en affectant la transparence t aux pixels
de couleur (r,v,b) (t=0 opaque, t = 1 transparent).
Options:
dim(nx,ny): redimensionne l´image à (nx,ny).
col(r1,v1,b1)col(r2,v2,b2): pour les pixels de couleur entre (r1,v1,b1) et (r2,v2,b2).
col(-1): cacule automatiquement r1,v1,b1=image(id)average col et r2=v2=b2=1.
poi(x,y): centre de rotation (x et y normalisés entre 0.0 et 1.0, 0.5 par défaut).
rotz(an): fait tourner l´image de l´angle an autour du point (x,y).
transp(t1)transp(t2): la transparence des pixels dont la couleur est entre (r1,g1,b1) et (r2,g2,b2) devient t1,
la transparence des autres pixels est t2 (0 par défaut).
transp(t1)transp(t2)transp(t3)transp(t4): transparence variant de t3 au centre à t4 au bord
(0 par défaut).
Exemples:
image(1,2)transp(0)transp(1)col(0,0,0)col(.5,.5,.5); extrait les pixels de couleur claire.
image(1,2)transp(0)transp(1)col(.25,.5,.25)col(1,1,1); extrait les pixels de couleur chaude.
image(1,2)transp(1)transp(0)col(.25,.5,.25)col(1,1,1); extrait les pixels de couleur froide.
image(id1,id2)format(f)col(c1,c2)transp(t1,t2)
calcule la transparence des pixels dont la composante c est entre c1 et c2:
t1 + (c - c1) * (t2 - t1) / (c2 - c1).
f="R": red
f="G": green
f="B": blue
Permet de retirer des pixels d´une couleur particulière.
Exemple:
read image(1)name("A0589.bmp")coe(.5);
image(1,2)format("B")col(c1,c2)transp(t1,t1);
screen;displ image(1)poi(0,.1)normal;displ image(2)poi(.5,.1)normal;
image(id1,id2) transp(t)luminance(lum)
Copie l´image id1 dans l´image id2 en affectant la transparence t
aux pixels de luminance lum (t=0 opaque, 1 transparent).
Options:
luminance(lum1,lum2): pour les pixels de luminance entre lum1 et lum2.
lum(-1): cacule automatiquement lum1=image(id)average luminance et lum2=1.
transp(t1,t2): pour les pixels dont la transparence est entre t1 et t2.
Exemples:
image(1,2)transp(0)transp(1)luminance(.5,1); extrait les pixels lumineux.
image(1,2)transp(1)transp(0)luminance(.5,1); extrait les pixels sombres.
Remarque
Pour sauver une image avec transparence utiliser ima or tga
extension.
image cut dim
image(id1,id2)cut dim(x1,y1,x2,y2)
Copie la fenêtre (x1,y1,x2,y2) de l´image id1 dans l´image id2.
Il faut 0 <= x1 < dx1, 0 <= y1 < dy1, 0 <x2 < dx1, 0 <= y2 < dy1
image dim
image(id)dim(nx,ny)
Construit l´image id noire par de dimensions (nx,ny).
Options:
col(r,v,b): les pixels ont la couleur (r,v,b).
col(r1,v1,b1,r2,v2,b2): les pixels ont des couleurs aléatoires
entre (r1,v1,b1) et (r2,v2,b2).
image(id1,id2)dim(nx,ny)
Applique l´image id1 dans l´image id2 de dimensions (dx,dy).
Si l´image id2 éxiste déjà elle est éventuellement
redimensionnée à (dx,dy).
Si id2 est plus grande que id1, elle est lissée par défaut
(sauf si smooth(0) est présent).
Options:
format("f"): précise le format.
inv(1): inverse les luminances.
normal: nx = nx * dimx(id1) ny = ny * dimx(id1)
precision(p): l´image est
seuillée par rapport à p.
Exemples:
image(1,2)dim(200); copie l´image 1 dans l´image 2 de dimensions 200*200.
image(1,1)dim(300,200); redimensionne l´image 1 en 300*200.
image screen
image(id)screen
Efface l´image id avec la couleur du fond.
Options:
screen(r,v,b): dans la couleur (r,v,b).
screen(r,g,b,a): avec la transparence a (0 par défaut).
Extension
L´extension eee d´un nom de fichier image name.eee
décrit dans
The extension eee of image file name.eee described in
format
bmp: format non compressé bitmap de Windows.
flo: format anyflo:
xxxxxx yyyyyy c \n: largeur, hauteur et code (0: non compressé, 1: compressé)
rgba, rgba, ...: pixels RGBA
jpg: format compressé JPEG.
tga: format compressé TGA.
ima: image 3D (secz=nombre de bitmaps).
image format
image(id)format("f")
Retourne la liste des pixels de l´image id selon le format "f".
Remarque:
Pour de grandes images le résultat peut excéder la taille de la pile et donner lieu à une erreur.
Utiliser image(id)pixel(x1,y1,x2,y2) pour extraire une fenêtre.
image(id)format("f")=p
Construit l´image id avec les pixels p selon le format "f".
Options:
dim(nx,ny): l´image aura nx colonnes et ny lignes, il faut alors que:
dim(p) = nx * ny * dimf, avec dimf = nombre d´octets du codage.
image(id)format("f")=p
Charge le buffer de pixels p dans l´image id selon le
format "f".
image(id1,id2)format("f")
Charge l´image id1 dans l´image id2 selon le
format "f".
Options:
var: retourne l´image.
Exemple: image(1,1)format("L"); transforme l´image 1 en son image luminance.
Format
f=L: luminance.
f=R: rouge.
f=G: vert.
f=B: bleu.
f=A: alpha.
f=LA: luminance,alpha.
f=RGB: rouge,vert,bleu.
f=RGBA: rouge,vert,bleu,alpha (valeur par défaut).
image back
image(id)back(rf,vf,bf)col(rc,vc,bc)error(er)
La couleur k de l´image id est modifiée par:
if((er = k - kc) < 0) er = 0.0;
if (er > error) k = kf;
Par défaut kf est la couleur du fond,
kc est la couleur courante et er=0.0.
image generate
generate_format
generate_speed
image(id)generate format("A")
Génère la couche alpha de l´image id:
alpha = 0 si le pixel est noir.
alpha = 1 si le pixel est d´une autre couleur.
image(num)generate format("A")col(r,v,b)
Génère la couche alpha de l´image num:
alpha = 0 si le pixel est de la couleur (r,v,b).
alpha = 1 si le pixel est d´une autre couleur.
image(id)generate format("A")col(r1,v1,b1,r2,v2,b2)
Génère la couche alpha de l´image id:
alpha = 0 si le pixel a une couleur comprise entre (r1,v1,b1) et (r2,v2,b2).
alpha = 1 si le pixel est d´une couleur extérieure.
image genetic
image genetic(id)
Retourne la propriété image de la génétique id
image genetic(id)=idi
Modifie cette propriété.
Remarque
la propiiété pixel sont des pixels aléatoires de
la taille de l´image idi.
la propiiété pixel dup est une copie des pixels
de l´image idi.
Quand la génétique id est reg&eqcute;nérée ces pixels sont proches
des pixel dup selon les notes des particules de cette génétique.
image graphic
Retourne les pixels d´une fenêtre.
Options:
dim(dx,dy): dimensions (15,15 par défaut).
image(id): retourne le résultat dans l´image id (qui est éventuelement
construite ou modifiée).
format("fff"): selon le format.
poi(x,y): coin bas gauche (0,0 par défaut).
EN DÉVELOPPEMENT
image haute definition
Lancer anyflo avec l´option:
anyflo hau=2
L´image en mémoire centrale a 4 fois la taille video. Lors d´un
´write image´, cette image sera convolee a la taille video.
Il sera necessaire de construire les bases de donnees en fonction de
la taille de la mémoire d´image. Par exemple:
d=dim screen;D=.1*d[0]: Fournit une base D independante de l´image
On peut preciser la taille de l´image antialiasée (dimx,dimy) et le
facteur d´antialiasage k:
anyflo x=dimx y=dimy gra=0 mem=1 hau=k
image image
image image add
image(id1,id2,...)image(id0)
Construit id0 = moyenne image(idi).
Options:
add(c1,c2,...): image(id0) = somme(ci * image(idi)).
dim(nx,ny): pour des images de tailles difgférentes, force les sizes à (nx,ny).
limit: évite un débordement des couleurs.
normal: normalise les coefficients ci.
image image average
image(id1,id2,...,idn)image(id0)average(c1,c2,...,cn
id0=sum(idi*ci)/sum(ci) barycenter des images idi avec les coefficients ci.
Exemple:
image(1,2)image(3)avarage(.5,.5); image(3) = moyenne des images 1 et 2.
image image bitmap add
image(id1)bitmap(b1,b2,...)image(id0)
Construit id0 = moyenne bitmap(bi)image(id1).
Options:
add(c1,c2,...): image(id0) = somme(ci * image(idi)).
limit: évite un débordement des couleurs.
normal: normalise les coefficients ci.
image(id1,id2,...,idn)image(id0)bitmap
Réalise une animation des images idi dnas les n bitmaps
de l´ image id0.
image(id1,id2)image(id0)bitmap interpol(ni)
Réalise une animation en interpolant les images idi and id2
sur ni pas et écrivant les résultats dans les bitmaps
de l´image id0 (les images id1 et id2 doivent avoir
les mêmes dimensions).
image(id1)image(id2)coe(c)
Réalise un seuillage: id2 = (id1<c) ? 0 : 1.
image(id1)image(id2)coe(c1,c2)
Fait id2 = abs(c1*(luminance(id1) + c2*(luminance(id2))). Pour c1=1 et c2=-1
on réalise une extraction de contour.
image(id1)image(id2)col("c")
c = R, r: fait image(id2) = composante rouge de l´image (id1).
c = G, g, V, v: fait image(id2) = composante verte de l´image (id1).
c = B, b: fait image(id2) = composante bleue de l´image (id1).
Options:
col(r,g,b): multiplie les couleurs de l´image id1(r,g,b).
dim(nx,ny): en redimensionnant.
b>limit: évite les débordement de couleurs.
image(id1)image(id2)col(r,g,b)
fait image(id2) = r * (composante rouge) + g * (composante verte) b * (composante blueue)
de l´image (id1).
image(id1)image(id2)contour smooth(smo)precision(prec)coe(c1,c2)
Extrait les contours de l´image id1 dans l´image id2
en soustrayant les luminances de l´image id1 et de l´image
id1 lissée à l´ordre smo, puis en seuillant le
résultat dans id2 par rapport à prec, par défaut
prec=0.05, c1=1 et c2=-1.
Les 2 images doivent avoir les mêmes dimensions (si id2
n´existe pas, elle est créée) et som > 1.
Options:
contour("R"):: composante rouge.
contour("V"):: composante verte.
contour("B"):: composante bleue.
contour(r,g,b):: r * rouge, g * vert, b * bleu.
Exemple: image(1,2)contour(.6,.3,.1)smooth(3) precision(.5)coe(1,2);
image(a)image(b)dim texture(d)
Construit la grille -12344 de côté d et de texture a.
Quand la grille est affichéee l´image b est générée
autour d´elle, puis la grille devient invisible.
Options:
image(a1,...,an)image(b1,...,bn)pour n images.
number(num): numéro de la grille (-12344 par défaut).
Remarquee:
Permet de construire des textures de toutes tailles.
yes illum and yes texture
doivent étre actifs.
NE fonctionne qu´en mode interaction.
le bloc texture generate vol(num)=n1,n0
est construit.
image(id1,id2,...)image(id0)interpol coe(c1,c2,...)
Fait image(id0)=somme(ci*image(idi)).
Options:
limit: évite un débordement de couleur..
normal: normalise les ci.
image(id1)image(id2)luminance
Fait image(id2) = luminance image(id1).
Options:
dim(nx,ny): redimensionant.
image(id1,id2,...,idn)image(id0)secx(nx)secy(ny)
Concatène les images idi dans l´image id0 avec nx images en ligne et
ny images en colonne, il doit y avoir exactement n=nx*ny images de mêmes dimensions.
Cette commande permet de générer une image de haute définition à partir de sous images.
image smooth
image(id1)image(id2)smooth(np)
Lisse l´image id1 dans l´image id2 sur une matrice
np * np (np impair, 3 par défaut).
image(id1)image(id2)smooth(mat)
Lisse l´image id1 dans l´image id2 sur la matrice
mat (de dimension impair).
Options:
normal: normalise la matrice mat.
Remarque: Les 2 images doivent avoir les mêmes dimensions, si id2 n´existe pas elle est créée.
image incrustation
image(id1,id2)transp(1)luminance(lum1)luminance(lum2);
displ image(id1,id2);
image line
image line(L)
Modifie l´image courante en rendant transparents les pixels extérieurs à la ligne 3D L.
Options:
adjust: change la taille aux seuls pixels visibles.
format(n): précise la dimension des vecteurs de la ligne L (3 par défaut).
inv: en rendant transparents les pixels intérieurs à la ligne 3D L.
poi(x1,y1): coordonnées du coin bas gauche de l´image id1.
tran(xt,yt): l´image id2 sera translatée de (xt,yt).
Remarques:
1) Il est nécessaire, en mode interaction, de faire
no screen de façon à ce que l´image courante ne soit pas effacée.
2) L´image peut être sauvegardée en mémoire par generate image, restituée par
displ image, et sauvegardée sur le disque par write image name("nnn.eee").
Les options abs et inv sont incompatibles.
image(id1,id2)line(L)
Copie l´image id1 dans l´image id2, les pixels extérieurs à la ligne
étant transparents.
Options:
abs: l´image id2 est recadrée autour de la ligne L.
adjust: change la taille aux seuls pixels visibles.
tran(dx,dy): déplace de (dx,dy) dans l´image id2(0,0 par défaut).
poi(x,y): coordonnées du coin bas gauche de l´image (0,0 par défaut).
Remarques:
1) Il y a erreur si NP(Ligne) < 3.
2) Il est nécessaire que id1 != id2.
image(id1)line(L)brush(id2)poi(x,y)
Si le pinceau id2 est de type image cette commande
construit l´image du pinceau en extrayant, dans l´image id affichée en (x,y), la fenêtre
encadrant la ligne 3D L, les pixels intérieurs à la ligne étant transparents.
Options:
inv: en extrayant les pixels extérieurs.
image limit
image(id)limit col(r1,v1,b1,r2,v2,b2)
Retourne la boite (x1,y1,x2,y2) limitant l´image id dont les pixels
ont une couleur comprise entre (r1,v1,b1) et (r2,v2,b2) (0,0,0,1,1,1 par défaut).
image(n)limit luminance(lum1,lum2)
Retourne la boite (x1,y1,x2,y2) limitant l´image num dont les pixels
ont une luminance comprise entre lum1 et lum2 (0,1 par défaut).
Options:
precision(p): l´image est réduite de p (entre 0 et 1).
normal: la boite retournée est normalisée (entre 0,0 et 1,1).
image rand
image(id)rand
Construit l´image id dim(128,128) de couleurs aléatoires.
Options:
dim(nx,ny): taille nx,ny (128,128 par défaut).
coe(c): image de base de dimension c*(nx,ny).
col(r1,g1,b1,r2,g2,b2) couleurs aléatoires entre r1,g1,b1 et r2,g2,b2.
EN DÉVELOPPEMENT
image read
image read number write number ext format
image read("A")number(i1,i2)write("B")ext("jpg")format("y")
Genere les images B[i2,i2+dimy-1] obtenues en balayant l´animation
A[i1,i1+dimy-1] selon les y
image device(id)dim(dx,dy)=p
Affecte l´image de device(id) avec p et de dimensions dx=dy=sqrt(dim(p)/4).
p doit contenir np=dx*dy quadruplets (r,v,b,a) normalisés entre 0.0 et 1.0.
Options:
dim(dx,dy): il faut que dim(p)=4*dx*dy.
image average
image(id)average(n)
Construit n images noires internes à l´image id.
Si n=0 supprime cette propriété.
image(id)average
Remplace cycliquement une des n images internes de l´image id par
l´image id et la recalcule comme moyenne des n images internes.
Remarque: permet de lisser les changements d´une image.
image(id1,id2)average
Remplace cycliquement une des n images internes de l´image
id1 par l´image id1 et la recalcule, dans l´image id2,
comme moyenne des n images internes.
image(id1,id2,id3)average(a1,a2)
Calcule image(id3) = a1 * image(id1) + a2 * image(id2)
a1 = a2 = 0.5 par défaut.
image(id)average col
Retourne la couleur moyenne de l´image id.
image(id)average luminance
Retourne la luminance moyenne de l´image id.
image(id)average transp
Retourne la transparence moyenne de l´image id (0: opaque, 1: transparente).
image brush
image brush(id1)
Retourne l´identificateur de l´image sur laquelle le pinceauid1
opère.
image brush(id1)=id2
Change cet identificateur.
Remarques:
Pour un pinceau associé &agreve; un
réseau neuronal, ce pinceau
prend ses informations de pixels dans l´image idi
au lieu de l´écran.
Si idi==0: ce pinceau prend ses informations de pixels
dans l´écran (par défaut).
image pixel
image(id)pixel(x1,y1,x2,y2)format("f")=r,g,b,a
Affecte la valeur (r,g,b,a) aux pixels de la fenêtre (x1,y1,x2,y2)
(toute l´image par défaut) de l´image id selon le
format "f" (RGB par défaut), avec:
r = composante rouge, entre 0.0 et 1.0.
g = composante verte, entre 0.0 et 1.0.
r = composante rouge entre 0.0 (transparent) et 1.0 (opaque).
a = transparence, entre 0.0 et 1.0.
/*??? A FAIRE ???*/
image(n)pixel col(r1,v1,b1,r2,v2,b2)
Retourne la liste des points (x,y,...) du contour defini par une couleur comprise entre (r1,g1,b1) et(r2,g2,b2).
image pixel col simple
Retourne le contour simplifié.
image pixel col contour
Retourne le contour ordonné.
image pixel dim
si dim(3) est présent, les datas sont de dimension 3. Exemple:
image(n) pixel dim(3)=x1,y1,0,x2,y2,0,...
image precision
image(id1,id2)precision(p)format("f")
Seuille l´image id1 dans l´image id2 selon le
format "f".
Exemples:
1) image(id1,id2)precision(p)format("L")
Pour chaque pixel:
if(luminance < p)luminance = 0
if(luminance >= p)luminance = 1
2) image(id1,id2)precision(r,v,b)format("RGB")
Pour chaque pixel:
if(r < r1)r =0;if(v < v1)v = 0;if(b < b1)b = 0;
if(r >= r2)r = 1;if(v >= 1)v = v2;if(b >= b2)b = 1;
Options:
inv(1): le seuillage est inversé.
image product
image(id1,id2,id3)product(p)
Fait id3 = p * id1 * id2.
Si id3 est absent, id3=id2.
p=1 par défaut.
Les 3 images doivent avoir les mêmes dimensions.
image(id1,id2,id3) product limit
Evite les débordements pour p > 1.
image segment
image(id)segment(x1,y1,x2,y2)
Ecrit le segment (x1,y1,x2,y2) dans l´image id.
Options:
col(r,v,b,a): dans la couleur (r,v,b,a) (1,1,1,0 par défaut).
image vertex
image vertex vol(id)
Retourne la propriété image vertex du volume id.
image vertex vol(id)=id1
Modifie cette propriété.
Remarque:
L´image id1 est affichée sur chaque sommet du volume id.
Options:
vertex(num): pour ce sommet
image vertex col vol(id)
Retourne la propriété image vertex col vol id.
image vertex col vol(id)=r,g,b
Modifie cette propriété.
Remarque
does: col image(id)*=r,g,b
Options:
=r,g,b,1 couleurs limitées.
image(id1,id2)video
image video
Convole l´image id1 dans l´image id2 de dimensions (768,576).
image speed
image(id1,id2)speed format("f")[var]
Génère la valeur absolue de la vitesse de l´image id1 dans l´image id2 selon le
format "f".
image speed
image(id1,id2)speed
Initialise les pixels de l´image id2 aux valeurs de la
speed de l´image id1.
Options:
speed(c): en multipliant la vitesse par c (1 par défaut).
image luminance
image(id)luminance
Retourne (lum,x,y) avec:
lum = luminance moyenne, x,y = barycentre des pixels de coefficients leur luminance.
Options:
normal: lum,x,y dans [0,1];
image(id)luminance(x1,x2,...,xn)
Construit image(id) luminance(x1,x2,...,xn) de dimension sqrt(n);
Options:
dim(nx,ny): dimension (nx,ny),il faut nx * ny = n.
image(id)luminance(lum)
Construit l´image(id) de luminance(lum).
texture
Pour affecter une image i comme texture à
un volume v, faire:
texture vol(v)=i
generate(2)texture image(i)
image vol
image vol(id)
retourne la propriété image du volume id.
image vol(id)=seq,d,s
change cette propriété.
Remarque:
si interaction image a été
invoqué la texture du volume id
sera automatiquement interpollée entre les images de la séquence
avec seq=ni,im1,im2,i1,i2 et texture number+=s*d (s=1 ou -1).
Pratiquement un capteur peut être connecté
à d.
image vol(id)number(num)
retourne la propriété image number du volume id.
image vol(id)number(num)=t0,seq,ni,cpt
change cette propriété.
Remarque:
t0=texture de départ, seq=numéro de la
séquence cible, ni = nombre d´images interpollées, cpt dans [0,ni-1].
Voir: interaction image vol(id)number(seq)animate(ni).
image(id1)vol(id2)dila(cx,cy,cz)tran(x,y,z)
Réalise une extrusion du volume id2 en dilatant les sommets de k*(cx,cy,cz) et
en les déplaçant de k*(dx,dy,dz), avec k = luminance(pixel).
Voir un exemple dans la fonction func_VOL() du fichier demo1_image.func.
image(id1)vol(id2)force(fx,fy,fz)
Réalise une extrusion du volume id2 en mettant des forces k*(fx,yy,fz) aux sommets
avec k = luminance(pixel).
image(id1)vol(id2)coe(c)col
Réalise l´extrusion en affectant aux sommets du volume id2 les couleurs
des pixels correspondant de l´image.
Il aura fallu faire:
generate col vertex vol(id2) et
illum vol(id2)=2,ref,spe,bri,transp
Voir aussi: