//------------------------------------------------------------------------------
public static PolygonsClp SimplifyPolygons(PolygonsClp polys,
PolyFillType fillType = PolyFillType.pftEvenOdd)
{
PolygonsClp result = new PolygonsClp();
Clipper c = new Clipper();
c.ForceSimple = true;
c.AddPolygons(polys, PolyType.ptSubject);
c.Execute(ClipType.ctUnion, result, fillType, fillType);
return result;
}
public static Polygon2D[] GetPolyUnion(Point[][] polygons)
{
if (polygons == null || polygons.Length == 0)
{
return new Polygon2D[0];
}
double scale = GetScale(polygons);
var convertedPolys = ConvertInput(polygons, scale);
Clipper clipper = new Clipper();
clipper.AddPolygons(convertedPolys, PolyType.ptSubject); // when doing union, I don't think it matters what is subject and what is union
//clipper.ForceSimple = true;
// Here is a page describing PolyFillType (nonzero is what you intuitively think of for a union)
// http://www.angusj.com/delphi/clipper/documentation/Docs/Units/ClipperLib/Types/PolyFillType.htm
PolyTree solution = new PolyTree();
if (!clipper.Execute(ClipType.ctUnion, solution, PolyFillType.pftNonZero, PolyFillType.pftNonZero))
{
return new Polygon2D[0];
}
return ConvertOutput(solution, 1d / scale);
}
//------------------------------------------------------------------------------
public PolyOffsetBuilder(PolygonsClp pts, PolygonsClp solution, bool isPolygon, double delta,
JoinType jointype, EndType endtype, double limit = 0)
{
//precondition: solution != pts
if (delta == 0) { solution = pts; return; }
m_p = pts;
m_delta = delta;
m_rmin = 0.5;
if (jointype == JoinType.jtMiter)
{
if (limit > 2) m_rmin = 2.0 / (limit * limit);
limit = 0.25; //just in case endtype == etRound
}
else
{
if (limit <= 0) limit = 0.25;
else if (limit > Math.Abs(delta)) limit = Math.Abs(delta);
}
double deltaSq = delta * delta;
solution.Clear();
solution.Capacity = pts.Count;
for (m_i = 0; m_i < pts.Count; m_i++)
{
int len = pts[m_i].Count;
if (len == 0 || (len < 3 && delta <= 0))
continue;
else if (len == 1)
{
currentPoly = new PolygonClp();
currentPoly = BuildArc(pts[m_i][0], 0, 2 * Math.PI, delta, limit);
solution.Add(currentPoly);
continue;
}
bool forceClose = PointsEqual(pts[m_i][0], pts[m_i][len - 1]);
if (forceClose) len--;
//build normals ...
normals.Clear();
normals.Capacity = len;
for (int j = 0; j < len - 1; ++j)
normals.Add(GetUnitNormal(pts[m_i][j], pts[m_i][j + 1]));
if (isPolygon || forceClose)
normals.Add(GetUnitNormal(pts[m_i][len - 1], pts[m_i][0]));
else
normals.Add(new DoublePoint(normals[len - 2]));
currentPoly = new PolygonClp();
if (isPolygon || forceClose)
{
m_k = len - 1;
for (m_j = 0; m_j < len; ++m_j)
OffsetPoint(jointype, limit);
solution.Add(currentPoly);
if (!isPolygon)
{
currentPoly = new PolygonClp();
m_delta = -m_delta;
m_k = len - 1;
for (m_j = 0; m_j < len; ++m_j)
OffsetPoint(jointype, limit);
m_delta = -m_delta;
currentPoly.Reverse();
solution.Add(currentPoly);
}
}
else
{
m_k = 0;
for (m_j = 1; m_j < len - 1; ++m_j)
OffsetPoint(jointype, limit);
IntPoint pt1;
if (endtype == EndType.etButt)
{
m_j = len - 1;
pt1 = new IntPoint((Int64)Round(pts[m_i][m_j].X + normals[m_j].X *
delta), (Int64)Round(pts[m_i][m_j].Y + normals[m_j].Y * delta));
AddPoint(pt1);
pt1 = new IntPoint((Int64)Round(pts[m_i][m_j].X - normals[m_j].X *
delta), (Int64)Round(pts[m_i][m_j].Y - normals[m_j].Y * delta));
AddPoint(pt1);
}
else
{
m_j = len - 1;
m_k = len - 2;
normals[m_j].X = -normals[m_j].X;
normals[m_j].Y = -normals[m_j].Y;
if (endtype == EndType.etSquare) DoSquare();
else DoRound(limit);
}
//re-build Normals ...
for (int j = len - 1; j > 0; j--)
{
normals[j].X = -normals[j - 1].X;
normals[j].Y = -normals[j - 1].Y;
}
normals[0].X = -normals[1].X;
normals[0].Y = -normals[1].Y;
m_k = len - 1;
for (m_j = m_k - 1; m_j > 0; --m_j)
OffsetPoint(jointype, limit);
if (endtype == EndType.etButt)
{
pt1 = new IntPoint((Int64)Round(pts[m_i][0].X - normals[0].X * delta),
(Int64)Round(pts[m_i][0].Y - normals[0].Y * delta));
AddPoint(pt1);
pt1 = new IntPoint((Int64)Round(pts[m_i][0].X + normals[0].X * delta),
(Int64)Round(pts[m_i][0].Y + normals[0].Y * delta));
AddPoint(pt1);
}
else
{
m_k = 1;
if (endtype == EndType.etSquare) DoSquare();
else DoRound(limit);
}
solution.Add(currentPoly);
}
}
//finally, clean up untidy corners ...
Clipper clpr = new Clipper();
clpr.AddPolygons(solution, PolyType.ptSubject);
if (delta > 0)
{
clpr.Execute(ClipType.ctUnion, solution, PolyFillType.pftPositive, PolyFillType.pftPositive);
}
else
{
IntRect r = clpr.GetBounds();
PolygonClp outer = new PolygonClp(4);
outer.Add(new IntPoint(r.left - 10, r.bottom + 10));
outer.Add(new IntPoint(r.right + 10, r.bottom + 10));
outer.Add(new IntPoint(r.right + 10, r.top - 10));
outer.Add(new IntPoint(r.left - 10, r.top - 10));
clpr.AddPolygon(outer, PolyType.ptSubject);
clpr.ReverseSolution = true;
clpr.Execute(ClipType.ctUnion, solution, PolyFillType.pftNegative, PolyFillType.pftNegative);
if (solution.Count > 0) solution.RemoveAt(0);
}
}