452 lines
16 KiB
Python
452 lines
16 KiB
Python
|
import numpy as np
|
||
|
|
from .constants import log
|
||
|
|
|
||
|
|
from . import util
|
||
|
|
from . import convex
|
||
|
|
from . import nsphere
|
||
|
|
from . import geometry
|
||
|
|
from . import grouping
|
||
|
|
from . import triangles
|
||
|
|
from . import transformations
|
||
|
|
|
||
|
|
try:
|
||
|
|
# scipy is a soft dependency
|
||
|
|
from scipy import spatial
|
||
|
|
from scipy import optimize
|
||
|
|
except BaseException as E:
|
||
|
|
# raise the exception when someone tries to use it
|
||
|
|
from . import exceptions
|
||
|
|
spatial = exceptions.ExceptionModule(E)
|
||
|
|
optimize = exceptions.ExceptionModule(E)
|
||
|
|
|
||
|
|
|
||
|
|
def oriented_bounds_2D(points, qhull_options='QbB'):
|
||
|
|
"""
|
||
|
|
Find an oriented bounding box for an array of 2D points.
|
||
|
|
|
||
|
|
Parameters
|
||
|
|
----------
|
||
|
|
points : (n,2) float
|
||
|
|
Points in 2D.
|
||
|
|
|
||
|
|
Returns
|
||
|
|
----------
|
||
|
|
transform : (3,3) float
|
||
|
|
Homogeneous 2D transformation matrix to move the
|
||
|
|
input points so that the axis aligned bounding box
|
||
|
|
is CENTERED AT THE ORIGIN.
|
||
|
|
rectangle : (2,) float
|
||
|
|
Size of extents once input points are transformed
|
||
|
|
by transform
|
||
|
|
"""
|
||
|
|
# make sure input is a numpy array
|
||
|
|
points = np.asanyarray(points, dtype=np.float64)
|
||
|
|
# create a convex hull object of our points
|
||
|
|
# 'QbB' is a qhull option which has it scale the input to unit
|
||
|
|
# box to avoid precision issues with very large/small meshes
|
||
|
|
convex = spatial.ConvexHull(
|
||
|
|
points, qhull_options=qhull_options)
|
||
|
|
|
||
|
|
# (n,2,3) line segments
|
||
|
|
hull_edges = convex.points[convex.simplices]
|
||
|
|
# (n,2) points on the convex hull
|
||
|
|
hull_points = convex.points[convex.vertices]
|
||
|
|
|
||
|
|
# unit vector direction of the edges of the hull polygon
|
||
|
|
# filter out zero- magnitude edges via check_valid
|
||
|
|
edge_vectors, _ = util.unitize(np.diff(hull_edges, axis=1).reshape((-1, 2)),
|
||
|
|
check_valid=True)
|
||
|
|
|
||
|
|
# create a set of perpendicular vectors
|
||
|
|
perp_vectors = np.fliplr(edge_vectors) * [-1.0, 1.0]
|
||
|
|
|
||
|
|
# find the projection of every hull point on every edge vector
|
||
|
|
# this does create a potentially gigantic n^2 array in memory,
|
||
|
|
# and there is the 'rotating calipers' algorithm which avoids this
|
||
|
|
# however, we have reduced n with a convex hull and numpy dot products
|
||
|
|
# are extremely fast so in practice this usually ends up being pretty
|
||
|
|
# reasonable
|
||
|
|
x = np.dot(edge_vectors, hull_points.T)
|
||
|
|
y = np.dot(perp_vectors, hull_points.T)
|
||
|
|
|
||
|
|
# reduce the projections to maximum and minimum per edge vector
|
||
|
|
bounds = np.column_stack((x.min(axis=1),
|
||
|
|
y.min(axis=1),
|
||
|
|
x.max(axis=1),
|
||
|
|
y.max(axis=1)))
|
||
|
|
|
||
|
|
# calculate the extents and area for each edge vector pair
|
||
|
|
extents = np.diff(bounds.reshape((-1, 2, 2)),
|
||
|
|
axis=1).reshape((-1, 2))
|
||
|
|
area = np.product(extents, axis=1)
|
||
|
|
area_min = area.argmin()
|
||
|
|
|
||
|
|
# (2,) float of smallest rectangle size
|
||
|
|
rectangle = extents[area_min]
|
||
|
|
|
||
|
|
# find the (3,3) homogeneous transformation which moves the input
|
||
|
|
# points to have a bounding box centered at the origin
|
||
|
|
offset = -bounds[area_min][:2] - (rectangle * .5)
|
||
|
|
theta = np.arctan2(*edge_vectors[area_min][::-1])
|
||
|
|
transform = transformations.planar_matrix(offset,
|
||
|
|
theta)
|
||
|
|
|
||
|
|
# we would like to consistently return an OBB with
|
||
|
|
# the largest dimension along the X axis rather than
|
||
|
|
# the long axis being arbitrarily X or Y.
|
||
|
|
if np.less(*rectangle):
|
||
|
|
# a 90 degree rotation
|
||
|
|
flip = transformations.planar_matrix(theta=np.pi / 2)
|
||
|
|
# apply the rotation
|
||
|
|
transform = np.dot(flip, transform)
|
||
|
|
# switch X and Y in the OBB extents
|
||
|
|
rectangle = np.roll(rectangle, 1)
|
||
|
|
|
||
|
|
return transform, rectangle
|
||
|
|
|
||
|
|
|
||
|
|
def oriented_bounds(obj, angle_digits=1, ordered=True, normal=None):
|
||
|
|
"""
|
||
|
|
Find the oriented bounding box for a Trimesh
|
||
|
|
|
||
|
|
Parameters
|
||
|
|
----------
|
||
|
|
obj : trimesh.Trimesh, (n, 2) float, or (n, 3) float
|
||
|
|
Mesh object or points in 2D or 3D space
|
||
|
|
angle_digits : int
|
||
|
|
How much angular precision do we want on our result.
|
||
|
|
Even with less precision the returned extents will cover
|
||
|
|
the mesh albeit with larger than minimal volume, and may
|
||
|
|
experience substantial speedups.
|
||
|
|
ordered : bool
|
||
|
|
Return a consistent order for bounds
|
||
|
|
normal : None or (3,) float
|
||
|
|
Override search for normal on 3D meshes
|
||
|
|
|
||
|
|
Returns
|
||
|
|
----------
|
||
|
|
to_origin : (4,4) float
|
||
|
|
Transformation matrix which will move the center of the
|
||
|
|
bounding box of the input mesh to the origin.
|
||
|
|
extents: (3,) float
|
||
|
|
The extents of the mesh once transformed with to_origin
|
||
|
|
"""
|
||
|
|
|
||
|
|
# extract a set of convex hull vertices and normals from the input
|
||
|
|
# we bother to do this to avoid recomputing the full convex hull if
|
||
|
|
# possible
|
||
|
|
if hasattr(obj, 'convex_hull'):
|
||
|
|
# if we have been passed a mesh, use its existing convex hull to pull from
|
||
|
|
# cache rather than recomputing. This version of the cached convex hull has
|
||
|
|
# normals pointing in arbitrary directions (straight from qhull)
|
||
|
|
# using this avoids having to compute the expensive corrected normals
|
||
|
|
# that mesh.convex_hull uses since normal directions don't matter here
|
||
|
|
vertices = obj.convex_hull.vertices
|
||
|
|
hull_normals = obj.convex_hull.face_normals
|
||
|
|
elif util.is_sequence(obj):
|
||
|
|
# we've been passed a list of points
|
||
|
|
points = np.asanyarray(obj)
|
||
|
|
if util.is_shape(points, (-1, 2)):
|
||
|
|
return oriented_bounds_2D(points)
|
||
|
|
elif util.is_shape(points, (-1, 3)):
|
||
|
|
hull_obj = spatial.ConvexHull(points)
|
||
|
|
vertices = hull_obj.points[hull_obj.vertices]
|
||
|
|
hull_normals, valid = triangles.normals(
|
||
|
|
hull_obj.points[hull_obj.simplices])
|
||
|
|
else:
|
||
|
|
raise ValueError('Points are not (n,3) or (n,2)!')
|
||
|
|
else:
|
||
|
|
raise ValueError(
|
||
|
|
'Oriented bounds must be passed a mesh or a set of points!')
|
||
|
|
|
||
|
|
# convert face normals to spherical coordinates on the upper hemisphere
|
||
|
|
# the vector_hemisphere call effectivly merges negative but otherwise
|
||
|
|
# identical vectors
|
||
|
|
spherical_coords = util.vector_to_spherical(
|
||
|
|
util.vector_hemisphere(hull_normals))
|
||
|
|
# the unique_rows call on merge angles gets unique spherical directions to check
|
||
|
|
# we get a substantial speedup in the transformation matrix creation
|
||
|
|
# inside the loop by converting to angles ahead of time
|
||
|
|
spherical_unique = grouping.unique_rows(spherical_coords,
|
||
|
|
digits=angle_digits)[0]
|
||
|
|
min_volume = np.inf
|
||
|
|
tic = util.now()
|
||
|
|
|
||
|
|
# matrices which will rotate each hull normal to [0,0,1]
|
||
|
|
if normal is None:
|
||
|
|
matrices = [np.linalg.inv(transformations.spherical_matrix(*s))
|
||
|
|
for s in spherical_coords[spherical_unique]]
|
||
|
|
else:
|
||
|
|
# if explicit normal was passed use it
|
||
|
|
matrices = [geometry.align_vectors(normal, [0, 0, 1])]
|
||
|
|
|
||
|
|
for to_2D in matrices:
|
||
|
|
# apply the transform here
|
||
|
|
projected = np.dot(to_2D, np.column_stack(
|
||
|
|
(vertices, np.ones(len(vertices)))).T).T[:, :3]
|
||
|
|
|
||
|
|
height = projected[:, 2].ptp()
|
||
|
|
rotation_2D, box = oriented_bounds_2D(projected[:, :2])
|
||
|
|
volume = np.product(box) * height
|
||
|
|
if volume < min_volume:
|
||
|
|
min_volume = volume
|
||
|
|
min_extents = np.append(box, height)
|
||
|
|
min_2D = to_2D.copy()
|
||
|
|
rotation_2D[:2, 2] = 0.0
|
||
|
|
rotation_Z = transformations.planar_matrix_to_3D(rotation_2D)
|
||
|
|
|
||
|
|
# combine the 2D OBB transformation with the 2D projection transform
|
||
|
|
to_origin = np.dot(rotation_Z, min_2D)
|
||
|
|
|
||
|
|
# transform points using our matrix to find the translation for the
|
||
|
|
# transform
|
||
|
|
transformed = transformations.transform_points(vertices,
|
||
|
|
to_origin)
|
||
|
|
box_center = (transformed.min(axis=0) + transformed.ptp(axis=0) * .5)
|
||
|
|
to_origin[:3, 3] = -box_center
|
||
|
|
|
||
|
|
# return ordered 3D extents
|
||
|
|
if ordered:
|
||
|
|
# sort the three extents
|
||
|
|
order = min_extents.argsort()
|
||
|
|
# generate a matrix which will flip transform
|
||
|
|
# to match the new ordering
|
||
|
|
flip = np.eye(4)
|
||
|
|
flip[:3, :3] = -np.eye(3)[order]
|
||
|
|
|
||
|
|
# make sure transform isn't mangling triangles
|
||
|
|
# by reversing windings on triangles
|
||
|
|
if np.isclose(np.trace(flip[:3, :3]), 0.0):
|
||
|
|
flip[:3, :3] = np.dot(flip[:3, :3], -np.eye(3))
|
||
|
|
|
||
|
|
# apply the flip to the OBB transform
|
||
|
|
to_origin = np.dot(flip, to_origin)
|
||
|
|
# apply the order to the extents
|
||
|
|
min_extents = min_extents[order]
|
||
|
|
|
||
|
|
log.debug('oriented_bounds checked %d vectors in %0.4fs',
|
||
|
|
len(spherical_unique),
|
||
|
|
util.now() - tic)
|
||
|
|
|
||
|
|
return to_origin, min_extents
|
||
|
|
|
||
|
|
|
||
|
|
def minimum_cylinder(obj, sample_count=6, angle_tol=.001):
|
||
|
|
"""
|
||
|
|
Find the approximate minimum volume cylinder which contains
|
||
|
|
a mesh or a a list of points.
|
||
|
|
|
||
|
|
Samples a hemisphere then uses scipy.optimize to pick the
|
||
|
|
final orientation of the cylinder.
|
||
|
|
|
||
|
|
A nice discussion about better ways to implement this is here:
|
||
|
|
https://www.staff.uni-mainz.de/schoemer/publications/ALGO00.pdf
|
||
|
|
|
||
|
|
|
||
|
|
Parameters
|
||
|
|
----------
|
||
|
|
obj : trimesh.Trimesh, or (n, 3) float
|
||
|
|
Mesh object or points in space
|
||
|
|
sample_count : int
|
||
|
|
How densely should we sample the hemisphere.
|
||
|
|
Angular spacing is 180 degrees / this number
|
||
|
|
|
||
|
|
Returns
|
||
|
|
----------
|
||
|
|
result : dict
|
||
|
|
With keys:
|
||
|
|
'radius' : float, radius of cylinder
|
||
|
|
'height' : float, height of cylinder
|
||
|
|
'transform' : (4,4) float, transform from the origin
|
||
|
|
to centered cylinder
|
||
|
|
"""
|
||
|
|
|
||
|
|
def volume_from_angles(spherical, return_data=False):
|
||
|
|
"""
|
||
|
|
Takes spherical coordinates and calculates the volume
|
||
|
|
of a cylinder along that vector
|
||
|
|
|
||
|
|
Parameters
|
||
|
|
---------
|
||
|
|
spherical : (2,) float
|
||
|
|
Theta and phi
|
||
|
|
return_data : bool
|
||
|
|
Flag for returned
|
||
|
|
|
||
|
|
Returns
|
||
|
|
--------
|
||
|
|
if return_data:
|
||
|
|
transform ((4,4) float)
|
||
|
|
radius (float)
|
||
|
|
height (float)
|
||
|
|
else:
|
||
|
|
volume (float)
|
||
|
|
"""
|
||
|
|
to_2D = transformations.spherical_matrix(*spherical,
|
||
|
|
axes='rxyz')
|
||
|
|
projected = transformations.transform_points(hull,
|
||
|
|
matrix=to_2D)
|
||
|
|
height = projected[:, 2].ptp()
|
||
|
|
|
||
|
|
try:
|
||
|
|
center_2D, radius = nsphere.minimum_nsphere(projected[:, :2])
|
||
|
|
except BaseException:
|
||
|
|
# in degenerate cases return as infinite volume
|
||
|
|
return np.inf
|
||
|
|
|
||
|
|
volume = np.pi * height * (radius ** 2)
|
||
|
|
if return_data:
|
||
|
|
center_3D = np.append(center_2D, projected[
|
||
|
|
:, 2].min() + (height * .5))
|
||
|
|
transform = np.dot(np.linalg.inv(to_2D),
|
||
|
|
transformations.translation_matrix(center_3D))
|
||
|
|
return transform, radius, height
|
||
|
|
return volume
|
||
|
|
|
||
|
|
# we've been passed a mesh with radial symmetry
|
||
|
|
# use center mass and symmetry axis and go home early
|
||
|
|
if hasattr(obj, 'symmetry') and obj.symmetry == 'radial':
|
||
|
|
# find our origin
|
||
|
|
if obj.is_watertight:
|
||
|
|
# set origin to center of mass
|
||
|
|
origin = obj.center_mass
|
||
|
|
else:
|
||
|
|
# convex hull should be watertight
|
||
|
|
origin = obj.convex_hull.center_mass
|
||
|
|
# will align symmetry axis with Z and move origin to zero
|
||
|
|
to_2D = geometry.plane_transform(
|
||
|
|
origin=origin,
|
||
|
|
normal=obj.symmetry_axis)
|
||
|
|
# transform vertices to plane to check
|
||
|
|
on_plane = transformations.transform_points(
|
||
|
|
obj.vertices, to_2D)
|
||
|
|
# cylinder height is overall Z span
|
||
|
|
height = on_plane[:, 2].ptp()
|
||
|
|
# center mass is correct on plane, but position
|
||
|
|
# along symmetry axis may be wrong so slide it
|
||
|
|
slide = transformations.translation_matrix(
|
||
|
|
[0, 0, (height / 2.0) - on_plane[:, 2].max()])
|
||
|
|
to_2D = np.dot(slide, to_2D)
|
||
|
|
# radius is maximum radius
|
||
|
|
radius = (on_plane[:, :2] ** 2).sum(axis=1).max() ** 0.5
|
||
|
|
# save kwargs
|
||
|
|
result = {'height': height,
|
||
|
|
'radius': radius,
|
||
|
|
'transform': np.linalg.inv(to_2D)}
|
||
|
|
return result
|
||
|
|
|
||
|
|
# get the points on the convex hull of the result
|
||
|
|
hull = convex.hull_points(obj)
|
||
|
|
if not util.is_shape(hull, (-1, 3)):
|
||
|
|
raise ValueError('Input must be reducable to 3D points!')
|
||
|
|
|
||
|
|
# sample a hemisphere so local hill climbing can do its thing
|
||
|
|
samples = util.grid_linspace([[0, 0], [np.pi, np.pi]], sample_count)
|
||
|
|
|
||
|
|
# if it's rotationally symmetric the bounding cylinder
|
||
|
|
# is almost certainly along one of the PCI vectors
|
||
|
|
if hasattr(obj, 'principal_inertia_vectors'):
|
||
|
|
# add the principal inertia vectors if we have a mesh
|
||
|
|
samples = np.vstack(
|
||
|
|
(samples,
|
||
|
|
util.vector_to_spherical(obj.principal_inertia_vectors)))
|
||
|
|
|
||
|
|
tic = [util.now()]
|
||
|
|
# the projected volume at each sample
|
||
|
|
volumes = np.array([volume_from_angles(i) for i in samples])
|
||
|
|
# the best vector in (2,) spherical coordinates
|
||
|
|
best = samples[volumes.argmin()]
|
||
|
|
tic.append(util.now())
|
||
|
|
|
||
|
|
# since we already explored the global space, set the bounds to be
|
||
|
|
# just around the sample that had the lowest volume
|
||
|
|
step = 2 * np.pi / sample_count
|
||
|
|
bounds = [(best[0] - step, best[0] + step),
|
||
|
|
(best[1] - step, best[1] + step)]
|
||
|
|
# run the local optimization
|
||
|
|
r = optimize.minimize(volume_from_angles,
|
||
|
|
best,
|
||
|
|
tol=angle_tol,
|
||
|
|
method='SLSQP',
|
||
|
|
bounds=bounds)
|
||
|
|
|
||
|
|
tic.append(util.now())
|
||
|
|
log.info('Performed search in %f and minimize in %f', *np.diff(tic))
|
||
|
|
|
||
|
|
# actually chunk the information about the cylinder
|
||
|
|
transform, radius, height = volume_from_angles(r['x'], return_data=True)
|
||
|
|
result = {'transform': transform,
|
||
|
|
'radius': radius,
|
||
|
|
'height': height}
|
||
|
|
return result
|
||
|
|
|
||
|
|
|
||
|
|
def corners(bounds):
|
||
|
|
"""
|
||
|
|
Given a pair of axis aligned bounds, return all
|
||
|
|
8 corners of the bounding box.
|
||
|
|
|
||
|
|
Parameters
|
||
|
|
----------
|
||
|
|
bounds : (2,3) or (2,2) float
|
||
|
|
Axis aligned bounds
|
||
|
|
|
||
|
|
Returns
|
||
|
|
----------
|
||
|
|
corners : (8,3) float
|
||
|
|
Corner vertices of the cube
|
||
|
|
"""
|
||
|
|
|
||
|
|
bounds = np.asanyarray(bounds, dtype=np.float64)
|
||
|
|
|
||
|
|
if util.is_shape(bounds, (2, 2)):
|
||
|
|
bounds = np.column_stack((bounds, [0, 0]))
|
||
|
|
elif not util.is_shape(bounds, (2, 3)):
|
||
|
|
raise ValueError('bounds must be (2,2) or (2,3)!')
|
||
|
|
|
||
|
|
minx, miny, minz, maxx, maxy, maxz = np.arange(6)
|
||
|
|
corner_index = np.array([minx, miny, minz,
|
||
|
|
maxx, miny, minz,
|
||
|
|
maxx, maxy, minz,
|
||
|
|
minx, maxy, minz,
|
||
|
|
minx, miny, maxz,
|
||
|
|
maxx, miny, maxz,
|
||
|
|
maxx, maxy, maxz,
|
||
|
|
minx, maxy, maxz]).reshape((-1, 3))
|
||
|
|
|
||
|
|
corners = bounds.reshape(-1)[corner_index]
|
||
|
|
return corners
|
||
|
|
|
||
|
|
|
||
|
|
def contains(bounds, points):
|
||
|
|
"""
|
||
|
|
Do an axis aligned bounding box check on a list of points.
|
||
|
|
|
||
|
|
Parameters
|
||
|
|
-----------
|
||
|
|
bounds : (2, dimension) float
|
||
|
|
Axis aligned bounding box
|
||
|
|
points : (n, dimension) float
|
||
|
|
Points in space
|
||
|
|
|
||
|
|
Returns
|
||
|
|
-----------
|
||
|
|
points_inside : (n,) bool
|
||
|
|
True if points are inside the AABB
|
||
|
|
"""
|
||
|
|
# make sure we have correct input types
|
||
|
|
bounds = np.asanyarray(bounds, dtype=np.float64)
|
||
|
|
points = np.asanyarray(points, dtype=np.float64)
|
||
|
|
|
||
|
|
if len(bounds) != 2:
|
||
|
|
raise ValueError('bounds must be (2,dimension)!')
|
||
|
|
if not util.is_shape(points, (-1, bounds.shape[1])):
|
||
|
|
raise ValueError('bounds shape must match points!')
|
||
|
|
|
||
|
|
# run the simple check
|
||
|
|
points_inside = np.logical_and(
|
||
|
|
(points > bounds[0]).all(axis=1),
|
||
|
|
(points < bounds[1]).all(axis=1))
|
||
|
|
|
||
|
|
return points_inside
|