Enum VoxelValue

pub enum VoxelValue {
    PrimitiveUndefined,
    PrimitiveOutsideSurfaceToWalk,
    PrimitiveInsideSurfaceToWalk,
    PrimitiveOnSurfaceNoWalk,
    PrimitiveOnSurfaceToWalk1,
    PrimitiveOnSurfaceToWalk2,
    PrimitiveOutsideSurface,
    PrimitiveInsideSurface,
    PrimitiveOnSurface,
}

The state of a voxel during and after voxelization.

This enum represents the classification of each voxel in the grid. After voxelization completes, only three values are meaningful for end-user code: PrimitiveOutsideSurface, PrimitiveInsideSurface, and PrimitiveOnSurface. The other variants are intermediate states used during the flood-fill algorithm.

Usage

Most users will work with VoxelSet which filters out outside voxels and only stores filled ones. However, if you’re working directly with VoxelizedVolume, you’ll encounter all these values.

Final States (After Voxelization)

• PrimitiveOutsideSurface: Voxel is completely outside the shape
• PrimitiveInsideSurface: Voxel is fully inside the shape (only with FillMode::FloodFill)
• PrimitiveOnSurface: Voxel intersects the boundary surface

Intermediate States (During Voxelization)

The following are temporary states used during the flood-fill algorithm and should be ignored by user code:

• PrimitiveUndefined
• PrimitiveOutsideSurfaceToWalk
• PrimitiveInsideSurfaceToWalk
• PrimitiveOnSurfaceNoWalk
• PrimitiveOnSurfaceToWalk1
• PrimitiveOnSurfaceToWalk2

Example

use parry3d::transformation::voxelization::{FillMode, VoxelValue, VoxelizedVolume};
use parry3d::shape::Cuboid;
use nalgebra::Vector3;

let cuboid = Cuboid::new(Vector3::new(1.0, 1.0, 1.0));
let (vertices, indices) = cuboid.to_trimesh();

// Create a dense voxelized volume
let volume = VoxelizedVolume::voxelize(
    &vertices,
    &indices,
    8,
    FillMode::FloodFill { detect_cavities: false },
    false,
);

// Query individual voxel values
let resolution = volume.resolution();
for i in 0..resolution[0] {
    for j in 0..resolution[1] {
        for k in 0..resolution[2] {
            match volume.voxel(i, j, k) {
                VoxelValue::PrimitiveOnSurface => {
                    // This voxel is on the boundary
                }
                VoxelValue::PrimitiveInsideSurface => {
                    // This voxel is inside the shape
                }
                VoxelValue::PrimitiveOutsideSurface => {
                    // This voxel is outside the shape
                }
                _ => {
                    // Should not happen after voxelization completes
                }
            }
        }
    }
}

Variants

PrimitiveUndefined

Intermediate value, should be ignored by end-user code.

PrimitiveOutsideSurfaceToWalk

Intermediate value, should be ignored by end-user code.

PrimitiveInsideSurfaceToWalk

Intermediate value, should be ignored by end-user code.

PrimitiveOnSurfaceNoWalk

Intermediate value, should be ignored by end-user code.

PrimitiveOnSurfaceToWalk1

Intermediate value, should be ignored by end-user code.

PrimitiveOnSurfaceToWalk2

Intermediate value, should be ignored by end-user code.

PrimitiveOutsideSurface

A voxel that is outside of the voxelized shape.

PrimitiveInsideSurface

A voxel that is on the interior of the voxelized shape.

PrimitiveOnSurface

Voxel that intersects the surface of the voxelized shape.

Trait Implementations

impl Clone for VoxelValue

fn clone(&self) -> VoxelValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for VoxelValue

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

Formats the value using the given formatter.

impl PartialEq for VoxelValue

fn eq(&self, other: &VoxelValue) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for VoxelValue

impl Eq for VoxelValue

impl StructuralPartialEq for VoxelValue