|
public CheckPolygonSubType ( List |
||
| corners | List |
Corners of the convex polygon to check. |
| return | PolygonSubType | |
public static void Rectangle(WriteableBitmap bitmap, DrawingContext dc)
{
// locating objects
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MaxHeight = 375;
blobCounter.MaxWidth = 375;
System.Drawing.Bitmap image;
using (var stream = new MemoryStream())
{
var encoder = new JpegBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(bitmap));
encoder.Save(stream);
image = new System.Drawing.Bitmap(stream);
}
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));
}
var path = new PathFigure(new System.Windows.Point(Points.First().X, Points.First().Y), Points.Select(row => new System.Windows.Media.LineSegment(new System.Windows.Point(row.X, row.Y), false)), true);
dc.DrawGeometry(Brushes.Red, null, new PathGeometry(new PathFigure[] { path }));
}
}
}
}
private Bitmap ProcessImage(Bitmap bitmap)
{
///CROP SYSTEM
//if (cropx1 != 0 && cropy1 != 0 && cropx2 != 0 && cropy2 != 0 && Worker.selected_square != 0)
//{
// Crop crop_filter = new Crop(new Rectangle(cropx1, cropy1, cropx2, cropy2));
// bitmap= crop_filter.Apply(bitmap);
// Console.WriteLine(">Crop Cutter:> Cropped\n({0},{1}),({2},{3})", cropx1, cropy1, cropx2, cropy2);
//}
//if (Worker.selected_square == 0)
//{
// Crop crop_filter = new Crop(new Rectangle(0, 0, bitmap.Width,bitmap.Height));
// bitmap = crop_filter.Apply(bitmap);
// //Console.WriteLine(">Crop Cutter:> RESET");
//}
//// step 2 - locating objects
if (cropx1 == 0 && cropy1 == 0 && cropx2 == 0 && cropy2 == 0)
{
cropx1 = 0;
cropy1 = 0;
cropx2 = bitmap.Width;
cropy2 = bitmap.Height;
}
Bitmap old = bitmap;
Crop crop_filter = new Crop(new Rectangle(cropx1, cropy1, cropx2, cropy2));
bitmap = crop_filter.Apply(bitmap);
// lock image
BitmapData bitmapData = bitmap.LockBits(
new Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.ReadWrite, bitmap.PixelFormat);
// ////invert
// Invert inv = new Invert();
// // //apply the filter
//inv.ApplyInPlace(bitmapData);
//// create filter
//HSLFiltering filter = new HSLFiltering();
//// set color ranges to keep
//filter.Hue = new IntRange(90, 300);
//filter.Saturation = new Range(0.0f, .5f);
//filter.Luminance = new Range(0f, 1);
//// apply the filter
//filter.ApplyInPlace(bitmapData);
//EuclideanColorFiltering filter = new EuclideanColorFiltering();
//// set center colol and radius
//filter.CenterColor = new RGB(209, 206, 196);
//filter.Radius = 150;
//// apply the filter
//filter.ApplyInPlace(bitmapData);
//// create filter
ChannelFiltering filter = new ChannelFiltering();
//// set channels' ranges to keep
Invert inv = new Invert();
//// //apply the filter
inv.ApplyInPlace(bitmapData);
if (red_max > 255)
{
red_max = 255;
Console.WriteLine("1THRESHOLD OVERIDE");
}
if (blue_max > 255)
{
blue_max = 255;
Console.WriteLine("2THRESHOLD OVERIDE");
}
if (green_max > 255)
{
green_max = 255;
Console.WriteLine("3THRESHOLD OVERIDE");
}
if (red > 255)
{
red = 254;
Console.WriteLine("4THRESHOLD OVERIDE");
}
if (blue > 255)
{
blue = 254;
Console.WriteLine("5THRESHOLD OVERIDE");
}
if (green > 255)
{
green = 254;
Console.WriteLine("6THRESHOLD OVERIDE");
}
if (red < 0)
{
red = 1;
Console.WriteLine("7THRESHOLD UNDERIDE");
}
if (blue < 0)
{
blue = 1;
Console.WriteLine("8THRESHOLD UNDERIDE");
}
if (green < 0)
{
green = 1;
Console.WriteLine("9THRESHOLD UNDERIDE");
}
if (red_max < 0)
{
red_max = 255;
Console.WriteLine("10THRESHOLD UNDERIDE");
}
if (blue_max < 0)
{
blue_max = 255;
Console.WriteLine("11THRESHOLD UNDERIDE");
}
if (green_max < 0)
{
green_max = 255;
Console.WriteLine("13THRESHOLD UNDERIDE");
}
if (red_max < red)
{
Console.WriteLine("14THRESHOLD UNION ERROR");
red = 0;
red_max = 255;
}
if (blue_max < blue)
{
blue = 0;
Console.WriteLine("15THRESHOLD UNION ERROR");
blue_max = 255;
}
if (green_max < green)
{
green = 0;
green_max = 255;
Console.WriteLine("16THRESHOLD UNION ERROR");
}
file.WriteLine("R: " + red + " R_M: " + red_max);
file.WriteLine("G: " + green + " G_M: " + green_max);
file.WriteLine("B: " + blue + " B_M: " + blue_max);
file.WriteLine("EOE");
//file.Close();
filter.Red = new IntRange(red, red_max);
filter.Green = new IntRange(green, green_max);
filter.Blue = new IntRange(blue, blue_max);
//// apply the filter
filter.ApplyInPlace(bitmapData);
////invert
//edge
//CannyEdgeDetector edge_filter = new CannyEdgeDetector();
//// apply the filter
//edge_filter.ApplyInPlace(bitmapData);
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = blob_size * 3;
blobCounter.MinWidth = blob_size * 4;
blobCounter.ProcessImage(bitmapData);
Blob[] 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); // circles
Pen redPen = new Pen(Color.Red, 2); // quadrilateral
Pen brownPen = new Pen(Color.Brown, 2); // quadrilateral with known sub-type
Pen greenPen = new Pen(Color.Green, 2); // known triangle
Pen bluePen = new Pen(Color.Blue, 2); // triangle
double curdist = 0;
double leastdist = 100;
//List<IntPoint> bestcorn;//promoted to super
for (int i = 0, n = blobs.Length; i < n; i++)
{
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List<IntPoint> corners; // the list of x,y coordinates. corners(list)->corner(intpoint)->[x,y]
// is triangle or quadrilateral
if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
{
cornide = corners;
// get sub-type
PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
Pen pen;
if (subType == PolygonSubType.Rectangle || subType == PolygonSubType.Trapezoid || subType == PolygonSubType.Parallelogram || subType == PolygonSubType.Rhombus || subType == PolygonSubType.Square || subType == PolygonSubType.Unknown)
{
if (corners.Count == 4)
{
pen = redPen;
IntPoint[] array_of_corners = corners.ToArray();//array_of_corners is now an array of corners
if (((732 / avdisty(array_of_corners)) + .222) < ((989 / avdistx(array_of_corners)) + 3.37))
{
curdist = ((732 / avdisty(array_of_corners)) + .222);//from our graph
}
else
{
curdist = ((989 / avdistx(array_of_corners)) + 3.37);//from our graph
}
//if (Worker.selected_square == 1)
//{
// Console.WriteLine("called\n");
// IntPoint one = array_of_corners[0];
// IntPoint two = array_of_corners[3];
// cropx1 = one.X - 5;
// cropy1 = one.Y - 5;
// cropx2 = two.X + 5;
// cropy2 = two.Y + 5;
//}
//else if (i == Worker.selected_square - 1 && Worker.selected_square != 1)
//{
// Console.WriteLine("called\n");
// IntPoint one = array_of_corners[0];
// IntPoint two = array_of_corners[3];
// cropx1 = one.X - 5;
// cropy1 = one.Y - 5;
// cropx2 = two.X + 5;
// cropy2 = two.Y + 5;
//}
//if (Worker.selected_square == 0)
//{
// cropx1 = 0;
// cropy1 = 0;
// cropx2 = 0;
// cropy2 = 0;
//}
if (Worker.selected_square == 0)//PREDATOR VISION
{
if (curdist < leastdist)
{
// Console.WriteLine((abs(array_of_corners[0].Y - array_of_corners[1].Y)) / (abs(array_of_corners[0].X - array_of_corners[1].X)));
//if ((abs(array_of_corners[0].Y - array_of_corners[3].Y)) / (abs(array_of_corners[0].X - array_of_corners[1].X)) < 1.25 && (abs(array_of_corners[0].Y - array_of_corners[3].Y)) / (abs(array_of_corners[0].X - array_of_corners[1].X)) > .5)
if (true)
{
leastdist = curdist;
if (leastdist < 55 && leastdist > 2)
{
double angle = (array_of_corners[0].X + array_of_corners[3].X) / 2;
Console.WriteLine("0: " + array_of_corners[0].X + " 1: " + array_of_corners[1].X + " 2: " + array_of_corners[2].X + " 3: " + array_of_corners[3].X);
Server.SetData(((array_of_corners[0].X + array_of_corners[1].X) / 2), 1);
Console.WriteLine("PREDATOR: " + Server.GetData(1));
Console.WriteLine(leastdist);
Server.SetData(leastdist, 0);
bestcorn = corners;//superify?
//g.DrawPolygon(pen, ToPointsArray(bestcorn));//leave here as a comment
IntPoint ones = array_of_corners[0];
PointF string_draw = new PointF(ones.X, ones.Y);
SolidBrush tbrush = new SolidBrush(Color.Red);
try
{
if (string_draw.X != 0 && string_draw.Y != 0)
{
g.DrawString(n.ToString(), this.Font, tbrush, string_draw);
}
}
catch (Exception e)
{
Console.WriteLine("{0} in {1} ({2},{3})", e.Message, e.StackTrace, string_draw.X, string_draw.Y);
}
}
}
}
try
{
Graphics global_graphics_predator = Graphics.FromImage(bitmap);
Pen penc = new Pen(Color.YellowGreen, 2);
//g.DrawPolygon(penc, ToPointsArray(bestcorn));
global_graphics_predator.DrawPolygon(penc, ToPointsArray(bestcorn));
global_graphics_predator.DrawLine(penc, new System.Drawing.Point(320, 1), new System.Drawing.Point(320, 479));
//bitmap = global_bitmap;
}
catch (Exception e)
{
}
yellowPen.Dispose();
redPen.Dispose();
greenPen.Dispose();
bluePen.Dispose();
brownPen.Dispose();
g.Dispose();
return bitmap;
}
else
{
int sel_least_dist = Worker.selected_square;
sel_least_dist *= 3;//threefeet
sel_least_dist -= 1;
int sel_max_dist = sel_least_dist + 5;
Console.WriteLine(sel_least_dist);
Console.WriteLine(sel_max_dist);
//Console.WriteLine(sel_least_dist + " " + sel_max_dist);
if (curdist < leastdist && curdist > sel_least_dist && curdist < sel_max_dist)
{
// Console.WriteLine((abs(array_of_corners[0].Y - array_of_corners[1].Y)) / (abs(array_of_corners[0].X - array_of_corners[1].X)));
//if ((abs(array_of_corners[0].Y - array_of_corners[3].Y)) / (abs(array_of_corners[0].X - array_of_corners[1].X)) < 1.25 && (abs(array_of_corners[0].Y - array_of_corners[3].Y)) / (abs(array_of_corners[0].X - array_of_corners[1].X)) > .5)
if (true)//todo
{
leastdist = curdist;
if (leastdist < 55 && leastdist > 2)
{
// Console.WriteLine("0: " + array_of_corners[0].X + " 1: " + array_of_corners[1].X + " 2: " + array_of_corners[2].X + " 3: " + array_of_corners[3].X);
Server.SetData(((array_of_corners[0].X + array_of_corners[1].X) / 2), 1);
Console.WriteLine(Server.GetData(1));
//Console.WriteLine(leastdist);
Server.SetData(leastdist, 0);
bestcorn = corners;//superify?
//g.DrawPolygon(pen, ToPointsArray(bestcorn));//leave here as a comment
IntPoint ones = array_of_corners[0];
PointF string_draw = new PointF(ones.X, ones.Y);
SolidBrush tbrush = new SolidBrush(Color.Red);
try
{
if (string_draw.X != 0 && string_draw.Y != 0)
{
g.DrawString(n.ToString(), this.Font, tbrush, string_draw);
// glob.DrawLine(penc, new System.Drawing.Point(10, 10), new System.Drawing.Point(20, 20));
//g.DrawLine(pen, new System.Drawing.Point(10, 10), new System.Drawing.Point(20, 20));
}
}
catch (Exception e)
{
Console.WriteLine("{0} in {1} ({2},{3})", e.Message, e.StackTrace, string_draw.X, string_draw.Y);
}
}
}
}
}
//pen = (corners.Count == 4) ? redPen : bluePen;
}//TODO get rid of anything that ISNT drawn, eg corner
}
//else
//{
// pen = (corners.Count == 4) ? brownPen : greenPen;
//}
}
}
//Console.WriteLine(leastdist); how dod oyo
//double leastdist = 0;
//for (int i = 0, n = blobs.Length; i < n; i++)
//{
// try
// {
// List<IntPoint> filterlist;
// filterlist = cornide;
// IntPoint[] filter_corners = filterlist.ToArray();
// double currentdist = 0;
// for (int corner_count = 0; corner_count < filter_corners.Length; corner_count++)
// {
// IntPoint one_f = filter_corners[corner_count];
// corner_count++;
// IntPoint two_f = filter_corners[corner_count];
// corner_count++;
// IntPoint three_f = filter_corners[corner_count];
// corner_count++;
// IntPoint four_f = filter_corners[corner_count];
// double y_average_a = ((double)one_f.Y + (double)two_f.Y) / 2;
// double y_average_b = ((double)three_f.Y + (double)four_f.Y) / 2;
// double averaged_dist = y_average_b - y_average_a;
// currentdist = ((732 / averaged_dist) + .222);//from our graph
// if (currentdist <= leastdist)
// {
// leastdist = currentdist;
// Pen pencil = redPen;
// g.DrawPolygon(pencil, ToPointsArray(filterlist));
// }
// }
// }
// catch
// {
// //do nothING
// }
//}
//Console.WriteLine(leastdist);
try
{
Graphics global_graphics = Graphics.FromImage(global_bitmap);
Pen penc = new Pen(Color.YellowGreen, 2);
{
//g.DrawPolygon(penc, ToPointsArray(bestcorn));
global_graphics.DrawPolygon(penc, ToPointsArray(bestcorn));
global_graphics.DrawLine(penc, new System.Drawing.Point(320, 1), new System.Drawing.Point(320, 479));
bitmap = global_bitmap;
}
}
catch (Exception e)
{
}
try
{
g.DrawLine(redPen, 220, 1, 220, 100);
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.InnerException);
}
yellowPen.Dispose();
redPen.Dispose();
greenPen.Dispose();
bluePen.Dispose();
brownPen.Dispose();
g.Dispose();
return bitmap;
}
// Process image
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( 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 = 5;
blobCounter.MinWidth = 5;
blobCounter.ProcessImage( bitmapData );
Blob[] 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 ); // circles
Pen redPen = new Pen( Color.Red, 2 ); // quadrilateral
Pen brownPen = new Pen( Color.Brown, 2 ); // quadrilateral with known sub-type
Pen greenPen = new Pen( Color.Green, 2 ); // known triangle
Pen bluePen = new Pen( Color.Blue, 2 ); // triangle
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 ) )
{
g.DrawEllipse( yellowPen,
(float) ( center.X - radius ), (float) ( center.Y - radius ),
(float) ( radius * 2 ), (float) ( radius * 2 ) );
}
else
{
List<IntPoint> corners;
// is triangle or quadrilateral
if ( shapeChecker.IsConvexPolygon( edgePoints, out corners ) )
{
// get sub-type
PolygonSubType subType = shapeChecker.CheckPolygonSubType( corners );
Pen pen;
if ( subType == PolygonSubType.Unknown )
{
pen = ( corners.Count == 4 ) ? redPen : bluePen;
}
else
{
pen = ( corners.Count == 4 ) ? brownPen : greenPen;
}
g.DrawPolygon( pen, ToPointsArray( corners ) );
}
}
}
yellowPen.Dispose( );
redPen.Dispose( );
greenPen.Dispose( );
bluePen.Dispose( );
brownPen.Dispose( );
g.Dispose( );
// put new image to clipboard
Clipboard.SetDataObject( bitmap );
// and to picture box
pictureBox.Image = bitmap;
UpdatePictureBoxPosition( );
}
private void detectQuads(Bitmap bitmap)
{
// Greyscale
filteredBitmap = Grayscale.CommonAlgorithms.BT709.Apply(bitmap);
// edge filter
SobelEdgeDetector edgeFilter = new SobelEdgeDetector();
edgeFilter.ApplyInPlace(filteredBitmap);
// Threshhold filter
Threshold threshholdFilter = new Threshold(190);
threshholdFilter.ApplyInPlace(filteredBitmap);
BitmapData bitmapData = filteredBitmap.LockBits(
new Rectangle(0, 0, filteredBitmap.Width, filteredBitmap.Height),
ImageLockMode.ReadWrite, filteredBitmap.PixelFormat);
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 125;
blobCounter.MinWidth = 125;
blobCounter.ProcessImage(bitmapData);
Blob[] blobs = blobCounter.GetObjectsInformation();
filteredBitmap.UnlockBits(bitmapData);
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
Bitmap bm = new Bitmap(filteredBitmap.Width, filteredBitmap.Height, PixelFormat.Format24bppRgb);
Graphics g = Graphics.FromImage(bm);
g.DrawImage(filteredBitmap, 0, 0);
Pen pen = new Pen(Color.Red, 5);
List<IntPoint> cardPositions = new List<IntPoint>();
// Loop through detected shapes
for (int i = 0, n = blobs.Length; i < n; i++)
{
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List<IntPoint> corners;
bool sameCard = false;
// is triangle or quadrilateral
if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
{
// get sub-type
PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
// Only return 4 corner rectanges
if ((subType == PolygonSubType.Parallelogram || subType == PolygonSubType.Rectangle) && corners.Count == 4)
{
// Check if its sideways, if so rearrange the corners so it's veritcal
rearrangeCorners(corners);
// Prevent it from detecting the same card twice
foreach (IntPoint point in cardPositions)
{
if (corners[0].DistanceTo(point) < 40)
sameCard = true;
}
if (sameCard)
continue;
// Hack to prevent it from detecting smaller sections of the card instead of the whole card
if (GetArea(corners) < 20000)
continue;
cardPositions.Add(corners[0]);
g.DrawPolygon(pen, ToPointsArray(corners));
// Extract the card bitmap
QuadrilateralTransformation transformFilter = new QuadrilateralTransformation(corners, 211, 298);
cardBitmap = transformFilter.Apply(cameraBitmap);
List<IntPoint> artCorners = new List<IntPoint>();
artCorners.Add(new IntPoint(14, 35));
artCorners.Add(new IntPoint(193, 35));
artCorners.Add(new IntPoint(193, 168));
artCorners.Add(new IntPoint(14, 168));
// Extract the art bitmap
QuadrilateralTransformation cartArtFilter = new QuadrilateralTransformation(artCorners, 183, 133);
cardArtBitmap = cartArtFilter.Apply(cardBitmap);
MagicCard card = new MagicCard();
card.corners = corners;
card.cardBitmap = cardBitmap;
card.cardArtBitmap = cardArtBitmap;
magicCards.Add(card);
}
}
}
pen.Dispose();
g.Dispose();
filteredBitmap = bm;
}
// todo: implement this
//public IBlobsFilter BlobsFilter
/// <summary>
/// uses AForge to detect square (or rectangular, if tile is obscured) tiles in the image
/// </summary>
/// <param name="img"></param>
public void DetectBlobsInImage(Bitmap img)
{
BlobCounter blobCounter = new BlobCounter();
blobCounter.ProcessImage(img);
Blob[] blobs = blobCounter.GetObjectsInformation();
Graphics g = Graphics.FromImage(img);
System.Drawing.Pen bluePen = new System.Drawing.Pen(System.Drawing.Color.Blue, 10);
for (int i = 0, n = blobs.Length; i < n; i++)
{
try
{
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List<IntPoint> corners = PointsCloud.FindQuadrilateralCorners(edgePoints);
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
if (subType == PolygonSubType.Square)
{
g.DrawPolygon(bluePen, PointsListToArray(corners));
}
}
catch (Exception) { }
}
bluePen.Dispose();
g.Dispose();
}
public void DetectQuads()
{
// Greyscale
FilteredBitmap = Grayscale.CommonAlgorithms.BT709.Apply(CameraBitmap);
// edge filter
var edgeFilter = new SobelEdgeDetector();
edgeFilter.ApplyInPlace(FilteredBitmap);
// Threshhold filter
var threshholdFilter = new Threshold(190);
threshholdFilter.ApplyInPlace(FilteredBitmap);
var bitmapData = FilteredBitmap.LockBits(
new Rectangle(0, 0, FilteredBitmap.Width, FilteredBitmap.Height),
ImageLockMode.ReadWrite, FilteredBitmap.PixelFormat);
var blobCounter = new BlobCounter
{
FilterBlobs = true,
MinHeight = 125,
MinWidth = 125
};
blobCounter.ProcessImage(bitmapData);
var blobs = blobCounter.GetObjectsInformation();
FilteredBitmap.UnlockBits(bitmapData);
var shapeChecker = new SimpleShapeChecker();
var bm = new Bitmap(FilteredBitmap.Width, FilteredBitmap.Height, PixelFormat.Format24bppRgb);
var g = Graphics.FromImage(bm);
g.DrawImage(FilteredBitmap, 0, 0);
var pen = new Pen((Color)new ColorConverter().ConvertFromString(Application.Current.Resources["AccentColor"].ToString()), 5);
var cardPositions = new List<IntPoint>();
// Loop through detected shapes
for (int i = 0, n = blobs.Length; i < n; i++)
{
var edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List<IntPoint> corners;
var sameCard = false;
// is triangle or quadrilateral
if (shapeChecker.IsQuadrilateral(edgePoints, out corners))
{
if (!corners.Any())
return;
// get sub-type
var subType = shapeChecker.CheckPolygonSubType(corners);
// Only return 4 corner rectanges
if ((subType != PolygonSubType.Parallelogram && subType != PolygonSubType.Rectangle) || corners.Count != 4)
continue;
// Check if its sideways, if so rearrange the corners so it's veritcal
RearrangeCorners(corners);
// Prevent it from detecting the same card twice
foreach (var point in cardPositions)
{
var distance = corners[0].DistanceTo(point);
if (corners[0].DistanceTo(point) < 40)
sameCard = true;
}
if (sameCard)
continue;
// Hack to prevent it from detecting smaller sections of the card instead of the whole card
var area = GetArea(corners);
if (area < 20000)// || area > 35000)
continue;
cardPositions.Add(corners[0]);
g.DrawPolygon(pen, ToPointsArray(corners));
// Extract the card bitmap
var transformFilter = new QuadrilateralTransformation(corners, 225, 325);
CardBitmap = transformFilter.Apply(CameraBitmap);
TmpCard = new MagicCard
{
Corners = corners,
CardBitmap = CardBitmap
};
}
}
pen.Dispose();
g.Dispose();
FilteredBitmap = bm;
}
public Bitmap Detect(Bitmap bitmap)
{
Bitmap grayscaleBitmap = Grayscale.CommonAlgorithms.BT709.Apply(bitmap);
IFilter smoothingFilter = null;
switch (_smoothMode)
{
case "None": smoothingFilter = null; break;
case "Mean": smoothingFilter = new Mean(); break;
case "Median": smoothingFilter = new Median(); break;
case "Conservative": smoothingFilter = new ConservativeSmoothing(); break;
case "Adaptive": smoothingFilter = new AdaptiveSmoothing(); break;
case "Bilateral": smoothingFilter = new BilateralSmoothing(); break;
}
Bitmap smoothBitmap = smoothingFilter != null ? smoothingFilter.Apply(grayscaleBitmap) : grayscaleBitmap;
IFilter edgeFilter = null;
switch (_edgeMode)
{
case "Homogenity": edgeFilter = new HomogenityEdgeDetector(); break;
case "Difference": edgeFilter = new DifferenceEdgeDetector(); break;
case "Sobel": edgeFilter = new SobelEdgeDetector(); break;
case "Canny": edgeFilter = new CannyEdgeDetector(); break;
}
Bitmap edgeBitmap = edgeFilter != null ? edgeFilter.Apply(smoothBitmap) : smoothBitmap;
IFilter threshholdFilter = new Threshold(_threshold);
Bitmap thresholdBitmap = _threshold == 0 ? edgeBitmap : threshholdFilter.Apply(edgeBitmap);
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = _minHeight;
blobCounter.MinWidth = _minWidth;
blobCounter.ProcessImage(thresholdBitmap);
Blob[] blobs = blobCounter.GetObjectsInformation();
Bitmap outputBitmap = new Bitmap(thresholdBitmap.Width, thresholdBitmap.Height, PixelFormat.Format24bppRgb);
Graphics bitmapGraphics = Graphics.FromImage(outputBitmap);
Bitmap inputBitmap = null;
switch (_drawMode)
{
case "Original": inputBitmap = bitmap; break;
case "Grayscale": inputBitmap = grayscaleBitmap; break;
case "Smooth": inputBitmap = smoothBitmap; break;
case "Edge": inputBitmap = edgeBitmap; break;
case "Threshold": inputBitmap = thresholdBitmap; break;
}
if (inputBitmap != null)
bitmapGraphics.DrawImage(inputBitmap, 0, 0);
Pen nonConvexPen = new Pen(Color.Red, 2);
Pen nonRectPen = new Pen(Color.Orange, 2);
Pen cardPen = new Pen(Color.Blue, 2);
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
List<IntPoint> cardPositions = new List<IntPoint>();
for (int i = 0; i < blobs.Length; i++)
{
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List<IntPoint> corners;
if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
{
PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
if ((subType == PolygonSubType.Parallelogram || subType == PolygonSubType.Rectangle) && corners.Count == 4)
{
// Check if its sideways, if so rearrange the corners so it's vertical.
RearrangeCorners(corners);
// Prevent detecting the same card twice by comparing distance against other detected cards.
bool sameCard = false;
foreach (IntPoint point in cardPositions)
{
if (corners[0].DistanceTo(point) < _minDistance)
{
sameCard = true;
break;
}
}
if (sameCard)
continue;
// Hack to prevent it from detecting smaller sections of the card instead of the whole card.
if (GetArea(corners) < _minArea)
continue;
cardPositions.Add(corners[0]);
bitmapGraphics.DrawPolygon(cardPen, ToPointsArray(corners));
}
else
{
foreach (IntPoint point in edgePoints.Take(300))
{
bitmapGraphics.DrawEllipse(nonRectPen, point.X, point.Y, 1, 1);
}
}
}
else
{
foreach (IntPoint point in edgePoints.Take(300))
{
bitmapGraphics.DrawEllipse(nonConvexPen, point.X, point.Y, 1, 1);
}
}
}
bitmapGraphics.Dispose();
nonConvexPen.Dispose();
nonRectPen.Dispose();
cardPen.Dispose();
return outputBitmap;
}
// =========================================================
private Bitmap DrawRectanglesFunct(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);
}
// Summary - Gets the exterior rectangles.
/***************
* It uses a different JPEG altogether due to bpp issue (only 24 or 32 is acceptable).
* Selects the rectangles on the basis of area (around 350 to 400).
* Sends the quadrilaterals (4 of them) with their 4 coordinates (each) to DecideCorners for trimming.
*/
public void PreProcess()
{
Bitmap bitmap = this.scanned_image;
List<List<IntPoint>> QuadCorners = new List<List<IntPoint>>(4);
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(0, 64);
colorFilter.Green = new IntRange(0, 64);
colorFilter.Blue = new IntRange(0, 64);
colorFilter.FillOutsideRange = false;
//MessageBox.Show(bitmapData.PixelFormat.ToString());
colorFilter.ApplyInPlace(bitmapData);
// step 2 - locating objects
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 5;
blobCounter.MinWidth = 5;
blobCounter.ProcessImage(bitmapData);
Blob[] blobs = blobCounter.GetObjectsInformation();
bitmap.UnlockBits(bitmapData);
// step 3 - check objects' type and highlight
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
//int count = 0;
Pen redPen = new Pen(Color.Red, 2);
Graphics g = Graphics.FromImage(bitmap);
// Threshold area values for rectangles. It doesnt have a specific equation for the value based on threshold.
// Values have been tested and set accordingly.
int area_upper = 0, area_lower = 0;
if (Scanner_DPI.dpi_value == 200)
{
area_lower = 2000;
area_upper = 3000;
}
else if (Scanner_DPI.dpi_value == 300)
{
area_lower = 5000;
area_upper = 6000;
}
for (int i = 0, n = blobs.Length; i < n; i++)
{
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List<IntPoint> corners;
// is quadrilateral
if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
{
// get sub-type
PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
if (subType == PolygonSubType.Rectangle && blobs[i].Area > area_lower && blobs[i].Area < area_upper)
{
//g.DrawPolygon(redPen, ToPointsArray(corners));
QuadCorners.Add(corners);
}
}
}
this.scanned_image = DecideCorners(QuadCorners);
}
private void Button_Click_1(object sender, RoutedEventArgs e)
{
// Open your image
string path = file.FullName;
Bitmap image = (Bitmap)Bitmap.FromFile(path);
// locating objects
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 1;
blobCounter.MinWidth = 1;
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<System.Drawing.Point> Points = new List<System.Drawing.Point>();
bool flag = false;
foreach (var point in cornerPoints)
{
if (point.X == 0 && point.Y == 0)
flag = true;
Points.Add(new System.Drawing.Point(point.X, point.Y));
}
if (flag)
continue;
Graphics g = Graphics.FromImage(image);
g.DrawPolygon(new Pen(Color.Red, 5.0f), Points.ToArray());
_rect++;
image.Save("result.png");
}
}
else if (shapeChecker.IsTriangle(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));
}
Graphics g = Graphics.FromImage(image);
g.DrawPolygon(new Pen(Color.Red, 5.0f), Points.ToArray());
_tri++;
image.Save("result.png");
}
}
BitmapImage bi = new BitmapImage();
bi.BeginInit();
bi.UriSource = new Uri(file.Directory + @"\result.png");
bi.EndInit();
IMG_AFTER.Source = bi;
TB_OUT.Text = "На картинке " + _rect-- + " прямоугольника \r\nИ " + _tri + " треугольника";
}
//returns corners of found rectangle
public List<IntPoint> getCorners(Bitmap toEdit)
{
Bitmap bitmap = new Bitmap(toEdit);
List<IntPoint> corners = new List<IntPoint>();
List<IntPoint> oneBlob = new List<IntPoint>();
// lock image
BitmapData bitmapData = bitmap.LockBits(
new Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.ReadWrite, bitmap.PixelFormat);
//black background
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);
//locate figurres
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 8;
blobCounter.MinWidth = 8;
blobCounter.ProcessImage(bitmapData);
Blob[] blobs = blobCounter.GetObjectsInformation();
bitmap.UnlockBits(bitmapData);
//check object type
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
Graphics g = Graphics.FromImage(bitmap);
for (int i = 0, n = blobs.Length; i < n; i++)
{
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
// check if trainge of rectangle
if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
{
// get subtype (is rectangle?)
PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
if (subType == PolygonSubType.Rectangle)
{
for (int j = 0; j < 4; j++)
{
for (int k = 0; k < 3; k++)
{
IntPoint temp = new IntPoint();
if (j < 3)
{
if (corners[k].Y > corners[k + 1].Y)
{
temp = corners[k];
corners[k] = corners[k + 1];
corners[k + 1] = temp;
}
}
}
}
//sort list of corners
if (corners[0].X > corners[1].X)
{
IntPoint temp = new IntPoint();
temp = corners[0];
corners[0] = corners[1];
corners[1] = temp;
}
if (corners[3].X > corners[2].X)
{
IntPoint temp = new IntPoint();
temp = corners[2];
corners[2] = corners[3];
corners[3] = temp;
}
int blobHeigth = Math.Abs(corners[3].Y - corners[0].Y);
int blobWidth = Math.Abs(corners[1].X - corners[0].X);
if (blobHeigth < blobWidth)
{
// float ratio = blobWidth / blobHeigth;
// if(ratio > 1)
oneBlob = corners;
}
}
}
}
g.Dispose();
// put new image to clipboard
Clipboard.SetDataObject(bitmap);
// and to picture box
// pictureBox.Image = bitmap;
return oneBlob;
// UpdatePictureBoxPosition();
}
// Process image
public Bitmap ProcessImage(Bitmap toEdit)
{
Bitmap bitmap = new Bitmap(toEdit);
List<IntPoint> corners = new List<IntPoint>();
// lock image
BitmapData bitmapData = bitmap.LockBits(
new Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.ReadWrite, bitmap.PixelFormat);
//black background
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);
//locating figures
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 5;
blobCounter.MinWidth = 5;
blobCounter.ProcessImage(bitmapData);
Blob[] blobs = blobCounter.GetObjectsInformation();
bitmap.UnlockBits(bitmapData);
//check type of figure
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
Graphics g = Graphics.FromImage(bitmap);
Pen redPen = new Pen(Color.Red, 2); // pen to colour egdes
for (int i = 0, n = blobs.Length; i < n; i++)
{
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
// is triangle or rectangle
if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
{
// get subtype (is rectangle?)
PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
Pen pen;
/*
if (subType == PolygonSubType.Unknown)
{
pen = (corners.Count == 4) ? redPen : bluePen;
}
else
{
pen = (corners.Count == 4) ? brownPen : greenPen;
}
*/
if (subType == PolygonSubType.Rectangle)
{
int blobHeigth = Math.Abs(corners[3].Y - corners[0].Y);
int blobWidth = Math.Abs(corners[1].X - corners[0].X);
if (blobHeigth < blobWidth)
{
pen = redPen;
g.DrawPolygon(pen, ToPointsArray(corners));
}
}
}
}
redPen.Dispose();
g.Dispose();
Clipboard.SetDataObject(bitmap);
// and to picture box
// pictureBox.Image = bitmap;
return bitmap;
// UpdatePictureBoxPosition();
}
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]++;
}
}
public List<string> DetectLicensePlate(Bitmap bitmap)
{
Bitmap original = (Bitmap)bitmap.Clone();
// threshold obrazku - s timto lze experimentovat a zlepsit detekci znacek v nekterych obraycich
bitmap = Grayscale.CommonAlgorithms.BT709.Apply(bitmap);
OtsuThreshold threshold = new OtsuThreshold();
bitmap = threshold.Apply(bitmap);
BitmapData bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadWrite, bitmap.PixelFormat);
// vyhledani objektu
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 10;
blobCounter.MinWidth = 60;
blobCounter.ProcessImage(bitmapData);
Blob[] blobs = blobCounter.GetObjectsInformation();
bitmap.UnlockBits(bitmapData);
// detekce objektu a jeho tvaru
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
//shapeChecker.AngleError = 15;
//shapeChecker.MinAcceptableDistortion = 1;
//shapeChecker.RelativeDistortionLimit = 0.05f;
List<string> results = new List<string>();
int a = 0;
string text;
for (int i = 0, n = blobs.Length; i < n; i++)
{
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List<IntPoint> corners;
if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
{
// zjisteni typu (obdelnik, ...)
PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
if (corners.Count() == 4)
{
Bitmap rectangle = this.Transform(corners, original);
text = this.Detect(rectangle);
if (text.Length > 6)
{
results.Add(text);
rectangle.Save("temp/" + text + ".jpg");
}
}
}
}
return results;
}
public bool markKnownForms()
{
if (currentImage != null)
{
try
{
Bitmap image = new Bitmap(this.currentImage);
// lock image
BitmapData bmData = image.LockBits(
new Rectangle(0, 0, image.Width, image.Height),
ImageLockMode.ReadWrite, image.PixelFormat);
// turn background to black
ColorFiltering cFilter = new ColorFiltering();
cFilter.Red = new IntRange(0, 64);
cFilter.Green = new IntRange(0, 64);
cFilter.Blue = new IntRange(0, 64);
cFilter.FillOutsideRange = false;
cFilter.ApplyInPlace(bmData);
// locate objects
BlobCounter bCounter = new BlobCounter();
bCounter.FilterBlobs = true;
bCounter.MinHeight = 20;
bCounter.MinWidth = 20;
bCounter.ProcessImage(bmData);
Blob[] baBlobs = bCounter.GetObjectsInformation();
image.UnlockBits(bmData);
// coloring objects
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
Graphics g = Graphics.FromImage(image);
Pen yellowPen = new Pen(Color.Yellow, 2); // circles
Pen redPen = new Pen(Color.Red, 2); // quadrilateral
Pen brownPen = new Pen(Color.Brown, 2); // quadrilateral with known sub-type
Pen greenPen = new Pen(Color.Green, 2); // known triangle
Pen bluePen = new Pen(Color.Blue, 2); // triangle
for (int i = 0, n = baBlobs.Length; i < n; i++)
{
List<IntPoint> edgePoints = bCounter.GetBlobsEdgePoints(baBlobs[i]);
AForge.Point center;
float radius;
// is circle ?
if (shapeChecker.IsCircle(edgePoints, out center, out radius))
{
g.DrawEllipse(yellowPen,
(float)(center.X - radius), (float)(center.Y - radius),
(float)(radius * 2), (float)(radius * 2));
}
else
{
List<IntPoint> corners;
// is triangle or quadrilateral
if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
{
PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
Pen pen;
if (subType == PolygonSubType.Unknown)
{
pen = (corners.Count == 4) ? redPen : bluePen;
}
else
{
pen = (corners.Count == 4) ? brownPen : greenPen;
}
g.DrawPolygon(pen, ToPointsArray(corners));
}
}
}
yellowPen.Dispose();
redPen.Dispose();
greenPen.Dispose();
bluePen.Dispose();
brownPen.Dispose();
g.Dispose();
this.currentImage = image;
return true;
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
}
}
return false;
}
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;
}
public Form1()
{
InitializeComponent();
Bitmap image = new Bitmap(@"C:\Images\bitmap.bmp");
Invert filter = new Invert();
// apply the filter
filter.ApplyInPlace(image);
var shapeChecker = new SimpleShapeChecker();
BlobCounter blobCounter = new BlobCounter();
// process input image
blobCounter.ProcessImage(image);
// get information about detected objects
Blob[] blobs = blobCounter.GetObjectsInformation();
var squares = 0;
Graphics g = Graphics.FromImage(image);
Pen bluePen = new Pen(Color.Yellow, 2);
Pen redpen = new Pen(Color.Red, 2);
var quads = blobs.Where(x => shapeChecker.IsQuadrilateral(blobCounter.GetBlobsEdgePoints(x)));
var largest = quads.OrderByDescending(x => x.Area).First();
List<IntPoint> largestedgePoints = blobCounter.GetBlobsEdgePoints(largest);
List<IntPoint> largestcorners;
shapeChecker.IsQuadrilateral(largestedgePoints, out largestcorners);
var largestpoints = largestcorners.Select(x => new PointF(x.X, x.Y)).ToArray();
//g.DrawPolygon(redpen, largestpoints);
for (int i = 0, n = blobs.Length; i < n; i++)
{
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List<IntPoint> corners;
Point center;
float radius;
if(blobs[i].Area < 150)
continue;
if (shapeChecker.IsQuadrilateral(edgePoints, out corners))
{
var a = corners.Select(x => new IntPoint(x.X, x.Y)).ToList();
var shape = shapeChecker.CheckPolygonSubType(a);
if (shape == PolygonSubType.Square || shape == PolygonSubType.Rectangle)
{
if (corners.Min(x => x.Y) < largestcorners.Min(x => x.Y) ||
corners.Min(x => x.Y) > largestcorners.Max(x => x.Y))
{
var points = corners.Select(x => new PointF(x.X, x.Y)).ToArray();
g.DrawPolygon(bluePen, points);
}
}
}
else if (shapeChecker.IsCircle(edgePoints, out center, out radius))
{
//g.DrawEllipse(bluePen,
// (int)(center.X - radius),
// (int)(center.Y - radius),
// (int)(radius * 2),
// (int)(radius * 2));
}
}
pictureBox1.Image = image;
bluePen.Dispose();
g.Dispose();
}
public static IEnumerable<MagicCard> DetectCardArt(Bitmap cameraBitmap)
{
var ret = new List<MagicCard>();
var filteredBitmap = Grayscale.CommonAlgorithms.BT709.Apply(cameraBitmap);
// edge filter
var edgeFilter = new SobelEdgeDetector();
edgeFilter.ApplyInPlace(filteredBitmap);
// Threshhold filter
var threshholdFilter = new Threshold(190);
threshholdFilter.ApplyInPlace(filteredBitmap);
var bitmapData = filteredBitmap.LockBits(
new Rectangle(0, 0, filteredBitmap.Width, filteredBitmap.Height),
ImageLockMode.ReadWrite, filteredBitmap.PixelFormat);
var blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 125;
blobCounter.MinWidth = 125;
blobCounter.ProcessImage(bitmapData);
var blobs = blobCounter.GetObjectsInformation();
filteredBitmap.UnlockBits(bitmapData);
var shapeChecker = new SimpleShapeChecker();
var bm = new Bitmap(filteredBitmap.Width, filteredBitmap.Height, PixelFormat.Format24bppRgb);
var cardPositions = new List<IntPoint>();
foreach (var blob in blobs)
{
var edgePoints = blobCounter.GetBlobsEdgePoints(blob);
List<IntPoint> corners;
// only operate on 4 sided polygons
if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
{
var subtype = shapeChecker.CheckPolygonSubType(corners);
if (corners.Count() != 4)
continue;
if (subtype != PolygonSubType.Parallelogram && subtype != PolygonSubType.Rectangle)
continue;
// if the image is sideways, rotate it so it'll match the DB card art
corners = Utilities.RotateCorners(corners).ToList();
if (Utilities.GetArea(corners) < 20000)
continue;
ret.Add( new MagicCard(cameraBitmap, corners));
}
}
return ret;
}
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(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 = 5;
blobCounter.MinWidth = 5;
blobCounter.ProcessImage(bitmapData);
Blob[] blobs = blobCounter.GetObjectsInformation();
bitmap.UnlockBits(bitmapData);
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
Graphics g = Graphics.FromImage(bitmap);
Pen brownPen = new Pen(Color.Red, 3);
for (int i = 0, n = blobs.Length; i < n; i++)
{
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
List<IntPoint> corners;
if (shapeChecker.IsConvexPolygon(edgePoints, out corners))
{
PolygonSubType subType = shapeChecker.CheckPolygonSubType(corners);
if (subType == PolygonSubType.Unknown)
{
if (corners.Count == 4)
{
g.DrawPolygon(brownPen, ToPointsArray(corners));
}
}
else
{
if (corners.Count == 4)
{
g.DrawPolygon(brownPen, ToPointsArray(corners));
}
}
}
}
brownPen.Dispose();
g.Dispose();
Clipboard.SetDataObject(bitmap);
pictureBox5.Image = bitmap;
}
