Reference/API

Geometry

class[source]
robokit.geom.BaseGeom(
count: int,
scene_offsets: np.ndarray,
poses: Optional[wp.array],
scales: Optional[wp.array],
capacity: Optional[int]
)

Base geom.

Lifecycle

geom = BoxGeom(...) # store raw inputs (CPU) scene.add(geom) # calls geom.build(device): allocate capacity-padded GPU arrays geom.update(...) # fixed buffers update in place; resource swaps advance graph_revision

Parameters
countintrequired
scene_offsetsnp.ndarrayrequired
posesOptional[wp.array]required
scalesOptional[wp.array]required
capacityOptional[int]required
Members
attribute[source]
BaseGeom.params_wp: Optional[wp.array] = None
attribute[source]
BaseGeom.mesh_ids_wp: Optional[wp.array] = None
attribute[source]
BaseGeom.volume_ids_wp: Optional[wp.array] = None
attribute[source]
BaseGeom.aabb_min_wp: Optional[wp.array] = None
attribute[source]
BaseGeom.aabb_max_wp: Optional[wp.array] = None
attribute[source]
BaseGeom.paddings_wp: Optional[wp.array] = None
attribute[source]
BaseGeom.device_wp: Optional[wp_device_type]
property[source]
BaseGeom.graph_revision: int

Revision of GPU resources referenced by captured graphs.

property[source]
BaseGeom.refine_band: float
property[source]
BaseGeom.launch_params: Tuple
method[source]
BaseGeom.query_sdf(
points: wp.array,
scene_offsets: Optional[wp.array] = None,
scene_indices: Optional[wp.array] = None,
query_mask: Optional[wp.array] = None,
distance_only: bool = False,
out_signed_dists: Optional[wp.array] = None,
out_normals: Optional[wp.array] = None,
out_closest_points: Optional[wp.array] = None,
record_tape: bool = True,
out_normal_jacobians: Optional[wp.array] = None,
out_observed: Optional[wp.array] = None
) -> Union[wp.array, Tuple[wp.array, wp.array, wp.array]]

Query this geom alone (same semantics as WarpScene.query_sdf); call build first.

Parameters
pointswp.arrayrequired
scene_offsetsOptional[wp.array]= None
scene_indicesOptional[wp.array]= None
query_maskOptional[wp.array]= None
distance_onlybool= False
out_signed_distsOptional[wp.array]= None
out_normalsOptional[wp.array]= None
out_closest_pointsOptional[wp.array]= None
record_tapebool= True
out_normal_jacobiansOptional[wp.array]= None
out_observedOptional[wp.array]= None
Returns
Union[wp.array, Tuple[wp.array, wp.array, wp.array]]
method[source]
BaseGeom.build(
device: Device = 'cpu'
) -> BaseGeom

Allocate the GPU arrays; called by WarpScene.add, or directly for scene-less query_sdf.

Parameters
deviceDevice= 'cpu'
Returns
BaseGeom
class[source]
robokit.geom.WarpScene(
num_scenes: int,
device: Device = 'cpu'
)

Heterogeneous batched scene SDF query.

Example

python
>>> import numpy as np
>>> import torch
>>> import warp as wp
>>> from robokit.geom.geoms import SphereGeom
>>> wp.init()
>>> scene = WarpScene(num_scenes=1, device="cpu").add(
...     SphereGeom(np.array([1.0]), np.array([0, 1], dtype=np.int32))
... )
>>> signed_dists, _, _ = scene.query_sdf_torch(
...     torch.tensor([[2.0, 0.0, 0.0], [0.5, 0.0, 0.0]]),
...     torch.tensor([0, 2]),
... )
>>> bool(torch.allclose(signed_dists, torch.tensor([1.0, -0.5])))
True
>>> normal_jacobians = wp.empty(1, dtype=wp.mat33, device="cpu")
>>> _ = scene.query_sdf(
...     wp.array([[2.0, 0.0, 0.0]], dtype=wp.vec3, device="cpu"),
...     scene_indices=wp.array([0], dtype=wp.int32, device="cpu"),
...     out_normal_jacobians=normal_jacobians,
... )
>>> np.allclose(normal_jacobians.numpy()[0], np.diag([0.0, 0.5, 0.5]))
True
>>> observed = wp.empty(1, dtype=wp.bool, device="cpu")
>>> _ = scene.query_sdf(wp.array([[2.0, 0.0, 0.0]], dtype=wp.vec3, device="cpu"),
...     scene_indices=wp.array([0], dtype=wp.int32, device="cpu"), out_observed=observed)
>>> bool(observed.numpy()[0])  # analytical geometry is fully known
True
Parameters
num_scenesintrequired
deviceDevice= 'cpu'
Members
property[source]
WarpScene.device: wp_device_type
property[source]
WarpScene.geoms: Tuple[BaseGeom, ...]
property[source]
WarpScene.num_scenes: int
property[source]
WarpScene.num_elements: int

Total element count across all attached geoms (a MeshGeom of N meshes counts N).

property[source]
WarpScene.graph_revision: int

Monotonic revision of resources referenced by captured graphs.

method[source]
WarpScene.add(
geom: BaseGeom
) -> WarpScene

Attach a geom: allocates its GPU arrays on this scene's device; update in place via geom.update(...).

Parameters
geomBaseGeomrequired
Returns
WarpScene
method[source]
WarpScene.query_sdf(
points: wp.array,
scene_offsets: Optional[wp.array] = None,
scene_indices: Optional[wp.array] = None,
query_mask: Optional[wp.array] = None,
distance_only: bool = False,
out_signed_dists: Optional[wp.array] = None,
out_normals: Optional[wp.array] = None,
out_closest_points: Optional[wp.array] = None,
record_tape: bool = True,
out_normal_jacobians: Optional[wp.array] = None,
out_observed: Optional[wp.array] = None
) -> Union[wp.array, Tuple[wp.array, wp.array, wp.array]]

Query the scene SDF (min over all attached geoms) at points.

Parameters
pointswp.arrayrequired

Query points, any shape (flattened to n internally).

scene_offsetsOptional[wp.array]= None

CSR boundaries into the flat points, int32, length num_scenes+1. Pass exactly one of scene_offsets / scene_indices.

scene_indicesOptional[wp.array]= None

Scene id of each point, int32, one per point. Skips the derivation launch, so hot loops pass a pre-built map here.

query_maskOptional[wp.array]= None

Optional per-point gate, int32, length n. Points with mask 0 skip every geom kernel.

distance_onlybool= False

Skip the normal/closest computation (~2x faster) and return only signed distances.

out_signed_distsOptional[wp.array]= None

Optional preallocated output; required shape n. Hot loops and CUDA-graph capture pass all out_* so no allocation happens per call.

out_normalsOptional[wp.array]= None

Optional preallocated output, shape n.

out_closest_pointsOptional[wp.array]= None

Optional preallocated output, shape n.

record_tapebool= True

Record the launches on an active wp.Tape; False keeps the query off the gradient.

out_normal_jacobiansOptional[wp.array]= None

Optional preallocated wp.mat33 output, one per point. Entry (i, j) is the derivative of normal component i with respect to point coordinate j. Mesh face normals have zero derivatives; voxel and primitive normals use analytical derivatives of the active query branch. Derivatives at cell, face, or closest-object switches are discontinuous.

out_observedOptional[wp.array]= None

Optional device bool array, one per point. True when every sensor map in the scene has observed the queried voxel; outside a sensor map or masked out is False. Meshes and analytical geometry leave this status unchanged. Unknown status never skips distance checks.

Returns
Union[wp.array, Tuple[wp.array, wp.array, wp.array]]

Flat (n,) views: signed_dists if distance_only, else (signed_dists, normals, closest_points). Points in an empty scene get MAX_DIST distance and zero normals.

method[source]
WarpScene.query_sdf_torch(
query_points: torch.Tensor,
scene_offsets: torch.Tensor,
poses: Optional[Dict[BaseGeom, torch.Tensor]] = None,
scales: Optional[Dict[BaseGeom, torch.Tensor]] = None
) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]

Differentiable scene SDF query (per-point min over all attached geoms).

Parameters
query_pointstorch.Tensorrequired

Query points, shape (n, 3), differentiable.

scene_offsetstorch.Tensorrequired

CSR boundaries into the points, length num_scenes+1.

posesOptional[Dict[BaseGeom, torch.Tensor]]= None

Optional per-geom pose overrides, (count, 4, 4) tensors keyed by attached geom. Overridden geoms are queried on these poses and receive gradients; other geoms use their stored (non-differentiable) transforms.

scalesOptional[Dict[BaseGeom, torch.Tensor]]= None

Optional per-geom scale overrides, (count,) tensors keyed by attached geom. Same semantics as poses.

Returns
Tuple[torch.Tensor, torch.Tensor, torch.Tensor]

(signed_dists, normals, closest_points) torch tensors, shapes (n,), (n, 3), (n, 3). Gradients flow to query_points and to the poses/scales tensors of whichever geom is closest at each point.

class[source]
robokit.geom.BoxGeom(
half_extents: np.ndarray,
scene_offsets: np.ndarray,
poses: Optional[wp.array] = None,
scales: Optional[wp.array] = None,
capacity: Optional[int] = None
)
Bases: BaseGeom

N boxes: half_extents (N, 3), posed/rotated via poses.

Parameters
half_extentsnp.ndarrayrequired
scene_offsetsnp.ndarrayrequired
posesOptional[wp.array]= None
scalesOptional[wp.array]= None
capacityOptional[int]= None
Members
attributeinherited from BaseGeom[source]
BoxGeom.params_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
BoxGeom.mesh_ids_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
BoxGeom.volume_ids_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
BoxGeom.aabb_min_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
BoxGeom.aabb_max_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
BoxGeom.paddings_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
BoxGeom.device_wp: Optional[wp_device_type]
propertyinherited from BaseGeom[source]
BoxGeom.graph_revision: int

Revision of GPU resources referenced by captured graphs.

propertyinherited from BaseGeom[source]
BoxGeom.refine_band: float
propertyinherited from BaseGeom[source]
BoxGeom.launch_params: Tuple
methodinherited from BaseGeom[source]
BoxGeom.query_sdf(
points: wp.array,
scene_offsets: Optional[wp.array] = None,
scene_indices: Optional[wp.array] = None,
query_mask: Optional[wp.array] = None,
distance_only: bool = False,
out_signed_dists: Optional[wp.array] = None,
out_normals: Optional[wp.array] = None,
out_closest_points: Optional[wp.array] = None,
record_tape: bool = True,
out_normal_jacobians: Optional[wp.array] = None,
out_observed: Optional[wp.array] = None
) -> Union[wp.array, Tuple[wp.array, wp.array, wp.array]]

Query this geom alone (same semantics as WarpScene.query_sdf); call build first.

Parameters
pointswp.arrayrequired
scene_offsetsOptional[wp.array]= None
scene_indicesOptional[wp.array]= None
query_maskOptional[wp.array]= None
distance_onlybool= False
out_signed_distsOptional[wp.array]= None
out_normalsOptional[wp.array]= None
out_closest_pointsOptional[wp.array]= None
record_tapebool= True
out_normal_jacobiansOptional[wp.array]= None
out_observedOptional[wp.array]= None
Returns
Union[wp.array, Tuple[wp.array, wp.array, wp.array]]
methodinherited from BaseGeom[source]
BoxGeom.build(
device: Device = 'cpu'
) -> BaseGeom

Allocate the GPU arrays; called by WarpScene.add, or directly for scene-less query_sdf.

Parameters
deviceDevice= 'cpu'
Returns
BaseGeom
method[source]
BoxGeom.update(
half_extents: Optional[np.ndarray] = None,
scene_offsets: Optional[np.ndarray] = None,
poses: Optional[wp.array] = None,
scales: Optional[wp.array] = None
) -> None
Parameters
half_extentsOptional[np.ndarray]= None
scene_offsetsOptional[np.ndarray]= None
posesOptional[wp.array]= None
scalesOptional[wp.array]= None
Returns
None
class[source]
robokit.geom.SphereGeom(
radii: np.ndarray,
scene_offsets: np.ndarray,
poses: Optional[wp.array] = None,
scales: Optional[wp.array] = None,
capacity: Optional[int] = None
)
Bases: BaseGeom

N spheres: radii (N,), centered via poses.

Parameters
radiinp.ndarrayrequired
scene_offsetsnp.ndarrayrequired
posesOptional[wp.array]= None
scalesOptional[wp.array]= None
capacityOptional[int]= None
Members
attributeinherited from BaseGeom[source]
SphereGeom.params_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
SphereGeom.mesh_ids_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
SphereGeom.volume_ids_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
SphereGeom.aabb_min_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
SphereGeom.aabb_max_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
SphereGeom.paddings_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
SphereGeom.device_wp: Optional[wp_device_type]
propertyinherited from BaseGeom[source]
SphereGeom.graph_revision: int

Revision of GPU resources referenced by captured graphs.

propertyinherited from BaseGeom[source]
SphereGeom.refine_band: float
propertyinherited from BaseGeom[source]
SphereGeom.launch_params: Tuple
methodinherited from BaseGeom[source]
SphereGeom.query_sdf(
points: wp.array,
scene_offsets: Optional[wp.array] = None,
scene_indices: Optional[wp.array] = None,
query_mask: Optional[wp.array] = None,
distance_only: bool = False,
out_signed_dists: Optional[wp.array] = None,
out_normals: Optional[wp.array] = None,
out_closest_points: Optional[wp.array] = None,
record_tape: bool = True,
out_normal_jacobians: Optional[wp.array] = None,
out_observed: Optional[wp.array] = None
) -> Union[wp.array, Tuple[wp.array, wp.array, wp.array]]

Query this geom alone (same semantics as WarpScene.query_sdf); call build first.

Parameters
pointswp.arrayrequired
scene_offsetsOptional[wp.array]= None
scene_indicesOptional[wp.array]= None
query_maskOptional[wp.array]= None
distance_onlybool= False
out_signed_distsOptional[wp.array]= None
out_normalsOptional[wp.array]= None
out_closest_pointsOptional[wp.array]= None
record_tapebool= True
out_normal_jacobiansOptional[wp.array]= None
out_observedOptional[wp.array]= None
Returns
Union[wp.array, Tuple[wp.array, wp.array, wp.array]]
methodinherited from BaseGeom[source]
SphereGeom.build(
device: Device = 'cpu'
) -> BaseGeom

Allocate the GPU arrays; called by WarpScene.add, or directly for scene-less query_sdf.

Parameters
deviceDevice= 'cpu'
Returns
BaseGeom
method[source]
SphereGeom.update(
radii: Optional[np.ndarray] = None,
scene_offsets: Optional[np.ndarray] = None,
poses: Optional[wp.array] = None,
scales: Optional[wp.array] = None
) -> None
Parameters
radiiOptional[np.ndarray]= None
scene_offsetsOptional[np.ndarray]= None
posesOptional[wp.array]= None
scalesOptional[wp.array]= None
Returns
None
class[source]
robokit.geom.PlaneGeom(
scene_offsets: np.ndarray,
poses: Optional[wp.array] = None,
scales: Optional[wp.array] = None,
capacity: Optional[int] = None
)
Bases: BaseGeom

N halfspaces (local z=0 planes, sdf = local z): count = scene_offsets[-1], orientation via poses.

Parameters
scene_offsetsnp.ndarrayrequired
posesOptional[wp.array]= None
scalesOptional[wp.array]= None
capacityOptional[int]= None
Members
attributeinherited from BaseGeom[source]
PlaneGeom.params_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
PlaneGeom.mesh_ids_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
PlaneGeom.volume_ids_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
PlaneGeom.aabb_min_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
PlaneGeom.aabb_max_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
PlaneGeom.paddings_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
PlaneGeom.device_wp: Optional[wp_device_type]
propertyinherited from BaseGeom[source]
PlaneGeom.graph_revision: int

Revision of GPU resources referenced by captured graphs.

propertyinherited from BaseGeom[source]
PlaneGeom.refine_band: float
propertyinherited from BaseGeom[source]
PlaneGeom.launch_params: Tuple
methodinherited from BaseGeom[source]
PlaneGeom.query_sdf(
points: wp.array,
scene_offsets: Optional[wp.array] = None,
scene_indices: Optional[wp.array] = None,
query_mask: Optional[wp.array] = None,
distance_only: bool = False,
out_signed_dists: Optional[wp.array] = None,
out_normals: Optional[wp.array] = None,
out_closest_points: Optional[wp.array] = None,
record_tape: bool = True,
out_normal_jacobians: Optional[wp.array] = None,
out_observed: Optional[wp.array] = None
) -> Union[wp.array, Tuple[wp.array, wp.array, wp.array]]

Query this geom alone (same semantics as WarpScene.query_sdf); call build first.

Parameters
pointswp.arrayrequired
scene_offsetsOptional[wp.array]= None
scene_indicesOptional[wp.array]= None
query_maskOptional[wp.array]= None
distance_onlybool= False
out_signed_distsOptional[wp.array]= None
out_normalsOptional[wp.array]= None
out_closest_pointsOptional[wp.array]= None
record_tapebool= True
out_normal_jacobiansOptional[wp.array]= None
out_observedOptional[wp.array]= None
Returns
Union[wp.array, Tuple[wp.array, wp.array, wp.array]]
methodinherited from BaseGeom[source]
PlaneGeom.build(
device: Device = 'cpu'
) -> BaseGeom

Allocate the GPU arrays; called by WarpScene.add, or directly for scene-less query_sdf.

Parameters
deviceDevice= 'cpu'
Returns
BaseGeom
method[source]
PlaneGeom.update(
scene_offsets: Optional[np.ndarray] = None,
poses: Optional[wp.array] = None,
scales: Optional[wp.array] = None
) -> None
Parameters
scene_offsetsOptional[np.ndarray]= None
posesOptional[wp.array]= None
scalesOptional[wp.array]= None
Returns
None
class[source]
robokit.geom.CapsuleGeom(
radii: np.ndarray,
half_heights: np.ndarray,
scene_offsets: np.ndarray,
poses: Optional[wp.array] = None,
scales: Optional[wp.array] = None,
capacity: Optional[int] = None
)
Bases: BaseGeom

N capsules: radii (N,) + half_heights (N,), axis along local z via poses.

Parameters
radiinp.ndarrayrequired
half_heightsnp.ndarrayrequired
scene_offsetsnp.ndarrayrequired
posesOptional[wp.array]= None
scalesOptional[wp.array]= None
capacityOptional[int]= None
Members
attributeinherited from BaseGeom[source]
CapsuleGeom.params_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
CapsuleGeom.mesh_ids_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
CapsuleGeom.volume_ids_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
CapsuleGeom.aabb_min_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
CapsuleGeom.aabb_max_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
CapsuleGeom.paddings_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
CapsuleGeom.device_wp: Optional[wp_device_type]
propertyinherited from BaseGeom[source]
CapsuleGeom.graph_revision: int

Revision of GPU resources referenced by captured graphs.

propertyinherited from BaseGeom[source]
CapsuleGeom.refine_band: float
propertyinherited from BaseGeom[source]
CapsuleGeom.launch_params: Tuple
methodinherited from BaseGeom[source]
CapsuleGeom.query_sdf(
points: wp.array,
scene_offsets: Optional[wp.array] = None,
scene_indices: Optional[wp.array] = None,
query_mask: Optional[wp.array] = None,
distance_only: bool = False,
out_signed_dists: Optional[wp.array] = None,
out_normals: Optional[wp.array] = None,
out_closest_points: Optional[wp.array] = None,
record_tape: bool = True,
out_normal_jacobians: Optional[wp.array] = None,
out_observed: Optional[wp.array] = None
) -> Union[wp.array, Tuple[wp.array, wp.array, wp.array]]

Query this geom alone (same semantics as WarpScene.query_sdf); call build first.

Parameters
pointswp.arrayrequired
scene_offsetsOptional[wp.array]= None
scene_indicesOptional[wp.array]= None
query_maskOptional[wp.array]= None
distance_onlybool= False
out_signed_distsOptional[wp.array]= None
out_normalsOptional[wp.array]= None
out_closest_pointsOptional[wp.array]= None
record_tapebool= True
out_normal_jacobiansOptional[wp.array]= None
out_observedOptional[wp.array]= None
Returns
Union[wp.array, Tuple[wp.array, wp.array, wp.array]]
methodinherited from BaseGeom[source]
CapsuleGeom.build(
device: Device = 'cpu'
) -> BaseGeom

Allocate the GPU arrays; called by WarpScene.add, or directly for scene-less query_sdf.

Parameters
deviceDevice= 'cpu'
Returns
BaseGeom
method[source]
CapsuleGeom.update(
radii: Optional[np.ndarray] = None,
half_heights: Optional[np.ndarray] = None,
scene_offsets: Optional[np.ndarray] = None,
poses: Optional[wp.array] = None,
scales: Optional[wp.array] = None
) -> None
Parameters
radiiOptional[np.ndarray]= None
half_heightsOptional[np.ndarray]= None
scene_offsetsOptional[np.ndarray]= None
posesOptional[wp.array]= None
scalesOptional[wp.array]= None
Returns
None
class[source]
robokit.geom.MeshGeom(
meshes: MeshList,
scene_offsets: np.ndarray,
poses: Optional[wp.array] = None,
scales: Optional[wp.array] = None,
enable_sdf: bool = False,
sdf_voxel_size: float = 0.01,
sdf_padding: float = 0.1,
refine_band_voxels: float = REFINE_BAND_VOXELS,
capacity: Optional[int] = None
)
Bases: BaseGeom

N triangle meshes; enable_sdf bakes a disk-cached per-mesh SDF for far queries instead of the exact mesh.

Parameters
meshesMeshListrequired
scene_offsetsnp.ndarrayrequired
posesOptional[wp.array]= None
scalesOptional[wp.array]= None
enable_sdfbool= False
sdf_voxel_sizefloat= 0.01
sdf_paddingfloat= 0.1
refine_band_voxelsfloat= REFINE_BAND_VOXELS
capacityOptional[int]= None
Members
attributeinherited from BaseGeom[source]
MeshGeom.params_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
MeshGeom.mesh_ids_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
MeshGeom.volume_ids_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
MeshGeom.aabb_min_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
MeshGeom.aabb_max_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
MeshGeom.paddings_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
MeshGeom.device_wp: Optional[wp_device_type]
propertyinherited from BaseGeom[source]
MeshGeom.graph_revision: int

Revision of GPU resources referenced by captured graphs.

methodinherited from BaseGeom[source]
MeshGeom.query_sdf(
points: wp.array,
scene_offsets: Optional[wp.array] = None,
scene_indices: Optional[wp.array] = None,
query_mask: Optional[wp.array] = None,
distance_only: bool = False,
out_signed_dists: Optional[wp.array] = None,
out_normals: Optional[wp.array] = None,
out_closest_points: Optional[wp.array] = None,
record_tape: bool = True,
out_normal_jacobians: Optional[wp.array] = None,
out_observed: Optional[wp.array] = None
) -> Union[wp.array, Tuple[wp.array, wp.array, wp.array]]

Query this geom alone (same semantics as WarpScene.query_sdf); call build first.

Parameters
pointswp.arrayrequired
scene_offsetsOptional[wp.array]= None
scene_indicesOptional[wp.array]= None
query_maskOptional[wp.array]= None
distance_onlybool= False
out_signed_distsOptional[wp.array]= None
out_normalsOptional[wp.array]= None
out_closest_pointsOptional[wp.array]= None
record_tapebool= True
out_normal_jacobiansOptional[wp.array]= None
out_observedOptional[wp.array]= None
Returns
Union[wp.array, Tuple[wp.array, wp.array, wp.array]]
property[source]
MeshGeom.launch_params: Tuple
property[source]
MeshGeom.refine_band: float
method[source]
MeshGeom.build(
device: Device = 'cpu'
) -> MeshGeom
Parameters
deviceDevice= 'cpu'
Returns
MeshGeom
method[source]
MeshGeom.update(
meshes: Optional[MeshList] = None,
scene_offsets: Optional[np.ndarray] = None,
poses: Optional[wp.array] = None,
scales: Optional[wp.array] = None
) -> None

meshes swaps the mesh ids + AABBs (and rebakes the SDF tier if enabled).

Parameters
meshesOptional[MeshList]= None
scene_offsetsOptional[np.ndarray]= None
posesOptional[wp.array]= None
scalesOptional[wp.array]= None
Returns
None
class[source]
robokit.geom.VolumeGeom(
sdf_volumes: List[SdfVolume],
scene_offsets: np.ndarray,
poses: Optional[wp.array] = None,
scales: Optional[wp.array] = None,
capacity: Optional[int] = None
)
Bases: BaseGeom

N pre-baked SdfVolume grids (NanoVDB trilinear sample; conservative extrapolation outside the AABB).

Parameters
sdf_volumesList[SdfVolume]required
scene_offsetsnp.ndarrayrequired
posesOptional[wp.array]= None
scalesOptional[wp.array]= None
capacityOptional[int]= None
Members
attributeinherited from BaseGeom[source]
VolumeGeom.params_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
VolumeGeom.mesh_ids_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
VolumeGeom.volume_ids_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
VolumeGeom.aabb_min_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
VolumeGeom.aabb_max_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
VolumeGeom.paddings_wp: Optional[wp.array] = None
attributeinherited from BaseGeom[source]
VolumeGeom.device_wp: Optional[wp_device_type]
propertyinherited from BaseGeom[source]
VolumeGeom.graph_revision: int

Revision of GPU resources referenced by captured graphs.

propertyinherited from BaseGeom[source]
VolumeGeom.refine_band: float
methodinherited from BaseGeom[source]
VolumeGeom.query_sdf(
points: wp.array,
scene_offsets: Optional[wp.array] = None,
scene_indices: Optional[wp.array] = None,
query_mask: Optional[wp.array] = None,
distance_only: bool = False,
out_signed_dists: Optional[wp.array] = None,
out_normals: Optional[wp.array] = None,
out_closest_points: Optional[wp.array] = None,
record_tape: bool = True,
out_normal_jacobians: Optional[wp.array] = None,
out_observed: Optional[wp.array] = None
) -> Union[wp.array, Tuple[wp.array, wp.array, wp.array]]

Query this geom alone (same semantics as WarpScene.query_sdf); call build first.

Parameters
pointswp.arrayrequired
scene_offsetsOptional[wp.array]= None
scene_indicesOptional[wp.array]= None
query_maskOptional[wp.array]= None
distance_onlybool= False
out_signed_distsOptional[wp.array]= None
out_normalsOptional[wp.array]= None
out_closest_pointsOptional[wp.array]= None
record_tapebool= True
out_normal_jacobiansOptional[wp.array]= None
out_observedOptional[wp.array]= None
Returns
Union[wp.array, Tuple[wp.array, wp.array, wp.array]]
property[source]
VolumeGeom.launch_params: Tuple
method[source]
VolumeGeom.build(
device: Device = 'cpu'
) -> VolumeGeom
Parameters
deviceDevice= 'cpu'
Returns
VolumeGeom
method[source]
VolumeGeom.update(
sdf_volumes: Optional[List[SdfVolume]] = None,
scene_offsets: Optional[np.ndarray] = None,
poses: Optional[wp.array] = None,
scales: Optional[wp.array] = None
) -> None

sdf_volumes swaps ids/AABBs/paddings.

Parameters
sdf_volumesOptional[List[SdfVolume]]= None
scene_offsetsOptional[np.ndarray]= None
posesOptional[wp.array]= None
scalesOptional[wp.array]= None
Returns
None