Commentçamarche.net
CodeS-SourceS
Rechercher un code, un tuto, une réponse

Images : le filtre médian

Soyez le premier à donner votre avis sur cette source.

Vue 17 885 fois - Téléchargée 910 fois


Description

Le filtre Médian est utilisé en traitement d'images pour palier aux anomalies lors d'une capture d'image.
Si vous avez un vieux scanner, sur vos images peuvent apparaître des pixels n'appartenant pas à celles-ci.

Source / Exemple :


using System;
using System.Drawing;
using System.Drawing.Imaging;

namespace Traitimage.Bitmaps.Traitements
{
	
	public class FormatImage24 
	{
		
		public static void Median(Bitmap bitmap, 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);
			
			int tailletabdemi = tailletab/2;
			//tableaux contenant les pixels contenus dans la matrice
			byte [] tabred = new byte[tailletab];
			byte [] tabgreen = new byte[tailletab];
			byte [] tabblue = new byte[tailletab];

			//Taille de l'image avec le bord en mirroir
			int widthcloned = imagecloned.Width;
			int heightcloned = imagecloned.Height;

			//Taille de l'image à traiter
			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 indice = 0;//indice pour tableaux
				int loc = 0;//localisation du pixel

				//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++)
					{
						//récupération des pixels 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);
								loc = (k*3)+(l*stridecloned);
								tabred[indice]= mPixel[loc];
								tabgreen[indice]= mPixel[loc+1];
								tabblue[indice]= mPixel[loc+2];
							}
						//tri (on prend le median)
						newPixel[0] = quick_select(tabred,tailletab);
						newPixel[1] = quick_select(tabgreen,tailletab);
						newPixel[2] = quick_select(tabblue,tailletab);
						newPixel+=3;
						mPixel+=3;
					}				
					newPixel+=offset;
					mPixel+=offsetcloned+(2*n*3);
				}
				bitmap.UnlockBits(bmpData);
				imagecloned.UnlockBits(bmpDatacloned);
			}
			imagecloned.Dispose();
		}

		private static byte quick_select(byte[] tab, int n)
		{
			int min, max ; //pointeur sur le min et le max en cours
			int median;
			int m, l, h; //milieu, petit, haut
			min = 0 ;
			max = n-1 ;
			median = (min + max) / 2;
			for (;;) 
			{
				if (max <= min) // 1 seul élément, plus besoin de trier, on renvoie le median
					return tab[median] ;
				if (max == min + 1) // plus que 2 éléments (on trie et on renvoie le median)
				{ 
					if (tab[min] > tab[max])
						inversion(ref tab[min], ref tab[max]) ; //on inverse
					return tab[median] ;
				}
				//on trie les élements min, milieu et max
				m = (min + max) / 2;
				if (tab[m] > tab[max]) inversion(ref tab[m], ref tab[max]) ;
				if (tab[min] > tab[max]) inversion(ref tab[min], ref tab[max]) ;
				if (tab[m] > tab[min]) inversion(ref tab[m], ref tab[min]) ;
				//on inverse le nouveau milieu avec le min+1
				inversion(ref tab[m], ref tab[min+1]) ;
				//on va inverser les elements dans la tranche en cours
				l = min + 1;
				h = max;
				for (;;) 
				{
					do l++; while (tab[min] > tab[l]) ;
					do h--; while (tab[h] > tab[min]) ;
					if (h < l)
						break;
					inversion(ref tab[l], ref tab[h]) ;
				}
				//on mets le milieu en position min à sa bonne place
				inversion(ref tab[min], ref tab[h]) ;
				//on réajuste les pointeurs min et max
				if (h <= median)
					min = l;
				if (h >= median)
					max = h - 1;
			}
		}

		private static void inversion(ref byte a,ref byte  b) 
		{
			byte t=a;
			a=b;
			b=t;
		}

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

Votre évaluation

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.