577 lines
17 KiB
Python
577 lines
17 KiB
Python
"""Parsing functions for Binvox files.
|
|
|
|
https://www.patrickmin.com/binvox/binvox.html
|
|
|
|
Exporting meshes as binvox files requires binvox CL tool to be on your path.
|
|
"""
|
|
import os
|
|
import subprocess
|
|
import numpy as np
|
|
import collections
|
|
|
|
from distutils.spawn import find_executable
|
|
|
|
from .. import util
|
|
from ..base import Trimesh
|
|
|
|
# find the executable
|
|
binvox_encoder = find_executable('binvox')
|
|
|
|
Binvox = collections.namedtuple(
|
|
'Binvox', ['rle_data', 'shape', 'translate', 'scale'])
|
|
|
|
|
|
def parse_binvox_header(fp):
|
|
"""
|
|
Read the header from a binvox file.
|
|
Spec available:
|
|
https://www.patrickmin.com/binvox/binvox.html
|
|
|
|
Parameters
|
|
------------
|
|
fp: file-object
|
|
File like object with binvox file
|
|
|
|
Returns
|
|
----------
|
|
shape : tuple
|
|
Shape of binvox according to binvox spec
|
|
translate : tuple
|
|
Translation
|
|
scale : float
|
|
Scale of voxels
|
|
|
|
Raises
|
|
------------
|
|
IOError
|
|
If invalid binvox file.
|
|
"""
|
|
|
|
line = fp.readline().strip()
|
|
if hasattr(line, 'decode'):
|
|
binvox = b'#binvox'
|
|
space = b' '
|
|
else:
|
|
binvox = '#binvox'
|
|
space = ' '
|
|
if not line.startswith(binvox):
|
|
raise IOError('Not a binvox file')
|
|
shape = tuple(
|
|
int(s) for s in fp.readline().strip().split(space)[1:])
|
|
translate = tuple(
|
|
float(s) for s in fp.readline().strip().split(space)[1:])
|
|
scale = float(fp.readline().strip().split(space)[1])
|
|
fp.readline()
|
|
return shape, translate, scale
|
|
|
|
|
|
def parse_binvox(fp, writeable=False):
|
|
"""
|
|
Read a binvox file, spec at
|
|
https://www.patrickmin.com/binvox/binvox.html
|
|
|
|
Parameters
|
|
------------
|
|
fp: file-object
|
|
File like object with binvox file
|
|
|
|
Returns
|
|
----------
|
|
binvox : namedtuple
|
|
Containing data
|
|
rle : numpy array
|
|
Run length encoded data
|
|
|
|
Raises
|
|
------------
|
|
IOError
|
|
If invalid binvox file
|
|
"""
|
|
# get the header info
|
|
shape, translate, scale = parse_binvox_header(fp)
|
|
# get the rest of the file
|
|
data = fp.read()
|
|
# convert to numpy array
|
|
rle_data = np.frombuffer(data, dtype=np.uint8)
|
|
if writeable:
|
|
rle_data = rle_data.copy()
|
|
return Binvox(rle_data, shape, translate, scale)
|
|
|
|
|
|
_binvox_header = '''#binvox 1
|
|
dim {sx} {sy} {sz}
|
|
translate {tx} {ty} {tz}
|
|
scale {scale}
|
|
data
|
|
'''
|
|
|
|
|
|
def binvox_header(shape, translate, scale):
|
|
"""
|
|
Get a binvox header string.
|
|
|
|
Parameters
|
|
--------
|
|
shape: length 3 iterable of ints denoting shape of voxel grid.
|
|
translate: length 3 iterable of floats denoting translation.
|
|
scale: num length of entire voxel grid.
|
|
|
|
Returns
|
|
--------
|
|
string including "data\n" line.
|
|
"""
|
|
sx, sy, sz = (int(s) for s in shape)
|
|
tx, ty, tz = translate
|
|
return _binvox_header.format(
|
|
sx=sx, sy=sy, sz=sz, tx=tx, ty=ty, tz=tz, scale=scale)
|
|
|
|
|
|
def binvox_bytes(rle_data, shape, translate=(0, 0, 0), scale=1):
|
|
"""Get a binary representation of binvox data.
|
|
|
|
Parameters
|
|
--------
|
|
rle_data : numpy array
|
|
Run-length encoded numpy array.
|
|
shape : (3,) int
|
|
Shape of voxel grid.
|
|
translate : (3,) float
|
|
Translation of voxels
|
|
scale : float
|
|
Length of entire voxel grid.
|
|
|
|
Returns
|
|
--------
|
|
data : bytes
|
|
Suitable for writing to binary file
|
|
"""
|
|
if rle_data.dtype != np.uint8:
|
|
raise ValueError(
|
|
"rle_data.dtype must be np.uint8, got %s" % rle_data.dtype)
|
|
|
|
header = binvox_header(shape, translate, scale).encode()
|
|
return header + rle_data.tostring()
|
|
|
|
|
|
def voxel_from_binvox(
|
|
rle_data, shape, translate=None, scale=1.0, axis_order='xzy'):
|
|
"""
|
|
Factory for building from data associated with binvox files.
|
|
|
|
Parameters
|
|
---------
|
|
rle_data : numpy
|
|
Run-length-encoded of flat voxel
|
|
values, or a `trimesh.rle.RunLengthEncoding` object.
|
|
See `trimesh.rle` documentation for description of encoding
|
|
shape : (3,) int
|
|
Shape of voxel grid.
|
|
translate : (3,) float
|
|
Translation of voxels
|
|
scale : float
|
|
Length of entire voxel grid.
|
|
encoded_axes : iterable
|
|
With values in ('x', 'y', 'z', 0, 1, 2),
|
|
where x => 0, y => 1, z => 2
|
|
denoting the order of axes in the encoded data. binvox by
|
|
default saves in xzy order, but using `xyz` (or (0, 1, 2)) will
|
|
be faster in some circumstances.
|
|
|
|
Returns
|
|
---------
|
|
result : VoxelGrid
|
|
Loaded voxels
|
|
"""
|
|
# shape must be uniform else scale is ambiguous
|
|
from ..voxel import encoding as enc
|
|
from ..voxel.base import VoxelGrid
|
|
|
|
from .. import transformations
|
|
|
|
if isinstance(rle_data, enc.RunLengthEncoding):
|
|
encoding = rle_data
|
|
else:
|
|
encoding = enc.RunLengthEncoding(rle_data, dtype=bool)
|
|
|
|
# translate = np.asanyarray(translate) * scale)
|
|
# translate = [0, 0, 0]
|
|
transform = transformations.scale_and_translate(
|
|
scale=scale / (np.array(shape) - 1),
|
|
translate=translate)
|
|
|
|
if axis_order == 'xzy':
|
|
perm = (0, 2, 1)
|
|
shape = tuple(shape[p] for p in perm)
|
|
encoding = encoding.reshape(shape).transpose(perm)
|
|
elif axis_order is None or axis_order == 'xyz':
|
|
encoding = encoding.reshape(shape)
|
|
else:
|
|
raise ValueError(
|
|
"Invalid axis_order '%s': must be None, 'xyz' or 'xzy'")
|
|
|
|
assert(encoding.shape == shape)
|
|
return VoxelGrid(encoding, transform)
|
|
|
|
|
|
def load_binvox(file_obj,
|
|
resolver=None,
|
|
axis_order='xzy',
|
|
file_type=None):
|
|
"""
|
|
Load trimesh `VoxelGrid` instance from file.
|
|
|
|
Parameters
|
|
-----------
|
|
file_obj : file-like object
|
|
Contains binvox data
|
|
resolver : unused
|
|
axis_order : str
|
|
Order of axes in encoded data.
|
|
Binvox default is 'xzy', but 'xyz' may be faster
|
|
where this is not relevant.
|
|
|
|
Returns
|
|
---------
|
|
result : trimesh.voxel.VoxelGrid
|
|
Loaded voxel data
|
|
"""
|
|
if file_type is not None and file_type != 'binvox':
|
|
raise ValueError(
|
|
'file_type must be None or binvox, got %s' % file_type)
|
|
data = parse_binvox(file_obj, writeable=True)
|
|
return voxel_from_binvox(
|
|
rle_data=data.rle_data,
|
|
shape=data.shape,
|
|
translate=data.translate,
|
|
scale=data.scale,
|
|
axis_order=axis_order)
|
|
|
|
|
|
def export_binvox(voxel, axis_order='xzy'):
|
|
"""
|
|
Export `trimesh.voxel.VoxelGrid` instance to bytes
|
|
|
|
Parameters
|
|
------------
|
|
voxel : `trimesh.voxel.VoxelGrid`
|
|
Assumes axis ordering of `xyz` and encodes
|
|
in binvox default `xzy` ordering.
|
|
axis_order : str
|
|
Eements in ('x', 'y', 'z', 0, 1, 2), the order
|
|
of axes to encode data (standard is 'xzy' for binvox). `voxel`
|
|
data is assumed to be in order 'xyz'.
|
|
|
|
Returns
|
|
-----------
|
|
result : bytes
|
|
Representation according to binvox spec
|
|
"""
|
|
translate = voxel.translation
|
|
scale = voxel.scale * ((np.array(voxel.shape) - 1))
|
|
neg_scale, = np.where(scale < 0)
|
|
encoding = voxel.encoding.flip(neg_scale)
|
|
scale = np.abs(scale)
|
|
if not util.allclose(scale[0], scale[1:], 1e-6 * scale[0] + 1e-8):
|
|
raise ValueError('Can only export binvox with uniform scale')
|
|
scale = scale[0]
|
|
if axis_order == 'xzy':
|
|
encoding = encoding.transpose((0, 2, 1))
|
|
elif axis_order != 'xyz':
|
|
raise ValueError('Invalid axis_order: must be one of ("xyz", "xzy")')
|
|
rle_data = encoding.flat.run_length_data(dtype=np.uint8)
|
|
return binvox_bytes(
|
|
rle_data, shape=voxel.shape, translate=translate, scale=scale)
|
|
|
|
|
|
class Binvoxer(object):
|
|
"""
|
|
Interface for binvox CL tool.
|
|
|
|
This class is responsible purely for making calls to the CL tool. It
|
|
makes no attempt to integrate with the rest of trimesh at all.
|
|
|
|
Constructor args configure command line options.
|
|
|
|
`Binvoxer.__call__` operates on the path to a mode file.
|
|
|
|
If using this interface in published works, please cite the references
|
|
below.
|
|
|
|
See CL tool website for further details.
|
|
|
|
https://www.patrickmin.com/binvox/
|
|
|
|
@article{nooruddin03,
|
|
author = {Fakir S. Nooruddin and Greg Turk},
|
|
title = {Simplification and Repair of Polygonal Models Using Volumetric
|
|
Techniques},
|
|
journal = {IEEE Transactions on Visualization and Computer Graphics},
|
|
volume = {9},
|
|
number = {2},
|
|
pages = {191--205},
|
|
year = {2003}
|
|
}
|
|
|
|
@Misc{binvox,
|
|
author = {Patrick Min},
|
|
title = {binvox},
|
|
howpublished = {{\tt http://www.patrickmin.com/binvox} or
|
|
{\tt https://www.google.com/search?q=binvox}},
|
|
year = {2004 - 2019},
|
|
note = {Accessed: yyyy-mm-dd}
|
|
}
|
|
"""
|
|
|
|
SUPPORTED_INPUT_TYPES = (
|
|
'ug',
|
|
'obj',
|
|
'off',
|
|
'dfx',
|
|
'xgl',
|
|
'pov',
|
|
'brep',
|
|
'ply',
|
|
'jot',
|
|
)
|
|
|
|
SUPPORTED_OUTPUT_TYPES = (
|
|
'binvox',
|
|
'hips',
|
|
'mira',
|
|
'vtk',
|
|
'raw',
|
|
'schematic',
|
|
'msh',
|
|
)
|
|
|
|
def __init__(
|
|
self,
|
|
dimension=32,
|
|
file_type='binvox',
|
|
z_buffer_carving=True,
|
|
z_buffer_voting=True,
|
|
dilated_carving=False,
|
|
exact=False,
|
|
bounding_box=None,
|
|
remove_internal=False,
|
|
center=False,
|
|
rotate_x=0,
|
|
rotate_z=0,
|
|
wireframe=False,
|
|
fit=False,
|
|
block_id=None,
|
|
use_material_block_id=False,
|
|
use_offscreen_pbuffer=True,
|
|
downsample_factor=None,
|
|
downsample_threshold=None,
|
|
verbose=False,
|
|
binvox_path=binvox_encoder,
|
|
):
|
|
"""
|
|
Configure the voxelizer.
|
|
|
|
Parameters
|
|
------------
|
|
dimension: voxel grid size (max 1024 when not using exact)
|
|
file_type: str
|
|
Output file type, supported types are:
|
|
'binvox'
|
|
'hips'
|
|
'mira'
|
|
'vtk'
|
|
'raw'
|
|
'schematic'
|
|
'msh'
|
|
z_buffer_carving : use z buffer based carving. At least one of
|
|
`z_buffer_carving` and `z_buffer_voting` must be True.
|
|
z_buffer_voting: use z-buffer based parity voting method.
|
|
dilated_carving: stop carving 1 voxel before intersection.
|
|
exact: any voxel with part of a triangle gets set. Does not use
|
|
graphics card.
|
|
bounding_box: 6-element float list/tuple of min, max values,
|
|
(minx, miny, minz, maxx, maxy, maxz)
|
|
remove_internal: remove internal voxels if True. Note there is some odd
|
|
behaviour if boundary voxels are occupied.
|
|
center: center model inside unit cube.
|
|
rotate_x: number of 90 degree ccw rotations around x-axis before
|
|
voxelizing.
|
|
rotate_z: number of 90 degree cw rotations around z-axis before
|
|
voxelizing.
|
|
wireframe: also render the model in wireframe (helps with thin parts).
|
|
fit: only write voxels in the voxel bounding box.
|
|
block_id: when converting to schematic, use this as the block ID.
|
|
use_matrial_block_id: when converting from obj to schematic, parse
|
|
block ID from material spec "usemtl blockid_<id>" (ids 1-255 only).
|
|
use_offscreen_pbuffer: use offscreen pbuffer instead of onscreen
|
|
window.
|
|
downsample_factor: downsample voxels by this factor in each dimension.
|
|
Must be a power of 2 or None. If not None/1 and `core dumped`
|
|
errors occur, try slightly adjusting dimensions.
|
|
downsample_threshold: when downsampling, destination voxel is on if
|
|
more than this number of voxels are on.
|
|
verbose: if False, silences stdout/stderr from subprocess call.
|
|
binvox_path: path to binvox executable. The default looks for an
|
|
executable called `binvox` on your `PATH`.
|
|
"""
|
|
if binvox_encoder is None:
|
|
raise IOError(
|
|
'No `binvox_path` provided, and no binvox executable found '
|
|
'on PATH. \nPlease go to https://www.patrickmin.com/binvox/ and '
|
|
'download the appropriate version.')
|
|
|
|
if dimension > 1024 and not exact:
|
|
raise ValueError(
|
|
'Maximum dimension using exact is 1024, got %d' % dimension)
|
|
if file_type not in Binvoxer.SUPPORTED_OUTPUT_TYPES:
|
|
raise ValueError(
|
|
'file_type %s not in set of supported output types %s' %
|
|
(file_type, str(Binvoxer.SUPPORTED_OUTPUT_TYPES)))
|
|
args = [binvox_path, '-d', str(dimension), '-t', file_type]
|
|
if exact:
|
|
args.append('-e')
|
|
if z_buffer_carving:
|
|
if z_buffer_voting:
|
|
pass
|
|
else:
|
|
args.append('-c')
|
|
elif z_buffer_voting:
|
|
args.append('-v')
|
|
else:
|
|
raise ValueError(
|
|
'At least one of `z_buffer_carving` or `z_buffer_voting` must '
|
|
'be True')
|
|
if dilated_carving:
|
|
args.append('-dc')
|
|
|
|
# Additional parameters
|
|
if bounding_box is not None:
|
|
if len(bounding_box) != 6:
|
|
raise ValueError('bounding_box must have 6 elements')
|
|
args.append('-bb')
|
|
args.extend(str(b) for b in bounding_box)
|
|
if remove_internal:
|
|
args.append('-ri')
|
|
if center:
|
|
args.append('-cb')
|
|
args.extend(('-rotx',) * rotate_x)
|
|
args.extend(('-rotz',) * rotate_z)
|
|
if wireframe:
|
|
args.append('-aw')
|
|
if fit:
|
|
args.append('-fit')
|
|
if block_id is not None:
|
|
args.extend(('-bi', block_id))
|
|
if use_material_block_id:
|
|
args.append('-mb')
|
|
if use_offscreen_pbuffer:
|
|
args.append('-pb')
|
|
if downsample_factor is not None:
|
|
times = np.log2(downsample_factor)
|
|
if int(times) != times:
|
|
raise ValueError(
|
|
'downsample_factor must be a power of 2, got %d'
|
|
% downsample_factor)
|
|
args.extend(('-down',) * int(times))
|
|
if downsample_threshold is not None:
|
|
args.extend(('-dmin', str(downsample_threshold)))
|
|
args.append('PATH')
|
|
self._args = args
|
|
self._file_type = file_type
|
|
|
|
self.verbose = verbose
|
|
|
|
@property
|
|
def file_type(self):
|
|
return self._file_type
|
|
|
|
def __call__(self, path, overwrite=False):
|
|
"""
|
|
Create an voxel file in the same directory as model at `path`.
|
|
|
|
Parameters
|
|
------------
|
|
path: string path to model file. Supported types:
|
|
'ug'
|
|
'obj'
|
|
'off'
|
|
'dfx'
|
|
'xgl'
|
|
'pov'
|
|
'brep'
|
|
'ply'
|
|
'jot' (polygongs only)
|
|
overwrite: if False, checks the output path (head.file_type) is empty
|
|
before running. If True and a file exists, raises an IOError.
|
|
|
|
Returns
|
|
------------
|
|
string path to voxel file. File type give by file_type in constructor.
|
|
"""
|
|
head, ext = os.path.splitext(path)
|
|
ext = ext[1:].lower()
|
|
if ext not in Binvoxer.SUPPORTED_INPUT_TYPES:
|
|
raise ValueError(
|
|
'file_type %s not in set of supported input types %s' %
|
|
(ext, str(Binvoxer.SUPPORTED_INPUT_TYPES)))
|
|
out_path = '%s.%s' % (head, self._file_type)
|
|
if os.path.isfile(out_path) and not overwrite:
|
|
raise IOError(
|
|
'Attempted to voxelize object a %s, but there is already a '
|
|
'file at output path %s' % (path, out_path))
|
|
self._args[-1] = path
|
|
|
|
# generalizes to python2 and python3
|
|
# will capture terminal output into variable rather than printing
|
|
verbosity = subprocess.check_output(self._args)
|
|
# if requested print ourselves
|
|
if self.verbose:
|
|
print(verbosity)
|
|
|
|
return out_path
|
|
|
|
|
|
def voxelize_mesh(mesh,
|
|
binvoxer=None,
|
|
export_type='off',
|
|
**binvoxer_kwargs):
|
|
"""
|
|
Interface for voxelizing Trimesh object via the binvox tool.
|
|
|
|
Implementation simply saved the mesh in the specified export_type then
|
|
runs the `Binvoxer.__call__` (using either the supplied `binvoxer` or
|
|
creating one via `binvoxer_kwargs`)
|
|
|
|
Parameters
|
|
------------
|
|
mesh: Trimesh object to voxelize.
|
|
binvoxer: optional Binvoxer instance.
|
|
export_type: file type to export mesh as temporarily for Binvoxer to
|
|
operate on.
|
|
**binvoxer_kwargs: kwargs for creating a new Binvoxer instance. If binvoxer
|
|
if provided, this must be empty.
|
|
|
|
Returns
|
|
------------
|
|
`VoxelGrid` object resulting.
|
|
"""
|
|
if not isinstance(mesh, Trimesh):
|
|
raise ValueError('mesh must be Trimesh instance, got %s' % str(mesh))
|
|
if binvoxer is None:
|
|
binvoxer = Binvoxer(**binvoxer_kwargs)
|
|
elif len(binvoxer_kwargs) > 0:
|
|
raise ValueError('Cannot provide binvoxer and binvoxer_kwargs')
|
|
if binvoxer.file_type != 'binvox':
|
|
raise ValueError(
|
|
'Only "binvox" binvoxer `file_type` currently supported')
|
|
with util.TemporaryDirectory() as folder:
|
|
model_path = os.path.join(folder, 'model.%s' % export_type)
|
|
with open(model_path, 'wb') as fp:
|
|
mesh.export(fp, file_type=export_type)
|
|
out_path = binvoxer(model_path)
|
|
with open(out_path, 'rb') as fp:
|
|
out_model = load_binvox(fp)
|
|
return out_model
|
|
|
|
|
|
_binvox_loaders = {'binvox': load_binvox}
|