How to broadcast a scalar multiplication through a Mesh?

General Usage
, , ,
1

I’m trying to port a JavaScript 3D slicer example to Julia. The example loads a 3D model of a bunny (from https://enkimute.github.io/ganja.js/examples/bunny.obj having 5002 triangle faces) and then calculates horizontal cross sections. The JavaScript version scales all the vertex coordinates in the mesh by a factor of 13 while parsing the individual text lines of the bunny object file. The Julia version can parse the whole bunny object file using Makie.FileIO’s load(). A scalar multiplication broadcast works at the level of triangle faces, but I don’t know how to save the multiplication results back into the structure.

julia> using Makie.FileIO

julia> faces = load("bunny.obj");

julia> nFace = length(faces)
5002

julia> typeof(faces)
GeometryBasics.Mesh{3, Float32, GeometryBasics.Ngon{3, Float32, 3, Point{3, Float32}}, GeometryBasics.SimpleFaceView{3, Float32, 3, GeometryBasics.OffsetInteger{-1, UInt32}, Point{3, Float32}, GeometryBasics.NgonFace{3, GeometryBasics.OffsetInteger{-1, UInt32}}}}

julia> typeof(faces[1]) # 3 vertices of a triangle face
GeometryBasics.Ngon{3, Float32, 3, Point{3, Float32}}

julia> typeof(faces[1][1]) # 3 coordinates of a vertex
Point{3, Float32}

julia> typeof(faces[1][1][1]) # a coordinate
Float32

julia> faces[1]
Triangle(Float32[-0.089491, 0.143926, 0.0124885], Float32[-0.0865619, 0.142492, 0.00843268], Float32[-0.0896984, 0.139713, 0.0137748])

julia> faces[1] .* 13
3-element Vector{Point{3, Float32}}:
 [-1.163383, 1.871038, 0.1623505]
 [-1.1253047, 1.852396, 0.10962484]
 [-1.1660792, 1.816269, 0.1790724]

julia> faces[1] = faces[1] .* 13
ERROR: CanonicalIndexError: setindex! not defined for GeometryBasics.Mesh{3, Float32, GeometryBasics.Ngon{3, Float32, 3, Point{3, Float32}}, GeometryBasics.SimpleFaceView{3, Float32, 3, GeometryBasics.OffsetInteger{-1, UInt32}, Point{3, Float32}, GeometryBasics.NgonFace{3, GeometryBasics.OffsetInteger{-1, UInt32}}}}
Stacktrace:
 [1] error_if_canonical_setindex(#unused#::IndexCartesian, A::GeometryBasics.Mesh{3, Float32, GeometryBasics.Ngon{3, Float32, 3, Point{3, Float32}}, GeometryBasics.SimpleFaceView{3, Float32, 3, GeometryBasics.OffsetInteger{-1, UInt32}, Point{3, Float32}, GeometryBasics.NgonFace{3, GeometryBasics.OffsetInteger{-1, UInt32}}}}, #unused#::Int64)
   @ Base .\abstractarray.jl:1354
 [2] setindex!(A::GeometryBasics.Mesh{3, Float32, GeometryBasics.Ngon{3, Float32, 3, Point{3, Float32}}, GeometryBasics.SimpleFaceView{3, Float32, 3, GeometryBasics.OffsetInteger{-1, UInt32}, Point{3, Float32}, GeometryBasics.NgonFace{3, GeometryBasics.OffsetInteger{-1, UInt32}}}}, v::Vector{Point{3, Float32}}, I::Int64)
   @ Base .\abstractarray.jl:1343
 [3] top-level scope
   @ REPL[17]:1

julia>

I tried using StaticArrays and declaring faces::MArray = load(“bunny.obj”) but got the following error and hint, but I don’t know how to apply the hint to such a complex structure. Any suggestions?

ERROR: LoadError: The size of type `MArray` is not known.

If you were trying to construct (or `convert` to) a `StaticArray` you
may need to add the size explicitly as a type parameter so its size is
inferrable to the Julia compiler (or performance would be terrible). For
example, you might try

    m = zeros(3,3)
    SMatrix(m)            # this error
    SMatrix{3,3}(m)       # correct - size is inferrable
    SArray{Tuple{3,3}}(m) # correct, note Tuple{3,3}

Stacktrace:
 [1] error(s::String)
   @ Base .\error.jl:35
 [2] missing_size_error(#unused#::Type{MArray})
   @ StaticArraysCore C:\Users\gsgm2\.julia\packages\StaticArraysCore\U2Z1K\src\StaticArraysCore.jl:475
 [3] Size(#unused#::Type{MArray})
   @ StaticArraysCore C:\Users\gsgm2\.julia\packages\StaticArraysCore\U2Z1K\src\StaticArraysCore.jl:491
 [4] length(a::Type{MArray})
   @ StaticArrays C:\Users\gsgm2\.julia\packages\StaticArrays\jA1zK\src\abstractarray.jl:2
 [5] convert(#unused#::Type{MArray}, a::GeometryBasics.Mesh{3, Float32, GeometryBasics.Ngon{3, Float32, 3, Point{3, Float32}}, GeometryBasics.SimpleFaceView{3, Float32, 3, GeometryBasics.OffsetInteger{-1, UInt32}, Point{3, Float32}, GeometryBasics.NgonFace{3, GeometryBasics.OffsetInteger{-1, UInt32}}}})
   @ StaticArrays C:\Users\gsgm2\.julia\packages\StaticArrays\jA1zK\src\convert.jl:195
 [6] top-level scope
   @ C:\dev\olarth\PGA\ripga2d3d\slicing.jl:9
 [7] include(fname::String)
   @ Base.MainInclude .\client.jl:476
 [8] top-level scope
   @ REPL[1]:1
in expression starting at C:\dev\olarth\PGA\ripga2d3d\slicing.jl:9
2

Don’t use StaticArrays for something like this. StaticArrays are when the length is a small compile-time constant, and they will be terrible for a length-5002 array (especially whose length is known only at runtime, but even if this were a compile-time constant it would be too long for a StaticArray to be a good idea).

If you want to convert faces= load(“bunny.obj”) into an ordinary Array, you could do Array(faces), since [GeometryMesh is a type of AbstractVector. Or, in one step:

faces= Array(load(“bunny.obj”))

That’s because the Geometry.Mesh is a read-only structure (it implements getindex but not setindex!). That’s why you have to convert to a mutable type like Array to write into the faces array.

2 Likes
3

That removes some abstraction but apparently not enough to allow a scaled element to be saved.

julia> using Makie.FileIO, GeometryBasics

julia> faces = load("bunny.obj");

julia> length(faces)
5002

julia> Afaces = Array(faces);

julia> length(Afaces)
5002

julia> typeof(faces)
GeometryBasics.Mesh{3, Float32, GeometryBasics.Ngon{3, Float32, 3, Point{3, Float32}}, SimpleFaceView{3, Float32, 3, OffsetInteger{-1, UInt32}, Point{3, Float32}, NgonFace{3, OffsetInteger{-1, UInt32}}}}

julia> typeof(Afaces)
Vector{Ngon{3, Float32, 3, Point{3, Float32}}} (alias for Array{GeometryBasics.Ngon{3, Float32, 3, Point{3, Float32}}, 1})

julia> typeof(Afaces[1])
GeometryBasics.Ngon{3, Float32, 3, Point{3, Float32}}

julia> Afaces[1]
Triangle(Float32[-0.089491, 0.143926, 0.0124885], Float32[-0.0865619, 0.142492, 0.00843268], Float32[-0.0896984, 0.139713, 0.0137748])

julia> Afaces[1] .* 13
3-element Vector{Point{3, Float32}}:
 [-1.163383, 1.871038, 0.1623505]
 [-1.1253047, 1.852396, 0.10962484]
 [-1.1660792, 1.816269, 0.1790724]

julia> Afaces[1] = Afaces[1] .* 13
ERROR: MethodError: Cannot `convert` an object of type Vector{Point{3, Float32}} to an object of type GeometryBasics.Ngon{3, Float32, 3, Point{3, Float32}}
Closest candidates are:
  convert(::Type, ::GeoInterface.AbstractGeometryTrait, ::Any) at C:\Users\gsgm2\.julia\packages\GeoInterface\J298z\src\fallbacks.jl:112
  convert(::Type{T}, ::T) where T at Base.jl:61
  GeometryBasics.Ngon{Dim, T, N, Point}(::Any) where {Dim, T<:Real, N, Point<:AbstractPoint{Dim, T}} at C:\Users\gsgm2\.julia\packages\GeometryBasics\KE3OI\src\basic_types.jl:60
Stacktrace:
 [1] setindex!(A::Vector{GeometryBasics.Ngon{3, Float32, 3, Point{3, Float32}}}, x::Vector{Point{3, Float32}}, i1::Int64)
   @ Base .\array.jl:966
 [2] top-level scope
   @ REPL[155]:1

julia>

For a while I was hopeful about using GeometryBasics’ coordinates(), but that loses about half of the faces.

julia> Cfaces = coordinates(faces);

julia> length(Cfaces)
2503

julia> typeof(Cfaces)
Vector{Point{3, Float32}} (alias for Array{Point{3, Float32}, 1})

julia>

There might be some way for Array() or coordinates() or decompose() or convert() or collect() to remove enough abstraction while retaining all the triangle faces but I haven’t found it.

1 Like