Alvasoft.net : Traitement d'image par filtrage

Introduction

Pourquoi le traitement d'image ?

• rendre des images exploitables afin de pouvoir mener à bien des études;
• améliorer le rendu, corriger certains paramètres (contraste, netteté,...).

Algorithme utilisé : filtrage par produit de convolution.

• vaste domaine de possibilités;
• très facilement paramétrable;
• implémentation abordable sous Delphi 7.

Programmé en Pascal sous Delphi 7 :

• environnement de programmation Pascal visuel développé par Borland;
• existe pour différentes plateformes (Windows / Linux);
• dualité code / interface graphique.

Démarche expérimentale

1. Définition des objectifs : applications du filtrage.

2. Documentation

3. Implémentation.

• 2.1 Ouverture et lecture du fichier image source;
• 2.2 Réalisation du filtre adapté aux besoins;
• 2.3 Application du filtre sur la source;
• 2.4 Sauvegarde du fichier image cible;
• 2.5 Gestion d'une interface graphique.

4. Optimisation des points ci-dessus.

Un peu de pseudo-code...

Ouverture d'un fichier :

Procedure Ouvrir();
begin
with bmpform do begin
if OPD.Execute then
 begin
 source.Picture.LoadFromFile(OPD.FileName);
 cible.Picture.Bitmap:=source.Picture.Bitmap ;
 origine.Text:=OPD.FileName;
 end;
end;
end;

Réalisation du filtre :

Type matrice = 
array[0..4,0..4] of integer;

function ConvertMtoT(M:matrice):tableau;

function ConvertTtoM(T:tableau):matrice;

Application du filtre :

Type
    TRGB = Record
           R : integer;
           G : integer;
           B : integer;
           End;

Variables utilisées :

RGB : TRGB;
Indice : integer;          	Indice matriciel
mX, mY, dX, dY : integer; 	Positions de la matrice
D : integer;              	Bord de la matrice : -D à +D
PosX, PosY : integer; 		Position PosX et PosY dans l'image

Et c'est parti...

FOR PosY := Rect.Top TO Rect.Bottom - 1 DO
	FOR PosX := Rect.Left TO Rect.Right - 1 DO
		FOR dY := -D TO D DO
			FOR dX := -D TO D DO
				mY := PosY + dY;
				mX := PosX + dX;

SI(mY>=1) ET (mY<=BMP.Height-1) ET (mX>=1) ET (mX<=BMP.Width-1)
Si le pixel à coefficienter est dans les limites de l'image, 
=> EFFET DE BORD
Alors : RGB.R := BMP.Scanline[mY,mX].RGBTRed;
Sinon : RGB.R := BMP.Scanline[PosY,PosX].RGBTRed;

Linéarisation de (dX,dY) :

Indice := 12 + dY * 5 + dX;

Définition des nouvelles valeurs des composantes RGB en fonction du filtre, multiplication par le coefficient matriciel

New_RGB.R := New_RGB.R + RGB.R * Filter[Indice]; 
New_RGB.R := New_RGB.R DIV Diviseur;

Vérification des limites sur le domaine de définition du type BYTE (entre 0 et 255) => EFFET DE BORD

IF New_RGB.R > 255 THEN New_RGB.R := 255 
ELSE IF New_RGB.R < 0 THEN New_RGB.R := 0;

Ecriture des nouvelles valeurs RGB dans l'image de destination

FinalBMP.Scanline[PosY,PosX].RGBTRed := New_RGB.R;

L'interface graphique

Application : détection de contours

Le filtre Laplacien permet de détecter parfaitement les contours car il évalue les variations d'intensité sur toute la surface à traiter.

Le laplacien : explications

Conclusion

• Facilité d'utilisation
• Performances honorables
• Vastes possibilités
• Optimisations possibles

Télécharger le programme