private void BubbleDetectBtn_Click(object sender, EventArgs e) { //Applying Operations on transformed Image transformedImage = transformedImage.Resize(400, 400, Emgu.CV.CvEnum.Inter.Linear); Image <Bgr, byte> transCopy = transformedImage.Copy(); Emgu.CV.Util.VectorOfVectorOfPoint qtnVect = new Emgu.CV.Util.VectorOfVectorOfPoint(); Image <Gray, byte> qtnGray = transCopy.Convert <Gray, byte>(); Image <Gray, byte> copyG = qtnGray.Copy(); CvInvoke.GaussianBlur(qtnGray, qtnGray, new Size(5, 5), 0); CvInvoke.AdaptiveThreshold(qtnGray, qtnGray, 255, Emgu.CV.CvEnum.AdaptiveThresholdType.GaussianC, Emgu.CV.CvEnum.ThresholdType.Binary, 55, 9); CvInvoke.BitwiseNot(qtnGray, qtnGray); CvInvoke.FindContours(qtnGray, qtnVect, null, Emgu.CV.CvEnum.RetrType.External, Emgu.CV.CvEnum.ChainApproxMethod.ChainApproxSimple, default); //CIRCLE METHOD List <CircleF> circList = new List <CircleF>(); Emgu.CV.Util.VectorOfVectorOfPoint test = new Emgu.CV.Util.VectorOfVectorOfPoint(); Emgu.CV.Util.VectorOfPoint qtnApprox = new Emgu.CV.Util.VectorOfPoint(); Dictionary <int, double> qtnDict = new Dictionary <int, double>(); if (qtnVect.Size > 0) { for (int i = 0; i < qtnVect.Size; i++) { double area = CvInvoke.ContourArea(qtnVect[i]); if (area > 70) { qtnDict.Add(i, area); } } var item = qtnDict.OrderByDescending(v => v.Value); //.Take(1); Emgu.CV.Util.VectorOfPoint approxList = new Emgu.CV.Util.VectorOfPoint(); foreach (var it in item) { int key = Convert.ToInt32(it.Key.ToString()); double peri = CvInvoke.ArcLength(qtnVect[key], true); CvInvoke.ApproxPolyDP(qtnVect[key], qtnApprox, 0.02 * peri, true); if (qtnApprox.Size == 0) { } else if (qtnApprox.Size > 6) { CircleF circle = CvInvoke.MinEnclosingCircle(qtnVect[key]); Point centre = new Point(); centre.X = (int)circle.Center.X; centre.Y = (int)circle.Center.Y; CvInvoke.Circle(transformedImage, centre, (int)circle.Radius, new MCvScalar(0, 255, 0), 2, Emgu.CV.CvEnum.LineType.Filled, 0); //break; } } MessageBox.Show("Bubbles Detected"); bubbleImage.Image = transformedImage; } }
private VectorOfPoint DetectHand(Mat processedImage) { Mat copy = new Mat(); CvInvoke.CvtColor(processedImage, copy, ColorConversion.Bgr2Hsv); /*CvInvoke.InRange(processedImage, new ScalarArray(new MCvScalar(low_H, low_S, low_V)), new ScalarArray(new MCvScalar(high_H, high_S, high_V)), copy);*/ CvInvoke.InRange(processedImage, new ScalarArray(new MCvScalar(0, 63, 59)), new ScalarArray(new MCvScalar(19, 228, 247)), copy); CvInvoke.Erode(copy, copy, null, new System.Drawing.Point(-1, -1), 5, BorderType.Constant, CvInvoke.MorphologyDefaultBorderValue); CvInvoke.Dilate(copy, copy, null, new System.Drawing.Point(-1, -1), 5, BorderType.Constant, CvInvoke.MorphologyDefaultBorderValue); VectorOfVectorOfPoint contours = new VectorOfVectorOfPoint(); VectorOfPoint biggestContour = new VectorOfPoint(); CvInvoke.FindContours(copy, contours, null, RetrType.List, ChainApproxMethod.ChainApproxSimple); if (contours.Size > 0) { biggestContour = contours[0]; for (int i = 0; i < contours.Size; i++) { if (contours[i].Size > biggestContour.Size) { biggestContour = contours[i]; } } CvInvoke.ApproxPolyDP(biggestContour, biggestContour, 0.0015, true); handFrames++; return(biggestContour); } return(new VectorOfPoint()); }
public Image <Bgr, byte> findrectangles(Image <Bgr, byte> image, int n1, int n2, int thicc, int tresh, int delta) { Image <Gray, byte> binarizedImage = blur(image, n1, n2); var contours = new VectorOfVectorOfPoint(); CvInvoke.FindContours( binarizedImage, contours, null, RetrType.List, ChainApproxMethod.ChainApproxSimple); var contoursImage = image.Copy(); var approxContour = new VectorOfPoint(); for (int i = 0; i < contours.Size; i++) { CvInvoke.ApproxPolyDP( contours[i], approxContour, CvInvoke.ArcLength(contours[i], true) * 0.05, true); if (CvInvoke.ContourArea(approxContour, false) > tresh) { var points = approxContour.ToArray(); if (isRectangle(points, delta) == true) { contoursImage.Draw(CvInvoke.MinAreaRect(approxContour), new Bgr(Color.GreenYellow), thicc); } } } return(contoursImage); }
private static VectorOfVectorOfPoint FindBiggestContour(Mat image) { var biggest = new VectorOfPoint(); double max_area = 0; var contours = new VectorOfVectorOfPoint(); var biggestContour = new VectorOfVectorOfPoint(); var hierarchy = new Mat(); CvInvoke.FindContours(image, contours, hierarchy, RetrType.Tree, ChainApproxMethod.ChainApproxSimple); for (int i = 0; i < contours.Size; ++i) { var area = CvInvoke.ContourArea(contours[i]); if (area > 100) { var peri = CvInvoke.ArcLength(contours[i], true); CvInvoke.ApproxPolyDP(contours[i], contours[i], 0.02 * peri, true); //Aproximate to ideal lines if (area > max_area) { biggest = contours[i]; max_area = area; } } } biggestContour.Push(biggest); return(biggestContour); }
public void _findOutline() { using (var im = _mat.Clone()) { VectorOfVectorOfPoint contours = new VectorOfVectorOfPoint(); CvInvoke.FindContours(im, contours, null, RetrType.List, ChainApproxMethod.ChainApproxSimple); var cts = contours.ToArrayOfArray() .Select(x => CvInvoke.ConvexHull(x.Select(y => new PointF(y.X, y.Y)).ToArray())).ToArray(); var cnt = cts.OrderByDescending(z => CvInvoke.ContourArea(new VectorOfPointF(z))).ToList(); var result = new VectorOfPointF(); foreach (var c in cnt) { var vop = new VectorOfPointF(c); var peri = CvInvoke.ArcLength(vop, true); var approx = new VectorOfPointF(); CvInvoke.ApproxPolyDP(vop, approx, _approxE * peri, true); if (approx.Size == 4) { result = approx; break; } } _outline = result; } }
private void DetectShapesToolStripMenuItem_Click(object sender, EventArgs e) { if (_imgInput == null) { return; } try { var tmpCnt = ExtractContours(_imgInput); var contours = FilterContours(tmpCnt); AddContoursToResCollection(_currentFile, _fileSize, contours, true); for (var i = 0; i < contours.Size; i++) { var perimeter = CvInvoke.ArcLength(contours[i], true); var approx = new VectorOfPoint(); CvInvoke.ApproxPolyDP(contours[i], approx, 0.03 * perimeter, true); } BuildClusterPack(_currentFile, contours); pictureBox1.Image = _imgInput.AsBitmap(); //pictureBox2.Image = temp.AsBitmap(); } catch (Exception ex) { listBox1.Items.Add(ex.Message); } }
public List <List <int[]> > getContours(string pathToImage, double tolerance) { img = new Image <Gray, byte>(pathToImage); UMat uimage = new UMat(); contours = new VectorOfVectorOfPoint(); CvInvoke.FindContours(img, contours, null, RetrType.List, ChainApproxMethod.ChainApproxSimple); List <List <int[]> > allPoints = new List <List <int[]> >(); int count = contours.Size; nContours = count; for (int i = 0; i < count; i++) { using (VectorOfPoint contour = contours[i]) using (VectorOfPoint approxContour = new VectorOfPoint()) { CvInvoke.ApproxPolyDP(contour, approxContour, CvInvoke.ArcLength(contour, true) * tolerance, true); Point[] pts = approxContour.ToArray(); List <int[]> contPoints = new List <int[]>(); for (int k = 0; k < pts.Length; k++) { int[] pointsCord = new int[2]; pointsCord[0] = pts[k].X; pointsCord[1] = pts[k].Y; contPoints.Add(pointsCord); } allPoints.Add(contPoints); } } return(allPoints); }
public void FindBoundPolygon() { // find convexhull PointF[] ps = new PointF[this.slicePoints2d.Count]; for (int i = 0; i < this.slicePoints2d.Count; i++) { PointF p = new PointF((float)this.slicePoints2d[i].x, (float)this.slicePoints2d[i].y); ps[i] = p; } PointF[] hull = CvInvoke.ConvexHull(ps); // find boundary polygon VectorOfPointF hull2 = new VectorOfPointF(); hull2.Push(hull); VectorOfPointF poly = new VectorOfPointF(); // when inferring # of polygon edge, the 3-rd param can be [0.0005,0.0015], than choose the best(how to define "best"??) CvInvoke.ApproxPolyDP(hull2, poly, 0.0003, true); for (int i = 0; i < poly.Size; i++) { this.cornerPoints2d.Add(new MyVector2(poly[i].X, poly[i].Y)); } // unproject to 3d foreach (MyVector2 corner2d in this.cornerPoints2d) { MyVector3 corner3d = frame.GetPointSpaceCoord(new MyVector3(corner2d, 0.0)); this.cornerPoints3d.Add(corner3d); } }
private Point[] GetLargestContour(VectorOfVectorOfPoint contours) { Point[] largestContour = new Point[0]; var maxPeri = 0.0; for (int i = 0; i < contours.Size; i++) { var contourVector = contours[i]; using var contour = new VectorOfPoint(); var peri = CvInvoke.ArcLength(contourVector, true); var area = CvInvoke.ContourArea(contourVector); CvInvoke.ApproxPolyDP(contourVector, contour, 0.1 * peri, true); if (contour != null) // && contour.ToArray().Length == 4 && CvInvoke.IsContourConvex(contour) { if (peri > maxPeri) { largestContour = contour.ToArray(); maxPeri = peri; } } } return(largestContour); }
private void AutoCrop(string path) { using var image = new Image <Bgr, byte>(path); // Grayscale var grayScaleImage = image.Convert <Gray, byte>(); // Applying GaussianBlur var blurredImage = grayScaleImage.SmoothGaussian(5, 5, 0, 0); // OR CvInvoke.GaussianBlur(grayScaleImage, blurredImage, new Size(5, 5), 0); // Applying Canny algorithm var cannyImage = new UMat(); CvInvoke.Canny(blurredImage, cannyImage, 50, 150); // Finding largest contours var contours = new VectorOfVectorOfPointF(); CvInvoke.FindContours(cannyImage, contours, null, RetrType.Tree, ChainApproxMethod.ChainApproxSimple); for (int i = 0; i < contours.Size; i++) { var contourVector = contours[i]; using var contour = new VectorOfPoint(); var peri = CvInvoke.ArcLength(contourVector, true); CvInvoke.ApproxPolyDP(contourVector, contour, 0.1 * peri, true); if (contour.ToArray().Length == 4 && CvInvoke.IsContourConvex(contour)) { Debug.WriteLine(contour.ToString()); // return contour; } } }
public static List <Triangle2DF> GetTraingles(UMat thresholeded) { List <Triangle2DF> _triangleList = new List <Triangle2DF>(); using (VectorOfVectorOfPoint contours = new VectorOfVectorOfPoint()) { //try to find contours on previously prepared image --> CvInvoke.FindContours(thresholeded, contours, null, RetrType.List, ChainApproxMethod.ChainApproxSimple); int count = contours.Size; for (int i = 0; i < count; i++) { using (VectorOfPoint contour = contours[i]) using (VectorOfPoint approxContour = new VectorOfPoint()) { CvInvoke.ApproxPolyDP(contour, approxContour, CvInvoke.ArcLength(contour, true) * 0.04, true); if (CvInvoke.ContourArea(approxContour, false) > 1) { //triangle has 3 contours --> if (approxContour.Size == 3) { Point[] pts = approxContour.ToArray(); _triangleList.Add(new Triangle2DF( pts[0], pts[1], pts[2] )); } } } } } return(_triangleList); }
public static List <VectorOfPoint> GetContours(Image <Gray, Byte> image, ChainApproxMethod apxMethod = ChainApproxMethod.ChainApproxSimple, RetrType retrievalType = RetrType.List, double accuracy = 0.001d, double minimumArea = 10) { List <VectorOfPoint> convertedContours = new List <VectorOfPoint>(); using (VectorOfVectorOfPoint contours = new VectorOfVectorOfPoint()) { using (Image <Gray, Byte> tempImage = image.Copy()) { CvInvoke.FindContours(tempImage, contours, null, retrievalType, apxMethod); } int count = contours.Size; for (int i = 0; i < count; i++) { using (VectorOfPoint contour = contours[i]) { VectorOfPoint approxContour = new VectorOfPoint(); CvInvoke.ApproxPolyDP(contour, approxContour, accuracy, false); if (CvInvoke.ContourArea(approxContour, false) > minimumArea) { convertedContours.Add(approxContour); } } } } return(convertedContours); }
private Mat CannyShapeDetection(Mat frame) { Mat returnImg = new Mat(frame.Rows, frame.Cols, frame.Depth, frame.NumberOfChannels); CvInvoke.Canny(frame, returnImg, cannyThreshold, cannyThresholdLinking); List <Triangle2DF> triangleList = new List <Triangle2DF>(); using (VectorOfVectorOfPoint contours = new VectorOfVectorOfPoint()) { CvInvoke.FindContours(returnImg, contours, null, RetrType.List, ChainApproxMethod.ChainApproxSimple); int count = contours.Size; for (int i = 0; i < count; i++) { using (VectorOfPoint contour = contours[i]) using (VectorOfPoint approxContour = new VectorOfPoint()) { CvInvoke.ApproxPolyDP(contour, approxContour, CvInvoke.ArcLength(contour, true) * 0.05, true); if (CvInvoke.ContourArea(approxContour, false) > 250) { if (approxContour.Size == 3) { var pts = approxContour.ToArray(); triangleList.Add(new Triangle2DF(pts[0], pts[1], pts[2])); } } } } } foreach (var triangle in triangleList) { CvInvoke.Polylines(returnImg, Array.ConvertAll(triangle.GetVertices(), System.Drawing.Point.Round), true, new MCvScalar(255)); } return(returnImg); }
private void FindGlassTopContour() { VectorOfPoint contour = new VectorOfPoint(); VectorOfPoint approxContour = new VectorOfPoint(); VectorOfPoint longestContour = new VectorOfPoint(); VectorOfPoint longestContourApprox = new VectorOfPoint(); int maxLength = 0; for (int i = 0; i < _contours.Size; i++) { contour = _contours[i]; CvInvoke.ApproxPolyDP(contour, approxContour, CvInvoke.ArcLength(contour, true) * 0.1, true); if (approxContour.Size == 2) { if ((approxContour.ToArray()[0].Y > _topLiquidPoint1.Y) || (approxContour.ToArray()[1].Y > _topLiquidPoint2.Y)) { continue; } if (maxLength < (int)CvInvoke.ArcLength(approxContour, false)) { maxLength = (int)CvInvoke.ArcLength(approxContour, false); longestContour = contour; longestContourApprox = approxContour; } } } _glassTopContour = longestContour; _approxGlassTopContour = approxContour; }
private static List <RotatedRect> LineCorners(Image <Gray, byte> mImgThreshold) { List <RotatedRect> boxList = new List <RotatedRect>(); using (VectorOfVectorOfPoint contours = new VectorOfVectorOfPoint()) { CvInvoke.FindContours(mImgThreshold, contours, null, RetrType.List, ChainApproxMethod.ChainApproxSimple); var count = contours.Size; for (var i = 0; i < count; i++) { using (VectorOfPoint contour = contours[i]) using (VectorOfPoint approxContour = new VectorOfPoint()) { CvInvoke.ApproxPolyDP(contour, approxContour, CvInvoke.ArcLength(contour, true) * 0.05, true); //if (CvInvoke.ContourArea(approxContour, false) < 10) //only consider contours with area greater than 250 // continue; if (approxContour.Size != 2) // line { continue; } if (approxContour[1].X - approxContour[0].X < 5 // || approxContour[1].Y - approxContour[0].Y < 2 ) { continue; } boxList.Add(CvInvoke.MinAreaRect(approxContour)); } } } return(boxList); }
private IEnumerable <Rectangle> GetBoundariesForProcessedImage(Mat edges) { List <Rectangle> boxList = new List <Rectangle>(); using (VectorOfVectorOfPoint contours = new VectorOfVectorOfPoint()) { CvInvoke.FindContours(edges, contours, null, RetrType.List, ChainApproxMethod.ChainApproxSimple); int contourCount = contours.Size; for (int i = 0; i < contourCount; i++) { using (VectorOfPoint approxContour = new VectorOfPoint()) using (VectorOfPoint approx = contours[i]) { CvInvoke.ApproxPolyDP(approx, approxContour, CvInvoke.ArcLength(approx, true) * 0.035, true); Point[] pts = approxContour.ToArray(); LineSegment2D[] edgesList = PointCollection.PolyLine(pts, true); double contourArea = CvInvoke.ContourArea(approxContour, true); if (contourArea >= 500 && contourArea <= edges.Width * edges.Height / 5.0) { Rectangle contourRectangle = GetRectangleFromContour(approxContour, edgesList); if (contourRectangle != default(Rectangle)) { boxList.Add(contourRectangle); } } } } } return(boxList); }
public Image <Gray, Byte> RescaleImage(Image <Gray, Byte> image) { var contours = new VectorOfVectorOfPoint(); var hierarchy = new Mat(); CvInvoke.FindContours(image, contours, hierarchy, Emgu.CV.CvEnum.RetrType.Tree, Emgu.CV.CvEnum.ChainApproxMethod.ChainApproxSimple); double largestArea = 0; int index = -1; for (int i = 0; i < contours.Size; i++) { double a = CvInvoke.ContourArea(contours[i], false); if (a > largestArea) { largestArea = a; index = i; } } VectorOfPoint poly = new VectorOfPoint(); CvInvoke.ApproxPolyDP(contours[index], poly, 3, true); Rectangle rect = CvInvoke.BoundingRectangle(poly); image.ROI = rect; var croppedImage = new Image <Gray, Byte>(image.Width, image.Height); var resizedImage = new Image <Gray, Byte>(Width, Height); croppedImage = image.Copy(); CvInvoke.Resize(croppedImage, resizedImage, new Size(Width, Height)); return(resizedImage); }
private void detectShapeToolStripMenuItem_Click(object sender, EventArgs e) { if (imgInput == null) { return; } try { var tempImg = imgInput.SmoothGaussian(5).Convert <Gray, byte>().ThresholdBinaryInv(new Gray(230), new Gray(255)); VectorOfVectorOfPoint countors = new VectorOfVectorOfPoint(); Mat m = new Mat(); CvInvoke.FindContours(tempImg, countors, m, Emgu.CV.CvEnum.RetrType.External, Emgu.CV.CvEnum.ChainApproxMethod.ChainApproxSimple); for (int i = 0; i < countors.Size; i++) { double perimeter = CvInvoke.ArcLength(countors[i], true); VectorOfPoint approx = new VectorOfPoint(); CvInvoke.ApproxPolyDP(countors[i], approx, 0.04 * perimeter, true); CvInvoke.DrawContours(imgInput, countors, i, new MCvScalar(0, 0, 255), 2); //moments center of the shape var moments = CvInvoke.Moments(countors[i]); int x = (int)(moments.M10 / moments.M00); int y = (int)(moments.M01 / moments.M00); if (approx.Size == 3) { CvInvoke.PutText(imgInput, "Triangle", new Point(x, y), Emgu.CV.CvEnum.FontFace.HersheySimplex, 0.5, new MCvScalar(0, 0, 255), 2); } if (approx.Size == 4) { Rectangle rec = CvInvoke.BoundingRectangle(countors[i]); double ar = (double)rec.Height / rec.Width; if (ar >= 0.95 && ar <= 1.05) { CvInvoke.PutText(imgInput, "Square", new Point(x, y), Emgu.CV.CvEnum.FontFace.HersheySimplex, 0.5, new MCvScalar(0, 0, 255), 2); } else { CvInvoke.PutText(imgInput, "Rectangle", new Point(x, y), Emgu.CV.CvEnum.FontFace.HersheySimplex, 0.5, new MCvScalar(0, 0, 255), 2); } } if (approx.Size == 6) { CvInvoke.PutText(imgInput, "Hexagon", new Point(x, y), Emgu.CV.CvEnum.FontFace.HersheySimplex, 0.5, new MCvScalar(0, 0, 255), 2); } if (approx.Size > 6) { CvInvoke.PutText(imgInput, "Circle", new Point(x, y), Emgu.CV.CvEnum.FontFace.HersheySimplex, 0.5, new MCvScalar(0, 0, 255), 2); } pictureBox2.Image = imgInput.ToBitmap(); } } catch (Exception ex) { MessageBox.Show(ex.Message); } }
private static VectorOfPoint getLinkedContoursOfImage(VectorOfPoint contour) { VectorOfPoint approxContour = new VectorOfPoint(); CvInvoke.ApproxPolyDP(contour, approxContour, CvInvoke.ArcLength(contour, true) * 0.05, true); return(approxContour); }
public static List <Point> ApproximationPoints(List <Point> points) { var points1 = new Points(points); var drawingPoints = points1.ConvertToDrawingPoints(); var vectorPoints = new VectorOfPoint(drawingPoints); VectorOfPoint approximation = new VectorOfPoint(); CvInvoke.ApproxPolyDP(vectorPoints, approximation, DataHandler.FindMaxInAllData(points).Count * 0.03, true); return(ConvertApproximationToPoints(approximation)); }
private void fnFindTriangleRect() { triangleRectImage = img.CopyBlank(); using (VectorOfVectorOfPoint contours = new VectorOfVectorOfPoint()) { CvInvoke.FindContours(cannyEdges, contours, null, RetrType.List, ChainApproxMethod.ChainApproxSimple); int count = contours.Size; for (int i = 0; i < count; i++) { using (VectorOfPoint contour = contours[i]) using (VectorOfPoint approxContour = new VectorOfPoint()) { CvInvoke.ApproxPolyDP(contour, approxContour, CvInvoke.ArcLength(contour, true) * 0.05, true); if (CvInvoke.ContourArea(approxContour, false) > 250) //only consider contour with area > 250 { if (approxContour.Size == 3) //The contour has 3 vertices, is a triangle { Point[] pts = approxContour.ToArray(); triangleList.Add(new Triangle2DF(pts[0], pts[1], pts[2])); } else if (approxContour.Size == 4) // The contour has 4 vertices { #region Determine if all the angles in the contours are within [80,100] degree bool isRectangle = true; Point[] pts = approxContour.ToArray(); LineSegment2D[] edges = PointCollection.PolyLine(pts, true); for (int j = 0; j < edges.Length; j++) { double dAngle = Math.Abs(edges[(j + 1) % edges.Length].GetExteriorAngleDegree(edges[j])); if (dAngle < 80 || dAngle > 100) { isRectangle = false; break; } } #endregion if (isRectangle) { boxList.Add(CvInvoke.MinAreaRect(approxContour)); } } } } } } foreach (Triangle2DF triangle in triangleList) { triangleRectImage.Draw(triangle, new Bgr(Color.DarkBlue), 2); } foreach (RotatedRect box in boxList) { triangleRectImage.Draw(box, new Bgr(Color.Red), 2); } ImgBox_Triangle_Rect.Image = triangleRectImage.Bitmap; }
private void shapeDetectorToolStripMenuItem_Click(object sender, EventArgs e) { if (ActiveMdiChild is ImageView) { string shape; // Variables Image <Gray, byte> gray = ((ImageView)ActiveMdiChild).Mat.ToImage <Gray, byte>(); Image <Gray, byte> thresh = ((ImageView)ActiveMdiChild).Mat.ToImage <Gray, byte>(); VectorOfVectorOfPoint contours = new VectorOfVectorOfPoint(); // Smoothing and Thresholding gray = gray.SmoothGaussian(3); CvInvoke.Threshold(gray, thresh, 127, 255, ThresholdType.Binary); // Calling findContours from threshold CvInvoke.FindContours(gray, contours, new Mat(), RetrType.List, ChainApproxMethod.ChainApproxSimple); // Getting contour from vector VectorOfPoint cnt = contours[0]; VectorOfPoint approx = new VectorOfPoint(); CvInvoke.ApproxPolyDP(cnt, approx, 3, true); Rectangle rect = CvInvoke.BoundingRectangle(cnt); double aspectRatio = (double)(rect.Width) / rect.Height; // Detecting shape using approximation of polygon if (approx.Size == 3) { shape = "triangle"; } else if (approx.Size == 4) { if (aspectRatio >= 0.95 && aspectRatio <= 1.05) { shape = "square"; } else { shape = "rectangle"; } } else { shape = "circle"; } shapeDetectionView = new ShapeDetectionView(((ImageView)ActiveMdiChild).FileName, shape); shapeDetectionView.ShowDialog(); } else { MessageBox.Show("Image shold be selected!", "Filtering Error", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1); } }
public Image <Bgr, byte> Lab4Func(int t = 0, double trhld = 80, double minzone = 50) { var grayImage = MainImageExp.Convert <Gray, byte>(); int kernelSize = 5; // радиусразмытия var bluredImage = grayImage.SmoothGaussian(kernelSize); var threshold = new Gray(trhld); // пороговоезначение var color = new Gray(255); // этим цветомбудут закрашены пиксели,имеющие значение >threshold var binarizedImage = bluredImage.ThresholdBinary(threshold, color); var contours = new VectorOfVectorOfPoint(); // контейнер для хранения контуров CvInvoke.FindContours( binarizedImage, // исходное чёрно-белое изображение contours, // найденные контуры null, // объект для хранения иерархии контуров (в данном случае не используется) RetrType.List, // структура возвращаемых данных (в данном случае список) ChainApproxMethod.ChainApproxSimple); var contoursImage = MainImageExp.CopyBlank(); var approxContour = new VectorOfPoint(); ShT = 0; ShR = 0; for (int i = 0; i < contours.Size; i++) { CvInvoke.ApproxPolyDP( contours[i], // исходныйконтур approxContour, // контурпослеаппроксимации CvInvoke.ArcLength(contours[i], true) * 0.05, // точностьаппроксимации, прямо//пропорциональнаяплощадиконтура true); // контур становится закрытым (первая и последняя точки соединяются)} if (CvInvoke.ContourArea(approxContour, false) > minzone) { if (approxContour.Size == 3 && (t == 3 || t == 0)) { ShT++; var points = approxContour.ToArray(); contoursImage.Draw(new Triangle2DF(points[0], points[1], points[2]), new Bgr(Color.GreenYellow), 2); } if (approxContour.Size == 4 && (t == 4 || t == 0)) { var points = approxContour.ToArray(); if (isRectangle(points) == true) { ShR++; contoursImage.Draw(CvInvoke.MinAreaRect(approxContour), new Bgr(Color.GreenYellow), 2); } } } } MainImageExp = contoursImage.Convert <Bgr, byte>(); return(MainImageExp); }
public Image <Bgr, byte> GetPalm(Mat mask) { int width = mask.Width; int height = mask.Height; var temp = new Mat(); var result = mask.ToImage <Bgr, byte>(); VectorOfVectorOfPoint contours = new VectorOfVectorOfPoint(); VectorOfPoint biggestContour = new VectorOfPoint(); CvInvoke.FindContours(mask, contours, null, RetrType.List, ChainApproxMethod.ChainApproxSimple); if (contours.Size > 0) { biggestContour = contours[0]; for (int i = 0; i < contours.Size; i++) { if (contours[i].Size > biggestContour.Size) { biggestContour = contours[i]; } } } if (biggestContour.Size != 0) { //Gaunam rankos konturus CvInvoke.ApproxPolyDP(biggestContour, biggestContour, 0.00000001, false); var points = biggestContour.ToArray(); VectorOfInt hull = new VectorOfInt(); //find the palm hand area using convexitydefect CvInvoke.ConvexHull(biggestContour, hull, true); var box = CvInvoke.MinAreaRect(biggestContour); Mat defects = new Mat(); CvInvoke.ConvexityDefects(biggestContour, hull, defects); if (!defects.IsEmpty) { //Data from Mat are not directly readable so we convert it to Matrix<> Matrix <int> m = new Matrix <int>(defects.Rows, defects.Cols, defects.NumberOfChannels); defects.CopyTo(m); for (int i = 0; i < m.Rows; i++) { int startIdx = m.Data[i, 0]; int endIdx = m.Data[i, 1]; Point startPoint = points[startIdx]; Point endPoint = points[endIdx]; //draw a line connecting the convexity defect start point and end point in thin red line CvInvoke.Line(result, startPoint, endPoint, new MCvScalar(0, 0, 255)); } } } return(result); }
public static VectorOfVectorOfPoint getApproxContour(VectorOfVectorOfPoint vectors) { var approxContours = new VectorOfVectorOfPoint(); for (int i = 0; i < vectors.Size; i++) { var contour = new VectorOfPoint(); CvInvoke.ApproxPolyDP(vectors[i], contour, CvInvoke.ArcLength(vectors[i], true) * 0.05, true); approxContours.Push(contour); } return(approxContours); }
public bool Is_Triangle(VectorOfPoint hull) { CvInvoke.ApproxPolyDP(hull, hull, 10, true); if (hull.Size == 3) { return(true); } else { return(false); } }
public static double Solidity(VectorOfPoint contour, VectorOfPoint convexHull) { double contourArea = CvInvoke.ContourArea(contour); VectorOfPoint vpHull = new VectorOfPoint(); CvInvoke.ApproxPolyDP(convexHull, vpHull, 0.001, true); double hullArea = Math.Abs(CvInvoke.ContourArea(vpHull)); return(contourArea / hullArea); }
//fonction pour dessiner les limits des obj et creer leur centroide List <RotatedRect> DrawRectangle(Image <Gray, byte> imageSeuil, String name) { List <RotatedRect> boxList = new List <RotatedRect>(); contours = new VectorOfVectorOfPoint(); Mat m = new Mat(); CvInvoke.FindContours(imageSeuil, contours, m, Emgu.CV.CvEnum.RetrType.External, Emgu.CV.CvEnum.ChainApproxMethod.ChainApproxSimple); for (int i = 0; i < contours.Size; i++) { double perimeter = CvInvoke.ArcLength(contours[i], true); VectorOfPoint approx = new VectorOfPoint(); CvInvoke.ApproxPolyDP(contours[i], approx, 0.04 * perimeter, true); if (CvInvoke.ContourArea(approx, false) > 250) //only consider contours with area greater than 250 { if (approx.Size == 4) //The contour has 4 vertices, it is a rectangle { bool isRectangle = true; Point[] pts = approx.ToArray(); LineSegment2D[] edges = PointCollection.PolyLine(pts, true); for (int j = 0; j < edges.Length; j++) { double angle = Math.Abs( edges[(j + 1) % edges.Length].GetExteriorAngleDegree(edges[j])); if (angle < 80 || angle > 100) { isRectangle = false; break; } } if (isRectangle) { boxList.Add(CvInvoke.MinAreaRect(approx)); } } foreach (RotatedRect box in boxList) { CvInvoke.Polylines(imageMat, Array.ConvertAll(box.GetVertices(), Point.Round), true, new Bgr(System.Drawing.Color.Blue).MCvScalar, 2); var moments = CvInvoke.Moments(contours[i]); int x = (int)(moments.M10 / moments.M00); int y = (int)(moments.M01 / moments.M00); CvInvoke.PutText(imageMat, name, new Point(x, y), Emgu.CV.CvEnum.FontFace.HersheySimplex, 0.5, new MCvScalar(0, 0, 255), 2); } } } return(boxList); }
private Triangle2DF TriangleFromInfrared(Mat infraredMat) { Image <Gray, short> infraredImg = infraredMat.ToImage <Gray, short>(); var smoothedInfraredImg = infraredImg.PyrDown(); smoothedInfraredImg = smoothedInfraredImg.PyrUp(); using (Mat convertedMat = new Mat(infraredMat.Size, DepthType.Cv8U, 1)) using (Mat multiplierMat = new Mat(infraredMat.Size, DepthType.Cv8U, 1)) { infraredImg.Mat.ConvertTo(convertedMat, DepthType.Cv8U, 1d / 256d); multiplierMat.SetTo(new MCvScalar(infraMultiplier)); CvInvoke.Multiply(convertedMat, multiplierMat, convertedMat); Mat thresholdMat = new Mat(infraredMat.Size, DepthType.Cv8U, 1); CvInvoke.Threshold(convertedMat, thresholdMat, 230, 255, ThresholdType.Binary); List <Triangle2DF> triangleList = new List <Triangle2DF>(); using (VectorOfVectorOfPoint contours = new VectorOfVectorOfPoint()) { CvInvoke.FindContours(thresholdMat, contours, null, RetrType.List, ChainApproxMethod.ChainApproxSimple); int count = contours.Size; for (int i = 0; i < count; i++) { using (VectorOfPoint contour = contours[i]) using (VectorOfPoint approxContour = new VectorOfPoint()) { CvInvoke.ApproxPolyDP(contour, approxContour, CvInvoke.ArcLength(contour, true) * 0.05, true); if (CvInvoke.ContourArea(approxContour, false) > 250) { if (approxContour.Size == 3) { var pts = approxContour.ToArray(); triangleList.Add(new Triangle2DF(pts[0], pts[1], pts[2])); } } } } } var biggestTri = triangleList.OrderBy((tri) => tri.Area).FirstOrDefault(); CvInvoke.Polylines(thresholdMat, Array.ConvertAll(biggestTri.GetVertices(), System.Drawing.Point.Round), true, new MCvScalar(255)); foreach (var triangle in triangleList) { CvInvoke.Polylines(convertedMat, Array.ConvertAll(triangle.GetVertices(), System.Drawing.Point.Round), true, new MCvScalar(255)); } //CvInvoke.Imshow("threshold", thresholdMat); return(biggestTri); } }
public void FindRectangles() { Image <Gray, byte> img = originalMat.ToImage <Bgr, byte>().Canny(127, 255); VectorOfVectorOfPoint contours = new VectorOfVectorOfPoint(); Mat mat = new Mat(); CvInvoke.FindContours(img, contours, mat, RetrType.External, ChainApproxMethod.ChainApproxSimple); VectorOfPoint contour = new VectorOfPoint(); VectorOfVectorOfPoint squares = new VectorOfVectorOfPoint(); for (int i = 0; i < contours.Size; i++) { CvInvoke.ApproxPolyDP(contours[i], contour, CvInvoke.ArcLength(contours[i], true) * 0.02, true); if (contour.Size == 4 && Math.Abs(CvInvoke.ContourArea(contour)) > SearchSize && CvInvoke.IsContourConvex(contour)) { Rectangle rect = CvInvoke.BoundingRectangle(contour); Rectangle maskRect = new Rectangle(rect.Location, rect.Size); Size inflateSize = new Size((int)(maskRect.Width * -0.1), (int)(maskRect.Height * -0.1)); maskRect.Inflate(inflateSize); Mat shapeMat = new Mat(originalMat, maskRect); int[] colorScalars = CvInvoke.Mean(shapeMat).ToArray().Select(x => (int)x).ToArray(); Color color = Color.FromArgb(255, colorScalars[2], colorScalars[1], colorScalars[0]); if (color.ToArgb() == Color.ToArgb()) { double maxCosine = 0.0; for (int j = 2; j < 5; j++) { double cosine = Math.Abs(Angle(contour[j % 4], contour[j - 2], contour[j - 1])); maxCosine = cosine > maxCosine ? cosine : maxCosine; } if (maxCosine < 0.3) { squares.Push(contour); } } } } Image <Bgr, byte> imgOut = new Image <Bgr, byte>(originalImage); CvInvoke.DrawContours(imgOut, squares, -1, new MCvScalar(0, 0, 255)); image.Image = new Bitmap(imgOut.Bitmap); imgOut.Dispose(); }