ImaLab

ImaLab est un environnement d'expérimentation avec des images, notamment avec des images de pollen (imalab/pollen), et un environnement de développement d'applications complexes, comprenant analyse et interprétation.

Nous décrivons quelques fonctionnalités utiles qui commencent à émerger:

• Visualiser les séquences d'images de pollen
• Opérateurs de traitement d'images
• Affichages: profils, courbes, reliefs
• Gestion interactive de points, de lignes, de rectangles

Puis il faut aussi décrire l'environnement de programmation, puisque toute expérimentation passe par l'ajout de nouveaux programmes

• Affichage d'images
• Lecture des images de Nicolas
• Affichage: graphiques
• Affichages avec Gnuplot
• Affichage avec Geomview
• Programmation des opérateurs de traitement d'images
• Impression de pixels

Environnement global

En travaillant avec Imalab, on est toujours en train de regarder une image, une séquence d'images, des résultats d'opérateurs ou autres courbes. Les objets clé de notre expérimentation sont donc l'image courante, souvent aussi une séquence d'images, et la fenêtre d'affichage. La fenêtre a la forme d'une "page" sur laquelle on peut visualiser plusieurs images; ce sont les paramètres screen-cols, screen-lines.

Des variables globales repèrent ces objects-clé: screen est la fenêtre d'affichage, current-image est l'image courante, ima-sequence est la séquence d'images. Bien entendu, ce sont des objets au sens C++; à présent, screen est un TTrueColor24Win, current-image est un TBitmapABGR, ima-sequence est un vecteur Scheme.

Après l'initialisation, un certain nombre de variables globales donnent les informations essentielles sur ces objets:

• current-image current-name l'image courante, son nom (indice dans la séquence courante)
• sequence-name nom de la séquence courante
• sequence-width sequence-height dimensions de l'image courante
• ima-sequence le vecteur d'images de la séquence courante
• seq-dim le nombre d'images, dimension du vecteur
• screen la fenêtre
• screen-width screen-height dimensions de la fenêtre
• screen-cols screen-lines screen-places format de la fenêtre par rapport à la taille de l'image courante. places=cols*lines
• image-dir repertoire courant pour les images
• asthma-images répertoire de base, préfixe tous les répertoires de séquences listés par ls-seq

Initialisation par fichier "mode C++": load-cppfile "name.cpp"

Visualiser les séquences d'images de pollen

Les séquences d'images de pollen se trouvent dans plusieurs répertoires, indiqués par la variable dirlist. A titre d'exemple, voici les commandes pour visualiser une séquence d'olea:

ls-seq "olea"
load-sequence "olea005"
defile 30

La première commande, ls-seq "olea", indique les noms des séquences existants dans le répertoire olea. Ensuite, la deuxième commande load-sequence "olea005" charge en mémoire la séquence choisie, puis la commande defile(d) permet de voir défiler les images de la séquence. Les images de la séquence défilent avec un delai d entre 2 images; d n'est pas calibré: 50 produit un défilement assez lent, 10 est rapide.

Pendant l'exécution de cette fonction, on contrôle le déroulement via le clavier.

• left-arrow/right-arrow commandent le sens du défilement avant-arrière.
• up-arrow/down-arrow accelère/ralentit par un facteur 2
• espace fait basculer entre mode-continu et mode-pas-à-pas.
• q quitte le défilement (l'écran reste tel quel)

En mode pas-à-pas

• left-arrow/right-arrow recule/avance d'une image
• up-arrow/down-arrow recule/avance de 10 images

view-pages(n)

La fonction view-pages() ou view-pages(n) permet de visualiser simultanément plusieurs images consécutives, en affichant screen-cols*screen-lines images dans la fenêtre. n est l'indice de la première image affichée initialement; si n est absent, on reprend la page telle quelle.

L'écran doit au préalable être initialisé avec la commande init-screen(col,lin).

Interaction avec des touches.

• left-arrow/right-arrow reculer/avancer d'une image
• up-arrow/down-arrow reculer/avancer d'une ligne
• page-up/page-down reculer/avancer d'une page
• clic souris affiche des cercles avec la fonction mu-circle (le point va dans point-list)
• q ou espace quit

A faire rapidement: menus popup.

Affichage de plusieurs séquences en "cinéma"

multi-view(sn,s1,s2,i1,i2)sn est le nom d'un pollen (olea, etc.). On fait défiler les images des séquences s1 ... s2 de cette espece; pour chaque séquence on affiche les images i1 .. i2, avec le delai en vigueur.

Opérateurs de traitement d'images

Exemple type: afficher les images du laplacien de l'image courante, avec des filtrages différents, dans la fenêtre à partir de la position 1:

image-setup 49
mu-affiche-lap (list(2,3,4,5,8),1)

La fonction mu-affiche-lap sert à l'affichage multiple de laplaciens.

mu-affiche-lap(i,pos)
mu-affiche-lap(list(i1,i2,...),pos)

Affiche le laplacien, aux niveaux de filtrage i1,... sous forme d'une image à niveaux de gris (vert en négatif, jaune en positif) dans les position pos,pos+1,... de la fenêtre.

Utilise les variables: lap-fact, lap-exp pour normaliser l'affichage;

D-Lap-S(n,pos)
D-Lap-S-ROI(n,x,y)

Affiche le "signe du laplacien" du niveau n en position pos. Affichage ternaire: vert - négatif, jaune - positiv, noir - inférieur à eps.

Affichage du niveau optimal du laplacien

affi-opt(level,pos,color)
affi-opt(list(l1,...),pos,color)
affi-opt-super(list(l1,...,ln),pos,list(color11,...,colorn))

affi-opt affiche dans des positions consécutives.
affi-opt-super superpose les résultats dans une seule image, à la position pos.

Les contours

On définit un contour comme un passage par zéro du laplacien; les contours dépendent du filtrage utilisé pour le calcul du laplacien. Différentes fonctions permettent d'afficher tous les points de contours d'un niveau donné, ou de superposer les contours de plusieurs niveaux avec une image. D'autres fonctions suivent un contour fermé trouvé à partir d'un point de départ.

affi-zcrossings(k,pos)
affi-zcrossings(k,pos,color,n)
affi-zcrossings(list(k1,...),pos [,color,n])

affiche les passages par zéro du niveau k à la position pos, ou pour plusieurs niveaux dans les positions pos,pos+1,... Si les paramètres color et n sont présent, les contours sont superposés avec l'image du laplacien de niveau n; ou, si n=true, avec l'image originale.

affi-zcrossings-super(pos,list(k1,...),list(color1,...))
affi-zcrossings-super(pos,list(k1,...),list(color1,...),n)

superpose les passages par zéro des niveaux k1,... à et les affiche à la position pos. Si le paramètre n est présent, le tout est superposé à l'image du laplacien du niveau n, ou à l'image originale, (comme pour la fonction précédente).

Détection de lignes dans l'image

Ces fonctions servent à expérimenter avec l'algorithme de recherche de contours fermés Ces contours forment toujours le bord d'un 8-connexe défini par un prédicat, comme par ex. "laplacien > eps".

Les noms des fonctions contiennent un b pour border, et une lettre b-y-r pour le prédicat: green, yellow, ridge. b2 désigne le 2ième algorithme.

lap-g-b(point,level,color[,lpos2])
lap-y-b(point,level,color[,lpos2])

lap-g-b2(point,dir,level,color[,lpos2])
lap-y-b2(point,dir,level,color[,lpos2])
lap-r-b2(point,dir,level,color[,lpos2])

Exemple d'utilisation:

lap-g-b(false,8,false,5)  // point saisi a la souris, couleur par defaut
lap-g-b(0,6,"red",5)      // même point d départ
lap-y-b(false,5,"red",4)

Dans cet exemple, lap-g-b(false,8,false,5) affiche un contour fermé défini par le "bord d'une zone verte" du laplacien. (Normalement, on affiche en vert les valeurs négatives). Les pixels affichés sont des pixels de frontière d'une région ayant une valeur du laplacien supérieur au seuil eps.

Paramètres des fonctions. Paramètre point: la recherche du point initial se fait sur la droite du point donné en premier paramètre (voir la fonction get-point pour le gestion des points). Pour l'algorithme b2, la direction de la recherche est donnée par le paramètre dir. Le paramètre level indique le niveau du laplacien. Le paramètre color indique la couleur d'affichage (false indique le défaut, vert ou jaune). l'argument lpos2 est facultatif, il permet d'indiquer une position de l'écran pour un deuxième tracé du contour.

Affichages: profils, courbes, reliefs

Pour l'affichage de courbes, on fait appel à gnuplot. Toutes les fonctions (presque) initialisent gnuplot si cela n'a pas déjà été fait.

Fonctions d'affichages selon un segment de droite, voir saisie d'une ligne. Une première série de fonctions affiche des profils mulitples, selon différents niveaux de filtrage: gradient, gradient normalisé, laplacien, laplacien normalisé,

plot-mu-grad-profile(line,list(level1,...))
plot-mu-ngrad-profile(line,list(level1,...))
plot-mu-lap-profile(line,list(level1,...))
plot-mu-nlap-profile(line,list(level1,...))

Une deuxième série de fonctions affiche des profils simples:

plot-grad-profile(line,level)
plot-angle-profile(line,level)
plot-dir-profile(line,level)

Des fonctions plus anciennes existent, avec un jeu de paramètres plus compliqué, notamment:

multi-gradprof(port,x0,y0,list(i1,i2,...))

Affichage des profils du gradient en un point, pour plusieurs niveaux de filtrage. Le port à utiliser est gnu-port (sauf mise au point).

multi-gradlap(port,x0,y0,list(i1,...))

Mêmes paramètres que la fonction précédente. Affiche le gradient, et le laplacien.

lap-profile(p,port=gnuplot-port)

Affichage du laplacien du point p, en fonction du niveau de filtrage.

Affichage en relief

gnuplot et geomview permettent d'afficher sous forme de relief. Pour essayer, il y a les 2 fonctions, avec des paramètres analogues:

zmesh-rect-float(rectangle,img,e) active geomview pour afficher sous forme de "zmesh" la fenêtre de l'image img définie par rectangle; e est un facteur d'échelle, permettant d'adapter la hauteur du relief.

splot-rect-grid(rectangle,img,e) affiche sous forme d'une une "grille-3D" - un grid au sens de gnuplot - la fenêtre de l'image img définie par rectangle; e est un facteur d'échelle, permettant d'adapter la hauteur du relief.

Ces fonctions initialisent geomview/gnuplot si besoin.

Initialisations

Qu'on veuille étudier une séquence d'images ou une seule image avec ImaLab, il faut savoir que de nombreuses initialisations doivent se faire dans un certain ordre. Grosso modo, il faut d'abord lire une image, ou une séquence; puis créer la fenêtre d'affichage, calculer les images filtrées, et ensuite on pourra tracer des courbes, afficher des graphiques. Il faut aussi lancer gnuplot, geomview, etc. De plus en plus, les initialisations sont faites automatiquement, selon les besoins, mais il est toujours utile de savoir ce qui doit se passer. Par exemple, les programmes ne peuvent pas deviner combien on veut avoir de places sur l'écran - par défaut, l'écran sera ridiculement petit, avec 1 seule place.

On reprend dans ce paragraphe l'ordre usuel des opérations au démarrage de ImaLab.

Lire une séquence

ls-seq "olea" liste les séquences existants dans un répertoire (sous-repertoire de asthma-images), et initialise la variable image-dir. La variable dirlist indique les répertoires qu'on peut lister ainsi. (Alain: en cas de modif, mettre à jour la valeur de dirlist dans le code).

load-sequence "olea001"charge la séquence indiqué, dans le vecteur ima-sequence; le nom est toujours relatif a image-dir. On peut afficher les images pendant le chargement: load-sequence(name,true)

Ensuite, on peut visualiser la séquence avec les fonctions defile et view-pages.

Lors d'une même session avec ImaLab, on peut charger d'autres séquences ultérieurement, avec des dimensions différentes: toutes les structures de données s'adapteront.

Lecture d'une sous-sequence

load-subsequence(nom,i1,i2,visu)Le booléen visu indique si on veut visualiser la séquence pendant le chargement (cela évite d'attendre). La variable globale sequence-step permet de réduire la densité de la séquence, et de ne lire qu'une image sur n; cette variable vaut 1 initialement.

Lecture des images de Nicolas

nd-load-subsequence(nom,i1,i2,visu)Les paramètres sont les mêmes que pour la fonction load-subsequence ci-dessus, mais les images sont prises chez Nicolas, selon ses conventions: le nom - WORK1 par ex. - est le nom d'un repertoire dans nd-ima-path, les images ont pour nom sequence-testiii. La séquence est chargée dans ima-sequence, et peut ensuite être affichée, donnée aux opérateurs, etc. comme toute séquence.

nd-show-subsequence(nom,i1,i2,visu)affiche seulement les images d'une séquence chez Nicolas, selon le gamma et le delai en vigueur. (Si le numéros des images sont difficiles à lire, penser à changer la couleur des graphiques - SetColor).

Initialiser l'image courante

La fonction image-setup effectue "les" calculs standard pour l'image courante, et initialise un certain nombre de variables globales; soit pour une image de la séquence:

image-setup(i)

soit pour l'image current-image qui peut, par exemple, être une image chargée directement; cela évite de s'encombrer avec une séquence si on ne veut pas la visualiser. Dans ce cas, on charge d'abord l'image:

current-image = load-tif("olea010_014");

Le nom de l'image est toujours relatif à la variable image-dir, que l'on peut positionner, par exemple, en appelant ls-seq.

puis on appèle image-setup()

La fonction image-setup initialise les variables suivantes:

• current-image
• i-current indice dans la séquence courante
• ii image courante, format TBitmapFloat
• aux-bmp1 aux-bmp2 auxiliaires TBitmapFloat, même taille
• mfxx mfyy TBitmapFloatVector, dérivées secondes
• mfdx mfdy TBitmapFloatVector, dérivées premières
• mflap TBitmapFloatVector, laplaciens
• vsigma TFloatVector, les sigmas utilisés
• voptsig TBitmapByteVector, niveau sigma optimal
• imaf TBitmapABGR image de manoeuvre

Les calculs de filtres multi-échelles se font avec les paramètres

• nb-levels nombre de niveaux
• sigma-init sigma-factor sigma initial, facteur multiplicatif

et la fonction MultiFilter dans libFilter (module modFilter, fichier Filter2.cc)

Affichage d'images

Les fonctions d'affichage d'images sont nombreuses, voici les plus utiles:

affiche1() affiche l'image courante, c.à d. l'image current-image. La fonction affiche1 tient compte de la valeur de la variable globale gamma.

affiche1(i) affiche la i-ième image de la séquence courante.

affiche-pos(ima,place,s) affiche une image ima à la place indiquée sur l'écran; place a une valuer entre 0 et screen-places, pour la 1ière, 2ième, ... place dans la fenêtre. La chaîne s (string) est affichée avec l'image, dans la couleur courante de l'écran (qu'on peut changer avec to-screen(SetColor "couleur")).

show-tif(filename) charge une image dans current-image et l'affiche.

La correction gamma

Plusieurs fonctions - notamment defile, view-pages, affiche1, afficheixy - tiennent compte de la correction gamma; gamma est le nom d'une variable globale, on peut donc le changer à tout moment.

affiche-gamma(i1,i2,p,g) affiche les images de la séquence courante, indices i1 à i2, avec un gamma g donné en paramètre, à partir de la place p de l'écran. Cela permet l'affichage aisée d'une ou plusieurs images avec des correctons différentes.

D'autres fonctions d'affichage d'images

affiche-abgr(im)
affiche-abgr(im,c,l)  (c,l) colonne,ligne dans la fenêtre
affiche-abgr(im,c,l,s)  s string affiché dans le coin SG
affiche-float(im,pos,e[,s])  image,position,échelle, string facultatif
affiche-floatxy(im,x,y,e[,s])  permet d'afficher en tout x,y
mu-affiche-float(vec,k,p)   k indice oulist d'indices, position p
affiche1()
affiche1(i)  i indice la la séquence courante
afficheixy(i,x0,y0)  i indice!
affiche-pos(im,pos,s)  pos position dans la fenêtre

Méthodes de base pour l'affichage

Toutes les fonctions d'affichage fon appel à une méthode de la classe TTrueColor24Win dont l'écran screen est une instance (c'est facile à comprendre dans le code Scheme). Les méthodes existantes dans le code C++ prévoient des possibilités qui ne sont pas exploitées actuellement, comme l'affichage de sous-images, ou la copie de l'écran pour écriture dans un fichier. Ces méthodes sont:

  void DisplayImage(void);
  void DisplayImage(unsigned char *);
  void DisplayImage(unsigned char *,int w,int h);
  void DisplayImage(unsigned char* data,int dst_x,int dst_y,int w,int h);
  void DisplayImage(XImage *,int src_x,int src_y,int dst_x,int dst_y,
		    int w,int h);
  // copy of complete ximage
  bool MakeCopy(int,int);  // border width
  XImage* GetCopy();
  void DisplayCopy();

Voir le code dans /net/orion/users/alux/GlobalVision/src/X11Win

Gestion interactive de points, de lignes, de rectangles

On effectue très souvent plusieurs analyses concernant un point précis dans l'image, ou un segment de droite, ou un rectangle. Ces entités sont le plus souvent saisies à l'aide de la souris, puis réutilisées. Pour simplifier ce type de gestion, les points saisis avec la souris sont stockés dans une liste point-list, les lignes dans la variable line-list, les rectangles dans rectangle-list.

Un exemple d'utilisation: une fonction qui prend comme argument une ligne, comme plot-mu-lap-profile; un premier appel, avec une ligne false, provoque la saisie avec la souris. Lors des appels suivants, on désigne cette même ligne pour le nombre 0. Pour connaitre le numero d'un point "plus ancien", il suffit de regarder la point-list et de repérer son indexe.

plot-mu-lap-profile(false,list(2,4,5))
plot-mu-lap-profile(0,list(2,5,6))

Tout argument nommé point, line, rectangle dans cette documentation fonctionne selon ce principe. Les fonctions en question, comme par exemple plot-mu-plot, mu-circle, font pour cela appel aux fonctions get-point, get-line, get-rectangle, resp.

La fonction get-point permet d'obtenir les coordonnées d'un point. Sans argument, ce point est défini par un clic-souris. Ces coordonnées sont toujours relatives à l'image, cad. acquises modulo sequence-width et sequence-height.

get-point()   active la souris pour un clic, ajoute le point a point-list
get-point(n)  recupère le n-ième point dans point-list (0 pour le plus récent)
get-point(x,y)  inutile en interactif. Résultat: (x . y)
get-point cons(x,y)

Les fonctions get-line et get-rectangle sont analogues.

get-line(#f)   active la souris, ajoute a line-list
get-line(n)    recupère la n-ième ligne

Bien entendu, on peut également garder des points dans des variables:

p2=get-point false
p3=list-ref(point-list,5)
lap-profile p3

Fonctions pour affichages graphiques

La fonction mu-circle affiche un cercle dans chacune des places dans la fenêtre, au même endroit.

mu-circle()  point défini par un clic, dans n'importe quelle image
mu-circle(x,y)

La macro to-screen permet d'envoyer des commandes à la fenêtre. Chaque argument est un appel de méthode, écrit comme un appel de fonction.

to-screen Raise
to-screen(DrawRectangle(100,100,10,20),DrawLine(30,50,150,56))

ceci est strictement équivalent à:

screen.Raise()
screen.DrawRectangle(100,100,10,20)
screen.DrawLine(30,50,150,56))
screen.Flush()

Les commandes qu'on peut envoyer à l'écran sont (voir les méthodes de la classe TTrueColor24Win (GlobalVision/src/X11Win/UTrueColor24Win.hh). Elles correspondent directement à des fonctions X; par exemple, la commande DrawString appèle la fonction XDrawString documentée dans le Xlib Reference Manual (p.166).

  void DrawPoint(int x1, int y1);
  void DrawCross(int x1, int y1, int s);
  void DrawLine(int x1, int y1, int x2, int y2);
  void DrawRectangle(int x1, int y1, int w, int h);
  void FillRectangle(int x1, int y1, int x2, int y2);
  void DrawArc(int x1, int y1, int w, int h,int a1,int a2);
  void DrawEllipse(int x1, int y1, int w, int h);
  void DrawCircle(int x1, int y1, int r);
  void DrawString (const char * st, int x, int y);
  void DrawImageString (const char * st, int x, int y);
  int SetForeground(char* color);
  int SetForeground(int color_code);
  int SetColor(char* color);   // synonyme for SetForeground
  int SetForeground(int r, int g, int b);
  void SetBackground(char* color);
  void SetBackground(int r,int g,int b);
  void SetWindowBackground(char* color);
  void SetWindowBackground(int r,int g,int b);
  int SetFunction (int);   // cf. Xlib Programming Manual, p.120
  void Lower();
  void Raise();
  void ClearWindow();
  void ClearArea(int x,int y,int w,int h);

Affichages avec Gnuplot

Fonctions

init-gnuplot()
to-gnu(string)  écrit dans gnuplot-port, ajoute fin de ligne
q-gnuplot()     pour terminer gnuplot

La fonction init-gnuplot crée un pipe Unix vers gnuplot; ce pipe correspond au port-ravi gnuplot-port. En écrivant dans ce port, toute fonction peut commander gnuplot. La fonction to-gnu facilite l'envoi d'une commande courte; cette fonction envoie son argument,puis ajoute une fin de ligne et un flush.

La fonction init-gnuplot est appelé automatiquement par les fonctions "splot-..." décrites ci-après, on n'a donc pas à s'en soucier. Le gnuplot-port est fermé automatiquement à la sortie de imalab.

Possibilités d'affichage:

splot-grid(port,img,x0,y0,l,e) affiche une grille 3-D (grid) représentant le relief d'une fenêtre carrée de l'image img. La fenêtre a pour point supérieur gauche (x0,y0) et le coté l; e est un facteur d'échelle, pour adapter l'allure du relief. Le port sera gnuplot-port; utiliser *scstdout* pour voir ce qui est envoyé à gnuplot. Cette fonction est analogue à la fonction zmesh-float (voir le paragraphe ci-après sur geomview).

Exemple: laplacien d'une imagette

splot-grid(gnuplot-port,mflap[4],60,80,20,20)

Commandes gnuplot utiles à connaitre

set terminal x11 1
      permet d'utiliser plusieurs fenêtres
set data style linespoints
            ou lines points impulses dots steps fsteps histeps boxes financebars
               candlesticks vector

Pour plus de détail voir la brochure Gnuplot, version 3.7

Affichage avec Geomview

La situation est parfaitement analogue à celle de gnuplot. Notamment, le fonctions init-geomwview, q-geomview sont appelées automatiquement selon besoin.

init-geomview()       ouvre le port geom-port
to-geomview(string)   écrit dans geom-port, ajoute fin de ligne + flush
q-geomview()          pour terminer geomview

Possibilités d'affichage:

Il y a plusieurs fonctions avec des paramètres plus ou moins identiques (même prototype pour les fonctions).

zmesh-rect-float(rectangle,img,e) affiche sous forme de "zmesh" (relief quadrillé) la fenêtre de l'image img définie par rectangle; e est un facteur d'échelle, permettant d'adapter la hauteur du relief.

zmesh-float(port,img,x0,y0,w,h,e) affiche sous forme de "zmesh" (relief quadrillé) une fenêtre de l'image img. La fenêtre a pour point supérieur gauche (x0,y0), largeur w, hauteur h; e est un facteur d'échelle, permettant d'adapter l'allure du relief. Le port sera geom-port, sauf mise au point.

zmesh-byte(port,img,x0,y0,l,c) affiche de facon analogue le canal c d'un bitmap possedant des canaux (méthode GetPixelByte à 3 arguments).

Inspection de pixels

pixrect(bmp,x0,y0,w,h,[ch]) affiche au terminal les pixels d'une imagette de bmp. L'argument optionnel ch permet d'indiquer un canal: 1-2-3 pour g-b-r. Sans l'argument canal, l'impression se fait en flottant.

print-rectangle(rect,bmp[,ch])effectue la m^me opération pour un rectangle au sens du

Dans: Filter/recursiveFilter2.cc
TBitmapFloatVector* MultiFilter(filterType f, TBitmapFloat& bmp, 
				float Sinit, float Sfactor, long nb,
				long freq=1, long init=0, long final=-1);

typedef enum {kGaussian, kDx, kDy, kDxx, kDxy, kDyy, kDxxx,
	      kDxxy, kDxyy, kDyyy} filterType;

Dans Filter/Scale.hh
void MaxSigmaBitmaps(TBitmapFloatVector& veclap,TBitmapByteVector& vecdst,
		     float Sinit,float Sfactor,long nb,float eps);

affi-opt(k,p,couleur="yellow")  affiche les pixels d'un niveau de voptsig
affi-opt-super(p,list(i1,i2,...),list(c1,c2,...) superpose en p
                               les niveaux i, avec les couleurs correspondantes.

(define mfg (MultiFilter kGaussian ii sigma-init sigma-factor nb-levels 1 0 -1))

mu-affiche-dog(mfg,k, p,ll="yellow")
Pondération à l'affichage: dog-factor / Energy.
k est un indice ou une liste d'indices, p la position d'affichage

init-fft dim    // dim=256 probablement
ff1=show-fft ima
inverse caddr ff1

ravi -mod c++
require imalab
   // on prend une image
ls-seq "poaceae2"
current-image= load-tif "poaceae020/poaceae020_050"
  // extraction d'une image de dimension convenable
i256=current-image.Extract(108,86,256,true)
ii= new TBitmapFloat i256   // conversion en float
i256.Convert(ii)
cc=FloatToComplex ii        // construction d'un vecteur complexe
FFT(cc,256)                 // l'appel fatidique
real=ComplexToFloat(cc,0,256,256) // image partie réelle
compx=ComplexToFloat(cc,1,256,256)
  // puis on affiche tous les morceaux
pixrect(real,20,30,5,2)   // affichage carac sur l'écran
init-screen(2,2)
affiche-floatxy(ii,0,0,1,"l'image")
affiche-floatxy(real,256,0,0.0001,"FFT partie R")  // facteur échelle à essayer
affiche-floatxy(real,256,0,ii.Energy() / real.Energy(),"FFT partie R")
affiche-floatxy(compx,256,256,0.0001,"FFT partie I")
affiche-floatxy(compx,256,256,ii.Energy() / compx.Energy(),"FFT partie I")
  // puis la transformée inverse
iFFT(cc,256)
imabis=ComplexToFloat(cc,0,256,256)
affiche-floatxy(imabis,0,256,ii.Energy() /imabis.Energy(), "image retrouvé")
wipe(vec,dim,k)
  // pour effacer le centre de la donnee complexe,
qui correspond au sous-tableau vec[m-k..m+k,m--k..m+k] avec m=dim/2