make polygon plotting work

Author: SimonDanisch

Project.toml

@@ -4,6 +4,7 @@ authors = ["SimonDanisch <[email protected]>"]
 version = "0.2.15"
 
 [deps]
+EarCut_jll = "5ae413db-bbd1-5e63-b57d-d24a61df00f5"
 IterTools = "c8e1da08-722c-5040-9ed9-7db0dc04731e"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"

src/GeometryBasics.jl

@@ -1,6 +1,7 @@
 module GeometryBasics
 
     using StaticArrays, Tables, StructArrays, IterTools, LinearAlgebra
+    using EarCut_jll
 
     using Base: @propagate_inbounds
 
@@ -12,15 +13,15 @@ module GeometryBasics
     include("viewtypes.jl")
     include("geometry_primitives.jl")
     include("rectangles.jl")
-    include("triangulation.jl")
     include("meshes.jl")
+    include("triangulation.jl")
     include("lines.jl")
     include("boundingboxes.jl")
 
     export AbstractGeometry, GeometryPrimitive
     export Mat, Point, Vec
     export LineFace, Polytope, Line, NgonFace, convert_simplex
-    export LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon
+    export LineString, AbstractPolygon, Polygon, MultiPoint, MultiLineString, MultiPolygon
     export Simplex, connect, Triangle, NSimplex, Tetrahedron
     export QuadFace, metafree, coordinates, TetrahedronFace
     export TupleView, SimplexFace, Mesh, meta
@@ -36,7 +37,7 @@ module GeometryBasics
     export AbstractMesh, Mesh, TriangleMesh
     export GLNormalMesh2D, PlainTriangleMesh
     export MetaT, meta_table
-    
+
     # all the different predefined mesh types
     # Note: meshes can contain arbitrary meta information,
     export AbstractMesh, TriangleMesh, PlainMesh, GLPlainMesh, GLPlainMesh2D, GLPlainMesh3D

src/basic_types.jl

@@ -92,7 +92,6 @@ function Polytope(::Type{<: NNgon{N}}, P::Type{<: AbstractPoint{NDim, T}}) where
     return Ngon{NDim, T, N, P}
 end
 
-
 const LineP{Dim, T, P <: AbstractPoint{Dim, T}} = Ngon{Dim, T, 2, P}
 const Line{Dim, T} = LineP{Dim, T, Point{Dim, T}}
 
@@ -111,6 +110,17 @@ const Quadrilateral{Dim, T} = Ngon{Dim, T, 4, P} where P <: AbstractPoint{Dim, T
 Base.show(io::IO, x::Quadrilateral) = print(io, "Quad(", join(x, ", "), ")")
 Base.summary(io::IO, x::Type{<: Quadrilateral}) = print(io, "Quad")
 
+function coordinates(lines::AbstractArray{LineP{Dim, T, PointType}}) where {Dim, T, PointType}
+    if lines isa Base.ReinterpretArray
+        return coordinates(lines.parent)
+    else
+        result = PointType[]
+        for line in lines
+            append!(result, coordinates(line))
+        end
+        return result
+    end
+end
 
 """
 A `Simplex` is a generalization of an N-dimensional tetrahedra and can be thought
@@ -181,7 +191,7 @@ struct LineString{
     points::V
 end
 
-coordinates(x::LineString) = x.points
+coordinates(x::LineString) = coordinates(x.points)
 
 Base.copy(x::LineString) = LineString(copy(x.points))
 Base.size(x::LineString) = size(coordinates(x))
@@ -276,6 +286,22 @@ function Polygon(exterior::AbstractVector{P}, faces::AbstractVector{<: LineFace}
     return Polygon(LineString(exterior, faces))
 end
 
+function Polygon(exterior::AbstractVector{P}, interior::AbstractVector{<:AbstractVector{P}}) where P <: AbstractPoint{Dim, T} where {Dim, T}
+    return Polygon(LineString(exterior), LineString.(interior))
+end
+
+function coordinates(polygon::Polygon{N, T, PointType}) where {N, T, PointType}
+    exterior = coordinates(polygon.exterior)
+    if isempty(polygon.interiors)
+        return exterior
+    else
+        result = PointType[]
+        append!(result, exterior)
+        foreach(x-> append!(result, coordinates(x)), polygon.interiors)
+        return result
+    end
+end
+
 """
     MultiPolygon(polygons::AbstractPolygon)
 """

src/interfaces.jl

@@ -75,13 +75,12 @@ faces(tesselation::Tesselation) = faces(tesselation.primitive, nvertices(tessela
 normals(tesselation::Tesselation) = normals(tesselation.primitive, nvertices(tesselation))
 texturecoordinates(tesselation::Tesselation) = texturecoordinates(tesselation.primitive, nvertices(tesselation))
 
-
 ## Decompose methods
 # Dispatch type to make `decompose(UV{Vec2f0}, primitive)` work
 # and to pass through tesselation information
 
 # Types that can be converted to a mesh via the functions below
-const Meshable{Dim, T} = Union{Tesselation{Dim, T}, Mesh{Dim, T},
+const Meshable{Dim, T} = Union{Tesselation{Dim, T}, Mesh{Dim, T}, AbstractPolygon{Dim, T},
                                GeometryPrimitive{Dim, T}, AbstractVector{<: AbstractPoint{Dim, T}}}
 
 struct UV{T} end
@@ -104,27 +103,22 @@ function decompose(::Type{P}, primitive) where {P<:AbstractPoint}
     return collect_with_eltype(P, metafree(coordinates(primitive)))
 end
 
+function decompose(::Type{P}, primitive) where {P<:AbstractPoint}
+    return collect_with_eltype(P, metafree(coordinates(primitive)))
+end
+
 function decompose(::Type{Point}, primitive::Meshable{Dim, T}) where {Dim, T}
     return collect_with_eltype(Point{Dim, T}, metafree(coordinates(primitive)))
 end
+function decompose(::Type{Point}, primitive::LineString{Dim, T}) where {Dim, T}
+    return collect_with_eltype(Point{Dim, T}, metafree(coordinates(primitive)))
+end
+
 
 function decompose(::Type{T}, primitive) where {T}
     return collect_with_eltype(T, primitive)
 end
 
-function decompose(::Type{P}, pol::Polygon) where {P<:AbstractPoint}
-    if isempty(pol.interiors)
-        return decompose(P, pol.exterior)
-    else
-        arr = copy(decompose(P, pol.exterior))
-        for i in pol.interiors
-            append!(arr, decompose(P, i))
-        end
-        return arr
-    end
-end
-
-decompose(::Type{P}, ls::LineString) where {P<:AbstractPoint} = ls.points.parent.data
 decompose_uv(primitive) = decompose(UV(), primitive)
 decompose_uvw(primitive) = decompose(UVW(), primitive)
 decompose_normals(primitive) = decompose(Normal(), primitive)

src/meshes.jl

@@ -14,7 +14,6 @@ function normals(mesh::AbstractMesh)
     return nothing
 end
 
-
 const GLTriangleElement = Triangle{3, Float32}
 const GLTriangleFace = TriangleFace{GLIndex}
 const PointWithUV{Dim, T} = PointMeta{Dim, T, Point{Dim, T}, (:uv,), Tuple{Vec{2, T}}}
@@ -144,14 +143,19 @@ Polygon triangluation!
 function mesh(polygon::AbstractVector{P}; pointtype=P, facetype=GLTriangleFace,
               normaltype=nothing) where {P<:AbstractPoint{2}}
 
+    return mesh(Polygon(polygon); pointtype, facetype, normaltype)
+end
+
+function mesh(polygon::AbstractPolygon{Dim, T}; pointtype=Point{Dim, T}, facetype=GLTriangleFace,
+              normaltype=nothing) where {Dim, T}
+
     faces = decompose(facetype, polygon)
     positions = decompose(pointtype, polygon)
 
     if normaltype !== nothing
         n = normals(positions, faces; normaltype=normaltype)
         positions = meta(positions; normals=n)
     end
-
     return Mesh(positions, faces)
 end
 

src/triangulation.jl

@@ -169,3 +169,70 @@ function decompose(::Type{FaceType}, points::AbstractArray{P}) where {P<:Abstrac
 
     return result
 end
+
+
+function earcut_triangulate(polygon::Vector{Vector{Point{2, Float64}}})
+    lengths = map(x-> UInt32(length(x)), polygon)
+    len = UInt32(length(lengths))
+    array = ccall(
+        (:u32_triangulate_f64, libearcut),
+        Tuple{Ptr{GLTriangleFace}, Cint},
+        (Ptr{Ptr{Float64}}, Ptr{UInt32}, UInt32),
+        polygon, lengths, len
+    )
+    return unsafe_wrap(Vector{GLTriangleFace}, array[1], array[2])
+end
+
+function earcut_triangulate(polygon::Vector{Vector{Point{2, Float32}}})
+    lengths = map(x-> UInt32(length(x)), polygon)
+    len = UInt32(length(lengths))
+    array = ccall(
+        (:u32_triangulate_f32, libearcut),
+        Tuple{Ptr{GLTriangleFace}, Cint},
+        (Ptr{Ptr{Float32}}, Ptr{UInt32}, UInt32),
+        polygon, lengths, len
+    )
+    return unsafe_wrap(Vector{GLTriangleFace}, array[1], array[2])
+end
+
+function earcut_triangulate(polygon::Vector{Vector{Point{2, Int64}}})
+    lengths = map(x-> UInt32(length(x)), polygon)
+    len = UInt32(length(lengths))
+    array = ccall(
+        (:u32_triangulate_i64, libearcut),
+        Tuple{Ptr{GLTriangleFace}, Cint},
+        (Ptr{Ptr{Int64}}, Ptr{UInt32}, UInt32),
+        polygon, lengths, len
+    )
+    return unsafe_wrap(Vector{GLTriangleFace}, array[1], array[2])
+end
+
+function earcut_triangulate(polygon::Vector{Vector{Point{2, Int32}}})
+    lengths = map(x-> UInt32(length(x)), polygon)
+    len = UInt32(length(lengths))
+    array = ccall(
+        (:u32_triangulate_i32, libearcut),
+        Tuple{Ptr{GLTriangleFace}, Cint},
+        (Ptr{Ptr{Int32}}, Ptr{UInt32}, UInt32),
+        polygon, lengths, len
+    )
+    return unsafe_wrap(Vector{GLTriangleFace}, array[1], array[2])
+end
+
+best_earcut_eltype(x) = Float64
+best_earcut_eltype(::Type{Float64}) = Float64
+best_earcut_eltype(::Type{<:AbstractFloat}) = Float32
+best_earcut_eltype(::Type{Int64}) = Int64
+best_earcut_eltype(::Type{Int32}) = Int32
+best_earcut_eltype(::Type{<:Integer}) = Int64
+
+function faces(polygon::Polygon{Dim, T}) where {Dim, T}
+    if isempty(polygon.interiors)
+        return decompose(GLTriangleFace, coordinates(polygon))
+    else
+        PT = Point{Dim, best_earcut_eltype(T)}
+        points = [decompose(PT, polygon.exterior)]
+        foreach(x-> push!(points, decompose(PT, x)), polygon.interiors)
+        return earcut_triangulate(points)
+    end
+end

src/viewtypes.jl

@@ -36,6 +36,8 @@ struct TupleView{T, N, Skip, A} <: AbstractVector{T}
     connect::Bool
 end
 
+coordinates(tw::TupleView) = coordinates(tw.data)
+
 function Base.size(x::TupleView{T, N, M}) where {T, N, M}
     nitems = length(x.data) ÷ (N - (N - M))
     nitems = nitems - max(N - M, 0)