Struct SparseField 

pub struct SparseField<T: Float> { /* private fields */ }

3-dimensional sparse field for scalar values.

The field uses a three-level hierarchical structure:

• A dynamic root node that can be subdivided arbitrarily (e.g., 1x1x2, 2x2x2, etc.)
• Internal nodes with a fixed subdivision pattern defined by BlockSize
• Dense leaf nodes containing the actual field data

This structure provides a balance between memory efficiency and computational performance, allowing dense sampling only in regions where the field is active. Empty or uniform regions can be efficiently represented at the internal node level.

Note: This type should not be constructed directly. Instead, use ~SparseSampler to sample and extract a sparse field from an implicit model.

Implementations

impl<T: Float> SparseField<T>

pub fn new(config: SparseFieldConfig<T>) -> Self

Creates a new empty sparse field with the given configuration.

Arguments

• config - The configuration specifying block sizes and sampling mode.

pub fn init_bounds(&mut self, bounds: &BoundingBox<T>)

Initializes the field’s bounds and activates the necessary internal nodes.

Arguments

• bounds - The bounding box defining the field’s extents.

impl<T: ModelFloat + 'static + Default> SparseField<T>

pub fn n_active_nodes(&self) -> usize

Compute the total number of active leaf nodes.

Trait Implementations

impl<T: Float + 'static> CellIterator<T> for SparseField<T>

fn iter_cells<'a>(&'a self) -> Self::Iter<'a>

Returns an iterator that yields all cell coordinates in the leaf nodes in the sparse field.

type Iter<'a> = Box<dyn Iterator<Item = BoundingBox<T>> + 'a> where Self: 'a

A different Iterator<Item=BoundingBox<T>> for each borrow‐lifetime 'a.

impl<T: Float + 'static> CellValueIterator<T> for SparseField<T>

fn iter_cell_values<'a>(&'a self) -> Self::Iter<'a>

Returns an iterator that yields the values at each cell’s corners in the leaf nodes in the sparse field.

type Iter<'a> = Box<dyn Iterator<Item = [T; 8]> + 'a> where Self: 'a

A different Iterator<Item=[T;8]> for each borrow‐lifetime 'a.

impl<T: Clone + Float> Clone for SparseField<T>

fn clone(&self) -> SparseField<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Float> Debug for SparseField<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for SparseField<T>

where T: Deserialize<'de> + Float,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Float + 'static> PointIterator<T> for SparseField<T>

fn iter_points<'a>(&'a self) -> Self::Iter<'a>

Returns an iterator that yields all point coordinates in each leaf node in the sparse field.

type Iter<'a> = Box<dyn Iterator<Item = Vec3<T>> + 'a> where Self: 'a

A different Iterator<Item=Vec3<T>> for each borrow‐lifetime 'a.

impl<T: ModelFloat + 'static + Default> Sampler<T, SparseField<T>> for SparseSampler<T>

fn sample_field( &mut self, model: &ImplicitModel<T>, ) -> Result<&SparseField<T>, ModelError>

Sample a field for the default component given by ImplicitModel::get_default_output

fn sample_field_for_component( &mut self, model: &ImplicitModel<T>, component_tag: &str, ) -> Result<&SparseField<T>, ModelError>

Sample a field from one of the model components.

fn iso_surface(&self, iso_val: T) -> Result<Mesh<T>, ModelError>

Extract an iso-surface for a certain iso value.

fn field(&self) -> &SparseField<T>

Access the field data.

impl<T> Serialize for SparseField<T>

where T: Serialize + Float,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Float + 'static> ValueIterator<T> for SparseField<T>

fn iter_values<'a>(&'a self) -> Self::Iter<'a>

Returns an iterator that yields each value in the leaf nodes in the sparse field.

type Iter<'a> = Box<dyn Iterator<Item = T> + 'a> where Self: 'a

A different Iterator<Item=T> for each borrow‐lifetime 'a.