Shape optimizer, which removes obtuse angles (close to flat) from a shape.
This shape optimizing algorithm checks all adjacent edges of a shape and substitutes any 2 edges with a single edge if angle between them is greater than MaxAngleToKeep. The algorithm makes sure there are not obtuse angles in a shape, which are very close to flat line.
The shape optimizer does not optimize shapes to less than 3 points, so optimized shape always will have at least 3 points.
For example, the below circle shape comprised of 65 points, can be optimized to 10 points by setting MaxAngleToKeep to 160.
// ==========================================================================================================
// Components:
// ==========================================================================================================
private List<Shapes.Component> FindComponentsFunct(Bitmap bitmap)
{
// Locating objects
BlobCounter blobCounter = new BlobCounter();
blobCounter.FilterBlobs = true;
blobCounter.MinHeight = 8;
blobCounter.MinWidth = 8;
blobCounter.ProcessImage(bitmap);
Blob[] blobs = blobCounter.GetObjectsInformation();
// create convex hull searching algorithm
GrahamConvexHull hullFinder = new GrahamConvexHull();
ClosePointsMergingOptimizer optimizer1 = new ClosePointsMergingOptimizer();
FlatAnglesOptimizer optimizer2 = new FlatAnglesOptimizer();
List<Shapes.Component> Components = new List<Shapes.Component>();
// process each blob
foreach (Blob blob in blobs)
{
List<IntPoint> leftPoints, rightPoints, edgePoints = new List<IntPoint>();
if ((blob.Rectangle.Height > 400) && (blob.Rectangle.Width > 600))
{
break; // The whole image could be a blob, discard that
}
// get blob's edge points
blobCounter.GetBlobsLeftAndRightEdges(blob,
out leftPoints, out rightPoints);
edgePoints.AddRange(leftPoints);
edgePoints.AddRange(rightPoints);
// blob's convex hull
List<IntPoint> Outline = hullFinder.FindHull(edgePoints);
optimizer1.MaxDistanceToMerge = 4;
optimizer2.MaxAngleToKeep = 170F;
Outline = optimizer2.OptimizeShape(Outline);
Outline = optimizer1.OptimizeShape(Outline);
// find Longest line segment
float dist = 0;
LineSegment Longest = new LineSegment(Outline[0], Outline[1]);
LineSegment line;
dist = Longest.Length;
int LongestInd = 0;
for (int i = 1; i < Outline.Count; i++)
{
if (i != Outline.Count - 1)
{
line = new LineSegment(Outline[i], Outline[i + 1]);
}
else
{
// last iteration
if (Outline[i] == Outline[0])
{
break;
}
line = new LineSegment(Outline[i], Outline[0]);
}
if (line.Length > dist)
{
Longest = line;
dist = line.Length;
LongestInd = i;
}
}
// Get the center point of it
AForge.Point LongestCenter = new AForge.Point();
LongestCenter.X = (float)Math.Round((Longest.End.X - Longest.Start.X) / 2.0 + Longest.Start.X);
LongestCenter.Y = (float)Math.Round((Longest.End.Y - Longest.Start.Y) / 2.0 + Longest.Start.Y);
AForge.Point NormalStart = new AForge.Point();
AForge.Point NormalEnd = new AForge.Point();
// Find normal:
// start= longest.start rotated +90deg relative to center
// end= longest.end rotated -90deg and relative to center
// If you rotate point (px, py) around point (ox, oy) by angle theta you'll get:
// p'x = cos(theta) * (px-ox) - sin(theta) * (py-oy) + ox
// p'y = sin(theta) * (px-ox) + cos(theta) * (py-oy) + oy
// cos90 = 0, sin90= 1 =>
// p'x= -(py-oy) + ox= oy-py+ox, p'y= (px-ox)+ oy
NormalStart.X = LongestCenter.Y - Longest.Start.Y + LongestCenter.X;
NormalStart.Y = (Longest.Start.X - LongestCenter.X) + LongestCenter.Y;
// cos-90=0, sin-90= -1 =>
// p'x= (py-oy) + ox
// p'y= -(px-ox)+oy= ox-px+oy
NormalEnd.X = (Longest.Start.Y - LongestCenter.Y) + LongestCenter.X;
NormalEnd.Y = LongestCenter.X - Longest.Start.X + LongestCenter.Y;
// Make line out of the points
Line Normal = Line.FromPoints(NormalStart, NormalEnd);
// Find the furthest intersection to the normal (skip the Longest)
AForge.Point InterSection = new AForge.Point();
AForge.Point Furthest = new AForge.Point();
bool FurhtestAssinged = false;
LineSegment seg;
dist = 0;
for (int i = 0; i < Outline.Count; i++)
{
if (i == LongestInd)
{
continue;
}
if (i != Outline.Count - 1)
{
seg = new LineSegment(Outline[i], Outline[i + 1]);
}
else
{
// last iteration
if (Outline[i] == Outline[0])
{
break;
}
seg = new LineSegment(Outline[i], Outline[0]);
}
if (seg.GetIntersectionWith(Normal) == null)
{
continue;
}
InterSection = (AForge.Point)seg.GetIntersectionWith(Normal);
if (InterSection.DistanceTo(LongestCenter) > dist)
{
Furthest = InterSection;
FurhtestAssinged = true;
dist = InterSection.DistanceTo(LongestCenter);
}
}
// Check, if there is a edge point that is close to the normal even further
AForge.Point fPoint = new AForge.Point();
for (int i = 0; i < Outline.Count; i++)
{
fPoint.X = Outline[i].X;
fPoint.Y = Outline[i].Y;
if (Normal.DistanceToPoint(fPoint) < 1.5)
{
if (fPoint.DistanceTo(LongestCenter) > dist)
{
Furthest = fPoint;
FurhtestAssinged = true;
dist = fPoint.DistanceTo(LongestCenter);
}
}
}
AForge.Point ComponentCenter = new AForge.Point();
if (FurhtestAssinged)
{
// Find the midpoint of LongestCenter and Furthest: This is the centerpoint of component
ComponentCenter.X = (float)Math.Round((LongestCenter.X - Furthest.X) / 2.0 + Furthest.X);
ComponentCenter.Y = (float)Math.Round((LongestCenter.Y - Furthest.Y) / 2.0 + Furthest.Y);
// Alignment is the angle of longest
double Alignment;
if (Math.Abs(Longest.End.X - Longest.Start.X) < 0.001)
{
Alignment = 0;
}
else
{
Alignment = Math.Atan((Longest.End.Y - Longest.Start.Y) / (Longest.End.X - Longest.Start.X));
Alignment = Alignment * 180.0 / Math.PI; // in deg.
}
Components.Add(new Shapes.Component(ComponentCenter, Alignment, Outline, Longest, NormalStart, NormalEnd));
}
}
return Components;
}
public List<Object> findObjects(VideoReader videoReader, IDepthReader depthReader, Action<ushort[], CameraSpacePoint[]> mappingFunction, IProgress<int> progress)
{
var shapeOptimizer = new FlatAnglesOptimizer(160);
Console.WriteLine("Find glyph box");
List<Object> objects = new List<Object>();
if (videoReader == null)
return objects;
/// For each frame (int frameNo)
/// For each recognized glyph in frame (int faceIndex)
/// Store A tuple of
/// - A list of bounding points for recognized glyph
/// - A glyphface instance
var recognizedGlyphs = new Dictionary<int, Dictionary<int, Dictionary<int, Tuple<List<System.Drawing.PointF>, GlyphFace, List<Point3>>>>>();
Bitmap image = null;
Mat m = null;
Bitmap grayImage = null;
Bitmap edges = null;
UnmanagedImage grayUI = null;
Bitmap transformed = null;
Bitmap transformedOtsu = null;
//A control flag, true if at the previous frame loop, there is detection of some glyph
// When this is true, only searching for glyph box in some neighborhood of the previous glyphs
// if the frame is not an anchor frame
bool previousFrameDetection = false;
for (int frameNo = 0; frameNo < videoReader.frameCount; frameNo++)
//for (int frameNo = 80; frameNo < 81; frameNo++)
{
if (progress != null)
progress.Report(frameNo);
Console.WriteLine("=============================================");
Console.WriteLine("Frame no " + frameNo);
m = videoReader.getFrame(frameNo);
if (m == null)
{
break;
}
var startPos = new System.Drawing.Point();
getImageForProcessing(recognizedGlyphs, m, previousFrameDetection, frameNo, ref image, ref startPos);
// Reset right after using
previousFrameDetection = false;
Stopwatch stopwatch = Stopwatch.StartNew();
/// Adapt from Glyph Recognition Prototyping
/// Copyright © Andrew Kirillov, 2009-2010
///
// 1 - Grayscale
grayImage = Grayscale.CommonAlgorithms.BT709.Apply(image);
stopwatch.Stop();
Console.WriteLine("Gray scale time = " + stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
// 2 - Edge detection
DifferenceEdgeDetector edgeDetector = new DifferenceEdgeDetector();
edges = edgeDetector.Apply(grayImage);
stopwatch.Stop();
Console.WriteLine("Edge detection time = " + stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
// 3 - Threshold edges
// Was set to 20 and the number of detected glyphs are too low
// Should be set higher
Threshold thresholdFilter = new Threshold(60);
thresholdFilter.ApplyInPlace(edges);
stopwatch.Stop();
Console.WriteLine("Threshold time = " + stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
// 4 - Blob Counter
BlobCounter blobCounter = new BlobCounter();
blobCounter.MinHeight = 32;
blobCounter.MinWidth = 32;
blobCounter.FilterBlobs = true;
blobCounter.ObjectsOrder = ObjectsOrder.Size;
blobCounter.ProcessImage(edges);
Blob[] blobs = blobCounter.GetObjectsInformation();
stopwatch.Stop();
Console.WriteLine("Blob finding time = " + stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
//// create unmanaged copy of source image, so we could draw on it
//UnmanagedImage imageData = UnmanagedImage.FromManagedImage(image);
// Get unmanaged copy of grayscale image, so we could access it's pixel values
grayUI = UnmanagedImage.FromManagedImage(grayImage);
// list of found dark/black quadrilaterals surrounded by white area
List<List<IntPoint>> foundObjects = new List<List<IntPoint>>();
// shape checker for checking quadrilaterals
SimpleShapeChecker shapeChecker = new SimpleShapeChecker();
Console.WriteLine("edgePoints");
// 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))
{
// do some more checks to filter so unacceptable shapes
// if ( CheckIfShapeIsAcceptable( 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 = this.CalculateAverageEdgesBrightnessDifference(
leftEdgePoints, rightEdgePoints, grayUI);
// check average difference, which tells how much outside is lighter than inside on the average
if (diff > 20)
{
//Drawing.Polygon(imageData, corners, Color.FromArgb(255, 255, 0, 0));
// add the object to the list of interesting objects for further processing
foundObjects.Add(corners);
}
}
}
}
stopwatch.Stop();
Console.WriteLine("Finding black quadiralateral surrounded by white area = " + stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
int recordedTimeForRgbFrame = (int)(videoReader.totalMiliTime * frameNo / (videoReader.frameCount - 1));
CameraSpacePoint[] csps = new CameraSpacePoint[videoReader.frameWidth * videoReader.frameHeight];
if (depthReader != null)
{
ushort[] depthValues = depthReader.readFrameAtTime(recordedTimeForRgbFrame);
mappingFunction(depthValues, csps);
}
stopwatch.Stop();
Console.WriteLine("Mapping into 3 dimensional = " + stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
// further processing of each potential glyph
foreach (List<IntPoint> corners in foundObjects)
{
Console.WriteLine("found some corner");
// 6 - do quadrilateral transformation
QuadrilateralTransformation quadrilateralTransformation =
new QuadrilateralTransformation(corners, 20 * (glyphSize + 2), 20 * (glyphSize + 2));
transformed = quadrilateralTransformation.Apply(grayImage);
// 7 - otsu thresholding
OtsuThreshold otsuThresholdFilter = new OtsuThreshold();
transformedOtsu = otsuThresholdFilter.Apply(transformed);
// +2 for offset
int glyphSizeWithBoundary = glyphSize + 2;
SquareBinaryGlyphRecognizer gr = new SquareBinaryGlyphRecognizer(glyphSizeWithBoundary);
bool[,] glyphValues = gr.Recognize(ref transformedOtsu,
new Rectangle(0, 0, 20 * (glyphSize + 2), 20 * (glyphSize + 2)));
bool[,] resizedGlyphValues = new bool[glyphSize, glyphSize];
for (int i = 0; i < glyphSize; i++)
for (int j = 0; j < glyphSize; j++)
{
resizedGlyphValues[i, j] = glyphValues[i + 1, j + 1];
}
GlyphFace face = new GlyphFace(resizedGlyphValues, glyphSize);
Console.WriteLine("Find glyph face " + face.ToString());
// Transfer back to original coordinates
List<IntPoint> originalCorners = new List<IntPoint>();
foreach (var corner in corners)
{
IntPoint p = new IntPoint(corner.X + startPos.X, corner.Y + startPos.Y);
originalCorners.Add(p);
}
Console.WriteLine("Corner points");
foreach (var corner in originalCorners)
{
Console.WriteLine(corner);
}
for (int boxPrototypeIndex = 0; boxPrototypeIndex < boxPrototypes.Count; boxPrototypeIndex++)
{
var boxPrototype = boxPrototypes[boxPrototypeIndex];
foreach (int faceIndex in boxPrototype.indexToGlyphFaces.Keys)
{
if (face.Equals(boxPrototype.indexToGlyphFaces[faceIndex]))
{
if (!recognizedGlyphs.ContainsKey(boxPrototypeIndex))
{
Console.WriteLine("Detect new type of prototype " + boxPrototypeIndex);
recognizedGlyphs[boxPrototypeIndex] = new Dictionary<int, Dictionary<int, Tuple<List<System.Drawing.PointF>, GlyphFace, List<Point3>>>>();
}
if (!recognizedGlyphs[boxPrototypeIndex].ContainsKey(frameNo))
{
Console.WriteLine("Detect glyph at frame " + frameNo + " for prototype " + boxPrototypeIndex);
if (!previousFrameDetection)
{
previousFrameDetection = true;
}
recognizedGlyphs[boxPrototypeIndex][frameNo] = new Dictionary<int, Tuple<List<System.Drawing.PointF>, GlyphFace, List<Point3>>>();
}
recognizedGlyphs[boxPrototypeIndex][frameNo][faceIndex] = new Tuple<List<System.Drawing.PointF>, GlyphFace, List<Point3>>(
originalCorners.Select(p => new System.Drawing.PointF(p.X, p.Y)).ToList(),
face,
depthReader != null ?
originalCorners.Select(p => p.X + p.Y * videoReader.frameWidth >= 0 && p.X + p.Y * videoReader.frameWidth < videoReader.frameWidth * videoReader.frameHeight ?
new Point3(csps[p.X + p.Y * videoReader.frameWidth].X,
csps[p.X + p.Y * videoReader.frameWidth].Y,
csps[p.X + p.Y * videoReader.frameWidth].Z) : new Point3()).ToList() :
new List<Point3>()
);
break;
}
}
}
}
foreach (IDisposable o in new IDisposable[] { image, m, grayImage, edges, grayUI, transformed, transformedOtsu })
{
if (o != null)
{
o.Dispose();
}
}
stopwatch.Stop();
Console.WriteLine("Transforming and detect glyph = " + stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
}
if (progress != null)
progress.Report(videoReader.frameCount);
if (recognizedGlyphs.Keys.Count != 0)
{
foreach (int boxPrototypeIndex in recognizedGlyphs.Keys)
{
Console.WriteLine("For boxPrototypeIndex = " + boxPrototypeIndex + " Found glyph box at " + recognizedGlyphs[boxPrototypeIndex].Keys.Count + " frames");
GlyphBoxObject oneBox = null;
var boxPrototype = boxPrototypes[boxPrototypeIndex];
oneBox = new GlyphBoxObject(currentSession, "", Color.Black, 1, videoReader.fileName);
oneBox.boxPrototype = boxPrototype;
foreach (int frameNo in recognizedGlyphs[boxPrototypeIndex].Keys)
{
var glyphs = recognizedGlyphs[boxPrototypeIndex][frameNo];
var glyphBounds = new List<List<System.Drawing.PointF>>();
var glyph3DBounds = new List<List<Point3>>();
var faces = new List<GlyphFace>();
foreach (var glyph in glyphs)
{
glyphBounds.Add(glyph.Value.Item1);
faces.Add(glyph.Value.Item2);
glyph3DBounds.Add(glyph.Value.Item3);
}
oneBox.setBounding(frameNo, glyphSize, glyphBounds, faces);
oneBox.set3DBounding(frameNo, glyphSize, glyph3DBounds, faces);
//Point3 center = new Point3();
//Quaternions quaternions = new Quaternions();
//oneBox.set3DBounding(frameNo, new CubeLocationMark(frameNo, center, quaternions));
}
objects.Add(oneBox);
}
}
return objects;
}
