sjk/nodep1

Project.toml

@@ -3,10 +3,8 @@ uuid = "e6723b4c-ebff-59f1-b4b7-d97aa5274f73"
 version = "0.7.0"
 
 [deps]
-StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 
 [compat]
-StaticArrays = "1"
 julia = "1.9"
 
 [extras]

docs/src/internals.md

@@ -8,8 +8,6 @@ This is some brief documentation on the basic internal functions.
 ```@docs
 Meshing._DEFAULT_SAMPLES
 Meshing._get_cubeindex
-Meshing._get_cubeindex_pos
-Meshing._determine_types
 ```
 
 ## Marching Cubes

src/Meshing.jl

@@ -1,7 +1,5 @@
 module Meshing
 
-using StaticArrays
-
 """
     _DEFAULT_SAMPLES = (24,24,24)
 
@@ -13,13 +11,11 @@ include("algorithmtypes.jl")
 include("common.jl")
 include("marching_tetrahedra.jl")
 include("marching_cubes.jl")
-include("surface_nets.jl")
 include("roots.jl")
 include("adaptive.jl")
 
 export isosurface,
        MarchingCubes,
-       MarchingTetrahedra,
-       NaiveSurfaceNets
+       MarchingTetrahedra
 
 end # module

src/adaptive.jl

@@ -12,7 +12,7 @@ end
 
 
 function vertices(h::HyperRectangle, ::Type{SV}) where SV
-    z = zero(eltype(SV))
+    z = zero(eltype(h.origin))
     @inbounds begin
         o = SV(h.origin[1],h.origin[2],h.origin[3])
         w = SV(h.widths[1],h.widths[2],h.widths[3])

src/algorithmtypes.jl

@@ -13,49 +13,22 @@ abstract type AbstractMeshingAlgorithm end
 abstract type AbstractAdaptiveMeshingAlgorithm end
 
 
-function (::Type{MeshAlgo})(;iso::T1=0.0, eps::T2=1e-3, reduceverts::Bool=true, insidepositive::Bool=false) where {T1, T2, MeshAlgo <: AbstractMeshingAlgorithm}
-    if isconcretetype(MeshAlgo)
-        return MeshAlgo(iso, eps, reduceverts, insidepositive)
-    else
-        return MeshAlgo{promote_type(T1, T2)}(iso, eps, reduceverts, insidepositive)
-    end
-end
-
-function (::Type{MeshAlgo})(iso) where MeshAlgo <: AbstractMeshingAlgorithm
-    MeshAlgo(iso=iso)
-end
-
-function (::Type{MeshAlgo})(iso,eps) where MeshAlgo <: AbstractMeshingAlgorithm
-    MeshAlgo(iso=iso,eps=eps)
-end
-
 """
-    MarchingCubes(iso=0.0, eps=1e-3, reduceverts=true, insidepositive=false)
-    MarchingCubes(;iso=0.0, eps=1e-3, reduceverts=true, insidepositive=false)
-    MarchingCubes(iso)
-    MarchingCubes(iso,eps)
+    MarchingCubes(;iso=0.0)
 
 Specifies the use of the Marching Cubes algorithm for isosurface extraction.
 This algorithm provides a good balance between performance and vertex count.
 In contrast to the other algorithms, vertices may be repeated, so mesh size
 may be large and it will be difficult to extract topological/connectivity information.
 
 - `iso` (default: 0.0) specifies the iso level to use for surface extraction.
-- `eps` (default: 1e-3) is the tolerence around a voxel corner to ensure manifold mesh generation.
-- `reduceverts` (default: true) if true will merge vertices within a voxel to reduce mesh size by around 30% and with slight performance improvement.
 """
-struct MarchingCubes{T} <: AbstractMeshingAlgorithm
-    iso::T
-    eps::T
-    reduceverts::Bool
-    insidepositive::Bool
+Base.@kwdef struct MarchingCubes{T} <: AbstractMeshingAlgorithm
+    iso::T = 0.0
 end
 
 """
-    MarchingTetrahedra(iso=0.0, eps=1e-3, reduceverts=true, insidepositive=false)
-    MarchingTetrahedra(;iso=0.0, eps=1e-3, reduceverts=true, insidepositive=false)
-    MarchingTetrahedra(iso)
-    MarchingTetrahedra(iso,eps)
+    MarchingTetrahedra(;iso=0.0, eps=1e-3)
 
 Specifies the use of the Marching Tetrahedra algorithm for isosurface extraction.
 This algorithm has a roughly 2x performance penalty compared to Marching Cubes,
@@ -64,40 +37,15 @@ making this algorithm useful for topological analysis.
 
 - `iso` specifies the iso level to use for surface extraction.
 - `eps` is the tolerence around a voxel corner to ensure manifold mesh generation.
-- `reduceverts` (default: true) if false, vertices will not be unique and have repeated face references.
 """
-struct MarchingTetrahedra{T} <: AbstractMeshingAlgorithm
-    iso::T
-    eps::T
-    reduceverts::Bool
-    insidepositive::Bool
+Base.@kwdef struct MarchingTetrahedra{T,E} <: AbstractMeshingAlgorithm
+    iso::T = 0.0
+    eps::E = 1e-3
 end
 
 """
-    NaiveSurfaceNets(iso=0.0, eps=1e-3, reduceverts=true, insidepositive=false)
-    NaiveSurfaceNets(;iso=0.0, eps=1e-3, reduceverts=true, insidepositive=false)
-    NaiveSurfaceNets(iso)
-    NaiveSurfaceNets(iso,eps)
-
-Specifies the use of the Naive Surface Nets algorithm for isosurface extraction.
-This algorithm has a slight performance advantage in some cases over Marching Cubes.
-Each vertex is guaranteed to not be repeated (useful for topological analysis),
-however the algorithm does not guarantee accuracy and generates quad faces.
-
-- `iso` specifies the iso level to use for surface extraction.
-- `eps` is the tolerence around a voxel corner to ensure manifold mesh generation.
-- `reduceverts` reserved for future use.
-"""
-struct NaiveSurfaceNets{T} <: AbstractMeshingAlgorithm
-    iso::T
-    eps::T
-    reduceverts::Bool
-    insidepositive::Bool
-end
-
-"""
-    MarchingCubes(iso=0.0, eps=1e-3, reduceverts=true, insidepositive=false)
-    MarchingCubes(;iso=0.0, eps=1e-3, reduceverts=true, insidepositive=false)
+    MarchingCubes(iso=0.0, eps=1e-3)
+    MarchingCubes(;iso=0.0, eps=1e-3)
     MarchingCubes(iso)
     MarchingCubes(iso,eps)
 
@@ -110,12 +58,11 @@ may be large and it will be difficult to extract topological/connectivity inform
 - `eps` (default: 1e-3) is the tolerence around a voxel corner to ensure manifold mesh generation.
 - `reduceverts` (default: true) if true will merge vertices within a voxel to reduce mesh size by around 30% and with slight performance improvement.
 """
-struct AdaptiveMarchingCubes{T} <: AbstractAdaptiveMeshingAlgorithm
+struct AdaptiveMarchingCubes{T,E} <: AbstractAdaptiveMeshingAlgorithm
     iso::T
     eps::T
     rtol::T
     atol::T
-    reduceverts::Bool
 end
 
 
@@ -124,13 +71,4 @@ struct AdaptiveMarchingTetrahedra{T} <: AbstractAdaptiveMeshingAlgorithm
     eps::T
     rtol::T
     atol::T
-    reduceverts::Bool
 end
-
-
-#
-# Helper functions
-#
-
-default_face_length(::Union{MarchingCubes,MarchingTetrahedra}) = 3
-default_face_length(::NaiveSurfaceNets) = 4

src/lut/mc.jl

@@ -578,30 +578,30 @@ const _mc_eq_mapping = (0x01, 0x01, 0x02, 0x01, 0x03, 0x02, 0x04, 0x01, 0x02, 0x
                         0x15, 0x10, 0x10, 0x03, 0x0c, 0x14, 0x11, 0x01, 0x18, 0x0c, 0x0c,
                         0x11, 0x0c, 0x14, 0x11, 0x01, 0x0c, 0x11, 0x14, 0x01, 0x11, 0x01, 0x01)
 
-const _mc_connectivity = ((0x01, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x01, 0x04, 0x02, 0x04, 0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x03, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x01, 0x04, 0x02, 0x05, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x01, 0x03, 0x04, 0x01, 0x04, 0x05, 0x04, 0x03, 0x06, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x04, 0x01, 0x03, 0x04, 0x03, 0x05, 0x04, 0x05, 0x06, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x01, 0x04, 0x02, 0x01, 0x05, 0x04, 0x06, 0x02, 0x04, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x04, 0x06, 0x07, 0x06, 0x05, 0x08, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x01, 0x03, 0x04, 0x04, 0x03, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x01, 0x03, 0x04, 0x01, 0x04, 0x05, 0x06, 0x04, 0x03, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x05, 0x07, 0x06, 0x05, 0x08, 0x07, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x03, 0x02, 0x04, 0x05, 0x06, 0x07, 0x05, 0x07, 0x08, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x01, 0x03, 0x04, 0x02, 0x05, 0x03, 0x06, 0x03, 0x07, 0x05, 0x07, 0x03),
-                            (0x01, 0x02, 0x03, 0x04, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x01, 0x04, 0x02, 0x01, 0x05, 0x04, 0x06, 0x04, 0x05, 0x07, 0x08, 0x09),
-                            (0x01, 0x02, 0x03, 0x01, 0x03, 0x04, 0x05, 0x06, 0x03, 0x06, 0x04, 0x03, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x01, 0x04, 0x02, 0x01, 0x05, 0x04, 0x04, 0x06, 0x02, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x04, 0x02, 0x01, 0x04, 0x05, 0x02, 0x04, 0x06, 0x05, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x01, 0x04, 0x02, 0x05, 0x06, 0x07, 0x06, 0x08, 0x07, 0x00, 0x00, 0x00),
-                            (0x01, 0x02, 0x03, 0x02, 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00))
+const _mc_connectivity = ((0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
+                        (0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
+                        (0x04, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
+                        (0x01, 0x04, 0x02, 0x04, 0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
+                        (0x03, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
+                        (0x01, 0x04, 0x02, 0x05, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
+                        (0x01, 0x03, 0x04, 0x01, 0x04, 0x05, 0x04, 0x03, 0x06, 0x00, 0x00, 0x00),
+                        (0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
+                        (0x04, 0x01, 0x03, 0x04, 0x03, 0x05, 0x04, 0x05, 0x06, 0x00, 0x00, 0x00),
+                        (0x01, 0x04, 0x02, 0x01, 0x05, 0x04, 0x06, 0x02, 0x04, 0x00, 0x00, 0x00),
+                        (0x04, 0x05, 0x06, 0x04, 0x06, 0x07, 0x06, 0x05, 0x08, 0x00, 0x00, 0x00),
+                        (0x01, 0x03, 0x04, 0x04, 0x03, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
+                        (0x01, 0x03, 0x04, 0x01, 0x04, 0x05, 0x06, 0x04, 0x03, 0x00, 0x00, 0x00),
+                        (0x04, 0x05, 0x06, 0x05, 0x07, 0x06, 0x05, 0x08, 0x07, 0x00, 0x00, 0x00),
+                        (0x03, 0x02, 0x04, 0x05, 0x06, 0x07, 0x05, 0x07, 0x08, 0x00, 0x00, 0x00),
+                        (0x01, 0x03, 0x04, 0x02, 0x05, 0x03, 0x06, 0x03, 0x07, 0x05, 0x07, 0x03),
+                        (0x04, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
+                        (0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x00, 0x00, 0x00),
+                        (0x01, 0x04, 0x02, 0x01, 0x05, 0x04, 0x06, 0x04, 0x05, 0x07, 0x08, 0x09),
+                        (0x01, 0x03, 0x04, 0x05, 0x06, 0x03, 0x06, 0x04, 0x03, 0x00, 0x00, 0x00),
+                        (0x01, 0x04, 0x02, 0x01, 0x05, 0x04, 0x04, 0x06, 0x02, 0x00, 0x00, 0x00),
+                        (0x04, 0x02, 0x01, 0x04, 0x05, 0x02, 0x04, 0x06, 0x05, 0x00, 0x00, 0x00),
+                        (0x01, 0x04, 0x02, 0x05, 0x06, 0x07, 0x06, 0x08, 0x07, 0x00, 0x00, 0x00),
+                        (0x02, 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00))
 
 const _mc_edge_list = ((0x01, 0x02), (0x02, 0x03), (0x03, 0x04), (0x04, 0x01),
                         (0x05, 0x06), (0x06, 0x07), (0x07, 0x08), (0x08, 0x05),

src/lut/mt.jl

@@ -20,20 +20,14 @@ Voxel corner and edge indexing conventions
   /
  X
 """
-# this gets vectorized so we want to ensure it is the
-# same type as out vertex
-@inline function voxCrnrPos(::Type{PT}) where {PT}
-    (PT(0, 0, 0),
-    PT(0, 1, 0),
-    PT(1, 1, 0),
-    PT(1, 0, 0),
-    PT(0, 0, 1),
-    PT(0, 1, 1),
-    PT(1, 1, 1),
-    PT(1, 0, 1))
-end
-
-const voxCrnrPosInt = voxCrnrPos(SVector{3,UInt8})
+const voxCrnrPos = ((0, 0, 0),
+                    (0, 1, 0),
+                    (1, 1, 0),
+                    (1, 0, 0),
+                    (0, 0, 1),
+                    (0, 1, 1),
+                    (1, 1, 1),
+                    (1, 0, 1))
 
 # the voxel IDs at either end of the tetrahedra edges, by edge ID
 const voxEdgeCrnrs = ((0x01, 0x02),