Exemple #1
0
        public void TestSTBuffer()
        {
            using (var db = new PostGisTestDataConnection(TestDatabaseConnectionString))
            {
                var point1  = db.Select(() => GeometryInput.STGeomFromText("POINT(100 90)"));
                var buffer1 = db.Select(() => GeometryProcessing.STBuffer(point1, 50, "quad_segs=8").STGeometryType());
                Assert.AreEqual("ST_Polygon", buffer1);

                var buffer2 = db.Select(() => GeometryProcessing.STBuffer(point1, 50).STNPoints());
                Assert.AreEqual(33, buffer2);

                var buffer3 = db.Select(() => GeometryProcessing.STBuffer(point1, 50, 2).STNPoints());
                Assert.AreEqual(9, buffer3);

                Assert.IsNull(db.Select(() => GeometryProcessing.STBuffer(null, 0)));
                Assert.IsNull(db.Select(() => GeometryProcessing.STBuffer(null, 0, null)));

                db.TestGeographies
                .Value(g => g.Id, 1)
                .Value(g => g.Geography, () => GeometryInput.STGeogFromText("POINT(0 0)"))
                .Insert();

                var geographyPointBufferArea = db.TestGeographies
                                               .Where(g => g.Id == 1)
                                               .Select(g => g.Geography.STBuffer(50.0).STArea())
                                               .Single();

                Assert.AreEqual(7788.324, geographyPointBufferArea.Value, 1.0E-3);
            }
        }
Exemple #2
0
        public void TestSTGeneratePoints()
        {
            using (var db = new PostGisTestDataConnection(TestDatabaseConnectionString))
            {
                var version = new Version(db.Select(() => VersionFunctions.PostGISLibVersion()));
                if (version >= new Version("3.0.0"))
                {
                    // TODO: Test for 2.3.0

                    var geom1 = db.Select(() => GeometryInput.STGeomFromText("POLYGON((175 150, 20 40, 50 60, 125 100, 175 150))"));

                    var result1  = db.Select(() => GeometryProcessing.STGeneratePoints(geom1, 5, 1)) as NTSGS.MultiPoint;
                    var expected = new double[][]
                    {
                        new[] { 139.29283354478, 118.602516148805 },
                        new[] { 131.832615216622, 108.222468996999 },
                        new[] { 114.403606086077, 103.400350731553 },
                        new[] { 61.1688280123262, 67.8262881638229 },
                        new[] { 136.491955979797, 111.749696268158 },
                    };

                    Assert.AreEqual(expected.Length, result1.Coordinates.Length);
                    for (var i = 0; i < expected.Length; i++)
                    {
                        Assert.AreEqual(expected[i][0], result1.Coordinates[i].X, 1.0E-9);
                        Assert.AreEqual(expected[i][1], result1.Coordinates[i].Y, 1.0E-9);
                    }

                    Assert.IsNull(db.Select(() => GeometryProcessing.STGeneratePoints(null, 1)));
                }
            }
        }
        public void TestSTCurveToLine()
        {
            using (var db = new PostGisTestDataConnection(TestDatabaseConnectionString))
            {
                const string wkt1 = "CIRCULARSTRING(0 0,100 -100,200 0)";
                db.TestGeometries.Value(g => g.Id, 1).Value(p => p.Geometry, () => GeometryInput.STGeomFromText(wkt1)).Insert();
                var result1 = db.TestGeometries.Where(g => g.Id == 1).Select(g => g.Geometry.STCurveToLine(20, 1, 1).STAsText()).Single();
                Assert.AreEqual("LINESTRING(0 0,50 -86.6025403784438,150 -86.6025403784439,200 0)", result1);

                Assert.IsNull(db.Select(() => GeometryProcessing.STCurveToLine(null, 20, 1, 1)));
            }
        }
        public void TestSTGeneratePoints()
        {
            using (var db = new PostGisTestDataConnection(TestDatabaseConnectionString))
            {
                var geom1 = db.Select(() => GeometryInput.STGeomFromText("POLYGON((175 150, 20 40, 50 60, 125 100, 175 150))"));

                var result1 = db.Select(() => GeometryProcessing.STGeneratePoints(geom1, 5, 1).STAsText());
                Assert.AreEqual("MULTIPOINT(139.29283354478 118.602516148805,131.832615216622 108.222468996999,114.403606086077 103.400350731553,61.1688280123262 67.8262881638229,136.491955979797 111.749696268158)", result1);

                Assert.IsNull(db.Select(() => GeometryProcessing.STGeneratePoints(null, 1)));
            }
        }
        public void TestSTFlipCoordinates()
        {
            using (var db = new PostGisTestDataConnection(TestDatabaseConnectionString))
            {
                var geom1 = db.Select(() => GeometryInput.STGeomFromText("POINT(1 2)"));

                var result1 = db.Select(() => GeometryProcessing.STFlipCoordinates(geom1).STAsText());
                Assert.AreEqual("POINT(2 1)", result1);

                Assert.IsNull(db.Select(() => GeometryProcessing.STFlipCoordinates(null)));
            }
        }
        public void TestSTDelaunayTriangles()
        {
            using (var db = new PostGisTestDataConnection(TestDatabaseConnectionString))
            {
                const string wkt1 = "POLYGON((175 150, 20 40, 50 60, 125 100, 175 150))";
                db.TestGeometries.Value(g => g.Id, 1).Value(p => p.Geometry, () => GeometryInput.STGeomFromText(wkt1)).Insert();
                var result1 = db.TestGeometries.Where(g => g.Id == 1).Select(g => g.Geometry.STDelaunayTriangles(0, 0).STAsText()).Single();
                Assert.AreEqual("GEOMETRYCOLLECTION(POLYGON((20 40,125 100,50 60,20 40)),POLYGON((50 60,125 100,175 150,50 60)))", result1);

                Assert.IsNull(db.Select(() => GeometryProcessing.STDelaunayTriangles(null, 0, 0)));
            }
        }
        public void TestSTClipByBox2D()
        {
            using (var db = new PostGisTestDataConnection(TestDatabaseConnectionString))
            {
                var geom1 = db.Select(() => GeometryInput.STGeomFromText("LINESTRING(0 0, 20 20)"));
                var box1  = db.Select(() => GeometryConstructors.STMakeEnvelope(0, 0, 10, 10));

                var clipped1 = db.Select(() => GeometryProcessing.STClipByBox2D(geom1, box1).STAsText());
                Assert.AreEqual("LINESTRING(0 0,10 10)", clipped1);

                Assert.IsNull(db.Select(() => GeometryProcessing.STClipByBox2D(null, null)));
            }
        }
        public void TestSTConvexHull()
        {
            using (var db = new PostGisTestDataConnection(TestDatabaseConnectionString))
            {
                const string wkt1 = "GEOMETRYCOLLECTION( MULTILINESTRING((100 190,10 8),(150 10, 20 30)), MULTIPOINT(50 5, 150 30, 50 10, 10 10) )";
                db.TestGeometries.Value(g => g.Id, 1).Value(p => p.Geometry, () => GeometryInput.STGeomFromText(wkt1)).Insert();

                var convexHull1 = db.TestGeometries.Where(g => g.Id == 1).Select(g => g.Geometry.STConvexHull().STAsText()).Single();

                Assert.AreEqual("POLYGON((50 5,10 8,10 10,100 190,150 30,150 10,50 5))", convexHull1);

                Assert.IsNull(db.Select(() => GeometryProcessing.STConvexHull(null)));
            }
        }
        public void TestSTBuffer()
        {
            using (var db = new PostGisTestDataConnection(TestDatabaseConnectionString))
            {
                var pt1     = db.Select(() => GeometryInput.STGeomFromText("POINT(100 90)"));
                var buffer1 = db.Select(() => GeometryProcessing.STBuffer(pt1, 50, "quad_segs=8").STGeometryType());
                Assert.AreEqual("ST_Polygon", buffer1);

                var buffer2 = db.Select(() => GeometryProcessing.STBuffer(pt1, 50).STNPoints());
                Assert.AreEqual(33, buffer2);

                var buffer3 = db.Select(() => GeometryProcessing.STBuffer(pt1, 50, 2).STNPoints());
                Assert.AreEqual(9, buffer3);

                Assert.IsNull(db.Select(() => GeometryProcessing.STBuffer(null, 0)));
                Assert.IsNull(db.Select(() => GeometryProcessing.STBuffer(null, 0, null)));
            }
        }
        public void TestSTTransformText()
        {
            using (var db = new PostGisTestDataConnection(TestDatabaseConnectionString))
            {
                const string Gnom = "+proj=gnom +ellps=WGS84 +lat_0=70 +lon_0=-160 +no_defs";
                const string wkt1 = "POLYGON((170 50,170 72,-130 72,-130 50,170 50))";
                const string wkt2 = "POLYGON((-170 68,-170 90,-141 90,-141 68,-170 68))";
                db.TestGeometries.Value(g => g.Id, 1).Value(p => p.Geometry, () => GeometryInput.STGeomFromText(wkt1, SRID4326)).Insert();
                db.TestGeometries.Value(g => g.Id, 2).Value(p => p.Geometry, () => GeometryInput.STGeomFromText(wkt2, SRID4326)).Insert();

                var result = db.TestGeometries
                             .Select(g => GeometryProcessing.STIntersection(
                                         db.TestGeometries.Where(g1 => g1.Id == 1).Single().Geometry.STTransform(Gnom),
                                         db.TestGeometries.Where(g2 => g2.Id == 2).Single().Geometry.STTransform(Gnom)
                                         ).STTransform(Gnom, SRID4326)
                                     .STAsText())
                             .First();

                Assert.AreEqual("POLYGON((-170 74.053793645338,-141 73.4268621378904,-141 68,-170 68,-170 74.053793645338))", result);
            }
        }
        public void TestSTRelateBool()
        {
            using (var db = new PostGisTestDataConnection(TestDatabaseConnectionString))
            {
                const string Wkt1 = "POINT(1 2)";
                const string Wkt2 = "POINT(1 2)";

                Assert.IsTrue(db.Select(() =>
                                        GeometryInput.STGeomFromText(Wkt1)
                                        .STRelate(
                                            GeometryProcessing.STBuffer(GeometryInput.STGeomFromText(Wkt2), 2),
                                            "0FFFFF212")));

                Assert.IsNull(db.TestGeometries
                              .Where(g => g.Id == 1)
                              .Select(g => g.Geometry)
                              .Select(g => g.STRelate(
                                          GeometryProcessing.STBuffer(GeometryInput.STGeomFromText(Wkt2), 2),
                                          "0FFFFF212"
                                          )).FirstOrDefault());
            }
        }
Exemple #12
0
        public void TestSTConvexHull()
        {
            using (var db = new PostGisTestDataConnection(TestDatabaseConnectionString))
            {
                const string Wkt1 = "GEOMETRYCOLLECTION( MULTILINESTRING((100 190,10 8),(150 10, 20 30)), MULTIPOINT(50 5, 150 30, 50 10, 10 10) )";
                db.TestGeometries
                .Value(g => g.Id, 1)
                .Value(g => g.Geometry, () => GeometryInput.STGeomFromText(Wkt1))
                .Insert();

                var convexHull1 = db.TestGeometries
                                  .Where(g => g.Id == 1)
                                  .Select(g => g.Geometry.STConvexHull().STAsText())
                                  .Single();

                // TODO: need explicit cast text to geometry
                if (this.CurrentVersion >= new Version("3.0.0"))
                {
                    Assert.AreEqual("POLYGON((50 5,10 8,10 10,100 190,150 30,150 10,50 5))", convexHull1);
                    Assert.IsNull(db.Select(() => GeometryProcessing.STConvexHull((NTSG)null)));
                }
            }
        }
        public void TestSTContainsProperly()
        {
            using (var db = new PostGisTestDataConnection(TestDatabaseConnectionString))
            {
                const string Point1 = "POINT(1 1)";

                var query1 = from g1 in db.SelectQuery(() => GeometryProcessing.STBuffer(GeometryInput.STGeomFromText(Point1), 3))
                             from g2 in db.SelectQuery(() => GeometryProcessing.STBuffer(GeometryInput.STGeomFromText(Point1), 10))
                             select g2.STContainsProperly(g1);

                var result1 = query1.FirstOrDefault();
                Assert.IsNotNull(result1);
                Assert.IsTrue(result1);

                var query2 = from g1 in db.TestGeometries.Where(g => g.Id == 1)
                             from g2 in db.TestGeometries.Where(g => g.Id == 1)
                             select g2.Geometry.STContainsProperly(g1.Geometry);

                var result2 = query2.FirstOrDefault();
                Assert.IsNull(result2);

                // TODO: need explicit cast text to geometry
                if (this.CurrentVersion >= new Version("3.0.0"))
                {
                    Assert.IsTrue(
                        db.Select(() => SpatialRelationships.STContainsProperly(
                                      "POLYGON((0 0,1 0,1 1,0 1, 0 0))",
                                      "LINESTRING(0.2 0.2, 0.8 0.8)")));

                    Assert.IsFalse(
                        db.Select(() => SpatialRelationships.STContainsProperly(
                                      "POLYGON((0 0,1 0,1 1,0 1, 0 0))",
                                      "LINESTRING(0.2 0.2, 1.2 1.2)")));
                }
            }
        }