Imalab: traitement d'images

Prima Homepage
ImaLab
Generating C++ Modules
User Manual
The Command Shell
Running Imalab
Plugin Process
Pixels and Images
Interactive selection
Graphics: plots, profiles
Image file I/O
Image display
Connectivity Analysis
Image Processing(1)
Gaussian operators
Technical Documentation
Creating New Modules
Tutorial
Tutorial Download

Image Processing Commands

Cette page décrit:

Filtres gaussiens récursifs
Fonctions générales de calcul d'opérateurs.
Détection de lignes dans l'image
Affichages d'opérateurs: profils, courbes, reliefs
Le DOG (difference of gaussians)
Utilisation de la FFT
Les commandes de haut niveau facilitant l'expérimentation.

Les commandes de haut niveau

Une expérimentation intéressante demande toujours l'enchainement de nombreux opérateurs de base et de fonctions d'affichage. Les "commandes de haut niveau" sont des fonctions qui réalisent des enchainements utiles. Elles sont le plus souvent écrites en Scheme, ce qui facilite les variations d´ecriture. La plupart des fonctions ci-après supposent que la fonction image-setupa été appelé au moins 1 fois auparavent. La fonction image-setup(image) calcule d'office plusieurs filtres laplaciens, dans le vecteur mflap, et initialise de nombreux paramètres globaux. Plus d'info sur image-setup.

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


image-setup(49); // on prend ima-vec[49]
mu-affiche-lap(list(2,3,4,5,8),1)

Les fonctions mu-affiche-lap et mu-affiche-grad servent à l'affichage multiple de laplaciens et de gradients.


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

Affiche le laplacien resp. le gradient, 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, grad-fact, grad-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


	// on suppose que image-setup a ete fait
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.


	// on suppose que image-setup a ete fait
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.


	// on suppose que image-setup a ete fait
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. Les arguments sont:

point: point de départ. de la recherche du point initial du contour. Algorithme 1: on cherche à droite; algorithme 2: on cherche dans la direction dir donnée en 2ième argument (entre 0 et 7).
level Le niveau (du laplacien) auquel le contour est défini.
color couleur avec laquelle les points sont affichés. (false indique le défaut, vert ou jaune). L'affichage se fait systématiquement dans l'imagette en position 1, et optionnellement dans l'imagette position lpos.

Les principales fonctions de calcul d'opérateurs

Les filtres gaussiens récursifs (module modfilter)

Ces fonctions ont été programmées selon l'article de ?? par Olivier Chomat et Vincent Colin ... puis corrigées ... les sources se trouvent actuellement dans /net/orion/users/alux/GlobalVision/src/Filter .

Sont disponibles: le filtre Gaussien, les dérivées du filtre Gasussien jusqu'à l'ordre 3, le gradient (module et angle), le laplacien.

Pour la plupart des filtres, il y a plusieurs procédures, avec les prototypes légèrement différents. Par exemple, on peut obtenir le module du gradient avec un seul appel de fonction, mais si on veut le module et l'angle, on peut aussi éviter de calculer les dérivées 2 fois.

Il y a des fonctions qui allouent la place pour leur image-résultat, et des fonctions qui remplissent une image existante, fournie en argument.
Attention!Dans ce cas, les dimensions doivent être justes: sinon, c'est le segmentation fault garanti!

La liste complète des fonctions est longue - en fait, c'est le fichier entier recursiveFilter.hh qui est donnée dans une page séparée qui est facile à comprendre. Nous expliquons ici quelques fonctions importantes.

Les déclarations


TBitmapFloat* FGR_XY(TBitmap&, double, double = -1.0);
TBitmapFloat* FGR_XY2(TBitmapFloat&, double);
void FGR_XY2(TBitmapFloat&, double, TBitmapFloat *);
TBitmapFloat* FGR_XY3(TBitmapFloat&, double);

concernent le filtre Gaussien d'une image (premier argument) avec une valeur de sigma (deuxième argument,l'autre argument double n'est pas pratiqué). Les différents prototypes varient selon la position du résultat: il peut être résultat d'une fonction - dans ce cas l'image est créée par le filtre; et le résultat peut se trouver dans une image passée en paramètre. FGR_XY est la version initiale du programme, FGR_XY2 une deuxième programmation (nettement plus efficace mais non générique), FGR_XY3 une troisième version (voir la différence dans le code).

Les noms des procédures indiquent directement le contenu: "d" signifie "dérivée": FGR_dX est la dérivée en X, etc., et elle existe en trois versions en deux progammations:


TBitmapFloat* FGR_dX(TBitmap&, double, double = -1.0);
void FGR_dX2(TBitmapFloat&, double,TBitmapFloat*);
TBitmapFloat* FGR_dX2(TBitmapFloat&, double);

Les filtres disponibles sont: toutes les dérivées jusqu'à l'ordre 3, puis les fonctions suivantes qui enchainent des calculs de dérivées sous diverses formes:


void FGR_AngleFromDerivatives(TBitmapFloat&, TBitmapFloat&, TBitmapFloat&);
TBitmapFloat* FGR_AngleFromDerivatives(TBitmapFloat&, TBitmapFloat&);
void FGR_Angle(TBitmap&, double, TBitmapFloat&);
TBitmapFloat* FGR_Angle(TBitmap&, double);
void FGR_GradFromDerivatives(TBitmapFloat&, TBitmapFloat&, TBitmapFloat&);
TBitmapFloat* FGR_GradFromDerivatives(TBitmapFloat&, TBitmapFloat&);
void FGR_Grad(TBitmap&, double, TBitmapFloat&);
TBitmapFloat* FGR_Grad(TBitmap&, double);
void FGR_LapFromDerivatives(TBitmapFloat&, TBitmapFloat&, TBitmapFloat&);
TBitmapFloat* FGR_LapFromDerivatives(TBitmapFloat&, TBitmapFloat&);
void FGR_Lap(TBitmap&, double, TBitmapFloat&);
TBitmapFloat* FGR_Lap(TBitmap&, double);

La fonction MultiFilter permet de construire une série d'images filtrées, avec des valeurs de sigma différentes.


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

Cette fonction crée un vecteur d'images filtrées, avec des filtres de type "gaussien", pour différents sigmas. Les sigmas utilisés sont: Sinit* pow (Sfactor, indice) avec les indices: indice-init = init, indice-max = final step = freq.

L'argument f code le type de filtre:


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

Ces constantes sont définies dans imalab.


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

image-setup effectue ce calcul, avec résultat dans voptsig.


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.

calcule dans les étages e=0,1,... de vecdest des "byte-images binaires", c. à d. avec des valeurs 0/1, les pixels qui ont un max (par rapport à sigma) au niveau e.

Fonctions générales de calcul d'opérateurs

Le module modFilter contient aussi quelques fonctions classiques utiles pour une expérimentation (mais nettement moins performantes que les filtres gaussiens décrits ci-dessus).

La fonction ImgFilter permet de calculer des convolutions avec des masques quelconque, définis à la volée.


float GaussX121(TBitmap& src, int x, int y) 
float GaussY121(TBitmap& src, int x, int y) 
void ImgGaussX121(TBitmap& src, TBitmap& dst);
void ImgGaussY121(TBitmap& src, TBitmap& dst);
void ImgGauss3XY(TBitmap& src, TBitmap& tmp, TBitmap& dst);
void ImgGauss3XY(TBitmap& src, TBitmap& tmp)
TBitmap * ImgGauss3XY(TBitmap& src);
double ImgFilterPt(TBitmap& src, TBitmapFloat& filter, int x, int y);
void ImgFilter(TBitmap& src, TBitmapFloat& dst, TBitmapFloat& filter);
TBitmapFloat* ImgFilter (TBitmap& src, TBitmapFloat& filter)

Exemple d'une session - la FFT

Pour ce qui est de la FFT, voir NR + Nicolas

Nouvelle forme simplifiée, affiche l'image et les deux images partieR-partieI de la FFT:


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

Le résultat est la liste (ima-r ima-i ima-complex). ima-complex sert ensuite d'argument à iFFT.


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