public void convert() { var imaging = new ImagingManager(Source); var scale = 0.4; imaging.AddFilter(new Imaging.Library.Filters.BasicFilters.BicubicFilter(scale)); //Downscaling imaging.Render(); imaging.AddFilter(new CannyEdgeDetector()); imaging.Render(); var blobCounter = new BlobCounter { ObjectsOrder = ObjectsOrder.Size }; imaging.AddFilter(blobCounter); imaging.Render(); List <Point> corners = null; var blobs = blobCounter.GetObjectsInformation(); foreach (var blob in blobs) { var points = blobCounter.GetBlobsEdgePoints(blob); var shapeChecker = new SimpleShapeChecker(); if (shapeChecker.IsQuadrilateral(points, out corners)) { break; } } var edgePoints = new EdgePoints(); edgePoints.SetPoints(corners.ToArray()); imaging.Render(); imaging.UndoAll(); edgePoints = edgePoints.ZoomIn(scale); imaging.AddFilter(new QuadrilateralTransformation(edgePoints, true)); imaging.Render(); var strm = StreamLoadFromPixel(imaging.Output); var memoryStream = new MemoryStream(); strm.CopyTo(memoryStream); DependencyService.Get <ISaveViewFile>().SaveAndViewAsync("out.jpg", memoryStream); myimg.Source = LoadFromPixel(imaging.Output); box.IsVisible = false; loading.IsVisible = false; loading.IsRunning = false; stackloading.IsVisible = false; }
private void InitializeFilters() { grayscaleFilter = new Grayscale(0.299, 0.587, 0.114); bradleyLocalFilter = new BradleyLocalThresholding(); bradleyLocalFilter.WindowSize = 9; bradleyLocalFilter.PixelBrightnessDifferenceLimit = 0.01f; plateBlobsFiltering = new BlobsFiltering(10, 20, 80, 66); blobCounter = new BlobCounter(); blobCounter.FilterBlobs = true; blobCounter.MinWidth = 50; blobCounter.MinHeight = 10; blobCounter.MaxWidth = 520; blobCounter.MaxHeight = 110; plateBlobCounter = new BlobCounter(); shapeChecker = new SimpleShapeChecker(); otsuThresholdFilter = new OtsuThreshold(); fillHoles = new FillHoles(); fillHoles.MaxHoleWidth = 100; fillHoles.MaxHoleHeight = 40; pen = new Pen(Color.GreenYellow, 4); openingFilter = new Opening(); contrastCorrectionFilter = new ContrastCorrection(80); colorFiltering = new ColorFiltering(); colorFiltering.Red = new IntRange(150, 255); colorFiltering.Green = new IntRange(150, 255); colorFiltering.Blue = new IntRange(150, 255); colorFiltering.FillOutsideRange = true; invert = new Invert(); }
private static List <List <IntPoint> > _FindQuads(Bitmap bitmap) { BlobCounter blobCounter = new BlobCounter(); blobCounter.MinHeight = 32; blobCounter.MinWidth = 32; blobCounter.FilterBlobs = true; blobCounter.ObjectsOrder = ObjectsOrder.Size; blobCounter.ProcessImage(bitmap); Blob[] blobs = blobCounter.GetObjectsInformation(); List <List <IntPoint> > foundObjects = new List <List <IntPoint> >(); SimpleShapeChecker shapeChecker = new SimpleShapeChecker(); List <IntPoint> corners; foreach (var blob in blobs) { List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blob); // does it look like a quadrilateral ? if (shapeChecker.IsQuadrilateral(edgePoints, out corners)) { foundObjects.Add(corners); } } return(foundObjects); }
private bool BlobCounter() { // lock image BitmapData bitmapData = _bitmap.LockBits(ImageLockMode.ReadWrite); // step 1 - turn background to black ColorFiltering colorFilter = new ColorFiltering(); colorFilter.Red = new IntRange(0, 64); colorFilter.Green = new IntRange(0, 64); colorFilter.Blue = new IntRange(0, 64); colorFilter.FillOutsideRange = false; colorFilter.ApplyInPlace(bitmapData); // step 2 - locating objects BlobCounter blobCounter = new BlobCounter(); blobCounter.FilterBlobs = true; blobCounter.MinHeight = 100; blobCounter.ProcessImage(bitmapData); Blob[] blobs = blobCounter.GetObjectsInformation(); _bitmap.UnlockBits(bitmapData); // step 3 - check objects' type and highlight SimpleShapeChecker shapeChecker = new SimpleShapeChecker(); using (var g = Graphics.FromImage(_bitmap)) using (Pen pen = new Pen(Color.Red, 2)) { for (int i = 0; i < blobs.Length; i++) { //Debug.WriteLine(String.Format("Blob {0}: W: {1} H:{2} ", i, blobs[i].Rectangle.Width, blobs[i].Rectangle.Height)); List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]); List <IntPoint> corners; if (shapeChecker.IsConvexPolygon(edgePoints, out corners)) { pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid; g.DrawRectangle(pen, blobs[i].Rectangle); } } } RectRight = new Rectangle(); RectLeft = new Rectangle(); if (blobs.Length != 2 || blobs.Any(b => b.Rectangle.Width > 47)) { return(false); } else { RectLeft = blobs.OrderBy(b => b.Rectangle.Left).First().Rectangle; RectRight = blobs.OrderBy(b => b.Rectangle.Left).Last().Rectangle; return(true); } }
public bool getCirlces(Bitmap bitmap) { bool isCirclePresent = false; BlobCounter blobCounter = new BlobCounter(); blobCounter.ProcessImage(bitmap); Blob[] blobs = blobCounter.GetObjectsInformation(); SimpleShapeChecker shapeChecker = new SimpleShapeChecker(); shapeChecker.RelativeDistortionLimit = 00.15F; for (int i = 0, n = blobs.Length; i < n; i++) { List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]); AForge.Point center; float radius; if (shapeChecker.IsCircle(edgePoints)) { isCirclePresent = true; } } return(isCirclePresent); }
public override void calcDescriptorInfo(Bitmap inImage) { shapeCount = new int[6]; originalImage = image; image = imgProcessor.preProcessImage(inImage); g = Graphics.FromImage(originalImage); BlobCounter bCounter = new BlobCounter(); bCounter.ProcessImage(image); Blob[] blobs = bCounter.GetObjectsInformation(); SimpleShapeChecker shapeChecker = new SimpleShapeChecker(); for (int i = 0; i < blobs.Length; i++) { if (blobs[i].Area < 100) { continue; } List <IntPoint> edgePts = bCounter.GetBlobsEdgePoints(blobs[i]); checkShape(shapeChecker, edgePts); } g.Dispose(); }
public List <List <System.Drawing.Point> > FindQuadrilaterals(Bitmap image) { var result = new List <List <System.Drawing.Point> >(); // locating objects var blobCounter = new BlobCounter(image); blobCounter.FilterBlobs = true; blobCounter.MinHeight = 20; blobCounter.MinWidth = 20; blobCounter.ProcessImage(image); Blob[] blobs = blobCounter.GetObjectsInformation(); // check for rectangles var shapeChecker = new SimpleShapeChecker(); foreach (var blob in blobs) { var edgePoints = blobCounter.GetBlobsEdgePoints(blob); // use the shape checker to extract the corner points if (shapeChecker.IsQuadrilateral(edgePoints, out List <IntPoint> cornerPoints)) { var points = cornerPoints.Select(point => new System.Drawing.Point(point.X, point.Y)).ToList(); result.Add(points); Graphics g = Graphics.FromImage(image); g.DrawPolygon(new Pen(Color.Red, 1.0f), points.ToArray()); } } return(result); }
private UMat findSquares(UMat img) { // Open your image string path = "test.png"; Bitmap image = img.Bitmap; //(Bitmap)Bitmap.FromFile(path); // locating objects BlobCounter blobCounter = new BlobCounter(); blobCounter.FilterBlobs = false; blobCounter.MinHeight = 5; blobCounter.MinWidth = 5; blobCounter.ProcessImage(image); Blob[] blobs = blobCounter.GetObjectsInformation(); // check for rectangles SimpleShapeChecker shapeChecker = new SimpleShapeChecker(); foreach (var blob in blobs) { List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blob); List <IntPoint> cornerPoints; // use the shape checker to extract the corner points if (shapeChecker.IsQuadrilateral(edgePoints, out cornerPoints)) { // only do things if the corners form a rectangle if (shapeChecker.CheckPolygonSubType(cornerPoints) == PolygonSubType.Rectangle) { // here i use the graphics class to draw an overlay, but you // could also just use the cornerPoints list to calculate your // x, y, width, height values. List <AForge.Point> Points = new List <AForge.Point>(); foreach (var point in cornerPoints) { Points.Add(new AForge.Point(point.X, point.Y)); } PointF[] P = new PointF[Points.Count]; for (int i = 0; i < P.Length; i++) { P[i] = new PointF(Points[i].X, Points[i].Y); } Bitmap newBitmap = new Bitmap(image.Width, image.Height); Graphics g = Graphics.FromImage(newBitmap); g.DrawImage(image, 0, 0); //Graphics g = Graphics.FromImage(image); g.DrawPolygon(new Pen(Color.Red, 5.0f), P); image = newBitmap; //image.Save("result.png"); } } } return((new Image <Bgr, Byte>(image)).ToUMat()); }
private async Task <IList <Rect> > GetPlateRectanglesAsync(Bitmap image) { var rectanglePoints = await Task.Factory.StartNew(() => { var blobCounter = new BlobCounter { FilterBlobs = true, MinHeight = 5, MinWidth = 5 }; blobCounter.ProcessImage(image); var blobs = blobCounter.GetObjectsInformation(); var shapeChecker = new SimpleShapeChecker(); var rectPoints = new List <List <AForgePoint> >(); foreach (var blob in blobs) { List <IntPoint> cornerPoints; var edgePoints = blobCounter.GetBlobsEdgePoints(blob); var points = new List <AForgePoint>(); if (shapeChecker.IsQuadrilateral(edgePoints, out cornerPoints)) { var polygonType = shapeChecker.CheckPolygonSubType(cornerPoints); if (polygonType == PolygonSubType.Rectangle || polygonType == PolygonSubType.Parallelogram) { foreach (var point in cornerPoints) { points.Add(new AForgePoint(point.X, point.Y)); } rectPoints.Add(points); } } } return(rectPoints); }); var rects = rectanglePoints.Select(points => GetRect(points)).ToList(); var images = new List <WriteableBitmap>(); var cadidatesRects = new List <Rect>(); foreach (var rect in rects) { var ratio = rect.Height / rect.Width; if (ratio >= MinPlateRatio && ratio <= MaxPlateRatio) { cadidatesRects.Add(rect); } } return(cadidatesRects); }
private Bitmap ProcessImage(Bitmap frame) { // convert the image to grayscale var grayConverter = new GrayscaleBT709(); var grayFrame = grayConverter.Apply(frame); // use a sobel edge detector to find color edges var edgeDetector = new SobelEdgeDetector(); var edgeFrame = edgeDetector.Apply(grayFrame); // threshold the edges var thresholdConverter = new Threshold(200); thresholdConverter.ApplyInPlace(edgeFrame); // use a blobcounter to find interesting shapes var detector = new BlobCounter() { FilterBlobs = true, MinWidth = 25, MinHeight = 25 }; detector.ProcessImage(edgeFrame); // find the circular shape var shapeDetector = new SimpleShapeChecker(); var blobs = detector.GetObjectsInformation(); var circles = from blob in blobs let edgePoints = detector.GetBlobsEdgePoints(blob) where shapeDetector.CheckShapeType(edgePoints) == ShapeType.Circle select blob; // show the traffic sign if (circles.Count() > 0) { var circleFrame = frame.Clone(circles.First().Rectangle, PixelFormat.DontCare); trafficSignBox.Image = circleFrame; } // highlight every circle in the image using (Graphics g = Graphics.FromImage(frame)) { var rects = detector.GetObjectsRectangles(); var pen = new Pen(Color.Blue, 4); foreach (var circle in circles) { g.DrawRectangle(pen, circle.Rectangle); } } // update picture boxes thresholdBox.Image = edgeFrame; return(frame); }
/// <summary> /// Méthode qui analyse les images envoyées par le client /// Repère les formes présentes, les découpe et les enregistre en ficiers distincts /// </summary> public void ProcessImage() { using (CamCapturer.CamCapturer cam = new CamCapturer.CamCapturer()) { Picture = cam.GetCapture(); Copy = cam.GetCapture(); } ShapeChecker = new SimpleShapeChecker(); ShapeAnalyser = new BlobCounter(); string date = DateTime.Now.Date.ToString("dMyyyy"); FolderName = string.Format("Kuhlschrank-{0}", date); ShapeAnalyser.FilterBlobs = true; ShapeAnalyser.MinHeight = 200; ShapeAnalyser.MinWidth = 500; Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), FolderName)); BitmapData bitData = Picture.LockBits(new Rectangle(0, 0, Picture.Width, Picture.Height), ImageLockMode.ReadWrite, Picture.PixelFormat); ColorFiltering filter = new ColorFiltering(); filter.Red = new IntRange(0, 64); filter.Green = new IntRange(0, 64); filter.Blue = new IntRange(0, 64); filter.FillOutsideRange = false; filter.ApplyInPlace(bitData); ShapeAnalyser.ProcessImage(bitData); Blob[] blobs = ShapeAnalyser.GetObjectsInformation(); Picture.UnlockBits(bitData); for (int i = 0; i < blobs.Length; i++) { List <IntPoint> edgePoints = ShapeAnalyser.GetBlobsEdgePoints(blobs[i]); List <IntPoint> corners; ShapeChecker.IsConvexPolygon(edgePoints, out corners); IntPoint pt0 = corners[0]; IntPoint pt1 = corners[1]; IntPoint pt2 = corners[2]; double width = Math.Sqrt(Math.Pow(pt1.X - pt0.X, 2) + Math.Pow(pt1.Y - pt0.Y, 2)); double height = Math.Sqrt(Math.Pow(pt2.X - pt1.X, 2) + Math.Pow(pt2.Y - pt1.Y, 2)); Rectangle crop = new Rectangle(corners[0].X, corners[1].Y, (int)width + 50, (int)height + 50); Bitmap target = new Bitmap(crop.Width, crop.Height); using (Graphics gr = Graphics.FromImage(target)) gr.DrawImage(Copy, new Rectangle(0, 0, target.Width, target.Height), crop, GraphicsUnit.Pixel); target.Save(string.Format(@"{0}\{1}\crop{2}.jpg", Path.GetTempPath(), FolderName, i)); } }
public List <int> GetLocationOfAllCircles(Bitmap bit) { Bitmap bits = edgedetection(bit); List <int> circleX = new List <int>(); List <int> circleY = new List <int>(); List <int> circleRadius = new List <int>(); SimpleShapeChecker shapeChecker = new SimpleShapeChecker(); BlobCounter blobCounter = new BlobCounter(); blobCounter.ProcessImage(bits); Blob[] blobs = blobCounter.GetObjectsInformation(); shapeChecker.RelativeDistortionLimit = 0.03f; for (int i = 0, n = blobs.Length; i < n; i++) { //Console.WriteLine("blob info is " + blobs[i].CenterOfGravity); List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]); AForge.Point center; float radius; // Console.WriteLine("The count is" + edgePoints.Count); if (shapeChecker.IsCircle(edgePoints, out center, out radius)) { circleX.Add((int)center.X); circleY.Add((int)center.Y); circleRadius.Add((int)radius); } } try { return(getLoctaionOfCircle(bits, circleX, circleY, circleRadius)); } catch (ArgumentOutOfRangeException) { circleX.Add(0); circleY.Add(0); circleRadius.Add(0); return(getLoctaionOfCircle(bits, circleX, circleY, circleRadius)); } }
public void GetDisplayCorner(ManagedImage m_processedImage, out List <IntPoint> displaycornerPoints) { // get display corner position //Process Image to 1bpp to increase SNR Bitmap m_orig = m_processedImage.bitmap.Clone(new Rectangle(0, 0, m_processedImage.bitmap.Width, m_processedImage.bitmap.Height), System.Drawing.Imaging.PixelFormat.Format1bppIndexed); // only support the 32bppArgb for Aforge Blob Counter Bitmap processbmp = m_orig.Clone(new Rectangle(0, 0, m_orig.Width, m_orig.Height), System.Drawing.Imaging.PixelFormat.Format32bppArgb); BlobCounter bbc = new BlobCounter(); bbc.FilterBlobs = true; bbc.MinHeight = 5; bbc.MinWidth = 5; bbc.ProcessImage(processbmp); Blob[] blobs = bbc.GetObjectsInformation(); SimpleShapeChecker shapeChecker = new SimpleShapeChecker(); foreach (var blob in blobs) { List <IntPoint> edgePoints = bbc.GetBlobsEdgePoints(blob); List <IntPoint> cornerPoints; int count = 0; // use the shape checker to extract the corner points if (shapeChecker.IsQuadrilateral(edgePoints, out cornerPoints)) { // only do things if the corners from a rectangle if (shapeChecker.CheckPolygonSubType(cornerPoints) == PolygonSubType.Rectangle) { flagPoints = cornerPoints; continue; } else { MessageBox.Show("Cannot Find the Display"); flagPoints = null; // picturebox_test.Image = m; count++; if (count < 3) { continue; } else { MessageBox.Show("Cannot Find the Display for 3 times. Quit Program"); Environment.ExitCode = -1; Application.Exit(); } } } } displaycornerPoints = flagPoints; }
private void ScanDocumentBtn_Click(object sender, EventArgs e) { var imaging = new ImagingManager(Source); var scale = 0.4; imaging.AddFilter(new BicubicFilter(scale)); //Downscaling imaging.Render(); imaging.AddFilter(new CannyEdgeDetector()); imaging.Render(); var blobCounter = new BlobCounter { ObjectsOrder = ObjectsOrder.Size }; imaging.AddFilter(blobCounter); imaging.Render(); List <Point> corners = null; var blobs = blobCounter.GetObjectsInformation(); foreach (var blob in blobs) { var points = blobCounter.GetBlobsEdgePoints(blob); var shapeChecker = new SimpleShapeChecker(); if (shapeChecker.IsQuadrilateral(points, out corners)) { break; } } var edgePoints = new EdgePoints(); edgePoints.SetPoints(corners.ToArray()); imaging.Render(); imaging.UndoAll(); edgePoints = edgePoints.ZoomIn(scale); imaging.AddFilter(new QuadrilateralTransformation(edgePoints, true)); imaging.Render(); var image = LoadFromPixelMap(imaging.Output); var imageView = FindViewById <ImageView>(Resource.Id.myImageView); imageView.SetImageBitmap(image); }
/// <summary> /// Initialize the needed components for this class. /// </summary> public void Initialize() { this.shapeChecker = new SimpleShapeChecker(); this.CellList = new List <ColonyModel>(); this.blobList = new List <Blob>(); // SET COLOR RANGE FOR BACKGROUND RangeRed = new IntRange(255, 255); RangeGreen = new IntRange(255, 255); RangeBlue = new IntRange(255, 255); }
public void GetDisplayCornerfrombmp(Bitmap processbmp, out List <IntPoint> displaycornerPoints) { BlobCounter bbc = new BlobCounter(); bbc.FilterBlobs = true; bbc.MinHeight = 5; bbc.MinWidth = 5; bbc.ProcessImage(processbmp); Blob[] blobs = bbc.GetObjectsInformation(); SimpleShapeChecker shapeChecker = new SimpleShapeChecker(); foreach (var blob in blobs) { List <IntPoint> edgePoints = bbc.GetBlobsEdgePoints(blob); List <IntPoint> cornerPoints; // use the shape checker to extract the corner points if (shapeChecker.IsQuadrilateral(edgePoints, out cornerPoints)) { // only do things if the corners from a rectangle if (shapeChecker.CheckPolygonSubType(cornerPoints) == PolygonSubType.Rectangle) { flagPoints = cornerPoints; List <IntPoint> tmpPoints = new List <IntPoint>(flagPoints); int max = new int[] { tmpPoints[0].X, tmpPoints[1].X, tmpPoints[2].X, tmpPoints[3].X }.Max(); int min = new int[] { tmpPoints[0].X, tmpPoints[1].X, tmpPoints[2].X, tmpPoints[3].X }.Min(); if (max - min > 500) { break; } continue; //break; } else { flagPoints = null; continue; } } } if (flagPoints == null) { MessageBox.Show("Cannot Find the Display"); } displaycornerPoints = flagPoints; }
/// <summary> /// Use AForge to automatically detect the image borders, and crop it to size /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void AutoFitImage_Click(object sender, RoutedEventArgs e) { if (_LocalPersistentObject.bitmapProcessingImage == null) { return; } WriteableBitmap bmp = _LocalPersistentObject.bitmapProcessingImage as WriteableBitmap; bmp = bmp.Resize(1024, 1024, WriteableBitmapExtensions.Interpolation.Bilinear); Bitmap image = AForge.Imaging.Image.Clone((Bitmap)bmp, System.Drawing.Imaging.PixelFormat.Format8bppIndexed); BlobCounter blobCounter = new BlobCounter(); blobCounter.FilterBlobs = true; blobCounter.MinHeight = 50; blobCounter.MinWidth = 50; blobCounter.ProcessImage(image); Blob[] blobs = blobCounter.GetObjectsInformation(); // check for rectangles SimpleShapeChecker shapeChecker = new SimpleShapeChecker(); foreach (var blob in blobs) { List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blob); List <IntPoint> cornerPoints; // use the shape checker to extract the corner points if (shapeChecker.IsQuadrilateral(edgePoints, out cornerPoints)) { // only do things if the corners form a rectangle if (shapeChecker.CheckPolygonSubType(cornerPoints) == PolygonSubType.Square) { // here i use the graphics class to draw an overlay, but you // could also just use the cornerPoints list to calculate your // x, y, width, height values. List <AForge.Point> Points = new List <AForge.Point>(); bmp = bmp.Crop(cornerPoints[0].X, cornerPoints[0].Y, cornerPoints[2].X, cornerPoints[2].Y); } } } bmp = bmp.Resize(640, 640, WriteableBitmapExtensions.Interpolation.Bilinear); _LocalPersistentObject.bitmapProcessingImage = (WriteableBitmap)bmp; MainImageFrame.Navigate(typeof(ImageLoadedView), _LocalPersistentObject, new SuppressNavigationTransitionInfo()); }
private void colorOfPlayer(Bitmap bitmap) { HSLFiltering GreenFilter = new HSLFiltering(); GreenFilter.Hue = new IntRange(200, 250); GreenFilter.Saturation = new Range(0.5f, 1); GreenFilter.Luminance = new Range(0.2f, 0.6f); GreenFilter.ApplyInPlace(bitmap); wbt = (WriteableBitmap)bitmap; img2.Source = wbt; img2.Visibility = Visibility.Visible; // this.PictureBox.Source = (ImageSource)concatenate.Apply(this.img2); BlobCounter blobCounter = new AForge.Imaging.BlobCounter(); blobCounter.ObjectsOrder = ObjectsOrder.Area; blobCounter.FilterBlobs = true; blobCounter.MinHeight = 10; blobCounter.MinWidth = 10; blobCounter.ProcessImage(bitmap); Blob[] blobs = blobCounter.GetObjectsInformation(); SimpleShapeChecker shapeChecker = new SimpleShapeChecker(); try { for (int i = 0, n = blobs.Length; i < n; i++) { List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]); AForge.Point center; float radius; // is circle ? if (shapeChecker.IsCircle(edgePoints, out center, out radius)) { if ((blobs[i].Area < 17000) && (blobs[i].Area > 3000)) { score = score + 2; } else if ((blobs[i].Area < 3000) && (blobs[i].Area > 1300)) { score = score + 4; } else if (blobs[i].Area < 1300) { score = score + 6; } } } }catch (Exception eeeee) { } text_score.Text = "" + score; }
private void button7_Click(object sender, EventArgs e) { Bitmap image = (Bitmap)pictureBox6.Image; // create instance of blob counter BlobCounter blobCounter = new BlobCounter(); blobCounter.FilterBlobs = true; blobCounter.MinHeight = 5; blobCounter.MinWidth = 5; blobCounter.MaxWidth = 350; blobCounter.MaxHeight = 350; //process the dilated image blobCounter.ProcessImage(image); // get info about detected objects Blob[] blobs = blobCounter.GetObjectsInformation(); // create a graphics object to draw on the image and a pen Graphics g = Graphics.FromImage(image); Pen Redpen = new Pen(Color.Red, 4); SimpleShapeChecker shapechecker = new SimpleShapeChecker(); //check in image and draw around the object found as rectangle for (int i = 0, n = blobs.Length; i < n; i++) { List <IntPoint> edgepoints = blobCounter.GetBlobsEdgePoints(blobs[i]); List <Point> Points = new List <Point>(); if (shapechecker.IsQuadrilateral(edgepoints, out cornerpoints)) { if (shapechecker.CheckPolygonSubType(cornerpoints) == PolygonSubType.Rectangle) { g.DrawPolygon(Redpen, cornerpoints.Select(p => new System.Drawing.Point(p.X, p.Y)).ToArray()); } } foreach (var point in cornerpoints) { Crop filter = new Crop(new Rectangle(point.X, point.Y, image.Width, image.Height)); newImage = filter.Apply(image); } } Redpen.Dispose(); g.Dispose(); pictureBox7.Image = newImage; }
public static bool HaveLabelRF(Bitmap imagePassport) { bool haveLabel = false; // 1- grayscale image Bitmap grayImage = AForge.Imaging.Filters.Grayscale.CommonAlgorithms.BT709.Apply(imagePassport); // 2 - Otsu thresholding AForge.Imaging.Filters.OtsuThreshold threshold = new AForge.Imaging.Filters.OtsuThreshold(); Bitmap binaryImage = threshold.Apply(grayImage); AForge.Imaging.Filters.Invert invertFilter = new AForge.Imaging.Filters.Invert(); Bitmap invertImage = invertFilter.Apply(binaryImage); // 3 - Blob counting BlobCounter blobCounter = new BlobCounter(); blobCounter.FilterBlobs = true; blobCounter.MinWidth = 10; blobCounter.MinWidth = 10; blobCounter.ProcessImage(invertImage); Blob[] blobs = blobCounter.GetObjectsInformation(); // 4 - check shape of each blob SimpleShapeChecker shapeChecker = new SimpleShapeChecker(); int count = 0; foreach (Blob blob in blobs) { List <AForge.IntPoint> edgePoint = blobCounter.GetBlobsEdgePoints(blob); // check if shape looks like a circle AForge.Point center; float radius; if (shapeChecker.IsCircle(edgePoint, out center, out radius)) { count++; Rectangle cloneRect = new Rectangle((int)(center.X - radius), (int)(center.Y - radius + 1.0), (int)(radius * 2) + 1, (int)(radius * 2) + 1); Bitmap RF = new Bitmap(binaryImage.Clone(cloneRect, binaryImage.PixelFormat), 32, 32); Bitmap RF2 = AForge.Imaging.Filters.Grayscale.CommonAlgorithms.BT709.Apply(RF); Bitmap RF3 = threshold.Apply(RF2); if (CompareLabel(RF3) > 70.0) { haveLabel = true; } } } return(haveLabel); }
public static List <Rectangle> FindRectangles(Bitmap source) { Bitmap canny = Grayscale.CommonAlgorithms.RMY.Apply(source); CannyEdgeDetector edgeDetector = new CannyEdgeDetector(5, 20); edgeDetector.ApplyInPlace(canny); BlobCounter blobCounter = new BlobCounter { FilterBlobs = true, MinWidth = 5, MinHeight = 5 }; blobCounter.ProcessImage(canny); Blob[] blobs = blobCounter.GetObjectsInformation(); List <Rectangle> rectangles = new List <Rectangle>(); SimpleShapeChecker shapeChecker = new SimpleShapeChecker(); for (int i = 0; i < blobs.Length; i++) { List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]); if (shapeChecker.IsConvexPolygon(edgePoints, out List <IntPoint> corners)) { if (blobs[i].Rectangle.Width > canny.Width / 5.3 && blobs[i].Rectangle.Width <canny.Width / 4.41 && canny.Height / 10.3> blobs[i].Rectangle.Height && blobs[i].Rectangle.Height > canny.Height / 20.5) { rectangles.Add(blobs[i].Rectangle); } } } // order by descending area rectangles.Sort((a, b) => { if (a.Width * a.Height > b.Width * b.Height) { return(1); } else if (a.Width * a.Height < b.Width * b.Height) { return(-1); } return(0); }); return(rectangles); }
/// <summary> /// Detects squares inside the provided image and makes image slices for each square. /// </summary> /// <param name="imagePath">Path to the diagram image.</param> /// <returns>Bitmap of the diagram image with marked table squares.</returns> private Bitmap Slice(string imagePath) { Bitmap image = PreProcess((Bitmap)Bitmap.FromFile(imagePath)); Bitmap fakeImage = new Bitmap(image.Width, image.Height); BlobCounter blobCounter = new BlobCounter(); blobCounter.FilterBlobs = true; blobCounter.MinHeight = 80; blobCounter.MinWidth = 80; blobCounter.ProcessImage(image); Blob[] blobs = blobCounter.GetObjectsInformation(); var maxArea = blobs.Max(b => b.Area); blobs = blobs.Where(b => b.Area != maxArea).ToArray(); // check for rectangles SimpleShapeChecker shapeChecker = new SimpleShapeChecker(); Graphics g = Graphics.FromImage(fakeImage); g.DrawImage(image, 0, 0, image.Width, image.Height); foreach (var blob in blobs) { Bitmap cropped = Crop(image, blob.Rectangle.X, blob.Rectangle.Y, blob.Rectangle.Width, blob.Rectangle.Height); cropped.Save(@"temp/" + DateTime.Now.Ticks + ".png"); List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blob); List <IntPoint> cornerPoints; shapeChecker.IsQuadrilateral(edgePoints, out cornerPoints); List <System.Drawing.Point> Points = new List <System.Drawing.Point>(); foreach (var point in cornerPoints) { Points.Add(new System.Drawing.Point(point.X, point.Y)); } g.DrawPolygon(new Pen(Color.Red, 5.0f), Points.ToArray()); } return(fakeImage); }
private void checkShape(SimpleShapeChecker shapeChecker, List <IntPoint> edgePts) { AForge.Point center; float radius; List <IntPoint> corners; if (edgePts.Count > 4 && shapeChecker.IsCircle(edgePts, out center, out radius)) { //shape is a circle drawEllipse(center, radius); shapeCount[0]++; } else if (edgePts.Count > 3 && shapeChecker.IsConvexPolygon(edgePts, out corners)) { PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners); if (subType == PolygonSubType.Unknown) { shapeCount[4]++; } else if (subType == PolygonSubType.Square) { shapeCount[2]++; } else if (subType == PolygonSubType.Rectangle) { shapeCount[3]++; } else if (subType == PolygonSubType.Trapezoid) { shapeCount[5]++; } else if (subType == PolygonSubType.EquilateralTriangle) { shapeCount[1]++; } else if (subType == PolygonSubType.IsoscelesTriangle) { shapeCount[1]++; } drawPolygon(corners); } else if (shapeChecker.IsTriangle(edgePts)) { //triangle shapeCount[1]++; } }
Pen greenPen = new Pen(Color.Green, 7); //is answer // public Form1() { InitializeComponent(); /*---filters---*/ brightnessFilter = new BrightnessCorrection(brightnessLevel); invertFilter = new Invert(); smoothFilter = new AdaptiveSmoothing(smoothFactor); thresholdFilter = new Threshold(thresholdLevel); blobFilter = new BlobsFiltering(); /*---tools---*/ blobCounter = new BlobCounter(); shapeChecker = new SimpleShapeChecker(); }
public void CreateFilters() { grayscaleFilter = new Grayscale(0.2125, 0.7154, 0.0721); sobelFilter = new SobelEdgeDetector(); dilitationFilter = new Dilatation3x3(); thresholdFilter = new Threshold(100); blobCounter = new BlobCounter {MinHeight = 200, MinWidth = 200, FilterBlobs = true, ObjectsOrder = ObjectsOrder.Size}; shapeChecker = new SimpleShapeChecker(); binaryGlyphRecognizer = new SquareBinaryGlyphRecognizer(5); // 5x5 matrica invertFilter = new Invert(); rotateFilter = new RotateBilinear(90); pen = new Pen(Color.CornflowerBlue, 4); mirrorFilter = new Mirror(false, true); hullFinder = new GrahamConvexHull(); otsuThresholdFilter = new OtsuThreshold(); }
private Tuple <Bitmap, IntPoint, IntPoint, IntPoint, IntPoint> ShapeCheck(Bitmap image) { IntPoint p1 = new IntPoint(); IntPoint p2 = new IntPoint(); IntPoint p3 = new IntPoint(); IntPoint p4 = new IntPoint(); BlobCounter blobCounter = new BlobCounter(); blobCounter.FilterBlobs = true; blobCounter.MinHeight = 500; blobCounter.MinWidth = 400; blobCounter.ProcessImage(image); Blob[] blobs = blobCounter.GetObjectsInformation(); SimpleShapeChecker shapeChecker = new SimpleShapeChecker(); foreach (var blob in blobs) { List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blob); List <IntPoint> cornerPoints; if (shapeChecker.IsQuadrilateral(edgePoints, out cornerPoints)) { if (shapeChecker.CheckPolygonSubType(cornerPoints) == PolygonSubType.Rectangle) { var points = SortCorners(cornerPoints, image); p1 = points.Item1; p2 = points.Item2; p3 = points.Item3; p4 = points.Item4; lblInfo.Content = "p1: " + p1.ToString() + " | p2: " + p2.ToString() + " | p3: " + p3.ToString() + " | p4: " + p4.ToString(); List <IntPoint> Points = new List <IntPoint>(); foreach (var point in cornerPoints) { Points.Add(new IntPoint(point.X, point.Y)); } Graphics g = Graphics.FromImage(image); g.DrawPolygon(new Pen(Color.Red, 5.0f), Points.Select(p => new System.Drawing.Point(p.X, p.Y)).ToArray()); } } } return(Tuple.Create(image, p1, p2, p3, p4)); }
public static Bitmap buscaRectangulos(Bitmap bitmap) { Blob[] blobs; Rectangle area = new Rectangle(0, 0, bitmap.Width, bitmap.Height); // lock image BitmapData bitmapData = bitmap.LockBits(area, ImageLockMode.ReadWrite, bitmap.PixelFormat); // Filtramos la imagen para determinar hasts cuando de ROJO, VERDE Y AZUL se permitiráanalizar ColorFiltering colorFilter = new ColorFiltering(); colorFilter.Red = new IntRange(0, 104); colorFilter.Green = new IntRange(0, 104); colorFilter.Blue = new IntRange(0, 104); colorFilter.FillOutsideRange = false; colorFilter.ApplyInPlace(bitmapData); // Localizamos objetos en la imagen BlobCounter blobCounter = new BlobCounter(); blobCounter.FilterBlobs = true; blobCounter.MinHeight = 15; blobCounter.MinWidth = 15; blobCounter.ProcessImage(bitmapData); blobs = blobCounter.GetObjectsInformation(); bitmap.UnlockBits(bitmapData); // step 3 -check objects' type and highlight SimpleShapeChecker shapeChecker = new SimpleShapeChecker(); Graphics g = Graphics.FromImage(bitmap); Pen yellowPen = new Pen(Color.Yellow, 2); // Para cada figuura encontrada for (int i = 0, n = blobs.Length; i < n; i++) { List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]); List <IntPoint> corners; // Cuadrado if (shapeChecker.IsQuadrilateral(edgePoints, out corners)) {//Obtenemos cuantas esquinas tiene el shape PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners); //Pintamos las áreas detectadas areaInteres(g, corners); } } //yellowPen.Dispose(); g.Dispose(); // put new image to clipboard Clipboard.SetDataObject(bitmap); // and to picture box return(bitmap); }
static void Main(string[] args) { try { string path = "D:\\HACK2015\\PICS"; Bitmap sourceImage = AForge.Imaging.Image.FromFile(Path.Combine(path, "CAM1s.jpg")); Difference differenceFilter = new Difference(); //AForge.Imaging.Filters.Difference differenceFilter.OverlayImage = sourceImage; Bitmap sourceImg = AForge.Imaging.Image.FromFile(Path.Combine(path, "CAM1.jpg")); Bitmap tempImg = sourceImg.Clone() as Bitmap; tempImg = differenceFilter.Apply(tempImg); FiltersSequence seq = new FiltersSequence(); seq.Add(Grayscale.CommonAlgorithms.BT709); seq.Add(new OtsuThreshold()); tempImg = seq.Apply(tempImg); tempImg.Save(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "CAM1.jpg")); int objectCount = 0; BlobCounter blobCounter = new BlobCounter(); blobCounter.FilterBlobs = true; blobCounter.MinHeight = 60; blobCounter.MinWidth = 40; blobCounter.ProcessImage(tempImg); Blob[] blobs = blobCounter.GetObjectsInformation(); for (int i = 0; i < blobs.Length; i++) { List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]); List <IntPoint> corners = null; SimpleShapeChecker shapeChecker = new SimpleShapeChecker(); if (shapeChecker.IsQuadrilateral(edgePoints, out corners)) { ++objectCount; } } Console.WriteLine("No. of BLOBS: " + blobCounter.GetObjectsInformation().Length); } catch (Exception ex) { Console.WriteLine(ex.Message); } Console.Read(); }
public Bitmap DetectCircle(Bitmap image) { SimpleShapeChecker shapeChecker = new SimpleShapeChecker(); // locate objects using blob counter BlobCounter blobCounter = new BlobCounter(); blobCounter.ProcessImage(image); Blob[] blobs = blobCounter.GetObjectsInformation(); // create Graphics object to draw on the image and a pen Graphics g = Graphics.FromImage(image); Pen redPen = new Pen(Color.Red, 2); // check each object and draw circle around objects, which // are recognized as circles for (int i = 0, n = blobs.Length; i < n; i++) { List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]); try { shapeChecker.CheckShapeType(edgePoints); } catch (Exception) { continue; } List <IntPoint> corners; AForge.Point center; float radius; if (shapeChecker.IsCircle(edgePoints, out center, out radius)) { g.DrawEllipse(redPen, (int)(center.X - radius), (int)(center.Y - radius), (int)(radius * 2), (int)(radius * 2)); } else if (shapeChecker.IsQuadrilateral(edgePoints, out corners)) { g.DrawPolygon(redPen, ToPointsArray(corners)); } } redPen.Dispose(); g.Dispose(); return(image); }
// ========================================================= private Bitmap DrawRectanglesFunct_OLD(Bitmap image) { // step 1 - turn background to black (done) // step 2 - locating objects BlobCounter blobCounter = new BlobCounter(); blobCounter.FilterBlobs = true; blobCounter.MinHeight = 3; blobCounter.MinWidth = 3; blobCounter.ProcessImage(image); Blob[] blobs = blobCounter.GetObjectsInformation(); // step 3 - check objects' type and do what you do: Graphics g = Graphics.FromImage(image); Pen pen = new Pen(Color.DarkOrange, 2); for (int i = 0, n = blobs.Length; i < n; i++) { SimpleShapeChecker ShapeChecker = new SimpleShapeChecker(); List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]); List <IntPoint> cornerPoints; // fine tune ShapeChecker ShapeChecker.AngleError = 15; // default 7 ShapeChecker.LengthError = 0.3F; // default 0.1 (10%) ShapeChecker.MinAcceptableDistortion = 0.9F; // in pixels, default 0.5 ShapeChecker.RelativeDistortionLimit = 0.2F; // default 0.03 (3%) // use the Outline checker to extract the corner points if (ShapeChecker.IsQuadrilateral(edgePoints, out cornerPoints)) { // only do things if the corners form a rectangle if (ShapeChecker.CheckPolygonSubType(cornerPoints) == PolygonSubType.Rectangle) { List <IntPoint> corners = PointsCloud.FindQuadrilateralCorners(edgePoints); g.DrawPolygon(pen, ToPointsArray(corners)); } } } return(image); }