|
public IsCircle ( List |
||
| edgePoints | List |
Shape's points to check. |
| return | bool | |
// 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( );
}
// ==========================================================================================================
// Circles:
// ==========================================================================================================
private List<Shapes.Circle> FindCirclesFunct(Bitmap bitmap)
{
// locating objects
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 5;
blobCounter.MinWidth = 5;
blobCounter.ProcessImage(bitmap);
Blob[] blobs = blobCounter.GetObjectsInformation();
List<Shapes.Circle> Circles = new List<Shapes.Circle>();
for (int i = 0, n = blobs.Length; i < n; i++)
{
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blobs[i]);
AForge.Point center;
float radius;
// is circle ?
if (shapeChecker.IsCircle(edgePoints, out center, out radius))
{
if (radius > 3) // MirrFilter out some noise
{
Circles.Add(new Shapes.Circle(center.X, center.Y, radius));
}
}
}
return (Circles);
}
public ActionResult Index(string Data, int Smallest = 3, int Largest = 6, HttpPostedFileBase file = null)
{
string base64Image = null;
if (file != null)
{
//try to determine data from posted file
var bitmap = new Bitmap(file.InputStream);
// lock image
BitmapData bitmapData = bitmap.LockBits(
new Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
// step 1 - turn background to black
var filter = new Invert();
filter.ApplyInPlace(bitmapData);
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);
var blobs = blobCounter.GetObjectsInformation();
bitmap.UnlockBits(bitmapData);
base64Image = bitmap.ToBase64();
// get information about detected objects
var shapeChecker = new SimpleShapeChecker();
var letters = new List<Letter>();
int circleCount = 0;
foreach (
var blob in
blobs.ToArray()
.OrderBy(b => b.Rectangle.Top)
.ThenBy(b => b.Rectangle.Left)
.ThenByDescending(b => b.Area))
{
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blob);
AForge.Point center;
float radius;
if (shapeChecker.IsCircle(edgePoints, out center, out radius))
{
//Todo: filter on the largest radius * 90% to deal with resolutions
if (radius < 40)
continue;
blobCounter.ExtractBlobsImage(bitmap, blob, false);
var letter = blob.Image.ToManagedImage(true);
var resizeFilter = new ResizeBilinear(150, 150);
letter = resizeFilter.Apply(letter);
var bwBitmap = new Bitmap(75, 75, PixelFormat.Format32bppArgb);
for (int y = 40; y < 115; y++)
{
for (int x = 40; x < 115; x++)
{
var color = letter.GetPixel(x, y);
if (color.Name == "ff000000")
{
bwBitmap.SetPixel(x - 40, y - 40, Color.Black);
}
else
{
bwBitmap.SetPixel(x - 40, y - 40, Color.White);
}
}
}
letters.Add(new Letter
{
L = TrainingData.GetBestGuess(bwBitmap),
X = center.X,
Y = center.Y,
Radius = radius
});
}
}
var minX = letters.Min(c => c.X);
var maxX = letters.Max(c => c.X);
var minY = letters.Min(c => c.Y);
var maxY = letters.Max(c => c.Y);
var smallestRadius = letters.Min(c => c.Radius);
var numberOfItemsPerRow = (int)((maxX - minX)/ smallestRadius / 2);
var numberOfItemsPerCol = (int)((maxY - minY) / smallestRadius / 2);
var spaceBetweenPointsX = (maxX - minX)/numberOfItemsPerRow;
var spaceBetweenPointsY = (maxY - minY) / numberOfItemsPerCol;
var varianceDelta = smallestRadius*.05f; //allow 5% pixel float
var puzzle = new StringBuilder();
for (var y = minY; y <= maxY; y += spaceBetweenPointsY)
{
for (var x = minX; x <= maxX; x += spaceBetweenPointsX)
{
var item = letters.FirstOrDefault(c => c.X > x - varianceDelta && c.X < x + varianceDelta
&& c.Y > y - varianceDelta && c.Y < y + varianceDelta);
if (item != null)
puzzle.Append(item.L);
else
puzzle.Append("_");
}
puzzle.AppendLine();
}
Data = puzzle.ToString();
}
var solutions = SolvePuzzle(Data, Smallest, Largest);
return View(new PuzzleModel
{
Data = Data,
Largest = Largest,
Smallest = Smallest,
Solutions = solutions,
Base64Image = base64Image
});
}
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 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;
}
public void blob_detect ()
{
Bitmap image = this.scanned_image;
BlobCounter blob = new BlobCounter();
blob.FilterBlobs = false;
int blob_ht_width = 30;
blob.MinHeight = blob_ht_width;
blob.MinWidth = blob_ht_width;
blob.ProcessImage(image);
Blob[] b = blob.GetObjectsInformation();
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
/*blob_counter.Text = b.Length.ToString();
Graphics g = Graphics.FromImage(image2);
Pen yellowPen = new Pen(Color.Yellow, 5);
Pen redPen = new Pen(Color.Red, 5);
Pen greenPen = new Pen(Color.Green, 5);
int b_counter = 0;
*/
for (int i = 0, n = b.Length; i < n; i++)
{
List<IntPoint> edgePoints = blob.GetBlobsEdgePoints(b[i]);
List<IntPoint> edges = new List<IntPoint>();
AForge.Point center;
float radius;
if (shapeChecker.IsCircle(edgePoints, out center, out radius))
{
if (b[i].Fullness * 100 >= 40 && b[i].Fullness * 100 < 100 && radius > 10)
{
Coordinate coor = new Coordinate(center.X, center.Y);
BLOB blb = new BLOB(coor, radius);
useful.Add(blb);
}
}
}
}
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 ActionResult Process(HttpPostedFileBase file)
{
var model = new List<TrainingDataItem>();
var bitmap = new Bitmap(file.InputStream);
// lock image
BitmapData bitmapData = bitmap.LockBits(
new Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
// step 1 - turn background to black
var filter = new Invert();
filter.ApplyInPlace(bitmapData);
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);
var blobs = blobCounter.GetObjectsInformation();
bitmap.UnlockBits(bitmapData);
// get information about detected objects
var shapeChecker = new SimpleShapeChecker();
int circleCount = 0;
foreach (
var blob in
blobs.ToArray()
.OrderBy(b => b.Rectangle.Top)
.ThenBy(b => b.Rectangle.Left)
.ThenByDescending(b => b.Area))
{
List<IntPoint> edgePoints = blobCounter.GetBlobsEdgePoints(blob);
AForge.Point center;
float radius;
if (shapeChecker.IsCircle(edgePoints, out center, out radius))
{
//Todo: filter on the largest radius * 90% to deal with resolutions
if (radius < 40)
continue;
blobCounter.ExtractBlobsImage(bitmap, blob, false);
var letter = blob.Image.ToManagedImage(true);
var resizeFilter = new ResizeBilinear(150, 150);
letter = resizeFilter.Apply(letter);
var base64 = (letter.ToBase64());
var sb = new StringBuilder();
var bwBitmap = new Bitmap(75, 75, PixelFormat.Format32bppArgb);
for (int y = 40; y < 115; y++)
{
for (int x = 40; x < 115; x++)
{
var color = letter.GetPixel(x, y);
if (color.Name == "ff000000")
{
sb.Append("0");
bwBitmap.SetPixel(x - 40, y - 40, Color.Black);
}
else
{
sb.Append("1");
bwBitmap.SetPixel(x - 40, y - 40, Color.White);
}
}
sb.AppendLine();
}
model.Add(new TrainingDataItem
{
Base64Image = (bwBitmap.ToBase64()),
Letter = TrainingData.GetBestGuess(bwBitmap)
});
}
}
return View(model.ToArray());
}
// Process specified image trying to recognize counter's image
public void Process( Bitmap image, IImageProcessingLog log )
{
log.AddMessage( "Image size: " + image.Width + " x " + image.Height );
// 1- grayscale image
Bitmap grayImage = Grayscale.CommonAlgorithms.BT709.Apply( image );
log.AddImage( "Grayscale", grayImage );
// 2 - Otsu thresholding
OtsuThreshold threshold = new OtsuThreshold( );
Bitmap binaryImage = threshold.Apply( grayImage );
log.AddImage( "Binary", binaryImage );
log.AddMessage( "Otsu threshold: " + threshold.ThresholdValue );
// 3 - Blob counting
BlobCounter blobCounter = new BlobCounter( );
blobCounter.FilterBlobs = true;
blobCounter.MinWidth = 24;
blobCounter.MinWidth = 24;
blobCounter.ProcessImage( binaryImage );
Blob[] blobs = blobCounter.GetObjectsInformation( );
log.AddMessage( "Found blobs (min width/height = 24): " + blobs.Length );
// 4 - check shape of each blob
SimpleShapeChecker shapeChecker = new SimpleShapeChecker( );
log.AddMessage( "Found coins: " );
int count = 0;
// create graphics object for drawing on image
Graphics g = Graphics.FromImage( image );
Pen pen = new Pen( Color.Red, 3 );
foreach ( Blob blob in blobs )
{
List<IntPoint> edgePoint = blobCounter.GetBlobsEdgePoints( blob );
// check if shape looks like a circle
DoublePoint center;
double radius;
if ( shapeChecker.IsCircle( edgePoint, out center, out radius ) )
{
count++;
log.AddMessage( string.Format( " {0}: center = ({1}, {2}), radius = {3}",
count, center.X, center.Y, radius ) );
// highlight coin
g.DrawEllipse( pen, (int) ( center.X - radius ), (int) ( center.Y - radius ),
(int) ( radius * 2 ), (int) ( radius * 2 ) );
}
}
g.Dispose( );
pen.Dispose( );
log.AddMessage( "Total coins: " + count);
log.AddImage( "Coins", image );
}
