• opencv [c++] OpenCV实现Halcon相关算子算法

    目录

     1.Dyn_threshold 动态阈值

     2.OpenCV实现

     2.Emphasize图像锐化增强处理

    3.select_shape()特征筛选

    4.opencv访问遍历图像的每一个像素方法

    5.Fill_up()区域填充算子

    6.Area_Center()计算区域面积与中心坐标

    7.sort_region()对区域进行排序

    8.shape_trans()区域转换算子

    9.opencv双阈值二值化---->Halcon的直方图双阈值二值化

     10.Gray_range_rect（）图像灰度增强预处理

    1.opencv4.3.0与VS2019环境配置见：

    https://blog.csdn.net/weixin_50016546/article/details/124770493

    2.opencv4.3.0与QT5.14.2环境配置见：

    QT5.14 [MSVC 2017编译版]与 OpenCV4.3.0 联编环境配置_NCUTer的博客-CSDN博客

     1.Dyn_threshold 动态阈值

    1. read_image (Image,'1.png')
    2. mean_image (Image,ImageMean,9,9)
    3. *动态阈值，也叫局部阈值
    4. dyn_threshold (Image, ImageMean, RegionDynThresh, 15, 'not_equal')

     2.OpenCV实现

    方案1：

    1. void dynthreshold_referHalcon(cv::Mat &frame_gray, int ksize, int offset) //仿Halcon
    2. {
    3.     cv::Mat srcMean;
    4.     cv::Mat RegionDynThresh;
    5.  
    6.     //均值滤波
    7.     blur(frame_gray, srcMean, cv::Size(9, 9));
    8.  
    9.     //动态阈值
    10.     RegionDynThresh = cv::Mat::zeros(frame_gray.size(), CV_8UC1);
    11.     DynThreshold(frame_gray, srcMean, RegionDynThresh, offset, Equal);
    12. }
    13.  
    14.  
    15. void DynThreshold(cv::Mat &src, cv::Mat &srcMean, cv::Mat &result, int offset, int LightDark)
    16. {
    17.     //使用Opencv实现Halcon中的动态阈值
    18.     //src是原图,灰度图
    19.     //srcMean是平滑滤波之后的图
    20.     //最好不要把Offset这个变量设置为0，因为这样会导致最后找到太多很小的regions，而这基本上都是噪声。
    21.     //所以这个值最好是在5-40之间，值选择的越大，提取出来的regions就会越小。
    22.     int r = src.rows; //高
    23.     int c = src.cols; //宽
    24.     int Value = 0;
    25.     for (int i = 0; i < r; i++)
    26.     {
    27.         uchar *datasrc = src.ptr<uchar>(i); //指针访问图像像素
    28.         uchar *datasrcMean = srcMean.ptr<uchar>(i);
    29.         uchar *dataresult = result.ptr<uchar>(i);
    30.  
    31.         for (int j = 0; j < c; j++)
    32.         {
    33.             switch (LightDark)
    34.             {
    35.             case Light:
    36.                 Value = datasrc[j] - datasrcMean[j];
    37.                 if (Value >= offset)
    38.                 {
    39.                     dataresult[j] = 255;
    40.                 }
    41.                 break;
    42.  
    43.             case Dark:
    44.                 Value = datasrcMean[j] - datasrc[j];
    45.                 if (Value >= offset)
    46.                 {
    47.                     dataresult[j] = 255;
    48.                 }
    49.                 break;
    50.  
    51.             case Equal:
    52.                 Value = datasrc[j] - datasrcMean[j];
    53.                 if (Value >= -offset && Value <= offset)
    54.                 {
    55.                     dataresult[j] = 255;
    56.                 }
    57.                 break;
    58.  
    59.             case Not_equal:
    60.                 Value = datasrc[j] - datasrcMean[j];
    61.                 if (Value < -offset || Value > offset)
    62.                 {
    63.                     dataresult[j] = 255;
    64.                 }
    65.                 break;
    66.  
    67.             default:
    68.                 break;
    69.             }
    70.         }
    71.     }
    72. }

     方案2：

    1. enum ThresholdType
    2. {
    3.     THRESHOLD_LIGHT,		//明
    4.     THRESHOLD_DARK,			//暗
    5.     THRESHOLD_EQUAL,		//等于
    6.     THRESHOLD_NOT_EQUAL		//不等于
    7. };
    8.  
    9. //功能：使用局部阈值分割图像
    10. //参数：
    11. //  src：输入图像
    12. //  pre：包含本地阈值的图像（一般可使用均值滤波后的图像）
    13. //  dst：输出图像
    14. //  offset：灰度偏移量（-255 ≤ offset ≤ 255）
    15. //  type：
    16. //      THRESHOLD_LIGHT（明）： g_src ≥ g_pre + offset
    17. //      THRESHOLD_DARK（暗）： g_src ≤ g_pre - offset
    18. //      THRESHOLD_EQUAL（等于）： g_pre - offset ≤ g_src ≤ g_pre + offset
    19. //      THRESHOLD_NOT_EQUAL（不等于）： g_pre - offset > g_src || g_src > g_pre + offset
    20. //返回值：无
    21. void dyn_threshold(Mat src, Mat pre, Mat &dst, int offset, ThresholdType type)
    22. {
    23.     dst = Mat(src.size(), CV_8UC1, Scalar(0));
    24.     int pixelsCount = src.rows * src.cols;
    25.  
    26.     for(int i = 0;i < pixelsCount; i++)
    27.     {
    28.         int g_src = src.data[i];
    29.         int g_pre = pre.data[i];
    30.         if (type == THRESHOLD_LIGHT)
    31.         {
    32.             if (g_src >= g_pre + offset)
    33.                 dst.data[i] = 255;
    34.         }
    35.         else if (type == THRESHOLD_DARK)
    36.         {
    37.             if (g_src <= g_pre - offset)
    38.                 dst.data[i] = 255;
    39.         }
    40.         else if (type == THRESHOLD_EQUAL)
    41.         {
    42.             if (g_src >= g_pre - offset && g_src <= g_pre + offset)
    43.                 dst.data[i] = 255;
    44.         }
    45.         else if (type == THRESHOLD_NOT_EQUAL)
    46.         {
    47.             if (g_src < g_pre - offset || g_src > g_pre + offset)
    48.                 dst.data[i] = 255;
    49.         }
    50.     }
    51. }

     2.Emphasize图像锐化增强处理

      Halcon算子： emphasize(img,outputimg,20,20,2)

    1. void emphasize(const cv::Mat &input, cv::Mat &output, int MaskWidth, int MaskHeight, float Factor)
    2. {
    3.     //公式res := round((orig - mean) * Factor) + orig
    4.     //等价于在MaskHeight、MaskWidth的空间内中心化后增加方差
    5.     cv::Mat mean;
    6.  
    7.     //等价于求指定范围窗口内的均值
    8.     cv::blur(input, mean, cv::Size(MaskWidth, MaskHeight));
    9.     output.create(input.size(), input.type());
    10.     if (input.type() == CV_8UC1)
    11.     {
    12.         for (int i = 0; i < input.rows; i++)
    13.         {
    14.             const uchar *rptr = input.ptr<uchar>(i);
    15.             uchar *mptr = mean.ptr<uchar>(i);
    16.             uchar *optr = output.ptr<uchar>(i);
    17.             for (int j = 0; j < input.cols; j++)
    18.             {
    19.                 optr[j] = cv::saturate_cast<uchar>(round((rptr[j] - mptr[j]) * Factor) + rptr[j] * 1.0f);
    20.             }
    21.         }
    22.     }
    23.     else if (input.type() == CV_8UC3)
    24.     {
    25.         for (int i = 0; i < input.rows; i++)
    26.         {
    27.             const uchar *rptr = input.ptr<uchar>(i);
    28.             uchar *mptr = mean.ptr<uchar>(i);
    29.             uchar *optr = output.ptr<uchar>(i);
    30.             for (int j = 0; j < input.cols; j++)
    31.             {
    32.                 //饱和转换 小于0的值会被置为0 大于255的值会被置为255
    33.                 optr[j * 3] = cv::saturate_cast<uchar>(round((rptr[j * 3] - mptr[j * 3]) * Factor) + rptr[j * 3] * 1.0f);
    34.                 optr[j * 3 + 1] = cv::saturate_cast<uchar>(round((rptr[j * 3 + 1] - mptr[j * 3 + 1]) * Factor) + rptr[j * 3 + 1] * 1.0f);
    35.                 optr[j * 3 + 2] = cv::saturate_cast<uchar>(round((rptr[j * 3 + 2] - mptr[j * 3 + 2]) * Factor) + rptr[j * 3 + 2] * 1.0f);
    36.             }
    37.         }
    38.     }
    39. }

    3.select_shape()特征筛选

    read_image (Image, '1.jpg')
    rgb1_to_gray (Image, GrayImage)
    threshold (GrayImage, Regions, 43, 120)
    connection (Regions, ConnectedRegions)
    select_shape (ConnectedRegions, SelectedRegions, 'area', 'and', 150, 666)
    select_shape (SelectedRegions, SelectedRegions1, 'circularity', 'and', 0.45, 1)

    opencv实现：

    方案1：

    1. #include "stdafx.h"
    2. #include <iostream>
    3. #include "opencv2/core/core.hpp"
    4. #include "opencv2/highgui/highgui.hpp"
    5. #include "opencv2/imgproc/imgproc.hpp"
    6. using namespace std;
    7. using namespace cv;
    8. #define  VP  vector<Point>  //用VP符号代替 vector<point>
    9.  
    10. RNG  rng (12345);
    11.  
    12. //带有上下限的threshold
    13. void threshold2(Mat gray,Mat& thresh,int minvalue,int maxvalue)
    14. {
    15.     Mat thresh1;
    16.     Mat thresh2;
    17.     threshold(gray,thresh1,43,255, THRESH_BINARY);
    18.     threshold(gray,thresh2,111,255,THRESH_BINARY_INV);
    19.     thresh = thresh1 & thresh2;
    20. }
    21.  
    22. //寻找并绘制出联通区域
    23. vector<vector<point>> connection2(Mat src,Mat& draw)
    24. {    
    25.     draw = Mat::zeros(src.rows,src.cols,CV_8UC3);
    26.     vector<vector<point>>contours;    
    27.     findContours(src,contours,CV_RETR_LIST,CV_CHAIN_APPROX_SIMPLE);
    28.     for (int i=0;i<contours.size();i++)
    29.     {
    30.         Scalar  color  = Scalar(rng.uniform(0,255),rng.uniform(0,255),rng.uniform(0,255));
    31.         drawContours(draw,contours,i,color,-1);
    32.     }
    33.     return contours;
    34. }
    35. //select_shape
    36. vector<vector<point>>  selectShapeArea(Mat src,Mat& draw,vector<VP> contours,int minvalue,int maxvalue)
    37. {
    38.     vector<vector<point>> result_contours;
    39.     draw = Mat::zeros(src.rows,src.cols,CV_8UC3);
    40.     for (int i=0;i<contours.size();i++)
    41.     { 
    42.         int countour_area = contourArea(contours[i]);
    43.         if (countour_area >minvalue && countour_area<maxvalue)
    44.         {
    45.             result_contours.push_back(contours[i]);
    46.         }
    47.     }
    48.     for (int i=0;i<result_contours.size();i++)
    49.     {
    50.         Scalar  color  = Scalar(rng.uniform(0,255),rng.uniform(0,255),rng.uniform(0,255));
    51.         drawContours(draw,result_contours,i,color,-1);
    52.     }
    53.     return result_contours;
    54. }
    55. //计算轮廓的圆的特性
    56. float calculateCircularity(vector<point> contour)
    57. {
    58.     Point2f center;
    59.     float radius = 0;
    60.     minEnclosingCircle((Mat)contour,center,radius);
    61.     //以最小外接圆半径作为数学期望，计算轮廓上各点到圆心距离的标准差
    62.     float fsum = 0;
    63.     float fcompare = 0;
    64.     for (int i=0;i<contour.size();i++)
    65.     {   
    66.         Point2f ptmp = contour[i];
    67.         float fdistenct = sqrt((float)((ptmp.x - center.x)*(ptmp.x - center.x)+(ptmp.y - center.y)*(ptmp.y-center.y)));
    68.         float fdiff = abs(fdistenct - radius);
    69.         fsum = fsum + fdiff;
    70.     }
    71.     fcompare = fsum/(float)contour.size();
    72.     return fcompare;
    73. }
    74. //select_shape
    75. vector<vector<point>> selectShapeCircularity(Mat src,Mat& draw,vector<VP> contours,float minvalue,float maxvalue)
    76. {
    77.     vector<vector<point>> result_contours;
    78.     draw = Mat::zeros(src.rows,src.cols,CV_8UC3);
    79.     for (int i=0;i<contours.size();i++)
    80.     {
    81.         float fcompare = calculateCircularity(contours[i]);
    82.         if (fcompare >=minvalue && fcompare <=maxvalue)
    83.         {
    84.             result_contours.push_back(contours[i]);
    85.         }
    86.     }
    87.     for (int i=0;i<result_contours.size();i++)
    88.     {
    89.         Scalar  color  = Scalar(rng.uniform(0,255),rng.uniform(0,255),rng.uniform(0,255));
    90.         drawContours(draw,result_contours,i,color,-1);
    91.     }
    92.     return result_contours;
    93. }
    94. int _tmain(int argc, _TCHAR* argv[])
    95. {    
    96.     Mat src;
    97.     Mat gray;
    98.     Mat thresh;
    99.     Mat draw_connection;
    100.     Mat draw_area;
    101.     Mat draw_circle;
    102.     vector<vector<point>>contours_connection;    
    103.     vector<vector<point>>contours_area;
    104.     vector<vector<point>>contours_circle;
    105.     vector<vector<point>>contours_tmp;
    106.     //read_image (Image1, '1.jpg')
    107.     src = imread("1.jpg");
    108.     //rgb1_to_gray (Image1, GrayImage)
    109.     cvtColor(src,gray,COLOR_BGR2GRAY);
    110.     //threshold (GrayImage, Regions, 43, 111)
    111.     threshold2(gray,thresh,43,111);
    112.     //connection (Regions, ConnectedRegions)
    113.     contours_connection = connection2(thresh.clone(),draw_connection);
    114.     //select_shape (ConnectedRegions, SelectedRegions, 'area', 'and', 150, 666)
    115.     contours_area = selectShapeArea(thresh.clone(),draw_area,contours_connection,150,666);
    116.     //select_shape (SelectedRegions, SelectedRegions1, 'circularity', 'and', 0.45, 1)
    117.     contours_circle = selectShapeCircularity(thresh.clone(),draw_circle,contours_area,1,6);
    118.     //显示结果
    119.     imshow("src",src);
    120.     imshow("thresh",thresh);
    121.     imshow("draw_connection",draw_connection);
    122.     imshow("draw_area",draw_area);
    123.     imshow("draw_circle",draw_circle);
    124.     waitKey();
    125. }

     方案2：

    1.  
    2.  
    3. enum SelectShapeType
    4. {
    5.     SELECT_AREA,			//选中区域面积
    6.     SELECT_RECTANGULARITY,	//选中区域矩形度
    7.     SELECT_WIDTH,			//选中区域宽度（平行于坐标轴）
    8.     SELECT_HEIGHT,			//选中区域高度（平行于坐标轴）
    9.     SELECT_ROW,				//选中区域中心行索引
    10.     SELECT_COLUMN,			//选中区域中心列索引
    11.     SELECT_RECT2_LEN1,		//选中区域最小外接矩形的一半长度
    12.     SELECT_RECT2_LEN2,		//选中区域最小外接矩形的一半宽度
    13.     SELECT_RECT2_PHI,   	//选中区域最小外接矩形的方向
    14.     SELECT_ELLIPSE_RA,      //选中区域外接椭圆的长半轴
    15.     SELECT_ELLIPSE_RB,      //选中区域外接椭圆的短半轴
    16.     SELECT_ELLIPSE_PHI      //选中区域外接椭圆的方向
    17. };
    18.  
    19. enum SelectOperation
    20. {
    21.     SELECT_AND,		//与
    22.     SELECT_OR		//或
    23. };
    24.  
    25. //功能：借助形状特征选择区域
    26. //参数：
    27. //  src：输入图像
    28. //  dst：输出图像
    29. //  types：要检查的形状特征
    30. //  operation：各个要素的链接类型（与、或）
    31. //  mins：下限值
    32. //  maxs：上限值
    33. //返回值：无
    34. int select_shape(Mat src, Mat &dst,
    35. 	vector<SelectShapeType> types,
    36. 	SelectOperation operation,
    37. 	vector<double> mins,
    38. 	vector<double> maxs)
    39. {
    40. 	if (!(types.size() == mins.size() && mins.size() == maxs.size()))
    41. 		return 0;
    42.  
    43. 	int num = types.size();
    44. 	dst = Mat(src.size(), CV_8UC1, Scalar(0));
    45.  
    46. 	vector<vector<Point>> contours;
    47. 	findContours(src, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);
    48. 	int cnum = contours.size();
    49.  
    50. 	vector<vector<Point>> selectContours;
    51. 	for (int i = 0; i < cnum; i++)
    52. 	{
    53. 		bool isAnd = true;
    54. 		bool isOr = false;
    55. 		for (int j = 0; j < num; j++)
    56. 		{
    57. 			double mind = mins[j];
    58. 			double maxd = maxs[j];
    59. 			if (mind > maxd)
    60. 			{
    61. 				mind = maxs[j];
    62. 				maxd = mins[j];
    63. 			}
    64. 			if (types[j] == SELECT_AREA)
    65. 			{
    66. 				Mat temp = Mat(src.size(), CV_8UC1, Scalar(0));
    67. 				vector<vector<Point>> pconver;
    68. 				pconver.push_back(contours[i]);
    69. 				drawContours(temp, pconver, -1, Scalar(255), CV_FILLED);
    70. 				bitwise_and(src, temp, temp);
    71. 				int area;
    72. 				Point2f center;
    73. 				area_center(temp, area, center);
    74. 				if (area >= mind && area <= maxd)
    75. 				{
    76. 					isAnd &= true;
    77. 					isOr |= true;
    78. 				}
    79. 				else
    80. 				{
    81. 					isAnd &= false;
    82. 					isOr |= false;
    83. 				}
    84. 			}
    85. 			else if (types[j] == SELECT_RECTANGULARITY)
    86. 			{
    87. 				Mat temp = Mat(src.size(), CV_8UC1, Scalar(0));
    88. 				vector<vector<Point>> pconver;
    89. 				pconver.push_back(contours[i]);
    90. 				drawContours(temp, pconver, -1, Scalar(255), CV_FILLED);
    91. 				bitwise_and(src, temp, temp);
    92. 				int area;
    93. 				Point2f center;
    94. 				area_center(temp, area, center);
    95. 				RotatedRect rect = minAreaRect(contours[i]);
    96. 				double rectangularity = area / rect.size.area();
    97. 				if (rectangularity >= mind && rectangularity <= maxd)
    98. 				{
    99. 					isAnd &= true;
    100. 					isOr |= true;
    101. 				}
    102. 				else
    103. 				{
    104. 					isAnd &= false;
    105. 					isOr |= false;
    106. 				}
    107. 			}
    108. 			else if (types[j] == SELECT_WIDTH)
    109. 			{
    110. 				Rect rect = boundingRect(contours[i]);
    111. 				if (rect.width >= mind && rect.width <= maxd)
    112. 				{
    113. 					isAnd &= true;
    114. 					isOr |= true;
    115. 				}
    116. 				else
    117. 				{
    118. 					isAnd &= false;
    119. 					isOr |= false;
    120. 				}
    121. 			}
    122. 			else if (types[j] == SELECT_HEIGHT)
    123. 			{
    124. 				Rect rect = boundingRect(contours[i]);
    125. 				if (rect.height >= mind && rect.height <= maxd)
    126. 				{
    127. 					isAnd &= true;
    128. 					isOr |= true;
    129. 				}
    130. 				else
    131. 				{
    132. 					isAnd &= false;
    133. 					isOr |= false;
    134. 				}
    135. 			}
    136. 			else if (types[j] == SELECT_ROW)
    137. 			{
    138. 				Mat temp = Mat(src.size(), CV_8UC1, Scalar(0));
    139. 				vector<vector<Point>> pconver;
    140. 				pconver.push_back(contours[i]);
    141. 				drawContours(temp, pconver, -1, Scalar(255), CV_FILLED);
    142. 				bitwise_and(src, temp, temp);
    143. 				int area;
    144. 				Point2f center;
    145. 				area_center(temp, area, center);
    146. 				if (center.y >= mind && center.y <= maxd)
    147. 				{
    148. 					isAnd &= true;
    149. 					isOr |= true;
    150. 				}
    151. 				else
    152. 				{
    153. 					isAnd &= false;
    154. 					isOr |= false;
    155. 				}
    156. 			}
    157. 			else if (types[j] == SELECT_COLUMN)
    158. 			{
    159. 				Mat temp = Mat(src.size(), CV_8UC1, Scalar(0));
    160. 				vector<vector<Point>> pconver;
    161. 				pconver.push_back(contours[i]);
    162. 				drawContours(temp, pconver, -1, Scalar(255), CV_FILLED);
    163. 				bitwise_and(src, temp, temp);
    164. 				int area;
    165. 				Point2f center;
    166. 				area_center(temp, area, center);
    167. 				if (center.x >= mind && center.x <= maxd)
    168. 				{
    169. 					isAnd &= true;
    170. 					isOr |= true;
    171. 				}
    172. 				else
    173. 				{
    174. 					isAnd &= false;
    175. 					isOr |= false;
    176. 				}
    177. 			}
    178. 			else if (types[j] == SELECT_RECT2_LEN1)
    179. 			{
    180. 				RotatedRect rect = minAreaRect(contours[i]);
    181. 				double len = rect.size.width;
    182. 				if (rect.size.width < rect.size.height)
    183. 					len = rect.size.height;
    184. 				if (len / 2 >= mind && len / 2 <= maxd)
    185. 				{
    186. 					isAnd &= true;
    187. 					isOr |= true;
    188. 				}
    189. 				else
    190. 				{
    191. 					isAnd &= false;
    192. 					isOr |= false;
    193. 				}
    194. 			}
    195. 			else if (types[j] == SELECT_RECT2_LEN2)
    196. 			{
    197. 				RotatedRect rect = minAreaRect(contours[i]);
    198. 				double len = rect.size.height;
    199. 				if (rect.size.width < rect.size.height)
    200. 					len = rect.size.width;
    201. 				if (len / 2 >= mind && len / 2 <= maxd)
    202. 				{
    203. 					isAnd &= true;
    204. 					isOr |= true;
    205. 				}
    206. 				else
    207. 				{
    208. 					isAnd &= false;
    209. 					isOr |= false;
    210. 				}
    211. 			}
    212. 			else if (types[j] == SELECT_RECT2_PHI)
    213. 			{
    214. 				RotatedRect rect = minAreaRect(contours[i]);
    215. 				float angle = 0;
    216. 				if (angle < 0) angle += 180;
    217. 				if (rect.size.width < rect.size.height)
    218. 				{
    219. 					angle = rect.angle;
    220. 					angle -= 90;
    221. 					if (angle < 0) angle += 180;
    222. 				}
    223. 				else
    224. 				{
    225. 					angle = rect.angle;
    226. 				}
    227. 				if (angle >= mind && angle <= maxd)
    228. 				{
    229. 					isAnd &= true;
    230. 					isOr |= true;
    231. 				}
    232. 				else
    233. 				{
    234. 					isAnd &= false;
    235. 					isOr |= false;
    236. 				}
    237. 			}
    238. 			else if (types[j] == SELECT_ELLIPSE_RA)
    239. 			{
    240. 				if (contours[i].size() < 5)
    241. 				{
    242. 					isAnd &= false;
    243. 					isOr |= false;
    244. 					continue;
    245. 				}
    246. 				RotatedRect rect = cv::fitEllipse(contours[i]);
    247. 				double len = rect.size.width;
    248. 				if (rect.size.width < rect.size.height)
    249. 					len = rect.size.height;
    250. 				if (len / 2 >= mind && len / 2 <= maxd)
    251. 				{
    252. 					isAnd &= true;
    253. 					isOr |= true;
    254. 				}
    255. 				else
    256. 				{
    257. 					isAnd &= false;
    258. 					isOr |= false;
    259. 				}
    260. 			}
    261. 			else if (types[j] == SELECT_ELLIPSE_RB)
    262. 			{
    263. 				if (contours[i].size() < 5)
    264. 				{
    265. 					isAnd &= false;
    266. 					isOr |= false;
    267. 					continue;
    268. 				}
    269. 				RotatedRect rect = cv::fitEllipse(contours[i]);
    270. 				double len = rect.size.height;
    271. 				if (rect.size.width < rect.size.height)
    272. 					len = rect.size.width;
    273. 				if (len / 2 >= mind && len / 2 <= maxd)
    274. 				{
    275. 					isAnd &= true;
    276. 					isOr |= true;
    277. 				}
    278. 				else
    279. 				{
    280. 					isAnd &= false;
    281. 					isOr |= false;
    282. 				}
    283. 			}
    284. 			else if (types[j] == SELECT_ELLIPSE_PHI)
    285. 			{
    286. 				if (contours[i].size() < 5)
    287. 				{
    288. 					isAnd &= false;
    289. 					isOr |= false;
    290. 					continue;
    291. 				}
    292. 				RotatedRect rect = cv::fitEllipse(contours[i]);
    293. 				float angle = 0;
    294. 				if (angle < 0) angle += 180;
    295. 				if (rect.size.width < rect.size.height)
    296. 				{
    297. 					angle = rect.angle;
    298. 					angle -= 90;
    299. 					if (angle < 0) angle += 180;
    300. 				}
    301. 				else
    302. 				{
    303. 					angle = rect.angle;
    304. 				}
    305. 				if (angle >= mind && angle <= maxd)
    306. 				{
    307. 					isAnd &= true;
    308. 					isOr |= true;
    309. 				}
    310. 				else
    311. 				{
    312. 					isAnd &= false;
    313. 					isOr |= false;
    314. 				}
    315. 			}
    316. 		}
    317. 		if (isAnd && operation == SELECT_AND)
    318. 			selectContours.push_back(contours[i]);
    319. 		if (isOr && operation == SELECT_OR)
    320. 			selectContours.push_back(contours[i]);
    321. 	}
    322. 	drawContours(dst, selectContours, -1, Scalar(255), CV_FILLED);
    323. 	bitwise_and(src, dst, dst);
    324. 	return selectContours.size();
    325. }

    4.opencv访问遍历图像的每一个像素方法

    1. void method_1(Mat &image) {
    2.     double t1 = getTickCount();
    3.     int w = image.cols;
    4.     int h = image.rows;
    5.     for (int row = 0; row < h; row++) {
    6.         for (int col = 0; col < w; col++) {
    7.             Vec3b bgr = image.at<Vec3b>(row, col);
    8.             bgr[0] = 255 - bgr[0];
    9.             bgr[1] = 255 - bgr[1];
    10.             bgr[2] = 255 - bgr[2];
    11.             image.at<Vec3b>(row, col) = bgr;
    12.         }
    13.     }
    14.     double t2 = getTickCount();
    15.     double t = ((t2 - t1) / getTickFrequency()) * 1000;
    16.     ostringstream ss;
    17.     ss << "Execute time : " << std::fixed << std::setprecision(2) << t << " ms ";
    18.     putText(image, ss.str(), Point(20, 20), FONT_HERSHEY_SIMPLEX, 0.75, Scalar(0, 0, 255), 2, 8);
    19.     imshow("result", image);
    20. }

    5.Fill_up()区域填充算子

    1. //功能：填充区域中的孔洞
    2. //参数：
    3. //  src：输入图像
    4. //  dst：输出图像
    5. //返回值：无
    6. void fill_up(Mat src, Mat &dst)
    7. {
    8.     dst = Mat(src.size(), CV_8UC1, Scalar(0));
    9.     vector<vector<Point>> contours;
    10.     findContours(src, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);
    11.     drawContours(dst, contours, -1, Scalar(255), CV_FILLED);
    12. }

    6.Area_Center()计算区域面积与中心坐标

    1. //功能：求图中像素值为255的斑块面积和重心坐标
    2. //参数：
    3. //  src：输入图像
    4. //  area：图中像素值为255的像素个数
    5. //  center：斑块的重心坐标
    6. //返回值：无
    7. void area_center(Mat src, int &area, Point2f &center)
    8. {
    9.     int pixelsCount = src.rows * src.cols;
    10.     area = 0;
    11.     center = Point2f(0, 0);
    12.     float centerX = 0;
    13.     float centerY = 0;
    14.     int mcol = src.cols;
    15.     for(int i=0;i<pixelsCount;i++)
    16.     {
    17.         if(src.data[i] == 255)
    18.         {
    19.             area++;
    20.  
    21.             int x = i % mcol;
    22.             int y = i / mcol;
    23.  
    24.             centerX += x;
    25.             centerY += y;
    26.         }
    27.     }
    28.     if (area > 0)
    29.     {
    30.         centerX /= area;
    31.         centerY /= area;
    32.         center = Point2f(centerX, centerY);
    33.     }
    34. }

    7.sort_region()对区域进行排序

    1.  
    2. enum SortCriterion
    3. {
    4.     FIRST_POINT,    //区域第一行的最左侧的点
    5.     LAST_POINT,     //区域最后一行的最右侧的点
    6.     UPPER_LEFT,     //区域周围矩形的左上角
    7.     UPPER_RIGHT,    //区域周围矩形的右上角
    8.     LOWER_LEFT,     //区域周围矩形的左下角
    9.     LOWER_RIGHT     //区域周围矩形的右下角
    10. };
    11.  
    12. enum SortDirection
    13. {
    14.     ROW,        //区域按行排列，即从左到右，从上到下
    15.     COLUMN      //区域按列排列，即从上到下，从左到右
    16. };
    17.  
    18. //功能：由区域的相对位置对区域进行排序
    19. //参数：
    20. //  src：输入图像
    21. //  contours：输入图像中的轮廓组
    22. //  pos：已排序的轮廓索引
    23. //  sc：排序基准点
    24. //  isDue：
    25. //      true：从小到大进行排序
    26. //      false：从大到小进行排序
    27. //  sd：排序方向
    28. //返回值：true：排序成功
    29. //		 false：排序失败
    30. bool sort_region(Mat src,vector<vector<Point>> contours, vector<int> &pos,
    31.                  SortCriterion sc, bool isDue, SortDirection sd)
    32. {
    33.     int count = contours.size();
    34.     pos.resize(count);
    35.     vector<Point> points;
    36.     for (int i = 0; i < count; i++)
    37.     {
    38.         pos[i] = i;
    39.         Rect rect = boundingRect(contours[i]);
    40.         if (sc == FIRST_POINT)
    41.         {
    42.             int row = rect.y;
    43.             for (int col = rect.x; col <= rect.x + rect.width; col++)
    44.             {
    45.                 if (src.at<uchar>(row, col) > 0)
    46.                 {
    47.                     points.push_back(Point(col, row));
    48.                     break;
    49.                 }
    50.             }
    51.         }
    52.         else if (sc == LAST_POINT)
    53.         {
    54.             int row = rect.y + rect.height;
    55.             for (int col = rect.x + rect.width; col >= rect.x; col--)
    56.             {
    57.                 if (src.at<uchar>(row, col) > 0)
    58.                 {
    59.                     points.push_back(Point(col, row));
    60.                     break;
    61.                 }
    62.             }
    63.         }
    64.         else if (sc == UPPER_LEFT)
    65.             points.push_back(rect.tl());
    66.         else if (sc == UPPER_RIGHT)
    67.             points.push_back(Point(rect.x + rect.width, rect.y));
    68.         else if (sc == LOWER_LEFT)
    69.             points.push_back(Point(rect.x, rect.y + rect.height));
    70.         else if (sc == LOWER_RIGHT)
    71.             points.push_back(rect.br());
    72.     }
    73.     int np = points.size();
    74.     if (np != count)
    75.         return false;
    76.     if (sd == ROW)
    77.     {
    78.         for (int i = 0; i < count - 1; i++)
    79.         {
    80.             for (int j = 0; j < count - 1 - i; j++)
    81.             {
    82.                 if (isDue)
    83.                 {
    84.                     if (points[j].y > points[j + 1].y)
    85.                     {
    86.                         Point temp = points[j];
    87.                         points[j] = points[j + 1];
    88.                         points[j + 1] = temp;
    89.  
    90.                         int index = pos[j];
    91.                         pos[j] = pos[j + 1];
    92.                         pos[j + 1] = index;
    93.                     }
    94.                 }
    95.                 else
    96.                 {
    97.                     if (points[j].y < points[j + 1].y)
    98.                     {
    99.                         Point temp = points[j];
    100.                         points[j] = points[j + 1];
    101.                         points[j + 1] = temp;
    102.  
    103.                         int index = pos[j];
    104.                         pos[j] = pos[j + 1];
    105.                         pos[j + 1] = index;
    106.                     }
    107.                 }
    108.             }
    109.         }
    110.         for (int i = 0; i < count - 1; i++)
    111.         {
    112.             for (int j = 0; j < count - 1 - i; j++)
    113.             {
    114.                 if (points[j].y == points[j + 1].y)
    115.                 {
    116.                     if (isDue)
    117.                     {
    118.                         if (points[j].x > points[j + 1].x)
    119.                         {
    120.                             Point temp = points[j];
    121.                             points[j] = points[j + 1];
    122.                             points[j + 1] = temp;
    123.  
    124.                             int index = pos[j];
    125.                             pos[j] = pos[j + 1];
    126.                             pos[j + 1] = index;
    127.                         }
    128.                     }
    129.                     else
    130.                     {
    131.                         if (points[j].x < points[j + 1].x)
    132.                         {
    133.                             Point temp = points[j];
    134.                             points[j] = points[j + 1];
    135.                             points[j + 1] = temp;
    136.  
    137.                             int index = pos[j];
    138.                             pos[j] = pos[j + 1];
    139.                             pos[j + 1] = index;
    140.                         }
    141.                     }
    142.                 }
    143.             }
    144.         }
    145.     }
    146.     else if (sd == COLUMN)
    147.     {
    148.         for (int i = 0; i < count - 1; i++)
    149.         {
    150.             for (int j = 0; j < count - 1 - i; j++)
    151.             {
    152.                 if (isDue)
    153.                 {
    154.                     if (points[j].x > points[j + 1].x)
    155.                     {
    156.                         Point temp = points[j];
    157.                         points[j] = points[j + 1];
    158.                         points[j + 1] = temp;
    159.  
    160.                         int index = pos[j];
    161.                         pos[j] = pos[j + 1];
    162.                         pos[j + 1] = index;
    163.                     }
    164.                 }
    165.                 else
    166.                 {
    167.                     if (points[j].x < points[j + 1].x)
    168.                     {
    169.                         Point temp = points[j];
    170.                         points[j] = points[j + 1];
    171.                         points[j + 1] = temp;
    172.  
    173.                         int index = pos[j];
    174.                         pos[j] = pos[j + 1];
    175.                         pos[j + 1] = index;
    176.                     }
    177.                 }
    178.             }
    179.         }
    180.         for (int i = 0; i < count - 1; i++)
    181.         {
    182.             for (int j = 0; j < count - 1 - i; j++)
    183.             {
    184.                 if (points[j].x == points[j + 1].x)
    185.                 {
    186.                     if (isDue)
    187.                     {
    188.                         if (points[j].y > points[j + 1].y)
    189.                         {
    190.                             Point temp = points[j];
    191.                             points[j] = points[j + 1];
    192.                             points[j + 1] = temp;
    193.  
    194.                             int index = pos[j];
    195.                             pos[j] = pos[j + 1];
    196.                             pos[j + 1] = index;
    197.                         }
    198.                     }
    199.                     else
    200.                     {
    201.                         if (points[j].y < points[j + 1].y)
    202.                         {
    203.                             Point temp = points[j];
    204.                             points[j] = points[j + 1];
    205.                             points[j + 1] = temp;
    206.  
    207.                             int index = pos[j];
    208.                             pos[j] = pos[j + 1];
    209.                             pos[j + 1] = index;
    210.                         }
    211.                     }
    212.                 }
    213.             }
    214.         }
    215.     }
    216.     return true;
    217. }

    8.shape_trans()区域转换算子

    1.  
    2. enum ShapeTransType
    3. {
    4.     SHAPETRANS_RECTANGLE,	//平行于坐标轴的最小外接矩形
    5.     SHAPETRANS_CIRCLE,		//最小外接圆
    6.     SHAPETRANS_CONVER		//凸包
    7. };
    8.  
    9. //功能：变换区域的形状
    10. //参数：
    11. //  src：输入图像
    12. //  dst：输出图像
    13. //  type：变换形状
    14. //返回值：无
    15. void shape_trans(Mat src, Mat &dst, ShapeTransType type)
    16. {
    17.     dst = Mat(src.size(), CV_8UC1, Scalar(0));
    18.     vector<vector<Point>> contours;
    19.     findContours(src, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);
    20.     int n = contours.size();
    21.     for (int i = 0; i < n; i++)
    22.     {
    23.         if (type == SHAPETRANS_RECTANGLE)
    24.         {
    25.             Rect rect = boundingRect(contours[i]);
    26.             rectangle (dst, rect, Scalar(255), CV_FILLED);
    27.         }
    28.         else if (type == SHAPETRANS_CIRCLE)
    29.         {
    30.             Point2f center;
    31.             float radius;
    32.             minEnclosingCircle(contours[i], center, radius);
    33.             circle (dst, center, radius, Scalar(255), CV_FILLED);
    34.         }
    35.         else if (type == SHAPETRANS_CONVER)
    36.         {
    37.             vector<Point> conver;
    38.             convexHull(contours[i], conver);
    39.  
    40.             vector<vector<Point>> pconver;
    41.             pconver.push_back(conver);
    42.  
    43.             fillPoly(dst, pconver, Scalar(255));
    44.         }
    45.     }
    46. }
    47.

    9.opencv双阈值二值化---->Halcon的直方图双阈值二值化

    halcon算子：

                    threshold(img , region , 40 , 160 )

    1. 	//正向阈值二值化与反向阈值二值化按位与操作取交集
    2.     Mat src= imread("1.png");
    3. 	Mat m1, m2, dst;
    4. 	threshold(src, m1, 40, 255, cv::THRESH_BINARY);
    5. 	threshold(src, m2, 160, 255, cv::THRESH_BINARY_INV);
    6. 	bitwise_and(m1, m2, dst);
    1. void Threshold(cv::Mat &src, cv::Mat &dst, int lowThresh, int highThresh)
    2. {
    3.     if(src.empty())
    4.     {
    5.         std::cout<<"src is empty"<<std::endl;
    6.         return;
    7.     }
    8.     dst = cv::Mat::zeros(src.size(), src.type());
    9.     double t = (double)cv::getTickCount();
    10.  
    11.     for(int i = 0; i < src.rows; i++)
    12.     {
    13.         uchar *srcPt = (uchar*)src.data + i * src.step;
    14.         uchar *dstPt = (uchar*)dst.data + i * dst.step;
    15.  
    16.         for(int j = 0; j < src.cols; j++)
    17.         {
    18.             uchar pixel = *srcPt++;
    19.             if(pixel > lowThresh && pixel < highThresh)
    20.                 *dstPt =  255;
    21.             dstPt++;
    22.         }
    23.     }
    24.     t = ((double)cv::getTickCount() - t) / cv::getTickFrequency()*1000; //获得时间，单位是毫秒
    25.     cout <<"耗时:"<< t<<"ms"<<endl;
    26. }
    27.

     10.Gray_range_rect（）图像灰度增强预处理

    1. //halcon gray_range_rect算子的C++实现
    2. void gray_range_rect(Mat &src, Mat &dst, Size size)
    3. {
    4. 	//图像边界扩充
    5. 	int hh = (size.height - 1) / 2;
    6. 	int hw = (size.width - 1) / 2;
    7. 	cv::Mat Newsrc;
    8. 	cv::copyMakeBorder(src, Newsrc, hh, hh, hw, hw, cv::BORDER_REFLECT_101);//以边缘为轴，对称
    9. 	dst = cv::Mat::zeros(src.rows, src.cols, src.type());
    10.  
    11. 	//遍历图像
    12. 	for (int i = 0; i < src.rows; i++)
    13. 	{
    14. 		for (int j = 0; j < src.cols; j++)
    15. 		{
    16. 			//uchar srcValue = src.at<uchar>(i, j);
    17. 			int minValue = 255;
    18. 			int maxValue = 0;
    19. 			for (int k = 0; k < hh; k++)
    20. 			{
    21. 				for (int z = 0; z < hw; z++)
    22. 				{
    23. 					int srcValue = (int)Newsrc.at<uchar>(i + k, j + z);
    24. 					minValue = minValue > srcValue ? srcValue : minValue;
    25. 					maxValue = maxValue > srcValue ? maxValue : srcValue;
    26.  
    27. 				}
    28. 			}
    29. 			uchar diffValue = (uchar)(maxValue - minValue);
    30. 			dst.at<uchar>(i, j) = diffValue;
    31. 		}
    32. 	}
    33. }

    后续学习更新。。

  • 相关阅读:
    智能家居项目开发准备工作
    Windows 本地安装 Mysql8.0
    自学系列之小游戏---贪吃蛇（vue3+ts+vite+element-plus+sass)（module.scss + tsx）
    2022年了你还不了解箭头函数与普通函数的区别吗？
    《向量数据库》——都有哪些向量数据库，都有什么特点？
    springmvc3：ajax请求，文件上传下载，拦截器，异常处理，注解配置mvc
    奢侈品鉴定机构小程序开发制作功能介绍
    软考 系统架构设计师 简明教程 | 系统设计
    9、MySQL——表与表之间的关系，多表查询、MySQL数据库的备份与恢复
    Android 蓝牙设备类型判断代码介绍
  • 原文地址：https://blog.csdn.net/weixin_50016546/article/details/125465347