Implemented GeoInterface.

Author: evetion

Project.toml

@@ -1,10 +1,11 @@
 name = "GeometryBasics"
 uuid = "5c1252a2-5f33-56bf-86c9-59e7332b4326"
 authors = ["SimonDanisch <[email protected]>"]
-version = "0.4.2"
+version = "0.4.3"
 
 [deps]
 EarCut_jll = "5ae413db-bbd1-5e63-b57d-d24a61df00f5"
+GeoInterface = "cf35fbd7-0cd7-5166-be24-54bfbe79505f"
 IterTools = "c8e1da08-722c-5040-9ed9-7db0dc04731e"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
@@ -21,6 +22,7 @@ julia = "1.3"
 [extras]
 OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]

src/GeometryBasics.jl

@@ -1,6 +1,6 @@
 module GeometryBasics
 
-using StaticArrays, Tables, StructArrays, IterTools, LinearAlgebra
+using StaticArrays, Tables, StructArrays, IterTools, LinearAlgebra, GeoInterface
 using EarCut_jll
 
 using Base: @propagate_inbounds
@@ -25,6 +25,7 @@ include("lines.jl")
 include("boundingboxes.jl")
 
 include("deprecated.jl")
+include("geointerface.jl")
 
 export AbstractGeometry, GeometryPrimitive
 export Mat, Point, Vec

src/geointerface.jl

@@ -0,0 +1,74 @@
+# Implementation of trait based interface from https://github.com/JuliaGeo/GeoInterface.jl/
+
+GeoInterface.isgeometry(::AbstractGeometry) = true
+GeoInterface.isgeometry(::AbstractFace) = true
+GeoInterface.isgeometry(::AbstractPoint) = true
+GeoInterface.isgeometry(::AbstractVector{<:AbstractGeometry}) = true
+GeoInterface.isgeometry(::AbstractVector{<:AbstractPoint}) = true
+GeoInterface.isgeometry(::AbstractVector{<:LineString}) = true
+GeoInterface.isgeometry(::AbstractVector{<:AbstractPolygon}) = true
+GeoInterface.isgeometry(::AbstractVector{<:AbstractFace}) = true
+GeoInterface.isgeometry(::Mesh) = true
+
+GeoInterface.geomtrait(::Point) = GeoInterface.PointTrait()
+GeoInterface.geomtrait(::Line) = GeoInterface.LineTrait()
+GeoInterface.geomtrait(::LineString) = GeoInterface.LineStringTrait()
+GeoInterface.geomtrait(::Polygon) = GeoInterface.PolygonTrait()
+GeoInterface.geomtrait(::MultiPoint) = GeoInterface.MultiPointTrait()
+GeoInterface.geomtrait(::MultiLineString) = GeoInterface.MultiLineStringTrait()
+GeoInterface.geomtrait(::MultiPolygon) = GeoInterface.MultiPolygonTrait()
+GeoInterface.geomtrait(::Ngon) = GeoInterface.PolygonTrait()
+GeoInterface.geomtrait(::AbstractMesh) = GeoInterface.PolyhedralSurfaceTrait()
+
+GeoInterface.geomtrait(::Simplex{Dim,T,1}) where {Dim,T} = GeoInterface.PointTrait()
+GeoInterface.geomtrait(::Simplex{Dim,T,2}) where {Dim,T} = GeoInterface.LineStringTrait()
+GeoInterface.geomtrait(::Simplex{Dim,T,3}) where {Dim,T} = GeoInterface.PolygonTrait()
+
+GeoInterface.ncoord(::GeoInterface.PointTrait, g::Point) = length(g)
+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)
+function GeoInterface.getgeom(::GeoInterface.LineStringTrait, g::LineString, i::Int)
+    return 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)
+    return i > 1 ? g.interiors[i - 1] : g.exterior
+end
+
+GeoInterface.ngeom(::GeoInterface.MultiPointTrait, g::MultiPoint) = length(g)
+GeoInterface.getgeom(::GeoInterface.MultiPointTrait, g::MultiPoint, i::Int) = g[i]
+
+function GeoInterface.ngeom(::GeoInterface.MultiLineStringTrait, g::MultiLineString)
+    return length(g)
+end
+function GeoInterface.getgeom(::GeoInterface.MultiLineStringTrait, g::MultiLineString,
+                              i::Int)
+    return g[i]
+end
+
+GeoInterface.ngeom(::GeoInterface.MultiPolygonTrait, g::MultiPolygon) = length(g)
+GeoInterface.getgeom(::GeoInterface.MultiPolygonTrait, g::MultiPolygon, i::Int) = g[i]
+
+function GeoInterface.ncoord(::GeoInterface.AbstractGeometryTrait,
+                             ::Simplex{Dim,T,N,P}) where {Dim,T,N,P}
+    return Dim
+end
+function GeoInterface.ncoord(::GeoInterface.AbstractGeometryTrait,
+                             ::AbstractGeometry{Dim,T}) where {Dim,T}
+    return Dim
+end
+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.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]

test/geointerface.jl

@@ -0,0 +1,27 @@
+@testset "Basic types" begin
+    point = Point(2, 3)
+    GeoInterface.testgeometry(point)
+
+    mp = MultiPoint([point, point])
+    GeoInterface.testgeometry(mp)
+
+    linestring = LineString(Point{2,Int}[(10, 10), (20, 20), (10, 40)])
+    GeoInterface.testgeometry(linestring)
+
+    multilinestring = MultiLineString([linestring, linestring])
+    GeoInterface.testgeometry(multilinestring)
+
+    poly = Polygon(rand(Point{2,Float32}, 5))
+    GeoInterface.testgeometry(poly)
+
+    triangle = Triangle(point, point, point)
+    GeoInterface.testgeometry(triangle)
+
+    polys = MultiPolygon([poly, poly])
+    GeoInterface.testgeometry(polys)
+end
+
+@testset "Mesh" begin
+    mesh = triangle_mesh(Sphere(Point3f(0), 1))
+    GeoInterface.testgeometry(mesh)
+end

test/runtests.jl

@@ -2,6 +2,7 @@ using Test, Random, StructArrays, Tables, StaticArrays, OffsetArrays
 using GeometryBasics
 using LinearAlgebra
 using GeometryBasics: attributes
+using GeoInterface
 
 @testset "GeometryBasics" begin
 
@@ -715,4 +716,8 @@ end
     include("fixed_arrays.jl")
 end
 
+@testset "GeoInterface" begin
+    include("geointerface.jl")
+end
+
 end  # testset "GeometryBasics"