//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldBeAbleToParseWeirdlyFormattedPoints()
internal virtual void ShouldBeAbleToParseWeirdlyFormattedPoints()
{
assertEqual(pointValue(WGS84, 1.0, 2.0), PointValue.Parse(" \t\n { latitude : 2.0 ,longitude :1.0 } \t"));
// TODO: Should some/all of these fail?
assertEqual(pointValue(WGS84, 1.0, 2.0), PointValue.Parse(" \t\n { latitude : 2.0 ,longitude :1.0 , } \t"));
assertEqual(pointValue(Cartesian, 2.0E-8, -1.0E7), PointValue.Parse(" \t\n { x :+.2e-7,y: -1.0E07 , } \t"));
assertEqual(pointValue(Cartesian, 2.0E-8, -1.0E7), PointValue.Parse(" \t\n { x :+.2e-7,y: -1.0E07 , garbage} \t"));
assertEqual(pointValue(Cartesian, 2.0E-8, -1.0E7), PointValue.Parse(" \t\n { gar ba ge,x :+.2e-7,y: -1.0E07} \t"));
}
public static PointArray PointArray(Point[] points)
{
PointValue[] values = new PointValue[points.Length];
for (int i = 0; i < points.Length; i++)
{
values[i] = Values.Point(points[i]);
}
return(new PointArray(values));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldBeAbleToParseIncompletePointWithHeaderInformation()
internal virtual void ShouldBeAbleToParseIncompletePointWithHeaderInformation()
{
string headerInformation = "{latitude: 40.7128}";
string data = "{longitude: -74.0060, height: 567.8, crs:wgs-84-3D}";
assertThrows(typeof(InvalidValuesArgumentException), () => PointValue.Parse(data));
// this should work
PointValue.Parse(data, PointValue.ParseHeaderInformation(headerInformation));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static <E extends Exception> void writeTo(ValueWriter<E> writer, org.neo4j.graphdb.spatial.Point[] values) throws E
public static void WriteTo <E>(ValueWriter <E> writer, Point[] values) where E : Exception
{
writer.BeginArray(values.Length, ValueWriter_ArrayType.Point);
foreach (Point x in values)
{
PointValue value = Values.Point(x);
writer.WritePoint(value.CoordinateReferenceSystem, value.Coordinate());
}
writer.EndArray();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldBeAbleToParsePointThatOverridesHeaderInformation()
internal virtual void ShouldBeAbleToParsePointThatOverridesHeaderInformation()
{
string headerInformation = "{crs:wgs-84}";
string data = "{latitude: 40.7128, longitude: -74.0060, height: 567.8, crs:wgs-84-3D}";
PointValue expected = PointValue.Parse(data);
PointValue actual = PointValue.Parse(data, PointValue.ParseHeaderInformation(headerInformation));
assertEqual(expected, actual);
assertEquals("wgs-84-3d", actual.CoordinateReferenceSystem.Name.ToLower());
}
//-------------------------------------------------------------
// Parser tests
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldBeAbleToParsePoints()
internal virtual void ShouldBeAbleToParsePoints()
{
assertEqual(pointValue(WGS84, 13.2, 56.7), PointValue.Parse("{latitude: 56.7, longitude: 13.2}"));
assertEqual(pointValue(WGS84, -74.0060, 40.7128), PointValue.Parse("{latitude: 40.7128, longitude: -74.0060, crs: 'wgs-84'}")); // - explicitly WGS84
assertEqual(pointValue(Cartesian, -21, -45.3), PointValue.Parse("{x: -21, y: -45.3}")); // - default to cartesian 2D
assertEqual(pointValue(WGS84, -21, -45.3), PointValue.Parse("{x: -21, y: -45.3, srid: 4326}")); // - explicitly set WGS84 by SRID
assertEqual(pointValue(Cartesian, 17, -52.8), PointValue.Parse("{x: 17, y: -52.8, crs: 'cartesian'}")); // - explicit cartesian 2D
assertEqual(pointValue(WGS84_3D, 13.2, 56.7, 123.4), PointValue.Parse("{latitude: 56.7, longitude: 13.2, height: 123.4}")); // - defaults to WGS84-3D
assertEqual(pointValue(WGS84_3D, 13.2, 56.7, 123.4), PointValue.Parse("{latitude: 56.7, longitude: 13.2, z: 123.4}")); // - defaults to WGS84-3D
assertEqual(pointValue(WGS84_3D, -74.0060, 40.7128, 567.8), PointValue.Parse("{latitude: 40.7128, longitude: -74.0060, height: 567.8, crs: 'wgs-84-3D'}")); // - explicitly WGS84-3D
assertEqual(pointValue(Cartesian_3D, -21, -45.3, 7.2), PointValue.Parse("{x: -21, y: -45.3, z: 7.2}")); // - default to cartesian 3D
assertEqual(pointValue(Cartesian_3D, 17, -52.8, -83.1), PointValue.Parse("{x: 17, y: -52.8, z: -83.1, crs: 'cartesian-3D'}")); // - explicit cartesian 3D
}
public static PointArray PointArray(Value[] maybePoints)
{
PointValue[] values = new PointValue[maybePoints.Length];
for (int i = 0; i < maybePoints.Length; i++)
{
Value maybePoint = maybePoints[i];
if (!(maybePoint is PointValue))
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
throw new System.ArgumentException(format("[%s:%s] is not a supported point value", maybePoint, maybePoint.GetType().FullName));
}
values[i] = Values.Point(( PointValue )maybePoint);
}
return(PointArray(values));
}
public override IList <Pair <PointValue, PointValue> > BoundingBox(PointValue center, double distance)
{
Debug.Assert(center.CoordinateReferenceSystem.Dimension == Dimension);
double[] coordinates = center.Coordinate();
double[] min = new double[Dimension];
double[] max = new double[Dimension];
for (int i = 0; i < Dimension; i++)
{
min[i] = coordinates[i] - distance;
max[i] = coordinates[i] + distance;
}
CoordinateReferenceSystem crs = center.CoordinateReferenceSystem;
return(Collections.singletonList(Pair.of(Values.PointValue(crs, min), Values.PointValue(crs, max))));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldCalculateGeographicDistance3D()
internal virtual void ShouldCalculateGeographicDistance3D()
{
CoordinateReferenceSystem crs = CoordinateReferenceSystem.Wgs84_3d;
//"distance function should measure distance from Copenhagen train station to Neo4j in Malmö"
PointValue cph = Geo(12.564590, 55.672874, 0.0);
PointValue cphHigh = Geo(12.564590, 55.672874, 1000.0);
PointValue malmo = Geo(12.994341, 55.611784, 0.0);
PointValue malmoHigh = Geo(12.994341, 55.611784, 1000.0);
double expected = 27842.0;
double expectedHigh = 27862.0;
assertThat("3D distance should match", crs.Calculator.distance(cph, malmo), closeTo(expected, 0.1));
assertThat("3D distance should match", crs.Calculator.distance(cph, malmoHigh), closeTo(expectedHigh, 0.2));
assertThat("3D distance should match", crs.Calculator.distance(cphHigh, malmo), closeTo(expectedHigh, 0.2));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldCalculateGeographicDistance()
internal virtual void ShouldCalculateGeographicDistance()
{
CoordinateReferenceSystem crs = CoordinateReferenceSystem.Wgs84;
assertThat("2D distance should match", crs.Calculator.distance(Geo(0.0, 0.0), Geo(0.0, 90.0)), closeTo(10000000.0, 20000.0));
assertThat("2D distance should match", crs.Calculator.distance(Geo(0.0, 0.0), Geo(0.0, -90.0)), closeTo(10000000.0, 20000.0));
assertThat("2D distance should match", crs.Calculator.distance(Geo(0.0, -45.0), Geo(0.0, 45.0)), closeTo(10000000.0, 20000.0));
assertThat("2D distance should match", crs.Calculator.distance(Geo(-45.0, 0.0), Geo(45.0, 0.0)), closeTo(10000000.0, 20000.0));
assertThat("2D distance should match", crs.Calculator.distance(Geo(-45.0, 0.0), Geo(45.0, 0.0)), closeTo(10000000.0, 20000.0));
//"distance function should measure distance from Copenhagen train station to Neo4j in Malmö"
PointValue cph = Geo(12.564590, 55.672874);
PointValue malmo = Geo(12.994341, 55.611784);
double expected = 27842.0;
assertThat("2D distance should match", crs.Calculator.distance(cph, malmo), closeTo(expected, 0.1));
}
public override double Distance(PointValue p1, PointValue p2)
{
Debug.Assert(p1.CoordinateReferenceSystem.Dimension == Dimension);
Debug.Assert(p2.CoordinateReferenceSystem.Dimension == Dimension);
double[] c1Coord = p1.Coordinate();
double[] c2Coord = p2.Coordinate();
double[] c1 = new double[] { toRadians(c1Coord[0]), toRadians(c1Coord[1]) };
double[] c2 = new double[] { toRadians(c2Coord[0]), toRadians(c2Coord[1]) };
double dx = c2[0] - c1[0];
double dy = c2[1] - c1[1];
double alpha = pow(sin(dy / 2), 2.0) + cos(c1[1]) * cos(c2[1]) * pow(sin(dx / 2.0), 2.0);
double greatCircleDistance = 2.0 * atan2(sqrt(alpha), sqrt(1 - alpha));
if (Dimension == 2)
{
return(EARTH_RADIUS_METERS * greatCircleDistance);
}
else if (Dimension == 3)
{
// get average height
double avgHeight = (p1.Coordinate()[2] + p2.Coordinate()[2]) / 2;
double distance2D = (EARTH_RADIUS_METERS + avgHeight) * greatCircleDistance;
double[] a = new double[Dimension - 1];
double[] b = new double[Dimension - 1];
a[0] = distance2D;
b[0] = 0.0;
for (int i = 1; i < Dimension - 1; i++)
{
a[i] = 0.0;
b[i] = c1Coord[i + 1] - c2Coord[i + 1];
}
return(Pythagoras(a, b));
}
else
{
// The above calculation works for more than 3D if all higher dimensions are orthogonal to the 3rd dimension.
// This might not be true in the general case, and so until we genuinely support higher dimensions fullstack
// we will explicitly disabled them here for now.
throw new System.NotSupportedException("More than 3 dimensions are not supported for distance calculations.");
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldComparePointWithinTwoBoundsExhaustive()
public virtual void ShouldComparePointWithinTwoBoundsExhaustive()
{
for (int minx = -5; minx < 5; minx++)
{
for (int maxx = -5; maxx < 5; maxx++)
{
for (int miny = -5; miny < 5; miny++)
{
for (int maxy = -5; maxy < 5; maxy++)
{
PointValue min = pointValue(Cartesian, minx, miny);
PointValue max = pointValue(Cartesian, maxx, maxy);
for (int x = -5; x < 5; x++)
{
for (int y = -5; y < 5; y++)
{
PointValue point = pointValue(Cartesian, x, y);
bool invalidRange = minx > maxx || miny > maxy;
bool undefinedMin = x > minx && y <miny || y> miny && x < minx;
bool undefinedMax = x <maxx && y> maxy || y <maxy && x> maxx;
bool? ii = (invalidRange || undefinedMin || undefinedMax) ? null : x >= minx && y >= miny && x <= maxx && y <= maxy;
bool? ix = (invalidRange || undefinedMin || undefinedMax) ? null : x >= minx && y >= miny && x < maxx && y < maxy;
bool? xi = (invalidRange || undefinedMin || undefinedMax) ? null : x > minx && y > miny && x <= maxx && y <= maxy;
bool? xx = (invalidRange || undefinedMin || undefinedMax) ? null : x > minx && y > miny && x < maxx && y < maxy;
// inclusive:inclusive
assertThat("{" + x + "," + y + "}.withinRange({" + minx + "," + miny + "}, true, {" + maxx + "," + maxy + "}, true", point.WithinRange(min, true, max, true), equalTo(ii));
// inclusive:exclusive
assertThat("{" + x + "," + y + "}.withinRange({" + minx + "," + miny + "}, true, {" + maxx + "," + maxy + "}, false", point.WithinRange(min, true, max, false), equalTo(ix));
// exclusive:inclusive
assertThat("{" + x + "," + y + "}.withinRange({" + minx + "," + miny + "}, false, {" + maxx + "," + maxy + "}, true", point.WithinRange(min, false, max, true), equalTo(xi));
// exclusive:exclusive
assertThat("{" + x + "," + y + "}.withinRange({" + minx + "," + miny + "}, false, {" + maxx + "," + maxy + "}, false", point.WithinRange(min, false, max, false), equalTo(xx));
}
}
}
}
}
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldBeAbleToParsePointWithUnquotedCrs()
internal virtual void ShouldBeAbleToParsePointWithUnquotedCrs()
{
assertEqual(pointValue(WGS84_3D, -74.0060, 40.7128, 567.8), PointValue.Parse("{latitude: 40.7128, longitude: -74.0060, height: 567.8, crs:wgs-84-3D}")); // - explicitly WGS84-3D, without quotes
}
internal abstract Value get(PointValue value);
public static PointValue MaxPointValue(PointValue reference)
{
double[] coordinates = new double[reference.Coordinate().Length];
Arrays.fill(coordinates, double.MaxValue);
return(PointValue(reference.CoordinateReferenceSystem, coordinates));
}
private InvalidValuesArgumentException AssertCannotParse(string text)
{
return(assertThrows(typeof(InvalidValuesArgumentException), () => PointValue.Parse(text)));
}
public override double Distance(PointValue p1, PointValue p2)
{
Debug.Assert(p1.CoordinateReferenceSystem.Dimension == Dimension);
Debug.Assert(p2.CoordinateReferenceSystem.Dimension == Dimension);
return(Pythagoras(p1.Coordinate(), p2.Coordinate()));
}
public abstract IList <Pair <PointValue, PointValue> > BoundingBox(PointValue center, double distance);
public abstract double Distance(PointValue p1, PointValue p2);
internal virtual Pair <PointValue, PointValue> BoundingBoxOf(double minLon, double maxLon, double minLat, double maxLat, PointValue center, double distance)
{
CoordinateReferenceSystem crs = center.CoordinateReferenceSystem;
int dimension = center.CoordinateReferenceSystem.Dimension;
double[] min = new double[dimension];
double[] max = new double[dimension];
min[0] = minLon;
min[1] = minLat;
max[0] = maxLon;
max[1] = maxLat;
if (dimension > 2)
{
double[] coordinates = center.Coordinate();
for (int i = 2; i < dimension; i++)
{
min[i] = coordinates[i] - distance;
max[i] = coordinates[i] + distance;
}
}
return(Pair.of(Values.PointValue(crs, min), Values.PointValue(crs, max)));
}
public override IList <Pair <PointValue, PointValue> > BoundingBox(PointValue center, double distance)
{
if (distance == 0.0)
{
return(Collections.singletonList(Pair.of(center, center)));
}
// Extend the distance slightly to assure that all relevant points lies inside the bounding box,
// with rounding errors taken into account
double extendedDistance = distance * EXTENSION_FACTOR;
CoordinateReferenceSystem crs = center.CoordinateReferenceSystem;
double lat = center.Coordinate()[1];
double lon = center.Coordinate()[0];
double r = extendedDistance / EARTH_RADIUS_METERS;
double latMin = lat - toDegrees(r);
double latMax = lat + toDegrees(r);
// If your query circle includes one of the poles
if (latMax >= 90)
{
return(Collections.singletonList(BoundingBoxOf(-180, 180, latMin, 90, center, distance)));
}
else if (latMin <= -90)
{
return(Collections.singletonList(BoundingBoxOf(-180, 180, -90, latMax, center, distance)));
}
else
{
double deltaLon = toDegrees(asin(sin(r) / cos(toRadians(lat))));
double lonMin = lon - deltaLon;
double lonMax = lon + deltaLon;
// If you query circle wraps around the dateline
if (lonMin < -180 && lonMax > 180)
{
// Large rectangle covering all longitudes
return(Collections.singletonList(BoundingBoxOf(-180, 180, latMin, latMax, center, distance)));
}
else if (lonMin < -180)
{
// two small rectangles east and west of dateline
Pair <PointValue, PointValue> box1 = BoundingBoxOf(lonMin + 360, 180, latMin, latMax, center, distance);
Pair <PointValue, PointValue> box2 = BoundingBoxOf(-180, lonMax, latMin, latMax, center, distance);
return(Arrays.asList(box1, box2));
}
else if (lonMax > 180)
{
// two small rectangles east and west of dateline
Pair <PointValue, PointValue> box1 = BoundingBoxOf(lonMin, 180, latMin, latMax, center, distance);
Pair <PointValue, PointValue> box2 = BoundingBoxOf(-180, lonMax - 360, latMin, latMax, center, distance);
return(Arrays.asList(box1, box2));
}
else
{
return(Collections.singletonList(BoundingBoxOf(lonMin, lonMax, latMin, latMax, center, distance)));
}
}
}
