Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Enhance coverage simplification to handle one tolerance per geometry #1037

Closed
wants to merge 7 commits into from
+540 −35
Closed

Enhance coverage simplification to handle one tolerance per geometry #1037

Show file tree
Hide file tree
Changes from 3 commits
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
e4578b9
Enhance coverage simplification to handle dynamic tolerance. (One per…
nstrahl Mar 10, 2024
b717e87
Move tolerance string input handling for coverage simplification to j…
nstrahl Mar 11, 2024
3d89401
Add dynamic tolerance explanation to class documentation
nstrahl Mar 11, 2024
6fcea76
Use Double arrays instead of lists for tolerances in coverage classes
nstrahl Jun 1, 2024
f885cfe
Move logic of area tolerance retrieval into a new function getAreaTol…
nstrahl Jun 1, 2024
f3f2106
Move tolerance assignment logic to new function assignEdgeTolerance
nstrahl Jun 1, 2024
0451e6d
Use Double arrays instead of lists for tolerances in coverage classes
nstrahl Jun 5, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
23 changes: 22 additions & 1 deletion modules/app/src/main/java/org/locationtech/jtstest/function/CoverageFunctions.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,7 +11,9 @@
*/
package org.locationtech.jtstest.function;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

import org.locationtech.jts.coverage.CoverageGapFinder;
import org.locationtech.jts.coverage.CoveragePolygonValidator;
Expand Down Expand Up @@ -64,13 +66,29 @@ public static Geometry simplify(Geometry coverage, double tolerance) {
Geometry[] result = CoverageSimplifier.simplify(cov, tolerance);
return FunctionsUtil.buildGeometry(result);
}

@Metadata(description="Simplify a coverage by providing one tolerance per geometry")
public static Geometry simplifyDynamicTolerance(Geometry coverage, String tolerances) {
Geometry[] cov = toGeometryArray(coverage);
List<Double> toleranceList = toDoubleList(tolerances);
Geometry[] result = CoverageSimplifier.simplify(cov, toleranceList);
return FunctionsUtil.buildGeometry(result);
}

@Metadata(description="Simplify inner edges of a coverage")
public static Geometry simplifyinner(Geometry coverage, double tolerance) {
Geometry[] cov = toGeometryArray(coverage);
Geometry[] result = CoverageSimplifier.simplifyInner(cov, tolerance);
return FunctionsUtil.buildGeometry(result);
}

@Metadata(description="Simplify inner edges of a coverage by providing one tolerance per geometry")
public static Geometry simplifyinnerDynamicTolerance(Geometry coverage, String tolerances) {
Geometry[] cov = toGeometryArray(coverage);
List<Double> toleranceList = toDoubleList(tolerances);
Geometry[] result = CoverageSimplifier.simplifyInner(cov, toleranceList);
return FunctionsUtil.buildGeometry(result);
}

static Geometry extractPolygons(Geometry geom) {
List components = PolygonExtracter.getPolygons(geom);
Expand All @@ -85,5 +103,8 @@ private static Geometry[] toGeometryArray(Geometry geom) {
}
return geoms;
}


private static List<Double> toDoubleList(String csvList) {
return Arrays.stream(csvList.split(",")).map(Double::parseDouble).collect(Collectors.toList());
}
}
17 changes: 12 additions & 5 deletions modules/core/src/main/java/org/locationtech/jts/coverage/CoverageEdge.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -30,15 +30,15 @@
*/
class CoverageEdge {

public static CoverageEdge createEdge(Coordinate[] ring) {
public static CoverageEdge createEdge(Coordinate[] ring, double tolerance) {
Coordinate[] pts = extractEdgePoints(ring, 0, ring.length - 1);
CoverageEdge edge = new CoverageEdge(pts, true);
CoverageEdge edge = new CoverageEdge(pts, true, tolerance);
return edge;
}

public static CoverageEdge createEdge(Coordinate[] ring, int start, int end) {
public static CoverageEdge createEdge(Coordinate[] ring, int start, int end, double tolerance) {
Coordinate[] pts = extractEdgePoints(ring, start, end);
CoverageEdge edge = new CoverageEdge(pts, false);
CoverageEdge edge = new CoverageEdge(pts, false, tolerance);
return edge;
}

Expand Down Expand Up @@ -137,9 +137,12 @@ else if (i > pts.length - 1) {
private int ringCount = 0;
private boolean isFreeRing = true;

public CoverageEdge(Coordinate[] pts, boolean isFreeRing) {
private double tolerance = -1;

public CoverageEdge(Coordinate[] pts, boolean isFreeRing, double tolerance) {
this.pts = pts;
this.isFreeRing = isFreeRing;
this.tolerance = tolerance;
}

public void incRingCount() {
Expand All @@ -160,6 +163,10 @@ public boolean isFreeRing() {
return isFreeRing;
}

public double getTolerance() { return tolerance; }

public void setTolerance(double tolerance) { this.tolerance = tolerance; }

public void setCoordinates(Coordinate[] pts) {
this.pts = pts;
}
Expand Down
52 changes: 35 additions & 17 deletions modules/core/src/main/java/org/locationtech/jts/coverage/CoverageRingEdges.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -51,21 +51,30 @@ class CoverageRingEdges {
* Create a new instance for a given coverage.
*
* @param coverage the set of polygonal geometries in the coverage
* @param tolerances the simplification tolerances for each geometry
* @return the edges of the coverage
*/
public static CoverageRingEdges create(Geometry[] coverage, List<Double> tolerances) {
CoverageRingEdges edges = new CoverageRingEdges(coverage, tolerances);
return edges;
}

public static CoverageRingEdges create(Geometry[] coverage) {
CoverageRingEdges edges = new CoverageRingEdges(coverage);
CoverageRingEdges edges = new CoverageRingEdges(coverage, new ArrayList<Double>(0));
return edges;
}

private Geometry[] coverage;
private Map<LinearRing, List<CoverageEdge>> ringEdgesMap;
private List<CoverageEdge> edges;

public CoverageRingEdges(Geometry[] coverage) {

private List<Double> coverageTolerances;

public CoverageRingEdges(Geometry[] coverage, List<Double> tolerances) {
this.coverage = coverage;
ringEdgesMap = new HashMap<LinearRing, List<CoverageEdge>>();
edges = new ArrayList<CoverageEdge>();
coverageTolerances = tolerances;
build();
}

Expand Down Expand Up @@ -94,7 +103,8 @@ private void build() {
Set<LineSegment> boundarySegs = CoverageBoundarySegmentFinder.findBoundarySegments(coverage);
nodes.addAll(findBoundaryNodes(boundarySegs));
HashMap<LineSegment, CoverageEdge> uniqueEdgeMap = new HashMap<LineSegment, CoverageEdge>();
for (Geometry geom : coverage) {
for (int icoverage = 0; icoverage < coverage.length; icoverage++) {
Geometry geom = coverage[icoverage];
for (int ipoly = 0; ipoly < geom.getNumGeometries(); ipoly++) {
Polygon poly = (Polygon) geom.getGeometryN(ipoly);

Expand All @@ -104,23 +114,23 @@ private void build() {

//-- extract shell
LinearRing shell = poly.getExteriorRing();
addRingEdges(shell, nodes, boundarySegs, uniqueEdgeMap);
addRingEdges(icoverage, shell, nodes, boundarySegs, uniqueEdgeMap);
//-- extract holes
for (int ihole = 0; ihole < poly.getNumInteriorRing(); ihole++) {
LinearRing hole = poly.getInteriorRingN(ihole);
//-- skip empty rings. Missing rings are copied in result
if (hole.isEmpty())
continue;
addRingEdges(hole, nodes, boundarySegs, uniqueEdgeMap);
addRingEdges(icoverage, hole, nodes, boundarySegs, uniqueEdgeMap);
}
}
}
}

private void addRingEdges(LinearRing ring, Set<Coordinate> nodes, Set<LineSegment> boundarySegs,
private void addRingEdges(int coverageId, LinearRing ring, Set<Coordinate> nodes, Set<LineSegment> boundarySegs,
HashMap<LineSegment, CoverageEdge> uniqueEdgeMap) {
addBoundaryInnerNodes(ring, boundarySegs, nodes);
List<CoverageEdge> ringEdges = extractRingEdges(ring, uniqueEdgeMap, nodes);
List<CoverageEdge> ringEdges = extractRingEdges(coverageId, ring, uniqueEdgeMap, nodes);
if (ringEdges != null)
ringEdgesMap.put(ring, ringEdges);
}
Expand Down Expand Up @@ -149,8 +159,8 @@ private void addBoundaryInnerNodes(LinearRing ring, Set<LineSegment> boundarySeg
}
}

private List<CoverageEdge> extractRingEdges(LinearRing ring,
HashMap<LineSegment, CoverageEdge> uniqueEdgeMap,
private List<CoverageEdge> extractRingEdges(int coverageId, LinearRing ring,
HashMap<LineSegment, CoverageEdge> uniqueEdgeMap,
Set<Coordinate> nodes) {
// System.out.println(ring);
List<CoverageEdge> ringEdges = new ArrayList<CoverageEdge>();
Expand All @@ -164,15 +174,15 @@ private List<CoverageEdge> extractRingEdges(LinearRing ring,
int first = findNextNodeIndex(pts, -1, nodes);
if (first < 0) {
//-- ring does not contain a node, so edge is entire ring
CoverageEdge edge = createEdge(pts, uniqueEdgeMap);
CoverageEdge edge = createEdge(coverageId, pts, uniqueEdgeMap);
ringEdges.add(edge);
}
else {
int start = first;
int end = start;
do {
end = findNextNodeIndex(pts, start, nodes);
CoverageEdge edge = createEdge(pts, start, end, uniqueEdgeMap);
CoverageEdge edge = createEdge(coverageId, pts, start, end, uniqueEdgeMap);
// System.out.println(ringEdges.size() + " : " + edge);
ringEdges.add(edge);
start = end;
Expand All @@ -181,29 +191,37 @@ private List<CoverageEdge> extractRingEdges(LinearRing ring,
return ringEdges;
}

private CoverageEdge createEdge(Coordinate[] ring, HashMap<LineSegment, CoverageEdge> uniqueEdgeMap) {
private CoverageEdge createEdge(int coverageId, Coordinate[] ring, HashMap<LineSegment, CoverageEdge> uniqueEdgeMap) {
CoverageEdge edge;
LineSegment edgeKey = CoverageEdge.key(ring);
if (uniqueEdgeMap.containsKey(edgeKey)) {
edge = uniqueEdgeMap.get(edgeKey);
if (!coverageTolerances.isEmpty()){
edge.setTolerance((edge.getTolerance() < coverageTolerances.get(coverageId)) ? edge.getTolerance() : coverageTolerances.get(coverageId));
}
}
else {
edge = CoverageEdge.createEdge(ring);
double tolerance = coverageTolerances.isEmpty() ? -1 : coverageTolerances.get(coverageId);
edge = CoverageEdge.createEdge(ring, tolerance);
uniqueEdgeMap.put(edgeKey, edge);
edges.add(edge);
}
edge.incRingCount();
return edge;
}

private CoverageEdge createEdge(Coordinate[] ring, int start, int end, HashMap<LineSegment, CoverageEdge> uniqueEdgeMap) {
private CoverageEdge createEdge(int coverageId, Coordinate[] ring, int start, int end, HashMap<LineSegment, CoverageEdge> uniqueEdgeMap) {
CoverageEdge edge;
LineSegment edgeKey = (end == start) ? CoverageEdge.key(ring) : CoverageEdge.key(ring, start, end);
if (uniqueEdgeMap.containsKey(edgeKey)) {
edge = uniqueEdgeMap.get(edgeKey);
if (!coverageTolerances.isEmpty()){
edge.setTolerance((edge.getTolerance() < coverageTolerances.get(coverageId)) ? edge.getTolerance() : coverageTolerances.get(coverageId));
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

can this logic be factored out into a function?

}
}
else {
edge = CoverageEdge.createEdge(ring, start, end);
double tolerance = coverageTolerances.isEmpty() ? -1 : coverageTolerances.get(coverageId);
edge = CoverageEdge.createEdge(ring, start, end, tolerance);
uniqueEdgeMap.put(edgeKey, edge);
edges.add(edge);
}
Expand Down Expand Up @@ -278,7 +296,7 @@ private Set<Coordinate> findBoundaryNodes(Set<LineSegment> boundarySegments) {

/**
* Recreates the polygon coverage from the current edge values.
*
*
* @return an array of polygonal geometries representing the coverage
*/
public Geometry[] buildCoverage() {
Expand Down
Loading