Broad Phase¶

class ipctk.BroadPhaseMethod¶

Bases: pybind11_object

Enumeration of implemented broad phase methods.

Members:

BRUTE_FORCE :

HASH_GRID :

SPATIAL_HASH :

SWEEP_AND_TINIEST_QUEUE :

SWEEP_AND_TINIEST_QUEUE_GPU :

Public Data Attributes:

`name`
`value`
`BRUTE_FORCE`
`HASH_GRID`
`SPATIAL_HASH`
`SWEEP_AND_TINIEST_QUEUE`
`SWEEP_AND_TINIEST_QUEUE_GPU`

Public Methods:

`__init__`(self, value)
`__repr__`(self)
`__str__`	name(self: handle) -> str
`__eq__`(self, other)
`__ne__`(self, other)
`__getstate__`(self)
`__hash__`(self)
`__int__`(self)
`__index__`(self)
`__setstate__`(self, state)

Inherited from pybind11_object

Private Data Attributes:

`__entries`

BRUTE_FORCE = <BroadPhaseMethod.BRUTE_FORCE: 0>¶

HASH_GRID = <BroadPhaseMethod.HASH_GRID: 1>¶

SPATIAL_HASH = <BroadPhaseMethod.SPATIAL_HASH: 2>¶

SWEEP_AND_TINIEST_QUEUE = <BroadPhaseMethod.SWEEP_AND_TINIEST_QUEUE: 3>¶

SWEEP_AND_TINIEST_QUEUE_GPU = <BroadPhaseMethod.SWEEP_AND_TINIEST_QUEUE_GPU: 4>¶

__eq__(self, other: object) → bool¶

__getstate__(self) → int¶

__hash__(self) → int¶

__index__(self) → int¶

__init__(self, value: int)¶

__int__(self) → int¶

__members__ = {'BRUTE_FORCE': <BroadPhaseMethod.BRUTE_FORCE: 0>, 'HASH_GRID': <BroadPhaseMethod.HASH_GRID: 1>, 'SPATIAL_HASH': <BroadPhaseMethod.SPATIAL_HASH: 2>, 'SWEEP_AND_TINIEST_QUEUE': <BroadPhaseMethod.SWEEP_AND_TINIEST_QUEUE: 3>, 'SWEEP_AND_TINIEST_QUEUE_GPU': <BroadPhaseMethod.SWEEP_AND_TINIEST_QUEUE_GPU: 4>}¶

__module__ = 'ipctk'¶

__ne__(self, other: object) → bool¶

__repr__(self) → str¶

__setstate__(self, state: int) → None¶

__str__()¶: name(self: handle) -> str

property name : str¶

property value : int¶

Broad Phase¶

class ipctk.BroadPhase¶

Bases: pybind11_object

Public Data Attributes:

`can_vertices_collide`	Function for determining if two vertices can collide.

Public Methods:

`__init__`(args, *kwargs)
`make_broad_phase`(broad_phase_method)	Construct a registered broad phase object.
`build`(args, *kwargs)	Overloaded function.
`clear`(self)	Clear any built data.
`detect_edge_vertex_candidates`(self)	Find the candidate edge-vertex collisisons.
`detect_edge_edge_candidates`(self)	Find the candidate edge-edge collisions.
`detect_face_vertex_candidates`(self)	Find the candidate face-vertex collisions.
`detect_edge_face_candidates`(self)	Find the candidate edge-face intersections.
`detect_collision_candidates`(self, dim)	Detect all collision candidates needed for a given dimensional simulation.

Inherited from pybind11_object

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'ipctk'¶

build(*args, **kwargs)¶

Overloaded function.

build(self: ipctk.BroadPhase, vertices: numpy.ndarray[numpy.float64[m, n]], edges: numpy.ndarray[numpy.int32[m, n]], faces: numpy.ndarray[numpy.int32[m, n]], inflation_radius: float = 0) -> None

Build the broad phase for static collision detection.

Parameters:
vertices: Vertex positions edges: Collision mesh edges faces: Collision mesh faces inflation_radius: Radius of inflation around all elements.
build(self: ipctk.BroadPhase, vertices_t0: numpy.ndarray[numpy.float64[m, n]], vertices_t1: numpy.ndarray[numpy.float64[m, n]], edges: numpy.ndarray[numpy.int32[m, n]], faces: numpy.ndarray[numpy.int32[m, n]], inflation_radius: float = 0) -> None

Build the broad phase for continuous collision detection.

Parameters:
vertices_t0: Starting vertices of the vertices. vertices_t1: Ending vertices of the vertices. edges: Collision mesh edges faces: Collision mesh faces inflation_radius: Radius of inflation around all elements.

property can_vertices_collide : collections.abc.Callable[[int, int], bool]¶: Function for determining if two vertices can collide.

clear(self) → None¶: Clear any built data.

detect_collision_candidates(self, dim: int) → ipc::Candidates¶

Detect all collision candidates needed for a given dimensional simulation.

Parameters:¶

dim: int¶: The dimension of the simulation (i.e., 2 or 3).

detect_edge_edge_candidates(self) → list[ipc::EdgeEdgeCandidate]¶

Find the candidate edge-edge collisions.

Returns:¶: The candidate edge-edge collisisons.

detect_edge_face_candidates(self) → list[ipc::EdgeFaceCandidate]¶

Find the candidate edge-face intersections.

Returns:¶: The candidate edge-face intersections.

detect_edge_vertex_candidates(self) → list[ipc::EdgeVertexCandidate]¶

Find the candidate edge-vertex collisisons.

Returns:¶: The candidate edge-vertex collisisons.

detect_face_vertex_candidates(self) → list[ipc::FaceVertexCandidate]¶

Find the candidate face-vertex collisions.

Returns:¶: The candidate face-vertex collisisons.

static make_broad_phase(broad_phase_method: ipctk.BroadPhaseMethod) → ipctk.BroadPhase¶

Construct a registered broad phase object.

Parameters:¶

broad_phase_method: ipctk.BroadPhaseMethod¶: The broad phase method to use.

Returns:¶

The constructed broad phase object.

Brute Force¶

class ipctk.BruteForce¶

Bases: BroadPhase

Public Data Attributes:

Inherited from BroadPhase

`can_vertices_collide`	Function for determining if two vertices can collide.

Public Methods:

`__init__`(self)
`detect_edge_vertex_candidates`(self)	Find the candidate edge-vertex collisisons.
`detect_edge_edge_candidates`(self)	Find the candidate edge-edge collisions.
`detect_face_vertex_candidates`(self)	Find the candidate face-vertex collisions.
`detect_edge_face_candidates`(self)	Find the candidate edge-face intersections.

Inherited from BroadPhase

`__init__`(args, *kwargs)
`make_broad_phase`(broad_phase_method)	Construct a registered broad phase object.
`build`(args, *kwargs)	Overloaded function.
`clear`(self)	Clear any built data.
`detect_edge_vertex_candidates`(self)	Find the candidate edge-vertex collisisons.
`detect_edge_edge_candidates`(self)	Find the candidate edge-edge collisions.
`detect_face_vertex_candidates`(self)	Find the candidate face-vertex collisions.
`detect_edge_face_candidates`(self)	Find the candidate edge-face intersections.
`detect_collision_candidates`(self, dim)	Detect all collision candidates needed for a given dimensional simulation.

Inherited from pybind11_object

__annotations__ = {}¶

__init__(self)¶

__module__ = 'ipctk'¶

detect_edge_edge_candidates(self) → list[ipc::EdgeEdgeCandidate]¶: Find the candidate edge-edge collisions.

detect_edge_face_candidates(self) → list[ipc::EdgeFaceCandidate]¶: Find the candidate edge-face intersections.

detect_edge_vertex_candidates(self) → list[ipc::EdgeVertexCandidate]¶: Find the candidate edge-vertex collisisons.

detect_face_vertex_candidates(self) → list[ipc::FaceVertexCandidate]¶: Find the candidate face-vertex collisions.

Hash Grid¶

class ipctk.HashGrid¶

Bases: BroadPhase

Public Data Attributes:

Inherited from BroadPhase

`can_vertices_collide`	Function for determining if two vertices can collide.

Public Methods:

`__init__`(self)
`build`(args, *kwargs)	Overloaded function.
`clear`(self)	Clear the hash grid.
`detect_edge_vertex_candidates`(self)	Find the candidate edge-vertex collisisons.
`detect_edge_edge_candidates`(self)	Find the candidate edge-edge collisions.
`detect_face_vertex_candidates`(self)	Find the candidate face-vertex collisions.
`detect_edge_face_candidates`(self)	Find the candidate edge-face intersections.
`cellSize`(self)
`gridSize`(self)
`domainMin`(self)
`domainMax`(self)

Inherited from BroadPhase

`__init__`(args, *kwargs)
`make_broad_phase`(broad_phase_method)	Construct a registered broad phase object.
`build`(args, *kwargs)	Overloaded function.
`clear`(self)	Clear any built data.
`detect_edge_vertex_candidates`(self)	Find the candidate edge-vertex collisisons.
`detect_edge_edge_candidates`(self)	Find the candidate edge-edge collisions.
`detect_face_vertex_candidates`(self)	Find the candidate face-vertex collisions.
`detect_edge_face_candidates`(self)	Find the candidate edge-face intersections.
`detect_collision_candidates`(self, dim)	Detect all collision candidates needed for a given dimensional simulation.

Inherited from pybind11_object

__annotations__ = {}¶

__init__(self)¶

__module__ = 'ipctk'¶

build(*args, **kwargs)¶

Overloaded function.

build(self: ipctk.HashGrid, vertices: numpy.ndarray[numpy.float64[m, n]], edges: numpy.ndarray[numpy.int32[m, n]], faces: numpy.ndarray[numpy.int32[m, n]], inflation_radius: float = 0) -> None

Build the broad phase for static collision detection.

Parameters:
vertices_t0: Vertex positions edges: Collision mesh edges faces: Collision mesh faces inflation_radius: Radius of inflation around all elements.
build(self: ipctk.HashGrid, vertices_t0: numpy.ndarray[numpy.float64[m, n]], vertices_t1: numpy.ndarray[numpy.float64[m, n]], edges: numpy.ndarray[numpy.int32[m, n]], faces: numpy.ndarray[numpy.int32[m, n]], inflation_radius: float = 0) -> None

Build the broad phase for continuous collision detection.

Parameters:
vertices_t0: Starting vertices of the vertices. vertices_t1: Ending vertices of the vertices. edges: Collision mesh edges faces: Collision mesh faces inflation_radius: Radius of inflation around all elements.

cellSize(self) → float¶

clear(self) → None¶: Clear the hash grid.

detect_edge_edge_candidates(self) → list[ipc::EdgeEdgeCandidate]¶

Find the candidate edge-edge collisions.

Returns:¶: The candidate edge-edge collisisons.

detect_edge_face_candidates(self) → list[ipc::EdgeFaceCandidate]¶

Find the candidate edge-face intersections.

Returns:¶: The candidate edge-face intersections.

detect_edge_vertex_candidates(self) → list[ipc::EdgeVertexCandidate]¶

Find the candidate edge-vertex collisisons.

Returns:¶: The candidate edge-vertex collisisons.

detect_face_vertex_candidates(self) → list[ipc::FaceVertexCandidate]¶

Find the candidate face-vertex collisions.

Returns:¶: The candidate face-vertex collisisons.

domainMax(self) → numpy.ndarray[numpy.float64[m, 1]]¶

domainMin(self) → numpy.ndarray[numpy.float64[m, 1]]¶

gridSize(self) → numpy.ndarray[numpy.int32[m, 1]]¶

Spatial Hash¶

class ipctk.SpatialHash¶

Bases: BroadPhase

Public Data Attributes:

`leftBottomCorner`
`rightTopCorner`
`voxelCount`
`one_div_voxelSize`
`voxelCount0x1`
`edgeStartInd`
`triStartInd`
`voxel`
`pointAndEdgeOccupancy`

Inherited from BroadPhase

`can_vertices_collide`	Function for determining if two vertices can collide.

Public Methods:

`__init__`(args, *kwargs)	Overloaded function.
`build`(args, *kwargs)	Overloaded function.
`clear`(self)
`queryPointForTriangles`(args, *kwargs)	Overloaded function.
`queryPointForPrimitives`(args, *kwargs)	Overloaded function.
`queryEdgeForPE`(self, e0, e1[, radius])
`queryEdgeForEdges`(args, *kwargs)	Overloaded function.
`queryEdgeForEdgesWithBBoxCheck`(args, *kwargs)	Overloaded function.
`queryTriangleForPoints`(args, *kwargs)	Overloaded function.
`queryTriangleForEdges`(self, t0, 1]], t1, ...)
`queryEdgeForTriangles`(args, *kwargs)	Overloaded function.
`queryPointForEdges`(self, vi)
`detect_edge_vertex_candidates`(self)	Find the candidate edge-vertex collisisons.
`detect_edge_edge_candidates`(self)	Find the candidate edge-edge collisions.
`detect_face_vertex_candidates`(self)	Find the candidate face-vertex collisions.
`detect_edge_face_candidates`(self)	Find the candidate edge-face intersections.

Inherited from BroadPhase

`__init__`(args, *kwargs)
`make_broad_phase`(broad_phase_method)	Construct a registered broad phase object.
`build`(args, *kwargs)	Overloaded function.
`clear`(self)	Clear any built data.
`detect_edge_vertex_candidates`(self)	Find the candidate edge-vertex collisisons.
`detect_edge_edge_candidates`(self)	Find the candidate edge-edge collisions.
`detect_face_vertex_candidates`(self)	Find the candidate face-vertex collisions.
`detect_edge_face_candidates`(self)	Find the candidate edge-face intersections.
`detect_collision_candidates`(self, dim)	Detect all collision candidates needed for a given dimensional simulation.

Inherited from pybind11_object

__annotations__ = {}¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: ipctk.SpatialHash) -> None
__init__(self: ipctk.SpatialHash, vertices: numpy.ndarray[numpy.float64[m, n]], edges: numpy.ndarray[numpy.int32[m, n]], faces: numpy.ndarray[numpy.int32[m, n]], inflation_radius: float = 0, voxelSize: float = -1) -> None
__init__(self: ipctk.SpatialHash, vertices_t0: numpy.ndarray[numpy.float64[m, n]], vertices_t1: numpy.ndarray[numpy.float64[m, n]], edges: numpy.ndarray[numpy.int32[m, n]], faces: numpy.ndarray[numpy.int32[m, n]], inflation_radius: float = 0, voxelSize: float = -1) -> None

__module__ = 'ipctk'¶

build(*args, **kwargs)¶

Overloaded function.

build(self: ipctk.SpatialHash, vertices: numpy.ndarray[numpy.float64[m, n]], edges: numpy.ndarray[numpy.int32[m, n]], faces: numpy.ndarray[numpy.int32[m, n]], inflation_radius: float = 0) -> None
build(self: ipctk.SpatialHash, vertices_t0: numpy.ndarray[numpy.float64[m, n]], vertices_t1: numpy.ndarray[numpy.float64[m, n]], edges: numpy.ndarray[numpy.int32[m, n]], faces: numpy.ndarray[numpy.int32[m, n]], inflation_radius: float = 0) -> None
build(self: ipctk.SpatialHash, vertices: numpy.ndarray[numpy.float64[m, n]], edges: numpy.ndarray[numpy.int32[m, n]], faces: numpy.ndarray[numpy.int32[m, n]], inflation_radius: float, voxelSize: float) -> None
build(self: ipctk.SpatialHash, vertices_t0: numpy.ndarray[numpy.float64[m, n]], vertices_t1: numpy.ndarray[numpy.float64[m, n]], edges: numpy.ndarray[numpy.int32[m, n]], faces: numpy.ndarray[numpy.int32[m, n]], inflation_radius: float, voxelSize: float) -> None

clear(self) → None¶

detect_edge_edge_candidates(self) → list[ipc::EdgeEdgeCandidate]¶: Find the candidate edge-edge collisions.

detect_edge_face_candidates(self) → list[ipc::EdgeFaceCandidate]¶: Find the candidate edge-face intersections.

detect_edge_vertex_candidates(self) → list[ipc::EdgeVertexCandidate]¶: Find the candidate edge-vertex collisisons.

detect_face_vertex_candidates(self) → list[ipc::FaceVertexCandidate]¶: Find the candidate face-vertex collisions.

property edgeStartInd : int¶

property leftBottomCorner : numpy.ndarray[numpy.float64[m, 1]]¶

property one_div_voxelSize : float¶

property pointAndEdgeOccupancy : list[list[int]]¶

queryEdgeForEdges(*args, **kwargs)¶

Overloaded function.

queryEdgeForEdges(self: ipctk.SpatialHash, ea0: numpy.ndarray[numpy.float64[m, 1]], ea1: numpy.ndarray[numpy.float64[m, 1]], radius: float = 0, eai: int = -1) -> List[int]
queryEdgeForEdges(self: ipctk.SpatialHash, ea0_t0: numpy.ndarray[numpy.float64[m, 1]], ea1_t0: numpy.ndarray[numpy.float64[m, 1]], ea0_t1: numpy.ndarray[numpy.float64[m, 1]], ea1_t1: numpy.ndarray[numpy.float64[m, 1]], radius: float = 0, eai: int = -1) -> List[int]
queryEdgeForEdges(self: ipctk.SpatialHash, eai: int) -> tsl::robin_set<int, absl::lts_20230125::hash_internal::Hash<int>, std::equal_to<int>, std::allocator<int>, false, tsl::rh::power_of_two_growth_policy<2ul> >

queryEdgeForEdgesWithBBoxCheck(*args, **kwargs)¶

Overloaded function.

queryEdgeForEdgesWithBBoxCheck(self: ipctk.SpatialHash, vertices: numpy.ndarray[numpy.float64[m, n]], edges: numpy.ndarray[numpy.int32[m, n]], ea0: numpy.ndarray[numpy.float64[m, 1]], ea1: numpy.ndarray[numpy.float64[m, 1]], radius: float = 0, eai: int = -1) -> List[int]
queryEdgeForEdgesWithBBoxCheck(self: ipctk.SpatialHash, vertices_t0: numpy.ndarray[numpy.float64[m, n]], vertices_t1: numpy.ndarray[numpy.float64[m, n]], edges: numpy.ndarray[numpy.int32[m, n]], eai: int) -> tsl::robin_set<int, absl::lts_20230125::hash_internal::Hash<int>, std::equal_to<int>, std::allocator<int>, false, tsl::rh::power_of_two_growth_policy<2ul> >

queryEdgeForPE(self, e0: numpy.ndarray[numpy.float64[m, 1]], e1: numpy.ndarray[numpy.float64[m, 1]], radius: float = 0) → tuple[list[int], list[int]]¶

queryEdgeForTriangles(*args, **kwargs)¶

Overloaded function.

queryEdgeForTriangles(self: ipctk.SpatialHash, e0: numpy.ndarray[numpy.float64[m, 1]], e1: numpy.ndarray[numpy.float64[m, 1]], radius: float = 0) -> tsl::robin_set<int, absl::lts_20230125::hash_internal::Hash<int>, std::equal_to<int>, std::allocator<int>, false, tsl::rh::power_of_two_growth_policy<2ul> >
queryEdgeForTriangles(self: ipctk.SpatialHash, ei: int) -> tsl::robin_set<int, absl::lts_20230125::hash_internal::Hash<int>, std::equal_to<int>, std::allocator<int>, false, tsl::rh::power_of_two_growth_policy<2ul> >

queryPointForEdges(self, vi: int) → tsl::robin_set<int, absl::lts_20230125::hash_internal::Hash<int>, std::equal_to<int>, std::allocator<int>, false, tsl::rh::power_of_two_growth_policy<2ul> >¶

queryPointForPrimitives(*args, **kwargs)¶

Overloaded function.

queryPointForPrimitives(self: ipctk.SpatialHash, p_t0: numpy.ndarray[numpy.float64[m, 1]], p_t1: numpy.ndarray[numpy.float64[m, 1]], radius: float = 0) -> Tuple[tsl::robin_set<int, absl::lts_20230125::hash_internal::Hash<int>, std::equal_to<int>, std::allocator<int>, false, tsl::rh::power_of_two_growth_policy<2ul> >, tsl::robin_set<int, absl::lts_20230125::hash_internal::Hash<int>, std::equal_to<int>, std::allocator<int>, false, tsl::rh::power_of_two_growth_policy<2ul> >, tsl::robin_set<int, absl::lts_20230125::hash_internal::Hash<int>, std::equal_to<int>, std::allocator<int>, false, tsl::rh::power_of_two_growth_policy<2ul> >]
queryPointForPrimitives(self: ipctk.SpatialHash, vi: int) -> Tuple[tsl::robin_set<int, absl::lts_20230125::hash_internal::Hash<int>, std::equal_to<int>, std::allocator<int>, false, tsl::rh::power_of_two_growth_policy<2ul> >, tsl::robin_set<int, absl::lts_20230125::hash_internal::Hash<int>, std::equal_to<int>, std::allocator<int>, false, tsl::rh::power_of_two_growth_policy<2ul> >, tsl::robin_set<int, absl::lts_20230125::hash_internal::Hash<int>, std::equal_to<int>, std::allocator<int>, false, tsl::rh::power_of_two_growth_policy<2ul> >]

queryPointForTriangles(*args, **kwargs)¶

Overloaded function.

queryPointForTriangles(self: ipctk.SpatialHash, p: numpy.ndarray[numpy.float64[m, 1]], radius: float = 0) -> tsl::robin_set<int, absl::lts_20230125::hash_internal::Hash<int>, std::equal_to<int>, std::allocator<int>, false, tsl::rh::power_of_two_growth_policy<2ul> >
queryPointForTriangles(self: ipctk.SpatialHash, p_t0: numpy.ndarray[numpy.float64[m, 1]], p_t1: numpy.ndarray[numpy.float64[m, 1]], radius: float = 0) -> tsl::robin_set<int, absl::lts_20230125::hash_internal::Hash<int>, std::equal_to<int>, std::allocator<int>, false, tsl::rh::power_of_two_growth_policy<2ul> >
queryPointForTriangles(self: ipctk.SpatialHash, vi: int) -> tsl::robin_set<int, absl::lts_20230125::hash_internal::Hash<int>, std::equal_to<int>, std::allocator<int>, false, tsl::rh::power_of_two_growth_policy<2ul> >

queryTriangleForEdges(self, t0: numpy.ndarray[numpy.float64[m, 1]], t1: numpy.ndarray[numpy.float64[m, 1]], t2: numpy.ndarray[numpy.float64[m, 1]], radius: float = 0) → tsl::robin_set<int, absl::lts_20230125::hash_internal::Hash<int>, std::equal_to<int>, std::allocator<int>, false, tsl::rh::power_of_two_growth_policy<2ul> >¶

queryTriangleForPoints(*args, **kwargs)¶

Overloaded function.

queryTriangleForPoints(self: ipctk.SpatialHash, t0: numpy.ndarray[numpy.float64[m, 1]], t1: numpy.ndarray[numpy.float64[m, 1]], t2: numpy.ndarray[numpy.float64[m, 1]], radius: float = 0) -> tsl::robin_set<int, absl::lts_20230125::hash_internal::Hash<int>, std::equal_to<int>, std::allocator<int>, false, tsl::rh::power_of_two_growth_policy<2ul> >
queryTriangleForPoints(self: ipctk.SpatialHash, t0_t0: numpy.ndarray[numpy.float64[m, 1]], t1_t0: numpy.ndarray[numpy.float64[m, 1]], t2_t0: numpy.ndarray[numpy.float64[m, 1]], t0_t1: numpy.ndarray[numpy.float64[m, 1]], t1_t1: numpy.ndarray[numpy.float64[m, 1]], t2_t1: numpy.ndarray[numpy.float64[m, 1]], radius: float = 0) -> tsl::robin_set<int, absl::lts_20230125::hash_internal::Hash<int>, std::equal_to<int>, std::allocator<int>, false, tsl::rh::power_of_two_growth_policy<2ul> >

property rightTopCorner : numpy.ndarray[numpy.float64[m, 1]]¶

property triStartInd : int¶

property voxel : tsl::robin_map<int, std::vector<int, std::allocator<int> >, absl::lts_20230125::hash_internal::Hash<int>, std::equal_to<int>, std::allocator<std::pair<int, std::vector<int, std::allocator<int> > > >, false, tsl::rh::power_of_two_growth_policy<2ul> >¶

property voxelCount : numpy.ndarray[numpy.int32[m, 1]]¶

property voxelCount0x1 : int¶

Sweep and Tiniest Queue¶

class ipctk.SweepAndTiniestQueue¶

Bases: CopyMeshBroadPhase

Public Data Attributes:

Inherited from BroadPhase

`can_vertices_collide`	Function for determining if two vertices can collide.

Public Methods:

`__init__`(self)
`build`(args, *kwargs)	Overloaded function.
`clear`(self)	Clear any built data.
`detect_edge_vertex_candidates`(self)	Find the candidate edge-vertex collisisons.
`detect_edge_edge_candidates`(self)	Find the candidate edge-edge collisions.
`detect_face_vertex_candidates`(self)	Find the candidate face-vertex collisions.
`detect_edge_face_candidates`(self)	Find the candidate edge-face intersections.

Inherited from CopyMeshBroadPhase

`__init__`(args, *kwargs)

Inherited from BroadPhase

`__init__`(args, *kwargs)
`make_broad_phase`(broad_phase_method)	Construct a registered broad phase object.
`build`(args, *kwargs)	Overloaded function.
`clear`(self)	Clear any built data.
`detect_edge_vertex_candidates`(self)	Find the candidate edge-vertex collisisons.
`detect_edge_edge_candidates`(self)	Find the candidate edge-edge collisions.
`detect_face_vertex_candidates`(self)	Find the candidate face-vertex collisions.
`detect_edge_face_candidates`(self)	Find the candidate edge-face intersections.
`detect_collision_candidates`(self, dim)	Detect all collision candidates needed for a given dimensional simulation.

Inherited from pybind11_object

__annotations__ = {}¶

__init__(self)¶

__module__ = 'ipctk'¶

build(*args, **kwargs)¶

Overloaded function.

build(self: ipctk.SweepAndTiniestQueue, vertices: numpy.ndarray[numpy.float64[m, n]], edges: numpy.ndarray[numpy.int32[m, n]], faces: numpy.ndarray[numpy.int32[m, n]], inflation_radius: float = 0) -> None

Build the broad phase for static collision detection.

Parameters:
vertices: Vertex positions edges: Collision mesh edges faces: Collision mesh faces inflation_radius: Radius of inflation around all elements.
build(self: ipctk.SweepAndTiniestQueue, vertices_t0: numpy.ndarray[numpy.float64[m, n]], vertices_t1: numpy.ndarray[numpy.float64[m, n]], edges: numpy.ndarray[numpy.int32[m, n]], faces: numpy.ndarray[numpy.int32[m, n]], inflation_radius: float = 0) -> None

Build the broad phase for continuous collision detection.

Parameters:
vertices_t0: Starting vertex positions vertices_t1: Ending vertex positions edges: Collision mesh edges faces: Collision mesh faces inflation_radius: Radius of inflation around all elements.

clear(self) → None¶: Clear any built data.

detect_edge_edge_candidates(self) → list[ipc::EdgeEdgeCandidate]¶

Find the candidate edge-edge collisions.

Returns:¶: The candidate edge-edge collisisons.

detect_edge_face_candidates(self) → list[ipc::EdgeFaceCandidate]¶

Find the candidate edge-face intersections.

Returns:¶: The candidate edge-face intersections.

detect_edge_vertex_candidates(self) → list[ipc::EdgeVertexCandidate]¶

Find the candidate edge-vertex collisisons.

Returns:¶: The candidate edge-vertex collisisons.

detect_face_vertex_candidates(self) → list[ipc::FaceVertexCandidate]¶

Find the candidate face-vertex collisions.

Returns:¶: The candidate face-vertex collisisons.

AABB¶

class ipctk.AABB¶

Bases: pybind11_object

Public Data Attributes:

`min`	Minimum corner of the AABB.
`max`	Maximum corner of the AABB.
`vertex_ids`	Vertex IDs attached to the AABB.

Public Methods:

`__init__`(args, *kwargs)	Overloaded function.
`from_point`(args, *kwargs)	Overloaded function.
`intersects`(self, other)	Check if another AABB intersects with this one.
`conservative_inflation`(min, max, ...)	Compute a conservative inflation of the AABB.

Inherited from pybind11_object

__annotations__ = {}¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: ipctk.AABB) -> None
__init__(self: ipctk.AABB, min: numpy.ndarray[numpy.float64[m, 1]], max: numpy.ndarray[numpy.float64[m, 1]]) -> None
__init__(self: ipctk.AABB, aabb1: ipctk.AABB, aabb2: ipctk.AABB) -> None
__init__(self: ipctk.AABB, aabb1: ipctk.AABB, aabb2: ipctk.AABB, aabb3: ipctk.AABB) -> None

__module__ = 'ipctk'¶

static conservative_inflation(min: numpy.ndarray[numpy.float64[m, 1]], max: numpy.ndarray[numpy.float64[m, 1]], inflation_radius: float) → tuple[numpy.ndarray[numpy.float64[m, 1]], numpy.ndarray[numpy.float64[m, 1]]]¶: Compute a conservative inflation of the AABB.

static from_point(*args, **kwargs)¶

Overloaded function.

from_point(p: numpy.ndarray[numpy.float64[m, 1]], inflation_radius: float = 0) -> ipctk.AABB

Compute a AABB for a static point.

Parameters:
p: The point’s position. inflation_radius: Radius of a sphere around the point which the AABB encloses.

Returns:
The constructed AABB.
from_point(p_t0: numpy.ndarray[numpy.float64[m, 1]], p_t1: numpy.ndarray[numpy.float64[m, 1]], inflation_radius: float = 0) -> ipctk.AABB

Compute a AABB for a moving point (i.e. temporal edge).

Parameters:
p_t0: The point’s position at time t=0. p_t1: The point’s position at time t=1. inflation_radius: Radius of a capsule around the temporal edge which the AABB encloses.

Returns:
The constructed AABB.

intersects(self, other: ipctk.AABB) → bool¶

Check if another AABB intersects with this one.

Parameters:¶

other: ipctk.AABB¶: The other AABB.

Returns:¶

If the two AABBs intersect.

property max : numpy.ndarray[numpy.float64[m, 1]]¶: Maximum corner of the AABB.

property min : numpy.ndarray[numpy.float64[m, 1]]¶: Minimum corner of the AABB.

property vertex_ids : list[int[3]]¶: Vertex IDs attached to the AABB.