tesseract_robotics.geometry¶
Geometric primitives for collision and visualization.
Primitives¶
Box¶
from tesseract_robotics.geometry import Box
box = Box(1.0, 0.5, 0.25) # x, y, z dimensions
print(f"Dimensions: {box.getX()} x {box.getY()} x {box.getZ()}")
Sphere¶
from tesseract_robotics.geometry import Sphere
sphere = Sphere(0.1) # radius
print(f"Radius: {sphere.getRadius()}")
Cylinder¶
from tesseract_robotics.geometry import Cylinder
cylinder = Cylinder(0.05, 0.2) # radius, length
print(f"Radius: {cylinder.getRadius()}, Length: {cylinder.getLength()}")
Capsule¶
Cone¶
Plane¶
from tesseract_robotics.geometry import Plane
# ax + by + cz + d = 0
plane = Plane(0, 0, 1, 0) # XY plane (z = 0)
Meshes¶
Mesh¶
Triangle mesh from file.
from tesseract_robotics.geometry import Mesh, createMeshFromPath
import numpy as np
# Load from file
meshes = createMeshFromPath("model.stl")
mesh = meshes[0]
# Access data
vertices = mesh.getVertices() # list of 3-vectors
faces = mesh.getFaces() # [count, i0, i1, ..., count, ...]
# With scale
meshes = createMeshFromPath("model.stl", scale=np.array([0.001, 0.001, 0.001]))
Mesh, ConvexMesh and PolygonMesh bind both native constructors. faces is flat:
each face is its vertex count followed by that many vertex indices. Every argument after faces is
optional and takes the C++ default; the pointer arguments take None for "not set".
from tesseract_robotics.common import BytesResource
from tesseract_robotics.geometry import Mesh, MeshFaceCountError, MeshMaterial
import numpy as np
vertices = [np.array(v, dtype=float) for v in ([0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0])]
faces = np.array([3, 0, 1, 2, 3, 0, 2, 3], dtype=np.int32)
mesh = Mesh(vertices, faces) # counts the faces
mesh = Mesh(
vertices, faces,
resource=BytesResource("square.stl", b"..."),
scale=np.array([1.0, 1.0, 1.0]),
normals=[np.array([0.0, 0.0, 1.0])] * 4,
vertex_colors=[np.array([1.0, 0.0, 0.0, 1.0])] * 4,
mesh_material=MeshMaterial(np.array([1.0, 0.0, 0.0, 1.0]), 0.0, 0.5, np.zeros(4)),
mesh_textures=None,
)
mesh = Mesh(vertices, faces, 2) # face_count given
try:
Mesh(vertices, faces, 3)
except MeshFaceCountError: # a ValueError
pass
The face_count overload exists in C++ to skip counting. Upstream stores the count without checking
it; the binding counts the faces anyway and raises MeshFaceCountError when the two disagree, so
getFaceCount() always matches getFaces(). PolygonMesh also takes a trailing
type=GeometryType.POLYGON_MESH. Fixed-size vectors (scale, each normal) must be numpy arrays:
nanobind's Eigen caster refuses a plain list.
ConvexMesh¶
Convex hull for efficient collision.
from tesseract_robotics.geometry import ConvexMesh, createConvexMeshFromPath
meshes = createConvexMeshFromPath("model.stl")
convex = meshes[0]
getCreationMethod() reports how the mesh was made, as ConvexMesh.CreationMethod: DEFAULT
(a new mesh), MESH, or CONVERTED, which the URDF parser sets when tesseract:make_convex
turned a mesh into its convex hull. setCreationMethod sets it, and ConvexMesh equality
compares it. clone() returns a DEFAULT mesh without normals, colors, material or textures:
upstream's clone passes only the vertices, faces, face count, resource and scale
(convex_mesh.cpp:77 @ 0.35.0).
from tesseract_robotics.geometry import ConvexMesh
convex.getCreationMethod() == ConvexMesh.CreationMethod.DEFAULT
convex.setCreationMethod(ConvexMesh.CreationMethod.MESH)
CompoundMesh¶
Multiple mesh parts as single geometry.
from tesseract_robotics.geometry import CompoundMesh, createMeshFromPath
# Combine multiple meshes (a compound needs more than one)
parts = createMeshFromPath("model.stl") + createMeshFromPath("model.stl")
compound = CompoundMesh(parts)
SignedDistanceField¶
A volumetric geometry: instead of a surface, it stores the signed distance to a surface — negative inside, zero on it, positive outside — sampled on a regular axis-aligned grid in the geometry's local frame. That yields distance and gradient everywhere in the volume, including for concave shapes a convex hull cannot represent, which is what trajectory optimization consumes. The discrete Bullet and FCL contact managers support it; continuous (cast) managers do not, because the field is concave.
Note
Unrelated to the Gazebo "SDF" Simulation Description Format. This replaces the old
SDFMesh, which was a mesh despite the name.
From a distance function¶
The usual entry point. createDiscreteSignedDistanceField evaluates your callable once per grid
point and keeps only the samples, so the returned geometry is pure data — it holds no reference
to your Python objects and takes no GIL during collision checking.
import numpy as np
from tesseract_robotics.geometry import createDiscreteSignedDistanceField
def sphere(point): # negative inside, positive outside
return float(np.linalg.norm(point) - 0.5)
field = createDiscreteSignedDistanceField(
sphere,
domain_min=np.array([-1.0, -1.0, -1.0]),
domain_max=np.array([1.0, 1.0, 1.0]),
dimensions=np.array([33, 33, 33], dtype=np.int32), # >= 2 per axis
)
field.getDistance(np.zeros(3)) # -0.5
Pass batched=True to receive every sample point as one (N, 3) float64 array and return N
distances — the fast path for a vectorised or GPU evaluator, and one Python call instead of
dimensions.prod():
field = createDiscreteSignedDistanceField(
lambda points: np.linalg.norm(points, axis=1) - 0.5,
np.array([-1.0, -1.0, -1.0]),
np.array([1.0, 1.0, 1.0]),
np.array([33, 33, 33], dtype=np.int32),
batched=True,
)
From a grid you already have¶
distances is flat and ordered x-fastest (index = i + nx*(j + ny*k)), so a numpy grid built
with indexing="ij" transfers with ravel(order="F") and comes back with reshape(..., order="F").
import numpy as np
from tesseract_robotics.geometry import SignedDistanceField
dims = np.array([33, 33, 33], dtype=np.int32)
lo, hi = np.full(3, -1.0), np.full(3, 1.0)
x, y, z = np.meshgrid(*[np.linspace(lo[i], hi[i], dims[i]) for i in range(3)], indexing="ij")
grid = np.sqrt(x**2 + y**2 + z**2) - 0.5
field = SignedDistanceField(lo, hi, dims, grid.ravel(order="F"))
assert np.allclose(field.getDistances().reshape(dims, order="F"), grid)
From a VDB file¶
Fields round-trip through the standard OpenVDB and NanoVDB grid formats as raw bytes, so a field
baked offline loads directly. The local scale is not stored in the grid and is supplied on read.
from pathlib import Path
from tesseract_robotics.geometry import (
readSignedDistanceFieldVDB, writeSignedDistanceFieldVDB,
)
field = readSignedDistanceFieldVDB(Path("part.vdb").read_bytes())
Path("out.vdb").write_bytes(writeSignedDistanceFieldVDB(field))
readSignedDistanceFieldNVDB / writeSignedDistanceFieldNVDB do the same for NanoVDB. Both
readers accept exactly one FloatGrid with an axis-aligned, uniformly scaled transform.
Lazy fields¶
createSignedDistanceField keeps your callable as the field's source of truth instead of
sampling up front, so queries are exact rather than trilinearly interpolated. dimensions then
only sets the resolution used if the grid is ever materialized (on serialization, comparison, or
an explicit discretize()).
Prefer the discrete form unless you need that exactness. A lazy field must be thread-safe, and it
holds a reference to your callable — so storing one in a module-level global forms a reference
cycle the garbage collector cannot see through (the callable reaches its __globals__, which
reaches the field, and nanobind instances have no tp_traverse).
from tesseract_robotics.geometry import createSignedDistanceField
field = createSignedDistanceField(sphere, lo, hi, dims)
field.isDiscretized() # False
field.getDistance(p) # exact - calls sphere(p)
field.discretize() # materialize the grid up front
Use a discrete field for collision
The collision backends call getDistance() once per sample point, and each call
re-acquires the GIL. contactTest releases the GIL specifically so trajectory sweeps can run
in parallel across threads; a lazy field hands that parallelism straight back to the
interpreter. Bullet also transcodes the field into its own grid when the geometry is added to
a manager, which is one Python call per lattice point.
discretize() does not change this: it fills the grid for serialization and comparison, and
getDistance() still calls the sampler, taking the GIL, every time. For pure data, build the
field with createDiscreteSignedDistanceField:
from tesseract_robotics.planning import create_obstacle
field = createDiscreteSignedDistanceField(sphere, lo, hi, dims)
create_obstacle(robot, name="field", geometry=field)
Note discretize() holds a process-wide static mutex while calling the sampler, so it must
never run on a thread that has released the GIL: that thread would hold the mutex and block on
the GIL while a Python thread holding the GIL blocks on the mutex. The bindings avoid this (the
VDB writers discretize before releasing the GIL); avoid arranging it yourself from a C++
callback.
Octree¶
Occupancy octree from 3D sensor data, backed by octomap.
PointCloud → Octree¶
from tesseract_robotics.geometry import (
PointCloud, Octree, OctreeSubType, createOctree,
)
# Build a point cloud and convert to an octomap OcTree
pc = PointCloud()
pc.addPoint(0.0, 0.0, 0.0)
pc.addPoint(0.1, 0.0, 0.0)
pc.addPoint(0.0, 0.1, 0.0)
# Or assign whole points: the point type is nested, as in C++ (PointCloud::Point)
pc.points = [PointCloud.Point(0.0, 0.0, 0.0), PointCloud.Point(0.1, 0.0, 0.0)]
ot = createOctree(pc, resolution=0.05, prune=True, binary=True)
# Wrap in a tesseract Octree geometry
octree = Octree(ot, OctreeSubType.BOX, pruned=True, binary_octree=True)
print(octree.calcNumSubShapes())
Building an Octree directly¶
from tesseract_robotics.geometry import OcTree
ot = OcTree(0.05) # leaf resolution
ot.updateNode(0.0, 0.0, 0.0, True)
ot.updateNode(0.1, 0.0, 0.0, True)
ot.updateInnerOccupancy()
ot.toMaxLikelihood()
ot.writeBinary("/tmp/scene.bt")
# Load back from file
loaded = OcTree("/tmp/scene.bt")
| OctreeSubType | Description |
|---|---|
BOX |
Each occupied voxel becomes a box |
SPHERE_INSIDE |
Inscribed sphere per voxel |
SPHERE_OUTSIDE |
Circumscribed sphere per voxel |
Utilities & Conversions¶
from tesseract_robotics.geometry import (
Box, Sphere, isIdentical, extractVertices, toTriangleMesh,
)
from tesseract_robotics.common import Isometry3d
origin = Isometry3d()
box = Box(1, 1, 1)
# Compare two geometries structurally
isIdentical(box, Box(1, 1, 1)) # True
isIdentical(box, Sphere(1)) # False
# Extract vertices (primitives are converted to a mesh first)
verts = extractVertices(box, origin) # 8 verts
# Convert a primitive to a triangle Mesh
mesh = toTriangleMesh(box, tolerance=0.01, origin=origin)
Mesh Materials¶
MeshMaterial¶
Surface material properties.
from tesseract_robotics.geometry import MeshMaterial
import numpy as np
material = MeshMaterial(
np.array([1.0, 0.0, 0.0, 1.0]), # base_color_factor (RGBA red)
0.0, # metallic_factor
0.5, # roughness_factor
np.zeros(4), # emissive_factor (RGBA)
)
material.getBaseColorFactor()
MeshTexture¶
A texture image and its per-vertex UV coordinates.
from tesseract_robotics.common import BytesResource
from tesseract_robotics.geometry import MeshTexture
import numpy as np
png_bytes = open("texture.png", "rb").read()
uvs = [np.array([0.0, 0.0]), np.array([1.0, 0.0]), np.array([1.0, 1.0]), np.array([0.0, 1.0])]
texture = MeshTexture(BytesResource("texture.png", png_bytes), uvs)
texture.getTextureImage().getUrl() # "texture.png"
texture_image must be a jpg or png resource. Neither argument takes None (TypeError): upstream
stores both without checking them, but a texture without an image or UVs is never valid.
Geometry Base¶
Geometry¶
Base class for all geometry types.
from tesseract_robotics.geometry import Geometry, GeometryType
geom = box # any geometry
# Type checking
geom_type = geom.getType()
if geom_type == GeometryType.BOX:
print("It's a box")
# Clone
copy = geom.clone()
== compares the geometry type and its UUID, not its content: every constructor and clone() draws a
new random UUID, so Box(1, 1, 1) == Box(1, 1, 1) and geom == geom.clone() are False. Use
isIdentical to compare content. Each class adds its own fields to ==: the mesh classes compare
vertex count, face count and scale (PolygonMesh, Mesh, ConvexMesh, which also compares its
creation method). getUUID() returns the UUID as its canonical string; setUUID(str)
sets it and raises ValueError for a malformed string, leaving the UUID unchanged.
from tesseract_robotics.geometry import Box, isIdentical
a, b = Box(1, 1, 1), Box(1, 1, 1)
a == b # False: different UUIDs
isIdentical(a, b) # True: same content
b.setUUID(a.getUUID())
a == b # True
| GeometryType | Description |
|---|---|
BOX |
Rectangular box |
SPHERE |
Sphere |
CYLINDER |
Cylinder |
CAPSULE |
Capsule (cylinder + hemisphere caps) |
CONE |
Cone |
PLANE |
Infinite plane |
MESH |
Triangle mesh |
CONVEX_MESH |
Convex hull |
SIGNED_DISTANCE_FIELD |
Volumetric signed distance field |
OCTREE |
Occupancy octree |
COMPOUND_MESH |
Multiple meshes |
Factory Functions¶
| Function | Description |
|---|---|
createMeshFromPath(path, scale) |
Load mesh from file |
createMeshFromResource(resource, scale) |
Load mesh from Resource |
createConvexMeshFromPath(path, scale) |
Load as convex hull |
createConvexMeshFromResource(resource, scale) |
Convex from Resource |
createMeshFromBytes(url, data, scale) |
Load mesh from an in-memory file |
createConvexMeshFromBytes(url, data, scale) |
Convex from an in-memory file |
createOctree(point_cloud, resolution, prune, binary) |
Build an octomap OcTree from a PointCloud |
createDiscreteSignedDistanceField(sdf, domain_min, domain_max, dimensions, scale, batched) |
Sample a distance function onto a grid |
createSignedDistanceField(sdf, domain_min, domain_max, dimensions, scale, batched) |
Lazy field backed by a distance function |
readSignedDistanceFieldVDB(data, scale) / writeSignedDistanceFieldVDB(sdf) |
OpenVDB FloatGrid bytes ↔ field |
readSignedDistanceFieldNVDB(data, scale) / writeSignedDistanceFieldNVDB(sdf) |
NanoVDB FloatGrid bytes ↔ field |
Every loader also takes flatten, normals, vertex_colors and material_and_texture, all
False by default as in C++. Turn the last three on to load a mesh's normals, vertex colors,
materials and textures. The URDF parser loads visual meshes with flatten and all three flags on.
Every mesh loader defaults to triangulate=True, where the C++ header says false. The URDF
parser always triangulates (urdf/src/mesh.cpp:84–88), and Mesh expects triangles.
from tesseract_robotics.geometry import createMeshFromPath
meshes = createMeshFromPath(
"textured.dae", flatten=True, normals=True, vertex_colors=True, material_and_texture=True
)
meshes[0].getMaterial().getBaseColorFactor()
The …FromBytes loaders take bytes you already hold. The extension of url selects the format,
so url must end in .stl, .dae, and so on. The bytes are copied, so the returned meshes do not
depend on data afterwards. createMeshFromAsset and extractMeshData are not bound: they take
assimp's aiScene, which Python never sees.
from pathlib import Path
from tesseract_robotics.geometry import createMeshFromBytes
data = Path("model.stl").read_bytes()
meshes = createMeshFromBytes("model.stl", data)
Reference¶
tesseract_geometry Python bindings
GeometryType
¶
Bases: Enum
GeometriesConst
¶
Box
¶
Sphere
¶
Cylinder
¶
Capsule
¶
Cone
¶
MeshMaterial
¶
MeshTexture
¶
MeshFaceCountError
¶
Bases: ValueError
A mesh constructor's face_count disagrees with the number of faces its faces array describes.
PolygonMesh
¶
Mesh
¶
Bases: PolygonMesh
ConvexMesh
¶
Bases: PolygonMesh
SignedDistanceFieldInterpolation
¶
Bases: Enum
How a grid-backed or sparse field is read between its samples
SignedDistanceField
¶
Bases: Geometry
getDomainMin
¶
Get the minimum corner of the sampled domain (local frame)
getDomainMax
¶
Get the maximum corner of the sampled domain (local frame)
getDimensions
¶
Get the number of samples along each axis
getDistances
¶
Get the sampled signed distances, flat and x-fastest (index = i + nx*(j + ny*k)). Reshape with .reshape(field.getDimensions(), order='F') for a 3D view. Discretizes a function-backed field on first call. Raises for a sparse field, which has no dense grid.
getScale
¶
Get the local scaling applied to the field
getDistance
¶
getDistance(point: Annotated[NDArray[float64], dict(shape=3, order=C)] | Sequence[float]) -> float
Get the signed distance at a point in the field's local frame. A function-backed field evaluates its sampler directly; a grid-backed field interpolates (see setInterpolation), with the point clamped to the domain. A sparse field returns +inf where it has no answer.
getGradient
¶
getGradient(point: Annotated[NDArray[float64], dict(shape=3, order=C)] | Sequence[float]) -> Annotated[NDArray[numpy.float64], dict(shape=3, order=C)]
Get the gradient of the signed distance at a point in the field's local frame (not normalized)
getDistanceAndGradient
¶
getDistanceAndGradient(point: Annotated[NDArray[float64], dict(shape=3, order=C)] | Sequence[float]) -> tuple[float, Annotated[NDArray[numpy.float64], dict(shape=3, order=C)]]
Get (distance, gradient) at a point in the field's local frame, from one lookup
isSparse
¶
Whether this is a sparse field: one NanoVDB grid, or levels of them
getNVDB
¶
A sparse field's grid as its bare NanoVDB grid buffer (empty for a dense, function-backed or multi-level field; a multi-level field's grids are its levels')
getBandClamp
¶
A sparse field's band clamp (0 for a dense, function-backed or multi-level field)
getLevels
¶
A multi-level field's levels, finest first (empty otherwise)
setInterpolation
¶
Choose how distances (and, unless setGradientInterpolation overrides it, gradients) are read between samples
getInterpolation
¶
How the distance is read
setGradientInterpolation
¶
Read the gradient with a different method from the distance
getGradientInterpolation
¶
How the gradient is read (defaults to the distance's method)
discretize
¶
Materialize the dense sample grid from the sampler (idempotent, no-op if already discretized). A function-backed field must be discretized before it can be serialized or compared; that happens automatically at those boundaries, so call this only to pin the snapshot up front.
CompoundMesh
¶
OcTree
¶
OctreeSubType
¶
PointCloud
¶
Octree
¶
createOctree
¶
createOctree(point_cloud: PointCloud, resolution: float, prune: bool, binary: bool = True) -> OcTree
Build an octomap OcTree from a PointCloud
createMeshFromPath
¶
createMeshFromPath(path: str, scale: Annotated[NDArray[float64], dict(shape=3, order=C)] | Sequence[float] = ..., triangulate: bool = True, flatten: bool = False, normals: bool = False, vertex_colors: bool = False, material_and_texture: bool = False) -> list[Mesh]
Load mesh from file and return vector of Mesh geometries
createConvexMeshFromPath
¶
createConvexMeshFromPath(path: str, scale: Annotated[NDArray[float64], dict(shape=3, order=C)] | Sequence[float] = ..., triangulate: bool = True, flatten: bool = False, normals: bool = False, vertex_colors: bool = False, material_and_texture: bool = False) -> list[ConvexMesh]
Load mesh from file and return vector of ConvexMesh geometries
createMeshFromResource
¶
createMeshFromResource(resource: Resource, scale: Annotated[NDArray[float64], dict(shape=3, order=C)] | Sequence[float] = ..., triangulate: bool = True, flatten: bool = False, normals: bool = False, vertex_colors: bool = False, material_and_texture: bool = False) -> list[Mesh]
Load Mesh from resource (e.g., package:// URL)
createConvexMeshFromResource
¶
createConvexMeshFromResource(resource: Resource, scale: Annotated[NDArray[float64], dict(shape=3, order=C)] | Sequence[float] = ..., triangulate: bool = True, flatten: bool = False, normals: bool = False, vertex_colors: bool = False, material_and_texture: bool = False) -> list[ConvexMesh]
Load ConvexMesh from resource (e.g., package:// URL)
createMeshFromBytes
¶
createMeshFromBytes(url: str, data: bytes, scale: Annotated[NDArray[float64], dict(shape=3, order=C)] | Sequence[float] = ..., triangulate: bool = True, flatten: bool = False, normals: bool = False, vertex_colors: bool = False, material_and_texture: bool = False) -> list[Mesh]
Load Mesh geometries from an in-memory mesh file; url's extension (.stl, .dae, ...) selects the format
createConvexMeshFromBytes
¶
createConvexMeshFromBytes(url: str, data: bytes, scale: Annotated[NDArray[float64], dict(shape=3, order=C)] | Sequence[float] = ..., triangulate: bool = True, flatten: bool = False, normals: bool = False, vertex_colors: bool = False, material_and_texture: bool = False) -> list[ConvexMesh]
Load ConvexMesh geometries from an in-memory mesh file; url's extension selects the format
createDiscreteSignedDistanceField
¶
createDiscreteSignedDistanceField(sdf: Callable, domain_min: Annotated[NDArray[float64], dict(shape=3, order=C)] | Sequence[float], domain_max: Annotated[NDArray[float64], dict(shape=3, order=C)] | Sequence[float], dimensions: Annotated[NDArray[int32], dict(shape=3, order=C)] | Sequence[int], scale: Annotated[NDArray[float64], dict(shape=3, order=C)] | Sequence[float] = ..., batched: bool = False) -> SignedDistanceField
Sample a signed distance function onto a dense grid up front and return the resulting field.
sdf is negative inside the surface and evaluated in the field's local frame. The grid spans [domain_min, domain_max] inclusive with dimensions samples per axis (>= 2 per axis), so the callable is invoked dimensions.prod() times - pass batched=True to evaluate them in one call.
Prefer this over createSignedDistanceField: sdf is called only during this call and is not retained, so the returned field is pure data - no GIL taken during collision checking and no reference back into your Python objects.
createSignedDistanceField
¶
createSignedDistanceField(sdf: Callable, domain_min: Annotated[NDArray[float64], dict(shape=3, order=C)] | Sequence[float], domain_max: Annotated[NDArray[float64], dict(shape=3, order=C)] | Sequence[float], dimensions: Annotated[NDArray[int32], dict(shape=3, order=C)] | Sequence[int], scale: Annotated[NDArray[float64], dict(shape=3, order=C)] | Sequence[float] = ..., batched: bool = False) -> SignedDistanceField
Create a lazily-evaluated field that keeps the distance function as its source of truth.
No grid is sampled up front: queries and collision backends call sdf directly (exact, no resampling), and the grid is materialized only for serialization or comparison. dimensions is the resolution used when that happens.
Use createDiscreteSignedDistanceField unless you specifically need exact sampling. The field keeps sdf alive and re-enters it from C++, which costs you three things.
- sdf must be thread-safe.
- Every evaluation takes the GIL, and the collision backends call getDistance() once per sample point. contactTest releases the GIL precisely so trajectory sweeps can run in parallel; a lazy field re-acquires it per query, serializing that work back against the interpreter. discretize() does not change that: it fills the grid for serialization and comparison, and getDistance() still calls sdf, taking the GIL, every time. For pure data use createDiscreteSignedDistanceField.
- The field references sdf (and so its globals), so storing it in a module-level global forms a reference cycle the garbage collector cannot see through - drop the field explicitly or keep it out of module scope.
Discretizing from a thread that does not hold the GIL is also a deadlock risk: discretize() holds a process-wide static mutex while calling the sampler, so it must not run inside a GIL-released region. The bindings never do that (the VDB writers discretize up front), but do not arrange it yourself by, say, discretizing from inside a C++ callback.
writeSignedDistanceFieldVDB
¶
Serialize a field as a standard OpenVDB FloatGrid (raises if the voxel spacing is non-uniform)
readSignedDistanceFieldVDB
¶
readSignedDistanceFieldVDB(data: bytes, scale: Annotated[NDArray[float64], dict(shape=3, order=C)] | Sequence[float] = ...) -> SignedDistanceField
Reconstruct a field from OpenVDB FloatGrid bytes (exactly one axis-aligned, uniformly scaled grid)
writeSignedDistanceFieldNVDB
¶
Serialize a field as a standard NanoVDB file: one FloatGrid, or a multi-level field's levels' grids in order
readSignedDistanceFieldNVDB
¶
readSignedDistanceFieldNVDB(data: bytes, scale: Annotated[NDArray[float64], dict(shape=3, order=C)] | Sequence[float] = ...) -> SignedDistanceField
Reconstruct a field from NanoVDB FloatGrid bytes (exactly one axis-aligned, uniformly scaled grid)
getSignedDistanceFieldNVDBGridNames
¶
The names of the grids in NanoVDB bytes, in file order
isIdentical
¶
Check if two geometries are identical
extractVertices
¶
extractVertices(geom: Geometry, origin: Isometry3d) -> list[Annotated[NDArray[numpy.float64], dict(shape=3, order=C)]]
Extract vertices from a geometry, transforming primitives to a mesh first
toTriangleMesh
¶
Convert a primitive geometry to a triangle Mesh