private bool SearchForOutstandingVertex(Vertices hullArea, out Vector2 outstanding)
{
Vector2 outstandingResult = Vector2.Zero;
bool found = false;
if (hullArea.Count > 2)
{
int hullAreaLastPoint = hullArea.Count - 1;
Vector2 tempVector1;
Vector2 tempVector2 = hullArea[0];
Vector2 tempVector3 = hullArea[hullAreaLastPoint];
// Search between the first and last hull point.
for (int i = 1; i < hullAreaLastPoint; i++)
{
tempVector1 = hullArea[i];
// Check if the distance is over the one that's tolerable.
if (LineUtils.DistanceBetweenPointAndLineSegment(ref tempVector1, ref tempVector2, ref tempVector3) >= _hullTolerance)
{
outstandingResult = hullArea[i];
found = true;
break;
}
}
}
outstanding = outstandingResult;
return(found);
}
private bool DistanceToHullAcceptable(Vertices polygon, Vector2 point, bool higherDetail)
{
if (polygon == null)
{
throw new ArgumentNullException(nameof(polygon), "'polygon' can't be null.");
}
if (polygon.Count < 3)
{
throw new ArgumentException("'polygon.Count' can't be less then 3.");
}
var edgeVertex2 = polygon[polygon.Count - 1];
Vector2 edgeVertex1;
if (higherDetail)
{
for (var i = 0; i < polygon.Count; i++)
{
edgeVertex1 = polygon[i];
if (LineUtils.DistanceBetweenPointAndLineSegment(ref point, ref edgeVertex1, ref edgeVertex2) <=
_hullTolerance || Vector2.Distance(point, edgeVertex1) <= _hullTolerance)
{
return(false);
}
edgeVertex2 = polygon[i];
}
return(true);
}
else
{
for (var i = 0; i < polygon.Count; i++)
{
edgeVertex1 = polygon[i];
if (LineUtils.DistanceBetweenPointAndLineSegment(ref point, ref edgeVertex1, ref edgeVertex2) <=
_hullTolerance)
{
return(false);
}
edgeVertex2 = polygon[i];
}
return(true);
}
}
private static void SimplifySection(Vertices vertices, int i, int j, bool[] usePoint, float distanceTolerance)
{
if ((i + 1) == j)
{
return;
}
Vector2 a = vertices[i];
Vector2 b = vertices[j];
double maxDistance = -1.0;
int maxIndex = i;
for (int k = i + 1; k < j; k++)
{
Vector2 point = vertices[k];
double distance = LineUtils.DistanceBetweenPointAndLineSegment(ref point, ref a, ref b);
if (distance > maxDistance)
{
maxDistance = distance;
maxIndex = k;
}
}
if (maxDistance <= distanceTolerance)
{
for (int k = i + 1; k < j; k++)
{
usePoint[k] = false;
}
}
else
{
SimplifySection(vertices, i, maxIndex, usePoint, distanceTolerance);
SimplifySection(vertices, maxIndex, j, usePoint, distanceTolerance);
}
}
private static void SimplifySection(Vertices vertices, int i, int j, bool[] usePoint, float distanceTolerance)
{
if (i + 1 == j)
{
return;
}
var a = vertices[i];
var b = vertices[j];
var maxDistance = -1.0f;
var maxIndex = i;
for (var k = i + 1; k < j; k++)
{
var point = vertices[k];
var distance = LineUtils.DistanceBetweenPointAndLineSegment(ref point, ref a, ref b);
if (distance > maxDistance)
{
maxDistance = distance;
maxIndex = k;
}
}
if (maxDistance <= distanceTolerance)
{
for (var k = i + 1; k < j; k++)
{
usePoint[k] = false;
}
}
else
{
SimplifySection(vertices, i, maxIndex, usePoint, distanceTolerance);
SimplifySection(vertices, maxIndex, j, usePoint, distanceTolerance);
}
}
private bool SplitPolygonEdge(Vertices polygon, Vector2 coordInsideThePolygon, out int vertex1Index, out int vertex2Index)
{
Vector2 slope;
int nearestEdgeVertex1Index = 0;
int nearestEdgeVertex2Index = 0;
bool edgeFound = false;
float shortestDistance = float.MaxValue;
bool edgeCoordFound = false;
Vector2 foundEdgeCoord = Vector2.Zero;
List <float> xCoords = SearchCrossingEdges(polygon, (int)coordInsideThePolygon.Y);
vertex1Index = 0;
vertex2Index = 0;
foundEdgeCoord.Y = coordInsideThePolygon.Y;
if (xCoords != null && xCoords.Count > 1 && xCoords.Count % 2 == 0)
{
float distance;
for (int i = 0; i < xCoords.Count; i++)
{
if (xCoords[i] < coordInsideThePolygon.X)
{
distance = coordInsideThePolygon.X - xCoords[i];
if (distance < shortestDistance)
{
shortestDistance = distance;
foundEdgeCoord.X = xCoords[i];
edgeCoordFound = true;
}
}
}
if (edgeCoordFound)
{
shortestDistance = float.MaxValue;
int edgeVertex2Index = polygon.Count - 1;
int edgeVertex1Index;
for (edgeVertex1Index = 0; edgeVertex1Index < polygon.Count; edgeVertex1Index++)
{
Vector2 tempVector1 = polygon[edgeVertex1Index];
Vector2 tempVector2 = polygon[edgeVertex2Index];
distance = LineUtils.DistanceBetweenPointAndLineSegment(ref foundEdgeCoord,
ref tempVector1, ref tempVector2);
if (distance < shortestDistance)
{
shortestDistance = distance;
nearestEdgeVertex1Index = edgeVertex1Index;
nearestEdgeVertex2Index = edgeVertex2Index;
edgeFound = true;
}
edgeVertex2Index = edgeVertex1Index;
}
if (edgeFound)
{
slope = polygon[nearestEdgeVertex2Index] - polygon[nearestEdgeVertex1Index];
slope.Normalize();
Vector2 tempVector = polygon[nearestEdgeVertex1Index];
distance = Vector2.Distance(tempVector, foundEdgeCoord);
vertex1Index = nearestEdgeVertex1Index;
vertex2Index = nearestEdgeVertex1Index + 1;
polygon.Insert(nearestEdgeVertex1Index, distance * slope + polygon[vertex1Index]);
polygon.Insert(nearestEdgeVertex1Index, distance * slope + polygon[vertex2Index]);
return(true);
}
}
}
return(false);
}