Images : filtres d'accentuation

Soyez le premier à donner votre avis sur cette source.

Vue 16 563 fois - Téléchargée 883 fois

Description

Il s'agit de filtres dit de convolutions (on applique une matrice à chaque pixel de l'image).
Parmi ces filtres, il existe une population de filtres linéaires qui permettent de réhausser
les contours de zones dans l'image.

Voici un exemple de matrice appliqué au pixel
-1 | -2 | -1
-2 | 16 | -2
-1 | -2 | -1

Grâce à cet technique, les images pas très nets en votre possession peuvent être corrigées.

Source / Exemple :


//matrice pour les filtres de convolutions
		private struct matrice
		{
			internal int [] tableau;
			internal int facteur;
			internal int offset;
		}

		public static void Accentuation(Bitmap bitmap)
		{
			matrice m;
			m.tableau = new int[] {-1,-2,-1,-2,16,-2,-1,-2,-1};
			m.facteur = 4;
			m.offset = 0;

			CalculMatrice(bitmap,m,1);
		}

		public static void AccentuationPlusForte(Bitmap bitmap)
		{
			matrice m;
			m.tableau = new int[] {-1,-1,-1,-1,-1,-1,-2,-4,-2,-1,-2,-4,48,-4,-2,-1,-2,-4,-2,-1,-1,-1,-1,-1,-1};
			m.facteur = 6;
			m.offset = 0;

			CalculMatrice(bitmap,m,2);
		}

		private static void CalculMatrice(Bitmap bitmap, matrice m,int n)
		{
			//on crée un bord de n pixel sur l'image avec effet mirroir
			Bitmap imagecloned = CreateBitmapWithMirrorForN(bitmap,n);

			//on détermine la taille de la matrice
			int tailletab = (int)Math.Pow((2*n)+1,2);
			
			//les valeurs de la matrice
			int [] tableau = new int[m.tableau.Length];
			tableau = m.tableau;
			int facteur = m.facteur;//division
			int moffset = m.offset;//ajout

			int widthcloned = imagecloned.Width;
			int heightcloned = imagecloned.Height;
			int width = bitmap.Width;
			int height = bitmap.Height;

			unsafe
			{
				BitmapData bmpData=bitmap.LockBits(new Rectangle(0,0,width,height),ImageLockMode.ReadWrite,PixelFormat.Format24bppRgb);
				BitmapData bmpDatacloned=imagecloned.LockBits(new Rectangle(0,0,widthcloned,heightcloned),ImageLockMode.ReadWrite,PixelFormat.Format24bppRgb);
			
				byte * newPixel = (byte*)(void *)bmpData.Scan0;
				byte * mPixel = (byte *)(void *)bmpDatacloned.Scan0;

				int red = 0;
				int blue = 0;
				int green = 0;
				int indice = 0;//indice pour le tableau

				//largeur de numérisation
				int stridecloned = bmpDatacloned.Stride;
				int stride = bmpData.Stride;
			
				//offsets
				int offsetcloned = widthcloned % 4;
				int offset = width % 4;

				mPixel+=(stridecloned*n)+(3*n);//on positionne en n par n

				for (int y = n; y < (heightcloned -n); y++)
				{
					for (int x = n; x < (widthcloned - n); x++)
					{
						red = 0;
						green = 0;
						blue = 0;

						//parcours de chaque éléments de la matrice
						for (int k=-n; k<n+1; k++)
							for (int l=-n; l<n+1; l++)
							{
								indice = (l+n)*(2*n+1)+(k+n);//où on se trouve dans la matrice
								int loc = (k*3)+(l*stridecloned);//localisation du pixel
								//on applique la matrice
								red = (red + ( mPixel[loc] * tableau[indice]));
								green = (green + ( mPixel[loc+1] * tableau[indice]));
								blue = (blue + ( mPixel[loc+2] * tableau[indice]));
							}
						red = ((red / facteur)+moffset);
						blue = ((blue / facteur)+moffset);
						green = ((green / facteur)+moffset);

						//bornage
						red = (red < 0) ? 0 : (red > 255) ? 255 : red;
						blue = (blue < 0) ? 0 : (blue > 255) ? 255 : blue;
						green = (green < 0) ? 0 : (green > 255) ? 255 : green;
						
						newPixel[0] =  (byte) red ;
						newPixel[1] = (byte)green;
						newPixel[2] = (byte)blue;
					
						newPixel+=3;
						mPixel+=3;
					}				
					newPixel+=offset;
					mPixel+=offsetcloned+(2*n*3);
				}
				bitmap.UnlockBits(bmpData);
				imagecloned.UnlockBits(bmpDatacloned);
			}
			imagecloned.Dispose();
		}

		/// <summary>
		/// Permet de renvoyer une image avec un bord n 
		/// dont ce dernier est le miroir du bord de l'image initiale.
		/// Cette image sert dans le cas d'application de matrice 2*n +1
		/// </summary>
		/// <param name="n">correspond à la bordure supplémentaire en pixel.</param>
		/// <returns></returns>
		public static Bitmap CreateBitmapWithMirrorForN(Bitmap bitmap, int n)
		{
			Bitmap bitmapWithMirror = new Bitmap(bitmap.Width+(n*2),bitmap.Height+(n*2));
			
			//copie de l'image au centre de la nouvelle
			Graphics g = Graphics.FromImage(bitmapWithMirror);
			g.DrawImage(bitmap,n,n,bitmap.Width,bitmap.Height);
			g.Dispose();

			//on va copier les lignes manquantes (recopie des lignes Nord, Sud, Ouest, Est de l'image)
			int width = bitmap.Width;
			int height = bitmap.Height;
			int heightcloned = bitmapWithMirror.Height;
			int widthcloned = bitmapWithMirror.Width;

			unsafe
			{
				BitmapData bmpDatacloned=bitmapWithMirror.LockBits(new Rectangle(0,0,widthcloned,heightcloned),ImageLockMode.ReadWrite,PixelFormat.Format24bppRgb);
				
				byte * newPixel = (byte *)(void *)bmpDatacloned.Scan0;

				//largeur de numérisation
				int stridecloned = bmpDatacloned.Stride;
				int newloc = 0;//localisation des nouveaux pixels ajoutés
				int loc = 0;//localisation des pixels servant à créer le mirroir
				

				for (int i = 1; i<=n;++i)
					for(int x=0;x<width;++x)
					{
						//rangee Nord
						newloc = ((x+n)*3)+((i-1)*stridecloned);
						loc = ((x+n)*3)+((2*n-i+1)*stridecloned);
						newPixel[newloc]= newPixel[loc];
						newPixel[newloc+1]= newPixel[loc+1];
						newPixel[newloc+2]= newPixel[loc+2];
						
						//rangee Sud
						newloc = ((x+n)*3)+((heightcloned-i)*stridecloned);
						loc = ((x+n)*3)+((heightcloned -(2*n-i+1))*stridecloned);
						newPixel[newloc]= newPixel[loc];
						newPixel[newloc+1]= newPixel[loc+1];
						newPixel[newloc+2]= newPixel[loc+2];
					}	
				for (int i=1; i<=n ; ++i)
				{
					
					for(int y=0;y<heightcloned;++y)
					{
						//rangee Ouest
						newloc = ((n-i)*3)+(y*stridecloned);
						loc = ((n+i-1)*3)+ (y*stridecloned);
						newPixel[newloc]= newPixel[loc];
						newPixel[newloc+1]= newPixel[loc+1];
						newPixel[newloc+2]= newPixel[loc+2];

						//rangee Est
						newloc = ((widthcloned-(n-i+1))*3)+(y*stridecloned);
						loc = ((widthcloned-(n+i))*3)+ (y*stridecloned);
						newPixel[newloc]= newPixel[loc];
						newPixel[newloc+1]= newPixel[loc+1];
						newPixel[newloc+2]= newPixel[loc+2];
					}
				}
				bitmapWithMirror.UnlockBits(bmpDatacloned);
			}
			//l'image renvoyee peut être exploitee via des matrices (2*n)+1 X (2*n)+1
			//pas de réduction donc de la taille initiale pour l'image traitée.
			//Une copie en miroir évite les effets de bords
			return bitmapWithMirror;
		}

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
341
Date d'inscription
mercredi 8 juin 2005
Statut
Membre
Dernière intervention
10 février 2009
2
Source parfaite merci
Messages postés
25
Date d'inscription
lundi 25 avril 2005
Statut
Membre
Dernière intervention
27 juillet 2005

lol ben je t'ai embété pour rien.
j'ai appliqué la méthode puis raffraichi l'image de mon picturebox...
Ca marche mais mon image et carrément plsu dégueulasse!
j'ai traité un screenshot et une image de "lena" (c une gonzesse lol) et ds les deux cas l'original est 1000 fois mieux.
Bref merci a toi de m'avoir repondu et aidé.
++ encore merci de ton attention pour un jeuen C sharpiste ;)
Messages postés
25
Date d'inscription
lundi 25 avril 2005
Statut
Membre
Dernière intervention
27 juillet 2005

ben je n'y parviens pas.
laquelle bitmap est mon image retouchée?
imagecloned?

j'ai vraiment du mal à cerner le fonctionnement.
Pour enregister l'image il faut bien que je l'ai!!! hors la comme la classe renvoi rien ben je fais comment.
de plus comment sauvé? pas question de rajouter un savedialog car c une classe!et dans mon composant ben jpe sauvé...masi koi ta classe me renvoi rien.

je passe un bitmap en paramètre.ta classe la traite et apres'ej le retrouve ou cette image avec le filtre appliqué?C imagecloned?
ta classe ne modifie pas l'image directement ds la pictureBox?sinon on verrai la différence.dc je dois raffraichir mon image avec celle traité par ta classe, mais elle se trouve ou?

dsl te t'embéter mais ya un truc que je saisis pas la. ;)
Messages postés
25
Date d'inscription
lundi 25 avril 2005
Statut
Membre
Dernière intervention
27 juillet 2005

oki merci @ toi
++
Messages postés
9
Date d'inscription
mercredi 5 janvier 2005
Statut
Modérateur
Dernière intervention
19 décembre 2007

Bonjour,

Tu lui passes une référence de Bitmap. Une fois appliquée le filtre (qui ne renvoie rien), tu te sers à nouveau de ta référence, tout simplement.

Si tu as pris ta référence de ta PictureBox, ce contrôle ne va pas se rafraichir sans rien faire.

Pour t'en persuader, enregistre la bitmap sur le disque, tu verras que celle-ci a bien été modifiée.

++
Tkfe
Afficher les 6 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.