Add Polygon constructors and createPolygon functionality (#134)

* Add createPolygon with single argument and update Polygon constructor

New createPolygon function allows creation of polygons without user
specified holes. Polygon constructor added to convert a LinearRing
to Polygon. Polygon constructor that takes a pointer limited by type.

* Add tests for Polygon constructors - ERROR thrown

Create a test file for GEOSGeom constructors found in geos_types.jl.
Tests pass for Polygon constructed from vectors, but an "illegal
instruction" error is thrown when one is constructed from a pointer.
The error messages mentions destroyGeom. There are more tests below
for constructing from a linear ring but these depend on the pointer
constructor and thus cause a seg fault.

* Add cloneGeom around pointers in Polygon constructor and finish tests

Adding cloneGeom around pointers sent to Polygon constructor that takes
in a pointer has stopped the tests from seg faulting. All desired
Polygon constructors and createPolygon functionality added and tested.

* Fix requested pull request changes

Typo in comments, remove magic numbers, change variable name

Author: skygering

examples/readme_examples.ipynb

@@ -443,6 +443,9 @@ function createPolygon(
     end
     result
 end
+# convenience function to create polygon without holes
+createPolygon(shell::GEOSGeom, context::GEOSContext = _context) =
+    createPolygon(shell, GEOSGeom[], context)
 
 function createCollection(
     geomtype::GEOSGeomTypes,

src/geos_functions.jl

@@ -74,20 +74,34 @@ end
 
 mutable struct Polygon <: AbstractGeometry
     ptr::GEOSGeom
-
+    # create polygon using GEOSGeom pointer - only makes sense if pointer points to a polygon or a linear ring to start with. 
     function Polygon(ptr::GEOSGeom)
-        polygon = new(ptr)
+        id = LibGEOS.geomTypeId(ptr)
+        if id == GEOS_POLYGON
+            polygon = new(cloneGeom(ptr))
+        elseif id == GEOS_LINEARRING
+            polygon = new(cloneGeom(createPolygon(ptr)))
+        else
+            error("LibGEOS: Can't convert a pointer to an element with a GeomType ID of $id to a polygon (yet). Please open an issue if you think this conversion makes sense. ")
+        end
         finalizer(destroyGeom, polygon)
         polygon
     end
+    # using vector of coordinates in following form:
+    # [[exterior], [hole1], [hole2], ...] where exterior and holeN are coordinates where the first and last point are the same
     function Polygon(coords::Vector{Vector{Vector{Float64}}})
         exterior = createLinearRing(coords[1])
         interiors = GEOSGeom[createLinearRing(lr) for lr in coords[2:end]]
         polygon = new(createPolygon(exterior, interiors))
         finalizer(destroyGeom, polygon)
         polygon
     end
-
+    # using 1 linear ring to form polygon with no holes - linear ring will be outer boundary of polygon
+    Polygon(ring::LinearRing) = Polygon(ring.ptr)
+    # using multiple linear rings to form polygon with holes - exterior linear ring will be polygon boundary and list of interior linear rings will form holes
+    Polygon(exterior::LinearRing, holes::Vector{LinearRing}) = 
+        Polygon(createPolygon(exterior.ptr, 
+                              GEOSGeom[ring.ptr for ring in holes]))
 end
 
 mutable struct MultiPolygon <: AbstractGeometry

src/geos_types.jl

@@ -14,6 +14,7 @@ if version != LibGEOS.GEOS_CAPI_VERSION
 end
 
 @testset "LibGEOS" begin
+    include("test_geos_types.jl")
     include("test_geos_functions.jl")
     include("test_geos_operations.jl")
     include("test_geo_interface.jl")

test/runtests.jl

@@ -90,6 +90,14 @@ end
     @test LibGEOS.getCoordinates(LibGEOS.getCoordSeq(interiors[2])) ==
           Vector{Float64}[[8, 1], [9, 1], [9, 2], [8, 2], [8, 1]]
 
+    exterior_poly = LibGEOS.createPolygon(exterior)
+    @test LibGEOS.getGeomDimensions(exterior_poly) == 2
+    @test LibGEOS.geomTypeId(exterior_poly) == LibGEOS.GEOS_POLYGON
+    @test LibGEOS.geomArea(exterior_poly) ≈ 100.0 atol = 1e-5
+    @test_throws ErrorException LibGEOS.interiorRing(exterior_poly, 1)
+    @test LibGEOS.equals(LibGEOS.exteriorRing(exterior_poly), exterior)
+
+
     # Interpolation and Projection
     ls = LibGEOS.createLineString(Vector{Float64}[[8, 1], [9, 1], [9, 2], [8, 2]])
     pt = LibGEOS.interpolate(ls, 2.5)

test/test_geos_functions.jl

@@ -0,0 +1,83 @@
+@testset "GEOS types" begin
+    @testset "Polygon" begin
+        # Test polygon made from vectors
+        poly_vec = LibGEOS.Polygon([
+            [[-2.0, -2.0], [2.0, -2.0], [2.0, 2.0], [-2.0,2.0], [-2.0, -2.0]],
+            [[0.0, 0.0], [1.0, 1.0], [1.0,0.0], [0.0, 0.0]]])
+        @test LibGEOS.isValid(poly_vec)
+        @test LibGEOS.area(poly_vec) == 15.5
+        @test !LibGEOS.isEmpty(poly_vec)
+        @test LibGEOS.geomTypeId(poly_vec.ptr) == 3
+        @test LibGEOS.getGeomDimensions(poly_vec.ptr) == 2
+        @test LibGEOS.GeoInterface.coordinates(poly_vec) == 
+            [[[-2.0, -2.0], [2.0, -2.0], [2.0, 2.0], [-2.0,2.0], [-2.0, -2.0]],
+             [[0.0, 0.0], [1.0, 1.0], [1.0,0.0], [0.0, 0.0]]]
+        @test length(LibGEOS.interiorRings(poly_vec)) == 1
+
+        # Test polygon made from  polygon pointer
+        poly_ptr = LibGEOS.Polygon(poly_vec.ptr)
+        @test LibGEOS.isValid(poly_ptr)
+        @test LibGEOS.equals(poly_vec, poly_ptr) # same area and coordinates
+        @test LibGEOS.geomTypeId(poly_vec.ptr) == 3
+        @test LibGEOS.getGeomDimensions(poly_vec.ptr) == 2
+        @test length(LibGEOS.interiorRings(poly_vec)) == 1
+
+        # Test polygon made from linear ring pointer
+        ring_ext = LibGEOS.LinearRing([[-2.0, -2.0], [2.0, -2.0], [2.0, 2.0],
+                                       [-2.0, 2.0], [-2.0, -2.0]])
+        poly_ringptr = LibGEOS.Polygon(ring_ext.ptr)
+        # These change when made into polygon - compare below
+        @test LibGEOS.geomTypeId(ring_ext.ptr) == 2
+        @test LibGEOS.getGeomDimensions(ring_ext.ptr) == 1
+
+        @test LibGEOS.isValid(poly_ringptr)
+        @test LibGEOS.area(poly_ringptr) == 16
+        @test !LibGEOS.isEmpty(poly_ringptr)
+        @test LibGEOS.geomTypeId(poly_ringptr.ptr) == 3
+        @test LibGEOS.getGeomDimensions(poly_ringptr.ptr) == 2
+
+        # Test polygon made from point pointer
+        point = LibGEOS.Point(1.0, 2.0)
+        @test_throws ErrorException LibGEOS.Polygon(point.ptr)
+
+        # Test polygon made from 1 linear ring
+        poly_ring = LibGEOS.Polygon(ring_ext)
+        @test LibGEOS.isValid(poly_ring)
+        @test LibGEOS.area(poly_ring) == 16
+        @test !LibGEOS.isEmpty(poly_ring)
+        @test LibGEOS.geomTypeId(poly_ring.ptr) == 3
+        @test LibGEOS.getGeomDimensions(poly_ring.ptr) == 2
+        @test LibGEOS.GeoInterface.coordinates(poly_ring) == 
+            [[[-2.0, -2.0], [2.0, -2.0], [2.0, 2.0], [-2.0, 2.0], [-2.0, -2.0]]]
+        @test length(LibGEOS.interiorRings(poly_ring)) == 0
+
+        # Test polygon made from multiple linear rings (exterior and interior)
+        ring_int1 = LibGEOS.LinearRing([[0.0, 0.0], [1.0, 1.0], [1.0,0.0],
+                                        [0.0, 0.0]])
+        ring_int2 = LibGEOS.LinearRing([[0.0, 0.0], [0.0, -1.0], [-1.0, -1.0],
+                                        [-1.0, 0.0], [0.0, 0.0]])
+
+        #1 ring
+        poly_rings1 = LibGEOS.Polygon(ring_ext, [ring_int1])
+        @test LibGEOS.isValid(poly_rings1)
+        @test LibGEOS.geomTypeId(poly_rings1.ptr) == 3
+        @test LibGEOS.getGeomDimensions(poly_rings1.ptr) == 2
+        @test length(LibGEOS.interiorRings(poly_rings1)) == 1
+        @test LibGEOS.equals(poly_rings1, poly_vec)
+
+        #2 rings
+        poly_rings2 = LibGEOS.Polygon(ring_ext, [ring_int1, ring_int2])
+
+        @test LibGEOS.isValid(poly_rings2)
+        @test LibGEOS.area(poly_rings2) == 14.5
+        @test !LibGEOS.isEmpty(poly_rings2)
+        @test LibGEOS.geomTypeId(poly_rings2.ptr) == 3
+        @test LibGEOS.getGeomDimensions(poly_rings2.ptr) == 2
+        @test LibGEOS.GeoInterface.coordinates(poly_rings2) == 
+            [[[-2.0, -2.0], [2.0, -2.0], [2.0, 2.0], [-2.0, 2.0], [-2.0, -2.0]],
+            [[0.0, 0.0], [1.0, 1.0], [1.0,0.0],[0.0, 0.0]],
+             [[0.0, 0.0], [0.0, -1.0], [-1.0, -1.0],[-1.0, 0.0], [0.0, 0.0]]]
+        @test length(LibGEOS.interiorRings(poly_rings2)) == 2
+    end
+
+end