gMerge branch 'sd/meshes'

Author: SimonDanisch

src/GeometryBasics.jl

@@ -7,6 +7,7 @@ module GeometryBasics
     include("fixed_arrays.jl")
     include("offsetintegers.jl")
     include("basic_types.jl")
+    include("interfaces.jl")
     include("metadata.jl")
     include("viewtypes.jl")
     include("geometry_primitives.jl")
@@ -29,6 +30,7 @@ module GeometryBasics
     export FaceView, SimpleFaceView
     export AbstractPoint, PointMeta, PointWithUV
     export decompose, coordinates, faces, normals, decompose_uv, decompose_normals
+    export Tesselation
     export GLTriangleFace, GLNormalMesh3D, GLPlainTriangleMesh, GLUVMesh3D, GLUVNormalMesh3D
     export AbstractMesh, Mesh, TriangleMesh
     export GLNormalMesh2D, PlainTriangleMesh

src/basic_types.jl

@@ -20,26 +20,6 @@ abstract type AbstractNgonFace{N, T} <: AbstractFace{N, T} end
 
 abstract type AbstractSimplex{Dim, N, T} <: StaticVector{Dim, T} end
 
-"""
-    coordinates(geometry)
-Returns the edges/vertices/coordinates of a geometry. Is allowed to return lazy iterators!
-Use `decompose(ConcretePointType, geometry)` to get `Vector{ConcretePointType}` with
-`ConcretePointType` to be something like `Point{3, Float32}`.
-"""
-function coordinates(points::AbstractVector{<:AbstractPoint})
-    return points
-end
-
-"""
-    faces(geometry)
-Returns the face connections of a geometry. Is allowed to return lazy iterators!
-Use `decompose(ConcreteFaceType, geometry)` to get `Vector{ConcreteFaceType}` with
-`ConcreteFaceType` to be something like `TriangleFace{Int}`.
-"""
-function faces(f::AbstractVector{<:AbstractFace})
-    return f
-end
-
 """
 Face index, connecting points to form a simplex
 """
@@ -57,7 +37,9 @@ const LineFace{T} = NgonFace{2, T}
 const TriangleFace{T} = NgonFace{3, T}
 const QuadFace{T} = NgonFace{4, T}
 
-Base.show(io::IO, x::TriangleFace{T}) where T = print(io, "TriangleFace(", join(x, ", "), ")")
+function Base.show(io::IO, x::TriangleFace{T}) where T
+    print(io, "TriangleFace(", join(x, ", "), ")")
+end
 
 Face(::Type{<: NgonFace{N}}, ::Type{T}) where {N, T} = NgonFace{N, T}
 Face(F::Type{NgonFace{N, FT}}, ::Type{T}) where {FT, N, T} = F
@@ -100,14 +82,14 @@ Base.length(::NNgon{N}) where N = N
 The Ngon Polytope element type when indexing an array of points with a SimplexFace
 """
 function Polytope(P::Type{<: AbstractPoint{Dim, T}}, ::Type{<: AbstractNgonFace{N, IT}}) where {N, Dim, T, IT}
-    Ngon{Dim, T, N, P}
+    return Ngon{Dim, T, N, P}
 end
 
 """
 The fully concrete Ngon type, when constructed from a point type!
 """
 function Polytope(::Type{<: NNgon{N}}, P::Type{<: AbstractPoint{NDim, T}}) where {N, NDim, T}
-    Ngon{NDim, T, N, P}
+    return Ngon{NDim, T, N, P}
 end
 
 
@@ -157,11 +139,10 @@ const Tetrahedron{T} = TetrahedronP{T, Point{3, T}}
 
 Base.show(io::IO, x::TetrahedronP) = print(io, "Tetrahedron(", join(x, ", "), ")")
 
-
 coordinates(x::Simplex) = x.points
 
 function (::Type{<: NSimplex{N}})(points::Vararg{P, N}) where {P <: AbstractPoint{Dim, T}, N} where {Dim, T}
-    Simplex{Dim, T, N, P}(SVector(points))
+    return Simplex{Dim, T, N, P}(SVector(points))
 end
 
 # Base Array interface
@@ -172,14 +153,14 @@ Base.length(::NSimplex{N}) where N = N
 The Simplex Polytope element type when indexing an array of points with a SimplexFace
 """
 function Polytope(P::Type{<: AbstractPoint{Dim, T}}, ::Type{<: AbstractSimplexFace{N}}) where {N, Dim, T}
-    Simplex{Dim, T, N, P}
+    return Simplex{Dim, T, N, P}
 end
 
 """
 The fully concrete Simplex type, when constructed from a point type!
 """
 function Polytope(::Type{<: NSimplex{N}}, P::Type{<: AbstractPoint{NDim, T}}) where {N, NDim, T}
-    Simplex{NDim, T, N, P}
+    return Simplex{NDim, T, N, P}
 end
 Base.show(io::IO, x::LineP) = print(io, "Line(", x[1], " => ", x[2], ")")
 
@@ -193,13 +174,14 @@ struct LineString{
     } <: AbstractVector{LineP{Dim, T, P}}
     points::V
 end
+
 coordinates(x::LineString) = x.points
 
 Base.size(x::LineString) = size(coordinates(x))
 Base.getindex(x::LineString, i) = getindex(coordinates(x), i)
 
 function LineString(points::AbstractVector{LineP{Dim, T, P}}) where {Dim, T, P}
-    LineString{Dim, T, P, typeof(points)}(points)
+    return LineString{Dim, T, P, typeof(points)}(points)
 end
 
 """
@@ -214,15 +196,15 @@ linestring = LineString(points)
 ```
 """
 function LineString(points::AbstractVector{<: AbstractPoint}, skip = 1)
-    LineString(connect(points, LineP, skip))
+    return LineString(connect(points, LineP, skip))
 end
 
 function LineString(points::AbstractVector{<: Pair{P, P}}) where P <: AbstractPoint{N, T} where {N, T}
-    LineString(reinterpret(LineP{N, T, P}, points))
+    return LineString(reinterpret(LineP{N, T, P}, points))
 end
 
 function LineString(points::AbstractVector{<: AbstractPoint}, faces::AbstractVector{<: LineFace})
-    LineString(connect(points, faces))
+    return LineString(connect(points, faces))
 end
 
 """
@@ -246,7 +228,7 @@ linestring = LineString(points, faces, 2)
 """
 function LineString(points::AbstractVector{<: AbstractPoint}, indices::AbstractVector{<: Integer}, skip = 1)
     faces = connect(indices, LineFace, skip)
-    LineString(points, faces)
+    return LineString(points, faces)
 end
 
 struct Polygon{
@@ -262,21 +244,21 @@ end
 Base.:(==)(a::Polygon, b::Polygon) = (a.exterior == b.exterior) && (a.interiors == b.interiors)
 
 function Polygon(exterior::E, interiors::AbstractVector{E}) where E <: AbstractVector{LineP{Dim, T, P}} where {Dim, T, P}
-    Polygon{Dim, T, P, typeof(exterior), typeof(interiors)}(exterior, interiors)
+    return Polygon{Dim, T, P, typeof(exterior), typeof(interiors)}(exterior, interiors)
 end
 
 Polygon(exterior::L) where L <: AbstractVector{<: LineP} = Polygon(exterior, L[])
 
 function Polygon(exterior::AbstractVector{P}, skip::Int = 1) where P <: AbstractPoint{Dim, T} where {Dim, T}
-    Polygon(LineString(exterior, skip))
+    return Polygon(LineString(exterior, skip))
 end
 
 function Polygon(exterior::AbstractVector{P}, faces::AbstractVector{<: Integer}, skip::Int = 1) where P <: AbstractPoint{Dim, T} where {Dim, T}
-    Polygon(LineString(exterior, faces, skip))
+    return Polygon(LineString(exterior, faces, skip))
 end
 
 function Polygon(exterior::AbstractVector{P}, faces::AbstractVector{<: LineFace}) where P <: AbstractPoint{Dim, T} where {Dim, T}
-    Polygon(LineString(exterior, faces))
+    return Polygon(LineString(exterior, faces))
 end
 
 
@@ -290,7 +272,7 @@ struct MultiPolygon{
 end
 
 function MultiPolygon(polygons::AbstractVector{P}; kw...) where P <: AbstractPolygon{Dim, T} where {Dim, T}
-    MultiPolygon(meta(polygons; kw...))
+    return MultiPolygon(meta(polygons; kw...))
 end
 
 Base.getindex(mp::MultiPolygon, i) = mp.polygons[i]
@@ -306,7 +288,7 @@ struct MultiLineString{
 end
 
 function MultiLineString(linestrings::AbstractVector{L}; kw...) where L <: AbstractVector{LineP{Dim, T, P}} where {Dim, T, P}
-    MultiLineString(meta(linestrings; kw...))
+    return MultiLineString(meta(linestrings; kw...))
 end
 
 Base.getindex(ms::MultiLineString, i) = ms.linestrings[i]
@@ -342,7 +324,7 @@ const AbstractMesh{Element} = AbstractVector{Element}
 The conrecte AbstractMesh implementation
 """
 struct Mesh{
-        Dim, T <: Real,
+        Dim, T <: Number,
         Element <: Polytope{Dim, T},
         V <: AbstractVector{Element}
     } <: AbstractMesh{Element}

src/geometry_primitives.jl

@@ -1,6 +1,5 @@
 ##
 # Generic base overloads
-
 Base.extrema(primitive::GeometryPrimitive) = (minimum(primitive), maximum(primitive))
 function widths(x::AbstractRange)
     mini, maxi = Float32.(extrema(x))
@@ -54,6 +53,9 @@ function convert_simplex(::Type{Vec{N, T}}, x) where {N, T}
     return (Vec{N, T}(ntuple(i-> i <= N2 ? T(x[i]) : T(0), N)),)
 end
 
+collect_with_eltype(::Type{T}, vec::Vector{T}) where T = vec
+collect_with_eltype(::Type{T}, vec::AbstractVector{T}) where T = collect(vec)
+
 function collect_with_eltype(::Type{T}, iter) where T
     # TODO we could be super smart about allocating the right length
     # but its kinda annoying, since e.g. T == Triangle and first(iter) isa Quad
@@ -70,71 +72,6 @@ function collect_with_eltype(::Type{T}, iter) where T
 end
 
 
-function faces(primitive, nvertices=30)
-    # doesn't have any specific algorithm to generate faces
-    # so will try to triangulate the coordinates!
-    return nothing
-end
-
-function decompose(::Type{F}, primitive, args...) where {F<:AbstractFace}
-    f = faces(primitive, args...)
-    f === nothing && return nothing
-    return collect_with_eltype(F, f)
-end
-
-function decompose(::Type{T}, primitive::AbstractVector{T}) where {T}
-    return primitive
-end
-
-function decompose(::Type{T}, primitive::AbstractVector{T}) where {T<:AbstractFace}
-    return primitive
-end
-
-function decompose(::Type{T}, primitive::AbstractVector{T}) where {T<:AbstractPoint}
-    return primitive
-end
-
-function decompose(::Type{P}, primitive, args...) where {P<:AbstractPoint}
-    return collect_with_eltype(P, coordinates(primitive, args...))
-end
-
-function decompose(::Type{Point}, primitive::Union{GeometryPrimitive{Dim}, Mesh{Dim}}, args...) where {Dim}
-    return collect_with_eltype(Point{Dim, Float32}, coordinates(primitive, args...))
-end
-
-# Dispatch type to make `decompose(UV{Vec2f0}, priomitive)` work
-struct UV{T} end
-UV(::Type{T}) where T = UV{T}()
-struct UVW{T} end
-UVW(::Type{T}) where T = UVW{T}()
-struct Normal{T} end
-Normal(::Type{T}) where T = Normal{T}()
-
-function decompose(::UV{T}, primitive::GeometryPrimitive, args...) where T
-    return collect_with_eltype(T, texturecoordinates(primitive, args...))
-end
-
-decompose_uv(args...) = decompose(UV(Vec2f0), args...)
-
-function decompose(::UVW{T}, primitive::GeometryPrimitive, args...) where T
-    return collect_with_eltype(T, texturecoordinates(primitive, args...))
-end
-
-function normals(primitive, nvertices=30)
-    # doesn't have any specific algorithm to generate normals
-    # so will be generated from faces + positions
-    return nothing
-end
-
-
-function decompose(::Normal{T}, primitive::GeometryPrimitive, args...) where T
-    n = normals(primitive, args...)
-    n === nothing && return nothing
-    return collect_with_eltype(T, n)
-end
-
-decompose_normals(args...) = decompose(Normal(Vec3f0), args...)
-
 """
 The unnormalized normal of three vertices.
 """
@@ -169,14 +106,6 @@ function normals(vertices::AbstractVector{<: AbstractPoint{3, T}},
     return normals_result
 end
 
-function normals(mesh::AbstractMesh)
-    if hasproperty(mesh, :normals)
-        return mesh.normals
-    else
-        return normals(coordinates(mesh), faces(mesh))
-    end
-end
-
 ##
 # Some more primitive types
 
@@ -273,8 +202,6 @@ function rotation(c::Cylinder{3, T}) where T
     return hcat(v, w, u)
 end
 
-best_nvertices(x::Cylinder{2}) = (2, 2)
-
 function coordinates(c::Cylinder{2, T}, nvertices=(2, 2)) where T
     r = Rect(c.origin[1] - c.r/2, c.origin[2], c.r, height(c))
     M = rotation(c)
@@ -287,8 +214,6 @@ function faces(sphere::Cylinder{2}, nvertices=(2, 2))
     return faces(Rect(0, 0, 1, 1), nvertices)
 end
 
-best_nvertices(x::Cylinder{3}) = 30
-
 function coordinates(c::Cylinder{3, T}, nvertices=30) where T
     if isodd(nvertices)
         nvertices = 2 * (nvertices ÷ 2)