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

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 锐化

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

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

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;
byte* descptr = (byte*)descdata.Scan0;
int step = source.Width * 3;
double value;
for (int x = 0; x < source.Height; x++)
{
for (int y = 0; y < source.Width; y++)
{
value = Math.Sqrt((*sourceptr - *(sourceptr + step + 3)) * (*sourceptr - *(sourceptr + step + 3)) +
(*(sourceptr + 3) - *(sourceptr + step)) * (*(sourceptr + 3) - *(sourceptr + step)));
*(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);

2。拉普拉斯掩膜锐化

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 * 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 - 3) + *(sourceptr + 3) +
*(sourceptr + step) - *(sourceptr) * 4);
*(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;
byte* descptr = (byte*)descdata.Scan0;
int step = source.Width * 3;
for (int x = 0; x < source.Height; x++)
{
for (int y = 0; y < source.Width; y++)
{
*(descptr++) = (byte)((*(sourceptr - (step + 3)) + *(sourceptr - step) + *(sourceptr - (step - 3)) +
*(sourceptr - 3) + *(sourceptr) + *(sourceptr + 3) +
*(sourceptr + (step - 3)) + *(sourceptr + step) + *(sourceptr + (step + 3))) / 9);
sourceptr++;
}
sourceptr += sourcedata.Stride - source.Width * 3;
descptr += descdata.Stride - desc.Width * 3;
}
}
source.UnlockBits(sourcedata);
desc.UnlockBits(descdata);

2。加权平均法

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

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 * 3;
for (int x = 0; x < source.Height; x++)
{
for (int y = 0; y < source.Width; y++)
{
*(descptr++) = (byte)((*(sourceptr - (step + 3)) + *(sourceptr - step) * 2 + *(sourceptr - (step - 3))+
*(sourceptr - 3) * 2 + *(sourceptr) * 4 + *(sourceptr + 3) * 2 +
*(sourceptr + (step - 3)) + *(sourceptr + step) * 2 + *(sourceptr + (step + 3))) / 16);
sourceptr++;
}
sourceptr += sourcedata.Stride - source.Width * 3;
descptr += descdata.Stride - desc.Width * 3;
}
}
source.UnlockBits(sourcedata);
desc.UnlockBits(descdata);

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
* pixel
- 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
* pixel
- 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
* pixel
- 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
* pixel
- 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
* pixel
- 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
* pixel
- 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
* pixel
- 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
* pixel
- 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
* pixel
- 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。中值滤波法

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

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 * 3;
byte[] mean = new byte[9];
for (int x = 0; x < source.Height; x++)
{
for (int y = 0; y < source.Width; y++)
{
mean[0] = *(sourceptr - (step + 3));
mean[1] = *(sourceptr - step);
mean[2] = *(sourceptr - (step - 3));
mean[3] = *(sourceptr - 3);
mean[4] = *(sourceptr);
mean[5] = *(sourceptr + 3);
mean[6] = *(sourceptr + (step - 3));
mean[7] = *(sourceptr + step);
mean[8] = *(sourceptr + (step + 3));

Array.Sort(mean);
*(descptr++) = mean[4];
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;
byte* descptr = (byte*)descdata.Scan0;
for (int x = 0; x < source.Height; x++)
{
for (int y = 0; y < source.Width; y++)
{
*(descptr++) = (byte)(255 - *(sourceptr++));
*(descptr++) = (byte)(255 - *(sourceptr++));
*(descptr++) = (byte)(255 - *(sourceptr++));
}
sourceptr += sourcedata.Stride - source.Width * 3;
descptr += descdata.Stride - desc.Width * 3;
}
}
source.UnlockBits(sourcedata);
desc.UnlockBits(descdata);

2。霓虹灯

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 * 3;
double value;
for (int x = 0; x < source.Height; x++)
{
for (int y = 0; y < source.Width; y++)
{
value = 2 * Math.Sqrt((*sourceptr - *(sourceptr + 3)) * (*sourceptr - *(sourceptr + 3)) +
(*sourceptr - *(sourceptr + step)) * (*sourceptr - *(sourceptr + step)));
*(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);

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。绿色转换灰度

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 += 1;
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);

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。平均转换灰度

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) = *(descptr + 1) = *(descptr + 2) = (byte)((*sourceptr + *(sourceptr + 1) + *(sourceptr + 2)) / 3);
descptr += 3;
sourceptr += 3;
}
sourceptr += sourcedata.Stride - source.Width * 3;
descptr += descdata.Stride - desc.Width * 3;
}
}
source.UnlockBits(sourcedata);
desc.UnlockBits(descdata);

5。加权平均转换灰度

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) = *(descptr + 1) = *(descptr + 2) = (byte)(*sourceptr * 0.11 + *(sourceptr + 1) * 0.58 + *(sourceptr + 2) * 0.31);
descptr += 3;
sourceptr += 3;
}
sourceptr += sourcedata.Stride - source.Width * 3;
descptr += descdata.Stride - desc.Width * 3;
}
}
source.UnlockBits(sourcedata);
desc.UnlockBits(descdata);