private List<float> SearchCrossingEdges(DetectedVertices polygon, int y)
{
if (polygon == null)
throw new ArgumentNullException("polygon", "'polygon' can't be null.");
if (polygon.Count < 3)
throw new ArgumentException("'polygon.MainPolygon.Count' can't be less then 3.");
List<float> result = SearchCrossingEdges((Vertices)polygon, y);
if (polygon.Holes != null)
{
for (int i = 0; i < polygon.Holes.Count; i++)
{
result.AddRange(SearchCrossingEdges(polygon.Holes[i], y));
}
}
result.Sort();
return result;
}
private bool DistanceToHullAcceptable(DetectedVertices polygon, Vector2 point, bool higherDetail)
{
if (polygon == null)
throw new ArgumentNullException("polygon", "'polygon' can't be null.");
if (polygon.Count < 3)
throw new ArgumentException("'polygon.MainPolygon.Count' can't be less then 3.");
// Check the distance to main polygon.
if (DistanceToHullAcceptable((Vertices)polygon, point, higherDetail))
{
if (polygon.Holes != null)
{
for (int i = 0; i < polygon.Holes.Count; i++)
{
// If there is one distance not acceptable then return false.
if (!DistanceToHullAcceptable(polygon.Holes[i], point, higherDetail))
return false;
}
}
// All distances are larger then _hullTolerance.
return true;
}
// Default to false.
return false;
}
private bool InPolygon(DetectedVertices polygon, Vector2 point)
{
bool inPolygon = !DistanceToHullAcceptable(polygon, point, true);
if (!inPolygon)
{
List<float> xCoords = SearchCrossingEdges(polygon, (int)point.Y);
if (xCoords.Count > 0 && xCoords.Count % 2 == 0)
{
for (int i = 0; i < xCoords.Count; i += 2)
{
if (xCoords[i] <= point.X && xCoords[i + 1] >= point.X)
return true;
}
}
return false;
}
return true;
}
public List<DetectedVertices> DetectVertices()
{
#region Check TextureConverter setup.
if (_data == null)
throw new Exception(
"'_data' can't be null. You have to use SetTextureData(uint[] data, int width) before calling this method.");
if (_data.Length < 4)
throw new Exception(
"'_data' length can't be less then 4. Your texture must be at least 2 x 2 pixels in size. " +
"You have to use SetTextureData(uint[] data, int width) before calling this method.");
if (_width < 2)
throw new Exception(
"'_width' can't be less then 2. Your texture must be at least 2 x 2 pixels in size. " +
"You have to use SetTextureData(uint[] data, int width) before calling this method.");
if (_data.Length % _width != 0)
throw new Exception(
"'_width' has an invalid value. You have to use SetTextureData(uint[] data, int width) before calling this method.");
#endregion Check TextureConverter setup.
List<DetectedVertices> detectedPolygons = new List<DetectedVertices>();
DetectedVertices polygon;
Vertices holePolygon;
Vector2? holeEntrance = null;
Vector2? polygonEntrance = null;
List<Vector2> blackList = new List<Vector2>();
bool searchOn;
do
{
if (detectedPolygons.Count == 0)
{
// First pass / single polygon
polygon = new DetectedVertices(CreateSimplePolygon(Vector2.Zero, Vector2.Zero));
if (polygon.Count > 2)
polygonEntrance = GetTopMostVertex(polygon);
}
else if (polygonEntrance.HasValue)
{
// Multi pass / multiple polygons
polygon = new DetectedVertices(CreateSimplePolygon(
polygonEntrance.Value, new Vector2(polygonEntrance.Value.X - 1f, polygonEntrance.Value.Y)));
}
else
break;
searchOn = false;
if (polygon.Count > 2)
{
if (_holeDetection)
{
do
{
holeEntrance = SearchHoleEntrance(polygon, holeEntrance);
if (holeEntrance.HasValue)
{
if (!blackList.Contains(holeEntrance.Value))
{
blackList.Add(holeEntrance.Value);
holePolygon = CreateSimplePolygon(holeEntrance.Value,
new Vector2(holeEntrance.Value.X + 1, holeEntrance.Value.Y));
if (holePolygon != null && holePolygon.Count > 2)
{
switch (_polygonDetectionType)
{
case VerticesDetectionType.Integrated:
// Add first hole polygon vertex to close the hole polygon.
holePolygon.Add(holePolygon[0]);
int vertex1Index, vertex2Index;
if (SplitPolygonEdge(polygon, holeEntrance.Value, out vertex1Index, out vertex2Index))
polygon.InsertRange(vertex2Index, holePolygon);
break;
case VerticesDetectionType.Separated:
if (polygon.Holes == null)
polygon.Holes = new List<Vertices>();
polygon.Holes.Add(holePolygon);
break;
}
}
}
else
break;
}
else
break;
}
while (true);
}
detectedPolygons.Add(polygon);
}
if (_multipartDetection || polygon.Count <= 2)
{
if (SearchNextHullEntrance(detectedPolygons, polygonEntrance.Value, out polygonEntrance))
searchOn = true;
}
}
while (searchOn);
if (detectedPolygons == null || (detectedPolygons != null && detectedPolygons.Count == 0))
throw new Exception("Couldn't detect any vertices.");
// Post processing.
if (PolygonDetectionType == VerticesDetectionType.Separated) // Only when VerticesDetectionType.Separated? -> Recheck.
ApplyTriangulationCompatibleWinding(ref detectedPolygons);
if (_pixelOffsetOptimization)
ApplyPixelOffsetOptimization(ref detectedPolygons);
if (_transform != Matrix.Identity)
ApplyTransform(ref detectedPolygons);
return detectedPolygons;
}
