likely broken merge attempt

Author: SimonDanisch

.github/workflows/ci.yml

@@ -3,7 +3,7 @@ on:
   push:
     branches:
       - master
-    tags: '*'
+    tags: "*"
   pull_request:
     branches:
       - master
@@ -15,8 +15,8 @@ jobs:
       fail-fast: false
       matrix:
         version:
-          - '1.5'
-          - '1.7'
+          - "1.6"
+          - "1"
         os:
           - ubuntu-latest
           - macOS-latest
@@ -54,7 +54,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: julia-actions/setup-julia@v1
         with:
-          version: '1.7'
+          version: "1.7"
       - run: |
           julia --project=docs -e '
             using Pkg

Project.toml

@@ -1,23 +1,27 @@
 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"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 
 [compat]
+EarCut_jll = "2"
+GeoInterface = "1.0.1"
 IterTools = "1.3.0"
-julia = "1.5"
+julia = "1.6"
 
 [extras]
+Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
+GeoJSON = "61d90e0f-e114-555e-ac52-39dfb47a3ef9"
 OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
-StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 
 [targets]
-test = ["Test", "Random", "StaticArrays", "OffsetArrays"]
+test = ["Aqua", "GeoJSON", "Test", "Random", "OffsetArrays"]

src/GeometryBasics.jl

@@ -1,6 +1,7 @@
 module GeometryBasics
 
 using IterTools, LinearAlgebra
+using GeoInterface
 using EarCut_jll
 import Base: *
 
@@ -24,6 +25,8 @@ include("triangulation.jl")
 include("lines.jl")
 include("boundingboxes.jl")
 
+include("geointerface.jl")
+
 export AbstractGeometry, GeometryPrimitive
 export Mat, Point, Vec
 export LineFace, Polytope, Line, NgonFace, convert_simplex
@@ -40,6 +43,7 @@ export Tesselation, Normal, UV, UVW
 export AbstractMesh, Mesh, MetaMesh
 export add_meta, pop_meta
 
+
 # all the different predefined mesh types
 # Note: meshes can contain arbitrary meta information,
 export AbstractMesh
@@ -48,11 +52,11 @@ export AbstractMesh
 export triangle_mesh, triangle_mesh, uv_mesh
 export uv_mesh, normal_mesh, uv_normal_mesh
 
-export height, origin, radius, width, widths, xwidth, yheight
+export height, origin, radius, width, widths
 export HyperSphere, Circle, Sphere
 export Cylinder, Cylinder2, Cylinder3, Pyramid, extremity
 export HyperRectangle, Rect, Rect2, Rect3, Recti, Rect2i, Rect3i, Rectf, Rect2f, Rect3f
-export before, during, isinside, isoutside, meets, overlaps, intersects, finishes
+export before, during, meets, overlaps, intersects, finishes
 export centered, direction, area, volume, update
 export max_dist_dim, max_euclidean, max_euclideansq, min_dist_dim, min_euclidean
 export min_euclideansq, minmax_dist_dim, minmax_euclidean, minmax_euclideansq

src/basic_types.jl

@@ -221,6 +221,53 @@ function coordinates(polygon::Polygon{N,T}) where {N,T}
     end
 end
 
+"""
+    MultiPolygon(polygons::AbstractPolygon)
+"""
+struct MultiPolygon{Dim,T<:Real,Element<:AbstractPolygon{Dim,T},
+                    A<:AbstractVector{Element}} <: AbstractVector{Element}
+    polygons::A
+end
+
+function MultiPolygon(polygons::AbstractVector{P};
+                      kw...) where {P<:AbstractPolygon{Dim,T}} where {Dim,T}
+    return MultiPolygon(meta(polygons; kw...))
+end
+
+Base.getindex(mp::MultiPolygon, i) = mp.polygons[i]
+Base.size(mp::MultiPolygon) = size(mp.polygons)
+
+struct MultiLineString{Dim,T<:Real,Element<:LineString{Dim,T},A<:AbstractVector{Element}} <:
+       AbstractVector{Element}
+    linestrings::A
+end
+
+function MultiLineString(linestrings::AbstractVector{L};
+                         kw...) where {L<:AbstractVector{LineP{Dim,T,P}}} where {Dim,T,P}
+    return MultiLineString(meta(linestrings; kw...))
+end
+
+Base.getindex(ms::MultiLineString, i) = ms.linestrings[i]
+Base.size(ms::MultiLineString) = size(ms.linestrings)
+
+"""
+    MultiPoint(points::AbstractVector{AbstractPoint})
+
+A collection of points
+"""
+struct MultiPoint{Dim,T<:Real,P<:AbstractPoint{Dim,T},A<:AbstractVector{P}} <:
+       AbstractVector{P}
+    points::A
+end
+
+function MultiPoint(points::AbstractVector{P};
+                    kw...) where {P<:AbstractPoint{Dim,T}} where {Dim,T}
+    return MultiPoint(meta(points; kw...))
+end
+
+Base.getindex(mpt::MultiPoint, i) = mpt.points[i]
+Base.size(mpt::MultiPoint) = size(mpt.points)
+
 """
     AbstractMesh
 

src/geointerface.jl

@@ -0,0 +1,115 @@
+# Implementation of trait based interface from https://github.com/JuliaGeo/GeoInterface.jl/
+
+GeoInterface.isgeometry(::Type{<:AbstractGeometry}) = true
+GeoInterface.isgeometry(::Type{<:AbstractFace}) = true
+GeoInterface.isgeometry(::Type{<:AbstractPoint}) = true
+GeoInterface.isgeometry(::Type{<:AbstractVector{<:AbstractGeometry}}) = true
+GeoInterface.isgeometry(::Type{<:AbstractVector{<:AbstractPoint}}) = true
+GeoInterface.isgeometry(::Type{<:AbstractVector{<:LineString}}) = true
+GeoInterface.isgeometry(::Type{<:AbstractVector{<:AbstractPolygon}}) = true
+GeoInterface.isgeometry(::Type{<:AbstractVector{<:AbstractFace}}) = true
+GeoInterface.isgeometry(::Type{<:Mesh}) = true
+
+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} = PointTrait()
+GeoInterface.geomtrait(::Simplex{Dim,T,2}) where {Dim,T} = LineStringTrait()
+GeoInterface.geomtrait(::Simplex{Dim,T,3}) where {Dim,T} = PolygonTrait()
+
+GeoInterface.ncoord(::PointTrait, g::Point) = length(g)
+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) + 1  # n line segments + 1
+function GeoInterface.getgeom(::LineStringTrait, g::LineString, i::Int)
+    return GeometryBasics.coordinates(g)[i]
+end
+
+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(::MultiPointTrait, g::MultiPoint) = length(g)
+GeoInterface.getgeom(::MultiPointTrait, g::MultiPoint, i::Int) = g[i]
+
+function GeoInterface.ngeom(::MultiLineStringTrait, g::MultiLineString)
+    return length(g)
+end
+function GeoInterface.getgeom(::MultiLineStringTrait, g::MultiLineString,
+                              i::Int)
+    return g[i]
+end
+
+GeoInterface.ngeom(::MultiPolygonTrait, g::MultiPolygon) = length(g)
+GeoInterface.getgeom(::MultiPolygonTrait, g::MultiPolygon, i::Int) = g[i]
+
+function GeoInterface.ncoord(::AbstractGeometryTrait,
+                             ::Simplex{Dim,T,N,P}) where {Dim,T,N,P}
+    return Dim
+end
+function GeoInterface.ncoord(::AbstractGeometryTrait,
+                             ::AbstractGeometry{Dim,T}) where {Dim,T}
+    return Dim
+end
+function GeoInterface.ngeom(::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)
+
+function GeoInterface.ncoord(::PolyhedralSurfaceTrait,
+                             ::Mesh{Dim,T,E,V} where {Dim,T,E,V})
+    return Dim
+end
+GeoInterface.ngeom(::PolyhedralSurfaceTrait, g::AbstractMesh) = length(g)
+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))
+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)])
+end
+
+function GeoInterface.convert(::Type{Polygon}, type::PolygonTrait, geom)
+    t = LineStringTrait()
+    exterior = GeoInterface.convert(LineString, t, GeoInterface.getexterior(geom))
+    if GeoInterface.nhole(geom) == 0
+        return Polygon(exterior)
+    else
+        interiors = GeoInterface.convert.(LineString, Ref(t), GeoInterface.gethole(geom))
+        return Polygon(exterior, interiors)
+    end
+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)])
+end
+
+function GeoInterface.convert(::Type{MultiLineString}, type::MultiLineStringTrait, geom)
+    t = LineStringTrait()
+    return MultiLineString([GeoInterface.convert(LineString, t, l) for l in getgeom(geom)])
+end
+
+function GeoInterface.convert(::Type{MultiPolygon}, type::MultiPolygonTrait, geom)
+    t = PolygonTrait()
+    return MultiPolygon([GeoInterface.convert(Polygon, t, poly) for poly in getgeom(geom)])
+end

src/meshes.jl

@@ -77,7 +77,7 @@ end
 Calculate the signed volume of one tetrahedron. Be sure the orientation of your
 surface is right.
 """
-function volume(triangle::Triangle) where {VT,FT}
+function volume(triangle::Triangle)
     v1, v2, v3 = triangle
     sig = sign(orthogonal_vector(v1, v2, v3) ⋅ v1)
     return sig * abs(v1 ⋅ (v2 × v3)) / 6
@@ -89,7 +89,7 @@ end
 Calculate the signed volume of all tetrahedra. Be sure the orientation of your
 surface is right.
 """
-function volume(mesh::Mesh) where {VT,FT}
+function volume(mesh::Mesh)
     return sum(volume, mesh)
 end
 

src/primitives/rectangles.jl

@@ -48,16 +48,16 @@ function Rect(v1::Vec{N,T1}, v2::Vec{N,T2}) where {N,T1,T2}
     return Rect{N,T}(Vec{N,T}(v1), Vec{N,T}(v2))
 end
 
-function RectT{T}(v1::VecTypes{N,T1}, v2::VecTypes{N,T2}) where {N,T,T1,T2}
+function RectT{T}(v1::VecTypes{N}, v2::VecTypes{N}) where {N,T}
     return if T <: Integer
         Rect{N,T}(round.(T, v1), round.(T, v2))
     else
         return Rect{N,T}(Vec{N,T}(v1), Vec{N,T}(v2))
     end
 end
 
-function Rect{N}(v1::VecTypes{N,T1}, v2::VecTypes{N,T2}) where {N,T1,T2}
-    T = promote_type(T1, T2)
+function Rect{N}(v1::VecTypes{N}, v2::VecTypes{N}) where {N}
+    T = promote_type(eltype(v1), eltype(v2))
     return Rect{N,T}(Vec{N,T}(v1), Vec{N,T}(v2))
 end
 
@@ -67,7 +67,7 @@ end
 ```
 Rect(vals::Number...)
 ```
-Rect constructor for indidually specified intervals.
+Rect constructor for individually specified intervals.
 e.g. Rect(0,0,1,2) has origin == Vec(0,0) and
 width == Vec(1,2)
 """
@@ -512,7 +512,7 @@ Base.isequal(b1::Rect, b2::Rect) = b1 == b2
 
 centered(R::Type{Rect{N,T}}) where {N,T} = R(Vec{N,T}(-0.5), Vec{N,T}(1))
 centered(R::Type{Rect{N}}) where {N} = R(Vec{N,Float32}(-0.5), Vec{N,Float32}(1))
-centered(R::Type{Rect}) where {N} = R(Vec{2,Float32}(-0.5), Vec{2,Float32}(1))
+centered(R::Type{Rect}) = R(Vec{2,Float32}(-0.5), Vec{2,Float32}(1))
 
 ##
 # Rect2 decomposition