better mesh conversion interface

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

@@ -82,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
 
 
@@ -139,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
@@ -154,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], ")")
 
@@ -175,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
 
 """
@@ -196,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
 
 """
@@ -228,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{
@@ -244,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
 
 
@@ -272,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]
@@ -288,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]

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,10 @@ 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{P}, vec::Vector{MetaPoint{P}}) 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
@@ -69,78 +72,6 @@ function collect_with_eltype(::Type{T}, iter) where T
     return result
 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{T}, primitive::AbstractVector{T2}) where {T, T2 <: Union{StaticVector, AbstractPoint}}
-    return convert(Vector{T}, primitive)
-end
-
-function decompose(::Type{T}, primitive::AbstractVector, args...) where {T<:AbstractPoint}
-    return collect_with_eltype(P, coordinates(primitive, args...))
-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.
@@ -372,9 +303,6 @@ function texturecoordinates(s::Circle, nvertices=64)
     return coordinates(Circle(Point2f0(0.5), 0.5f0), nvertices)
 end
 
-best_nvertices(x::Circle) = 64
-best_nvertices(x::Sphere) = 24
-
 function coordinates(s::Sphere, nvertices=24)
     θ = LinRange(0, pi, nvertices); φ = LinRange(0, 2pi, nvertices)
     inner(θ, φ) = Point(cos(φ)*sin(θ), sin(φ)*sin(θ), cos(θ)) .* s.r .+ s.center

src/interfaces.jl

@@ -18,12 +18,106 @@ function faces(f::AbstractVector{<:AbstractFace})
     return f
 end
 
-coordinates(x, ::Nothing) = coordinates(x)
-faces(x, ::Nothing) = faces(x)
-decompose(x, ::Nothing) = decompose(x)
-decompose(t::Type{<:Point}, x, ::Nothing) = decompose(t, x)
-decompose(t::Type{<:NgonFace}, x, ::Nothing) = decompose(t, x)
-decompose(t::Vec, x, ::Nothing) = decompose(t, x)
-decompose(t::UV, x, ::Nothing) = decompose(t, x)
-decompose(t::UVW, x, ::Nothing) = decompose(t, x)
-decompose(t::Normal, x, ::Nothing) = decompose(t, x)
+function normals(primitive, nvertices=nothing)
+    # doesn't have any specific algorithm to generate normals
+    # so will be generated from faces + positions
+    # which we indicate by returning nothing!
+    # Overload normals(primitive::YourPrimitive), to calcalute the normals
+    # differently
+    return nothing
+end
+
+function faces(primitive, nvertices=nothing)
+    # doesn't have any specific algorithm to generate faces
+    # so will try to triangulate the coordinates!
+    return nothing
+end
+
+"""
+    Tesselation(primitive, nvertices)
+For abstract geometries, when we generate
+a mesh from them, we need to decide how fine grained we want to mesh them.
+To transport this information to the various decompose methods, you can wrap it
+in the Tesselation object e.g. like this:
+
+```julia
+sphere = Sphere(Point3f0(0), 1)
+m1 = mesh(sphere) # uses a default value for tesselation
+m2 = mesh(Tesselation(sphere, 64)) # uses 64 for tesselation
+length(coordinates(m1)) != length(coordinates(m2))
+```
+For grid based tesselation, you can also use a tuple:
+```julia
+rect = Rect2D(0, 0, 1, 1)
+Tesselation(rect, (5, 5))
+"""
+struct Tesselation{Dim, T, Primitive, NGrid}
+    primitive::Primitive
+    nvertices::NTuple{NGrid, Int}
+end
+
+function Tesselation(primitive::GeometryPrimitive{Dim, T}, nvertices::NTuple{N, <:Integer}) where {Dim, T, N}
+    return Tesselation{Dim, T, typeof(primitive), N}(primitive, Int.(nvertices))
+end
+
+
+Tesselation(primitive, nvertices::Integer) = Tesselation(primitive, (nvertices,))
+
+# This is a bit lazy, I guess we should just refactor these methods
+# to directly work on Tesselation - but this way it's backward compatible and less
+# refactor work :D
+nvertices(tesselation::Tesselation) = tesselation.nvertices
+nvertices(tesselation::Tesselation{T, N, P, 1}) where {T, N, P} = tesselation.nvertices[1]
+
+coordinates(tesselation::Tesselation) = coordinates(tesselation.primitive, nvertices(tesselation))
+faces(tesselation::Tesselation) = faces(tesselation.primitive, nvertices(tesselation))
+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}, priomitive)` 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},
+                               GeometryPrimitive{Dim, T}, AbstractVector{<: AbstractPoint{Dim, T}}}
+
+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(::Type{F}, primitive) where {F<:AbstractFace}
+    f = faces(primitive)
+    f === nothing && return nothing
+    return collect_with_eltype(F, f)
+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{T}, primitive) where {T}
+    return collect_with_eltype(T, primitive)
+end
+
+decompose_uv(primitive) = decompose(UV(Vec2f0), primitive)
+decompose_uvw(primitive) = decompose(UVW(Vec3f0), primitive)
+decompose_normals(primitive) = decompose(Normal(Vec3f0), primitive)
+
+function decompose(::Normal{T}, primitive) where T
+    n = normals(primitive)
+    n === nothing && return nothing
+    return collect_with_eltype(T, n)
+end
+
+function decompose(::Union{UV{T}, UVW{T}}, primitive) where T
+    return collect_with_eltype(T, texturecoordinates(primitive))
+end

src/lines.jl

@@ -60,7 +60,6 @@ function intersects(a::Line{2, T1}, b::Line{2, T2}) where {T1, T2}
     return true, point
 end
 
-
 function simple_concat(vec::AbstractVector, range, endpoint::P) where P
     result = Vector{P}(undef, length(range) + 1)
     for (i, j) in enumerate(range)
@@ -70,7 +69,6 @@ function simple_concat(vec::AbstractVector, range, endpoint::P) where P
     return result
 end
 
-
 function consecutive_pairs(arr)
     n = length(arr)
     zip(view(arr, 1:n-1), view(arr, 2:n))