switch back to NamedTuple for performance

Author: ffreyer

src/basic_types.jl

@@ -440,18 +440,26 @@ The type of a concrete mesh. It can hold arbitrary vertex data (including FaceVi
 struct Mesh{
         Dim, T <: Real, # TODO: Number?
         FT <: AbstractFace,
+        Names,
+        VAT <: Tuple{<: AbstractVector{Point{Dim, T}}, Vararg{VertexAttributeType}},
         FVT <: AbstractVector{FT}
     } <: AbstractMesh{Dim, T}
 
-    vertex_attributes::Dict{Symbol, VertexAttributeType} 
+    vertex_attributes::NamedTuple{Names, VAT}
     faces::FVT
     views::Vector{UnitRange{Int}}
 
     function Mesh(
-            va::Dict{Symbol, VertexAttributeType}, 
+            vertex_attributes::NamedTuple{Names, VAT}, 
             fs::FVT,
             views::Vector{UnitRange{Int}} = UnitRange{Int}[]
-        ) where {FT <: AbstractFace, FVT <: AbstractVector{FT}}
+        ) where {
+            FT <: AbstractFace, FVT <: AbstractVector{FT}, Names, Dim, T,
+            VAT <: Tuple{<: AbstractVector{Point{Dim, T}}, Vararg{VertexAttributeType}}
+        }
+
+        va = vertex_attributes
+        names = Names
 
         # verify type
         if !haskey(va, :position )
@@ -460,12 +468,13 @@ struct Mesh{
 
         if haskey(va, :normals)
             @warn "`normals` as a vertex attribute name has been deprecated in favor of `normal` to bring it in line with mesh.position and mesh.uv"
-            va[:normal] = pop!(va, :normals)
+            names = ntuple(i -> ifelse(names[i] == :normal, :normal, names[i]), length(names))
+            va = NamedTuple{names}(values(va))
         end
 
         # verify that faces of FaceViews match `fs` (in length per face)
         N = maximum(f -> value(maximum(f)), fs, init = 0)
-        for (name, attrib) in va
+        for (name, attrib) in pairs(va)
             if attrib isa FaceView
                 try
                     verify(fs, attrib)
@@ -477,10 +486,7 @@ struct Mesh{
             end
         end
 
-        D = length(eltype(va[:position]))
-        T = eltype(eltype(va[:position]))
-
-        return new{D, T, FT, FVT}(va, fs, views)
+        return new{Dim, T, FT, names, VAT, FVT}(va, fs, views)
     end
 end
 
@@ -489,7 +495,7 @@ end
         @warn "mesh.normals has been deprecated in favor of mesh.normal to bring it in line with mesh.position and mesh.uv"
         return hasproperty(mesh, :normal)
     end
-    return haskey(getfield(mesh, :vertex_attributes), field) || hasfield(Mesh, field)
+    return hasproperty(getfield(mesh, :vertex_attributes), field) || hasfield(Mesh, field)
 end
 @inline function Base.getproperty(mesh::Mesh, field::Symbol)
     if hasfield(Mesh, field)
@@ -498,11 +504,11 @@ end
         @warn "mesh.normals has been deprecated in favor of mesh.normal to bring it in line with mesh.position and mesh.uv"
         return getproperty(mesh, :normal)
     else
-        return getindex(getfield(mesh, :vertex_attributes), field)
+        return getproperty(getfield(mesh, :vertex_attributes), field)
     end
 end
 @inline function Base.propertynames(mesh::Mesh)
-    return (fieldnames(Mesh)..., keys(getfield(mesh, :vertex_attributes))...)
+    return (fieldnames(Mesh)..., propertynames(getfield(mesh, :vertex_attributes))...)
 end
 
 coordinates(mesh::Mesh) = mesh.position
@@ -530,21 +536,6 @@ function Base.iterate(mesh::Mesh, i=1)
     return i - 1 < length(mesh) ? (mesh[i], i + 1) : nothing
 end
 
-function add_vertex_attribute!(mesh::Mesh, val::AbstractVector, name::Symbol)
-    @boundscheck begin
-        N = maximum(f -> value(maximum(f)), faces(mesh))
-        length(val) < N && error("Given vertex data not large enough to be adressed by all faces ($N required, $(length(val)) given)")
-    end
-    mesh.vertex_attributes[name] = val
-    return mesh
-end
-
-function add_vertex_attribute!(mesh::Mesh, val::FaceView, name::Symbol)
-    @boundscheck verify(faces(mesh), val)
-    mesh.vertex_attributes[name] = val
-    return mesh
-end
-
 """
     Mesh(faces[; views, attributes...])
     Mesh(positions, faces[; views])
@@ -568,14 +559,13 @@ sub-meshes. This is done by providing ranges for indexing faces which correspond
 to the sub-meshes. By default this is left empty.
 """
 function Mesh(faces::AbstractVector{<:AbstractFace}; views::Vector{UnitRange{Int}} = UnitRange{Int}[], attributes...)
-    return Mesh(Dict{Symbol, VertexAttributeType}(attributes), faces, views)
+    return Mesh(NamedTuple(attributes), faces, views)
 end
 
 function Mesh(points::AbstractVector{Point{Dim, T}},
               faces::AbstractVector{<:AbstractFace}; 
               views = UnitRange{Int}[], kwargs...) where {Dim, T}
-    va = Dict{Symbol, VertexAttributeType}(kwargs)
-    va[:position] = points
+    va = (position = points, kwargs...)
     return Mesh(va, faces, views)
 end
 
@@ -585,9 +575,10 @@ function Mesh(points::AbstractVector{<:Point}, faces::AbstractVector{<:Integer},
 end
 
 function Mesh(; kwargs...)
-    va = Dict{Symbol, VertexAttributeType}(kwargs)
-    fs = faces(va[:position]::FaceView)
-    va[:position] = values(va[:position])
+    fs = faces(kwargs[:position]::FaceView)
+    va = NamedTuple{keys(kwargs)}(map(keys(kwargs)) do k
+        return k == :position ? values(kwargs[k]) : kwargs[k]
+    end)
     return Mesh(va, fs)
 end
 

src/meshes.jl

@@ -56,12 +56,10 @@ function mesh(
 
     fs = decompose(facetype, faces)
 
-    va = Dict{Symbol, VertexAttributeType}()
-    for k in keys(vertex_attributes)
-        if !isnothing(vertex_attributes[k])
-            va[k] = convert_facetype(facetype, vertex_attributes[k])
-        end
-    end
+    names = keys(vertex_attributes)
+    valid_names = filter(name -> !isnothing(vertex_attributes[name]), names)
+    vals = convert_facetype.(Ref(facetype), getindex.(Ref(vertex_attributes), valid_names))
+    va = NamedTuple{valid_names}(vals)
 
     return Mesh(positions, fs; va...)
 end
@@ -80,22 +78,22 @@ function mesh(
         attributes...
     ) where {D, T, FT <: AbstractFace}
 
-    va = Dict{Symbol, VertexAttributeType}()
-    for k in keys(attributes)
-        isnothing(attributes[k]) || setindex!(va, attributes[k], k)
-    end
+    names = keys(attributes)
+    valid_names = filter(name -> !isnothing(attributes[name]), names)
 
-    if isempty(va) && (GeometryBasics.pointtype(mesh) == pointtype) && (FT == facetype)
+    if isempty(valid_names) && (GeometryBasics.pointtype(mesh) == pointtype) && (FT == facetype)
         return mesh
     else
-        # 1. add vertex attributes, 2. convert position attribute
+        vals = getindex.(Ref(attributes), valid_names)
+        va = NamedTuple{valid_names}(vals)
+    
+        # add vertex attributes
         va = merge(vertex_attributes(mesh), va)
-        va[:position] = decompose(pointtype, va[:position])
-
-        # Resolve facetype conversions of FaceViews
-        for (k, v) in va
-            va[k] = convert_facetype(facetype, v)
-        end
+        # convert position attribute and facetypes in FaceViews
+        va = NamedTuple{keys(va)}(map(keys(va)) do name
+            val = name == :position ? decompose(pointtype, va[:position]) : va[name]
+            return convert_facetype(facetype, val)
+        end)
 
         # update main face type
         f, views = decompose(facetype, faces(mesh), mesh.views)
@@ -275,18 +273,18 @@ function Base.merge(meshes::AbstractVector{<:Mesh})
         if consistent_face_views
 
             # All the same kind of face, can just merge
-            new_attribs = Dict{Symbol, VertexAttributeType}(map(collect(names)) do name
-                return name => reduce(vcat, getproperty.(meshes, name))
+            new_attribs = NamedTuple{names}(map(names) do name
+                return reduce(vcat, getproperty.(meshes, name))
             end)
             fs = reduce(vcat, faces.(meshes))
 
             # TODO: is the type difference in offset bad?
             idx = length(faces(m1))
-            offset = length(coordinates(m1))::Int
+            offset = length(coordinates(m1))::Int # TODO: unnecessary
             views = isempty(m1.views) ? UnitRange{Int64}[1:idx] : copy(m1.views)
 
             Ns = length.(faces.(meshes))
-            Ms = length.(coordinates.(meshes))::Vector{Int}
+            Ms = length.(coordinates.(meshes))::Vector{Int} # TODO: unnecessary
             for (mesh, N, M) in Iterators.drop(zip(meshes, Ns, Ms), 1)
                 # update face indices
                 for i = idx .+ (1:N)
@@ -330,11 +328,11 @@ function clear_faceviews(mesh::Mesh)
     main_fs = faces(mesh)
     va = vertex_attributes(mesh)
 
-    names = filter(name -> va[name] isa FaceView, collect(keys(va)))
+    names = filter(name -> va[name] isa FaceView, keys(va))
     isempty(names) && return mesh
 
     other_fs = faces.(getproperty.((mesh,), names))
-    pushfirst!(names, :position)
+    names = (:position, names...)
     all_fs = tuple(main_fs, other_fs...)
 
     if isempty(mesh.views)
@@ -343,21 +341,19 @@ function clear_faceviews(mesh::Mesh)
 
         named_maps = NamedTuple{tuple(names...)}(maps)
 
-        new_va = Dict{Symbol, VertexAttributeType}()
-        for (name, attrib) in va
-            new_va[name] = values(attrib)[get(named_maps, name, maps[1])]
-        end
+        new_va = NamedTuple{keys(va)}(map(keys(va)) do name
+            values(va[name])[get(named_maps, name, maps[1])]
+        end)
 
         return Mesh(new_va, new_fs)
 
     else
 
         new_fs = sizehint!(eltype(main_fs)[], length(main_fs))
         new_views = sizehint!(UnitRange{Int}[], length(mesh.views))
-        new_va = Dict{Symbol, VertexAttributeType}()
-        for (name, attrib) in va
-            new_va[name] = sizehint!(eltype(values(attrib))[], length(attrib))
-        end
+        new_va = NamedTuple{keys(va)}(map(keys(va)) do name
+            sizehint!(similar(values(va[name]), 0), length(va[name]))
+        end)
 
         vertex_index_counter = eltype(first(main_fs))(1)
 
@@ -448,16 +444,17 @@ This also removes unused vertices.
 function split_mesh(mesh::Mesh, views::Vector{UnitRange{Int}} = mesh.views)
     return map(views) do idxs
         new_fs, maps = merge_vertex_indices((view(faces(mesh), idxs),))
-        new_va = Dict{Symbol, VertexAttributeType}()
-
-        for (k, v) in vertex_attributes(mesh)
+        
+        names = keys(vertex_attributes(mesh))
+        new_va = NamedTuple{names}(map(names) do name
+            v = getproperty(mesh, name)
             if v isa FaceView
                 _fs, _maps = merge_vertex_indices((view(faces(v), idxs),))
-                new_va[k] = FaceView(values(v)[_maps[1]], _fs)
+                return FaceView(values(v)[_maps[1]], _fs)
             else
-                new_va[k] = v[maps[1]]
+                return v[maps[1]]
             end
-        end
+        end)
 
         return Mesh(new_va, new_fs)
     end

test/runtests.jl

@@ -45,7 +45,7 @@ end
             @test mesh.position === points
             @test GeometryBasics.faces(mesh) === tfaces
             # TODO: Is the order variable with Dict?
-            @test propertynames(mesh) == (:vertex_attributes, :faces, :views, :normal, :position, :stress)
+            @test propertynames(mesh) == (:vertex_attributes, :faces, :views, :position, :normal, :stress)
         end
     end