예제 #1
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldFindByTableAndCode()
        internal virtual void ShouldFindByTableAndCode()
        {
            assertThat(CoordinateReferenceSystem.Get(1, 4326), equalTo(CoordinateReferenceSystem.Wgs84));
            assertThat(CoordinateReferenceSystem.Get(1, 4979), equalTo(CoordinateReferenceSystem.Wgs84_3d));
            assertThat(CoordinateReferenceSystem.Get(2, 7203), equalTo(CoordinateReferenceSystem.Cartesian));
            assertThat(CoordinateReferenceSystem.Get(2, 9157), equalTo(CoordinateReferenceSystem.Cartesian_3D));
        }
예제 #2
0
 /// <summary>
 /// Creates a PointValue, and enforces consistency between the CRS and coordinate dimensions.
 /// </summary>
 public static PointValue PointValue(CoordinateReferenceSystem crs, params double[] coordinate)
 {
     if (crs.Dimension != coordinate.Length)
     {
         throw new System.ArgumentException(format("Cannot create point, CRS %s expects %d dimensions, but got coordinates %s", crs, crs.Dimension, Arrays.ToString(coordinate)));
     }
     return(new PointValue(crs, coordinate));
 }
예제 #3
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldCalculateCartesianDistance3D()
        internal virtual void ShouldCalculateCartesianDistance3D()
        {
            CoordinateReferenceSystem crs = CoordinateReferenceSystem.Cartesian_3D;

            assertThat("", crs.Calculator.distance(Cart(0.0, 0.0, 0.0), Cart(1.0, 0.0, 0.0)), equalTo(1.0));
            assertThat("", crs.Calculator.distance(Cart(0.0, 0.0, 0.0), Cart(0.0, 1.0, 0.0)), equalTo(1.0));
            assertThat("", crs.Calculator.distance(Cart(0.0, 0.0, 0.0), Cart(0.0, 0.0, 1.0)), equalTo(1.0));
            assertThat("", crs.Calculator.distance(Cart(0.0, 0.0, 0.0), Cart(0.0, 1.0, 1.0)), closeTo(1.41, 0.01));
            assertThat("", crs.Calculator.distance(Cart(0.0, 0.0, 0.0), Cart(1.0, 1.0, 1.0)), closeTo(1.73, 0.01));
            assertThat("", crs.Calculator.distance(Cart(-1000000.0, -1000000.0, -1000000.0), Cart(1000000.0, 1000000.0, 1000000.0)), closeTo(3464102.0, 1.0));
        }
예제 #4
0
 internal PointValue(CoordinateReferenceSystem crs, params double[] coordinate)
 {
     this._crs        = crs;
     this._coordinate = coordinate;
     foreach (double c in coordinate)
     {
         if (!Double.isFinite(c))
         {
             throw new InvalidValuesArgumentException("Cannot create a point with non-finite coordinate values: " + Arrays.ToString(coordinate));
         }
     }
 }
예제 #5
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldCalculateCartesianDistance()
        internal virtual void ShouldCalculateCartesianDistance()
        {
            CoordinateReferenceSystem crs = CoordinateReferenceSystem.Cartesian;

            assertThat("", crs.Calculator.distance(Cart(0.0, 0.0), Cart(0.0, 1.0)), equalTo(1.0));
            assertThat("", crs.Calculator.distance(Cart(0.0, 0.0), Cart(1.0, 0.0)), equalTo(1.0));
            assertThat("", crs.Calculator.distance(Cart(0.0, 0.0), Cart(1.0, 1.0)), closeTo(1.4, 0.02));
            assertThat("", crs.Calculator.distance(Cart(0.0, 0.0), Cart(0.0, -1.0)), equalTo(1.0));
            assertThat("", crs.Calculator.distance(Cart(0.0, 0.0), Cart(-1.0, 0.0)), equalTo(1.0));
            assertThat("", crs.Calculator.distance(Cart(0.0, 0.0), Cart(-1.0, -1.0)), closeTo(1.4, 0.02));
            assertThat("", crs.Calculator.distance(Cart(1.0, 0.0), Cart(0.0, -1.0)), closeTo(1.4, 0.02));
            assertThat("", crs.Calculator.distance(Cart(1.0, 0.0), Cart(-1.0, 0.0)), equalTo(2.0));
            assertThat("", crs.Calculator.distance(Cart(1.0, 0.0), Cart(-1.0, -1.0)), closeTo(2.24, 0.01));
            assertThat("", crs.Calculator.distance(Cart(-1000000.0, -1000000.0), Cart(1000000.0, 1000000.0)), closeTo(2828427.0, 1.0));
        }
예제 #6
0
        public override bool Equals(object o)
        {
            if (this == o)
            {
                return(true);
            }
            if (o == null || this.GetType() != o.GetType())
            {
                return(false);
            }

            CoordinateReferenceSystem that = ( CoordinateReferenceSystem )o;

            return(_href.Equals(that._href));
        }
예제 #7
0
            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))));
            }
예제 #8
0
//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));
        }
예제 #9
0
//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));
        }
예제 #10
0
        private static CoordinateReferenceSystem FindSpecifiedCRS(PointBuilder fields)
        {
            string crsValue  = fields.Crs;
            int    sridValue = fields.Srid;

            if (!string.ReferenceEquals(crsValue, null) && sridValue != -1)
            {
                throw new InvalidValuesArgumentException("Cannot specify both CRS and SRID");
            }
            else if (!string.ReferenceEquals(crsValue, null))
            {
                return(CoordinateReferenceSystem.ByName(crsValue));
            }
            else if (sridValue != -1)
            {
                return(CoordinateReferenceSystem.Get(sridValue));
            }
            else
            {
                return(null);
            }
        }
예제 #11
0
            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)));
            }
예제 #12
0
 public static CoordinateReferenceSystem Crs(CRS crs)
 {
     return(CoordinateReferenceSystem.Get(crs));
 }
예제 #13
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldFailToGetWithIncorrectCode()
        internal virtual void ShouldFailToGetWithIncorrectCode()
        {
            InvalidValuesArgumentException exception = assertThrows(typeof(InvalidValuesArgumentException), () => CoordinateReferenceSystem.Get(42));

            assertEquals("Unknown coordinate reference system code: 42", exception.Message);
        }
예제 #14
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldGetCrsByCode()
        internal virtual void ShouldGetCrsByCode()
        {
            assertEquals(Cartesian, CoordinateReferenceSystem.get(Cartesian.Code));
            assertEquals(WGS84, CoordinateReferenceSystem.get(WGS84.Code));
        }
예제 #15
0
        private PointValue Geo(params double[] coords)
        {
            CoordinateReferenceSystem crs = coords.Length == 3 ? CoordinateReferenceSystem.Cartesian_3D : CoordinateReferenceSystem.Cartesian;

            return(Values.PointValue(crs, coords));
        }
예제 #16
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void writePoint(CoordinateReferenceSystem crs, double[] coordinate) throws E
        public override void WritePoint(CoordinateReferenceSystem crs, double[] coordinate)
        {           // no-op
        }
예제 #17
0
 /// <summary>
 /// Unlike pointValue(), this method does not enforce consistency between the CRS and coordinate dimensions.
 /// This can be useful for testing.
 /// </summary>
 public static PointValue UnsafePointValue(CoordinateReferenceSystem crs, params double[] coordinate)
 {
     return(new PointValue(crs, coordinate));
 }
예제 #18
0
            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)));
                    }
                }
            }
예제 #19
0
        /// <summary>
        /// The string representation of this object when indexed in string-only indexes, like lucene, for equality search only. This should normally only
        /// happen when points are part of composite indexes, because otherwise they are indexed in the spatial index.
        /// </summary>
        public virtual string ToIndexableString()
        {
            CoordinateReferenceSystem crs = CoordinateReferenceSystem;

            return(format("P:%d-%d%s", crs.Table.TableId, crs.Code, Arrays.ToString(_coordinate)));
        }
예제 #20
0
 public override void WritePoint(CoordinateReferenceSystem crs, double[] coordinate)
 {
     Buffer.Add(new PointValue(crs, coordinate));
 }
예제 #21
0
        /// <summary>
        /// This contains the logic to decide the default coordinate reference system based on the input fields
        /// </summary>
        private static PointValue FromInputFields(PointBuilder fields)
        {
            CoordinateReferenceSystem crs = FindSpecifiedCRS(fields);

            double[] coordinates;

            if (fields.X != null && fields.Y != null)
            {
                coordinates = fields.Z != null ? new double[] { fields.X.Value, fields.Y.Value, fields.Z.Value } : new double[] { fields.X.Value, fields.Y.Value };
                if (crs == null)
                {
                    crs = coordinates.Length == 3 ? CoordinateReferenceSystem.Cartesian_3D : CoordinateReferenceSystem.Cartesian;
                }
            }
            else if (fields.Latitude != null && fields.Longitude != null)
            {
                if (fields.Z != null)
                {
                    coordinates = new double[] { fields.Longitude.Value, fields.Latitude.Value, fields.Z.Value };
                }
                else if (fields.Height != null)
                {
                    coordinates = new double[] { fields.Longitude.Value, fields.Latitude.Value, fields.Height.Value };
                }
                else
                {
                    coordinates = new double[] { fields.Longitude.Value, fields.Latitude.Value };
                }
                if (crs == null)
                {
                    crs = coordinates.Length == 3 ? CoordinateReferenceSystem.Wgs84_3d : CoordinateReferenceSystem.Wgs84;
                }
                if (!crs.Geographic)
                {
                    throw new InvalidValuesArgumentException("Geographic points does not support coordinate reference system: " + crs + ". This is set either in the csv header or the actual data column");
                }
            }
            else
            {
                if (crs == CoordinateReferenceSystem.Cartesian)
                {
                    throw new InvalidValuesArgumentException("A " + CoordinateReferenceSystem.Cartesian.Name + " point must contain 'x' and 'y'");
                }
                else if (crs == CoordinateReferenceSystem.Cartesian_3D)
                {
                    throw new InvalidValuesArgumentException("A " + CoordinateReferenceSystem.Cartesian_3D.Name + " point must contain 'x', 'y' and 'z'");
                }
                else if (crs == CoordinateReferenceSystem.Wgs84)
                {
                    throw new InvalidValuesArgumentException("A " + CoordinateReferenceSystem.Wgs84.Name + " point must contain 'latitude' and 'longitude'");
                }
                else if (crs == CoordinateReferenceSystem.Wgs84_3d)
                {
                    throw new InvalidValuesArgumentException("A " + CoordinateReferenceSystem.Wgs84_3d.Name + " point must contain 'latitude', 'longitude' and 'height'");
                }
                throw new InvalidValuesArgumentException("A point must contain either 'x' and 'y' or 'latitude' and 'longitude'");
            }

            if (crs.Dimension != coordinates.Length)
            {
                throw new InvalidValuesArgumentException("Cannot create point with " + crs.Dimension + "D coordinate reference system and " + coordinates.Length + " coordinates. Please consider using equivalent " + coordinates.Length + "D coordinate reference system");
            }
            return(Values.PointValue(crs, coordinates));
        }
예제 #22
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void writePoint(CoordinateReferenceSystem crs, double[] coordinate) throws E
        public override void WritePoint(CoordinateReferenceSystem crs, double[] coordinate)
        {
            throw Exception("writePoint");
        }