C# Bitmap图像处理(含增强对比度的三种方法)

bitmap类

bitmap对象封装了ｇｄｉ+中的一个位图，此位图由图形图像及其属性的像素数据组成.因此bitmap是用于处理由像素数据定义的图像的对象.该类的主要方法和属性如下：

1. getpixel方法和setpixel方法：获取和设置一个图像的指定像素的颜色.
2. pixelformat属性：返回图像的像素格式.
3. palette属性：获取和设置图像所使用的颜色调色板.
4. height width属性：返回图像的高度和宽度.
5. lockbits方法和unlockbits方法：分别锁定和解锁系统内存中的位图像素.在基于像素点的图像处理方法中使用lockbits和unlockbits是一个很好的方式，这两种方法可以使我们指定像素的范围来控制位图的任意一部分，从而消除了通过循环对位图的像素逐个进行处理，每调用lockbits之后都应该调用一次unlockbits.

bitmapdata类

bitmapdata对象指定了位图的属性
1. height属性：被锁定位图的高度.
2. width属性：被锁定位图的宽度.
3. pixelformat属性：数据的实际像素格式.
4. scan0属性：被锁定数组的首字节地址，如果整个图像被锁定，则是图像的第一个字节地址.
5. stride属性：步幅，也称为扫描宽度.

这里要重点说说stride属性，这个和width有什么区别呢，可以这么说，如果你的图片大小也就是图片字节是4的整数倍，那么stride与width是相等的，否则stride就是大于width的最小4的整数倍。在处理过程中，stride肯定是4的整数倍，这里是个坑啊。。。

                                                       

例1：有一个一维像素点阵数组，里面放的是每个像素点的灰度值，知道宽和高，要转换成bitmap

/// <summary>
/// 像素点阵转换为bitmap
/// </summary>
/// <param name="rawvalues">byte[]数组</param>
/// <param name="width">图片的宽度</param>
/// <param name="height">图片的高度</param>
/// <returns>bitmap图片</returns>
public static bitmap tograybitmap(byte[] rawvalues, int width, int height)
{
    bitmap bmp = new bitmap(width, height, system.drawing.imaging.pixelformat.format8bppindexed);
    bitmapdata bmpdata = bmp.lockbits(new system.drawing.rectangle(0, 0, width, height), imagelockmode.writeonly, system.drawing.imaging.pixelformat.format8bppindexed);
     获取图像参数  
    //bmpdata.stride = width;
    int stride = bmpdata.stride;  // 扫描线的宽度  
    int offset = stride - width;  // 显示宽度与扫描线宽度的间隙  
    intptr iptr = bmpdata.scan0;  // 获取bmpdata的内存起始位置  
    int scanbytes = stride * height;// 用stride宽度，表示这是内存区域的大小  
     下面把原始的显示大小字节数组转换为内存中实际存放的字节数组  
    int posscan = 0, posreal = 0;// 分别设置两个位置指针，指向源数组和目标数组  
    byte[] pixelvalues = new byte[scanbytes];  //为目标数组分配内存  
    for (int x = 0; x < height; x++)
    {
         下面的循环节是模拟行扫描  
        for (int y = 0; y < width; y++)
        {
            pixelvalues[posscan++] = rawvalues[posreal++];
        }
        posscan += offset;  //行扫描结束，要将目标位置指针移过那段“间隙”  
    }
     用marshal的copy方法，将刚才得到的内存字节数组复制到bitmapdata中  
    system.runtime.interopservices.marshal.copy(pixelvalues, 0, iptr, scanbytes);
    bmp.unlockbits(bmpdata);  // 解锁内存区域  
     下面的代码是为了修改生成位图的索引表，从伪彩修改为灰度  
    colorpalette temppalette;
    using (bitmap tempbmp = new bitmap(1, 1, system.drawing.imaging.pixelformat.format8bppindexed))
    {
        temppalette = tempbmp.palette;
    }
    for (int i = 0; i < 256; i++)
    {
        temppalette.entries[i] = system.drawing.color.fromargb(i, i, i);
    }
 
    bmp.palette = temppalette;
 
     算法到此结束，返回结果  
    return bmp;
}

至于24位位图数据其实就是 一个像素点有rgb三个值而已，道理一样。

例2：:根据图片得到他的灰度数组

//8位位图得到除去文件头信息的一位灰度数组
 
 
bitmapdata bmpdata = map.lockbits(new system.drawing.rectangle(0, 0, map.width, map.height), imagelockmode.readonly, system.drawing.imaging.pixelformat.format8bppindexed);
 
 获取图像参数  
 
int stride = bmpdata.stride;  // 扫描线的宽度  
 
int offset = stride - map.width;  // 显示宽度与扫描线宽度的间隙  
 
intptr iptr = bmpdata.scan0;  // 获取bmpdata的内存起始位置  
 
int scanbytes = stride * map.height;// 用stride宽度，表示这是内存区域的大小  
 
 下面把原始的显示大小字节数组转换为内存中实际存放的字节数组  
 
mapdata = new byte[scanbytes];  //为目标数组分配内存
 
system.runtime.interopservices.marshal.copy(iptr, mapdata, 0, scanbytes); //copy内存中数据到数组中

这里对与bitmapdata的操作方式是readonly

下面的三个例子分别基于像素（getpixel和setpixel）、基于内存、基于指针这三种方法增强图片对比度。均测试通过

运行时间：

1）基于像素：400-600ms
2）基于内存：17-18ms
3）基于指针：20-23ms
利用lut，应该可以进一步减少运行时间

 // 第一种方法：像素提取法。速度慢
        public bitmap methodbaseonpixel(bitmap bitmap,int degree)
        {
            color curcolor;
            int grayr, grayg, grayb;
 
            double deg = (100.0 + degree) / 100.0;
            for (int i = 0; i < bitmap.width; i++)
            {
                for (int j = 0; j < bitmap.height; j++)
                {
                    curcolor = bitmap.getpixel(i, j);
                    grayr =convert.toint32((((curcolor.r / 255.0 - 0.5) * deg + 0.5)) * 255);
                    grayg = convert.toint32((((curcolor.g / 255.0 - 0.5) * deg + 0.5)) * 255);
                    grayb = convert.toint32((((curcolor.b / 255.0 - 0.5) * deg + 0.5)) * 255);
                    if (grayr < 0)
                        grayr = 0;
                    else if (grayr > 255)
                        grayr = 255;
 
                    if (grayb < 0)
                        grayb = 0;
                    else if (grayb > 255)
                        grayb = 255;
 
                    if (grayg < 0)
                        grayg = 0;
                    else if (grayg > 255)
                        grayg = 255;
 
 
                    bitmap.setpixel(i, j, color.fromargb(grayr, grayg, grayb));
                }
            }
 
            return bitmap;
        }

// 第二种方法：基于内存
        public unsafe bitmap methodbaseonmemory(bitmap bitmap, int degree)
        {
            if (bitmap == null)
            {
                return null;
            }
            double deg = (100.0 + degree) / 100.0;
 
            int width = bitmap.width;
            int height = bitmap.height;
 
            int length = height * 3 * width;
            byte[] rgb = new byte[length];
 
            bitmapdata data = bitmap.lockbits(new rectangle(0, 0, width, height), imagelockmode.readwrite, pixelformat.format24bpprgb);
 
            system.intptr scan0 = data.scan0;
            system.runtime.interopservices.marshal.copy(scan0, rgb, 0, length);
 
            double gray = 0;
            for (int i = 0; i < rgb.length; i += 3)
            {
                for (int j = 0; j < 3; j++)
                {
                    gray = (((rgb[i + j] / 255.0 -0.5) * deg+0.5)) * 255.0;
                    if (gray > 255)
                        gray = 255;
 
                    if (gray < 0)
                        gray = 0;
                    rgb[i + j] = (byte) gray;
                }
            }
 
            system.runtime.interopservices.marshal.copy(rgb, 0, scan0, length);// 此处copy是之前copy的逆操作
            bitmap.unlockbits(data);
            return bitmap;
        }
    }

//第三种方法：基于指针
        public unsafe bitmap methodbaseonptr(bitmap b, int degree)
        {
            if (b == null)
            {
                return null;
            }
            try
            {
                double num = 0.0;
                double num2 = (100.0 + degree) / 100.0;
                num2 *= num2;
                int width = b.width;
                int height = b.height;
                bitmapdata bitmapdata = b.lockbits(new rectangle(0, 0, width, height), imagelockmode.readwrite, pixelformat.format24bpprgb);
                byte* numptr = (byte*)bitmapdata.scan0;
 
                int offset = bitmapdata.stride - (width * 3);
                for (int i = 0; i < height; i++)
                {
                    for (int j = 0; j < width; j++)
                    {
                        for (int k = 0; k < 3; k++)
                        {
                            num = ((((((double)numptr[k]) / 255.0) - 0.5) * num2) + 0.5) * 255.0;
                            if (num < 0.0)
                            {
                                num = 0.0;
                            }
                            if (num > 255.0)
                            {
                                num = 255.0;
                            }
                            numptr[k] = (byte)num;
                        }
                        numptr += 3;
 
                    }
                    numptr += offset;
                }
                b.unlockbits(bitmapdata);
                return b;
            }
            catch
            {
                return b;
            }
        }

参考：

1.  http://blog.csdn.net/jiangxinyu/article/details/6222302 （此博客的代码中有错误，精简代码基于内存处理的copy顺序有问题）

2.  http://www.pin5i.com/showtopic-20228.html  // c# 特效图片：雾化、浮雕等。

到此这篇关于c# bitmap图像处理(含增强对比度的三种方法)的文章就介绍到这了,更多相关c# bitmap图像处理内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！