图像处理(锐化、平滑、反色，霓虹灯，浮雕、灰度处理)

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

图像锐化是补偿图像的轮廓，增强图像的边缘及灰度跳变的部分，使图像变得清晰。图像平滑往往使图像中的边界、轮廓模糊，为了减少这类不利影响，利用图像锐化技术可以使图像的边缘清晰。图像锐化处理的目的是使图像的边缘、轮廓线及图像的细节变得清晰。经过平滑的图像变得模糊的根本原因是对图像进行了平均或积分运算，因此对其进行逆运算。

1。梯度锐化

2。拉普拉斯掩膜锐化

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// 平滑

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

1。邻域平均法

噪声点像素的灰度与其临近像素的灰度显著不同，根据噪声点这一特性，可以使用邻域平均法。

2。加权平均法

邻域平均处理方法是以图像模糊为代价减小噪声。有时为了突出源图像中的点（i, j）本身的重要性，对于同一尺寸的模板，不同位置的系数采用不同的数值就可以采用加权平均法实现。

3。选择式掩膜平滑

邻域平均法和加权平均法在消除噪声的同时，都不可避免地带来平均化的缺憾，致使尖锐变化的边缘或线条变得模糊。考虑图像中目标物体和背景一般都具有不同的统计特性，即不同的均值和方差，为保留一定的边缘信息，可采用选择式掩膜平滑滤波，这样可以得到较好的图像细节。这种方法以尽量不模糊边缘轮廓为目的。

Bitmap desc = new Bitmap(source.Width, source.Height);
BitmapData sourcedata = source.LockBits(new Rectangle(0, 0, source.Width, source.Height),
                ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
BitmapData descdata = desc.LockBits(new Rectangle(0, 0, desc.Width, desc.Height),
                ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb);

unsafe
{
      byte* sourceptr = (byte*)sourcedata.Scan0;  //B,G,R
      byte* descptr = (byte*)descdata.Scan0;
      int step = source.Width * 3;
      sourceptr += step * 2;
      descptr += step * 2;
      byte[] pixel = new byte[9];
      float[,] mean = new float[9,3];
      float[,] var = new float[9,3];
      int n, m;
      float min;
      for (int x = 2; x < source.Height - 2; x++)
      {
            sourceptr += 6;
            descptr += 6;
            for (int y = 2; y < source.Width - 2; y++)
            {
                  for (int color = 0; color < 3; color++)
                     {
                         pixel[0] = *(sourceptr - (step + 3));
                         pixel[1] = *(sourceptr - step);
                         pixel[2] = *(sourceptr - (step - 3));
                         pixel[3] = *(sourceptr - 3);
                         pixel[4] = *(sourceptr);
                         pixel[5] = *(sourceptr + 3);
                         pixel[6] = *(sourceptr + (step - 3));
                         pixel[7] = *(sourceptr + step);
                         pixel[8] = *(sourceptr + (step + 3));
                         mean[0, color] = (float)(pixel[0] + pixel[1] + pixel[2] + pixel[3] + pixel[4] +
                                        pixel[5] + pixel[6] + pixel[7] + pixel[8]) / 9;
                         var[0, color] = 0;
                         for (n = 0; n < 9; n++)
                              var[0, color] += pixel[n] * pixel[n] - mean[0, color] * mean[0, color];

                         pixel[0] = *(sourceptr - (step + 6));
                         pixel[1] = *(sourceptr - (step + 3));
                         pixel[2] = *(sourceptr - 6);
                         pixel[3] = *(sourceptr - 3);
                         pixel[4] = *(sourceptr);
                         pixel[5] = *(sourceptr + (step - 6));
                         pixel[6] = *(sourceptr + (step - 3));
                         mean[1, color] = (float)(pixel[0] + pixel[1] + pixel[2] + pixel[3] + pixel[4] +
                                          pixel[5] + pixel[6]) / 7;
                         var[1, color] = 0;
                         for (n = 0; n < 7; n++)
                              var[1, color] += pixel[n] * pixel[n] - mean[1, color] * mean[1, color];

                         pixel[0] = *(sourceptr - (step + step + 3));
                         pixel[1] = *(sourceptr - (step + step));
                         pixel[2] = *(sourceptr - (step + step - 3));
                         pixel[3] = *(sourceptr - (step + 3));
                         pixel[4] = *(sourceptr - step);
                         pixel[5] = *(sourceptr - (step - 3));
                         pixel[6] = *(sourceptr);
                         mean[2, color] = (float)(pixel[0] + pixel[1] + pixel[2] + pixel[3] + pixel[4] +
                                          pixel[5] + pixel[6]) / 7;
                         var[2, color] = 0;
                         for (n = 0; n < 7; n++)
                              var[2, color] += pixel[n] * pixel[n] - mean[2, color] * mean[2, color];

                         pixel[0] = *(sourceptr - (step - 3));
                         pixel[1] = *(sourceptr - (step - 6));
                         pixel[2] = *(sourceptr);
                         pixel[3] = *(sourceptr + 3);
                         pixel[4] = *(sourceptr + 6);
                         pixel[5] = *(sourceptr + (step + 3));
                         pixel[6] = *(sourceptr + (step + 6));
                         mean[3, color] = (float)(pixel[0] + pixel[1] + pixel[2] + pixel[3] + pixel[4] +
                                          pixel[5] + pixel[6]) / 7;
                         var[3, color] = 0;
                         for (n = 0; n < 7; n++)
                              var[3, color] += pixel[n] * pixel[n] - mean[3, color] * mean[3, color];

                         pixel[0] = *(sourceptr);
                         pixel[1] = *(sourceptr + (step - 3));
                         pixel[2] = *(sourceptr + step);
                         pixel[3] = *(sourceptr + (step + 3));
                         pixel[4] = *(sourceptr + (step + step - 3));
                         pixel[5] = *(sourceptr + step + step);
                         pixel[6] = *(sourceptr + (step + step + 3));
                         mean[4, color] = (float)(pixel[0] + pixel[1] + pixel[2] + pixel[3] + pixel[4] +
                                          pixel[5] + pixel[6]) / 7;
                         var[4, color] = 0;
                         for (n = 0; n < 7; n++)
                              var[4, color] += pixel[n] * pixel[n] - mean[4, color] * mean[4, color];

                         pixel[0] = *(sourceptr - (step + step + 6));
                         pixel[1] = *(sourceptr - (step + step + 3));
                         pixel[2] = *(sourceptr - (step + 6));
                         pixel[3] = *(sourceptr - (step + 3));
                         pixel[4] = *(sourceptr - step);
                         pixel[5] = *(sourceptr - 3);
                         pixel[6] = *(sourceptr);
                         mean[5, color] = (float)(pixel[0] + pixel[1] + pixel[2] + pixel[3] + pixel[4] +
                                          pixel[5] + pixel[6]) / 7;
                         var[5, color] = 0;
                         for (n = 0; n < 7; n++)
                              var[5, color] += pixel[n] * pixel[n] - mean[5, color] * mean[5, color];

                         pixel[0] = *(sourceptr - (step + step - 3));
                         pixel[1] = *(sourceptr - (step + step - 6));
                         pixel[2] = *(sourceptr - step);
                         pixel[3] = *(sourceptr - (step - 3));
                         pixel[4] = *(sourceptr - (step - 6));
                         pixel[5] = *(sourceptr);
                         pixel[6] = *(sourceptr + 3);
                         mean[6, color] = (float)(pixel[0] + pixel[1] + pixel[2] + pixel[3] + pixel[4] +
                                          pixel[5] + pixel[6]) / 7;
                         var[6, color] = 0;
                         for (n = 0; n < 7; n++)
                              var[6, color] += pixel[n] * pixel[n] - mean[6, color] * mean[6, color];

                         pixel[0] = *(sourceptr);
                         pixel[1] = *(sourceptr + 3);
                         pixel[2] = *(sourceptr + step);
                         pixel[3] = *(sourceptr + (step + 3));
                         pixel[4] = *(sourceptr + (step + 6));
                         pixel[5] = *(sourceptr + (step + step + 3));
                         pixel[6] = *(sourceptr + (step + step + 6));
                         mean[7, color] = (float)(pixel[0] + pixel[1] + pixel[2] + pixel[3] + pixel[4] +
                                          pixel[5] + pixel[6]) / 7;
                         var[7, color] = 0;
                         for (n = 0; n < 7; n++)
                              var[7, color] += pixel[n] * pixel[n] - mean[7, color] * mean[7, color];

                         pixel[0] = *(sourceptr - 3);
                         pixel[1] = *(sourceptr);
                         pixel[2] = *(sourceptr + (step - 6));
                         pixel[3] = *(sourceptr + (step - 3));
                         pixel[4] = *(sourceptr + step);
                         pixel[5] = *(sourceptr + (step + step - 6));
                         pixel[6] = *(sourceptr + (step + step - 3));
                         mean[8, color] = (float)(pixel[0] + pixel[1] + pixel[2] + pixel[3] + pixel[4] +
                                          pixel[5] + pixel[6]) / 7;
                         var[8, color] = 0;
                         for (n = 0; n < 7; n++)
                              var[8, color] += pixel[n] * pixel[n] - mean[8, color] * mean[8, color];

                         descptr++;
                         sourceptr++;
                   }

                   min = var[0, 0] + var[0, 1] + var[0, 2];
                   m = 0;
                   for (n = 1; n < 9; n++)
                   {
                        if (min > var[n, 0] + var[n, 1] + var[n, 2])
                        {
                             min = var[n, 0] + var[n, 1] + var[n, 2];
                             m = n;
                        }
                   }

                   *(descptr - 3) = (byte)(mean[m, 0]);
                   *(descptr - 2) = (byte)(mean[m, 1]);
                   *(descptr - 1) = (byte)(mean[m, 2]);
             }
             sourceptr += sourcedata.Stride - source.Width * 3 + 6;
             descptr += descdata.Stride - desc.Width * 3 + 6;
      }
}
source.UnlockBits(sourcedata);
desc.UnlockBits(descdata);

4。中值滤波法

中值滤波是一种非线性平滑滤波，在一定条件下可以克服线性滤波带来的图像细节模糊问题，而且对滤除噪声干扰及图像扫描噪声非常有效。中值滤波通常采用一个含有奇数个点的滑动窗口，用窗口中各点灰度值的中值来代替中心点的灰度值。对于奇数个元素，中值是指按大小排序后中间的数值；对偶数个元素，中值是指排序后中间两个元素灰度值的平均值。

/////////////////////////////////////////////////////////////////////////////////////////////////

反色，霓虹灯，浮雕

1。反色

2。霓虹灯

3。浮雕

Bitmap desc = new Bitmap(source.Width, source.Height);

BitmapData sourcedata = source.LockBits(new Rectangle(0, 0, source.Width, source.Height),
                ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
BitmapData descdata = desc.LockBits(new Rectangle(0, 0, desc.Width, desc.Height),
                ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb);

unsafe
{
      byte* sourceptr = (byte*)sourcedata.Scan0;
      byte* descptr = (byte*)descdata.Scan0;
      int step = (source.Width + 1) * 3;
      double value;
      for (int x = 0; x < source.Height; x++)
      {
           for (int y = 0; y < source.Width; y++)
           {
                value = Math.Abs(*(sourceptr - step) - *sourceptr + 128);
                *(descptr++) = value > 255 ? (byte)255 : (byte)(value);
                sourceptr++;
            }
            sourceptr += sourcedata.Stride - source.Width * 3;
            descptr += descdata.Stride - desc.Width * 3;
       }
}
source.UnlockBits(sourcedata);
desc.UnlockBits(descdata);

//////////////////////////////////////////////////////////////////////////

灰度处理

将彩色的图片转换成黑白有很多种方法：

1。红色转换灰度

Bitmap desc = new Bitmap(source.Width, source.Height);

BitmapData sourcedata = source.LockBits(new Rectangle(0, 0, source.Width, source.Height),
                ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
BitmapData descdata = desc.LockBits(new Rectangle(0, 0, desc.Width, desc.Height),
                ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb);

unsafe
{
      byte* sourceptr = (byte*)sourcedata.Scan0;  //B,G,R
      sourceptr += 2;
      byte* descptr = (byte*)descdata.Scan0;
      for (int x = 0; x < source.Height; x++)
      {
           for (int y = 0; y < source.Width; y++)
           {
                *(descptr++) = *sourceptr;
                *(descptr++) = *sourceptr;
                *(descptr++) = *sourceptr;
                sourceptr += 3;
            }
            sourceptr += sourcedata.Stride - source.Width * 3;
            descptr += descdata.Stride - desc.Width * 3;
       }
}
source.UnlockBits(sourcedata);
desc.UnlockBits(descdata);

2。绿色转换灰度

3。蓝色转换灰度

Bitmap desc = new Bitmap(source.Width, source.Height);

BitmapData sourcedata = source.LockBits(new Rectangle(0, 0, source.Width, source.Height),
                ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
BitmapData descdata = desc.LockBits(new Rectangle(0, 0, desc.Width, desc.Height),
                ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb);

unsafe
{
      byte* sourceptr = (byte*)sourcedata.Scan0;  //B,G,R
      byte* descptr = (byte*)descdata.Scan0;
      for (int x = 0; x < source.Height; x++)
      {
           for (int y = 0; y < source.Width; y++)
           {
                *(descptr++) = *sourceptr;
                *(descptr++) = *sourceptr;
                *(descptr++) = *sourceptr;
                sourceptr += 3;
            }
            sourceptr += sourcedata.Stride - source.Width * 3;
            descptr += descdata.Stride - desc.Width * 3;
       }
}
source.UnlockBits(sourcedata);
desc.UnlockBits(descdata);

4。平均转换灰度

5。加权平均转换灰度