How Binvox Converts Meshes into Voxels

Optimizing Voxel Resolution with BinvoxVoxelizing a 3D mesh is the process of converting a continuous surface into a discrete grid of volumetric pixels (voxels). Binvox is a lightweight, widely used command-line tool for converting polygonal meshes (OBJ, OFF, etc.) into voxel representations. Choosing the right voxel resolution is the single most important factor affecting output quality, file size, and downstream performance. This article explains how resolution affects voxelization, practical trade-offs, methods to choose and test resolutions, and tips for using Binvox effectively in real projects.

What “resolution” means in voxelization

In Binvox, resolution refers to the number of voxels along the longest axis of the mesh’s axis-aligned bounding box. If you run binvox with -d 256, Binvox will create a cubic grid with 256 voxels on the largest dimension; the other dimensions are scaled proportionally to maintain the object’s aspect ratio. Resolution determines:

• Surface detail captured: higher resolution preserves small features and thin parts.
• Memory and disk usage: voxel count grows roughly with the cube of resolution.
• Processing time: both voxelization and any downstream operations (rendering, mesh conversion) take longer as resolution rises.
• Topological fidelity: low resolutions can close holes or lose thin connections; high resolutions better preserve topology.

Rule of thumb: doubling resolution increases voxel count by ~8x.

Practical trade-offs

Below is a concise comparison of low, medium, and high resolution choices.

Estimating needed resolution

1. Identify the smallest feature size s you need to preserve (in model units, e.g., mm).
2. Measure the model’s longest bounding-box dimension L.
3. Required resolution d ≈ L / s. Round up to a power-of-two-friendly or convenient integer.

Example: A model 200 mm long with features of about 1 mm requires d ≈ 200 / 1 = 200 → choose 256.

Note: If your model uses non-metric units (e.g., Blender units), convert or measure consistently.

Binvox command-line flags that matter for resolution and quality

• -d N : sets maximum voxel grid dimension (primary resolution control)
• -pb : makes the voxelization watertight using parity bit algorithm (better interior filling)
• -e : enables conservative voxelization (marks voxels intersecting the surface), which helps preserve thin features but increases filled voxels
• -ad : adjust for ASCII/float precision differences on import
• -s : scale option (rarely needed if geometry is properly scaled)
• -c : compress the output (useful for large voxel grids)

Typical usage:

binvox -d 256 -pb -e mymodel.obj 

Strategies to find a good resolution

1. Start coarse, iterate: Begin at 64 or 128 to check general shape and orientation.
2. Targeted local tests: If only a small region has very fine detail, isolate and voxelize that submesh at higher resolution to determine necessary d.
3. Progressive doubling: Increase resolution by factors of two (128 → 256 → 512) and inspect differences to find diminishing returns.
4. Use conservative voxelization (-e) for thin fins, wires, or detailed engravings.
5. Compare voxelized output visually and with metrics (voxel count, surface error).

Measuring voxelization quality

• Visual inspection (orthographic renders, wireframe overlays).
• Surface distance metrics: convert voxel output back to mesh (e.g., with viewvox/voxels2mesh) and compute Hausdorff or RMS distance to original mesh.
• Topology checks: evaluate connected components and hole counts.
• Volume/area preservation: compare volume or surface area of voxel-derived mesh to original.

Memory and performance considerations

• Memory usage is roughly proportional to number of voxels; a 256^3 grid has ~16.7M voxels.
• Consider streaming or chunking for very large models — voxelize subregions, then merge.
• Use compression (-c) for storage, but note compression adds CPU overhead at write/read time.
• For batch processing, parallelize across models rather than increasing per-model resolution beyond necessary.

Special cases and tips

• Thin shells: If your mesh is a thin shell and you need a solid voxel model, use -pb for parity-based filling or pre-thicken the geometry.
• Noisy geometry: Clean meshes (remove duplicate vertices, fix non-manifold edges) before voxelizing; binvox can produce unexpected results with corrupted geometry.
• Multiple scales: For assets used at different scales (UI thumbnails vs. physics), create several voxel LODs.
• Preserving sharp corners: Increase resolution and avoid aggressive smoothing on subsequent processing.
• 3D printing: Match voxel size to printer resolution; for FDM, avoid voxel features smaller than nozzle/filament capabilities.

Example workflow

1. Inspect and clean mesh in your modeling tool (remove stray faces, ensure normals consistent).
2. Measure bounding box and smallest important feature.
3. Choose initial resolution using d ≈ L / s; pick conservative higher value if uncertain.
4. Run binvox with conservative option if needed:

   
   binvox -d 256 -pb -e cleaned_model.obj 

5. Convert voxels back to mesh if required and compute error metrics or visually inspect.
6. Adjust resolution up/down and repeat until acceptable balance of quality and resource use is reached.

Conclusion

Optimizing voxel resolution with Binvox is a balance between capturing necessary detail and managing file size, memory, and processing time. Start from the smallest feature you need to preserve, use conservative voxelization for thin elements, test progressively, and validate outputs with visual and quantitative checks. With iterative tuning you can find the minimal resolution that meets your needs and keeps workflows efficient.