various

Author: micycle1

CHANGELOG.md

@@ -17,11 +17,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changes
 * Packed circles from `PGS_CirclePacking.stochasticPack()` will now always lie within a shape bounds.
 * `PGS_Processing.pointsOnExterior()` methods now respect GROUP shapes and holes (inner rings) and will populate them with points.
+* `PGS_Morphology.simplifyDCE()` now supports GROUP shapes and polygon holes.
 
 ### Fixed
 * `urquhartFaces()`, `relativeNeighborFaces()`, `gabrielFaces()` and `spannerFaces()` from `PGS_Meshing` now preserve holes from the input.
 
-## Removed
+### Removed
 * `simplifyDCE(shape, targetNumVertices)` and `simplifyDCE(shape, vertexRemovalFraction)` in favour a single method that accepts a user-defined termination callback that is supplied with the current vertex candidate's coordinate, relevance score, and the number of vertices remaining.
 
 

pom.xml

@@ -243,7 +243,7 @@
 		<dependency>
 			<groupId>org.tinspin</groupId>
 			<artifactId>tinspin-indexes</artifactId>
-			<version>2.1.2</version>
+			<version>2.1.3</version>
 		</dependency>
 		<dependency> <!-- for test running -->
 			<groupId>org.junit.jupiter</groupId>

src/main/java/micycle/pgs/PGS.java

@@ -18,8 +18,10 @@
 import org.locationtech.jts.geom.CoordinateList;
 import org.locationtech.jts.geom.Geometry;
 import org.locationtech.jts.geom.GeometryFactory;
+import org.locationtech.jts.geom.GeometryFilter;
 import org.locationtech.jts.geom.LineString;
 import org.locationtech.jts.geom.LinearRing;
+import org.locationtech.jts.geom.MultiPolygon;
 import org.locationtech.jts.geom.Point;
 import org.locationtech.jts.geom.Polygon;
 import org.locationtech.jts.geom.PrecisionModel;
@@ -29,7 +31,6 @@
 import org.locationtech.jts.noding.snap.SnappingNoder;
 import org.locationtech.jts.operation.linemerge.LineMerger;
 import org.locationtech.jts.operation.polygonize.Polygonizer;
-
 import micycle.pgs.color.Colors;
 import micycle.pgs.commons.Nullable;
 import micycle.pgs.commons.PEdge;
@@ -266,7 +267,7 @@ static final PShape polygonizeSegments(Collection<SegmentString> segments, boole
 	 *         formed by the given edges
 	 */
 	@SuppressWarnings("unchecked")
-	static final PShape polygonizeEdgesRobust(Collection<PEdge> edges) {
+	private static final PShape polygonizeEdgesRobust(Collection<PEdge> edges) {
 		final Set<PEdge> edgeSet = new HashSet<>(edges);
 		final Polygonizer polygonizer = new Polygonizer();
 		polygonizer.setCheckRingsValid(false);
@@ -417,6 +418,43 @@ static SimpleWeightedGraph<PVector, PEdge> makeCompleteGraph(List<PVector> point
 		return graph;
 	}
 
+	/**
+	 * Extracts all the polygons from a given geometry. If the geometry instance is
+	 * a MultiPolygon, each individual polygon is extracted and added to the result
+	 * list. Other geometry types contained within the input geometry are ignored.
+	 */
+	static List<Polygon> extractPolygons(Geometry g) {
+		List<Polygon> polygons = new ArrayList<>(g.getNumGeometries());
+		final GeometryFilter filter = new GeometryFilter() {
+			public void filter(Geometry geom) {
+				if (geom instanceof Polygon) {
+					polygons.add((Polygon) geom);
+				} else if (geom instanceof MultiPolygon) {
+					for (int i = 0; i < geom.getNumGeometries(); i++) {
+						polygons.add((Polygon) geom.getGeometryN(i));
+					}
+				}
+			}
+		};
+
+		g.apply(filter);
+		return polygons;
+	}
+
+	/**
+	 * Extracts all the LinearRings from a given polygon. This includes both the
+	 * exterior ring and all interior rings (if any).
+	 */
+	static List<LinearRing> extractLinearRings(Polygon polygon) {
+		List<LinearRing> rings = new ArrayList<>(1 + polygon.getNumInteriorRing());
+		rings.add((LinearRing) polygon.getExteriorRing());
+		for (int i = 0; i < polygon.getNumInteriorRing(); i++) {
+			rings.add((LinearRing) polygon.getInteriorRingN(i));
+		}
+
+		return rings;
+	}
+
 	/**
 	 * Provides convenient iteration of the child geometries of a JTS MultiGeometry.
 	 * This iterator does not recurse all geometries (as does

src/main/java/micycle/pgs/PGS_Contour.java

@@ -829,7 +829,7 @@ private static PShape offsetCurves(PShape shape, OffsetStyle style, double spaci
 		}
 
 		if (g.getCoordinates().length > 2000) {
-			g = DouglasPeuckerSimplifier.simplify(g, 1);
+			g = DouglasPeuckerSimplifier.simplify(g, 0.25);
 		}
 
 		final BufferParameters bufParams = new BufferParameters(8, BufferParameters.CAP_FLAT, style.style,

src/main/java/micycle/pgs/PGS_Morphology.java

@@ -254,18 +254,21 @@ public static PShape simplifyTopology(PShape shape, double distanceTolerance) {
 	 * This algorithm simplifies a shape by iteratively removing kinks from the
 	 * shape, starting with those having the least shape-relevance.
 	 * <p>
-	 * The simplification process terminates according to a user-specified callback
-	 * that decides whether the DCE algorithm should terminate based on the current
-	 * kink (having a candidate vertex), using its coordinates, relevance score, and
-	 * the number of vertices remaining in the simplified geometry. Implementations
-	 * can use this method to provide custom termination logic which may depend on
-	 * various factors, such as a threshold relevance score, a specific number of
-	 * vertices to preserve, or other criteria.
+	 * The simplification process terminates according to a user-specified
+	 * {@link DCETerminationCallback#shouldTerminate(Coordinate, double, int)
+	 * callback} that decides whether the DCE algorithm should terminate based on
+	 * the current kink (having a candidate vertex), using its coordinates,
+	 * relevance score, and the number of vertices remaining in the simplified
+	 * geometry. Implementations can use this method to provide custom termination
+	 * logic which may depend on various factors, such as a threshold relevance
+	 * score, a specific number of vertices to preserve, or other criteria.
+	 * <p>
+	 * Note: the termination callback is applied per ring (boundary, hole, line,
+	 * etc) in the input.
 	 * 
 	 * @param shape               The input shape to be simplified, which can be a
 	 *                            polygonal (inclusive of holes) or a lineal shape.
-	 *                            Note that GROUP shapes are not supported by this
-	 *                            method.
+	 *                            GROUP shapes are supported.
 	 * @param terminationCallback The callback used to determine when the
 	 *                            simplification process should terminate.
 	 *                            {@code true} if the DCE process should terminate;

src/main/java/micycle/pgs/PGS_PointSet.java

@@ -26,8 +26,8 @@
 import org.jgrapht.graph.SimpleGraph;
 import org.tinfour.common.IIncrementalTin;
 import org.tinfour.common.Vertex;
-import org.tinspin.index.kdtree.KDTree;
-
+import org.tinspin.index.IndexConfig;
+import org.tinspin.index.PointMap;
 import it.unimi.dsi.fastutil.objects.Object2DoubleOpenHashMap;
 import it.unimi.dsi.util.XoRoShiRo128PlusRandom;
 import it.unimi.dsi.util.XoRoShiRo128PlusRandomGenerator;
@@ -67,7 +67,7 @@ private PGS_PointSet() {
 	 * @return
 	 */
 	public static List<PVector> prunePointsWithinDistance(List<PVector> points, double distanceTolerance) {
-		final KDTree<PVector> tree = KDTree.create(2);
+		final PointMap<Object> tree = PointMap.Factory.createKdTree(IndexConfig.create(2).setDefensiveKeyCopy(false));
 		final List<PVector> newPoints = new ArrayList<>();
 		for (PVector p : points) {
 			final double[] coords = new double[] { p.x, p.y };

src/main/java/micycle/pgs/PGS_SegmentSet.java

@@ -22,7 +22,6 @@
 import org.locationtech.jts.geom.LineSegment;
 import org.locationtech.jts.geom.LineString;
 import org.locationtech.jts.geom.Location;
-import org.locationtech.jts.geom.util.LineStringExtracter;
 import org.locationtech.jts.geom.util.LinearComponentExtracter;
 import org.locationtech.jts.noding.MCIndexSegmentSetMutualIntersector;
 import org.locationtech.jts.noding.NodedSegmentString;

src/main/java/micycle/pgs/commons/AreaMerge.java

@@ -1,17 +1,14 @@
 package micycle.pgs.commons;
 
-import java.util.Collection;
 import java.util.HashMap;
-import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Objects;
-import java.util.Set;
 import java.util.TreeSet;
 import java.util.stream.Collectors;
 import org.jgrapht.Graph;
 import org.jgrapht.Graphs;
-import org.jgrapht.alg.util.NeighborCache;
 import org.jgrapht.alg.util.Pair;
 import org.jgrapht.graph.DefaultEdge;
 import org.jgrapht.graph.SimpleGraph;
@@ -44,14 +41,13 @@ private AreaMerge() {
 	 */
 	public static PShape areaMerge(PShape mesh, double areaThreshold) {
 		SimpleGraph<PShape, DefaultEdge> graph = PGS_Conversion.toDualGraph(mesh);
-		NeighborCache<PShape, DefaultEdge> neighborCache = new NeighborCache<>(graph);
 
 		Map<PShape, FaceGroup> initialFaceMap = new HashMap<>(graph.vertexSet().size());
 		SimpleGraph<FaceGroup, DefaultEdge> groupsGraph = new SimpleGraph<>(DefaultEdge.class);
 		TreeSet<FaceGroup> smallGroups = new TreeSet<>(); // groups having area < areaThreshold
 		for (PShape face : graph.vertexSet()) {
 			double area = PGS_ShapePredicates.area(face);
-			FaceGroup f = new FaceGroup(face, area, neighborCache);
+			FaceGroup f = new FaceGroup(face, area);
 			initialFaceMap.put(face, f);
 			groupsGraph.addVertex(f);
 
@@ -72,11 +68,13 @@ public static PShape areaMerge(PShape mesh, double areaThreshold) {
 
 		while (!smallGroups.isEmpty()) {
 			final FaceGroup toMerge = smallGroups.pollFirst();
-			Collection<FaceGroup> neighbors = Graphs.neighborSetOf(groupsGraph, toMerge);
 
 			// find smallest neighbor of the toMerge face
-//			FaceGroup smallestNeighbor = neighbors.stream().min((a, b) -> Double.compare(a.area, b.area)).orElse(null);
-			FaceGroup smallestNeighbor = Graphs.neighborListOf(groupsGraph, toMerge).get(0);
+			List<FaceGroup> neighboringGroups = Graphs.neighborListOf(groupsGraph, toMerge);
+			// sort neighbors by area, pick the smallest. ensures algorithm is stable on the
+			// same input
+			FaceGroup smallestNeighbor = neighboringGroups.stream().min((a, b) -> Double.compare(a.area, b.area)).orElse(null);
+//			FaceGroup smallestNeighbor = neighbors.get(0);
 			if (smallestNeighbor == null) {
 				break; // exit merging
 			}
@@ -86,10 +84,6 @@ public static PShape areaMerge(PShape mesh, double areaThreshold) {
 
 			if (smallestNeighbor.area > areaThreshold) {
 				smallGroups.remove(smallestNeighbor);
-			} else {
-				// re-insert and order the new group
-//				smallGroups.remove(smallestNeighbor);
-//				smallGroups.add(smallestNeighbor);
 			}
 		}
 
@@ -141,13 +135,9 @@ static class FaceGroup implements Comparable<FaceGroup> {
 		private double area;
 		/** A map of faces comprising this group and their respective areas. */
 		private Map<PShape, Double> faces;
-		private Set<PShape> neighborFaces; // union of neighbors of each face - faces themselves
-		private final NeighborCache<PShape, DefaultEdge> neighborCache;
 
-		FaceGroup(PShape initial, double area, NeighborCache<PShape, DefaultEdge> meshNeighborCache) {
+		FaceGroup(PShape initial, double area) {
 			this.faces = new HashMap<>();
-			this.neighborFaces = new HashSet<>();
-			this.neighborCache = meshNeighborCache;
 			addFace(initial, area);
 		}
 
@@ -156,45 +146,20 @@ static class FaceGroup implements Comparable<FaceGroup> {
 		 */
 		public boolean addFace(PShape face, double area) {
 			if (face == null) {
-//				System.err.println("Tried to add null face.");
 				return false;
 			}
-//			if (!faces.isEmpty() && !neighborFaces.contains(face)) {
-//				System.err.println("Tried to add a face that is not a neighboring face of the group.");
-//				return false;
-//			}
 			if (!faces.containsKey(face)) {
 				faces.put(face, area);
 				this.area += area;
-//				recomputeNeighbors(face);
 				return true;
 			}
 			return false;
 		}
 
-		private void recomputeNeighbors(PShape face) {
-			neighborFaces.addAll(neighborCache.neighborsOf(face));
-			/*
-			 * Now remove any of the group's own faces from the neighbours.
-			 */
-			neighborFaces.removeAll(faces.keySet());
-		}
-
-		private void recomputeNeighbors() {
-			neighborFaces.clear();
-			for (PShape face : faces.keySet()) {
-				neighborFaces.addAll(neighborCache.neighborsOf(face));
-			}
-			neighborFaces.removeAll(faces.keySet());
-		}
-
 		/**
 		 * Merges another facegroup into this one.
 		 */
 		public boolean mergeWith(FaceGroup other) {
-//			if (!neighbors(other)) {
-//				return false;
-//			}
 			boolean changed = false;
 			for (Entry<PShape, Double> faceEntry : other.faces.entrySet()) {
 				changed = changed | addFace(faceEntry.getKey(), faceEntry.getValue());
@@ -203,35 +168,6 @@ public boolean mergeWith(FaceGroup other) {
 			return changed;
 		}
 
-		/**
-		 * @return true if this and the other facegroup have no faces in common
-		 */
-		public boolean disjoint(FaceGroup other) {
-			Set<PShape> myFaces = new HashSet<>(faces.keySet());
-			myFaces.retainAll(other.faces.keySet());
-			return myFaces.isEmpty();
-		}
-
-		public boolean neighbors(PShape face) {
-			return neighborFaces.contains(face);
-		}
-
-		/**
-		 * @param facegroup
-		 * @return true if the groups are disjoint and neighborFaces each other
-		 */
-		public boolean neighbors(FaceGroup facegroup) {
-			if (!disjoint(facegroup)) {
-				return false;
-			}
-			for (PShape face : facegroup.faces.keySet()) {
-				if (neighborFaces.contains(face)) {
-					return true;
-				}
-			}
-			return false;
-		}
-
 		public boolean hasFace(PShape face) {
 			return faces.keySet().contains(face);
 		}