Merge pull request #4 from elara-leitstellentechnik/v1.0.6

Port of v1.0.6

Author: micycle1

src/main/java/clipper2/Clipper.java

@@ -1,10 +1,5 @@
 package clipper2;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
 import clipper2.core.ClipType;
 import clipper2.core.FillRule;
 import clipper2.core.InternalClipper;
@@ -21,19 +16,27 @@
 import clipper2.engine.ClipperD;
 import clipper2.engine.PointInPolygonResult;
 import clipper2.engine.PolyPath64;
-import clipper2.engine.PolyPathBase;
 import clipper2.engine.PolyPathD;
+import clipper2.engine.PolyPathNode;
 import clipper2.engine.PolyTree64;
 import clipper2.engine.PolyTreeD;
 import clipper2.offset.ClipperOffset;
 import clipper2.offset.EndType;
 import clipper2.offset.JoinType;
+import clipper2.rectclip.RectClip;
+import clipper2.rectclip.RectClipLines;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
 
 public final class Clipper {
 
 	public static final Rect64 MaxInvalidRect64 = new Rect64(Long.MAX_VALUE, Long.MAX_VALUE, Long.MIN_VALUE, Long.MIN_VALUE);
 
 	public static final RectD MaxInvalidRectD = new RectD(Double.MAX_VALUE, Double.MAX_VALUE, -Double.MAX_VALUE, -Double.MAX_VALUE);
+	private static final String PRECISION_RANGE_ERROR = "Error: Precision is out of range.";
 
 	public static Paths64 Intersect(Paths64 subject, Paths64 clip, FillRule fillRule) {
 		return BooleanOp(ClipType.Intersection, subject, clip, fillRule);
@@ -43,8 +46,8 @@ public static PathsD Intersect(PathsD subject, PathsD clip, FillRule fillRule) {
 		return Intersect(subject, clip, fillRule, 2);
 	}
 
-	public static PathsD Intersect(PathsD subject, PathsD clip, FillRule fillRule, int roundingDecimalPrecision) {
-		return BooleanOp(ClipType.Intersection, subject, clip, fillRule, roundingDecimalPrecision);
+	public static PathsD Intersect(PathsD subject, PathsD clip, FillRule fillRule, int precision) {
+		return BooleanOp(ClipType.Intersection, subject, clip, fillRule, precision);
 	}
 
 	public static Paths64 Union(Paths64 subject, FillRule fillRule) {
@@ -63,8 +66,8 @@ public static PathsD Union(PathsD subject, PathsD clip, FillRule fillRule) {
 		return Union(subject, clip, fillRule, 2);
 	}
 
-	public static PathsD Union(PathsD subject, PathsD clip, FillRule fillRule, int roundingDecimalPrecision) {
-		return BooleanOp(ClipType.Union, subject, clip, fillRule, roundingDecimalPrecision);
+	public static PathsD Union(PathsD subject, PathsD clip, FillRule fillRule, int precision) {
+		return BooleanOp(ClipType.Union, subject, clip, fillRule, precision);
 	}
 
 	public static Paths64 Difference(Paths64 subject, Paths64 clip, FillRule fillRule) {
@@ -75,8 +78,8 @@ public static PathsD Difference(PathsD subject, PathsD clip, FillRule fillRule)
 		return Difference(subject, clip, fillRule, 2);
 	}
 
-	public static PathsD Difference(PathsD subject, PathsD clip, FillRule fillRule, int roundingDecimalPrecision) {
-		return BooleanOp(ClipType.Difference, subject, clip, fillRule, roundingDecimalPrecision);
+	public static PathsD Difference(PathsD subject, PathsD clip, FillRule fillRule, int precision) {
+		return BooleanOp(ClipType.Difference, subject, clip, fillRule, precision);
 	}
 
 	public static Paths64 Xor(Paths64 subject, Paths64 clip, FillRule fillRule) {
@@ -87,8 +90,8 @@ public static PathsD Xor(PathsD subject, PathsD clip, FillRule fillRule) {
 		return Xor(subject, clip, fillRule, 2);
 	}
 
-	public static PathsD Xor(PathsD subject, PathsD clip, FillRule fillRule, int roundingDecimalPrecision) {
-		return BooleanOp(ClipType.Xor, subject, clip, fillRule, roundingDecimalPrecision);
+	public static PathsD Xor(PathsD subject, PathsD clip, FillRule fillRule, int precision) {
+		return BooleanOp(ClipType.Xor, subject, clip, fillRule, precision);
 	}
 
 	public static Paths64 BooleanOp(ClipType clipType, Paths64 subject, Paths64 clip, FillRule fillRule) {
@@ -109,10 +112,9 @@ public static PathsD BooleanOp(ClipType clipType, PathsD subject, PathsD clip, F
 		return BooleanOp(clipType, subject, clip, fillRule, 2);
 	}
 
-	public static PathsD BooleanOp(ClipType clipType, PathsD subject, @Nullable PathsD clip, FillRule fillRule,
-			int roundingDecimalPrecision) {
+	public static PathsD BooleanOp(ClipType clipType, PathsD subject, @Nullable PathsD clip, FillRule fillRule, int precision) {
 		PathsD solution = new PathsD();
-		ClipperD c = new ClipperD(roundingDecimalPrecision);
+		ClipperD c = new ClipperD(precision);
 		c.AddSubjectsD(subject);
 		if (clip != null) {
 			c.AddClipsD(clip);
@@ -184,7 +186,7 @@ public static PathsD InflatePaths(PathsD paths, double delta, JoinType joinType,
 
 	public static PathsD InflatePaths(PathsD paths, double delta, JoinType joinType, EndType endType, double miterLimit, int precision) {
 		if (precision < -8 || precision > 8) {
-			throw new IllegalArgumentException("Error: Precision is out of range.");
+			throw new IllegalArgumentException(PRECISION_RANGE_ERROR);
 		}
 		double scale = Math.pow(10, precision);
 		Paths64 tmp = ScalePaths64(paths, scale);
@@ -194,6 +196,157 @@ public static PathsD InflatePaths(PathsD paths, double delta, JoinType joinType,
 		return ScalePathsD(tmp, 1 / scale);
 	}
 
+	public static Path64 RectClip(Rect64 rect, Path64 path)
+	{
+		if (rect.IsEmpty() || path.isEmpty()) return new Path64();
+		RectClip rc = new RectClip(rect);
+		return rc.ExecuteInternal(path);
+	}
+
+	public static Paths64 RectClip(Rect64 rect, Paths64 paths)
+	{
+		if (rect.IsEmpty() || paths.isEmpty()) return new Paths64();
+
+		Paths64 result = new Paths64(paths.size());
+		RectClip rc = new RectClip(rect);
+		for (Path64 path : paths) {
+			Rect64 pathRec = GetBounds(path);
+			if (!rect.Intersects(pathRec))
+				continue;
+			else if (rect.Contains(pathRec))
+				result.add(path);
+			else
+			{
+				Path64 p = rc.ExecuteInternal(path);
+				if (p.size() > 0) result.add(p);
+			}
+		}
+		return result;
+	}
+
+	public static PathD RectClip(RectD rect, PathD path){
+		return RectClip(rect, path, 2);
+	}
+
+	public static PathD RectClip(RectD rect, PathD path, int precision)
+	{
+		if (precision < -8 || precision > 8)
+			throw new IllegalArgumentException(PRECISION_RANGE_ERROR);
+		if (rect.IsEmpty() || path.size() == 0) return new PathD();
+		double scale = Math.pow(10, precision);
+		Rect64 r = ScaleRect(rect, scale);
+		Path64 tmpPath = ScalePath64(path, scale);
+		RectClip rc = new RectClip(r);
+		tmpPath = rc.ExecuteInternal(tmpPath);
+		return ScalePathD(tmpPath, 1 / scale);
+	}
+
+	public static PathsD RectClip(RectD rect, PathsD paths)
+	{
+		return RectClip(rect, paths, 2);
+	}
+
+	public static PathsD RectClip(RectD rect, PathsD paths, int precision)
+	{
+		if (precision < -8 || precision > 8)
+			throw new IllegalArgumentException(PRECISION_RANGE_ERROR);
+		if (rect.IsEmpty() || paths.size() == 0) return new PathsD();
+		double scale = Math.pow(10, precision);
+		Rect64 r = ScaleRect(rect, scale);
+		RectClip rc = new RectClip(r);
+		PathsD result = new PathsD(paths.size());
+		for (PathD p : paths) {
+			RectD pathRec = GetBounds(p);
+			if (!rect.Intersects(pathRec))
+				continue;
+			else if (rect.Contains(pathRec))
+				result.add(p);
+			else
+			{
+				Path64 p64 = ScalePath64(p, scale);
+				p64 = rc.ExecuteInternal(p64);
+				if (p64.size() > 0)
+					result.add(ScalePathD(p64, 1 / scale));
+			}
+		}
+		return result;
+	}
+	public static Paths64 RectClipLines(Rect64 rect, Path64 path)
+	{
+		if (rect.IsEmpty() || path.size() == 0) return new Paths64();
+		RectClipLines rco = new RectClipLines(rect);
+		return rco.NewExecuteInternal(path);
+	}
+
+	public static Paths64 RectClipLines(Rect64 rect, Paths64 paths)
+	{
+		Paths64 result = new Paths64(paths.size());
+		if (rect.IsEmpty() || paths.size() == 0) return result;
+		RectClipLines rco = new RectClipLines(rect);
+		for (Path64 path : paths) {
+			Rect64 pathRec = GetBounds(path);
+			if (!rect.Intersects(pathRec))
+				continue;
+			else if (rect.Contains(pathRec))
+				result.add(path);
+			else
+			{
+				Paths64 pp = rco.NewExecuteInternal(path);
+				if (pp.size() > 0) result.addAll(pp);
+			}
+		}
+		return result;
+	}
+
+	public static PathsD RectClipLines(RectD rect, PathD path)
+	{
+		return RectClipLines(rect, path, 2);
+	}
+
+	public static PathsD RectClipLines(RectD rect, PathD path, int precision)
+	{
+		if (precision < -8 || precision > 8)
+			throw new IllegalArgumentException(PRECISION_RANGE_ERROR);
+		if (rect.IsEmpty() || path.size() == 0) return new PathsD();
+		double scale = Math.pow(10, precision);
+		Rect64 r = ScaleRect(rect, scale);
+		Path64 tmpPath = ScalePath64(path, scale);
+		RectClipLines rco = new RectClipLines(r);
+		Paths64 tmpPaths = rco.NewExecuteInternal(tmpPath);
+		return ScalePathsD(tmpPaths, 1 / scale);
+	}
+	public static PathsD RectClipLines(RectD rect, PathsD paths)
+	{
+		return RectClipLines(rect, paths, 2);
+	}
+
+	public static PathsD RectClipLines(RectD rect, PathsD paths, int precision)
+	{
+		if (precision < -8 || precision > 8)
+			throw new IllegalArgumentException(PRECISION_RANGE_ERROR);
+		PathsD result = new PathsD(paths.size());
+		if (rect.IsEmpty() || paths.size() == 0) return result;
+		double scale = Math.pow(10, precision);
+		Rect64 r = ScaleRect(rect, scale);
+		RectClipLines rco = new RectClipLines(r);
+		for (PathD p : paths) {
+			RectD pathRec = GetBounds(p);
+			if (!rect.Intersects(pathRec))
+				continue;
+			else if (rect.Contains(pathRec))
+				result.add(p);
+			else
+			{
+				Path64 p64 = ScalePath64(p, scale);
+				Paths64 pp64 = rco.NewExecuteInternal(p64);
+				if (pp64.size() == 0) continue;
+				PathsD ppd = ScalePathsD(pp64, 1 / scale);
+				result.addAll(ppd);
+			}
+		}
+		return result;
+	}
+
 	public static Paths64 MinkowskiSum(Path64 pattern, Path64 path, boolean isClosed) {
 		return Minkowski.Sum(pattern, path, isClosed);
 	}
@@ -353,6 +506,17 @@ public static PointD ScalePointD(Point64 pt, double scale) {
 		return result;
 	}
 
+	public static Rect64 ScaleRect(RectD rec, double scale)
+	{
+		Rect64 result = new Rect64(
+			(long) (rec.left * scale),
+			(long) (rec.top * scale),
+			(long) (rec.right * scale),
+			(long) (rec.bottom * scale)
+		);
+		return result;
+	}
+
 	public static Path64 ScalePath(Path64 path, double scale) {
 		if (InternalClipper.IsAlmostZero(scale - 1)) {
 			return path;
@@ -528,6 +692,30 @@ public static PathsD ReversePaths(PathsD paths) {
 		return result;
 	}
 
+	public static Rect64 GetBounds(Path64 path)
+	{
+		Rect64 result = MaxInvalidRect64;
+		for (Point64 pt : path) {
+			if (pt.x < result.left) result.left = pt.x;
+			if (pt.x > result.right) result.right = pt.x;
+			if (pt.y < result.top) result.top = pt.y;
+			if (pt.y > result.bottom) result.bottom = pt.y;
+		}
+		return result.IsEmpty() ? new Rect64() : result;
+	}
+
+	public static RectD GetBounds(PathD path)
+	{
+		RectD result = MaxInvalidRectD;
+		for (PointD pt : path) {
+			if (pt.x < result.left) result.left = pt.x;
+			if (pt.x > result.right) result.right = pt.x;
+			if (pt.y < result.top) result.top = pt.y;
+			if (pt.y > result.bottom) result.bottom = pt.y;
+		}
+		return result.IsEmpty() ? new RectD() : result;
+	}
+
 	public static Rect64 GetBounds(Paths64 paths) {
 		Rect64 result = MaxInvalidRect64;
 		for (Path64 path : paths) {
@@ -669,7 +857,7 @@ public static void AddPolyNodeToPathsD(PolyPathD polyPath, PathsD paths) {
 
 	public static PathsD PolyTreeToPathsD(PolyTreeD polyTree) {
 		PathsD result = new PathsD();
-		for (PolyPathBase polyPathBase : polyTree) {
+		for (PolyPathNode polyPathBase : polyTree) {
 			PolyPathD p = (PolyPathD) polyPathBase;
 			AddPolyNodeToPathsD(p, result);
 		}
@@ -939,7 +1127,7 @@ public static PathD TrimCollinear(PathD path, int precision) {
 	 */
 	public static PathD TrimCollinear(PathD path, int precision, boolean isOpen) {
 		if (precision < -8 || precision > 8) {
-			throw new IllegalArgumentException("Error: Precision is out of range.");
+			throw new IllegalArgumentException(PRECISION_RANGE_ERROR);
 		}
 		double scale = Math.pow(10, precision);
 		Path64 p = ScalePath64(path, scale);