You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
442 lines
17 KiB
442 lines
17 KiB
/*
|
|
* Copyright 2006 Google Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.google.common.geometry;
|
|
|
|
import com.google.common.collect.Lists;
|
|
|
|
import java.util.List;
|
|
import java.util.logging.Logger;
|
|
|
|
/**
|
|
* Tests for {@link S2Loop}.
|
|
*
|
|
*/
|
|
public strictfp class S2PolygonBuilderTest extends GeometryTestCase {
|
|
private static final Logger log = Logger.getLogger(S2PolygonBuilderTest.class.getCanonicalName());
|
|
|
|
// A chain represents either a polyline or a loop, depending
|
|
// on whether "closed" is true.
|
|
private class Chain {
|
|
String str;
|
|
boolean closed;
|
|
|
|
public Chain(String str, boolean closed) {
|
|
this.str = str;
|
|
this.closed = closed;
|
|
}
|
|
}
|
|
|
|
private class TestCase {
|
|
// +1 = undirected, -1 = directed, 0 = either one
|
|
int undirectedEdges;
|
|
|
|
// +1 = XOR, -1 = don't XOR, 0 = either one
|
|
int xorEdges;
|
|
|
|
// Minimum and maximum merge distances for this test case in degrees.
|
|
double minMerge;
|
|
double maxMerge;
|
|
|
|
// Each test case consists of a set of input loops and polylines.
|
|
Chain[] chainsIn;
|
|
|
|
// The expected set of output loops, directed appropriately.
|
|
String[] loopsOut;
|
|
|
|
// The expected number of unused edges.
|
|
int numUnusedEdges;
|
|
|
|
public TestCase(int undirectedEdges,
|
|
int xorEdges,
|
|
double minMerge,
|
|
double maxMerge,
|
|
Chain[] chainsIn,
|
|
String[] loopsOut,
|
|
int numUnusedEdges) {
|
|
this.undirectedEdges = undirectedEdges;
|
|
this.xorEdges = xorEdges;
|
|
this.minMerge = minMerge;
|
|
this.maxMerge = maxMerge;
|
|
this.chainsIn = chainsIn;
|
|
this.loopsOut = loopsOut;
|
|
this.numUnusedEdges = numUnusedEdges;
|
|
}
|
|
}
|
|
|
|
TestCase[] testCases = new TestCase[] {
|
|
// 0: No loops.
|
|
new TestCase(0, 0, 0.0, 10.0, new Chain[] {new Chain(null, false)}, new String[] {}, 0),
|
|
|
|
// 1: One loop with some extra edges.
|
|
new TestCase(0,
|
|
0,
|
|
0.0,
|
|
4.0,
|
|
new Chain[] {new Chain("0:0, 0:10, 10:5", true), new Chain("0:0, 5:5", false),
|
|
new Chain("10:5, 20:7, 30:10, 40:15, 50:3, 60:-20", false)},
|
|
new String[] {"0:0, 0:10, 10:5"},
|
|
6),
|
|
|
|
// 2: One loop that has an edge removed by XORing, plus lots of
|
|
// extra edges.
|
|
new TestCase(0, 1, 0.0, 1.0, // XOR
|
|
new Chain[] {new Chain("0:0, 0:10, 5:15, 10:10, 10:0", true),
|
|
new Chain("10:10, 12:12, 14:14, 16:16, 18:18", false),
|
|
new Chain("14:14, 14:16, 14:18, 14:20", false),
|
|
new Chain("14:18, 16:20, 18:22", false),
|
|
new Chain("18:12, 16:12, 14:12, 12:12", false),
|
|
new Chain("20:18, 18:16, 16:14, 14:12", false),
|
|
new Chain("20:14, 18:14, 16:14", false),
|
|
new Chain("5:15, 0:10", false)},
|
|
new String[] {},
|
|
21),
|
|
|
|
// 3: Three loops (two shells and one hole) that combine into one.
|
|
new TestCase(0, 1, 0.0, 4.0, // XOR
|
|
new Chain[] {new Chain("0:0, 0:10, 5:10, 10:10, 10:5, 10:0", true),
|
|
new Chain("0:10, 0:15, 5:15, 5:10", true),
|
|
new Chain("10:10, 5:10, 5:5, 10:5", true), },
|
|
new String[] {"0:0, 0:10, 0:15, 5:15, 5:10, 5:5, 10:5, 10:0"},
|
|
0),
|
|
|
|
// 4: A big CCW triangle contained 3 CW triangular holes. The whole thing
|
|
// looks like a pyramid of nine small triangles (with two extra edges).
|
|
new TestCase(-1, 0, 0.0, 0.9, // Directed edges required for unique result.
|
|
new Chain[] {new Chain("0:0, 0:2, 0:4, 0:6, 1:5, 2:4, 3:3, 2:2, 1:1", true),
|
|
new Chain("0:2, 1:1, 1:3", true),
|
|
new Chain("0:4, 1:3, 1:5", true),
|
|
new Chain("1:3, 2:2, 2:4", true),
|
|
new Chain("0:0, 0:1", false),
|
|
new Chain("1:3, 5:7", false)},
|
|
new String[] {"0:0, 0:2, 1:1",
|
|
"0:2, 0:4, 1:3",
|
|
"0:4, 0:6, 1:5",
|
|
"1:1, 1:3, 2:2",
|
|
"1:3, 1:5, 2:4",
|
|
"2:2, 2:4, 3:3"},
|
|
2),
|
|
|
|
// 5: A square divided into four subsquares. In this case we want
|
|
// to extract the four loops rather than taking their union.
|
|
// There are four extra edges as well.
|
|
new TestCase(0, -1, 0.0, 4.0, // Don't XOR
|
|
new Chain[] {new Chain("0:0, 0:5, 5:5, 5:0", true),
|
|
new Chain("0:5, 0:10, 5:10, 5:5", true),
|
|
new Chain("5:0, 5:5, 10:5, 10:0", true),
|
|
new Chain("5:5, 5:10, 10:10, 10:5", true),
|
|
new Chain("0:10, 0:15, 0:20", false),
|
|
new Chain("20:0, 15:0, 10:0", false)},
|
|
new String[] {"0:0, 0:5, 5:5, 5:0", "0:5, 0:10, 5:10, 5:5", "5:0, 5:5, 10:5, 10:0",
|
|
"5:5, 5:10, 10:10, 10:5"},
|
|
4),
|
|
|
|
// 6: Five nested loops that touch at a point.
|
|
new TestCase(0,
|
|
0,
|
|
0.0,
|
|
0.8,
|
|
new Chain[] {new Chain("0:0, 0:10, 10:10, 10:0", true),
|
|
new Chain("0:0, 1:9, 9:9, 9:1", true), new Chain("0:0, 2:8, 8:8, 8:2", true),
|
|
new Chain("0:0, 3:7, 7:7, 7:3", true), new Chain("0:0, 4:6, 6:6, 6:4", true)},
|
|
new String[] {"0:0, 0:10, 10:10, 10:0", "0:0, 1:9, 9:9, 9:1", "0:0, 2:8, 8:8, 8:2",
|
|
"0:0, 3:7, 7:7, 7:3", "0:0, 4:6, 6:6, 6:4"},
|
|
0),
|
|
|
|
|
|
// 7: Four diamonds nested within each other touching at two points.
|
|
new TestCase(-1, 0, 0.0, 4.0, // Directed edges required for unique result.
|
|
new Chain[] {new Chain("0:-20, -10:0, 0:20, 10:0", true),
|
|
new Chain("0:10, -10:0, 0:-10, 10:0", true),
|
|
new Chain("0:-10, -5:0, 0:10, 5:0", true), new Chain("0:5, -5:0, 0:-5, 5:0", true)},
|
|
new String[] {"0:-20, -10:0, 0:-10, 10:0", "0:-10, -5:0, 0:-5, 5:0",
|
|
"0:5, -5:0, 0:10, 5:0", "0:10, -10:0, 0:20, 10:0"},
|
|
0),
|
|
|
|
// 8: Seven diamonds nested within each other touching at one
|
|
// point between each nested pair.
|
|
new TestCase(0,
|
|
0,
|
|
0.0,
|
|
9.0,
|
|
new Chain[] {new Chain("0:-70, -70:0, 0:70, 70:0", true),
|
|
new Chain("0:-70, -60:0, 0:60, 60:0", true),
|
|
new Chain("0:-50, -60:0, 0:50, 50:0", true),
|
|
new Chain("0:-40, -40:0, 0:50, 40:0", true),
|
|
new Chain("0:-30, -30:0, 0:30, 40:0", true),
|
|
new Chain("0:-20, -20:0, 0:30, 20:0", true),
|
|
new Chain("0:-10, -20:0, 0:10, 10:0", true)},
|
|
new String[] {"0:-70, -70:0, 0:70, 70:0",
|
|
"0:-70, -60:0, 0:60, 60:0",
|
|
"0:-50, -60:0, 0:50, 50:0",
|
|
"0:-40, -40:0, 0:50, 40:0",
|
|
"0:-30, -30:0, 0:30, 40:0",
|
|
"0:-20, -20:0, 0:30, 20:0",
|
|
"0:-10, -20:0, 0:10, 10:0"},
|
|
0),
|
|
|
|
// 9: A triangle and a self-intersecting bowtie.
|
|
new TestCase(0,
|
|
0,
|
|
0.0,
|
|
4.0,
|
|
new Chain[] {new Chain("0:0, 0:10, 5:5", true), new Chain("0:20, 0:30, 10:20", false),
|
|
new Chain("10:20, 10:30, 0:20", false)},
|
|
new String[] {"0:0, 0:10, 5:5"},
|
|
4),
|
|
|
|
// 10: Two triangles that intersect each other.
|
|
new TestCase(0,
|
|
0,
|
|
0.0,
|
|
2.0,
|
|
new Chain[] {new Chain("0:0, 0:10, 5:5", true), new Chain("2:2, 2:12, 7:7", true)},
|
|
new String[] {},
|
|
6),
|
|
|
|
// 11: Four squares that combine to make a big square. The nominal
|
|
// edges of the square are at +/-8.5 degrees in latitude and longitude.
|
|
// All vertices except the center vertex are perturbed by up to 0.5
|
|
// degrees in latitude and/or longitude. The various copies of the
|
|
// center vertex are misaligned by more than this (i.e. they are
|
|
// structured as a tree where adjacent vertices are separated by at
|
|
// most 1 degree in latitude and/or longitude) so that the clustering
|
|
// algorithm needs more than one iteration to find them all. Note that
|
|
// the merged position of this vertex doesn't matter because it is XORed
|
|
// away in the output.
|
|
new TestCase(0, 1, 1.5, 5.8, // XOR, min_merge > sqrt(2), max_merge < 6.
|
|
new Chain[] {new Chain("-8:-8, -8:0", false),
|
|
new Chain("-8:1, -8:8", false),
|
|
new Chain("0:-9, -2:0", false),
|
|
new Chain("-1:1, 1:9", false),
|
|
new Chain("0:8, 2:2", false),
|
|
new Chain("0:-2, 1:-8", false),
|
|
new Chain("8:9, 9:1", false),
|
|
new Chain("9:0, 8:-9", false),
|
|
new Chain("9:-9, 0:-8", false),
|
|
new Chain("1:-9, -9:-9", false),
|
|
new Chain("8:0, 1:0", false),
|
|
new Chain("1:2, -8:0", false),
|
|
new Chain("-8:1, 1:-1", false),
|
|
new Chain("0:1, 8:1", false),
|
|
new Chain("-9:8, 1:8", false),
|
|
new Chain("0:9, 8:8", false)},
|
|
new String[] {"8.5:8.5, 8.5:0.5, 8.5:-8.5, 0.5:-8.5, "
|
|
+ "-8.5:-8.5, -8.5:0.5, -8.5:8.5, 0.5:8.5"},
|
|
0)};
|
|
|
|
private void getVertices(String str,
|
|
S2Point x,
|
|
S2Point y,
|
|
S2Point z,
|
|
double maxPerturbation,
|
|
List<S2Point> vertices) {
|
|
|
|
// Parse the vertices, perturb them if desired, and transform them into the
|
|
// given frame.
|
|
S2Polyline line = makePolyline(str);
|
|
|
|
for (int i = 0; i < line.numVertices(); ++i) {
|
|
S2Point p = line.vertex(i);
|
|
// (p[0]*x + p[1]*y + p[2]*z).Normalize()
|
|
S2Point axis = S2Point.normalize(
|
|
S2Point.add(S2Point.add(S2Point.mul(x, p.x), S2Point.mul(y, p.y)), S2Point.mul(z, p.z)));
|
|
S2Cap cap = S2Cap.fromAxisAngle(axis, S1Angle.radians(maxPerturbation));
|
|
vertices.add(samplePoint(cap));
|
|
}
|
|
}
|
|
|
|
private boolean loopsEqual(S2Loop a, S2Loop b, double maxError) {
|
|
// Return true if two loops have the same cyclic vertex sequence.
|
|
|
|
if (a.numVertices() != b.numVertices()) {
|
|
return false;
|
|
}
|
|
for (int offset = 0; offset < a.numVertices(); ++offset) {
|
|
if (S2.approxEquals(a.vertex(offset), b.vertex(0), maxError)) {
|
|
boolean success = true;
|
|
for (int i = 0; i < a.numVertices(); ++i) {
|
|
if (!S2.approxEquals(a.vertex(i + offset), b.vertex(i), maxError)) {
|
|
success = false;
|
|
break;
|
|
}
|
|
}
|
|
if (success) {
|
|
return true;
|
|
}
|
|
// Otherwise continue looping. There may be more than one candidate
|
|
// starting offset since vertices are only matched approximately.
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private boolean findLoop(S2Loop loop, List<S2Loop> candidates, double maxError) {
|
|
for (int i = 0; i < candidates.size(); ++i) {
|
|
if (loopsEqual(loop, candidates.get(i), maxError)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
boolean findMissingLoops(
|
|
List<S2Loop> actual, List<S2Loop> expected, double maxError, String label) {
|
|
// Dump any loops from "actual" that are not present in "expected".
|
|
boolean found = false;
|
|
for (int i = 0; i < actual.size(); ++i) {
|
|
if (findLoop(actual.get(i), expected, maxError)) {
|
|
continue;
|
|
}
|
|
System.err.print(label + " loop " + i + ":\n");
|
|
S2Loop loop = actual.get(i);
|
|
for (int j = 0; j < loop.numVertices(); ++j) {
|
|
S2Point p = loop.vertex(j);
|
|
System.err.print(" [" + p.x + ", " + p.y + ", " + p.z + "]\n");
|
|
}
|
|
found = true;
|
|
}
|
|
return found;
|
|
}
|
|
|
|
void addChain(Chain chain,
|
|
S2Point x,
|
|
S2Point y,
|
|
S2Point z,
|
|
double maxPerturbation,
|
|
S2PolygonBuilder builder) {
|
|
|
|
// Transform the given edge chain to the frame (x,y,z), perturb each vertex
|
|
// up to the given distance, and add it to the builder.
|
|
|
|
List<S2Point> vertices = Lists.newArrayList();
|
|
getVertices(chain.str, x, y, z, maxPerturbation, vertices);
|
|
if (chain.closed) {
|
|
vertices.add(vertices.get(0));
|
|
}
|
|
for (int i = 1; i < vertices.size(); ++i) {
|
|
builder.addEdge(vertices.get(i - 1), vertices.get(i));
|
|
}
|
|
}
|
|
|
|
boolean evalTristate(int state) {
|
|
return (state > 0) ? true : (state < 0) ? false : (rand.nextDouble() > 0.5);
|
|
}
|
|
|
|
boolean testBuilder(TestCase test) {
|
|
for (int iter = 0; iter < 200; ++iter) {
|
|
// Initialize to the default options, which are changed below
|
|
S2PolygonBuilder.Options options = S2PolygonBuilder.Options.DIRECTED_XOR;
|
|
|
|
options.setUndirectedEdges(evalTristate(test.undirectedEdges));
|
|
options.setXorEdges(evalTristate(test.xorEdges));
|
|
|
|
// Each test has a minimum and a maximum merge distance. The merge
|
|
// distance must be at least the given minimum to ensure that all expected
|
|
// merging will take place, and it must be at most the given maximum to
|
|
// ensure that no unexpected merging takes place.
|
|
//
|
|
// If the minimum and maximum values are different, we have some latitude
|
|
// to perturb the vertices as long as the merge distance is adjusted
|
|
// appropriately. If "p" is the maximum perturbation distance, "min" and
|
|
// "max" are the min/max merge distances, and "m" is the actual merge
|
|
// distance for this test, we require that
|
|
//
|
|
// x >= min + 2*p and x <= max - 2*p .
|
|
//
|
|
// This implies that p <= 0.25 * (max - min). We choose "p" so that it is
|
|
// zero half of the time, and otherwise chosen randomly up to this limit.
|
|
|
|
double minMerge = S1Angle.degrees(test.minMerge).radians();
|
|
double maxMerge = S1Angle.degrees(test.maxMerge).radians();
|
|
double r = Math.max(0.0, 2 * rand.nextDouble() - 1);
|
|
double maxPerturbation = r * 0.25 * (maxMerge - minMerge);
|
|
|
|
// Now we set the merge distance chosen randomly within the limits above
|
|
// (min + 2*p and max - 2*p). Half of the time we set the merge distance
|
|
// to the minimum value.
|
|
|
|
r = Math.max(0.0, 2 * rand.nextDouble() - 1);
|
|
options.setMergeDistance(S1Angle.radians(
|
|
minMerge + 2 * maxPerturbation + r * (maxMerge - minMerge - 4 * maxPerturbation)));
|
|
|
|
options.setValidate(true);
|
|
S2PolygonBuilder builder = new S2PolygonBuilder(options);
|
|
|
|
// On each iteration we randomly rotate the test case around the sphere.
|
|
// This causes the S2PolygonBuilder to choose different first edges when
|
|
// trying to build loops.
|
|
S2Point x = randomPoint();
|
|
S2Point y = S2Point.normalize(S2Point.crossProd(x, randomPoint()));
|
|
S2Point z = S2Point.normalize(S2Point.crossProd(x, y));
|
|
|
|
for (Chain chain : test.chainsIn) {
|
|
addChain(chain, x, y, z, maxPerturbation, builder);
|
|
}
|
|
List<S2Loop> loops = Lists.newArrayList();
|
|
List<S2Edge> unusedEdges = Lists.newArrayList();
|
|
if (test.xorEdges < 0) {
|
|
builder.assembleLoops(loops, unusedEdges);
|
|
} else {
|
|
S2Polygon polygon = new S2Polygon();
|
|
builder.assemblePolygon(polygon, unusedEdges);
|
|
polygon.release(loops);
|
|
}
|
|
List<S2Loop> expected = Lists.newArrayList();
|
|
for (String loop : test.loopsOut) {
|
|
List<S2Point> vertices = Lists.newArrayList();
|
|
getVertices(loop, x, y, z, 0, vertices);
|
|
expected.add(new S2Loop(vertices));
|
|
}
|
|
// We assume that the vertex locations in the expected output polygon
|
|
// are separated from the corresponding vertex locations in the input
|
|
// edges by at most half of the minimum merge distance. Essentially
|
|
// this means that the expected output vertices should be near the
|
|
// centroid of the various input vertices.
|
|
double maxError = 0.5 * minMerge + maxPerturbation;
|
|
|
|
// Note single "|" below so that we print both sets of loops.
|
|
if (findMissingLoops(loops, expected, maxError, "Actual")
|
|
| findMissingLoops(expected, loops, maxError, "Expected")) {
|
|
System.err.print(
|
|
"During iteration " + iter + ", undirected: " + options.getUndirectedEdges() + ", xor: "
|
|
+ options.getXorEdges() + "\n\n");
|
|
return false;
|
|
}
|
|
if (unusedEdges.size() != test.numUnusedEdges) {
|
|
System.err.print("Wrong number of unused edges: " + unusedEdges.size() + "%d (should be "
|
|
+ test.numUnusedEdges + ")\n");
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void testAssembleLoops() {
|
|
boolean success = true;
|
|
for (int i = 0; i < testCases.length; ++i) {
|
|
log.info("Starting test case " + i);
|
|
|
|
boolean caseSuccess = testBuilder(testCases[i]);
|
|
|
|
log.info("Test case " + i + " finished: " + ((caseSuccess) ? "SUCCESS" : "FAILED"));
|
|
|
|
success &= caseSuccess;
|
|
}
|
|
assertTrue(success);
|
|
}
|
|
}
|