public static void cv_06() // 边缘轮廓的检测/查找
{
Mat srcImage = Cv2.ImRead(@"G:\\pics\\123.jpg", ImreadModes.Color);
Mat src_gray = new Mat();
Cv2.CvtColor(srcImage, src_gray, ColorConversionCodes.RGB2GRAY); //转换为灰度图
Cv2.Blur(src_gray, src_gray, new OpenCvSharp.Size(2, 2)); //滤波
Mat canny_Image = new Mat();
Cv2.Canny(src_gray, canny_Image, 100, 200); //Canny边缘检测
OpenCvSharp.Point[][] contours;
HierarchyIndex[] hierarchly;
Cv2.FindContours(canny_Image, out contours, out hierarchly, RetrievalModes.Tree, ContourApproximationModes.ApproxSimple, new OpenCvSharp.Point(0, 0)); //获得轮廓
Mat dst_Image = Mat.Zeros(canny_Image.Size(), srcImage.Type()); // 图片像素值归零
Random rnd = new Random();
for (int i = 0; i < contours.Length; i++)
{
Scalar color = new Scalar(rnd.Next(0, 255), rnd.Next(0, 255), rnd.Next(0, 255));
Cv2.DrawContours(dst_Image, contours, i, color, 2, LineTypes.Link8, hierarchly); //画出轮廓
}
//return dst_Image; //返回结果
Cv2.ImShow("dst_Image", dst_Image);
Cv2.ImShow("canny_Image", canny_Image);
Cv2.WaitKey();
//return canny_Image;
}
void Recognize()
{
OpenCvSharp.Point[][] contours;
HierarchyIndex[] hierarchy;
Mat after_2gray = new Mat();
Mat after_canny = new Mat();
Mat after_blur = new Mat();
Mat frame_range = new Mat();
Mat after_after = new Mat();
Cv2.Blur(frame_in, after_blur, new OpenCvSharp.Size(3, 3));
Cv2.InRange(after_blur, new Scalar(0, 0, 0), new Scalar(70, 70, 70), frame_range);
Cv2.FindContours(frame_range, out contours, out hierarchy, RetrievalModes.External, ContourApproximationModes.ApproxSimple);
for (int i = 0; i < contours.Count(); i++)
{
Rect bR = Cv2.BoundingRect(contours[i]);
if ((bR.Width > 20) && (bR.Height > 20))
{
Cv2.DrawContours(frame_out, contours, i, new Scalar(0, 0, 255), 2);
try
{
Point2d[] GetTempPoints = FindTemp(contours[i]);
ShowTemp(GetTempPoints);
}
catch { }
}
}
}
private static void debug_showallcontours(Mat ori_img, HierarchyIndex[] hierarchyIndexes, Point[][] contours)
{
//clone image
Mat contourImage = new Mat(ori_img.Rows, ori_img.Cols, ori_img.Type());
ori_img.CopyTo(contourImage);
var contourIndex = 0;
//debug to see all contour captured by openCV (without the closed border on the doc it will not work), so might need to implement fail safe to check if contour area smaller than 50% of the picture will not transform
//uncomment to draw for all contours
foreach (var cont in contours)
{
Cv2.DrawContours(
contourImage,
contours,
contourIndex,
color: Scalar.Yellow,
thickness: 3,
lineType: LineTypes.Link8,
hierarchy: hierarchyIndexes,
maxLevel: int.MaxValue);
contourIndex = hierarchyIndexes[contourIndex].Next;
}
var d1 = Xamarin.Forms.DependencyService.Get <ISaveViewFile>().SaveAndViewAsync("contourImage.jpg", contourImage.ToMemoryStream());
}
/// <summary>
/// Create a processed image of the image distance calibration algorithm used as visual feedback for the user
/// and rendered in the video feed panel on the user interface <br/>
///Image processing algorithm
/// </summary>
/// <param name="img">input image, of type OpenCvSharp.Mat</param>
/// <param name="allContours">all countours found in an image, of type OpenCvSharp.Mat[]. Note: only index 0 and 1 will be used</param>
/// <param name="pointsList">center point of the 2 largest contours by area, of type List<OpenCvSharp.Point></param>
/// <param name="distance">Distance between center points of the 2 largest contours by area, of type int. Note: int because it's used only to roughly display</param>
/// <returns>output image, of type OpenCvSharp.Mat</returns>
public Mat ComposeImageIDC(Mat img, Mat[] allContours, List <OpenCvSharp.Point> pointsList, int distance)
{
Mat imgComposed = new Mat();
Cv2.CvtColor(img, imgComposed, ColorConversionCodes.GRAY2BGR);
Cv2.DrawContours(imgComposed, allContours, -1, Scalar.FromRgb(0, 128, 255), 2); ///See method without "_" in source code for actual implementation. This methods exists because of limitations in documenting the API
for (int i = 0; i < allContours.Count(); i++)
{
Cv2.Circle(imgComposed, pointsList[i], 2, Scalar.FromRgb(250, 50, 50), 5);
}
Cv2.Line(imgComposed, pointsList[0], pointsList[1], Scalar.FromRgb(0, 250, 100), 1);
Cv2.PutText(imgComposed, distance.ToString() + " px", new OpenCvSharp.Point((pointsList[0].X + pointsList[1].X) / 2 - 10, (pointsList[0].Y + pointsList[1].Y) / 2 - 20), HersheyFonts.HersheySimplex, 1, Scalar.FromRgb(250, 50, 50), 2);
// Draw IDC bounding box if necessary
if (TrackingSettings.TrackingAlgorithm == Enums.TrackingAlgoirthm.ImageDistance)
{
imgComposed = DrawBoundingBox(ref imgComposed,
new OpenCvSharp.Point()
{
X = IDCSettings.BoxTopLeft.X, Y = IDCSettings.BoxTopLeft.Y
},
new OpenCvSharp.Point()
{
X = IDCSettings.BoxBottomRight.X, Y = IDCSettings.BoxBottomRight.Y
},
Scalar.Orange,
LineTypes.Link4
);
}
return(imgComposed);
}
private Mat FindContours(Mat srcImage)
{
Mat src_gray = new Mat();
Cv2.CvtColor(srcImage, src_gray, ColorConversionCodes.RGB2GRAY);
Cv2.Blur(src_gray, src_gray, new OpenCvSharp.Size(2, 2));
Mat cannyImage = new Mat();
Cv2.Canny(src_gray, cannyImage, 100, 200);
OpenCvSharp.Point[][] contours;
HierarchyIndex[] hierarchly;
Cv2.FindContours(cannyImage, out contours, out hierarchly, RetrievalModes.Tree,
ContourApproximationModes.ApproxSimple, new OpenCvSharp.Point(0, 0));
Mat dstImage = Mat.Zeros(cannyImage.Size(), srcImage.Type());
Random rnd = new Random();
for (int i = 0; i < contours.Length; i++)
{
Scalar color = new Scalar(rnd.Next(0, 255), rnd.Next(0, 255), rnd.Next(0, 255));
Cv2.DrawContours(dstImage, contours, i, color, 2, LineTypes.Link8, hierarchly);
}
return(dstImage);
}
static void Main(string[] args)
{
Mat src = Cv2.ImRead("chess.png");
Mat gray = new Mat();
Mat binary = new Mat();
Mat morp = new Mat();
Mat image = new Mat();
Mat dst = src.Clone();
Mat kernel = Cv2.GetStructuringElement(MorphShapes.Rect, new Size(3, 3));
Point[][] contours;
HierarchyIndex[] hierarchy;
Cv2.CvtColor(src, gray, ColorConversionCodes.BGR2GRAY);
Cv2.Threshold(gray, binary, 230, 255, ThresholdTypes.Binary);
Cv2.MorphologyEx(binary, morp, MorphTypes.Close, kernel, new Point(-1, -1), 2);
Cv2.BitwiseNot(morp, image);
Cv2.FindContours(image, out contours, out hierarchy, RetrievalModes.Tree, ContourApproximationModes.ApproxTC89KCOS);
Cv2.DrawContours(dst, contours, -1, new Scalar(255, 0, 0), 2, LineTypes.AntiAlias, hierarchy, 3);
for (int i = 0; i < contours.Length; i++)
{
for (int j = 0; j < contours[i].Length; j++)
{
Cv2.Circle(dst, contours[i][j], 1, new Scalar(0, 0, 255), 3);
}
}
Cv2.ImShow("dst", dst);
Cv2.WaitKey(0);
Cv2.DestroyAllWindows();
}
public List <RotatedRect> GetBarcode(Mat src)
{
Mat imgthresh = BarcodeRegion(src);
Point[][] contours;
HierarchyIndex[] hierarchy;
Cv2.FindContours(imgthresh, out contours, out hierarchy, RetrievalModes.External, ContourApproximationModes.ApproxNone, new Point(0, 0));
//Cv2.ImShow("X", imgthresh);
//Cv2.WaitKey();
List <RotatedRect> barcode = new List <RotatedRect>();
for (int i = 0; i < contours.Length; i++)
{
double area = Cv2.ContourArea(contours[i]);
RotatedRect rect = Cv2.MinAreaRect(contours[i]);
double ratio = area / (rect.Size.Width * rect.Size.Height);
if (1 - ratio < 0.2 && area > 200)
{
Cv2.DrawContours(src, contours, i, 255, -1);
barcode.Add(rect);
}
}
//RotatedRect p;
barcode = barcode.OrderBy(p => p.Center.X).ThenBy(p => p.Center.Y).ToList();
Cv2.ImShow("X", src);
Cv2.WaitKey();
return(barcode);
}
//边缘检测
private void ucBtnExt_A2_BtnClick(object sender, EventArgs e)
{
//提取苹果轮廓
Cv2.FindContours(apple_mask, out apple_contours, out apple_hierarchy,
RetrievalModes.External, ContourApproximationModes.ApproxNone);
background_mask = new Mat(fruit_mask.Size(), MatType.CV_8UC1, new Scalar(0));
//绘制苹果轮廓
Cv2.DrawContours(background_mask, apple_contours, -1, new Scalar(255), 2,
LineTypes.Link8, apple_hierarchy);
//提取梨子轮廓
Cv2.FindContours(pear_mask, out pear_contours, out pear_hierarchy, RetrievalModes.External,
ContourApproximationModes.ApproxNone);
//绘制梨子轮廓
for (int i = 0; i < pear_contours.Length; i++)
{
if (Cv2.ArcLength(pear_contours[i], true) > 40) //轮廓周长大于40时绘制
{
Cv2.DrawContours(background_mask, pear_contours, i, new Scalar(255), 2, LineTypes.Link8,
pear_hierarchy);
}
}
this.pictureBoxIpl_img.ImageIpl = background_mask;
//输出日志
newLog = "[msg] 边缘检测完毕";
}
static void MSER_Preprocessing(ref Mat img, out OpenCvSharp.Point offset_bounding_rec, List <OpenCvSharp.Point[]> contours_final)
{
OpenCvSharp.Point[][] temp = new Point[1][];
Cv2.GaussianBlur(img, img, new OpenCvSharp.Size(7, 7), 0, 0);
/*
* //忽略內圈和外圈一些面積
* OpenCvSharp.Point[][] temp = new Point[1][];
* temp[0] = contours_final[0];
* Cv2.DrawContours(img_copy, temp, -1, 255, 40);
* temp[0] = contours_final[1];
* Cv2.DrawContours(img_copy, temp, -1, 255, 40);
*/
//忽略外圈一些面積
temp[0] = contours_final[1];
Cv2.DrawContours(img, temp, -1, 255, 100);
//temp[0] = contours_final[0];
//Cv2.DrawContours(img, temp, -1, 255, 20);
//200原因:外圈預留空間
var biggestContourRect = Cv2.BoundingRect(contours_final[0]);
var expand_rect = new Rect(biggestContourRect.TopLeft.X - 200, biggestContourRect.TopLeft.Y - 200, biggestContourRect.Width + 200, biggestContourRect.Height + 200);
img = new Mat(img, expand_rect);
offset_bounding_rec = expand_rect.TopLeft;
}
private static void ShapeContextDistanceExtractorSaample()
{
var src = Cv2.ImRead(@"data\shapes.png", ImreadModes.Color);
var gray = src.CvtColor(ColorConversionCodes.BGR2GRAY);
var canny = gray.Canny(100, 200);
Point[][] contours;
HierarchyIndex[] hierarchy;
canny.FindContours(
out contours, out hierarchy, RetrievalModes.External, ContourApproximationModes.ApproxSimple);
Mat dst = src.Clone();
Cv2.DrawContours(dst, new Point[][] { contours[4] }, -1, Scalar.Red, 2);
Cv2.DrawContours(dst, new Point[][] { contours[5] }, -1, Scalar.Yellow, 2);
var distanceExtractor = ShapeContextDistanceExtractor.Create();
//var distanceExtractor = HausdorffDistanceExtractor.Create();
using (var inputA = MatOfPoint.FromArray(contours[4]))
using (var inputB = MatOfPoint.FromArray(contours[5]))
{
var distance = distanceExtractor.ComputeDistance(inputA, inputB);
Console.WriteLine(distance); // always 0
}
Window.ShowImages(dst);
}
public void FindContours()
{
using var src = Image("markers_6x6_250.png", ImreadModes.Grayscale);
Cv2.BitwiseNot(src, src);
Cv2.FindContours(
src,
out var contours,
out var hierarchy,
RetrievalModes.External,
ContourApproximationModes.ApproxSimple);
Assert.NotEmpty(contours);
Assert.NotEmpty(hierarchy);
Assert.All(contours, contour =>
{
Assert.Equal(4, contour.Length);
});
if (Debugger.IsAttached)
{
using var view = new Mat(src.Size(), MatType.CV_8UC3, Scalar.All(0));
Cv2.DrawContours(view, contours, -1, Scalar.Red);
Window.ShowImages(src, view);
}
}
private void find_max_area(Mat src_gray, ref OpenCvSharp.Point center, ref Mat dst_color)//カラーで返す
{
src_gray.Threshold(0, 255, ThresholdTypes.Otsu | ThresholdTypes.Binary);
Mat[] contours;
Mat hie = new Mat();
Cv2.FindContours(src_gray, out contours, hie, RetrievalModes.External, ContourApproximationModes.ApproxSimple);
if (contours.Length > 0)
{
double max_size = 0;
int max_index = 0;
for (int i = 0; i < contours.Length; i++)
{
double size = Cv2.ContourArea(contours[i]);
if (max_size < size)
{
max_size = size;
max_index = i;
}
}
Cv2.DrawContours(dst_color, contours, max_index, new Scalar(255, 255, 255), -1);
RotatedRect box = Cv2.MinAreaRect(contours[max_index]);
center = box.Center;
}
contours = null;
hie.Dispose();
src_gray.Dispose();
}
public Mat StoroboMat(Parameters para)
{
int step = para.StoroboStep;
using (Mat mask = new Mat(rawmat.Size(), MatType.CV_8UC1, Scalar.Black)) {
SetRawMat();
rawmat.CopyTo(output3);
for (int t = para.StartFrame; t < para.EndFrame; t += step)
{
PosFrames = t;
var cnt = new List <IEnumerable <OPoint> > {
GetContour(para)
};
if (cnt[0] == null)
{
continue;
}
SetRawMat();
mask.SetTo(Scalar.Black);
Cv2.DrawContours(mask, cnt, 0, Scalar.White, -1);
rawmat.CopyTo(output3, mask);
double phase = (t - para.StartFrame) / (double)(para.EndFrame - para.StartFrame);
Cv2.DrawContours(output3, cnt, 0, Rainbow(phase), 4);
}
}
return(output3);
}
/// <summary>
/// Create a processed image of the dynamic threshold algorithm used as visual feedback for the user
/// and rendered in the video feed panel on the user interface <br/>
///Image processing algorithm
/// </summary>
/// <param name="img">input image, of type OpenCvSharp.Mat</param>
/// <param name="largestContourArea">desired contour, of type OpenCvSharp.Mat</param>
/// <param name="contourCenter">center point of desired contour, of type OpenCvSharp.Point</param>
/// <param name="actuatorPositionPixels">position of an actuator translated into pixels, of type System.Drawing.Point</param>
/// <returns>output image, of type OpenCvSharp.Mat</returns>
public Mat ComposeImageDTC(ref Mat img, ref Mat largestContourArea, ref OpenCvSharp.Point contourCenter, ref System.Drawing.Point actuatorPositionPixels)
{
// Convert to RGB, draw largest contour, draw largest contour center, put coordinates text, draw actuators position
Cv2.CvtColor(img, imgComposed, ColorConversionCodes.GRAY2BGR);
Cv2.DrawContours(imgComposed, new Mat[] { largestContourArea }, -1, Scalar.FromRgb(0, 128, 255), 2);
Cv2.Circle(imgComposed, contourCenter, 2, Scalar.FromRgb(250, 50, 50), 5);
Cv2.PutText(imgComposed, contourCenter.X.ToString() + "," + contourCenter.Y.ToString(), contourCenter, HersheyFonts.HersheySimplex, 1, Scalar.FromRgb(250, 50, 50), 2);
//Cv2.Rectangle(imgComposed, new OpenCvSharp.Point(100, 100), new OpenCvSharp.Point(300, 300), Scalar.Azure, 2, LineTypes.AntiAlias, 0);
// Draw actuator position line - Either axis X, either Y, either both
foreach (Enums.Axis axis in TASettings.ConnectedAxisList)
{
if (axis == Enums.Axis.X)
{
Cv2.Line(imgComposed, new OpenCvSharp.Point(actuatorPositionPixels.X, 0), new OpenCvSharp.Point(actuatorPositionPixels.X, imgComposed.Height - 1), Scalar.FromRgb(0, 250, 100), 3);
}
else if (axis == Enums.Axis.Y)
{
Cv2.Line(imgComposed, new OpenCvSharp.Point(0, actuatorPositionPixels.Y), new OpenCvSharp.Point(imgComposed.Width - 1, actuatorPositionPixels.Y), Scalar.FromRgb(0, 250, 100), 3);
}
}
// Draw IDC bounding box if necessary
if (TrackingSettings.TrackingAlgorithm == Enums.TrackingAlgoirthm.ImageDistance)
{
imgComposed = DrawBoundingBox(ref imgGrayscale,
new OpenCvSharp.Point()
{
X = IDCSettings.BoxTopLeft.X, Y = IDCSettings.BoxTopLeft.Y
},
new OpenCvSharp.Point()
{
X = IDCSettings.BoxBottomRight.X, Y = IDCSettings.BoxBottomRight.Y
},
Scalar.Orange,
LineTypes.Link4
);
}
// Draw bounding box if necessary
if (TrackingSettings.TrackingAlgorithm == Enums.TrackingAlgoirthm.BoundingBox)
{
imgComposed = DrawBoundingBox(ref imgGrayscale,
new OpenCvSharp.Point()
{
X = BoundingBoxCalib.TopLeftPixelPos.X, Y = BoundingBoxCalib.TopLeftPixelPos.Y
},
new OpenCvSharp.Point()
{
X = BoundingBoxCalib.BottomRightPixelPos.X, Y = BoundingBoxCalib.BottomRightPixelPos.Y
},
Scalar.BlueViolet,
LineTypes.Link4
);
}
return(imgComposed);
}
//Find outer defect
static void FindContour_and_outer_defect(Mat img, List <Point[]> contours_final, ref int nLabels, out int [,] stats, string mode)
{
// variable
OpenCvSharp.Point[][] temp = new Point[1][];
//0: 內圈 ; 1: 外圈
OpenCvSharp.Point[] contour_now;
if (mode == "inner")
{
contour_now = contours_final[0];
}
else
{
contour_now = contours_final[1];
}
// Convex hull
var ellipsecontour = Cv2.FitEllipse(contour_now);
Mat convex_mask_img = Mat.Zeros(img.Size(), MatType.CV_8UC1);
Cv2.Ellipse(convex_mask_img, ellipsecontour, 255, -1);
// Contour
temp[0] = contour_now;
Mat contour_mask_img = Mat.Zeros(img.Size(), MatType.CV_8UC1);
Cv2.DrawContours(contour_mask_img, temp, -1, 255, -1);
Mat diff_image = contour_mask_img ^ convex_mask_img;
//Opening
Mat kernel = Mat.Ones(4, 4, MatType.CV_8UC1);//改變凹角大小
diff_image = diff_image.MorphologyEx(MorphTypes.Open, kernel);
//=========================吃掉邊界=======================================
//temp[0] = contour_now;
//Cv2.DrawContours(diff_image, temp, -1, 0, 3);
//================================================================
convex_mask_img.SaveImage("./" + mode + "convex" + ".jpg");
contour_mask_img.SaveImage("./" + mode + "contour" + ".jpg");
diff_image.SaveImage("./" + mode + "mask" + ".jpg");
//Connected Component
var labelMat = new MatOfInt();
var statsMat = new MatOfInt();// Row: number of labels Column: 5
var centroidsMat = new MatOfDouble();
nLabels = Cv2.ConnectedComponentsWithStats(diff_image, labelMat, statsMat, centroidsMat);
var labels = labelMat.ToRectangularArray();
stats = statsMat.ToRectangularArray();
var centroids = centroidsMat.ToRectangularArray();
}
void DrawContours(int width, int height, string file, Mat[] contours)
{
using (var image = new Mat(new Size(width, height), MatType.CV_8UC3))
{
Cv2.DrawContours(image, contours, -1, new Scalar(0, 0, 255), 3);
image.SaveImage(file);
}
}
private static void DrawContours(IReadOnlyList <Point[]> contours, IList <Point[]> contoursPoly, Mat drawing)
{
var center = new Point2f[contours.Count];
var radius = new float[contours.Count];
for (var i = 0; i < contours.Count; i++)
{
if (Cv2.ContourArea(contours[i]) >= 5000)
{
contoursPoly[i] = Cv2.ApproxPolyDP(contours[i], 3, true);
Cv2.MinEnclosingCircle(contoursPoly[i], out center[i], out radius[i]);
var tempContour = contours[i];
var hulls = new Point[1][];
var hullsI = new int[1][];
hulls[0] = Cv2.ConvexHull(tempContour);
hullsI[0] = Cv2.ConvexHullIndices(tempContour);
Cv2.DrawContours(drawing, hulls, -1, Scalar.Gold, 2);
if (hullsI[0].Length > 0)
{
var defects = Cv2.ConvexityDefects(tempContour, hullsI[0]);
if (defects.Length > 0)
{
for (var j = 1; j < defects.Length; j++)
{
var startIdx = defects[j][0];
var ptStart = tempContour[startIdx];
var farIdx = defects[j][2];
var ptFar = tempContour[farIdx];
if (GetDistance(ptStart, ptFar) > 1000 && ptStart.Y < center[i].Y && radius[i] >= 70)
{
Cv2.Circle(drawing, ptStart, 10, Scalar.Yellow, 2);
Cv2.Line(drawing, ptStart, ptFar, Scalar.Pink, 2);
_numberOfFingers++;
}
}
if (radius[i] > 50)
{
Cv2.DrawContours(drawing, contoursPoly, i, Scalar.Red);
Cv2.Circle(drawing, center[i], (int)radius[i], Scalar.White, 2);
Cv2.Circle(drawing, center[i], 5, Scalar.Red, 2);
if (Program.ControlMode)
{
_posX = (int)(4 * (center[i].X - 100));
_posY = (int)(4 * (center[i].Y - 100));
WinApiUtils.SetCursorPos(_posX, _posY);
}
}
}
}
}
}
}
static List <Point[][]> AdaptiveThreshold_Based_Extract_Defect(Mat Src, List <OpenCvSharp.Point[]> contours_final)
{
//=========prepare adaptive threshold input
Mat Adaptive_Src = Mat.Zeros(Src.Size(), MatType.CV_8UC1);
//用adaptive threshold 濾出瑕疵
Cv2.GaussianBlur(Src, Adaptive_Src, new OpenCvSharp.Size(3, 3), 0, 0);
/*//=====================================1008test== mask inner and outer to black===================================
* OpenCvSharp.Point[][] test = new Point[1][];
* test[0] = contours_final[1];
* Cv2.DrawContours(Adaptive_Src, test, -1, 0, -1);
* Cv2.DrawContours(Adaptive_Src, test, -1, 0, 10);
* Adaptive_Src.SaveImage("adaptive_prepocessing.jpg");
* //==================================================================================
*/
Cv2.AdaptiveThreshold(Adaptive_Src, Adaptive_Src, 255, AdaptiveThresholdTypes.GaussianC, ThresholdTypes.Binary, 45, 105 / 10);
Adaptive_Src.SaveImage("adaptive.jpg");
//讓黑白相反(not opetation)
Mat Src_255 = new Mat(Adaptive_Src.Size(), MatType.CV_8UC1, new Scalar(255));
Cv2.Subtract(Src_255, Adaptive_Src, Adaptive_Src);
// denoise
OpenCvSharp.Point[][] temp = new Point[1][];
Point[][] contours;
HierarchyIndex[] hierarchly;
Cv2.FindContours(Adaptive_Src, out contours, out hierarchly, RetrievalModes.Tree, ContourApproximationModes.ApproxSimple);
foreach (OpenCvSharp.Point[] contour_now in contours)
{
if (Cv2.ContourArea(contour_now) < 100)
{
//Console.WriteLine("Arc Length: " + (Cv2.ArcLength(contour_now, true) + " Area: " + Cv2.ContourArea(contour_now))+" Length/Area:" +(Cv2.ArcLength(contour_now, true) / Cv2.ContourArea(contour_now)));
OpenCvSharp.Point[] approx = Cv2.ApproxPolyDP(contour_now, 0.000, true);
temp[0] = approx;
Cv2.DrawContours(Adaptive_Src, temp, -1, 0, -1);
}
}
//Mat kernel = Cv2.GetStructuringElement(MorphShapes.Ellipse, new Size(13, 7));
//Adaptive_Src = Adaptive_Src.MorphologyEx(MorphTypes.Close, kernel);
//=========================吃掉邊界=======================================
temp[0] = contours_final[0];
Cv2.DrawContours(Adaptive_Src, temp, -1, 0, 30);
temp[0] = contours_final[1];
Cv2.DrawContours(Adaptive_Src, temp, -1, 0, 45);
Adaptive_Src.SaveImage("a.jpg");
//上面已經得到defect圖，用Find_Defect_Contour_and_Extract萃取出來
return(Find_Defect_Contour_and_Extract(Src, Adaptive_Src, contours_final));
}
public static void cv_08() // 仿射变换 Cv2.WarpAffine（）
{
Mat srcImage = Cv2.ImRead(@"G:\\pics\\2.jpg");
Cv2.ImShow("src", srcImage);
Mat grayImage = new Mat();
Mat binaryImage = new Mat();
Cv2.CvtColor(srcImage, grayImage, ColorConversionCodes.BGR2GRAY);
Cv2.Threshold(grayImage, binaryImage, 20, 150, ThresholdTypes.Binary);//转换为二值图像
Cv2.ImShow("二值化图", binaryImage);
OpenCvSharp.Point[][] contours; //创建存储轮廓的数组
HierarchyIndex[] hierarchy;
Cv2.FindContours(binaryImage, out contours, out hierarchy, RetrievalModes.External, ContourApproximationModes.ApproxNone); //从二值图中检索轮廓，参数：1，寻找轮廓的图像；2，返回轮廓数组；4，轮廓的检索模式5，轮廓近似模式
RotatedRect[] outRect = new RotatedRect[contours.Length]; //创建存储外接矩形的数组
OpenCvSharp.Point[][] contours_poly = new OpenCvSharp.Point[contours.Length][];
for (int i = 0; i < contours.Length; i++)
{
contours_poly[i] = Cv2.ApproxPolyDP(contours[i], 10, true); //Cv2.ApproxPolyDP()对指定的点集进行多边形逼近的函数；参数：1，输入的点集；2，指定的精度，也即是原始曲线与近似曲线之间的最大距离；3，若为true，则说明近似曲线是闭合的；反之，若为false，则断开。
outRect[i] = Cv2.MinAreaRect(contours_poly[i]); //最小外接矩形集合
Point2f[] pot = new Point2f[4]; //新建点集合接收点集合
float angle = outRect[i].Angle; //矩形角度
pot = outRect[i].Points(); //矩形的4个角点
double line1 = Math.Sqrt((pot[0].X - pot[1].X) * (pot[0].X - pot[1].X) + (pot[0].Y - pot[1].Y) * (pot[0].Y - pot[1].Y));
double line2 = Math.Sqrt((pot[0].X - pot[3].X) * (pot[0].X - pot[3].X) + (pot[0].Y - pot[3].Y) * (pot[0].Y - pot[3].Y));
if (line1 * line2 < 1000)//过滤太小的矩形
{
continue;
}
if (line1 > line2)//依据实际情况进行判断
{
angle += 90;
}
Mat Roi = new Mat(srcImage.Size(), MatType.CV_8UC3);
Roi.SetTo(0); //设置黑像素
Cv2.DrawContours(binaryImage, contours, -1, Scalar.White, -1); //在二值化图像中画出轮廓区域并染白
Cv2.ImShow("bin", binaryImage);
srcImage.CopyTo(Roi, binaryImage);//将原图通过掩码抠图到Roi
Cv2.ImShow("Roi", Roi);
Mat afterRotato = new Mat(srcImage.Size(), MatType.CV_8UC3);
afterRotato.SetTo(0);
Point2f center = outRect[i].Center;
Mat matrixWarpAffine = Cv2.GetRotationMatrix2D(center, angle, 1); //计算变换矩阵，参数：1，旋转中心点；2，旋转的角度，正值是逆时针，负值是顺时针；3，缩放因子
Cv2.WarpAffine(Roi, afterRotato, matrixWarpAffine, Roi.Size(), InterpolationFlags.Linear, BorderTypes.Constant); //得到变换后的图像，滤除其他信息
Cv2.ImShow("仿射变换旋转后", afterRotato);
Cv2.WaitKey();
}
}
public static Mat FindContoursMat(Mat binary, Mat src)
{
Cv2.FindContours(binary, out var contours, out _, RetrievalModes.External,
ContourApproximationModes.ApproxSimple);
var rotateRect = new RotatedRect[contours.Length];
var contours_poly = new Point[contours.Length][];
for (var i = 0; i < contours.Length; i++)
{
contours_poly[i] = Cv2.ApproxPolyDP(contours[i], 30, true); //返回凸包，单线长大于30过滤
rotateRect[i] = Cv2.MinAreaRect(contours_poly[i]); //最小外接矩形集合
var angle = rotateRect[i].Angle; //矩形角度
var pot = rotateRect[i].Points();
var line1 = Math.Sqrt((pot[0].X - pot[1].X) * (pot[0].X - pot[1].X) +
(pot[0].Y - pot[1].Y) * (pot[0].Y - pot[1].Y));
var line2 = Math.Sqrt((pot[0].X - pot[3].X) * (pot[0].X - pot[3].X) +
(pot[0].Y - pot[3].Y) * (pot[0].Y - pot[3].Y));
if (line1 * line2 < 1000)
{
continue; //过滤，太小的矩形直接pass
}
if (line1 > line2)
{
angle += 90; //依据实际情况进行判断
}
var Roi = new Mat(src.Size(), MatType.CV_8UC3);
Roi.SetTo(0);
Cv2.DrawContours(binary, contours, -1, Scalar.White, -1); //在二值图像中圈出轮廓区域并染白
//Cv2.DrawContours(binary, contours, -1, Scalar.White);
//Cv2.ImShow("bin", binary);
src.CopyTo(Roi, binary); //将原图通过mask抠图到Roi
//Cv2.ImShow("Roi", Roi);
var afterRotato = new Mat(src.Size(), MatType.CV_8UC3);
afterRotato.SetTo(0);
Point2f center = rotateRect[i].Center;
var M = Cv2.GetRotationMatrix2D(center, angle, 1); //计算变换矩阵
Cv2.WarpAffine(Roi, afterRotato, M, Roi.Size(), InterpolationFlags.Linear,
BorderTypes.Wrap); //得到变换后的图像，滤除其他信息
var bin2 = new Mat();
//Cv2.ImShow("after", afterRotato);
Cv2.CvtColor(afterRotato, bin2, ColorConversionCodes.RGB2GRAY);
Cv2.Threshold(bin2, bin2, 50, 255, ThresholdTypes.Binary | ThresholdTypes.Otsu);
Cv2.FindContours(bin2, out var con, out _, RetrievalModes.External,
ContourApproximationModes.ApproxSimple);
foreach (var t in con)
{
var rect = Cv2.BoundingRect(t); //直接使用矫正矩形，因为矫正后不需要再旋转
if (rect.Height * rect.Width < 8000)
{
continue; //过滤干扰信息
}
return(new Mat(afterRotato, rect));
}
}
return(new Mat());
}
public Texture2D ExtraerSprite(Mat matOriginal, Contorno contorno, int ajustarRotacion)
{
var matTexturaAlfa = new Mat(contorno.BoundingRect.Height, contorno.BoundingRect.Width, MatType.CV_8UC1, new Scalar());
Cv2.DrawContours(matTexturaAlfa, new[] { contorno.contorno }, 0, ProcesarRecuadros.ColEscalarBlanco,
-1, LineTypes.AntiAlias, null, 0, -contorno.BoundingRect.TopLeft);
var matTexturaColor = new Mat(matOriginal, contorno.BoundingRect);
if (equalizarHistograma || ajusteTresh > 0f || equalizarHistogramaDeSat)
{
var convertMat = new Mat();
Cv2.CvtColor(matTexturaColor, convertMat, ColorConversionCodes.BGR2HSV);
var splits = convertMat.Split();
if (equalizarHistograma || equalizarHistogramaDeSat)
{
var clahe = Cv2.CreateCLAHE();
if (equalizarHistograma)
{
Cv2.FastNlMeansDenoising(splits[2], splits[2]);
clahe.Apply(splits[2], splits[2]);
}
if (equalizarHistogramaDeSat)
{
Cv2.FastNlMeansDenoising(splits[1], splits[1]);
clahe.Apply(splits[1], splits[1]);
}
}
// Cv2.Threshold(splits[2],splits[1],ajusteTresh,255,ThresholdTypes.TozeroInv);
if (ajusteTresh > 0)
{
Cv2.Threshold(splits[1], splits[1], ajusteTresh, 255, ThresholdTypes.Tozero);
}
// clahe.Apply(splits[1],splits[1]);
// clahe.Apply(splits[2],splits[2]);
// Cv2. EqualizeHist(splits[2],splits[2]);
Cv2.Merge(splits, matTexturaColor = convertMat);
Cv2.CvtColor(matTexturaColor, matTexturaColor, ColorConversionCodes.HSV2BGR);
}
var textura = new Texture2D(matTexturaAlfa.Width, matTexturaAlfa.Height);
textura.alphaIsTransparency = true;
textura.hideFlags = HideFlags.DontSaveInBuild | HideFlags.DontSaveInEditor;
Cv2.Merge(matTexturaColor.Split().Concat(new[] { matTexturaAlfa }).ToArray(), matTexturaAlfa);
if (ajustarRotacion > 0)
{
Cv2.Rotate(matTexturaAlfa, matTexturaAlfa, (RotateFlags)(ajustarRotacion - 1));
}
textura = OCVUnity.MatToTexture(matTexturaAlfa, textura);
return(textura);
}
void Run(string file)
{
var input = File.ReadAllBytes(file);
using (var mat = Mat.FromImageData(input))
using (var grey = mat.CvtColor(ColorConversionCodes.BGR2GRAY))
using (var thresholded = new Mat())
{
Cv2.AdaptiveThreshold(grey, thresholded, 255, AdaptiveThresholdTypes.GaussianC, ThresholdTypes.BinaryInv, 15, 7);
thresholded.SaveImage(GetModifiedName(file, "thresholded"));
/* close the gaps between the artifacts by using dilation */
int dilateX = 15, dilateY = 3;
using (var dilateKernel = Cv2.GetStructuringElement(MorphShapes.Ellipse, new Size(dilateX, dilateY)))
using (var morphed = new Mat())
{
Cv2.MorphologyEx(thresholded, morphed, MorphTypes.Dilate, dilateKernel);
morphed.SaveImage(GetModifiedName(file, "morphed"));
/* find external contours */
Mat[] contours; var hierarchy = new Mat();
Cv2.FindContours(morphed, out contours, hierarchy, RetrievalModes.External, ContourApproximationModes.ApproxSimple);
/* draw contours */
using (var contourImage = new Mat())
{
Cv2.CvtColor(grey, contourImage, ColorConversionCodes.GRAY2BGR);
Cv2.DrawContours(contourImage, contours, -1, new Scalar(0, 0, 255), 1);
contourImage.SaveImage(GetModifiedName(file, "contour"));
}
var imageHeight = mat.Height;
var yThreshold = 2;
var items = contours
.Select(c => new { Contour = c, BoundingBox = c.BoundingRect() })
.ToArray();
/* filter all contours that are near the top border or bottom border */
var filteredTopBottom = items
.Where(i => i.BoundingBox.Top <= yThreshold ||
(imageHeight - i.BoundingBox.Bottom) <= yThreshold)
.ToArray();
var filteredContours = filteredTopBottom.Select(i => i.Contour).ToArray();
DrawContours(mat.Width, imageHeight, GetModifiedName(file, "filtered-top-bottom-contours"),
filteredContours);
using (var fixedImage = grey.Clone())
{
Cv2.DrawContours(fixedImage, filteredContours, -1, new Scalar(255, 255, 255), Cv2.FILLED);
fixedImage.SaveImage(GetModifiedName(file, "fixed"));
}
}
}
}
private void Start()
{
#region load texture
Mat origin = Unity.TextureToMat(this.m_texture);
m_image_origin.texture = Unity.MatToTexture(origin);
#endregion
#region Gray scale image
Mat grayMat = new Mat();
Cv2.CvtColor(origin, grayMat, ColorConversionCodes.BGR2GRAY);
m_image_gray.texture = Unity.MatToTexture(grayMat);
#endregion
#region Find Edge
Mat thresh = new Mat();
Cv2.Threshold(grayMat, thresh, v_thresh, v_maxval, ThresholdTypes.BinaryInv);
m_Image_binarization.texture = Unity.MatToTexture(thresh);
#endregion
#region Create Mask
Mat Mask = Unity.TextureToMat(Unity.MatToTexture(grayMat));
Point[][] contours; HierarchyIndex[] hierarchy;
Cv2.FindContours(thresh, out contours, out hierarchy, RetrievalModes.Tree, ContourApproximationModes.ApproxNone, null);
for (int i = 0; i < contours.Length; i++)
{
Cv2.DrawContours(Mask, new Point[][] { contours[i] }, 0, new Scalar(0, 0, 0), -1);
}
Mask = Mask.CvtColor(ColorConversionCodes.BGR2GRAY);
Cv2.Threshold(Mask, Mask, v_thresh, v_maxval, ThresholdTypes.Binary);
m_image_mask.texture = Unity.MatToTexture(Mask);
#endregion
#region TransparentBackground
Mat transparent = origin.CvtColor(ColorConversionCodes.BGR2BGRA);
unsafe
{
byte *b_transparent = transparent.DataPointer;
byte *b_mask = Mask.DataPointer;
float pixelCount = transparent.Height * transparent.Width;
for (int i = 0; i < pixelCount; i++)
{
if (b_mask[0] == 255)
{
b_transparent[0] = 0;
b_transparent[1] = 0;
b_transparent[2] = 0;
b_transparent[3] = 0;
}
b_transparent = b_transparent + 4;
b_mask = b_mask + 1;
}
}
m_image_backgroundTransparent.texture = Unity.MatToTexture(transparent);
#endregion
}
//Draw contours
public static Mat C_Image_Draw_Contours(Mat image, Mat Origi_Image)
{
OpenCvSharp.Point[][] contours_data;
HierarchyIndex[] hierarchyIndexes;
Cv2.FindContours(image, out contours_data, out hierarchyIndexes, RetrievalModes.Tree, ContourApproximationModes.ApproxSimple);
for (int i = 0; i < contours_data.Length; i++)
{
Cv2.DrawContours(Origi_Image, contours_data, i, Scalar.Red, 2, LineTypes.Link8, hierarchyIndexes);
}
return(Origi_Image);
}
private Line GetLine(Mat img, Mat img_debug, Mat mask_white, Player player, Point pt0, Point pt1, Point pt2, string line_name)
{
//Point ptc1 = new Point(70, 390);
//Point ptc2 = new Point(520, 390);
if (config.Preview > 0)
{
Cv2.Line(img_debug, pt0, pt1, Colors.purple, 2);
Cv2.Line(img_debug, pt0, pt2, Colors.purple, 2);
}
// https://stackoverflow.com/questions/51875114/triangle-filling-in-opencv
// triangle_cnt = np.array( [pt1, pt2, pt3] )
// cv2.drawContours(image, [triangle_cnt], 0, (0, 255, 0), -1)
// cv2.imshow("image", image)
// cv2.waitKey()
// https://stackoverflow.com/questions/44063407/opencvsharp-2-floodfill-is-broken-and-corrupts-output-mask
Mat mask = new Mat(img.Rows, img.Cols, MatType.CV_8UC1, new Scalar(0, 0, 0, 0));
// floodflags = 4
// #floodflags |= cv2.FLOODFILL_MASK_ONLY
// floodflags |= (255 << 8)
//FloodFillFlags flags = FloodFillFlags.Link4 | FloodFillFlags.MaskOnly | FloodFillFlags.FixedRange;
// num,im,mask,rect = cv2.floodFill(orig2, mask, seed, (255,255,0), (5,)*3, (5,)*3, floodflags)
//Rect rect = new Rect();
//int flags = (int)FloodFillFlags.Link4 | (int)FloodFillFlags.MaskOnly | (255 << 8);
//Cv2.FloodFill(src, mask, seed, new Scalar(255, 255, 0), out rect, new Scalar(2, 2, 2), new Scalar(2, 2, 2), flags);
//Mat mask2 = new Mat(mask, new Rect(new Point(1, 1), new Size(src.Cols, src.Rows)));
//mask.Release();
// https://stackoverflow.com/questions/35969667/how-to-use-the-opencvsharp-3-polylines-fillpoly-library-function
List <List <Point> > listOfListOfPoint = new List <List <Point> >();
List <Point> points = new List <Point>();
listOfListOfPoint.Add(points);
points.Add(pt0);
points.Add(pt1);
points.Add(pt2);
//Cv2.C Polylines(mask, listOfListOfPoint, true, new Scalar(255), 1);
Cv2.DrawContours(mask, listOfListOfPoint, 0, new Scalar(255), -1);
Mat mask2 = new Mat();
Cv2.BitwiseNot(mask_white, mask2, mask);
//Cv2.BitwiseAnd(mask2, mask, mask);
Scalar color_line = Cv2.Mean(img, mask2);
if (config.Preview == 4)
{
Cv2.ImShow(line_name, mask2);
}
Line line = new Line();
line.mask = mask2;
line.color = color_line;
return(line);
}
public Mat drawContour(Mat image, Point[] contour, Scalar color)
{
Point[][] contours = new Point[1][];
contours[0] = contour;
Cv2.DrawContours(image, contours, 0,
color: color,
thickness: 4,
lineType: LineTypes.Link8,
maxLevel: int.MaxValue);
return(image);
}
Mat getBinMask()
{
Mat binmask = new Mat(_gcut.Size(), MatType.CV_8U);
binmask = _gcut & (byte)GrabCutClasses.FGD;
binmask = binmask * 255;
Mat tmp = new Mat();
binmask.CopyTo(tmp);
OpenCvSharp.HierarchyIndex[] hi;
binmask *= 0;
Cv2.FindContours(tmp, out co, out hi, RetrievalModes.CComp, ContourApproximationModes.ApproxNone);
//simplify
for (int i = 0; i < co.Length; i++)
{
double tol = 0.5;
co[i] = simplifyDouglasPeucker(co[i].Select(z => new Point2f(z.X, z.Y)).ToArray(), tol).Select(z => new OpenCvSharp.Point(z.X, z.Y)).ToArray();
}
for (int i = 0; i < co.Length; i++)
{
if (hi[i].Parent != -1)
{
continue;
}
if (Cv2.ContourArea(co[i]) < 50)
{
continue;
}
Cv2.DrawContours(binmask, co, i, new Scalar(255, 255, 255), Cv2.FILLED, LineTypes.AntiAlias);
}
for (int i = 0; i < co.Length; i++)
{
if (hi[i].Parent == -1)
{
continue;
}
if (Cv2.ContourArea(co[i]) < 50)
{
continue;
}
Cv2.DrawContours(binmask, co, i, new Scalar(0, 0, 0), Cv2.FILLED, LineTypes.AntiAlias);
}
binmask.CopyTo(_bin);
return(binmask);
}
public Mat MinEnclosing(Mat img)
{
Mat binary = new Mat();
Mat morp = new Mat();
Mat image = new Mat();
Mat dst = img.Clone();
int pointX = 0, pointY = 0;
string text;
Mat kernel = Cv2.GetStructuringElement(MorphShapes.Rect, new OpenCvSharp.Size(3, 3));
OpenCvSharp.Point[][] contours;
HierarchyIndex[] hierarchy;
Cv2.Threshold(img, binary, 230, 255, ThresholdTypes.Binary);
Cv2.MorphologyEx(binary, morp, MorphTypes.Close, kernel, new OpenCvSharp.Point(-1, -1), 2);
Cv2.BitwiseNot(morp, image);
Cv2.FindContours(image, out contours, out hierarchy, RetrievalModes.Tree, ContourApproximationModes.ApproxTC89KCOS);
for (int i = 0; i < contours.Length; i++)
{
double perimeter = Cv2.ArcLength(contours[i], true);
double epsilon = perimeter * 0.01;
OpenCvSharp.Point[] approx = Cv2.ApproxPolyDP(contours[i], epsilon, true);
OpenCvSharp.Point[][] draw_approx = new OpenCvSharp.Point[][] { approx };
Cv2.DrawContours(dst, draw_approx, -1, new Scalar(255, 0, 0), 2, LineTypes.AntiAlias);
Cv2.MinEnclosingCircle(contours[i], out Point2f center, out float radius);
Cv2.Circle(dst, new OpenCvSharp.Point(center.X, center.Y), (int)radius, Scalar.Red, 2, LineTypes.AntiAlias);
pointX += (int)center.X;
pointY += (int)center.Y;
for (int j = 0; j < approx.Length; j++)
{
Cv2.Circle(dst, approx[j], 1, new Scalar(0, 0, 255), 3);
}
}
if (contours.Length > 0)
{
pointX = pointX / contours.Length;
pointY = pointY / contours.Length;
text = pointX.ToString();
text = text + ":" + pointY.ToString();
Cv2.PutText(dst, text, new OpenCvSharp.Point(3300, 2700), HersheyFonts.HersheyPlain, 5, Scalar.White, 5);
}
return(dst);
}
public void DetectHandFrom(Pipeline pipeline)
{
FrameCount++;
ElapsedMillisecondsOfLastFrames = (int)(pipeline.FrameDate - _lastFrameDate).TotalMilliseconds;
CheckAllFramesLifeTime(pipeline.FrameDate);
CheckTrackQueueLifeTime();
_allFrames.Enqueue(pipeline.FrameDate);
OpenCvSharp.Point[][] contours;
HierarchyIndex[] hierarchyIndices;
Cv2.FindContours(pipeline.OutputMat, out contours, out hierarchyIndices, RetrievalModes.External, ContourApproximationModes.ApproxSimple);
OpenCvSharp.Point[] largestArea = null;
double largestAreaSize = 0;
foreach (var contour in contours)
{
var area = Cv2.ContourArea(contour, false);
if (area > TrackerConfig.MinHandAreaSize)
{
if (largestArea == null)
{
largestArea = contour;
largestAreaSize = area;
}
else
{
if (area > largestAreaSize)
{
largestAreaSize = area;
largestArea = contour;
}
}
}
}
HandArea = largestArea;
if (HandArea != null)
{
TrackerVisualisation = new Mat();
pipeline.InputMat.CopyTo(TrackerVisualisation);
Cv2.DrawContours(TrackerVisualisation, new OpenCvSharp.Point[][] { HandArea }, -1, new Scalar(0, 255, 0), 3);
var newSample = HandTrackerSample.From(DateTime.Now, pipeline.InputMat, HandArea);
_samples.Enqueue(newSample);
DetectHulls();
}
else
{
TrackerVisualisation = null;
}
_lastFrameDate = pipeline.FrameDate;
}
public static OpenCvSharp.Point[] Square(Mat src)
{
Mat[] split = Cv2.Split(src);
Mat blur = new Mat();
Mat binary = new Mat();
OpenCvSharp.Point[] squares = new OpenCvSharp.Point[4];
int N = 10;
double max = src.Size().Width *src.Size().Height * 0.9;
double min = src.Size().Width *src.Size().Height * 0.1;
for (int channel = 0; channel < 3; channel++)
{
Cv2.GaussianBlur(split[channel], blur, new OpenCvSharp.Size(5, 5), 1);
for (int i = 0; i < N; i++)
{
Cv2.Threshold(blur, binary, i * 255 / N, 255, ThresholdTypes.Binary);
OpenCvSharp.Point[][] contours;
HierarchyIndex[] hierarchy;
Cv2.FindContours(binary, out contours, out hierarchy, RetrievalModes.List, ContourApproximationModes.ApproxTC89KCOS);
Mat test = src.Clone();
Cv2.DrawContours(test, contours, -1, new Scalar(0, 0, 255), 3);
for (int j = 0; j < contours.Length; j++)
{
double perimeter = Cv2.ArcLength(contours[j], true);
OpenCvSharp.Point[] result = Cv2.ApproxPolyDP(contours[j], perimeter * 0.02, true);
double area = Cv2.ContourArea(result);
bool convex = Cv2.IsContourConvex(result);
if (result.Length == 4 && area > min && area < max && convex)
{
double cos = 0;
for (int k = 1; k < 5; k++)
{
double t = Math.Abs(Angle(result[(k - 1) % 4], result[k % 4], result[(k + 1) % 4]));
cos = cos > t ? cos : t;
}
if (cos < 0.15)
{
squares = result;
}
}
}
}
}
return(squares);
}
