CPL
/
geboshi_V2
1
0
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Laidieni 0 Vikivietne Aktivitāte
革博士V2程序
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
8 Revīzijas
2 Atzari
904 MiB
 
Koks: 9ed8b006e0
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no '9ed8b006e0'
${ noResults }
geboshi_V2/LeatherProject/GeBoShi/SysCtrl/OpencvUtils.cs

875 rindas
36 KiB
Neapstrādāts Vainot Vēsture 

  1. #define online

  2. using DocumentFormat.OpenXml.Spreadsheet;

  3. using HalconDotNet;

  4. using OpenCvSharp;

  5. using OpenCvSharp.XImgProc;

  6. using System;

  7. using System.Collections.Generic;

  8. using System.Linq;

  9. using System.Runtime.InteropServices;

  10. using System.Security.Cryptography;

  11. using System.Text;

  12. using System.Threading.Tasks;

  13. 

  14. namespace GeBoShi.SysCtrl

  15. {

  16.     public static class OpencvUtils

  17.     {

  18.         public static int image_width = 2048;

  19.         public static int image_height = 2048;

  20.         #region 图像预处理

  21.         public static Mat Resize(Mat mat, int width, int height, out int xw)

  22.         {

  23.             OpenCvSharp.Size dsize = new OpenCvSharp.Size(width, height);

  24.             //Mat mat2 = new Mat();

  25.             //ResizeUniform(mat, dsize, out mat2, out xw);

  26.  

  27.             xw = (width - mat.Cols) / 2;

  28.             Mat mat2 = new Mat(height, width, MatType.CV_8UC3, new Scalar(114, 114, 114));

  29.             Rect roi = new Rect((width - mat.Cols) / 2, (height - mat.Rows) / 2, mat.Cols, mat.Rows);

  30.             mat.CopyTo(new Mat(mat2, roi));

  31. 

  32.             return mat2;

  33.         }

  34.         /// <summary>

  35.         /// 等比例缩放

  36.         /// </summary>

  37.         /// <param name="src"></param>

  38.         /// <param name="dst_size"></param>

  39.         /// <param name="dst"></param>

  40.         /// <returns></returns>

  41.         public static int ResizeUniform(Mat src, Size dst_size, out Mat dst, out int xw)

  42.         {

  43.             xw = 0;

  44.             int w = src.Cols;

  45.             int h = src.Rows;

  46.             int dst_w = dst_size.Width;

  47.             int dst_h = dst_size.Height;

  48.             //std::cout << "src: (" << h << ", " << w << ")" << std::endl;

  49.             dst = new Mat(dst_h, dst_w, MatType.CV_8UC3, new Scalar(114, 114, 114));

  50. 

  51.             float[] ratio = new float[2];

  52.             float ratio_src = w * 1.0f / h;

  53.             float ratio_dst = dst_w * 1.0f / dst_h;

  54. 

  55.             int tmp_w = 0;

  56.             int tmp_h = 0;

  57.             if (ratio_src > ratio_dst)

  58.             {

  59.                 tmp_w = dst_w;

  60.                 tmp_h = (int)(dst_w * 1.0f / w) * h;

  61. 

  62.                 ratio[0] = (float)w / (float)tmp_w;

  63.                 ratio[1] = (float)h / (float)tmp_h;

  64.             }

  65.             else if (ratio_src < ratio_dst)

  66.             {

  67.                 tmp_h = dst_h;

  68.                 tmp_w = (int)((dst_h * 1.0f / h) * w);

  69. 

  70.                 ratio[0] = (float)w / (float)tmp_w;

  71.                 ratio[1] = (float)h / (float)tmp_h;

  72.             }

  73.             else

  74.             {

  75.                 Cv2.Resize(src, dst, dst_size);

  76. 

  77.                 ratio[0] = (float)w / (float)tmp_w;

  78.                 ratio[1] = (float)h / (float)tmp_h;

  79.                 return 0;

  80.             }

  81. 

  82.             //std::cout << "tmp: (" << tmp_h << ", " << tmp_w << ")" << std::endl;

  83.             Mat tmp = new Mat();

  84.             Cv2.Resize(src, tmp, new Size(tmp_w, tmp_h));

  85. 

  86.             unsafe

  87.             {

  88.                 if (tmp_w != dst_w)

  89.                 { //高对齐，宽没对齐

  90.                     int index_w = (int)((dst_w - tmp_w) / 2.0);

  91.                     xw = index_w;

  92.                     //std::cout << "index_w: " << index_w << std::endl;

  93.                     for (int i = 0; i < dst_h; i++)

  94.                     {

  95.                         Buffer.MemoryCopy(IntPtr.Add(tmp.Data, i * tmp_w * 3).ToPointer(), IntPtr.Add(dst.Data, i * dst_w * 3 + index_w * 3).ToPointer(), tmp_w * 3, tmp_w * 3);

  96.                     }

  97.                 }

  98.                 else if (tmp_h != dst_h)

  99.                 { //宽对齐， 高没有对齐

  100.                     int index_h = (int)((dst_h - tmp_h) / 2.0);

  101.                     //std::cout << "index_h: " << index_h << std::endl;

  102.                     Buffer.MemoryCopy(tmp.Data.ToPointer(), IntPtr.Add(dst.Data, index_h * dst_w * 3).ToPointer(), tmp_w * tmp_h * 3, tmp_w * tmp_h * 3);

  103.                 }

  104.                 else

  105.                 {

  106.                 }

  107.             }

  108.             return 0;

  109.         }

  110.         public static Mat ResizeMat(Mat mat, int width, int height)

  111.         {

  112.             OpenCvSharp.Size dsize = new OpenCvSharp.Size(width, height);

  113.             Mat mat2 = new Mat();

  114.             mat2 = mat.Resize(dsize);

  115.             //Cv2.Resize(mat, mat2, dsize);

  116.             return mat2;

  117.         }

  118. 

  119.         /// <summary>

  120.         /// 计算合理宽幅

  121.         /// </summary>

  122.         /// <param name="sumWidth">多个相机图像总宽(外部去除重合部分)</param>

  123.         /// <returns></returns>

  124.         public static int GetWidthForResize(int sumWidth)

  125.         {

  126.             //保证计算8x2 16个小图

  127.             int count = (int)Math.Round(sumWidth * 1.0f / image_width, 0);

  128.             count = 8;

  129.             return count * image_width;

  130. 

  131.             //int count = sumWidth / image_width;

  132.             ////int remainder = sumWidth % image_width;

  133.             //if (count % 2 == 0) 

  134.             //    return count * image_width; 

  135.             //else

  136.             //    return count * image_width+ image_width; 

  137.         }

  138.         /// <summary>

  139.         /// 裁切指定区域

  140.         /// </summary>

  141.         /// <param name="mat"></param>

  142.         /// <param name="x"></param>

  143.         /// <param name="y"></param>

  144.         /// <param name="width"></param>

  145.         /// <param name="height"></param>

  146.         /// <returns></returns>

  147.         public static Mat CutImage(Mat mat, int x, int y, int width, int height)

  148.         {

  149.             Rect roi = new Rect(x, y, width, height);

  150.             return new Mat(mat, roi).Clone();

  151.         }

  152.         #endregion

  153. 

  154.         #region 裁边

  155.         /// <summary>

  156.         /// 裁边

  157.         /// </summary>

  158.         /// <param name="mat_rgb"></param>

  159.         /// <param name="isLeft"></param>

  160.         /// <param name="marginHoleWidth"></param>

  161.         /// <param name="marginWidth"></param>

  162.         /// <returns></returns>

  163.         public static Mat getMaxInsetRect2(Mat mat_rgb, bool isLeft, int marginHoleWidth, bool IsAI, out int marginWidth)

  164.         {

  165.             int bian = 3500;

  166.             Rect Roi;

  167.             if (!isLeft)

  168.                 Roi = new Rect(mat_rgb.Width - bian, 0, bian, mat_rgb.Height);

  169.             else

  170.                 Roi = new Rect(0, 0, bian, mat_rgb.Height);

  171.             int type = isLeft ? 1 : 0;

  172.             int len = 0;

  173.             if(!IsAI)

  174.                 len = EdgeClipping2(mat_rgb, type, Roi, isLeft);

  175.             else

  176.                 len = EdgeClipping3(mat_rgb, type, Roi, isLeft);

  177. #if false

  178.             //Mat mat_rgb = new Mat("E:\\CPL\\测试代码\\边缘检测\\test\\test\\test\\img\\19.bmp");

  179.             Mat image_gray = new Mat();

  180.             Cv2.CvtColor(mat_rgb, image_gray, ColorConversionCodes.BGR2GRAY);

  181.             //cvtColor(image_RGB, image, COLOR_RGB2GRAY);

  182.             int height = image_gray.Rows;

  183.             int width = image_gray.Cols;

  184.            

  185.             // 算法定义：取均分5段图片的五条横线，经过一系列处理之后，二值化，找到沿边位置，然后取均值作为直边，在缩进一段有针眼的位置

  186.             // 定义每段的行数 

  187.             int num_rows = 5;

  188.             int segment_height = height / num_rows - 1;

  189. 

  190.             // 定义空数组保存结果

  191.             int[] total = new int[num_rows];

  192. 

  193.             // 平均截取5行数据并处理图像

  194.             for (int i = 0; i < num_rows; i++)

  195.             {

  196.                 // 截取当前行的图像

  197.                 int start_row = i * segment_height;

  198.                 Rect roi = new Rect(0, start_row, width, 1);

  199.                 Mat current_segment = image_gray.Clone(roi);

  200. 

  201.                 // 对当前行的图像进行平滑处理

  202.                 Mat smoothed_image = new Mat();

  203.                 Cv2.GaussianBlur(current_segment, smoothed_image, new Size(5, 1), 0);

  204. 

  205.                 // 计算当前行的灰度直方图

  206.                 Mat absolute_histo = new Mat();

  207.                 Cv2.CalcHist(new Mat[] { smoothed_image }, new int[] { 0 }, new Mat(), absolute_histo, 1, new int[] { 256 }, new Rangef[] { new Rangef(0, 256) });

  208.                 Cv2.GaussianBlur(current_segment, smoothed_image, new Size(19, 1), 0);

  209. 

  210.                 // 对图片进行分割i+1

  211.                 //double otsu_threshold;

  212.                 //threshold(smoothed_image, smoothed_image, 0, 255, THRESH_BINARY + THRESH_OTSU, &otsu_threshold);

  213.                 Cv2.Threshold(smoothed_image, smoothed_image, 0, 255, ThresholdTypes.Binary | ThresholdTypes.Otsu);

  214. 

  215.                 // 使用形态学操作进行孔洞填充

  216.                 Mat kernel = Cv2.GetStructuringElement(MorphShapes.Rect, new Size(25, 1));

  217.                 Mat filled_image = new Mat();

  218.                 Cv2.MorphologyEx(smoothed_image, filled_image, MorphTypes.Close, kernel);

  219. 

  220.                 // 取较长的一个值作为皮革的宽度

  221.                 int num_255 = Cv2.CountNonZero(filled_image);

  222.                 int length_t = (num_255 > width / 2) ? num_255 : width - num_255;

  223.                 total[i] = (length_t);

  224.                 API.OutputDebugString($"getMaxInsetRect2: 【{i + 1}】{length_t}={num_255}|{width}");

  225.             }

  226.             // 取平均值作为宽度

  227.             int length = (int)total.Average();

  228.             marginWidth = width-length;

  229. #endif

  230.             int length = len; //(len > mat_rgb.Width / 2) ? len : mat_rgb.Width - len;

  231.             if (isLeft)

  232.                 marginWidth = length;

  233.             else

  234.                 marginWidth = mat_rgb.Width - length;

  235.             // 判断数据是否异常，判断当前线段的宽度是否大于设定像素的偏差

  236.             //int abnormal_pxl = 200;

  237.             //for (int i = 0; i < num_rows; i++)

  238.             //{

  239.             //    if (Math.Abs(total[i] - length) > abnormal_pxl)

  240.             //        throw  new Exception("数据异常,当段图片的宽度有问题!");

  241.             //}

  242. 

  243.             //右侧相机，拍摄产品，边缘位于右侧判断，缩进100像素，去点针眼

  244.             //Cv2.Line(mat_rgb, new Point(length - 100, 0), new Point(length - 100, height), new Scalar(255, 0, 0), 20);

  245.             ////左侧相机，拍摄产品，边缘位于左侧判断，缩进100像素，去点针眼

  246.             //Cv2.Line(mat_rgb, new Point(width - length + 100, 0), new Point(width - length + 100, height), new Scalar(0, 255, 0), 20);

  247. 

  248.             //int decWidth = width - length + marginHoleWidth;

  249.             //if (isLeft)

  250.             //    return cutImage(mat_rgb, decWidth, 0, width- decWidth, height);

  251.             //else

  252.             //    return cutImage(mat_rgb, 0, 0, width - decWidth, height);

  253. 

  254.             //API.OutputDebugString($"getMaxInsetRect2:margin={marginWidth}，length={length}({marginHoleWidth}),isLeft={isLeft},mat_rgb={mat_rgb.Width}*{mat_rgb.Height},w={length - marginHoleWidth},h={mat_rgb.Height}");

  255. #if online

  256.             if (isLeft)

  257.                 return CutImage(mat_rgb, length + marginHoleWidth, 0, mat_rgb.Width - length - marginHoleWidth, mat_rgb.Height);

  258.             else

  259.                 return CutImage(mat_rgb, 0, 0, length - marginHoleWidth, mat_rgb.Height);

  260. #else

  261.             if (isLeft)

  262.             {

  263.                 Cv2.Line(mat_rgb, new Point(length + marginHoleWidth, 0), new Point(length + marginHoleWidth, mat_rgb.Height), new Scalar(255, 0, 0), 20);

  264.                 return mat_rgb;

  265.             }

  266.             else

  267.             {

  268.                 Cv2.Line(mat_rgb, new Point(length - marginHoleWidth, 0), new Point(length - marginHoleWidth, mat_rgb.Height), new Scalar(0, 255, 0), 20);

  269.                 return mat_rgb;

  270.             }

  271. #endif

  272.         }

  273. 

  274.         /// <summary>

  275.         /// 寻边算法

  276.         /// </summary>

  277.         /// <param name="image"></param>

  278.         /// <param name="FindType"></param>

  279.         /// <param name="Roi"></param>

  280.         /// <param name="IsLeft"></param>

  281.         /// <returns></returns>

  282.         private static int EdgeClipping2(Mat image, int FindType, Rect Roi, bool IsLeft)

  283.         {

  284.             Mat mat_rgb = image.Clone(Roi);

  285.             int height = mat_rgb.Rows;

  286.             int width = mat_rgb.Cols;

  287.             int sf = 10; //缩放比例

  288.             int pix = 5; //获取均值区域长宽像素

  289.             int pointNum = 15; //获取找遍点数

  290.             int offsetGray = 5; //二值化偏差

  291. 

  292.             //按比例缩放

  293.             int sf_height = height / sf;

  294.             int sf_width = width / sf;

  295. 

  296.             Cv2.Resize(mat_rgb, mat_rgb, new Size(sf_width, sf_height), 0, 0, InterpolationFlags.Linear);

  297.             //mat_rgb = mat_rgb.Resize(new Size(sf_width, sf_height));

  298. 

  299.             int[] maxlev = new int[3] { 3, 1, 0 };

  300.             int[] srlev = new int[3] { 29, 25, 11 };

  301.             int length_t = 0;

  302.             Mat[] lineImg = new Mat[3];

  303.             List<int> lines = new List<int>();

  304.             List<int> total_t = new List<int>();

  305.             for (int lv = 0; lv < 3; lv++)

  306.             {

  307.                 lines.Clear();

  308.                 total_t.Clear();

  309.                 Mat himg = mat_rgb.Clone();

  310.                 //mat_rgb = mat_rgb.PyrMeanShiftFiltering(10, 27, 3);

  311.                 Cv2.PyrMeanShiftFiltering(himg, himg, 10, srlev[lv], maxlev[lv]);//10,17;

  312. 

  313.                 //分通道处理

  314.                 Mat[] mv = Cv2.Split(himg);     

  315.                 for (int cht = 0; cht < 3; cht++)

  316.                 {

  317.                     //转灰度图

  318.                     //mat_rgb = mat_rgb.CvtColor(ColorConversionCodes.BGR2GRAY);

  319.                     Mat image_gray = new Mat();

  320.                     image_gray = mv[cht];

  321. 

  322.                     //image_gray.ImWrite($"image_gray{cht}.jpg");

  323. 

  324.                     Mat image_Canny = new Mat();

  325.                     Cv2.Canny(image_gray, image_Canny, 32, 64, 3);

  326. 

  327.                     //image_Canny.ImWrite($"image_Canny{cht}.jpg");

  328. 

  329.                     var lins = Cv2.HoughLinesP(image_Canny, 1, Math.PI / 360, 0, 20, 10);

  330.                     lineImg[cht] = new Mat(new Size(himg.Cols, himg.Rows), MatType.CV_8UC1, new Scalar());

  331.                     lines.Add(lins.Length);

  332.                     foreach (var item in lins)

  333.                     {

  334.                         var fdang = Math.Atan2((item.P2.Y - item.P1.Y), (item.P2.X - item.P1.X));

  335.                         var ang = Math.Abs(fdang * (180 / Math.PI));

  336.                         if (ang > 60 && ang < 120)

  337.                             Cv2.Line(lineImg[cht], item.P1.X, item.P1.Y, item.P2.X, item.P2.Y, new Scalar(255, 255, 255), 2);

  338.                     }

  339. 

  340.                     //lineImg[cht].ImWrite($"image_Canny2_{cht}.jpg");

  341. 

  342.                     //mat_rgb = mat_rgb.Canny(32, 64);

  343.                     if (lins.Length >= 1)

  344.                         break;

  345.                 }

  346.                 if (lines.Count > 0 && lines.Max() >= 1)

  347.                     break;

  348.             }

  349.             //二值化

  350.             

  351.             Mat image_Otsu = new Mat();

  352.             

  353.             int hDis = sf_height / (pointNum + 2); //去除边缘两点

  354. #if false   //二值算法

  355.             List<double> LeftAvg = new List<double>();

  356.             List<double> RightAvg = new List<double>();

  357.             //double thb = Cv2.Threshold(image_gray, image_Otsu, 0, 255, ThresholdTypes.Binary | ThresholdTypes.Otsu);

  358.             #region 多点获取二值化均值

  359.             for (int i = 0; i < pointNum; i++)

  360.             {

  361.                 Rect roiLeft = new Rect(0, hDis + hDis * i, pix, pix);

  362.                 Mat current_segmentL = image_gray.Clone(roiLeft);

  363.                 //Scalar ttr = current_segmentL.Mean();

  364.                 LeftAvg.Add(current_segmentL.Mean().Val0);

  365. 

  366.                 Rect roiRight = new Rect(sf_width - pix, hDis + hDis * i, pix, pix);

  367.                 Mat current_segmentR = image_gray.Clone(roiRight);

  368.                 RightAvg.Add(current_segmentR.Mean().Val0);

  369.             }

  370.             double thres = 0;

  371.             if (IsLeft)

  372.             {

  373.                 if (LeftAvg.Average() > RightAvg.Average())

  374.                     thres = RightAvg.Max() + offsetGray;

  375.                 else

  376.                     thres = RightAvg.Min() - offsetGray;

  377.             }

  378.             else

  379.             {

  380.                 if (LeftAvg.Average() > RightAvg.Average())

  381.                     thres = LeftAvg.Min() - offsetGray;

  382.                 else

  383.                     thres = LeftAvg.Max() + offsetGray;

  384.             }

  385.             //double thres = (RightAvg.Average() + )/2;

  386.             #endregion

  387. #endif

  388. #if false

  389.             double min, max;

  390.   

  391.             image_gray.MinMaxLoc(out min, out max);

  392.             double thres = (min + max) / 2;

  393. #endif

  394. 

  395. #if false    //二值化图片

  396.             //Cv2.Threshold(image_gray, image_Otsu, 0, 255, ThresholdTypes.Otsu);

  397.             double thb = Cv2.Threshold(image_gray, image_Otsu, thres, 255, ThresholdTypes.Binary);

  398.             image_Otsu.ImWrite("Otsu1.jpg");

  399.             Cv2.MedianBlur(image_Otsu, image_Otsu, 21);

  400.             image_Otsu.ImWrite("Otsu2.jpg");

  401.             endTime = DateTimeOffset.Now;

  402.             Console.WriteLine("灰度图二值化(ms): " + (endTime - startTime).TotalMilliseconds.ToString("0.000"));

  403.             startTime = DateTimeOffset.Now;

  404. #else

  405.             /*

  406.             image_Otsu = image_Canny;

  407.             */

  408. #endif

  409. 

  410.             int findex = lines.FindIndex(x => x == lines.Max());

  411.             image_Otsu = lineImg[findex];

  412. 

  413.             // 定义空数组保存结果

  414.             int[] total = new int[pointNum];

  415.             total_t = new List<int>();

  416.             //bool isLeft = FindType == 0 ? true : false;

  417.             // 平均截取pointNum行数据并处理图像

  418.             for (int i = 0; i < pointNum; i++)

  419.             {

  420.                 // 截取当前行的图像

  421.                 Rect roi = new Rect(0, hDis + hDis * i, sf_width, 1);

  422.                 //Mat current_segment = image_Otsu.Clone(roi);

  423.                 Mat current_segment = image_Otsu.Clone(roi);

  424. 

  425. #if false

  426.                 #region 预处理

  427.                 // 对当前行的图像进行平滑处理

  428.                 Mat smoothed_image2 = new Mat();

  429.                 Cv2.GaussianBlur(current_segment, smoothed_image2, new Size(5, 1), 0);

  430. 

  431.                 // 计算当前行的灰度直方图

  432.                 Mat absolute_histo2 = new Mat();

  433. 

  434.                 Cv2.CalcHist(new Mat[] { smoothed_image2 }, new int[] { 0 }, new Mat(), absolute_histo2, 1, new int[] { 256 }, new Rangef[] { new Rangef(0, 256) });

  435.                 Cv2.GaussianBlur(current_segment, smoothed_image2, new Size(9, 1), 0);

  436. 

  437.                 // 对图片进行分割

  438.                 //double otsu_threshold;

  439.                 //threshold(smoothed_image, smoothed_image, 0, 255, THRESH_BINARY + THRESH_OTSU, &otsu_threshold);

  440.                 double otsu_threshold2 = Cv2.Threshold(smoothed_image2, smoothed_image2, 0, 255, ThresholdTypes.Binary | ThresholdTypes.Otsu);

  441. 

  442.                 // 使用形态学操作进行孔洞填充

  443.                 Mat kernel3 = Cv2.GetStructuringElement(MorphShapes.Rect, new Size(5, 1));

  444.                 Mat filled_image3 = new Mat();

  445.                 Cv2.MorphologyEx(smoothed_image2, filled_image3, MorphTypes.Close, kernel3);

  446.                 #endregion

  447. #else

  448.                 //Mat filled_image3 = current_segment.Clone();

  449.                 Mat filled_image3 = current_segment;

  450. #endif

  451. #if true

  452.                 //从左到右判断边和从右到左判断边

  453.                 int numX = 0;

  454.                 byte tempVal = 0;

  455.                 if (!IsLeft)

  456.                 {

  457.                     tempVal = filled_image3.At<byte>(0, 0);

  458.                     //filled_image3.

  459.                     for (int j = 0; j < filled_image3.Cols; j++)

  460.                     {

  461.                         if (filled_image3.At<byte>(0, j) != tempVal)

  462.                         {

  463.                             numX = j;

  464.                             break;

  465.                         }

  466.                     }

  467.                 }

  468.                 else

  469.                 {

  470.                     tempVal = filled_image3.At<byte>(0, filled_image3.Cols - 1);

  471.                     for (int j = filled_image3.Cols - 1; j >= 0; j--)

  472.                     {

  473.                         if (filled_image3.At<byte>(0, j) != tempVal)

  474.                         {

  475.                             numX = j;

  476.                             break;

  477.                         }

  478.                     }

  479.                 }

  480. 

  481.                 //int numX = 0;

  482.                 //byte tempVal = 0;

  483. 

  484.                 //unsafe

  485.                 //{

  486.                 //    byte* ptr = (byte*)filled_image3.Data;

  487.                 //    if (isLeft)

  488.                 //    {

  489.                 //        tempVal = ptr[0];

  490.                 //        for (int j = 0; j < filled_image3.Cols; j++)

  491.                 //        {

  492.                 //            if (ptr[j] != tempVal)

  493.                 //            {

  494.                 //                numX = j;

  495.                 //                break;

  496.                 //            }

  497.                 //        }

  498.                 //    }

  499.                 //    else

  500.                 //    {

  501.                 //        tempVal = ptr[filled_image3.Cols - 1];

  502.                 //        //tempVal = filled_image3.At<byte>(0, filled_image3.Cols - 1);

  503.                 //        for (int j = filled_image3.Cols - 1; j >= 0; j--)

  504.                 //        {

  505.                 //            if (ptr[j] != tempVal)

  506.                 //            {

  507.                 //                numX = j;

  508.                 //                break;

  509.                 //            }

  510.                 //        }

  511.                 //    }

  512.                 //}

  513.                

  514. #else

  515.                 int numX = Cv2.CountNonZero(filled_image3);

  516. #endif

  517.                 //int length_t = (numX > (sf_width / 2)) ? numX :sf_width - numX;

  518.                 length_t = numX;

  519.                 total[i] = (length_t);

  520.                 if (length_t > 0)

  521.                     total_t.Add(length_t);

  522. 

  523.                 current_segment.Dispose();

  524.             }

  525. 

  526. 

  527.             // 取平均值作为宽度

  528.             int length = 0;

  529.             if(total_t.Count> 0)

  530.                 length = (int)total_t.Average();

  531. 

  532.             //endTime = DateTimeOffset.Now;

  533.             //Console.WriteLine("计算边(ms): " + (endTime - startTime).TotalMilliseconds.ToString("0.000"));

  534. 

  535.             // 判断数据是否异常，判断当前线段的宽度是否大于设定像素的偏差

  536.             //int abnormal_pxl = 100 / 4;

  537.             //for (int i = 0; i < pointNum; i++)

  538.             //{

  539.             //    if (Math.Abs(total[i] - length) > abnormal_pxl)

  540.             //        Console.WriteLine("数据异常!");

  541.             //    //出现数据异常，当段图片的宽度有问题

  542.             //}

  543. 

  544.             //乘上换算系数还原

  545.             length = length * sf + Roi.X;

  546. 

  547.             //if ((length > 6520 && length < 6530) || (length > 1570 && length < 1590))

  548.             //    ;

  549.             //else

  550.             //    ;

  551.             mat_rgb.Dispose();

  552.             //himg.Dispose();

  553.             //image_gray.Dispose();

  554.             //image_Canny.Dispose();

  555.             //image_Otsu.Dispose();

  556.             

  557.             return length;

  558.         }

  559. 

  560. 

  561.         private static StructuredEdgeDetection _edgeDetect;

  562.         public static void LoadEdgeMode()

  563.         {

  564.             if(_edgeDetect == null)

  565.                 _edgeDetect = OpenCvSharp.XImgProc.CvXImgProc.CreateStructuredEdgeDetection("model.yml");

  566.         }

  567.         /// <summary>

  568.         /// 模型寻边

  569.         /// </summary>

  570.         /// <param name="image"></param>

  571.         /// <param name="FindType"></param>

  572.         /// <param name="Roi"></param>

  573.         /// <param name="IsLeft"></param>

  574.         /// <returns></returns>

  575.         private static int EdgeClipping3(Mat image, int FindType, Rect Roi, bool IsLeft)

  576.         {

  577.             Mat mat_rgb = image.Clone(Roi);

  578. 

  579.             int height = mat_rgb.Rows;

  580.             int width = mat_rgb.Cols;

  581.             int sf = 10; //缩放比例

  582.             int pix = 5; //获取均值区域长宽像素

  583.             int pointNum = 15; //获取找遍点数

  584.             int offsetGray = 5; //二值化偏差  

  585. 

  586.             int length_t = 0;

  587.             List<int> lines = new List<int>();

  588.             List<int> total_t = new List<int>();

  589.             //按比例缩放

  590.             double sf_height = height / sf;

  591.             double sf_width = width / sf;

  592.             Cv2.Resize(mat_rgb, mat_rgb, new Size(sf_width, sf_height), 0, 0, InterpolationFlags.Linear);

  593.             Mat himg = new Mat();

  594. 

  595.             Mat edgeimg = new Mat();

  596.             Cv2.CvtColor(mat_rgb, edgeimg, ColorConversionCodes.BGR2RGB);

  597. 

  598.             Mat edges = new Mat();

  599.             edgeimg.ConvertTo(edgeimg, MatType.CV_32F, 1 / 255.0);

  600. 

  601.             if(_edgeDetect == null)

  602.                 LoadEdgeMode();

  603.             //Cv2.Normalize(edgeimg, edgeimg, 1.0, 0, NormTypes.L2, -1);

  604.             _edgeDetect.DetectEdges(edgeimg, edges);

  605. 

  606. 

  607.             Mat image_Otsu = new Mat();

  608.             int hDis = (int)sf_height / (pointNum + 2); //去除边缘两点

  609. 

  610.             edges.ConvertTo(image_Otsu, MatType.CV_8U, 255.0);

  611.             Cv2.Threshold(image_Otsu, image_Otsu, 0, 255, ThresholdTypes.Otsu);

  612. 

  613.             // 定义空数组保存结果

  614.             int[] total = new int[pointNum];

  615. 

  616.             // 平均截取pointNum行数据并处理图像

  617.             for (int i = 0; i < pointNum; i++)

  618.             {

  619.                 // 截取当前行的图像

  620.                 Rect roi = new Rect(0, hDis + hDis * i, (int)sf_width, 1);

  621.                 Mat current_segment = image_Otsu.Clone(roi);

  622. 

  623.                 //Mat filled_image3 = current_segment.Clone();

  624.                 Mat filled_image3 = current_segment;

  625. 

  626. #if true

  627.                 //从左到右判断边和从右到左判断边     

  628.                 int numX = 0;

  629.                 int tm = 0;

  630.                 byte tempVal = 0;

  631.                 bool findOne = false;

  632.                 if (IsLeft)

  633.                 {

  634.                     tempVal = filled_image3.At<byte>(0, 0);

  635.                     //filled_image3.

  636.                     for (int j = 0; j < filled_image3.Cols; j++)

  637.                     {

  638.                         if (filled_image3.At<byte>(0, j) != tempVal)

  639.                         {

  640.                             if (!findOne)

  641.                             {

  642.                                 tm = j;

  643.                                 findOne = true;

  644.                                 tempVal = filled_image3.At<byte>(0, j);

  645.                             }

  646.                             else

  647.                             {

  648.                                 //numX = j;

  649.                                 numX = (tm + j) / 2;

  650.                                 break;

  651.                             }

  652.                         }

  653.                     }

  654.                 }

  655.                 else

  656.                 {

  657.                     tempVal = filled_image3.At<byte>(0, filled_image3.Cols - 1);

  658.                     for (int j = filled_image3.Cols - 1; j >= 0; j--)

  659.                     {

  660.                         if (filled_image3.At<byte>(0, j) != tempVal)

  661.                         {

  662.                             if (!findOne)

  663.                             {

  664.                                 tm = j;

  665.                                 findOne = true;

  666.                                 tempVal = filled_image3.At<byte>(0, j);

  667.                             }

  668.                             else

  669.                             {

  670.                                 //numX = j;

  671.                                 numX = (tm + j) / 2;

  672.                                 break;

  673.                             }

  674.                         }

  675.                     }

  676.                 }

  677. #else

  678.                 int numX = Cv2.CountNonZero(filled_image3);

  679. #endif

  680.                 //length_t = (numX > (sf_width / 2)) ? numX :(int)(sf_width - numX);

  681.                 length_t = numX;

  682.                 total[i] = (length_t);

  683.                 if (length_t > 0)

  684.                     total_t.Add(length_t);

  685.             }

  686. 

  687. 

  688.             // 取平均值作为宽度

  689.             int length = 0;

  690.             if (total_t.Count > 0)

  691.             {

  692.                 length = (int)total_t.Average();

  693.                 if (IsLeft)

  694.                     length = length - ConfMgr.Instance.SysConfigParams.Crop_offset;

  695.                 else

  696.                     length = length + ConfMgr.Instance.SysConfigParams.Crop_offset;

  697.             }

  698. 

  699.             //乘上换算系数还原

  700.             length = length * sf + Roi.X;

  701.             return length;

  702.         }

  703.         #endregion

  704. 

  705.         #region 合并

  706.         /// <summary>

  707.         /// 合并MAT（宽高必需一致）

  708.         /// </summary>

  709.         /// <param name="mats"></param>

  710.         /// <param name="isHorizontal"></param>

  711.         /// <returns></returns>

  712.         public static Mat MergeImage_sameSize(Mat[] mats, bool isHorizontal = true)

  713.         {

  714.             Mat matOut = new Mat();

  715.             if (isHorizontal)

  716.                 Cv2.HConcat(mats, matOut);//横向拼接

  717.             else

  718.                 Cv2.VConcat(mats, matOut);//纵向拼接

  719.             return matOut;

  720.         }

  721.         #endregion

  722. 

  723.         #region MatToHalcon

  724.         public static void MatToHObject(Mat imgMat, out HObject imgHOject)

  725.         {

  726.             int ImageWidth = imgMat.Width;

  727.             int ImageHeight = imgMat.Height;

  728.             int channel = imgMat.Channels();

  729.             long size = ImageWidth * ImageHeight * channel;

  730.             int col_byte_num = ImageWidth * channel;

  731. 

  732. 

  733.             byte[] rgbValues = new byte[size];

  734.             unsafe

  735.             {

  736.                 for (int i = 0; i < ImageHeight; i++)

  737.                 {

  738.                     IntPtr c = imgMat.Ptr(i);

  739.                     // 一行一行将mat 像素复制到byte[]

  740.                     Marshal.Copy(c, rgbValues, i * col_byte_num, col_byte_num);

  741.                 }

  742.                 void* p;

  743.                 IntPtr ptr;

  744.                 fixed (byte* pc = rgbValues)

  745.                 {

  746.                     p = (void*)pc;

  747.                     ptr = new IntPtr(p);

  748.                 }

  749. 

  750. 

  751.                 if (channel == 1)

  752.                 {

  753.                     HOperatorSet.GenImage1(out imgHOject, "byte", ImageWidth, ImageHeight, ptr);

  754.                 }

  755.                 else

  756.                 {

  757.                     HOperatorSet.GenImageInterleaved(out imgHOject, ptr, "bgr", ImageWidth, ImageHeight, 0, "byte", 0, 0, 0, 0, -1, 0);

  758.                 }

  759.             }

  760.         }

  761.     #if false

  762.             /// <summary>

  763.             /// 把OpenCV图像转换到Halcon图像

  764.             /// </summary>

  765.             /// <param name="mImage">OpenCV图像_Mat</param>

  766.             /// <returns>Halcon图像_HObject</returns>

  767.             public HObject MatToHImage(Mat mImage)

  768.             {

  769.                 try

  770.                 {

  771.                     HObject hImage;

  772.                     int matChannels = 0;   // 通道数

  773.                     Type matType = null;

  774.                     int width, height;   // 宽，高

  775.                     width = height = 0;  // 宽，高初始化

  776.  

  777.                     // 获取通道数

  778.                     matChannels = mImage.Channels();

  779.                     if (matChannels == 0)

  780.                     {

  781.                         return null;

  782.                     }

  783.                     if (matChannels == 1)        // 单通道

  784.                     {

  785.                         IntPtr ptr;      // 灰度图通道

  786.                         Mat[] mats = mImage.Split();

  787.  

  788.                         // 改自：Mat.GetImagePointer1(mImage, out ptr, out matType, out width, out height);     // ptr=2157902018096    cType=byte    width=830    height=822

  789.                         ptr = mats[0].Data;          // 取灰度图值

  790.                         matType = mImage.GetType();  // byte

  791.                         height = mImage.Rows;        // 高

  792.                         width = mImage.Cols;         // 宽

  793.  

  794.                         // 改自：hImage = new HObject(new OpenCvSharp.Size(width, height), MatType.CV_8UC1, new Scalar(0));

  795.                         byte[] dataGrayScaleImage = new byte[width * height];      //Mat dataGrayScaleImage = new Mat(new OpenCvSharp.Size(width, height), MatType.CV_8UC1);

  796.  

  797.                         unsafe

  798.                         {

  799.                             fixed (byte* ptrdata = dataGrayScaleImage)

  800.                             {

  801. 

  802.             #region 按行复制

  803.                                  //for (int i = 0; i < height; i++)

  804.                                  //{

  805.                                  //    CopyMemory((IntPtr)(ptrdata + width * i), new IntPtr((long)ptr + width * i), width);

  806.                                  //}

  807. 

  808.             #endregion

  809. 

  810.                                 CopyMemory((IntPtr)ptrdata, new IntPtr((long)ptr), width * height);

  811.                                 HOperatorSet.GenImage1(out hImage, "byte", width, height, (IntPtr) ptrdata);

  812.  

  813.                             }

  814.                         }

  815.                         return hImage;

  816.                     }

  817.                     else if (matChannels == 3)   // 三通道

  818.                     {

  819.                         IntPtr ptrRed;    // R通道图

  820.                         IntPtr ptrGreen;  // G通道图

  821.                         IntPtr ptrBlue;   // B通道图

  822.                         Mat[] mats = mImage.Split();

  823.   

  824.                         ptrRed = mats[0].Data;    // 取R通道值

  825.                         ptrGreen = mats[1].Data;  // 取G通道值

  826.                         ptrBlue = mats[2].Data;   // 取B通道值

  827.                         matType = mImage.GetType();  // 类型

  828.                         height = mImage.Rows;        // 高

  829.                         width = mImage.Cols;         // 宽

  830.    

  831.                         // 改自：hImage = new HObject(new OpenCvSharp.Size(width, height), MatType.CV_8UC1, new Scalar(0));

  832.                         byte[] dataRed = new byte[width * height];      //Mat dataGrayScaleImage = new Mat(new OpenCvSharp.Size(width, height), MatType.CV_8UC1);

  833.                         byte[] dataGreen = new byte[width * height];

  834.                         byte[] dataBlue = new byte[width * height];

  835.    

  836.                         unsafe

  837.                         {

  838.                             fixed (byte* ptrdataRed = dataRed, ptrdataGreen = dataGreen, ptrdataBlue = dataBlue)

  839.                             {

  840.            

  841.                 #region 按行复制

  842.                             //HImage himg = new HImage("byte", width, height, (IntPtr)ptrdataRed);

  843.                             //for (int i = 0; i < height; i++)

  844.                             //{

  845.                             //     CopyMemory((IntPtr)(ptrdataRed + width * i), new IntPtr((long)ptrRed + width * i), width);

  846.                             //     CopyMemory((IntPtr)(ptrdataGreen + width * i), new IntPtr((long)ptrGreen + width * i), width);

  847.                             //     CopyMemory((IntPtr)(ptrdataBlue + width * i), new IntPtr((long)ptrBlue + width * i), width);

  848.                             //}

  849.  

  850.                 #endregion

  851. 

  852.                                 CopyMemory((IntPtr)ptrdataRed, new IntPtr((long)ptrRed), width * height);        // 复制R通道

  853.                                 CopyMemory((IntPtr)ptrdataGreen, new IntPtr((long)ptrGreen), width * height);    // 复制G通道

  854.                                 CopyMemory((IntPtr)ptrdataBlue, new IntPtr((long)ptrBlue), width * height);      // 复制B通道

  855.                                 HOperatorSet.GenImage3(out hImage, "byte", width, height, (IntPtr)ptrdataRed, (IntPtr)ptrdataGreen, (IntPtr)ptrdataBlue);   // 合成

  856.                             }

  857.                         }

  858.                         return hImage;

  859.                     }

  860.                     else

  861.                     {

  862.                         return null;

  863.                     }

  864.                 }

  865.                 catch (Exception ex)

  866.                 {

  867.                     throw ex;

  868.                 }

  869. 

  870.             }

  871.     #endif

  872.     #endregion

  873.     }

  874. }