C#图片灰度处理(位深度24→位深度8)

#region 灰度处理
        /// <summary>
        /// 将源图像灰度化，并转化为8位灰度图像。
        /// </summary>
        /// <param name="original"> 源图像。 </param>
        /// <returns> 8位灰度图像。 </returns>
        public static Bitmap RgbToGrayScale(Bitmap original)
        {
            if (original != null)
            {
                // 将源图像内存区域锁定
                Rectangle rect = new Rectangle(, , original.Width, original.Height);
                BitmapData bmpData = original.LockBits(rect, ImageLockMode.ReadOnly,
                        PixelFormat.Format24bppRgb);
 
                // 获取图像参数
                int width = bmpData.Width;
                int height = bmpData.Height;
                int stride = bmpData.Stride;  // 扫描线的宽度,比实际图片要大
                int offset = stride - width * ;  // 显示宽度与扫描线宽度的间隙
                IntPtr ptr = bmpData.Scan0;   // 获取bmpData的内存起始位置的指针
                int scanBytesLength = stride * height;  // 用stride宽度，表示这是内存区域的大小
 
                // 分别设置两个位置指针，指向源数组和目标数组
                int posScan = , posDst = ;
                byte[] rgbValues = new byte[scanBytesLength];  // 为目标数组分配内存
                Marshal.Copy(ptr, rgbValues, , scanBytesLength);  // 将图像数据拷贝到rgbValues中
                // 分配灰度数组
                byte[] grayValues = new byte[width * height]; // 不含未用空间。
                // 计算灰度数组
 
                byte blue, green, red, YUI;
 
                for (int i = ; i < height; i++)
                {
                    for (int j = ; j < width; j++)
                    {
 
                        blue = rgbValues[posScan];
                        green = rgbValues[posScan + ];
                        red = rgbValues[posScan + ];
                        YUI = (byte)(0.229 * red + 0.587 * green + 0.144 * blue);
                        //grayValues[posDst] = (byte)((blue + green + red) / 3);
                        grayValues[posDst] = YUI;
                        posScan += ;
                        posDst++;
 
                    }
                    // 跳过图像数据每行未用空间的字节，length = stride - width * bytePerPixel
                    posScan += offset;
                }
 
                // 内存解锁
                Marshal.Copy(rgbValues, , ptr, scanBytesLength);
                original.UnlockBits(bmpData);  // 解锁内存区域
 
                // 构建8位灰度位图
                Bitmap retBitmap = BuiltGrayBitmap(grayValues, width, height);
                return retBitmap;
            }
            else
            {
                return null;
            }
        }
 
        /// <summary>
        /// 用灰度数组新建一个8位灰度图像。
        /// </summary>
        /// <param name="rawValues"> 灰度数组(length = width * height)。 </param>
        /// <param name="width"> 图像宽度。 </param>
        /// <param name="height"> 图像高度。 </param>
        /// <returns> 新建的8位灰度位图。 </returns>
        private static Bitmap BuiltGrayBitmap(byte[] rawValues, int width, int height)
        {
            // 新建一个8位灰度位图，并锁定内存区域操作
            Bitmap bitmap = new Bitmap(width, height, PixelFormat.Format8bppIndexed);
            BitmapData bmpData = bitmap.LockBits(new Rectangle(, , width, height),
                 ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed);
 
            // 计算图像参数
            int offset = bmpData.Stride - bmpData.Width;        // 计算每行未用空间字节数
            IntPtr ptr = bmpData.Scan0;                         // 获取首地址
            int scanBytes = bmpData.Stride * bmpData.Height;    // 图像字节数 = 扫描字节数 * 高度
            byte[] grayValues = new byte[scanBytes];            // 为图像数据分配内存
 
            // 为图像数据赋值
            int posSrc = , posScan = ;                        // rawValues和grayValues的索引
            for (int i = ; i < height; i++)
            {
                for (int j = ; j < width; j++)
                {
                    grayValues[posScan++] = rawValues[posSrc++];
                }
                // 跳过图像数据每行未用空间的字节，length = stride - width * bytePerPixel
                posScan += offset;
            }
 
            // 内存解锁
            Marshal.Copy(grayValues, , ptr, scanBytes);
            bitmap.UnlockBits(bmpData);  // 解锁内存区域
 
            // 修改生成位图的索引表，从伪彩修改为灰度
            ColorPalette palette;
            // 获取一个Format8bppIndexed格式图像的Palette对象
            using (Bitmap bmp = new Bitmap(, , PixelFormat.Format8bppIndexed))
            {
                palette = bmp.Palette;
            }
            for (int i = ; i < ; i++)
            {
                palette.Entries[i] = Color.FromArgb(i, i, i);
            }
            // 修改生成位图的索引表
            bitmap.Palette = palette;
 
            return bitmap;
        }
        #endregion

C#图片二值化处理(位深度8→位深度1)

#region 二值化
/*
1位深度图像 颜色表数组255个元素 只有用前两个 0对应0  1对应255
1位深度图像每个像素占一位
8位深度图像每个像素占一个字节  是1位的8倍
*/
        /// <summary>
        /// 将源灰度图像二值化，并转化为1位二值图像。
        /// </summary>
        /// <param name="bmp"> 源灰度图像。 </param>
        /// <returns> 1位二值图像。 </returns>
        public static Bitmap GTo2Bit(Bitmap bmp)
        {
            if (bmp != null)
            {
                // 将源图像内存区域锁定
                Rectangle rect = new Rectangle(, , bmp.Width, bmp.Height);
                BitmapData bmpData = bmp.LockBits(rect, ImageLockMode.ReadOnly,
                        PixelFormat.Format8bppIndexed);
 
                // 获取图像参数
                int leng, offset_1bit = ;
                int width = bmpData.Width;
                int height = bmpData.Height;
                int stride = bmpData.Stride;  // 扫描线的宽度,比实际图片要大
                int offset = stride - width;  // 显示宽度与扫描线宽度的间隙
                IntPtr ptr = bmpData.Scan0;   // 获取bmpData的内存起始位置的指针
                int scanBytesLength = stride * height;  // 用stride宽度，表示这是内存区域的大小
                if (width %  == )
                {
                    leng = width / ;
                }
                else
                {
                    leng = width /  + ( - (width /  % ));
                    if (width %  != )
                    {
                        offset_1bit = leng - width / ;
                    }
                    else
                    {
                        offset_1bit = leng - width / ;
                    }
                }
 
                // 分别设置两个位置指针，指向源数组和目标数组
                int posScan = , posDst = ;
                byte[] rgbValues = new byte[scanBytesLength];  // 为目标数组分配内存
                Marshal.Copy(ptr, rgbValues, , scanBytesLength);  // 将图像数据拷贝到rgbValues中
                // 分配二值数组
                byte[] grayValues = new byte[leng * height]; // 不含未用空间。
                // 计算二值数组
                int x, v, t = ;
                for (int i = ; i < height; i++)
                {
                    for (x = ; x < width; x++)
                    {
                        v = rgbValues[posScan];
                        t = (t << ) | (v >  ?  : );
 
                        if (x %  == )
                        {
                            grayValues[posDst] = (byte)t;
                            posDst++;
                            t = ;
                        }
                        posScan++;
                    }
 
                    if ((x %= ) != )
                    {
                        t <<=  - x;
                        grayValues[posDst] = (byte)t;
                    }
                    // 跳过图像数据每行未用空间的字节，length = stride - width * bytePerPixel
                    posScan += offset;
                    posDst += offset_1bit;
                }
 
                // 内存解锁
                Marshal.Copy(rgbValues, , ptr, scanBytesLength);
                bmp.UnlockBits(bmpData);  // 解锁内存区域
 
                // 构建1位二值位图
                Bitmap retBitmap = twoBit(grayValues, width, height);
                return retBitmap;
            }
            else
            {
                return null;
            }
        }
 
        /// <summary>
        /// 用二值数组新建一个1位二值图像。
        /// </summary>
        /// <param name="rawValues"> 二值数组(length = width * height)。 </param>
        /// <param name="width"> 图像宽度。 </param>
        /// <param name="height"> 图像高度。 </param>
        /// <returns> 新建的1位二值位图。 </returns>
        private static Bitmap twoBit(byte[] rawValues, int width, int height)
        {
            // 新建一个1位二值位图，并锁定内存区域操作
            Bitmap bitmap = new Bitmap(width, height, PixelFormat.Format1bppIndexed);
            BitmapData bmpData = bitmap.LockBits(new Rectangle(, , width, height),
                 ImageLockMode.WriteOnly, PixelFormat.Format1bppIndexed);
 
            // 计算图像参数
            int offset = bmpData.Stride - bmpData.Width / ;        // 计算每行未用空间字节数
            IntPtr ptr = bmpData.Scan0;                         // 获取首地址
            int scanBytes = bmpData.Stride * bmpData.Height;    // 图像字节数 = 扫描字节数 * 高度
            byte[] grayValues = new byte[scanBytes];            // 为图像数据分配内存
 
            // 为图像数据赋值
            int posScan = ;                        // rawValues和grayValues的索引
            for (int i = ; i < height; i++)
            {
                for (int j = ; j < bmpData.Width / ; j++)
                {
                    grayValues[posScan] = rawValues[posScan];
                    posScan++;
                }
                // 跳过图像数据每行未用空间的字节，length = stride - width * bytePerPixel
                posScan += offset;
            }
 
            // 内存解锁
            Marshal.Copy(grayValues, , ptr, scanBytes);
            bitmap.UnlockBits(bmpData);  // 解锁内存区域
 
            // 修改生成位图的索引表
            ColorPalette palette;
            // 获取一个Format8bppIndexed格式图像的Palette对象
            using (Bitmap bmp = new Bitmap(, , PixelFormat.Format1bppIndexed))
            {
                palette = bmp.Palette;
            }
            for (int i = ; i < ; i = +)
            {
                palette.Entries[i] = Color.FromArgb(i, i, i);
            }
            // 修改生成位图的索引表
            bitmap.Palette = palette;
 
            return bitmap;
        }
        #endregion