利用边缘改进全局阈值处理-c#实现-基于EmguCv

关于边缘改进全局阈值处理基本实现是：

 1.先计算其边界，利用拉普拉斯或者梯度变换都以。

 2.计算变化后边界图像的绝对值

3.指定一个阈值（一般以百分比的形式指定，比如我指定90%，如果存在有灰度k,灰度小于K的像素总数占全部像素的90%，那么K就是我们要求的灰度）

4.对2中计算完的图像进行阈值变换，转化为2值图像

5.用4中计算得到的二值图像乘原始图像。

6.计算5中计算的到的图像中灰度大于0的直方图。

7.对6中得到的直方图进行全局分隔。

8.提出全局分隔出来的灰度，用该灰度对原始图片进行阈值分割，即可得到结果。

c#算法实现

主函数：

/// <summary>
/// 边界修饰自适应阈值变换
/// </summary>
/// <param name="image">输入图像</param>
/// <param name="percent">百分比</param>
/// <returns></returns>
public static Mat EdgeModifyOtsu(Mat image,double percent=0.99)
{
Mat _m = new Mat();//拉普拉斯变换后的图像
Mat _m1 = new Mat();
Mat _Rmat = new Mat();//要返回的图像
//拉普拉斯变换
CvInvoke.Laplacian(image, _m, Emgu.CV.CvEnum.DepthType.Cv16S,3);
//取绝对值
_m1 = AbsCv16s(_m);
//阈值变换
double max = PercentGary(_m1, percent);
CvInvoke.Threshold(_m1, _m1, max, 1, Emgu.CV.CvEnum.ThresholdType.Binary);

//转换为8字节
_m1 = Cv16sTo8u(_m1);

//与原图像相乘
CvInvoke.Multiply(_m1, image, _m1, 1, Emgu.CV.CvEnum.DepthType.Cv8U);
//寻找相乘后的图像灰度大于0的直方图的自适应阈值
int _K = OtsuThreshold(_m1, 1);
CvInvoke.Threshold(image, _Rmat, _K, 255, Emgu.CV.CvEnum.ThresholdType.Binary);
return _Rmat;
}

取绝对值函数：
/// <summary>
/// 将16位像素的灰度值绝对值化
/// </summary>
/// <param name="image">图片</param>
/// <returns>转换好的图片</returns>
public static Mat AbsCv16s(Mat image)
{
Mat _m_ = new Mat(image.Size, Emgu.CV.CvEnum.DepthType.Cv16S, 1);
unsafe
{
Int16* dataImage = (Int16*)image.DataPointer.ToPointer();
Int16* data_m_ = (Int16*)_m_.DataPointer.ToPointer();
for (int row = 0; row < image.Height; row++)
{
//data = data + row * image.Cols;
for (int col = 0; col < image.Width; col++)
{

Int16 _ii = *dataImage;
* data_m_ = Math.Abs(_ii);

dataImage++;
data_m_++;
}
}
}
return _m_;
}
用百分比计算分割函数：

/// <summary>
/// 计算图片百分比像素的灰度值
/// </summary>
/// <param name="image">输入图片</param>
/// <param name="percent">百分比像素</param>
/// <returns>返回灰度值</returns>
public static double PercentGary(Mat image, double percent)
{
long[] _his = Histogram(image, 0,16);
long _count = 0;//表示在k中存在的像素
for (int _index = 0; _index < Math.Pow(2,16); _index++)//若所有像素都在k内，就将其方差置为0
{
_count += _his[_index];
if ((double)_count / image.Total.ToInt64() > percent)
{
return _index;
}

}
return Math.Pow(2, 16);

}

将16位有符号二值图像转换为8位无符二值图像函数：

/// <summary>
/// 将16有符号位二值图转化为8位
/// </summary>
/// <param name="image">图片</param>
/// <returns>返回转换好的图片</returns>
public static Mat Cv16sTo8u(Mat image)
{
Mat _m_ = new Mat(image.Size, Emgu.CV.CvEnum.DepthType.Cv8U, 1);
unsafe
{
Int16* dataImage = (Int16*)image.DataPointer.ToPointer();
byte* data_m_ = (byte*)_m_.DataPointer.ToPointer();
for (int row = 0; row < image.Height; row++)
{
//data = data + row * image.Cols;
for (int col = 0; col < image.Width; col++)
{
*data_m_ = Convert.ToByte( Math.Abs(*dataImage));
dataImage++;
data_m_++;
}
}
}
return _m_;
}
寻找相乘后的图像灰度大于0的直方图的自适应阈值函数： 

/// <summary>
/// 寻找图片大于d值像素集的最适应阈值
/// </summary>
/// <param name="image">输入的图片</param>
/// <param name="d"></param>
/// <returns>返回最合适阈值</returns>
public static int OtsuThreshold(Mat image, int d)
{
long[] his = Histogram(image,8,d);

float _PK;
float _MK;//第k级累加灰度均值；
float _MG = 0;//整个图片的灰度均值

long _MN = 0;//图片的像素数目
float[] _Ks = new float[256];//存储类值最大方差
float _Max;//类间最大方差
List<int> _MaxKs = new List<int>();//存储使类间方差最大的多个K值；

for (int _index = 0; _index < his.Length; _index++)//计算直方图中像素的总数
{
_MN += his[_index];
}

for (int i = 0; i < 256; i++)//计算图片平均灰度值
{
_MG += (float)(i * (double)his[i] / _MN);
}

for (int k = 0; k < 256; k++)//计算 图片在不同K的类值最大方差
{
long _count = 0;//表示在k中存在的像素
for (int _index = 0; _index <= k; _index++)//若所有像素都在k内，就将其方差置为0
{
_count += his[_index];
}
if (_count == _MN)
{
_Ks[k] = 0;
continue;
}
else if (_count == 0)
{
_Ks[k] = 0;
continue;
}

_PK = (float)((double)_count / _MN);

_MK = 0;

for (int i = d; i <= k; i++)
{
float p = (float)((double)his[i] / _MN);
//_PK += p;
_MK += i * p;
}

_Ks[k] = (float)Math.Pow(_MG * _PK - _MK, 2) / (_PK * (1 - _PK));

}

_Ks[0] = 0;
_Max = _Ks.Max();
for (int i = 0; i < 256; i++)
{
if (_Ks[i] == _Max)
_MaxKs.Add(i);
}

int _K = (int)_MaxKs.Average();
return _K;
}

计算直方图函数：

/// <summary>
/// 图片灰度直方图计算
/// </summary>
/// <param name="image">图片</param>
/// <param name="depth">深度</param>
/// <param name="d">要跳过的灰度</param>
/// <returns></returns>
public static long[] Histogram(Mat image, int depth= 8,int d = 0)
{
if (image.NumberOfChannels != 1)
{
throw new Exception("通道必须为1");
}

//提取直方图------------------------------------
long[] _his = new long[(int) Math.Pow(2,depth)];
for (int i = d; i < (int)Math.Pow(2, depth); i++)
{
_his[i] = 0;
}

unsafe
{
byte* data = (byte*)image.DataPointer.ToPointer();

for (int row = 0; row < image.Height; row++)
{
//data = data +
987e
row * image.Cols;
for (int col = 0; col < image.Width; col++)
{
if (*data >= d)
{
_his[*data]++;
}
data++;
}
}
}
return _his;
}

   

这是基于emgucv基本的实现函数.

下面是其处理效果：

原始图片：



先用均值滤波器滤波，再用普通的otsu 得到的是：                                                                边界修饰后的：


                                                                      



原始图片：



普通Otsu处理结果：                                                                                                                                     边界修饰后：