public Point2DList(Point2DList l)
{
int numPoints = l.Count;
for (int i = 0; i < numPoints; ++i)
{
mPoints.Add(l[i]);
}
mBoundingBox.Set(l.BoundingBox);
mEpsilon = l.Epsilon;
mWindingOrder = l.WindingOrder;
}
public static void InitializeHoles(List <Contour> holes, ITriangulatable parent, ConstrainedPointSet cps)
{
int numHoles = holes.Count;
int holeIdx = 0;
// pass 1 - remove duplicates
while (holeIdx < numHoles)
{
int hole2Idx = holeIdx + 1;
while (hole2Idx < numHoles)
{
bool bSamePolygon = PolygonUtil.PolygonsAreSame2D(holes[holeIdx], holes[hole2Idx]);
if (bSamePolygon)
{
// remove one of them
holes.RemoveAt(hole2Idx);
--numHoles;
}
else
{
++hole2Idx;
}
}
++holeIdx;
}
// pass 2: Intersections and Containment
holeIdx = 0;
while (holeIdx < numHoles)
{
bool bIncrementHoleIdx = true;
int hole2Idx = holeIdx + 1;
while (hole2Idx < numHoles)
{
if (PolygonUtil.PolygonContainsPolygon(holes[holeIdx], holes[holeIdx].Bounds, holes[hole2Idx], holes[hole2Idx].Bounds, false))
{
holes[holeIdx].AddHole(holes[hole2Idx]);
holes.RemoveAt(hole2Idx);
--numHoles;
}
else if (PolygonUtil.PolygonContainsPolygon(holes[hole2Idx], holes[hole2Idx].Bounds, holes[holeIdx], holes[holeIdx].Bounds, false))
{
holes[hole2Idx].AddHole(holes[holeIdx]);
holes.RemoveAt(holeIdx);
--numHoles;
bIncrementHoleIdx = false;
break;
}
else
{
bool bIntersect = PolygonUtil.PolygonsIntersect2D(holes[holeIdx], holes[holeIdx].Bounds, holes[hole2Idx], holes[hole2Idx].Bounds);
if (bIntersect)
{
// this is actually an error condition
// fix by merging hole1 and hole2 into hole1 (including the holes inside hole2!) and delete hole2
// Then, because hole1 is now changed, restart it's check.
PolygonOperationContext ctx = new PolygonOperationContext();
if (!ctx.Init(PolygonUtil.PolyOperation.Union | PolygonUtil.PolyOperation.Intersect, holes[holeIdx], holes[hole2Idx]))
{
if (ctx.mError == PolygonUtil.PolyUnionError.Poly1InsidePoly2)
{
holes[hole2Idx].AddHole(holes[holeIdx]);
holes.RemoveAt(holeIdx);
--numHoles;
bIncrementHoleIdx = false;
break;
}
else
{
throw new Exception("PolygonOperationContext.Init had an error during initialization");
}
}
PolygonUtil.PolyUnionError pue = PolygonUtil.PolygonOperation(ctx);
if (pue == PolygonUtil.PolyUnionError.None)
{
Point2DList union = ctx.Union;
Point2DList intersection = ctx.Intersect;
// create a new contour for the union
Contour c = new Contour(parent);
c.AddRange(union);
c.Name = "(" + holes[holeIdx].Name + " UNION " + holes[hole2Idx].Name + ")";
c.WindingOrder = Point2DList.WindingOrderType.Default;
// add children from both of the merged contours
int numChildHoles = holes[holeIdx].GetNumHoles();
for (int i = 0; i < numChildHoles; ++i)
{
c.AddHole(holes[holeIdx].GetHole(i));
}
numChildHoles = holes[hole2Idx].GetNumHoles();
for (int i = 0; i < numChildHoles; ++i)
{
c.AddHole(holes[hole2Idx].GetHole(i));
}
// make sure we preserve the contours of the intersection
Contour cInt = new Contour(c);
cInt.AddRange(intersection);
cInt.Name = "(" + holes[holeIdx].Name + " INTERSECT " + holes[hole2Idx].Name + ")";
cInt.WindingOrder = Point2DList.WindingOrderType.Default;
c.AddHole(cInt);
// replace the current contour with the merged contour
holes[holeIdx] = c;
// toss the second contour
holes.RemoveAt(hole2Idx);
--numHoles;
// current hole is "examined", so move to the next one
hole2Idx = holeIdx + 1;
}
else
{
throw new Exception("PolygonOperation had an error!");
}
}
else
{
++hole2Idx;
}
}
}
if (bIncrementHoleIdx)
{
++holeIdx;
}
}
numHoles = holes.Count;
holeIdx = 0;
while (holeIdx < numHoles)
{
int numPoints = holes[holeIdx].Count;
for (int i = 0; i < numPoints; ++i)
{
int j = holes[holeIdx].NextIndex(i);
uint constraintCode = TriangulationConstraint.CalculateContraintCode(holes[holeIdx][i], holes[holeIdx][j]);
TriangulationConstraint tc = null;
if (!cps.TryGetConstraint(constraintCode, out tc))
{
tc = new TriangulationConstraint(holes[holeIdx][i], holes[holeIdx][j]);
cps.AddConstraint(tc);
}
// replace the points in the holes with valid points
if (holes[holeIdx][i].VertexCode == tc.P.VertexCode)
{
holes[holeIdx][i] = tc.P;
}
else if (holes[holeIdx][j].VertexCode == tc.P.VertexCode)
{
holes[holeIdx][j] = tc.P;
}
if (holes[holeIdx][i].VertexCode == tc.Q.VertexCode)
{
holes[holeIdx][i] = tc.Q;
}
else if (holes[holeIdx][j].VertexCode == tc.Q.VertexCode)
{
holes[holeIdx][j] = tc.Q;
}
}
++holeIdx;
}
}
// From Eric Jordan's convex decomposition library
/// <summary>
/// Merges all parallel edges in the list of vertices
/// </summary>
/// <param name="tolerance"></param>
public void MergeParallelEdges(double tolerance)
{
if (Count <= 3)
{
// Can't do anything useful here to a triangle
return;
}
bool[] mergeMe = new bool[Count];
int newNVertices = Count;
//Gather points to process
for (int i = 0; i < Count; ++i)
{
int lower = (i == 0) ? (Count - 1) : (i - 1);
int middle = i;
int upper = (i == Count - 1) ? (0) : (i + 1);
double dx0 = this[middle].X - this[lower].X;
double dy0 = this[middle].Y - this[lower].Y;
double dx1 = this[upper].Y - this[middle].X;
double dy1 = this[upper].Y - this[middle].Y;
double norm0 = Math.Sqrt(dx0 * dx0 + dy0 * dy0);
double norm1 = Math.Sqrt(dx1 * dx1 + dy1 * dy1);
if (!(norm0 > 0.0 && norm1 > 0.0) && newNVertices > 3)
{
//Merge identical points
mergeMe[i] = true;
--newNVertices;
}
dx0 /= norm0;
dy0 /= norm0;
dx1 /= norm1;
dy1 /= norm1;
double cross = dx0 * dy1 - dx1 * dy0;
double dot = dx0 * dx1 + dy0 * dy1;
if (Math.Abs(cross) < tolerance && dot > 0 && newNVertices > 3)
{
mergeMe[i] = true;
--newNVertices;
}
else
{
mergeMe[i] = false;
}
}
if (newNVertices == Count || newNVertices == 0)
{
return;
}
int currIndex = 0;
// Copy the vertices to a new list and clear the old
Point2DList oldVertices = new Point2DList(this);
Clear();
for (int i = 0; i < oldVertices.Count; ++i)
{
if (mergeMe[i] || newNVertices == 0 || currIndex == newNVertices)
{
continue;
}
if (currIndex >= newNVertices)
{
throw new Exception("Point2DList::MergeParallelEdges - currIndex[ " + currIndex.ToString() + "] >= newNVertices[" + newNVertices + "]");
}
mPoints.Add(oldVertices[i]);
mBoundingBox.AddPoint(oldVertices[i]);
++currIndex;
}
mWindingOrder = CalculateWindingOrder();
mEpsilon = CalculateEpsilon();
}
/// <summary>
/// Checks if polygon is valid for use in Box2d engine.
/// Last ditch effort to ensure no invalid polygons are
/// added to world geometry.
///
/// Performs a full check, for simplicity, convexity,
/// orientation, minimum angle, and volume. This won't
/// be very efficient, and a lot of it is redundant when
/// other tools in this section are used.
///
/// From Eric Jordan's convex decomposition library
/// </summary>
/// <param name="printErrors"></param>
/// <returns></returns>
public PolygonError CheckPolygon()
{
PolygonError error = PolygonError.None;
if (Count < 3 || Count > Point2DList.kMaxPolygonVertices)
{
error |= PolygonError.NotEnoughVertices;
// no other tests will be valid at this point, so just return
return(error);
}
if (IsDegenerate())
{
error |= PolygonError.Degenerate;
}
//bool bIsConvex = IsConvex();
//if (!IsConvex())
//{
// error |= PolygonError.NotConvex;
//}
if (!IsSimple())
{
error |= PolygonError.NotSimple;
}
if (GetArea() < MathUtil.EPSILON)
{
error |= PolygonError.AreaTooSmall;
}
// the following tests don't make sense if the polygon is not simple
if ((error & PolygonError.NotSimple) != PolygonError.NotSimple)
{
bool bReversed = false;
WindingOrderType expectedWindingOrder = WindingOrderType.CCW;
WindingOrderType reverseWindingOrder = WindingOrderType.CW;
if (WindingOrder == reverseWindingOrder)
{
WindingOrder = expectedWindingOrder;
bReversed = true;
}
//Compute normals
Point2D[] normals = new Point2D[Count];
Point2DList vertices = new Point2DList(Count);
for (int i = 0; i < Count; ++i)
{
vertices.Add(new Point2D(this[i].X, this[i].Y));
int i1 = i;
int i2 = NextIndex(i);
Point2D edge = new Point2D(this[i2].X - this[i1].X, this[i2].Y - this[i1].Y);
normals[i] = Point2D.Perpendicular(edge, 1.0);
normals[i].Normalize();
}
//Required side checks
for (int i = 0; i < Count; ++i)
{
int iminus = PreviousIndex(i);
//Parallel sides check
double cross = Point2D.Cross(normals[iminus], normals[i]);
cross = MathUtil.Clamp(cross, -1.0f, 1.0f);
float angle = (float)Math.Asin(cross);
if (Math.Abs(angle) <= Point2DList.kAngularSlop)
{
error |= PolygonError.SidesTooCloseToParallel;
break;
}
// For some reason, the following checks do not seem to work
// correctly in all cases - they return false positives.
// //Too skinny check - only valid for convex polygons
// if (bIsConvex)
// {
// for (int j = 0; j < Count; ++j)
// {
// if (j == i || j == NextIndex(i))
// {
// continue;
// }
// Point2D testVector = vertices[j] - vertices[i];
// testVector.Normalize();
// double s = Point2D.Dot(testVector, normals[i]);
// if (s >= -Point2DList.kLinearSlop)
// {
// error |= PolygonError.TooThin;
// }
// }
// Point2D centroid = vertices.GetCentroid();
// Point2D n1 = normals[iminus];
// Point2D n2 = normals[i];
// Point2D v = vertices[i] - centroid;
// Point2D d = new Point2D();
// d.X = Point2D.Dot(n1, v); // - toiSlop;
// d.Y = Point2D.Dot(n2, v); // - toiSlop;
// // Shifting the edge inward by toiSlop should
// // not cause the plane to pass the centroid.
// if ((d.X < 0.0f) || (d.Y < 0.0f))
// {
// error |= PolygonError.TooThin;
// }
// }
}
if (bReversed)
{
WindingOrder = reverseWindingOrder;
}
}
//if (error != PolygonError.None)
//{
// Console.WriteLine("Found invalid polygon: {0} {1}\n", Point2DList.GetErrorString(error), this.ToString());
//}
return(error);
}
public virtual void AddRange(Point2DList l)
{
AddRange(l.mPoints.GetEnumerator(), l.WindingOrder);
}