TRAITEMENT D'IMAGE EN NOIR ET BLANC

        //Structure de manipulation de tableaux RGB
    public struct RGBPix
    {
        public byte R;
        public byte G;
        public byte B;
    }

    //Classe de manipulation et conversion d'image en noir et blanc
    public class FaxImage
    {

        //Petite enumération des différent algo gérer par la classe
        public enum BWAlgorithme
        {
            Floyd,
            Haltone,
            Random
        }
        //Immage d'origine
        private Bitmap _OriginalImg = null;
        //Pointer ver un tableau de byte contenant les données en niveaux de gris
        private IntPtr _GreyDat = IntPtr.Zero;
        //Image finale
        private Bitmap _BWImg = null;

        //variable de configuration internes
        private BWAlgorithme _DitherAlgo = BWAlgorithme.Floyd;
        private sbyte _Luminosity = 0;
        private int _Height = 0;
        private int _Width = 0;

        //Constructeur On lui passe l'image d'origine, et la taille finale souhaiter
        public FaxImage(System.Drawing.Bitmap Img,int Width,int Height)
        {
            this.Width = Width;
            this.Height = Height;
            this._OriginalImg = Img;
        }

        //Métode pour changer d'image d'origine
        public void SetImage(Bitmap Image)
        {
            this._OriginalImg = Image;
            if (this._GreyDat != IntPtr.Zero)
            {
                System.Runtime.InteropServices.Marshal.FreeHGlobal(this._GreyDat);
                this._GreyDat = IntPtr.Zero;
            }
        }

        //Propriété pour récupérer l'image en noir et blanc
        public System.Drawing.Bitmap BWImage
        {
            get
            {
                //On recalcul l'image en niveau de gris si besoin.
                if (this._GreyDat == IntPtr.Zero)
                    Make_GrayDat();
                //On recalcul l'image noir et blanc si besoin
                if (_BWImg==null)
                    switch (this._DitherAlgo)
                    {
                        case BWAlgorithme.Floyd:
                            Make_BWDat_Floyd();
                            break;
                        case BWAlgorithme.Haltone:
                            Make_BWDat_HalfTone();
                            break;
                        case BWAlgorithme.Random:
                            Make_BWDat_Random();
                            break;
                    }
                //On retourne l'image
                return this._BWImg;
            }            
        }

        Propriéter de modification de la luminositer de l'image final
        public sbyte Luminosity
        {
            get
            {
                return this._Luminosity;
            }
            set
            {
                if (this._Luminosity != value)
                {
                    this._Luminosity = value;
                    if (this._BWImg != null)
                    {
                        this._BWImg.Dispose();
                        this._BWImg = null;
                    }
                }
            }
        }

        //Propriéter pour indiquer l'algo a utiliser lors de la conversion
        public BWAlgorithme DitherAlgo
        {
            get
            {
                return this._DitherAlgo;
            }
            set
            {
                if (this._DitherAlgo != value)
                {
                    this._DitherAlgo = value;
                    if (this._BWImg != null)
                    {
                        this._BWImg.Dispose();
                        this._BWImg = null;
                    }
                }
            }
        }

        //Propriéter de la hauteur final de l'image
        public int Height
        {
            get
            {
                return this._Height;
            }
            set
            {
                if (value < 1) value = 1;
                if (this._Height != value)
                {
                    this._Height = value;
                    if (this._GreyDat != IntPtr.Zero)
                    {
                        System.Runtime.InteropServices.Marshal.FreeHGlobal(this._GreyDat);
                        this._GreyDat = IntPtr.Zero;
                    }

                }
            }
        }

        //Propriéter de la largeur final de l'image
        public int Width
        {
            get
            {
                return this._Width;
            }
            set
            {   
                if (value < 1) value = 1;
                if (this._Width != value)
                {
                    this._Width = value;
                    if (this._GreyDat != IntPtr.Zero)
                    {
                        System.Runtime.InteropServices.Marshal.FreeHGlobal(this._GreyDat);
                        this._GreyDat = IntPtr.Zero;
                    }

                }
            }
        }

        private void Make_BWDat_Floyd()
        {
            //Initialisation de l'image
            if (this._BWImg != null)
                this._BWImg.Dispose();
            this._BWImg=new Bitmap(this._Width, this._Height, PixelFormat.Format1bppIndexed);
            BitmapData BWDat = this._BWImg.LockBits(new Rectangle(0, 0, this._Width, this._Height), ImageLockMode.WriteOnly, PixelFormat.Format1bppIndexed);

            //Allocation de la mémoire pour les erreurs
            IntPtr Erreurs = System.Runtime.InteropServices.Marshal.AllocHGlobal(((this._Height + 1) * this._Width + 1) * sizeof(int));

            //Calcule des donnée noir et blanc
            unsafe
            {
                byte CurBitMsk;
                int PointVal;
                int ErrToDispatch;
                byte* CurGrey = (byte*)this._GreyDat.ToPointer();
                int* CurErreur = (int*)Erreurs.ToPointer();
                int* CurErreur7 = &(CurErreur[1]);
                int* CurErreur1 = &(CurErreur[this._Width - 1]);
                int* CurErreur5 = &(CurErreur[this._Width]);
                int* CurErreur3 = &(CurErreur[this._Width + 1]);

                //initialisation des premiéres erreurs (les autres seront initialiser à la volée).
                for (int* LastErreur = &(((int*)Erreurs.ToPointer())[this._Width]); CurErreur <= LastErreur; CurErreur++)
                    *CurErreur = 0;
                CurErreur = (int*)Erreurs.ToPointer();

                Random Rnd = new Random();

                float LuminosityRatio = (float)((float)255/(float)(255 - Math.Abs(this._Luminosity)));
                byte LuminosityOffset = (this._Luminosity < 0) ? (byte)0 : (byte)this._Luminosity;

                //Table de précacule de la luminosité
                byte* LuminosityTab = stackalloc byte [255];
                for (int grayValue = 0; grayValue < 255; grayValue++)
                    LuminosityTab[grayValue] = (byte)(grayValue / LuminosityRatio + LuminosityOffset);

                for (int y = 0; y < this._Height; y++)
                {   
                    CurBitMsk = 128;// 1 << 7;
                    for (
                        byte* CurBWs = &(((byte*)BWDat.Scan0.ToPointer())[BWDat.Stride * y]),  //On ointe vers le premier octe de la ligne en cours.
                        afterLastGrey = &(((byte*)this._GreyDat.ToPointer())[(y+1)*this.Width]); //Borne de la ligne des niveaux de gris
                        //On parcourt la ligne courante
                        CurGrey < afterLastGrey;
                        //incrémentation des pointeurs
                        CurGrey++,
                        CurErreur++,
                        CurErreur7++,
                        CurErreur1++,
                        CurErreur5++,
                        CurErreur3++
                    )
                    {
                        //Calcul de la valeur du point
                        PointVal = LuminosityTab[*CurGrey] + *CurErreur + Rnd.Next(-25, 25);
                        
                        if(PointVal > 128)
                        {
                            //Enregistrement du point
                            *CurBWs |= CurBitMsk;
                            //Calcul de l'erreur
                            ErrToDispatch = PointVal - 255;
                        }
                        else
                        {
                            //Enregistrement du point
                            *CurBWs &=  (byte)(255 ^ CurBitMsk);
                            //Calcul de l'erreur
                            ErrToDispatch = PointVal;
                        }

                        //Diffusion de l'erreur
                        *CurErreur7 += ((ErrToDispatch * 7) >> 4);
                        *CurErreur1 += (ErrToDispatch >> 4);
                        *CurErreur5 += ((ErrToDispatch * 5) >> 4);
                        *CurErreur3 = ((ErrToDispatch * 3) >> 4); // = et pas += pour initialisé à la volée

                        //Initialisation des pointeurs et du masque de bit courant pour le point suivant
                        CurBitMsk >>= 1;
                        if (CurBitMsk == 0)
                        {
                            CurBitMsk = 128;//1 << 7;
                            CurBWs++;
                        }
                    }
                }
            }

            //Libération du tableau des erreurs
            System.Runtime.InteropServices.Marshal.FreeHGlobal(Erreurs);
            
            //Sauveguarde de l'image.
            this._BWImg.UnlockBits(BWDat);
        }

        private void Make_BWDat_Random()
        {
            //Initialisation de l'image
            if (this._BWImg != null)
                this._BWImg.Dispose();
            this._BWImg = new Bitmap(this._Width, this._Height, PixelFormat.Format1bppIndexed);
            BitmapData BWDat = this._BWImg.LockBits(new Rectangle(0, 0, this._Width, this._Height), ImageLockMode.WriteOnly, PixelFormat.Format1bppIndexed);

            //initialisation d'un Tableau de byte aléatoire.
            Byte[] rnds = new Byte[this._Width * this._Height];
            new Random().NextBytes(rnds);

            //Calcule des donnée noir et blanc
            unsafe
            {
                byte* CurBWs = (byte*)BWDat.Scan0.ToPointer();
                byte* CurGrey = (byte*)this._GreyDat.ToPointer();
                byte CurBitMsk;
                double LuminosityRatio = (255 - Math.Abs(this._Luminosity)) / 255.0;
                for (int y = 0; y < this._Height; y++)
                {
                    CurBitMsk = 128;// 1 << 7;
                    CurBWs = &(((byte*)BWDat.Scan0.ToPointer())[BWDat.Stride * y]);
                    for (int x = 0; x < this._Width; x++)
                    {                        
                        //Enregistrement du point
                        *CurBWs = (byte)((((*CurGrey * LuminosityRatio) + ((this._Luminosity < 0) ? (sbyte)0 : this._Luminosity)) > rnds[x + y * this._Width]) ? (*CurBWs | CurBitMsk) : (*CurBWs & (255 ^ CurBitMsk)));
                        
                        //Initialisation des pointeurs et du masque de bit courant pour le point suivant
                        CurBitMsk >>= 1;
                        if (CurBitMsk == 0)
                        {
                            CurBitMsk = 128; // 1 << 7;
                            CurBWs++;
                        }
                        CurGrey++;
                    }
                }
            }

            //Sauveguarde de l'image.
            this._BWImg.UnlockBits(BWDat);
        }

        private void Make_BWDat_HalfTone()
        {
            //Initialisation de l'image
            if (this._BWImg != null)
                this._BWImg.Dispose();
            this._BWImg = new Bitmap(this._Width, this._Height, PixelFormat.Format1bppIndexed);
            BitmapData BWDat = this._BWImg.LockBits(new Rectangle(0, 0, this._Width, this._Height), ImageLockMode.WriteOnly, PixelFormat.Format1bppIndexed);

            //Calcul des donnée noir et blanc
            unsafe
            {
                byte* CurBWs = (byte*)BWDat.Scan0.ToPointer();
                byte* CurGrey = (byte*)this._GreyDat.ToPointer();
                byte CurBitMsk;
                double LuminosityRatio = (255 - Math.Abs(this._Luminosity)) / 255.0;
                for (int y = 0; y < this._Height; y++)
                {
                    CurBitMsk = 1 << 7;
                    CurBWs = &(((byte*)BWDat.Scan0.ToPointer())[BWDat.Stride * y]);
                    for (int x = 0; x < this._Width; x++)
                    {
                        //Enregistrement du point
                        *CurBWs = (byte)((((*CurGrey * LuminosityRatio) + ((this._Luminosity < 0) ? (sbyte)0 : this._Luminosity)) > 128) ? (*CurBWs | CurBitMsk) : (*CurBWs & (255 ^ CurBitMsk)));

                        //Initialisation des pointeurs et du masque de bit courant pour le point suivant
                        CurBitMsk >>= 1;
                        if (CurBitMsk == 0)
                        {
                            CurBitMsk = 1 << 7;
                            CurBWs++;
                        }
                        CurGrey++;
                    }
                }
            }

            //Enregistrement des modification.
            this._BWImg.UnlockBits(BWDat);
        }


public void Make_GrayDat()
        {
            //On redimensionne l'image d'origine.
            Bitmap SizedImg = new Bitmap (this._OriginalImg ,this._Width,this._Height);

            //OnRécupére les données de l'image.
            BitmapData RGBDat = SizedImg.LockBits(new Rectangle(0, 0, this._Width, this._Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);

            //On initialise le tableau de donnée.
            if (this._GreyDat != IntPtr.Zero)
            {
                System.Runtime.InteropServices.Marshal.ReAllocHGlobal(this._GreyDat,new IntPtr(this._Width * this._Height));
            }
            else
            {
                this._GreyDat = System.Runtime.InteropServices.Marshal.AllocHGlobal(this._Width * this._Height);
            }

            //On Recalcule les données de niveau de gris.
            unsafe
            {
                //tables de precalculs des multiplications pour le calcul du niveau de gris
                //Les tableaus sont créer dans le tas (+ rapide por les petits tableau)
                //ils sont libéré à la fin de la fonction.
                int* multiBleu = stackalloc int[256];
                int* multiVert = stackalloc int[256];
                int* multiRouge = stackalloc int[256];
                for (int i = 0; i < 256; i++)
                {
                    multiBleu[i] = 76 * i;
                    multiVert[i] = 151 * i;
                    multiRouge[i] = 28 * i;
                }

                byte* CurGrey = (byte*)this._GreyDat.ToPointer();
                for (int y = 0; y < this._Height; y++)
                {
                    //On pointe vers le début de la ligne
                    RGBPix* CurRGBDat = (RGBPix*)&(((byte*)RGBDat.Scan0.ToPointer())[y * RGBDat.Stride]);
                    //Balayage de la ligne
                    for (
                        // Calcul de la borne supérieur de la ligne
                        byte* afterLastGrey = &(((byte*)this._GreyDat.ToPointer())[(y+1)*this.Width]); //Borne de la ligne des niveaux de gris
                        //On Balaye toute la ligne
                        CurGrey < afterLastGrey; 
                        //On pointe vers les données suivantes
                        CurRGBDat++,
                        CurGrey++
                    )
                        *CurGrey = (byte)((multiBleu[CurRGBDat->B] + multiVert[CurRGBDat->G] + multiRouge[CurRGBDat->R]) >> 8);
                }
            }

            //On supprime les donnée en noir et blans pour forcer leur recalcule
            if (_BWImg != null)
            {
                this._BWImg.Dispose();
                this._BWImg=null;
            }

            //On libére les ressoure
            SizedImg.UnlockBits(RGBDat);
            SizedImg.Dispose();
        }
    }

08 novembre 2006 17:02:39 :

Ajout d'une Photo, de commentaires et modifications mineur du code...

09 novembre 2006 14:22:08 :

Optimisation de l'algo Floyd et de l'algo de niveau de gris