Continuous Collision Detection¶
- ipctk.is_step_collision_free(mesh: ipctk.CollisionMesh, vertices_t0: numpy.ndarray[numpy.float64[m, n]], vertices_t1: numpy.ndarray[numpy.float64[m, n]], min_distance: float = 0.0, broad_phase_method: ipctk.BroadPhaseMethod = <BroadPhaseMethod.HASH_GRID: 1>, narrow_phase_ccd: ipctk.NarrowPhaseCCD = <ipctk.TightInclusionCCD object at 0x7fd7e1f57a70>) bool ¶
Determine if the step is collision free.
Note
Assumes the trajectory is linear.
- Parameters:¶
- mesh
The collision mesh.
- vertices_t0
Surface vertex vertices at start as rows of a matrix.
- vertices_t1
Surface vertex vertices at end as rows of a matrix.
- min_distance
The minimum distance allowable between any two elements.
- broad_phase_method
The broad phase method to use.
- narrow_phase_ccd
The narrow phase CCD algorithm to use.
- Returns:¶
True if <b>any</b> collisions occur.
- ipctk.compute_collision_free_stepsize(mesh: ipctk.CollisionMesh, vertices_t0: numpy.ndarray[numpy.float64[m, n]], vertices_t1: numpy.ndarray[numpy.float64[m, n]], min_distance: float = 0.0, broad_phase_method: ipctk.BroadPhaseMethod = <BroadPhaseMethod.HASH_GRID: 1>, narrow_phase_ccd: ipctk.NarrowPhaseCCD = <ipctk.TightInclusionCCD object at 0x7fd7e1f57e70>) float ¶
Computes a maximal step size that is collision free.
Note
Assumes the trajectory is linear.
- Parameters:¶
- mesh
The collision mesh.
- vertices_t0
Vertex vertices at start as rows of a matrix. Assumes vertices_t0 is intersection free.
- vertices_t1
Surface vertex vertices at end as rows of a matrix.
- min_distance
The minimum distance allowable between any two elements.
- broad_phase_method
The broad phase method to use.
- narrow_phase_ccd
The narrow phase CCD algorithm to use.
- Returns:¶
A step-size \(\in [0, 1]\) that is collision free. A value of 1.0 if a full step and 0.0 is no step.
Narrow Phase CCD¶
- class ipctk.NarrowPhaseCCD¶
Bases:
pybind11_object
Public Methods:
__init__
(*args, **kwargs)point_point_ccd
(self, p0_t0, p1_t0, p0_t1, p1_t1)point_edge_ccd
(self, p_t0, e0_t0, e1_t0, ...)point_triangle_ccd
(self, p_t0, t0_t0, t1_t0, ...)edge_edge_ccd
(self, ea0_t0, ea1_t0, eb0_t0, ...)Inherited from
pybind11_object
-
__annotations__ =
{}
¶
- __init__(*args, **kwargs)¶
-
__module__ =
'ipctk'
¶
-
edge_edge_ccd(self, ea0_t0: numpy.ndarray[numpy.float64[3, 1]], ea1_t0: numpy.ndarray[numpy.float64[3, 1]], eb0_t0: numpy.ndarray[numpy.float64[3, 1]], eb1_t0: numpy.ndarray[numpy.float64[3, 1]], ea0_t1: numpy.ndarray[numpy.float64[3, 1]], ea1_t1: numpy.ndarray[numpy.float64[3, 1]], eb0_t1: numpy.ndarray[numpy.float64[3, 1]], eb1_t1: numpy.ndarray[numpy.float64[3, 1]], min_distance: float =
0.0
, tmax: float =1.0
) tuple[bool, float] ¶
-
point_edge_ccd(self, p_t0: numpy.ndarray[numpy.float64[m, 1]], e0_t0: numpy.ndarray[numpy.float64[m, 1]], e1_t0: numpy.ndarray[numpy.float64[m, 1]], p_t1: numpy.ndarray[numpy.float64[m, 1]], e0_t1: numpy.ndarray[numpy.float64[m, 1]], e1_t1: numpy.ndarray[numpy.float64[m, 1]], min_distance: float =
0.0
, tmax: float =1.0
) tuple[bool, float] ¶
-
point_point_ccd(self, p0_t0: numpy.ndarray[numpy.float64[m, 1]], p1_t0: numpy.ndarray[numpy.float64[m, 1]], p0_t1: numpy.ndarray[numpy.float64[m, 1]], p1_t1: numpy.ndarray[numpy.float64[m, 1]], min_distance: float =
0.0
, tmax: float =1.0
) tuple[bool, float] ¶
-
point_triangle_ccd(self, p_t0: numpy.ndarray[numpy.float64[3, 1]], t0_t0: numpy.ndarray[numpy.float64[3, 1]], t1_t0: numpy.ndarray[numpy.float64[3, 1]], t2_t0: numpy.ndarray[numpy.float64[3, 1]], p_t1: numpy.ndarray[numpy.float64[3, 1]], t0_t1: numpy.ndarray[numpy.float64[3, 1]], t1_t1: numpy.ndarray[numpy.float64[3, 1]], t2_t1: numpy.ndarray[numpy.float64[3, 1]], min_distance: float =
0.0
, tmax: float =1.0
) tuple[bool, float] ¶
-
__annotations__ =
Tight Inclusion CCD¶
- class ipctk.TightInclusionCCD¶
Bases:
NarrowPhaseCCD
Public Data Attributes:
Solver tolerance.
Maximum number of iterations.
Conservative rescaling of the time of impact.
Public Methods:
__init__
(self[, tolerance, max_iterations, ...])Construct a new AdditiveCCD object.
Inherited from
NarrowPhaseCCD
__init__
(*args, **kwargs)point_point_ccd
(self, p0_t0, p1_t0, p0_t1, p1_t1)point_edge_ccd
(self, p_t0, e0_t0, e1_t0, ...)point_triangle_ccd
(self, p_t0, t0_t0, t1_t0, ...)edge_edge_ccd
(self, ea0_t0, ea1_t0, eb0_t0, ...)Inherited from
pybind11_object
-
DEFAULT_CONSERVATIVE_RESCALING =
0.8
¶
-
DEFAULT_MAX_ITERATIONS =
10000000
¶
-
DEFAULT_TOLERANCE =
1e-06
¶
-
SMALL_TOI =
1e-06
¶
-
__annotations__ =
{}
¶
-
__init__(self, tolerance: float =
1e-06
, max_iterations: int =10000000
, conservative_rescaling: float =0.8
)¶ Construct a new AdditiveCCD object.
-
__module__ =
'ipctk'
¶
- property conservative_rescaling : float¶
Conservative rescaling of the time of impact.
- property max_iterations : int¶
Maximum number of iterations.
- property tolerance : float¶
Solver tolerance.
-
DEFAULT_CONSERVATIVE_RESCALING =
Additive CCD¶
- class ipctk.AdditiveCCD¶
Bases:
NarrowPhaseCCD
Public Data Attributes:
The conservative rescaling value used to avoid taking steps exactly to impact.
Public Methods:
__init__
(self[, max_iterations, ...])Construct a new AdditiveCCD object.
Inherited from
NarrowPhaseCCD
__init__
(*args, **kwargs)point_point_ccd
(self, p0_t0, p1_t0, p0_t1, p1_t1)point_edge_ccd
(self, p_t0, e0_t0, e1_t0, ...)point_triangle_ccd
(self, p_t0, t0_t0, t1_t0, ...)edge_edge_ccd
(self, ea0_t0, ea1_t0, eb0_t0, ...)Inherited from
pybind11_object
-
DEFAULT_CONSERVATIVE_RESCALING =
0.9
¶
-
__annotations__ =
{}
¶
-
__init__(self, max_iterations: float =
10000000
, conservative_rescaling: float =0.9
)¶ Construct a new AdditiveCCD object.
-
__module__ =
'ipctk'
¶
- property conservative_rescaling : float¶
The conservative rescaling value used to avoid taking steps exactly to impact.
-
DEFAULT_CONSERVATIVE_RESCALING =
Inexact CCD¶
Note
This method is disabled by default. To enable it, set the
IPC_TOOLKIT_WITH_INEXACT_CCD
CMake option to ON
.
- ipctk.inexact_point_edge_ccd_2D(p_t0: numpy.ndarray[numpy.float64[2, 1]], e0_t0: numpy.ndarray[numpy.float64[2, 1]], e1_t0: numpy.ndarray[numpy.float64[2, 1]], p_t1: numpy.ndarray[numpy.float64[2, 1]], e0_t1: numpy.ndarray[numpy.float64[2, 1]], e1_t1: numpy.ndarray[numpy.float64[2, 1]], conservative_rescaling: float) tuple[bool, float] ¶
Inexact continuous collision detection between a point and an edge in 2D.
- Parameters:¶
- p_t0: numpy.ndarray[numpy.float64[2, 1]]¶
Initial position of the point
- e0_t0: numpy.ndarray[numpy.float64[2, 1]]¶
Initial position of the first endpoint of the edge
- e1_t0: numpy.ndarray[numpy.float64[2, 1]]¶
Initial position of the second endpoint of the edge
- p_t1: numpy.ndarray[numpy.float64[2, 1]]¶
Final position of the point
- e0_t1: numpy.ndarray[numpy.float64[2, 1]]¶
Final position of the first endpoint of the edge
- e1_t1: numpy.ndarray[numpy.float64[2, 1]]¶
Final position of the second endpoint of the edge
- conservative_rescaling: float¶
Conservative rescaling of the time of impact
- Returns:¶
True if a collision was detected, false otherwise. Output time of impact
- Return type:¶
Tuple of
Nonlinear CCD¶
- class ipctk.NonlinearTrajectory¶
Bases:
pybind11_object
Public Methods:
__init__
(self)__call__
(self, t)Compute the point's position at time t
max_distance_from_linear
(self, t0, t1)Compute the maximum distance from the nonlinear trajectory to a linearized trajectory
Inherited from
pybind11_object
-
__annotations__ =
{}
¶
- __call__(self, t: float) numpy.ndarray[numpy.float64[m, 1]] ¶
Compute the point’s position at time t
- __init__(self)¶
-
__module__ =
'ipctk'
¶
-
__annotations__ =
- class ipctk.IntervalNonlinearTrajectory¶
Bases:
NonlinearTrajectory
Public Methods:
__init__
(self)__call__
(*args, **kwargs)Overloaded function.
max_distance_from_linear
(self, t0, t1)Compute the maximum distance from the nonlinear trajectory to a linearized trajectory
Inherited from
NonlinearTrajectory
__init__
(self)__call__
(self, t)Compute the point's position at time t
max_distance_from_linear
(self, t0, t1)Compute the maximum distance from the nonlinear trajectory to a linearized trajectory
Inherited from
pybind11_object
-
__annotations__ =
{}
¶
- __call__(*args, **kwargs)¶
Overloaded function.
__call__(self: ipctk.IntervalNonlinearTrajectory, t: float) -> numpy.ndarray[numpy.float64[m, 1]]
Compute the point’s position at time t
__call__(self: ipctk.IntervalNonlinearTrajectory, t: filib::Interval) -> numpy.ndarray[filib::Interval[m, 1]]
Compute the point’s position over a time interval t
- __init__(self)¶
-
__module__ =
'ipctk'
¶
- max_distance_from_linear(self, t0: float, t1: float) float ¶
Compute the maximum distance from the nonlinear trajectory to a linearized trajectory
Note
This uses interval arithmetic to compute the maximum distance. If you know a tighter bound on the maximum distance, it is recommended to override this function.
-
__annotations__ =
-
ipctk.point_point_nonlinear_ccd(p0: ipctk.NonlinearTrajectory, p1: ipctk.NonlinearTrajectory, tmax: float =
1.0
, min_distance: float =0
, tolerance: float =1e-06
, max_iterations: int =10000000
, conservative_rescaling: float =0.8
) tuple[bool, float] ¶ Perform nonlinear CCD between two points moving along nonlinear trajectories.
- Parameters:¶
- p0: ipctk.NonlinearTrajectory¶
First point’s trajectory
- p1: ipctk.NonlinearTrajectory¶
Second point’s trajectory
- tmax: float =
1.0
¶ Maximum time to check for collision
- min_distance: float =
0
¶ Minimum separation distance between the two points
- tolerance: float =
1e-06
¶ Tolerance for the linear CCD algorithm
- max_iterations: int =
10000000
¶ Maximum number of iterations for the linear CCD algorithm
- conservative_rescaling: float =
0.8
¶ Conservative rescaling of the time of impact
- Returns:¶
True if the two points collide, false otherwise. Output time of impact
- Return type:¶
Tuple of
-
ipctk.point_edge_nonlinear_ccd(p: ipctk.NonlinearTrajectory, e0: ipctk.NonlinearTrajectory, e1: ipctk.NonlinearTrajectory, tmax: float =
1.0
, min_distance: float =0
, tolerance: float =1e-06
, max_iterations: int =10000000
, conservative_rescaling: float =0.8
) tuple[bool, float] ¶ Perform nonlinear CCD between a point and a linear edge moving along nonlinear trajectories.
- Parameters:¶
- p: ipctk.NonlinearTrajectory¶
Point’s trajectory
- e0: ipctk.NonlinearTrajectory¶
Edge’s first endpoint’s trajectory
- e1: ipctk.NonlinearTrajectory¶
Edge’s second endpoint’s trajectory
- tmax: float =
1.0
¶ Maximum time to check for collision
- min_distance: float =
0
¶ Minimum separation distance between the point and the edge
- tolerance: float =
1e-06
¶ Tolerance for the linear CCD algorithm
- max_iterations: int =
10000000
¶ Maximum number of iterations for the linear CCD algorithm
- conservative_rescaling: float =
0.8
¶ Conservative rescaling of the time of impact
- Returns:¶
True if the point and edge collide, false otherwise. Output time of impact
- Return type:¶
Tuple of
-
ipctk.edge_edge_nonlinear_ccd(ea0: ipctk.NonlinearTrajectory, ea1: ipctk.NonlinearTrajectory, eb0: ipctk.NonlinearTrajectory, eb1: ipctk.NonlinearTrajectory, tmax: float =
1.0
, min_distance: float =0
, tolerance: float =1e-06
, max_iterations: int =10000000
, conservative_rescaling: float =0.8
) tuple[bool, float] ¶ Perform nonlinear CCD between two linear edges moving along nonlinear trajectories.
- Parameters:¶
- ea0: ipctk.NonlinearTrajectory¶
First edge’s first endpoint’s trajectory
- ea1: ipctk.NonlinearTrajectory¶
First edge’s second endpoint’s trajectory
- eb0: ipctk.NonlinearTrajectory¶
Second edge’s first endpoint’s trajectory
- eb1: ipctk.NonlinearTrajectory¶
Second edge’s second endpoint’s trajectory
- tmax: float =
1.0
¶ Maximum time to check for collision
- min_distance: float =
0
¶ Minimum separation distance between the two edges
- tolerance: float =
1e-06
¶ Tolerance for the linear CCD algorithm
- max_iterations: int =
10000000
¶ Maximum number of iterations for the linear CCD algorithm
- conservative_rescaling: float =
0.8
¶ Conservative rescaling of the time of impact
- Returns:¶
True if the two edges collide, false otherwise. Output time of impact
- Return type:¶
Tuple of
-
ipctk.point_triangle_nonlinear_ccd(p: ipctk.NonlinearTrajectory, t0: ipctk.NonlinearTrajectory, t1: ipctk.NonlinearTrajectory, t2: ipctk.NonlinearTrajectory, tmax: float =
1.0
, min_distance: float =0
, tolerance: float =1e-06
, max_iterations: int =10000000
, conservative_rescaling: float =0.8
) tuple[bool, float] ¶ Perform nonlinear CCD between a point and a linear triangle moving along nonlinear trajectories.
- Parameters:¶
- p: ipctk.NonlinearTrajectory¶
Point’s trajectory
- t0: ipctk.NonlinearTrajectory¶
Triangle’s first vertex’s trajectory
- t1: ipctk.NonlinearTrajectory¶
Triangle’s second vertex’s trajectory
- t2: ipctk.NonlinearTrajectory¶
Triangle’s third vertex’s trajectory
- tmax: float =
1.0
¶ Maximum time to check for collision
- min_distance: float =
0
¶ Minimum separation distance between the two edges
- tolerance: float =
1e-06
¶ Tolerance for the linear CCD algorithm
- max_iterations: int =
10000000
¶ Maximum number of iterations for the linear CCD algorithm
- conservative_rescaling: float =
0.8
¶ Conservative rescaling of the time of impact
- Returns:¶
True if the point and triangle collide, false otherwise. Output time of impact
- Return type:¶
Tuple of
Miscellaneous¶
-
ipctk.point_static_plane_ccd(p_t0: numpy.ndarray[numpy.float64[m, 1]], p_t1: numpy.ndarray[numpy.float64[m, 1]], plane_origin: numpy.ndarray[numpy.float64[m, 1]], plane_normal: numpy.ndarray[numpy.float64[m, 1]], conservative_rescaling: float =
0.8
) tuple[bool, float] ¶ Compute the time of impact between a point and a static plane in 3D using continuous collision detection.
- Parameters:¶
- p_t0: numpy.ndarray[numpy.float64[m, 1]]¶
The initial position of the point.
- p_t1: numpy.ndarray[numpy.float64[m, 1]]¶
The final position of the point.
- plane_origin: numpy.ndarray[numpy.float64[m, 1]]¶
The origin of the plane.
- plane_normal: numpy.ndarray[numpy.float64[m, 1]]¶
The normal of the plane.
- conservative_rescaling: float =
0.8
¶ Conservative rescaling of the time of impact.
- Returns:¶
True if a collision was detected, false otherwise. Output time of impact
- Return type:¶
Tuple of