fix plotting

Author: SimonDanisch

src/geometry_primitives.jl

@@ -106,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
 
@@ -210,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)
@@ -224,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)

src/interfaces.jl

@@ -60,7 +60,6 @@ function Tesselation(primitive::GeometryPrimitive{Dim, T}, nvertices::NTuple{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
@@ -85,10 +84,13 @@ const Meshable{Dim, T} = Union{Tesselation{Dim, T}, Mesh{Dim, T},
 
 struct UV{T} end
 UV(::Type{T}) where T = UV{T}()
+UV() = UV(Vec2f0)
 struct UVW{T} end
 UVW(::Type{T}) where T = UVW{T}()
+UVW() = UVW(Vec3f0)
 struct Normal{T} end
 Normal(::Type{T}) where T = Normal{T}()
+Normal() = Normal(Vec3f0)
 
 function decompose(::Type{F}, primitive) where {F<:AbstractFace}
     f = faces(primitive)
@@ -108,16 +110,33 @@ 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)
+decompose_uv(primitive) = decompose(UV(), primitive)
+decompose_uvw(primitive) = decompose(UVW(), primitive)
+decompose_normals(primitive) = decompose(Normal(), primitive)
 
-function decompose(::Normal{T}, primitive) where T
+function decompose(NT::Normal{T}, primitive) where T
     n = normals(primitive)
-    n === nothing && return nothing
+    if n === nothing
+        return decompose(NT, normals(coordinates(primitive), faces(primitive)))
+    end
     return collect_with_eltype(T, n)
 end
 
-function decompose(::Union{UV{T}, UVW{T}}, primitive) where T
-    return collect_with_eltype(T, texturecoordinates(primitive))
+function decompose(UVT::Union{UV{T}, UVW{T}}, primitive) where T
+    uv = texturecoordinates(primitive)
+    if uv === nothing
+        return decompose(UVT, texturecoordinates(coordinates(primitive)))
+    end
+    return collect_with_eltype(T, uv)
+end
+
+function texturecoordinates(positions::AbstractVector{<:VecTypes})
+    bb = Rect(positions)
+    return map(positions) do p
+        return (p .- minimum(bb)) ./ widths(bb)
+    end
 end
+
+# Stay backward compatible:
+
+decompose(::Type{T}, primitive::Meshable, nvertices) where T = decompose(T, Tesselation(primitive, nvertices))

src/meshes.jl

@@ -2,7 +2,18 @@ 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
+
+function texturecoordinates(mesh::AbstractMesh)
+    hasproperty(mesh, :uv) && return mesh.uv
+    hasproperty(mesh, :uvw) && return mesh.uvw
+    return nothing
+end
+
+function normals(mesh::AbstractMesh)
+    hasproperty(mesh, :normals) && return mesh.normals
+    return nothing
+end
+
 
 const GLTriangleElement = Triangle{3, Float32}
 const GLTriangleFace = TriangleFace{GLIndex}
@@ -74,7 +85,7 @@ const GLNormalUVWMesh{Dim} = NormalUVWMesh{Dim, Float32}
 const GLNormalUVWMesh2D = GLNormalUVWMesh{2}
 const GLNormalUVWMesh3D = GLNormalUVWMesh{3}
 
-best_pointtype(::GeometryPrimitive{N, T}) where {N, T} = Point{N, T}
+best_pointtype(::Meshable{Dim, T}) where {Dim, T} = Point{Dim, T}
 
 """
     mesh(primitive::GeometryPrimitive;
@@ -106,9 +117,9 @@ function mesh(primitive::Meshable;
     end
 
     if normaltype !== nothing
-        primitive_normals = decompose(Normal(normaltype), primitive)
+        primitive_normals = normals(primitive)
         if primitive_normals !== nothing
-            attributes[:normals] = primitive_normals
+            attributes[:normals] = decompose(normaltype, primitive_normals)
         else
             # Normals not implemented for primitive, so we calculate them!
             n = normals(positions, faces)
@@ -156,7 +167,7 @@ end
 
 function normal_mesh(points::AbstractVector{<:AbstractPoint},
                      faces::AbstractVector{<:AbstractFace})
-    _points = convert(Vector{Point3f0}, points)
+    _points = decompose(Point3f0, points)
     _faces = decompose(GLTriangleFace, faces)
     return Mesh(meta(_points; normals=normals(_points, _faces)), _faces)
 end
@@ -166,6 +177,15 @@ function normal_mesh(primitive::Meshable{N}) where {N}
                 facetype=GLTriangleFace)
 end
 
+## Backward compatibility
+function normal_mesh(primitive::GeometryPrimitive; nvertices=30)
+    return normal_mesh(Tesselation(primitive, nvertices))
+end
+
+function triangle_mesh(primitive::GeometryPrimitive; nvertices=30)
+    return triangle_mesh(Tesselation(primitive, nvertices))
+end
+
 """
     volume(triangle)
 
@@ -205,19 +225,6 @@ function Base.merge(meshes::AbstractVector{<: Mesh})
     end
 end
 
-function decompose(::Normal{T}, mesh::Mesh) where {T}
-    normal_vectors = normals(mesh)
-    return decompose(T, normal_vectors)
-end
-
-function decompose(::UV{T}, mesh::Mesh) where {T}
-    if hasproperty(mesh, :uv)
-        return decompose(T, mesh.uv)
-    else
-        error("Mesh doesn't have UV texture coordinates")
-    end
-end
-
 """
     pointmeta(mesh::Mesh; meta_data...)
 
@@ -232,6 +239,14 @@ function pointmeta(mesh::Mesh; meta_data...)
     return Mesh(meta(metafree(points); attr..., meta_data...), faces(mesh))
 end
 
+function pointmeta(mesh::Mesh, uv::UV)
+    return pointmeta(mesh; uv=decompose(uv, mesh))
+end
+
+function pointmeta(mesh::Mesh, normal::Normal)
+    return pointmeta(mesh; normal=decompose(normal, mesh))
+end
+
 """
     pop_pointmeta(mesh::Mesh, property::Symbol)
 Remove `property` from point metadata.

test/geometrytypes.jl

@@ -206,8 +206,6 @@ end
     @test decompose(Point2f0, mesh) ≈ decompose(Point2f0, tess_circle)
 end
 
-
-
 @testset "Rectangles" begin
     rect = FRect2D(0, 7, 20, 3)
     @test (rect + 4) == FRect2D(4, 11, 20, 3)

test/runtests.jl

@@ -303,6 +303,19 @@ end
     points = decompose(Point2f0, Circle(Point2f0(0), 1))
     triangle_mesh(points)
     @test true # yay no errors so far!
+
+    m = GeometryBasics.mesh(Sphere(Point3f0(0), 1))
+    @test normals(m) == nothing
+    m_normals = pointmeta(m, Normal(Vec3f0))
+    @test normals(m_normals) isa Vector{Vec3f0}
+
+    @test texturecoordinates(m) == nothing
+    uv = decompose_uv(m)
+    @test Rect(Point.(uv)) == Rect(0, 0, 1, 1)
+
+    points = decompose(Point2f0, Circle(Point2f0(0), 1))
+    m = GeometryBasics.mesh(points)
+    @test coordinates(m) === points
 end
 
 @testset "Tests from GeometryTypes" begin