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);
}
