image


traitement des images

image en mémoire
image statique
image dynamique
image
image 2D
image 3D
traitement
propriétés

brush        bitmap
col        coordinates
affichage
génération
image        inclu
luminance
texture
vol
Voir aussi

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
generate image time
dynamique de pixel

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

iamage(id)
iamage(id1,id2)

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].
col(r,v,b): de couleur (r,v,b).
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(dimx,dimy): dimensioned (dimx,dimy) (128,128 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.
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].
screen(r,g,b): couleur (r,g,b) (noir par défaut).
sphere(x,y,z,r): pour une image 3D remplit le buffer avec une sphère de couleur r1,g1,b1,r2,g2,b2, de centre x,y,z (dimx/2,dimy/2,dimz/2 par défaut) et de rayon r ((dimx+dimy)/4 par défaut).

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.
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)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 read image avec l´option:
       name("name1 name2 ...")
ou:
       name("name")number("4D",num,nb

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.
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)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

adhere          add          alea          average
back          brush
center          CG          coe          contour          cut
device          dim          disk          dynamic
extension
format          frame
generate image interpol          generate image time          graphic
haute_définition
image image          incrustation          image(id1,id2)
line          limit
pixel          precision          product
radius          read          rectangle
screen          segment          smooth          speed
transp
video          vol
win

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 add

image(id1,id2,id3) add(v1,v2)

        Fait id3 = v1 * id1 + v2 * id2.
Par défaut v1=v2=1.
Si id3 est absent, id3=id2.
Les 2 images id1 et id2 doivent avoir les mêmes dimensions.

image(id1,id2,id3) add(v1,v2)limit

        Fait id3 = v1 * id1 + v2 * id2 en limitant les couleurs (entre 0 et 255).

image(id1,id2) add(r,g,b)

        Fait id =id1 + (r,g,b).
Options:
limit: évite un débordement des couleurs.

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);
       Médaillon circulaire net
image(1,2) center(.25,.25,.75,.75) radius(.5);
        Médaillon ellipsoïdal flou
image(1,2) radius(.5) law(0,0,0,.5,1,0,1,0,0);
        Médaillon en couronne
Par défaut le centre est celui de l´image (0.5,0.5).

image(id1,id2)transp

transp col
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(.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) 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.

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 cut coe

image(id1,id2)cut coe(cx1,cy1,cx2,cy2)
        Copie la fenêtre (cx1*dx1,cy1*dy1,cx2*dx2,cy2*y2) de l´image id1 dans l´image id2.
Il faut 0 < = c[xy][12] <= 1

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 peut être:
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: format compressé anyflo (EN DEVELOPPEMENT).

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 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

coe
col
contour
luminance
secx secy
smooth

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:
dim(nx,ny): en redimensionnant.

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,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(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).

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

average
average col
average luminance
average transp

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(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(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

Propriétés

Par défaut les images créées ou lues sont invalides c´est à dire cachées. Pour les afficher faire displ image dans une fonction F4 (avant les volumes, donc derrière) ou F5 (après les volumes et donc front).
validate image(id)=1 fait de l´image id un objet affichable, à chaque image, avant les volumes selon ses propriétés.

dila image(id)=r,v,b

Les composantes des couleurs des pixels de l´image id sont multipliées par (r,v,b).

move(x,y)image(id)

Le coin bas gauche de l´image id s´affiche en (x,y).

rotx(an)image(id)

L´image id est périodicisée en x.

roty(an)image(id)

L´image id est périodicisée en y.

tran(x,y)image(id)

L´image id est déplacée de (x,y).

rotz(an)image(id)

L´image id est tournée de l´angle an autour de son centre.
Options:
poi(x,y): autour du point (x,y) (coordonnées normalisées entre 0 et 1).
rotz(an1,an2): définit un vortex (rotation interpolée entre an1 et an2).
Toutes les options de displ image, sauf l´option ini qui est systématiquement validée (c´est à dire que les transformations sont effectuées à partir de l´image initiale).

Voir aussi:

audio image        adjust image        alea image        alex imagelimite        aley image
bitmap
CG image        col image
dila image        dim image        displ image        displ image(id)speed
edit image        exec audio image
field image        frame image
hole image
generate image        generate bitmap image(id).        generate speed image(id).
ini image        interpol image        inv image
limit image        luminance image
module image        morphing image
no image
period image        pixel image
read image        rectangle image        rem image        rotx image        roty image        rotz image
screen image        segment image        sphere image        stock image        symx image        symy image
traj image        tran image        transp image
validate
write image
yes image