IMAGES : LE FILTRE MÉDIAN

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