using GeoInterface

The trait names can get quite long and are exported, and not much else is exported.

Author: visr

src/GeometryBasics.jl

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

src/geointerface.jl

@@ -10,70 +10,70 @@ GeoInterface.isgeometry(::Type{<:AbstractVector{<:AbstractPolygon}}) = true
 GeoInterface.isgeometry(::Type{<:AbstractVector{<:AbstractFace}}) = true
 GeoInterface.isgeometry(::Type{<: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(::Point) = PointTrait()
+GeoInterface.geomtrait(::Line) = LineTrait()
+GeoInterface.geomtrait(::LineString) = LineStringTrait()
+GeoInterface.geomtrait(::Polygon) = PolygonTrait()
+GeoInterface.geomtrait(::MultiPoint) = MultiPointTrait()
+GeoInterface.geomtrait(::MultiLineString) = MultiLineStringTrait()
+GeoInterface.geomtrait(::MultiPolygon) = MultiPolygonTrait()
+GeoInterface.geomtrait(::Ngon) = PolygonTrait()
+GeoInterface.geomtrait(::AbstractMesh) = 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.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()
 
-GeoInterface.ncoord(::GeoInterface.PointTrait, g::Point) = length(g)
-GeoInterface.getcoord(::GeoInterface.PointTrait, g::Point, i::Int) = g[i]
+GeoInterface.ncoord(::PointTrait, g::Point) = length(g)
+GeoInterface.getcoord(::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(::LineTrait, g::Line) = length(g)
+GeoInterface.getgeom(::LineTrait, g::Line, i::Int) = g[i]
 
-GeoInterface.ngeom(::GeoInterface.LineStringTrait, g::LineString) = length(g) + 1  # n line segments + 1
-function GeoInterface.getgeom(::GeoInterface.LineStringTrait, g::LineString, i::Int)
+GeoInterface.ngeom(::LineStringTrait, g::LineString) = length(g) + 1  # n line segments + 1
+function GeoInterface.getgeom(::LineStringTrait, g::LineString, i::Int)
     return GeometryBasics.coordinates(g)[i]
 end
 
-GeoInterface.ngeom(::GeoInterface.PolygonTrait, g::Polygon) = length(g.interiors) + 1  # +1 for exterior
-function GeoInterface.getgeom(::GeoInterface.PolygonTrait,
+GeoInterface.ngeom(::PolygonTrait, g::Polygon) = length(g.interiors) + 1  # +1 for exterior
+function GeoInterface.getgeom(::PolygonTrait,
                               g::Polygon,
                               i::Int)::typeof(g.exterior)
     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]
+GeoInterface.ngeom(::MultiPointTrait, g::MultiPoint) = length(g)
+GeoInterface.getgeom(::MultiPointTrait, g::MultiPoint, i::Int) = g[i]
 
-function GeoInterface.ngeom(::GeoInterface.MultiLineStringTrait, g::MultiLineString)
+function GeoInterface.ngeom(::MultiLineStringTrait, g::MultiLineString)
     return length(g)
 end
-function GeoInterface.getgeom(::GeoInterface.MultiLineStringTrait, g::MultiLineString,
+function GeoInterface.getgeom(::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]
+GeoInterface.ngeom(::MultiPolygonTrait, g::MultiPolygon) = length(g)
+GeoInterface.getgeom(::MultiPolygonTrait, g::MultiPolygon, i::Int) = g[i]
 
-function GeoInterface.ncoord(::GeoInterface.AbstractGeometryTrait,
+function GeoInterface.ncoord(::AbstractGeometryTrait,
                              ::Simplex{Dim,T,N,P}) where {Dim,T,N,P}
     return Dim
 end
-function GeoInterface.ncoord(::GeoInterface.AbstractGeometryTrait,
+function GeoInterface.ncoord(::AbstractGeometryTrait,
                              ::AbstractGeometry{Dim,T}) where {Dim,T}
     return Dim
 end
-function GeoInterface.ngeom(::GeoInterface.AbstractGeometryTrait,
+function GeoInterface.ngeom(::AbstractGeometryTrait,
                             ::Simplex{Dim,T,N,P}) where {Dim,T,N,P}
     return N
 end
-GeoInterface.ngeom(::GeoInterface.PolygonTrait, ::Ngon) = 1  # can't have any holes
-GeoInterface.getgeom(::GeoInterface.PolygonTrait, g::Ngon, _) = LineString(g.points)
+GeoInterface.ngeom(::PolygonTrait, ::Ngon) = 1  # can't have any holes
+GeoInterface.getgeom(::PolygonTrait, g::Ngon, _) = LineString(g.points)
 
-function GeoInterface.ncoord(::GeoInterface.PolyhedralSurfaceTrait,
+function GeoInterface.ncoord(::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]
+GeoInterface.ngeom(::PolyhedralSurfaceTrait, g::AbstractMesh) = length(g)
+GeoInterface.getgeom(::PolyhedralSurfaceTrait, g::AbstractMesh, i) = g[i]

test/geointerface.jl

@@ -1,47 +1,47 @@
 @testset "Basic types" begin
     point = Point(2, 3)
-    GeoInterface.testgeometry(point)
-    @test GeoInterface.ncoord(point) == 2
-    @test GeoInterface.getcoord(point, 2) == 3
+    testgeometry(point)
+    @test ncoord(point) == 2
+    @test 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
+    testgeometry(mp)
+    @test ngeom(mp) == 2
+    @test 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)
+    testgeometry(linestring)
+    @test ngeom(linestring) == 3
+    @test getgeom(linestring, 1) == Point(10, 10)
+    @test getgeom(linestring, 2) == Point(20, 20)
+    @test getgeom(linestring, 3) == Point(10, 40)
     @test GeoInterface.coordinates(linestring) == [[10, 10], [20, 20], [10, 40]]
 
     multilinestring = MultiLineString([linestring, linestring])
-    GeoInterface.testgeometry(multilinestring)
+    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), [rand(Point{2,Float32}, 5)])
-    GeoInterface.testgeometry(poly)
+    testgeometry(poly)
     @test length(GeoInterface.coordinates(poly)) == 2
     @test length(GeoInterface.coordinates(poly)[1]) == 5
 
     triangle = Triangle(point, point, point)
-    GeoInterface.testgeometry(triangle)
+    testgeometry(triangle)
     @test length(GeoInterface.coordinates(triangle)) == 1
     @test length(GeoInterface.coordinates(triangle)[1]) == 3
 
     polys = MultiPolygon([poly, poly])
-    GeoInterface.testgeometry(polys)
+    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
     mesh = triangle_mesh(Sphere(Point3f(0), 1))
-    GeoInterface.testgeometry(mesh)
+    testgeometry(mesh)
 end