Merge branch 'master' into sd/simple-mesh

Author: SimonDanisch

Project.toml

@@ -1,7 +1,7 @@
 name = "GeometryBasics"
 uuid = "5c1252a2-5f33-56bf-86c9-59e7332b4326"
 authors = ["SimonDanisch <[email protected]>"]
-version = "0.4.3"
+version = "0.4.5"
 
 [deps]
 EarCut_jll = "5ae413db-bbd1-5e63-b57d-d24a61df00f5"

src/geointerface.jl

@@ -20,6 +20,15 @@ GeoInterface.geomtrait(::MultiPolygon) = MultiPolygonTrait()
 GeoInterface.geomtrait(::Ngon) = PolygonTrait()
 GeoInterface.geomtrait(::AbstractMesh) = PolyhedralSurfaceTrait()
 
+# GeoInterface calls this method in `GeoInterface.convert(GeometryBasics, ...)`
+geointerface_geomtype(::GeoInterface.PointTrait) = Point
+geointerface_geomtype(::GeoInterface.MultiPointTrait) = MultiPoint
+geointerface_geomtype(::GeoInterface.LineStringTrait) = LineString
+geointerface_geomtype(::GeoInterface.MultiLineStringTrait) = MultiLineString
+geointerface_geomtype(::GeoInterface.PolygonTrait) = Polygon
+geointerface_geomtype(::GeoInterface.MultiPolygonTrait) = MultiPolygon
+geointerface_geomtype(::GeoInterface.PolyhedralSurfaceTrait) = Mesh
+
 GeoInterface.geomtrait(::Simplex{Dim,T,1}) where {Dim,T} = PointTrait()
 GeoInterface.geomtrait(::Simplex{Dim,T,2}) where {Dim,T} = LineStringTrait()
 GeoInterface.geomtrait(::Simplex{Dim,T,3}) where {Dim,T} = PolygonTrait()
@@ -30,7 +39,9 @@ GeoInterface.getcoord(::PointTrait, g::Point, i::Int) = g[i]
 GeoInterface.ngeom(::LineTrait, g::Line) = length(g)
 GeoInterface.getgeom(::LineTrait, g::Line, i::Int) = g[i]
 
-GeoInterface.ngeom(::LineStringTrait, g::LineString) = length(g)  # n line segments + 1
+
+GeoInterface.ngeom(::LineStringTrait, g::LineString) = length(g) + 1  # n line segments + 1
+GeoInterface.ncoord(::LineStringTrait, g::LineString{Dim}) where {Dim} = Dim
 function GeoInterface.getgeom(::LineStringTrait, g::LineString, i::Int)
     return GeometryBasics.coordinates(g)[i]
 end
@@ -52,6 +63,7 @@ function GeoInterface.getgeom(::MultiLineStringTrait, g::MultiLineString,
                               i::Int)
     return g[i]
 end
+GeoInterface.ncoord(::MultiLineStringTrait, g::MultiLineString{Dim}) where {Dim} = Dim
 
 GeoInterface.ngeom(::MultiPolygonTrait, g::MultiPolygon) = length(g)
 GeoInterface.getgeom(::MultiPolygonTrait, g::MultiPolygon, i::Int) = g[i]
@@ -80,12 +92,12 @@ GeoInterface.getgeom(::PolyhedralSurfaceTrait, g::AbstractMesh, i) = g[i]
 
 function GeoInterface.convert(::Type{Point}, type::PointTrait, geom)
     dim = Int(ncoord(geom))
-    return Point{dim}(GeoInterface.coordinates(geom))
+    return Point{dim, Float64}(GeoInterface.coordinates(geom))
 end
 
 function GeoInterface.convert(::Type{LineString}, type::LineStringTrait, geom)
     dim = Int(ncoord(geom))
-    return LineString([Point{dim}(GeoInterface.coordinates(p)) for p in getgeom(geom)])
+    return LineString([Point{dim, Float64}(GeoInterface.coordinates(p)) for p in getgeom(geom)])
 end
 
 function GeoInterface.convert(::Type{Polygon}, type::PolygonTrait, geom)
@@ -101,7 +113,7 @@ end
 
 function GeoInterface.convert(::Type{MultiPoint}, type::MultiPointTrait, geom)
     dim = Int(ncoord(geom))
-    return MultiPoint([Point{dim}(GeoInterface.coordinates(p)) for p in getgeom(geom)])
+    return MultiPoint([Point{dim, Float64}(GeoInterface.coordinates(p)) for p in getgeom(geom)])
 end
 
 function GeoInterface.convert(::Type{MultiLineString}, type::MultiLineStringTrait, geom)

test/geointerface.jl

@@ -14,6 +14,7 @@
     linestring = LineString(Point{2,Int}[(10, 10), (20, 20), (10, 40)])
     @test testgeometry(linestring)
     @test ngeom(linestring) == 3
+    @test ncoord(linestring) == 2
     @test getgeom(linestring, 1) == Point(10, 10)
     @test getgeom(linestring, 2) == Point(20, 20)
     @test getgeom(linestring, 3) == Point(10, 40)
@@ -23,6 +24,7 @@
     @test testgeometry(multilinestring)
     @test GeoInterface.coordinates(multilinestring) ==
           [[[10, 10], [20, 20], [10, 40]], [[10, 10], [20, 20], [10, 40]]]
+    @test ncoord(multilinestring) == 2
 
     poly = Polygon(rand(Point{2,Float32}, 5), [rand(Point{2,Float32}, 5)])
     @test testgeometry(poly)
@@ -68,15 +70,15 @@ end
     multipolygon_json = GeoJSON.read(multipolygon_str)
     multipolygon_hole_json = GeoJSON.read(multipolygon_hole_str)
 
-    point_gb = GeoInterface.convert(Point, point_json)
-    point_3d_gb = GeoInterface.convert(Point, point_3d_json)
-    linestring_gb = GeoInterface.convert(LineString, linestring_json)
-    polygon_gb = GeoInterface.convert(Polygon, polygon_json)
-    polygon_hole_gb = GeoInterface.convert(Polygon, polygon_hole_json)
-    multipoint_gb = GeoInterface.convert(MultiPoint, multipoint_json)
-    multilinestring_gb = GeoInterface.convert(MultiLineString, multilinestring_json)
-    multipolygon_gb = GeoInterface.convert(MultiPolygon, multipolygon_json)
-    multipolygon_hole_gb = GeoInterface.convert(MultiPolygon, multipolygon_hole_json)
+    point_gb = GeoInterface.convert(GeometryBasics, point_json)
+    point_3d_gb = GeoInterface.convert(GeometryBasics, point_3d_json)
+    linestring_gb = GeoInterface.convert(GeometryBasics, linestring_json)
+    polygon_gb = GeoInterface.convert(GeometryBasics, polygon_json)
+    polygon_hole_gb = GeoInterface.convert(GeometryBasics, polygon_hole_json)
+    multipoint_gb = GeoInterface.convert(GeometryBasics, multipoint_json)
+    multilinestring_gb = GeoInterface.convert(GeometryBasics, multilinestring_json)
+    multipolygon_gb = GeoInterface.convert(GeometryBasics, multipolygon_json)
+    multipolygon_hole_gb = GeoInterface.convert(GeometryBasics, multipolygon_hole_json)
 
     @test point_gb === Point{2, Float64}(30.1, 10.1)
     @test point_3d_gb === Point{3, Float64}(30.1, 10.1, 5.1)