Fixed LineString coordinates. Added more tests.

Author: evetion

src/GeometryBasics.jl

@@ -1,6 +1,7 @@
 module GeometryBasics
 
-using StaticArrays, Tables, StructArrays, IterTools, LinearAlgebra, GeoInterface
+using StaticArrays, Tables, StructArrays, IterTools, LinearAlgebra
+using GeoInterface: GeoInterface
 using EarCut_jll
 
 using Base: @propagate_inbounds

src/basic_types.jl

@@ -57,7 +57,6 @@ Fixed Size Polygon, e.g.
 - ...
 """
 struct Ngon{Dim,T<:Real,N,Point<:AbstractPoint{Dim,T}} <: AbstractPolygon{Dim,T}
-
     points::SVector{N,Point}
 end
 
@@ -137,7 +136,6 @@ It applies to infinite dimensions. The structure of this type is designed
 to allow embedding in higher-order spaces by parameterizing on `T`.
 """
 struct Simplex{Dim,T<:Real,N,Point<:AbstractPoint{Dim,T}} <: Polytope{Dim,T}
-
     points::SVector{N,Point}
 end
 
@@ -328,7 +326,6 @@ Base.size(mp::MultiPolygon) = size(mp.polygons)
 
 struct MultiLineString{Dim,T<:Real,Element<:LineString{Dim,T},A<:AbstractVector{Element}} <:
        AbstractVector{Element}
-
     linestrings::A
 end
 
@@ -347,7 +344,6 @@ A collection of points
 """
 struct MultiPoint{Dim,T<:Real,P<:AbstractPoint{Dim,T},A<:AbstractVector{P}} <:
        AbstractVector{P}
-
     points::A
 end
 

src/geointerface.jl

@@ -30,13 +30,15 @@ GeoInterface.getcoord(::GeoInterface.PointTrait, g::Point, i::Int) = g[i]
 GeoInterface.ngeom(::GeoInterface.LineTrait, g::Line) = length(g)
 GeoInterface.getgeom(::GeoInterface.LineTrait, g::Line, i::Int) = g[i]
 
-GeoInterface.ngeom(::GeoInterface.LineStringTrait, g::LineString) = length(g)
+GeoInterface.ngeom(::GeoInterface.LineStringTrait, g::LineString) = length(g) + 1  # n line segments + 1
 function GeoInterface.getgeom(::GeoInterface.LineStringTrait, g::LineString, i::Int)
-    return coordinates(g)[i]
+    return GeometryBasics.coordinates(g)[i]
 end
 
 GeoInterface.ngeom(::GeoInterface.PolygonTrait, g::Polygon) = length(g.interiors) + 1  # +1 for exterior
-function GeoInterface.getgeom(::GeoInterface.PolygonTrait, g::Polygon, i::Int)
+function GeoInterface.getgeom(::GeoInterface.PolygonTrait,
+                              g::Polygon,
+                              i::Int)::typeof(g.exterior)
     return i > 1 ? g.interiors[i - 1] : g.exterior
 end
 
@@ -66,9 +68,12 @@ function GeoInterface.ngeom(::GeoInterface.AbstractGeometryTrait,
                             ::Simplex{Dim,T,N,P}) where {Dim,T,N,P}
     return N
 end
-GeoInterface.ngeom(::PolygonTrait, ::Ngon) = 1  # can't have any holes
-GeoInterface.getgeom(::PolygonTrait, g::Ngon, _) = LineString(g.points)
+GeoInterface.ngeom(::GeoInterface.PolygonTrait, ::Ngon) = 1  # can't have any holes
+GeoInterface.getgeom(::GeoInterface.PolygonTrait, g::Ngon, _) = LineString(g.points)
 
-GeoInterface.ncoord(::PolyhedralSurfaceTrait, ::Mesh{Dim,T,E,V} where {Dim,T,E,V}) = Dim
-GeoInterface.ngeom(::PolyhedralSurfaceTrait, g::AbstractMesh) = length(g)
-GeoInterface.getgeom(::PolyhedralSurfaceTrait, g::AbstractMesh, i) = g[i]
+function GeoInterface.ncoord(::GeoInterface.PolyhedralSurfaceTrait,
+                             ::Mesh{Dim,T,E,V} where {Dim,T,E,V})
+    return Dim
+end
+GeoInterface.ngeom(::GeoInterface.PolyhedralSurfaceTrait, g::AbstractMesh) = length(g)
+GeoInterface.getgeom(::GeoInterface.PolyhedralSurfaceTrait, g::AbstractMesh, i) = g[i]

test/geointerface.jl

@@ -1,24 +1,44 @@
 @testset "Basic types" begin
     point = Point(2, 3)
     GeoInterface.testgeometry(point)
+    @test GeoInterface.ncoord(point) == 2
+    @test GeoInterface.getcoord(point, 2) == 3
+    @test GeoInterface.coordinates(point) == [2, 3]
 
     mp = MultiPoint([point, point])
     GeoInterface.testgeometry(mp)
+    @test GeoInterface.ngeom(mp) == 2
+    @test GeoInterface.getgeom(mp, 2) == point
+    @test GeoInterface.coordinates(mp) == [[2, 3], [2, 3]]
 
     linestring = LineString(Point{2,Int}[(10, 10), (20, 20), (10, 40)])
     GeoInterface.testgeometry(linestring)
+    @test GeoInterface.ngeom(linestring) == 3
+    @test GeoInterface.getgeom(linestring, 1) == Point(10, 10)
+    @test GeoInterface.getgeom(linestring, 2) == Point(20, 20)
+    @test GeoInterface.getgeom(linestring, 3) == Point(10, 40)
+    @test GeoInterface.coordinates(linestring) == [[10, 10], [20, 20], [10, 40]]
 
     multilinestring = MultiLineString([linestring, linestring])
     GeoInterface.testgeometry(multilinestring)
+    @test GeoInterface.coordinates(multilinestring) ==
+          [[[10, 10], [20, 20], [10, 40]], [[10, 10], [20, 20], [10, 40]]]
 
-    poly = Polygon(rand(Point{2,Float32}, 5))
+    poly = Polygon(rand(Point{2,Float32}, 5), [rand(Point{2,Float32}, 5)])
     GeoInterface.testgeometry(poly)
+    @test length(GeoInterface.coordinates(poly)) == 2
+    @test length(GeoInterface.coordinates(poly)[1]) == 5
 
     triangle = Triangle(point, point, point)
     GeoInterface.testgeometry(triangle)
+    @test length(GeoInterface.coordinates(triangle)) == 1
+    @test length(GeoInterface.coordinates(triangle)[1]) == 3
 
     polys = MultiPolygon([poly, poly])
     GeoInterface.testgeometry(polys)
+    @test length(GeoInterface.coordinates(polys)) == 2
+    @test length(GeoInterface.coordinates(polys)[1]) == 2
+    @test length(GeoInterface.coordinates(polys)[1][1]) == 5
 end
 
 @testset "Mesh" begin