/*
* SPDX-License-Identifier: Apache-2.0
*
* The OpenSearch Contributors require contributions made to
* this file be licensed under the Apache-2.0 license or a
* compatible open source license.
*/
/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch licenses this file to you 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.
*/
/*
* Modifications Copyright OpenSearch Contributors. See
* GitHub history for details.
*/
package org.opensearch.common.geo;
import org.opensearch.common.geo.builders.CircleBuilder;
import org.opensearch.common.geo.builders.CoordinatesBuilder;
import org.opensearch.common.geo.builders.EnvelopeBuilder;
import org.opensearch.common.geo.builders.LineStringBuilder;
import org.opensearch.common.geo.builders.MultiLineStringBuilder;
import org.opensearch.common.geo.builders.PointBuilder;
import org.opensearch.common.geo.builders.PolygonBuilder;
import org.opensearch.common.geo.builders.ShapeBuilder;
import org.opensearch.geometry.LinearRing;
import org.opensearch.index.mapper.GeoShapeIndexer;
import org.opensearch.test.OpenSearchTestCase;
import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.LineString;
import org.locationtech.jts.geom.Polygon;
import org.locationtech.spatial4j.exception.InvalidShapeException;
import org.locationtech.spatial4j.shape.Circle;
import org.locationtech.spatial4j.shape.Point;
import org.locationtech.spatial4j.shape.Rectangle;
import org.locationtech.spatial4j.shape.impl.PointImpl;
import static org.opensearch.test.hamcrest.OpenSearchGeoAssertions.assertMultiLineString;
import static org.opensearch.test.hamcrest.OpenSearchGeoAssertions.assertMultiPolygon;
import static org.opensearch.test.hamcrest.OpenSearchGeoAssertions.assertPolygon;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.not;
/**
* Tests for {@link ShapeBuilder}
*/
public class ShapeBuilderTests extends OpenSearchTestCase {
public void testNewPoint() {
PointBuilder pb = new PointBuilder().coordinate(-100, 45);
Point point = pb.buildS4J();
assertEquals(-100D, point.getX(), 0.0d);
assertEquals(45D, point.getY(), 0.0d);
org.opensearch.geometry.Point geoPoint = pb.buildGeometry();
assertEquals(-100D, geoPoint.getX(), 0.0d);
assertEquals(45D, geoPoint.getY(), 0.0d);
}
public void testNewRectangle() {
EnvelopeBuilder eb = new EnvelopeBuilder(new Coordinate(-45, 30), new Coordinate(45, -30));
Rectangle rectangle = eb.buildS4J();
assertEquals(-45D, rectangle.getMinX(), 0.0d);
assertEquals(-30D, rectangle.getMinY(), 0.0d);
assertEquals(45D, rectangle.getMaxX(), 0.0d);
assertEquals(30D, rectangle.getMaxY(), 0.0d);
org.opensearch.geometry.Rectangle luceneRectangle = eb.buildGeometry();
assertEquals(-45D, luceneRectangle.getMinX(), 0.0d);
assertEquals(-30D, luceneRectangle.getMinY(), 0.0d);
assertEquals(45D, luceneRectangle.getMaxX(), 0.0d);
assertEquals(30D, luceneRectangle.getMaxY(), 0.0d);
}
public void testNewPolygon() {
PolygonBuilder pb = new PolygonBuilder(
new CoordinatesBuilder().coordinate(-45, 30).coordinate(45, 30).coordinate(45, -30).coordinate(-45, -30).coordinate(-45, 30)
);
Polygon poly = pb.toPolygonS4J();
LineString exterior = poly.getExteriorRing();
assertEquals(exterior.getCoordinateN(0), new Coordinate(-45, 30));
assertEquals(exterior.getCoordinateN(1), new Coordinate(45, 30));
assertEquals(exterior.getCoordinateN(2), new Coordinate(45, -30));
assertEquals(exterior.getCoordinateN(3), new Coordinate(-45, -30));
LinearRing polygon = pb.toPolygonGeometry().getPolygon();
assertEquals(polygon.getY(0), 30, 0d);
assertEquals(polygon.getX(0), -45, 0d);
assertEquals(polygon.getY(1), 30, 0d);
assertEquals(polygon.getX(1), 45, 0d);
assertEquals(polygon.getY(2), -30, 0d);
assertEquals(polygon.getX(2), 45, 0d);
assertEquals(polygon.getY(3), -30, 0d);
assertEquals(polygon.getX(3), -45, 0d);
}
public void testNewPolygon_coordinate() {
PolygonBuilder pb = new PolygonBuilder(
new CoordinatesBuilder().coordinate(new Coordinate(-45, 30))
.coordinate(new Coordinate(45, 30))
.coordinate(new Coordinate(45, -30))
.coordinate(new Coordinate(-45, -30))
.coordinate(new Coordinate(-45, 30))
);
Polygon poly = pb.toPolygonS4J();
LineString exterior = poly.getExteriorRing();
assertEquals(exterior.getCoordinateN(0), new Coordinate(-45, 30));
assertEquals(exterior.getCoordinateN(1), new Coordinate(45, 30));
assertEquals(exterior.getCoordinateN(2), new Coordinate(45, -30));
assertEquals(exterior.getCoordinateN(3), new Coordinate(-45, -30));
LinearRing polygon = pb.toPolygonGeometry().getPolygon();
assertEquals(polygon.getY(0), 30, 0d);
assertEquals(polygon.getX(0), -45, 0d);
assertEquals(polygon.getY(1), 30, 0d);
assertEquals(polygon.getX(1), 45, 0d);
assertEquals(polygon.getY(2), -30, 0d);
assertEquals(polygon.getX(2), 45, 0d);
assertEquals(polygon.getY(3), -30, 0d);
assertEquals(polygon.getX(3), -45, 0d);
}
public void testNewPolygon_coordinates() {
PolygonBuilder pb = new PolygonBuilder(
new CoordinatesBuilder().coordinates(
new Coordinate(-45, 30),
new Coordinate(45, 30),
new Coordinate(45, -30),
new Coordinate(-45, -30),
new Coordinate(-45, 30)
)
);
Polygon poly = pb.toPolygonS4J();
LineString exterior = poly.getExteriorRing();
assertEquals(exterior.getCoordinateN(0), new Coordinate(-45, 30));
assertEquals(exterior.getCoordinateN(1), new Coordinate(45, 30));
assertEquals(exterior.getCoordinateN(2), new Coordinate(45, -30));
assertEquals(exterior.getCoordinateN(3), new Coordinate(-45, -30));
LinearRing polygon = pb.toPolygonGeometry().getPolygon();
assertEquals(polygon.getY(0), 30, 0d);
assertEquals(polygon.getX(0), -45, 0d);
assertEquals(polygon.getY(1), 30, 0d);
assertEquals(polygon.getX(1), 45, 0d);
assertEquals(polygon.getY(2), -30, 0d);
assertEquals(polygon.getX(2), 45, 0d);
assertEquals(polygon.getY(3), -30, 0d);
assertEquals(polygon.getX(3), -45, 0d);
}
public void testLineStringBuilder() {
// Building a simple LineString
LineStringBuilder lsb = new LineStringBuilder(
new CoordinatesBuilder().coordinate(-130.0, 55.0)
.coordinate(-130.0, -40.0)
.coordinate(-15.0, -40.0)
.coordinate(-20.0, 50.0)
.coordinate(-45.0, 50.0)
.coordinate(-45.0, -15.0)
.coordinate(-110.0, -15.0)
.coordinate(-110.0, 55.0)
);
lsb.buildS4J();
buildGeometry(lsb);
// Building a linestring that needs to be wrapped
lsb = new LineStringBuilder(
new CoordinatesBuilder().coordinate(100.0, 50.0)
.coordinate(110.0, -40.0)
.coordinate(240.0, -40.0)
.coordinate(230.0, 60.0)
.coordinate(200.0, 60.0)
.coordinate(200.0, -30.0)
.coordinate(130.0, -30.0)
.coordinate(130.0, 60.0)
);
lsb.buildS4J();
buildGeometry(lsb);
// Building a lineString on the dateline
lsb = new LineStringBuilder(
new CoordinatesBuilder().coordinate(-180.0, 80.0).coordinate(-180.0, 40.0).coordinate(-180.0, -40.0).coordinate(-180.0, -80.0)
);
lsb.buildS4J();
buildGeometry(lsb);
// Building a lineString on the dateline
lsb = new LineStringBuilder(
new CoordinatesBuilder().coordinate(180.0, 80.0).coordinate(180.0, 40.0).coordinate(180.0, -40.0).coordinate(180.0, -80.0)
);
lsb.buildS4J();
buildGeometry(lsb);
}
public void testMultiLineString() {
MultiLineStringBuilder mlsb = new MultiLineStringBuilder().linestring(
new LineStringBuilder(
new CoordinatesBuilder().coordinate(-100.0, 50.0).coordinate(50.0, 50.0).coordinate(50.0, 20.0).coordinate(-100.0, 20.0)
)
)
.linestring(
new LineStringBuilder(
new CoordinatesBuilder().coordinate(-100.0, 20.0).coordinate(50.0, 20.0).coordinate(50.0, 0.0).coordinate(-100.0, 0.0)
)
);
mlsb.buildS4J();
buildGeometry(mlsb);
// LineString that needs to be wrapped
new MultiLineStringBuilder().linestring(
new LineStringBuilder(
new CoordinatesBuilder().coordinate(150.0, 60.0).coordinate(200.0, 60.0).coordinate(200.0, 40.0).coordinate(150.0, 40.0)
)
)
.linestring(
new LineStringBuilder(
new CoordinatesBuilder().coordinate(150.0, 20.0).coordinate(200.0, 20.0).coordinate(200.0, 0.0).coordinate(150.0, 0.0)
)
);
mlsb.buildS4J();
buildGeometry(mlsb);
}
public void testPolygonSelfIntersection() {
PolygonBuilder newPolygon = new PolygonBuilder(
new CoordinatesBuilder().coordinate(-40.0, 50.0).coordinate(40.0, 50.0).coordinate(-40.0, -50.0).coordinate(40.0, -50.0).close()
);
Exception e = expectThrows(InvalidShapeException.class, () -> newPolygon.buildS4J());
assertThat(e.getMessage(), containsString("Self-intersection at or near point (0.0"));
}
/** note: only supported by S4J at the moment */
public void testGeoCircle() {
double earthCircumference = 40075016.69;
Circle circle = new CircleBuilder().center(0, 0).radius("100m").buildS4J();
assertEquals((360 * 100) / earthCircumference, circle.getRadius(), 0.00000001);
assertEquals(new PointImpl(0, 0, ShapeBuilder.SPATIAL_CONTEXT), circle.getCenter());
circle = new CircleBuilder().center(+180, 0).radius("100m").buildS4J();
assertEquals((360 * 100) / earthCircumference, circle.getRadius(), 0.00000001);
assertEquals(new PointImpl(180, 0, ShapeBuilder.SPATIAL_CONTEXT), circle.getCenter());
circle = new CircleBuilder().center(-180, 0).radius("100m").buildS4J();
assertEquals((360 * 100) / earthCircumference, circle.getRadius(), 0.00000001);
assertEquals(new PointImpl(-180, 0, ShapeBuilder.SPATIAL_CONTEXT), circle.getCenter());
circle = new CircleBuilder().center(0, 90).radius("100m").buildS4J();
assertEquals((360 * 100) / earthCircumference, circle.getRadius(), 0.00000001);
assertEquals(new PointImpl(0, 90, ShapeBuilder.SPATIAL_CONTEXT), circle.getCenter());
circle = new CircleBuilder().center(0, -90).radius("100m").buildS4J();
assertEquals((360 * 100) / earthCircumference, circle.getRadius(), 0.00000001);
assertEquals(new PointImpl(0, -90, ShapeBuilder.SPATIAL_CONTEXT), circle.getCenter());
double randomLat = (randomDouble() * 180) - 90;
double randomLon = (randomDouble() * 360) - 180;
double randomRadius = randomIntBetween(1, (int) earthCircumference / 4);
circle = new CircleBuilder().center(randomLon, randomLat).radius(randomRadius + "m").buildS4J();
assertEquals((360 * randomRadius) / earthCircumference, circle.getRadius(), 0.00000001);
assertEquals(new PointImpl(randomLon, randomLat, ShapeBuilder.SPATIAL_CONTEXT), circle.getCenter());
}
public void testPolygonWrapping() {
PolygonBuilder pb = new PolygonBuilder(
new CoordinatesBuilder().coordinate(-150.0, 65.0)
.coordinate(-250.0, 65.0)
.coordinate(-250.0, -65.0)
.coordinate(-150.0, -65.0)
.close()
);
assertMultiPolygon(pb.buildS4J(), true);
assertMultiPolygon(buildGeometry(pb), false);
}
public void testLineStringWrapping() {
LineStringBuilder lsb = new LineStringBuilder(
new CoordinatesBuilder().coordinate(-150.0, 65.0)
.coordinate(-250.0, 65.0)
.coordinate(-250.0, -65.0)
.coordinate(-150.0, -65.0)
.close()
);
assertMultiLineString(lsb.buildS4J(), true);
assertMultiLineString(buildGeometry(lsb), false);
}
public void testDatelineOGC() {
// tests that the following shape (defined in counterclockwise OGC order)
// https://gist.github.com/anonymous/7f1bb6d7e9cd72f5977c crosses the dateline
// expected results: 3 polygons, 1 with a hole
// a giant c shape
PolygonBuilder builder = new PolygonBuilder(
new CoordinatesBuilder().coordinate(174, 0)
.coordinate(-176, 0)
.coordinate(-176, 3)
.coordinate(177, 3)
.coordinate(177, 5)
.coordinate(-176, 5)
.coordinate(-176, 8)
.coordinate(174, 8)
.coordinate(174, 0)
);
// 3/4 of an embedded 'c', crossing dateline once
builder.hole(
new LineStringBuilder(
new CoordinatesBuilder().coordinate(175, 1)
.coordinate(175, 7)
.coordinate(-178, 7)
.coordinate(-178, 6)
.coordinate(176, 6)
.coordinate(176, 2)
.coordinate(179, 2)
.coordinate(179, 1)
.coordinate(175, 1)
)
);
// embedded hole right of the dateline
builder.hole(
new LineStringBuilder(
new CoordinatesBuilder().coordinate(-179, 1).coordinate(-179, 2).coordinate(-177, 2).coordinate(-177, 1).coordinate(-179, 1)
)
);
assertMultiPolygon(builder.close().buildS4J(), true);
assertMultiPolygon(buildGeometry(builder.close()), false);
}
public void testDateline() {
// tests that the following shape (defined in clockwise non-OGC order)
// https://gist.github.com/anonymous/7f1bb6d7e9cd72f5977c crosses the dateline
// expected results: 3 polygons, 1 with a hole
// a giant c shape
PolygonBuilder builder = new PolygonBuilder(
new CoordinatesBuilder().coordinate(-186, 0)
.coordinate(-176, 0)
.coordinate(-176, 3)
.coordinate(-183, 3)
.coordinate(-183, 5)
.coordinate(-176, 5)
.coordinate(-176, 8)
.coordinate(-186, 8)
.coordinate(-186, 0)
);
// 3/4 of an embedded 'c', crossing dateline once
builder.hole(
new LineStringBuilder(
new CoordinatesBuilder().coordinate(-185, 1)
.coordinate(-181, 1)
.coordinate(-181, 2)
.coordinate(-184, 2)
.coordinate(-184, 6)
.coordinate(-178, 6)
.coordinate(-178, 7)
.coordinate(-185, 7)
.coordinate(-185, 1)
)
);
// embedded hole right of the dateline
builder.hole(
new LineStringBuilder(
new CoordinatesBuilder().coordinate(-179, 1).coordinate(-177, 1).coordinate(-177, 2).coordinate(-179, 2).coordinate(-179, 1)
)
);
assertMultiPolygon(builder.close().buildS4J(), true);
assertMultiPolygon(buildGeometry(builder.close()), false);
}
public void testComplexShapeWithHole() {
PolygonBuilder builder = new PolygonBuilder(
new CoordinatesBuilder().coordinate(-85.0018514, 37.1311314)
.coordinate(-85.0016645, 37.1315293)
.coordinate(-85.0016246, 37.1317069)
.coordinate(-85.0016526, 37.1318183)
.coordinate(-85.0017119, 37.1319196)
.coordinate(-85.0019371, 37.1321182)
.coordinate(-85.0019972, 37.1322115)
.coordinate(-85.0019942, 37.1323234)
.coordinate(-85.0019543, 37.1324336)
.coordinate(-85.001906, 37.1324985)
.coordinate(-85.001834, 37.1325497)
.coordinate(-85.0016965, 37.1325907)
.coordinate(-85.0016011, 37.1325873)
.coordinate(-85.0014816, 37.1325353)
.coordinate(-85.0011755, 37.1323509)
.coordinate(-85.000955, 37.1322802)
.coordinate(-85.0006241, 37.1322529)
.coordinate(-85.0000002, 37.1322307)
.coordinate(-84.9994, 37.1323001)
.coordinate(-84.999109, 37.1322864)
.coordinate(-84.998934, 37.1322415)
.coordinate(-84.9988639, 37.1321888)
.coordinate(-84.9987841, 37.1320944)
.coordinate(-84.9987208, 37.131954)
.coordinate(-84.998736, 37.1316611)
.coordinate(-84.9988091, 37.131334)
.coordinate(-84.9989283, 37.1311337)
.coordinate(-84.9991943, 37.1309198)
.coordinate(-84.9993573, 37.1308459)
.coordinate(-84.9995888, 37.1307924)
.coordinate(-84.9998746, 37.130806)
.coordinate(-85.0000002, 37.1308358)
.coordinate(-85.0004984, 37.1310658)
.coordinate(-85.0008008, 37.1311625)
.coordinate(-85.0009461, 37.1311684)
.coordinate(-85.0011373, 37.1311515)
.coordinate(-85.0016455, 37.1310491)
.coordinate(-85.0018514, 37.1311314)
);
builder.hole(
new LineStringBuilder(
new CoordinatesBuilder().coordinate(-85.0000002, 37.1317672)
.coordinate(-85.0001983, 37.1317538)
.coordinate(-85.0003378, 37.1317582)
.coordinate(-85.0004697, 37.131792)
.coordinate(-85.0008048, 37.1319439)
.coordinate(-85.0009342, 37.1319838)
.coordinate(-85.0010184, 37.1319463)
.coordinate(-85.0010618, 37.13184)
.coordinate(-85.0010057, 37.1315102)
.coordinate(-85.000977, 37.1314403)
.coordinate(-85.0009182, 37.1313793)
.coordinate(-85.0005366, 37.1312209)
.coordinate(-85.000224, 37.1311466)
.coordinate(-85.000087, 37.1311356)
.coordinate(-85.0000002, 37.1311433)
.coordinate(-84.9995021, 37.1312336)
.coordinate(-84.9993308, 37.1312859)
.coordinate(-84.9992567, 37.1313252)
.coordinate(-84.9991868, 37.1314277)
.coordinate(-84.9991593, 37.1315381)
.coordinate(-84.9991841, 37.1316527)
.coordinate(-84.9992329, 37.1317117)
.coordinate(-84.9993527, 37.1317788)
.coordinate(-84.9994931, 37.1318061)
.coordinate(-84.9996815, 37.1317979)
.coordinate(-85.0000002, 37.1317672)
)
);
assertPolygon(builder.close().buildS4J(), true);
assertPolygon(buildGeometry(builder.close()), false);
}
public void testShapeWithHoleAtEdgeEndPoints() {
PolygonBuilder builder = new PolygonBuilder(
new CoordinatesBuilder().coordinate(-4, 2)
.coordinate(4, 2)
.coordinate(6, 0)
.coordinate(4, -2)
.coordinate(-4, -2)
.coordinate(-6, 0)
.coordinate(-4, 2)
);
builder.hole(
new LineStringBuilder(
new CoordinatesBuilder().coordinate(4, 1).coordinate(4, -1).coordinate(-4, -1).coordinate(-4, 1).coordinate(4, 1)
)
);
assertPolygon(builder.close().buildS4J(), true);
assertPolygon(buildGeometry(builder.close()), false);
}
public void testShapeWithPointOnDateline() {
PolygonBuilder builder = new PolygonBuilder(
new CoordinatesBuilder().coordinate(180, 0).coordinate(176, 4).coordinate(176, -4).coordinate(180, 0)
);
assertPolygon(builder.close().buildS4J(), true);
assertPolygon(buildGeometry(builder.close()), false);
}
public void testShapeWithEdgeAlongDateline() {
// test case 1: test the positive side of the dateline
PolygonBuilder builder = new PolygonBuilder(
new CoordinatesBuilder().coordinate(180, 0).coordinate(176, 4).coordinate(180, -4).coordinate(180, 0)
);
assertPolygon(builder.close().buildS4J(), true);
assertPolygon(buildGeometry(builder.close()), false);
// test case 2: test the negative side of the dateline
builder = new PolygonBuilder(
new CoordinatesBuilder().coordinate(-176, 4).coordinate(-180, 0).coordinate(-180, -4).coordinate(-176, 4)
);
assertPolygon(builder.close().buildS4J(), true);
assertPolygon(buildGeometry(builder.close()), false);
}
public void testShapeWithBoundaryHoles() {
// test case 1: test the positive side of the dateline
PolygonBuilder builder = new PolygonBuilder(
new CoordinatesBuilder().coordinate(-177, 10)
.coordinate(176, 15)
.coordinate(172, 0)
.coordinate(176, -15)
.coordinate(-177, -10)
.coordinate(-177, 10)
);
builder.hole(
new LineStringBuilder(
new CoordinatesBuilder().coordinate(176, 10).coordinate(180, 5).coordinate(180, -5).coordinate(176, -10).coordinate(176, 10)
)
);
assertMultiPolygon(builder.close().buildS4J(), true);
assertMultiPolygon(buildGeometry(builder.close()), false);
// test case 2: test the negative side of the dateline
builder = new PolygonBuilder(
new CoordinatesBuilder().coordinate(-176, 15)
.coordinate(179, 10)
.coordinate(179, -10)
.coordinate(-176, -15)
.coordinate(-172, 0)
.close()
);
builder.hole(
new LineStringBuilder(
new CoordinatesBuilder().coordinate(-176, 10)
.coordinate(-176, -10)
.coordinate(-180, -5)
.coordinate(-180, 5)
.coordinate(-176, 10)
.close()
)
);
assertMultiPolygon(builder.close().buildS4J(), true);
assertMultiPolygon(buildGeometry(builder.close()), false);
}
public void testShapeWithTangentialHole() {
// test a shape with one tangential (shared) vertex (should pass)
PolygonBuilder builder = new PolygonBuilder(
new CoordinatesBuilder().coordinate(179, 10)
.coordinate(168, 15)
.coordinate(164, 0)
.coordinate(166, -15)
.coordinate(179, -10)
.coordinate(179, 10)
);
builder.hole(
new LineStringBuilder(
new CoordinatesBuilder().coordinate(-177, 10)
.coordinate(-178, -10)
.coordinate(-180, -5)
.coordinate(-180, 5)
.coordinate(-177, 10)
)
);
assertMultiPolygon(builder.close().buildS4J(), true);
assertMultiPolygon(buildGeometry(builder.close()), false);
}
public void testShapeWithInvalidTangentialHole() {
// test a shape with one invalid tangential (shared) vertex (should throw exception)
PolygonBuilder builder = new PolygonBuilder(
new CoordinatesBuilder().coordinate(179, 10)
.coordinate(168, 15)
.coordinate(164, 0)
.coordinate(166, -15)
.coordinate(179, -10)
.coordinate(179, 10)
);
builder.hole(
new LineStringBuilder(
new CoordinatesBuilder().coordinate(164, 0).coordinate(175, 10).coordinate(175, 5).coordinate(179, -10).coordinate(164, 0)
)
);
Exception e;
e = expectThrows(InvalidShapeException.class, () -> builder.close().buildS4J());
assertThat(e.getMessage(), containsString("interior cannot share more than one point with the exterior"));
e = expectThrows(IllegalArgumentException.class, () -> buildGeometry(builder.close()));
assertThat(e.getMessage(), containsString("interior cannot share more than one point with the exterior"));
}
public void testBoundaryShapeWithTangentialHole() {
// test a shape with one tangential (shared) vertex for each hole (should pass)
PolygonBuilder builder = new PolygonBuilder(
new CoordinatesBuilder().coordinate(-177, 10)
.coordinate(176, 15)
.coordinate(172, 0)
.coordinate(176, -15)
.coordinate(-177, -10)
.coordinate(-177, 10)
);
builder.hole(
new LineStringBuilder(
new CoordinatesBuilder().coordinate(-177, 10)
.coordinate(-178, -10)
.coordinate(-180, -5)
.coordinate(-180, 5)
.coordinate(-177, 10)
)
);
builder.hole(
new LineStringBuilder(new CoordinatesBuilder().coordinate(172, 0).coordinate(176, 10).coordinate(176, -5).coordinate(172, 0))
);
assertMultiPolygon(builder.close().buildS4J(), true);
assertMultiPolygon(buildGeometry(builder.close()), false);
}
public void testBoundaryShapeWithInvalidTangentialHole() {
// test shape with two tangential (shared) vertices (should throw exception)
PolygonBuilder builder = new PolygonBuilder(
new CoordinatesBuilder().coordinate(-177, 10)
.coordinate(176, 15)
.coordinate(172, 0)
.coordinate(176, -15)
.coordinate(-177, -10)
.coordinate(-177, 10)
);
builder.hole(
new LineStringBuilder(
new CoordinatesBuilder().coordinate(-177, 10)
.coordinate(172, 0)
.coordinate(180, -5)
.coordinate(176, -10)
.coordinate(-177, 10)
)
);
Exception e;
e = expectThrows(InvalidShapeException.class, () -> builder.close().buildS4J());
assertThat(e.getMessage(), containsString("interior cannot share more than one point with the exterior"));
e = expectThrows(IllegalArgumentException.class, () -> buildGeometry(builder.close()));
assertThat(e.getMessage(), containsString("interior cannot share more than one point with the exterior"));
}
/**
* Test an enveloping polygon around the max mercator bounds
*/
public void testBoundaryShape() {
PolygonBuilder builder = new PolygonBuilder(
new CoordinatesBuilder().coordinate(-180, 90).coordinate(180, 90).coordinate(180, -90).coordinate(-180, 90)
);
assertPolygon(builder.close().buildS4J(), true);
assertPolygon(buildGeometry(builder.close()), false);
}
public void testShapeWithAlternateOrientation() {
// cw: should produce a multi polygon spanning hemispheres
PolygonBuilder builder = new PolygonBuilder(
new CoordinatesBuilder().coordinate(180, 0).coordinate(176, 4).coordinate(-176, 4).coordinate(180, 0)
);
assertPolygon(builder.close().buildS4J(), true);
assertPolygon(buildGeometry(builder.close()), false);
// cw: geo core will convert to ccw across the dateline
builder = new PolygonBuilder(new CoordinatesBuilder().coordinate(180, 0).coordinate(-176, 4).coordinate(176, 4).coordinate(180, 0));
assertMultiPolygon(builder.close().buildS4J(), true);
assertMultiPolygon(buildGeometry(builder.close()), false);
}
public void testInvalidShapeWithConsecutiveDuplicatePoints() {
PolygonBuilder builder = new PolygonBuilder(
new CoordinatesBuilder().coordinate(180, 0).coordinate(176, 4).coordinate(176, 4).coordinate(-176, 4).coordinate(180, 0)
);
Exception e = expectThrows(InvalidShapeException.class, () -> builder.close().buildS4J());
assertThat(e.getMessage(), containsString("duplicate consecutive coordinates at: ("));
e = expectThrows(InvalidShapeException.class, () -> buildGeometry(builder.close()));
assertThat(e.getMessage(), containsString("duplicate consecutive coordinates at: ("));
}
public void testPolygon3D() {
String expected = "{\n"
+ " \"type\" : \"polygon\",\n"
+ " \"orientation\" : \"right\",\n"
+ " \"coordinates\" : [\n"
+ " [\n"
+ " [\n"
+ " -45.0,\n"
+ " 30.0,\n"
+ " 100.0\n"
+ " ],\n"
+ " [\n"
+ " 45.0,\n"
+ " 30.0,\n"
+ " 75.0\n"
+ " ],\n"
+ " [\n"
+ " 45.0,\n"
+ " -30.0,\n"
+ " 77.0\n"
+ " ],\n"
+ " [\n"
+ " -45.0,\n"
+ " -30.0,\n"
+ " 101.0\n"
+ " ],\n"
+ " [\n"
+ " -45.0,\n"
+ " 30.0,\n"
+ " 110.0\n"
+ " ]\n"
+ " ]\n"
+ " ]\n"
+ "}";
PolygonBuilder pb = new PolygonBuilder(
new CoordinatesBuilder().coordinate(new Coordinate(-45, 30, 100))
.coordinate(new Coordinate(45, 30, 75))
.coordinate(new Coordinate(45, -30, 77))
.coordinate(new Coordinate(-45, -30, 101))
.coordinate(new Coordinate(-45, 30, 110))
);
assertEquals(expected, pb.toString());
}
public void testInvalidSelfCrossingPolygon() {
PolygonBuilder builder = new PolygonBuilder(
new CoordinatesBuilder().coordinate(0, 0)
.coordinate(0, 2)
.coordinate(1, 1.9)
.coordinate(0.5, 1.8)
.coordinate(1.5, 1.8)
.coordinate(1, 1.9)
.coordinate(2, 2)
.coordinate(2, 0)
.coordinate(0, 0)
);
Exception e = expectThrows(InvalidShapeException.class, () -> builder.close().buildS4J());
assertThat(e.getMessage(), containsString("Self-intersection at or near point ["));
assertThat(e.getMessage(), not(containsString("NaN")));
e = expectThrows(InvalidShapeException.class, () -> buildGeometry(builder.close()));
assertThat(e.getMessage(), containsString("Self-intersection at or near point ["));
assertThat(e.getMessage(), not(containsString("NaN")));
}
public Object buildGeometry(ShapeBuilder<?, ?, ?> builder) {
return new GeoShapeIndexer(true, "name").prepareForIndexing(builder.buildGeometry());
}
}