improve meshing interface

Author: SimonDanisch

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
@@ -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

@@ -69,7 +69,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!
@@ -94,6 +93,14 @@ function decompose(::Type{T}, primitive::AbstractVector{T}) where {T<:AbstractPo
     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
@@ -365,6 +372,9 @@ 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

@@ -0,0 +1,29 @@
+"""
+    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
+
+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)

src/meshes.jl

@@ -2,6 +2,7 @@ const FaceMesh{Dim, T, Element} = Mesh{Dim, T, Element, <: FaceView{Element}}
 
 coordinates(mesh::FaceMesh) = coordinates(getfield(mesh, :simplices))
 faces(mesh::FaceMesh) = faces(getfield(mesh, :simplices))
+best_nvertices(mesh::Mesh) = nothing
 
 const GLTriangleElement = Triangle{3, Float32}
 const GLTriangleFace = TriangleFace{GLIndex}
@@ -73,9 +74,11 @@ const GLNormalUVWMesh{Dim} = NormalUVWMesh{Dim, Float32}
 const GLNormalUVWMesh2D = GLNormalUVWMesh{2}
 const GLNormalUVWMesh3D = GLNormalUVWMesh{3}
 
-best_nvertices(any_primitive) = 24
-best_pointtype(::GeometryPrimitive{N, T}) where {N, T} = Point{N, T}
+# Types that can be converted to a mesh via the functions below
+const MeshLike{N, T} = Union{Mesh{N, T}, GeometryPrimitive{N, T}, AbstractVector{<: AbstractPoint{N, T}}}
 
+best_nvertices(any_primitive) = nothing
+best_pointtype(::GeometryPrimitive{N, T}) where {N, T} = Point{N, T}
 
 """
     mesh(primitive::GeometryPrimitive;
@@ -90,7 +93,7 @@ Note, that this can be an `Int` or `Tuple{Int, Int}``, when the primitive is gri
 It also only losely correlates to the number of vertices, depending on the algorithm used.
 #TODO: find a better number here!
 """
-function mesh(primitive::GeometryPrimitive;
+function mesh(primitive::MeshLike;
               pointtype=best_pointtype(primitive), facetype=GLTriangleFace,
               uv=nothing, normaltype=nothing, nvertices=nothing)
 
@@ -149,40 +152,33 @@ function mesh(polygon::AbstractVector{P}; pointtype=P, facetype=GLTriangleFace,
     return Mesh(positions, faces)
 end
 
-mesh(m::Mesh) = m
-triangle_mesh(m::Mesh) = m
-
-function triangle_mesh(primitive::GeometryPrimitive{N}; nvertices=nothing) where {N}
+function triangle_mesh(primitive::MeshLike{N}; nvertices=nothing) where {N}
     return mesh(primitive; pointtype=Point{N, Float32}, facetype=GLTriangleFace, nvertices=nvertices)
 end
 
 
-function triangle_mesh(polygon::AbstractVector{<: AbstractPoint{2}})
-    return mesh(polygon; pointtype=Point{2, Float32}, facetype=GLTriangleFace)
-end
-
-function uv_mesh(primitive::GeometryPrimitive{N, T}; nvertices=nothing) where {N, T}
+function uv_mesh(primitive::MeshLike{N, T}; nvertices=nothing) where {N, T}
     return mesh(primitive; pointtype=Point{N, Float32}, uv=Vec2f0,
                 facetype=GLTriangleFace, nvertices=nvertices)
 end
 
-function uv_normal_mesh(primitive::GeometryPrimitive{N}; nvertices=nothing) where {N}
+function uv_normal_mesh(primitive::MeshLike{N}; nvertices=nothing) where {N}
     return mesh(primitive; pointtype=Point{N, Float32}, uv=Vec2f0, normaltype=Vec3f0,
                 facetype=GLTriangleFace, nvertices=nvertices)
 end
 
-function normal_mesh(primitive::GeometryPrimitive{N}; nvertices=nothing) where {N}
-    return mesh(primitive; pointtype=Point{N, Float32}, normaltype=Vec3f0,
-                facetype=GLTriangleFace, nvertices=nvertices)
-end
-
 function normal_mesh(points::AbstractVector{<:AbstractPoint},
                      faces::AbstractVector{<:AbstractFace})
     _points = convert(Vector{Point3f0}, points)
     _faces = decompose(GLTriangleFace, faces)
     return Mesh(meta(_points; normals=normals(_points, _faces)), _faces)
 end
 
+function normal_mesh(primitive::MeshLike{N}; nvertices=nothing) where {N}
+    return mesh(primitive; pointtype=Point{N, Float32}, normaltype=Vec3f0,
+                facetype=GLTriangleFace, nvertices=nvertices)
+end
+
 """
     volume(triangle)
 

src/viewtypes.jl

@@ -138,11 +138,9 @@ Tables.schema(faceview::FaceView) = Tables.schema(getfield(faceview, :elements))
 
 Base.size(faceview::FaceView) = size(getfield(faceview, :faces))
 
-Base.show(io::IO, ::Type{<: FaceView{Element}}) where Element = print(io, "FaceView{", Element, "}")
-
 function Base.show(io::IO, ::Type{<: FaceView{Element}}) where Element
     if @isdefined Element
-        print(io, "FaceView{", T, "}")
+        print(io, "FaceView{", Element, "}")
     else
         print(io, "FaceView{Element}")
     end