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 async void StartScan(object sender, EventArgs e)
{
var scale = 0.4;
var stream = await TakePhoto();
Loader.IsRunning = true;
Loader.IsVisible = true;
LoaderGrid.IsVisible = true;
await Task.Delay(10);
var source = GetPixelMap(stream);
var imaging = new ImagingManager(source); //source is PixelMap, you can find samples how to convert image to PixelMap
imaging.AddFilter(new BicubicFilter(scale)); //Downscaling
imaging.AddFilter(new CannyEdgeDetector()); //This filter contains Grayscale and Gaussian filter in it
imaging.Render(); //Renders the image to use it further use
var blobCounter = new BlobCounter()
{
ObjectsOrder = ObjectsOrder.Size
};
imaging.AddFilter(blobCounter);
imaging.Render();
//Following code finds largest quadratical blob
List <Imaging.Library.Entities.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;
}
}
imaging.UndoAll(); //Undo every filters applied
var edgePoints = new EdgePoints();
edgePoints.SetPoints(corners.ToArray());
edgePoints = edgePoints.ZoomIn(scale); //Corrects points that found on downscaled image to original
imaging.AddFilter(new QuadrilateralTransformation(edgePoints, true));
imaging.Render();
CovertedImage.Source = LoadImageFromPixelMap(imaging.Output);
//imaging.Output gives that extracted rectangle shape from photo. Check out WPF sample how to save it.
Loader.IsRunning = false;
Loader.IsVisible = false;
LoaderGrid.IsVisible = false;
await Task.Delay(10);
}
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 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 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 void process()
{
stopwatch.Reset();
stopwatch.Start();
plates = new List <string>();
frame = contrastCorrectionFilter.Apply(originalImage);
frame = grayscaleFilter.Apply(frame);
BitmapData frameData = frame.LockBits(new Rectangle(0, 0, frame.Width, frame.Height), ImageLockMode.ReadWrite, frame.PixelFormat);
UnmanagedImage data = new UnmanagedImage(frameData);
bradleyLocalFilter.ApplyInPlace(data);
fillHoles.ApplyInPlace(data);
openingFilter.ApplyInPlace(data);
blobCounter.ProcessImage(data);
data.Dispose();
frame.UnlockBits(frameData);
Graphics g = Graphics.FromImage(originalImage);
Blob[] blobs = blobCounter.GetObjectsInformation();
foreach (Blob blob in blobs)
{
List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blob);
List <IntPoint> corners = null;
// da li je četverougao?
if (!shapeChecker.IsQuadrilateral(edgePoints, out corners))
{
continue;
}
if (FindNewCornersAndCheckAspectRatio(corners))
{
SimpleQuadrilateralTransformation sqt = new SimpleQuadrilateralTransformation(corners, 300, 66);
Bitmap plate = sqt.Apply(originalImage);
plate = grayscaleFilter.Apply(plate);
otsuThresholdFilter.ApplyInPlace(plate);
if (!IsLicensePlate(plate))
{
continue;
}
String plateText;
if (FindText(plate, out plateText))
{
g.DrawPolygon(pen, ToPointsArray(corners));
frame = plate;
plates.Add(plateText);
}
}
}
g.Dispose();
stopwatch.Stop();
}
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);
}
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 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;
}
/// <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 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);
}
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);
}
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();
}
private bool isSquare(List <IntPoint> edgePoints, out List <IntPoint> corners)
{
if (shapeChecker.IsQuadrilateral(edgePoints, out corners))
{
// edges same length?
IntPoint v1 = corners[0] - corners[1];
IntPoint v2 = corners[1] - corners[2];
float t1 = v1.EuclideanNorm() - v2.EuclideanNorm();
if (t1 < 0)
{
t1 = -t1;
}
if (t1 > 3)
{
return(false);
}
IntPoint v3 = corners[2] - corners[3];
float t2 = v2.EuclideanNorm() - v3.EuclideanNorm();
if (t2 < 0)
{
t2 = -t2;
}
if (t2 > 3)
{
return(false);
}
IntPoint v4 = corners[3] - corners[0];
float t3 = v3.EuclideanNorm() - v4.EuclideanNorm();
if (t3 < 0)
{
t3 = -t3;
}
if (t3 > 3)
{
return(false);
}
return(true);
}
else
{
return(false);
}
}
// =========================================================
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);
}
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;
continue;
}
else
{
MessageBox.Show("Cannot Find the Display");
flagPoints = null;
// picturebox_test.Image = m;
continue;
}
}
}
displaycornerPoints = flagPoints;
}
public static IntPoint[] DetectSurface(Bitmap image)
{
var blobCounter = new BlobCounter
{
FilterBlobs = true,
MinHeight = 10,
MinWidth = 10
};
var shapes = new List <Shape>();
var shapeChecker = new SimpleShapeChecker();
var threshold = GetThreshold(image);
blobCounter.BackgroundThreshold = Color.FromArgb(255, threshold, threshold, threshold);
blobCounter.ProcessImage(image);
var blobs = blobCounter.GetObjectsInformation();
foreach (var blob in blobs)
{
if (blob.Fullness >= 1)
{
continue;
}
var edgePoints = blobCounter.GetBlobsEdgePoints(blob);
if (shapeChecker.IsQuadrilateral(edgePoints, out List <IntPoint> corners))
{
shapes.Add(new Shape {
Blob = blob, Corners = corners
});
}
}
var bestShape = shapes.OrderBy(s => s.Blob.Area)
.Skip(shapes.Count / 2)
.Take(1).FirstOrDefault();
return(bestShape?.Corners?.ToArray());
}
private bool IsValid(Bitmap image, SimpleShapeChecker shapeChecker, List <IntPoint> blobEdgePoints,
out List <IntPoint> cornerPoints)
{
if (!shapeChecker.IsQuadrilateral(blobEdgePoints, out cornerPoints))
{
return(false);
}
if (shapeChecker.CheckPolygonSubType(cornerPoints) != PolygonSubType.Rectangle)
{
return(false);
}
if (!IsSameSizeAsLogo(cornerPoints))
{
return(false);
}
if (!IsWhiteRectangle(image, cornerPoints))
{
return(false);
}
return(true);
}
public List <IntPoint> GetDisplayCorner(Bitmap bitmap)
{
BlobCounter bbc = new BlobCounter();
bbc.FilterBlobs = true;
bbc.MinHeight = 5;
bbc.MinWidth = 5;
bbc.ProcessImage(bitmap);
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;
continue;
}
else
{
flagPoints = null;
continue;
}
}
}
return(flagPoints);
}
private void ProcessImage(Bitmap bitmap)
{
// lock image
BitmapData bitmapData = bitmap.LockBits(
new Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.ReadWrite, bitmap.PixelFormat);
// step 1 - turn background to black
ColorFiltering colorFilter = new ColorFiltering();
colorFilter.Red = new IntRange(Properties.Settings.Default.camFilterRed1, Properties.Settings.Default.camFilterRed2);
colorFilter.Green = new IntRange(Properties.Settings.Default.camFilterGreen1, Properties.Settings.Default.camFilterGreen2);
colorFilter.Blue = new IntRange(Properties.Settings.Default.camFilterBlue1, Properties.Settings.Default.camFilterBlue2);
colorFilter.FillOutsideRange = Properties.Settings.Default.camFilterOutside;
colorFilter.ApplyInPlace(bitmapData);
// step 2 - locating objects
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = (int)Properties.Settings.Default.camShapeSizeMin * (int)cameraZoom;
blobCounter.MinWidth = (int)Properties.Settings.Default.camShapeSizeMin * (int)cameraZoom;
blobCounter.MaxHeight = (int)Properties.Settings.Default.camShapeSizeMax * (int)cameraZoom;
blobCounter.MaxWidth = (int)Properties.Settings.Default.camShapeSizeMax * (int)cameraZoom;
blobCounter.ProcessImage(bitmapData);
Blob[] blobs = blobCounter.GetObjectsInformation();
bitmap.UnlockBits(bitmapData);
// step 3 - check objects' type and highlight
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
shapeChecker.MinAcceptableDistortion = (float)Properties.Settings.Default.camShapeDist;
shapeChecker.RelativeDistortionLimit = (float)Properties.Settings.Default.camShapeDistMax;
Graphics g = Graphics.FromImage(bitmap);
Pen yellowPen = new Pen(Color.Yellow, 5); // circles
Pen redPen = new Pen(Color.Red, 10); // circles
Pen greenPen = new Pen(Color.Green, 5); // known triangle
double lowestDistance = xmid;
double distance;
shapeFound = false;
AForge.Point center;
double shapeRadius = 1;
for (int i = 0, n = blobs.Length; i < n; i++)
{
List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
System.Single radius;
// is circle ?
// g.DrawPolygon(greenPen, ToPointsArray(edgePoints));
if (Properties.Settings.Default.camShapeCircle && shapeChecker.IsCircle(edgePoints, out center, out radius))
{
shapeFound = true;
distance = center.DistanceTo((AForge.Point)picCenter);
g.DrawEllipse(yellowPen,
(float)(shapeCenter.X - shapeRadius), (float)(shapeCenter.Y - shapeRadius),
(float)(shapeRadius * 2), (float)(shapeRadius * 2));
if (lowestDistance > Math.Abs(distance))
{
lowestDistance = Math.Abs(distance);
shapeCenter = center;
shapeRadius = radius;
}
}
List <IntPoint> corners;
if (Properties.Settings.Default.camShapeRect && shapeChecker.IsQuadrilateral(edgePoints, out corners)) //.IsConvexPolygon
{
IntPoint minxy, maxxy, centxy;
shapeFound = true;
PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
g.DrawPolygon(yellowPen, ToPointsArray(corners));
PointsCloud.GetBoundingRectangle(corners, out minxy, out maxxy);
centxy = (minxy + maxxy) / 2;
distance = picCenter.DistanceTo(centxy);// PointsCloud.GetCenterOfGravity(corners));
if (lowestDistance > Math.Abs(distance))
{
lowestDistance = Math.Abs(distance);
shapeCenter = centxy; // PointsCloud.GetCenterOfGravity(corners);
shapeRadius = maxxy.DistanceTo(minxy) / 2; // 50;
}
}
}
if (shapeFound)
{
g.DrawEllipse(redPen,
(float)(shapeCenter.X - shapeRadius * 1.2), (float)(shapeCenter.Y - shapeRadius * 1.2),
(float)(shapeRadius * 2.4), (float)(shapeRadius * 2.4));
}
yellowPen.Dispose();
redPen.Dispose();
greenPen.Dispose();
g.Dispose();
pictureBoxVideo.BackgroundImage = bitmap;
}
private void FindChessBoard(Bitmap image, ref List <int> coordX, ref List <int> coordY)
{
// locating objects
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 50;
blobCounter.MinWidth = 50;
blobCounter.MaxHeight = image.Height / 8;
blobCounter.MaxWidth = image.Height / 8;
Graphics g = Graphics.FromImage(image);
// create grayscale filter (BT709)
Grayscale filterG = new Grayscale(0.2125, 0.7154, 0.0721);
// apply the filter
Bitmap imageWork = filterG.Apply(image);
imageWork.Save("resultGrey.png");
// create filter
Threshold filterBinarisation = new Threshold(ThresholdChessboard);
// apply the filter
filterBinarisation.ApplyInPlace(imageWork);
imageWork.Save("resultBinarisation.png");
// create filter
Erosion filterErosion = new Erosion();
// apply the filter
filterErosion.ApplyInPlace(imageWork);
imageWork.Save("resultErosion.png");
blobCounter.ProcessImage(imageWork);
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 <Point> Points = new List <Point>();
foreach (var point in cornerPoints)
{
coordX.Add(point.X);
coordY.Add(point.Y);
Points.Add(new Point(point.X, point.Y));
}
g.DrawPolygon(new Pen(Color.Red, 1.0f), Points.ToArray());
}
}
}
coordX = filterPos(coordX);
coordY = filterPos(coordY);
if (coordX.Count > 2 && coordY.Count > 2)
{
g.DrawRectangle(new Pen(Color.Green, 1.0f), coordX[0], coordY[0], coordX[coordX.Count - 1] - coordX[0], coordY[coordY.Count - 1] - coordY[0]);
}
image.Save("debug.bmp");
}
public ImageProcessorResult Process(Bitmap bitmap, bool rgb)
{
var result = new ImageProcessorResult();
_viewConfig = _configService.ViewConfig;
_imageProcessorConfig = _configService.ImageProcessorConfig;
new Blur().ApplyInPlace(bitmap);
Bitmap overlay = bitmap;
if (_viewConfig.BackgroundImage == ViewConfigBackgroundImage.CameraRaw)
{
// 카메라 원본
overlay = bitmap;
}
// 그레이 스케일
var grayscale = Grayscale.CommonAlgorithms.BT709.Apply(bitmap);
// 경계 검출
var edges = new DifferenceEdgeDetector().Apply(grayscale);
if (_viewConfig.BackgroundImage == ViewConfigBackgroundImage.Edge)
{
overlay = new GrayscaleToRGB().Apply(edges);
}
// 이진화
// var threshold = new Threshold(_imageProcessorConfig.Threshold).Apply(edges);
var threshold = new OtsuThreshold().Apply(edges);
if (_viewConfig.BackgroundImage == ViewConfigBackgroundImage.Binary)
{
overlay = new GrayscaleToRGB().Apply(threshold);
}
// 오버레이 복제
overlay = overlay.CloneBitmap();
// 오버레이 데이터
var overlayData = overlay.LockBits(overlay.GetRectangle(), ImageLockMode.ReadWrite, overlay.PixelFormat);
_blobCounter = new BlobCounter();
_blobCounter.MinHeight = _imageProcessorConfig.BlobMinHeight;
_blobCounter.MinHeight = _imageProcessorConfig.BlobMinWidth;
_blobCounter.FilterBlobs = true;
_blobCounter.ObjectsOrder = ObjectsOrder.XY;
_blobCounter.ProcessImage(threshold);
var blobs = _blobCounter.GetObjectsInformation();
var shapeChecker = new SimpleShapeChecker();
// 각 영역에 대해 처리 수행
foreach (var blob in blobs)
{
// 현재 시도하는 마커
Marker marker = new Marker();
var edgePoints = _blobCounter.GetBlobsEdgePoints(blob);
// 사각형 판정
var points = new List <IntPoint>();
if (shapeChecker.IsQuadrilateral(edgePoints, out points))
{
marker.Points = points;
List <IntPoint> leftEdge, rightEdge;
_blobCounter.GetBlobsLeftAndRightEdges(blob, out leftEdge, out rightEdge);
// 각도와 길이 판정
if (MoreQuadTest(blob, marker, leftEdge, rightEdge))
{
// 검은색 테두리 판정
if (BorderTest(blob, marker, grayscale, leftEdge, rightEdge))
{
// 판정 완료
result.Markers.Add(marker);
// 무게 중심 좌표
marker.X = (int)(blob.CenterOfGravity.X - (threshold.Width / 2));
marker.Y = (int)(-(blob.CenterOfGravity.Y - (threshold.Height / 2)));
// 프레임워크에서 계산한 넓이
marker.FrameworkArea = blob.Area;
// 오버레이
ApplyOverlay(overlayData, marker.Points);
}
}
}
}
overlay.UnlockBits(overlayData);
foreach (var marker in result.Markers)
{
var points = marker.Points;
// 방향 보정
var sideLength = points[0].DistanceTo(points[1]);
if (points[2].Y - points[1].Y < sideLength / 1.6)
{
points = new List <IntPoint>(
new IntPoint[] { points[1], points[2], points[3], points[0] });
marker.Points = points;
}
// 변형 복구
var quadrilateralTransformation = new QuadrilateralTransformation(points,
_imageProcessorConfig.QuadrilateralTransformationWidth,
_imageProcessorConfig.QuadrilateralTransformationHeight);
var transformed = quadrilateralTransformation.Apply(bitmap);
// 회전 및 색상 판정 시작
int halfWidth = _imageProcessorConfig.QuadrilateralTransformationWidth / 2,
halfHeight = _imageProcessorConfig.QuadrilateralTransformationHeight / 2;
// x => x + 1 사분면
var crops = new[]
{
new Crop(new Rectangle(halfWidth, 0, halfWidth, halfHeight)),
new Crop(new Rectangle(0, 0, halfWidth, halfHeight)),
new Crop(new Rectangle(0, halfHeight, halfWidth, halfHeight)),
new Crop(new Rectangle(halfWidth, halfHeight, halfWidth, halfHeight))
};
var quadImage = new[]
{
crops[0].Apply(transformed),
crops[1].Apply(transformed),
crops[2].Apply(transformed),
crops[3].Apply(transformed)
};
var filteredResult = new[] {
new {
Img = quadImage[0],
Red = Filter(quadImage[0], MarkerColor.Red).Luminance(),
Green = Filter(quadImage[0], MarkerColor.Green).Luminance(),
Blue = Filter(quadImage[0], MarkerColor.Blue).Luminance(),
White = Filter(quadImage[0], MarkerColor.White).Luminance()
},
new {
Img = quadImage[1],
Red = Filter(quadImage[1], MarkerColor.Red).Luminance(),
Green = Filter(quadImage[1], MarkerColor.Green).Luminance(),
Blue = Filter(quadImage[1], MarkerColor.Blue).Luminance(),
White = Filter(quadImage[1], MarkerColor.White).Luminance()
},
new {
Img = quadImage[2],
Red = Filter(quadImage[2], MarkerColor.Red).Luminance(),
Green = Filter(quadImage[2], MarkerColor.Green).Luminance(),
Blue = Filter(quadImage[2], MarkerColor.Blue).Luminance(),
White = Filter(quadImage[2], MarkerColor.White).Luminance()
},
new {
Img = quadImage[3],
Red = Filter(quadImage[3], MarkerColor.Red).Luminance(),
Green = Filter(quadImage[3], MarkerColor.Green).Luminance(),
Blue = Filter(quadImage[3], MarkerColor.Blue).Luminance(),
White = Filter(quadImage[3], MarkerColor.White).Luminance()
}
};
var whiteDesc = filteredResult.OrderByDescending(a => a.White).ToArray();
if (rgb)
{
// RGB 색상 판별
var colorQuad = whiteDesc.Skip(1);
var red = colorQuad.Sum(a => a.Red);
var green = colorQuad.Sum(a => a.Green);
var blue = colorQuad.Sum(a => a.Blue);
Console.WriteLine("{0}: {1} {2} {3}", colorQuad.Count(), red, green, blue);
var max = Math.Max(red, Math.Max(green, blue));
if (red == max)
{
marker.Color = MarkerColor.Red;
}
else if (green == max)
{
marker.Color = MarkerColor.Green;
}
else if (blue == max)
{
marker.Color = MarkerColor.Blue;
}
}
else
{
// 흑백 색상 판별
var whiteMax = whiteDesc[0].White;
var whiteRest = (whiteDesc[1].White + whiteDesc[2].White + whiteDesc[3].White) / 3;
if (whiteMax - whiteRest < _imageProcessorConfig.ColorTestWhite)
{
// White
marker.Color = MarkerColor.White;
}
else
{
// Black
marker.Color = MarkerColor.Black;
}
}
// 회전 판별
for (int i = 0; i < 4; i++)
{
if (filteredResult[i].White == whiteDesc.First().White)
{
marker.Rotate = (MarkerRotate)(i + 1);
break;
}
}
// 백색 마커에는 회전 방향이 없습니다.
if (marker.Color == MarkerColor.White)
{
// 지정되지 않습니다.
marker.Rotate = MarkerRotate.None;
}
// 화상 중심으로 좌표 변환
for (int i = 0; i < marker.Points.Count; i++)
{
marker.Points[i] = new IntPoint
{
X = marker.Points[i].X - _configService.DeviceConfig.PixelWidth / 2,
Y = marker.Points[i].Y - _configService.DeviceConfig.PixelHeight / 2
};
}
// 코어 서비스에서 기하학적 방법으로 거리 계산
var coreResult = _coreService.Query(marker.Points, _imageProcessorConfig.MarkerSize);
marker.EuclideanDistance = coreResult.Distance;
marker.TiltAngle = Math.Asin(coreResult.TranslationVector[1] / marker.EuclideanDistance);
marker.PanAngle = Math.Asin(coreResult.TranslationVector[0] / marker.EuclideanDistance);
if (marker.PanAngle > Math.PI)
{
// 음수
marker.PanAngle = 2 * Math.PI - marker.PanAngle;
}
marker.TransX = coreResult.TranslationVector[0];
marker.TransY = coreResult.TranslationVector[1];
marker.TransZ = coreResult.TranslationVector[2];
}
BackgroundBitmap = overlay;
Console.WriteLine();
foreach (var marker in result.Markers)
{
Console.WriteLine(marker.Color);
}
return(result);
}
private System.Drawing.Rectangle?FindHealthbarRect()
{
var healthArea = CaptureApexWindow();
// locating objects
var blobCounter = new BlobCounter();
blobCounter.CoupledSizeFiltering = true;
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 6;
blobCounter.MinWidth = 100;
blobCounter.MaxHeight = 15;
//grayscale
var bmp = Grayscale.CommonAlgorithms.BT709.Apply(healthArea);
//Invert invert = new Invert();
//bmp = invert.Apply(bmp);
var filter = new IterativeThreshold(2, 4);
// apply the filter
filter.ApplyInPlace(bmp);
blobCounter.ProcessImage(bmp);
Blob[] blobs = blobCounter.GetObjectsInformation();
// check for rectangles
var shapeChecker = new SimpleShapeChecker();
shapeChecker.AngleError = 5.0f;
shapeChecker.LengthError = 0.5f;
foreach (var blob in blobs)
{
List <AForge.IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blob);
List <AForge.IntPoint> cornerPoints;
try
{
// use the shape checker to extract the corner points
if (shapeChecker.IsQuadrilateral(edgePoints, out cornerPoints))
{
PolygonSubType subType = shapeChecker.CheckPolygonSubType(cornerPoints);
if (subType == PolygonSubType.Trapezoid)
{
// 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 <System.Drawing.Point> Points = new List <System.Drawing.Point>();
foreach (var point in cornerPoints)
{
Points.Add(new System.Drawing.Point(point.X, point.Y));
}
var boundingBox = GetBoundingBox(Points);
var ratio = (boundingBox.Width / (float)boundingBox.Height);
if (ratio > 21.0f && ratio < 24.0f)
{
return(boundingBox);
}
}
}
}
catch (Exception e) { }
}
return(null);
}
private void altProcess(Bitmap bm, int level)
{
var img = new Image <Bgr, byte>(bm);
if (level == 1)
{
var resImage = new Image <Bgr, byte>(img.Bitmap);
CvInvoke.BilateralFilter(resImage, img, 30, 80, 80);
CvInvoke.MedianBlur(img, img, 5);
resImage = img;
}
else if (level == 2)
{
CvInvoke.MedianBlur(img, img, 5);
var resImage = new Image <Bgr, byte>(img.Bitmap);
CvInvoke.BilateralFilter(resImage, img, 25, 75, 75);
CvInvoke.Blur(img, img, new Size(5, 5), new Point(0, 0));
}
var grayimage = new Image <Gray, byte>(bm);
CvInvoke.CvtColor(img, grayimage, ColorConversion.Bgr2Gray);
BlackBG(grayimage);
Console.WriteLine("Filtering done");
var cannyThreshold = GetKMeansThreshold(grayimage);
label2.Text = cannyThreshold.ToString();
Thresholding(grayimage, cannyThreshold);
Console.WriteLine("Canny threshold using KMEANS found " + cannyThreshold);
//Convert the image to grayscale and filter out the noise
var cannyEdges = new UMat();
Console.WriteLine("Canny threshold using KMEANS found " + cannyThreshold);
var uimage = new UMat();
CvInvoke.CvtColor(img, uimage, ColorConversion.Bgr2Gray);
CvInvoke.Canny(uimage, cannyEdges, cannyThreshold, cannyThreshold);
BlobCounter blobCounter = new BlobCounter( );
if (level == 1)
{
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 25;
blobCounter.MinWidth = 25;
blobCounter.ProcessImage(cannyEdges.Bitmap);
}
else
{
blobCounter.ProcessImage(grayimage.ToBitmap());
}
//blobCounter.ProcessImage(grayimage.ToBitmap());
Blob[] blobs = blobCounter.GetObjectsInformation( );
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
var triangleList = new List <Triangle2DF>();
var boxList = new List <RotatedRect>();
var circleList = new List <CircleF>();
Bitmap newBM = new Bitmap(img.Bitmap);
Graphics g = Graphics.FromImage(newBM);
Pen redPen = new Pen(Color.Red, 2);
Pen yellowPen = new Pen(Color.Yellow, 2);
Pen greenPen = new Pen(Color.Green, 2);
Pen bluePen = new Pen(Color.Blue, 2);
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, out center, out radius))
{
//g.DrawEllipse(bluePen,
// (float)(center.X - radius), (float)(center.Y - radius),
// (float)(radius * 2), (float)(radius * 2));
circleList.Add(new CircleF(new PointF(center.X, center.Y), radius));
}
else
{
List <IntPoint> corners;
if (edgePoints.Count > 1)
{
if (shapeChecker.IsQuadrilateral(edgePoints, out corners))
{
System.Console.WriteLine(corners.Count);
if (shapeChecker.CheckPolygonSubType(corners) ==
PolygonSubType.Square || shapeChecker.CheckPolygonSubType(corners) ==
PolygonSubType.Rectangle)
{
IntPoint minXY, maxXY;
PointsCloud.GetBoundingRectangle(corners, out minXY, out maxXY);
AForge.Point c = PointsCloud.GetCenterOfGravity(corners);
//g.DrawPolygon(greenPen, ToPointsArray(corners));
boxList.Add(new RotatedRect(new PointF(c.X, c.Y), new SizeF(maxXY.X - minXY.X, maxXY.Y - minXY.Y), 0));
}
}
else
{
corners = PointsCloud.FindQuadrilateralCorners(edgePoints);
if (corners.Count == 3)
{
Triangle2DF tri = new Triangle2DF(new PointF(corners[0].X, corners[0].Y), new PointF(corners[1].X, corners[1].Y), new PointF(corners[2].X, corners[2].Y));
triangleList.Add(tri);
//g.DrawPolygon(yellowPen, ToPointsArray(corners));
}
//g.DrawPolygon(redPen, ToPointsArray(corners));
}
}
}
}
Console.WriteLine("boxes " + boxList.Count);
Console.WriteLine("triangles " + triangleList.Count);
Console.WriteLine("circles " + circleList.Count);
redPen.Dispose();
greenPen.Dispose();
bluePen.Dispose();
yellowPen.Dispose();
//g.Dispose();
resPicBox.Image = newBM;
CircleF[] circles = circleList.ToArray();
var cList = circles.ToList();
FilterSame(boxList, triangleList, cList, img.Width * img.Height);
circles = cList.ToArray();
var points = new List <PointF>();
var Image = img.CopyBlank();
foreach (var triangle in triangleList)
{
Image.Draw(triangle, new Bgr(Color.Red), 3);
points.Add(triangle.Centeroid);
}
foreach (var box in boxList)
{
Image.Draw(box, new Bgr(Color.Blue), 3);
points.Add(box.Center);
}
foreach (var circle in circles)
{
Image.Draw(circle, new Bgr(Color.DarkCyan), 3);
points.Add(circle.Center);
}
var listPoints = SortPoints(points, img);
for (var i = 0; i < listPoints.Length; i++)
{
Console.WriteLine(listPoints[i].X.ToString() + " " + listPoints[i].Y.ToString());
}
System.Console.WriteLine("Points sorted, num of objects " + listPoints.Length.ToString());
resPicBox.Image = (Image + img).ToBitmap();
if (listPoints.Length > 3)
{
var bezSegList = InterpolatePointWithBeizerCurves(listPoints.ToList <PointF>());
var gr = Graphics.FromImage(resPicBox.Image);
var p = new Pen(Color.Red);
foreach (BeizerCurveSegment seg in bezSegList)
{
var bezierList = GetBez(new PointF[]
{ seg.StartPoint, seg.FirstControlPoint, seg.SecondControlPoint, seg.EndPoint });
for (var i = 0; i < bezierList.Length - 1; i++)
{
gr.DrawLine(p, bezierList[i], bezierList[i + 1]);
}
}
}
else
{
var gr = Graphics.FromImage(resPicBox.Image);
var p = new Pen(Color.Red);
for (var i = 0; i < listPoints.Length - 1; i++)
{
gr.DrawLine(p, listPoints[i], listPoints[i + 1]);
}
}
//var bezierList = GetBezierCurve1(listPoints);
}
public void processShapes()
{
//Working Variables
Pen fuschiaPen = new Pen(Color.Fuchsia, 3.0f);
Pen aquaPen = new Pen(Color.Aqua, 5.0f);
Pen redPen = new Pen(Color.Red, 3.0f);
Pen orangePen = new Pen(Color.Orange, 3.0f);
//Locking Image Bits
Bitmap workingFrame = edgeDetection();
System.Drawing.Imaging.BitmapData bmpData = workingFrame.LockBits(new Rectangle(0, 0, workingFrame.Width, workingFrame.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, workingFrame.PixelFormat);
//Turning the Background Black and getting rid of the green of the PCB
/*ColorFiltering colorFilter = new ColorFiltering();
* Threshold filter = new Threshold((int)hScrollBar1.Value);
*
* colorFilter.Red = new IntRange(0, hScrollBar1.Value);
* colorFilter.Blue = new IntRange(0, hScrollBar1.Value);
* colorFilter.Green = new IntRange(0, hScrollBar1.Value);
*/
// colorFilter.ApplyInPlace(bmpData);
workingFrame.UnlockBits(bmpData);
//Identifing the Blobs in target picture
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
//blobCounter.MinHeight = 5;
//blobCounter.MinWidth = 5;
blobCounter.MinHeight = hScrollBar2.Value;
blobCounter.MinWidth = hScrollBar2.Value;
blobCounter.ProcessImage(bmpData);
Blob[] blobs = blobCounter.GetObjectsInformation();
//scrollableImagePanel1.Image = (Bitmap)workingFrame.Clone();
//Classifying the objects{}
AForge.Math.Geometry.SimpleShapeChecker shapeCheck = new SimpleShapeChecker();
Bitmap tempBitmap = new Bitmap(workingFrame.Width, workingFrame.Height);
Graphics g = Graphics.FromImage(tempBitmap);
g.DrawImage(workingFrame, 0, 0);
if (caseValue == 1)
{
scrollableImagePanel1.Image = tempBitmap;
}
if (caseValue == 2)
{
scrollableImagePanel3.Image = tempBitmap;
}
if (caseValue == 3)
{
scrollableImagePanel2.Image = tempBitmap;
}
if (caseValue == 4)
{
scrollableImagePanel5.Image = tempBitmap;
}
if (caseValue == 5)
{
scrollableImagePanel4.Image = tempBitmap;
}
int blobLength = blobs.Length;
for (int i = 0; i < blobLength; i++)
{
List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
AForge.Point center;
float radius;
if (shapeCheck.IsCircle(edgePoints, out center, out radius))
{
float tempLocationX = (float)(center.X - radius);
float tempLocationY = (float)(center.Y - radius);
float diameter = radius * 2.0f;
g.DrawEllipse(fuschiaPen, tempLocationX, tempLocationY, diameter, diameter);
}
else
{
List <IntPoint> corners = PointsCloud.FindQuadrilateralCorners(edgePoints);
if (shapeCheck.IsQuadrilateral(edgePoints, out corners))
{
Rectangle testRectangle = new Rectangle(corners[0].X, corners[0].Y, (corners[1].X - corners[0].X), corners[3].Y - corners[0].Y);
g.DrawRectangle(redPen, testRectangle);
if (shapeCheck.CheckPolygonSubType(corners) == PolygonSubType.Rectangle)
{
g.DrawPolygon(aquaPen, ToPointsArray(corners));
}
else
{
g.DrawPolygon(orangePen, ToPointsArray(corners));
}
}
}
//redPen.Dispose();
//orangePen.Dispose();
//g.Dispose();
}
}
/// <summary>
/// Search for glyphs in the specified image and recognize them.
/// </summary>
///
/// <param name="image">Image to search glyphs in.</param>
///
/// <returns>Return a list of found glyphs.</returns>
///
/// <remarks><para>The method does processing of the specified image and searches for glyphs in it of
/// the specified <see cref="GlyphSize">size</see>. In the case if <see cref="GlyphDatabase">glyphs' database</see>
/// is set, it tries to find a matching glyph in it for each found glyph in the image. If matching is found,
/// then <see cref="ExtractedGlyphData.RecognizedGlyph">RecognizedGlyph</see> and
/// <see cref="ExtractedGlyphData.RecognizedQuadrilateral">RecognizedQuadrilateral</see>
/// properties of <see cref="ExtractedGlyphData"/> are set correspondingly.</para></remarks>
///
/// <exception cref="UnsupportedImageFormatException">Pixel format of the specified image is not supported.
/// It must be 8 bpp indexed or 24/32 bpp color image.</exception>
///
public List <ExtractedGlyphData> FindGlyphs(UnmanagedImage image)
{
List <ExtractedGlyphData> extractedGlyphs = new List <ExtractedGlyphData>( );
if ((image.PixelFormat != PixelFormat.Format8bppIndexed) &&
(!Grayscale.CommonAlgorithms.BT709.FormatTranslations.ContainsKey(image.PixelFormat)))
{
throw new UnsupportedImageFormatException("Pixel format of the specified image is not supported.");
}
// 1 - grayscaling
UnmanagedImage grayImage = null;
if (image.PixelFormat == PixelFormat.Format8bppIndexed)
{
grayImage = image;
}
else
{
grayImage = UnmanagedImage.Create(image.Width, image.Height, PixelFormat.Format8bppIndexed);
Grayscale.CommonAlgorithms.BT709.Apply(image, grayImage);
}
// 2 - Edge detection
UnmanagedImage edgesImage = edgeDetector.Apply(grayImage);
// 3 - Threshold edges
thresholdFilter.ApplyInPlace(edgesImage);
// 4 - Blob Counter
blobCounter.ProcessImage(edgesImage);
Blob[] blobs = blobCounter.GetObjectsInformation( );
// 5 - check each blob
for (int i = 0, n = blobs.Length; i < n; i++)
{
List <IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List <IntPoint> corners = null;
// does it look like a quadrilateral ?
if (shapeChecker.IsQuadrilateral(edgePoints, out corners))
{
// get edge points on the left and on the right side
List <IntPoint> leftEdgePoints, rightEdgePoints;
blobCounter.GetBlobsLeftAndRightEdges(blobs[i], out leftEdgePoints, out rightEdgePoints);
// calculate average difference between pixel values from outside of the shape and from inside
float diff = CalculateAverageEdgesBrightnessDifference(
leftEdgePoints, rightEdgePoints, grayImage);
// check average difference, which tells how much outside is lighter than inside on the average
if (diff > 20)
{
// perform glyph recognition
ExtractedGlyphData glyphData = RecognizeGlyph(grayImage, corners);
if (glyphData != null)
{
extractedGlyphs.Add(glyphData);
if (extractedGlyphs.Count >= maxNumberOfGlyphsToSearch)
{
break;
}
}
}
}
}
// dispose resources
if (image.PixelFormat != PixelFormat.Format8bppIndexed)
{
grayImage.Dispose( );
}
edgesImage.Dispose( );
return(extractedGlyphs);
}