Struct VoxelizedVolume

pub struct VoxelizedVolume { /* private fields */ }

A dense voxel grid storing the state of every voxel in a cubic volume.

VoxelizedVolume is the intermediate representation used during the voxelization process. Unlike VoxelSet which only stores filled voxels, VoxelizedVolume stores a complete dense 3D array where every grid cell has an associated VoxelValue.

When to Use

Most users should use VoxelSet instead, which is converted from VoxelizedVolume automatically and is much more memory-efficient. You might want to use VoxelizedVolume directly if you need to:

• Query the state of ALL voxels, including empty ones
• Implement custom voxel processing algorithms
• Generate visualizations showing both filled and empty voxels

Memory Usage

VoxelizedVolume stores all voxels in a dense 3D array:

• Memory usage: O(resolution^3) in 3D or O(resolution^2) in 2D
• A 100×100×100 grid requires 1 million voxel entries

For this reason, VoxelSet is usually preferred for storage.

Conversion

VoxelizedVolume automatically converts to VoxelSet:

use parry3d::transformation::voxelization::{FillMode, VoxelSet, VoxelizedVolume};
use parry3d::shape::Ball;
///
let ball = Ball::new(1.0);
let (vertices, indices) = ball.to_trimesh(10, 10);

// Create dense volume
let volume = VoxelizedVolume::voxelize(
    &vertices,
    &indices,
    10,
    FillMode::SurfaceOnly,
    false,
);

// Convert to sparse set (automatic via Into trait)
let voxel_set: VoxelSet = volume.into();

Example: Querying All Voxels

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();

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

// Count voxels by state
let resolution = volume.resolution();
let mut inside = 0;
let mut surface = 0;
let mut outside = 0;

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::PrimitiveInsideSurface => inside += 1,
                VoxelValue::PrimitiveOnSurface => surface += 1,
                VoxelValue::PrimitiveOutsideSurface => outside += 1,
                _ => {}
            }
        }
    }
}

println!("Inside: {}, Surface: {}, Outside: {}", inside, surface, outside);

Implementations

impl VoxelizedVolume

pub fn with_voxel_size( points: &[Point<f32>], indices: &[[u32; 3]], voxel_size: f32, fill_mode: FillMode, keep_voxel_to_primitives_map: bool, ) -> Self

Voxelizes the given shape described by its boundary: a triangle mesh (in 3D) or polyline (in 2D).

Parameters

• points - The vertex buffer of the boundary of the shape to voxelize.
• indices - The index buffer of the boundary of the shape to voxelize.
• resolution - Controls the number of subdivision done along each axis. This number is the number of subdivisions along the axis where the input shape has the largest extent. The other dimensions will have a different automatically-determined resolution (in order to keep the voxels cubic).
• fill_mode - Controls what is being voxelized.
• keep_voxel_to_primitives_map - If set to true a map between the voxels and the primitives (3D triangles or 2D segments) it intersects will be computed.

pub fn voxelize( points: &[Point<f32>], indices: &[[u32; 3]], resolution: u32, fill_mode: FillMode, keep_voxel_to_primitives_map: bool, ) -> Self

Voxelizes the given shape described by its boundary: a triangle mesh (in 3D) or polyline (in 2D).

Parameters

• points - The vertex buffer of the boundary of the shape to voxelize.
• indices - The index buffer of the boundary of the shape to voxelize.
• resolution - Controls the number of subdivision done along each axis. This number is the number of subdivisions along the axis where the input shape has the largest extent. The other dimensions will have a different automatically-determined resolution (in order to keep the voxels cubic).
• fill_mode - Controls what is being voxelized.
• keep_voxel_to_primitives_map - If set to true a map between the voxels and the primitives (3D triangles or 2D segments) it intersects will be computed.

pub fn resolution(&self) -> [u32; 3]

The number of voxel subdivisions along each coordinate axis.

pub fn scale(&self) -> f32

The scale factor that needs to be applied to the voxels of self in order to give them the size matching the original model’s size.

pub fn voxel(&self, i: u32, j: u32, k: u32) -> VoxelValue

The value of the given voxel.

In 2D, the k argument is ignored.

pub fn to_trimesh(&self, value: VoxelValue) -> (Vec<Point<f32>>, Vec<[u32; 3]>)

Naive conversion of all the voxels with the given value to a triangle-mesh.

This conversion is extremely naive: it will simply collect all the 12 triangles forming the faces of each voxel. No actual boundary extraction is done.

Trait Implementations

impl From<VoxelizedVolume> for VoxelSet

fn from(shape: VoxelizedVolume) -> Self

Converts to this type from the input type.