Download scripts/genesis_patch.py from yianW/goal_gen_cases: direct link, hf CLI and curl.
- Browser
- Download file 4.39 kB
-
https://huggingface.co/datasets/yianW/goal_gen_cases/resolve/main/scripts/genesis_patch.py
- Command line
-
hf download hf://datasets/yianW/goal_gen_cases/scripts/genesis_patch.py
-
curl -L -o genesis_patch.py https://huggingface.co/datasets/yianW/goal_gen_cases/resolve/main/scripts/genesis_patch.py
4.39 kB
| """ | |
| Runtime monkey-patch that adds `RigidEntity.detect_collision_parallel` and | |
| `RigidLink.detect_collision` to upstream Genesis. | |
| The methods are pure-Python — they only read fields already exposed by the | |
| upstream `RigidEntity` / `RigidLink` / collider state — so we can attach them | |
| at runtime instead of forking Genesis. | |
| IMPORTANT: `apply()` must be called AFTER `gs.init()`. Importing | |
| `genesis.engine.entities.rigid_entity.rigid_entity` before `gs.init()` raises | |
| `Genesis hasn't been initialized.` from `genesis.utils.array_class`, so all | |
| genesis-internal imports are deferred until inside `apply()`. | |
| Usage: | |
| import genesis as gs | |
| import genesis_patch | |
| gs.init(...) | |
| genesis_patch.apply() | |
| # now RigidEntity.detect_collision_parallel is available | |
| """ | |
| import numpy as np | |
| _APPLIED = False | |
| def apply(): | |
| """Install detect_collision_parallel / detect_collision on Genesis classes. | |
| Idempotent. Must be called after `gs.init()`. | |
| """ | |
| global _APPLIED | |
| if _APPLIED: | |
| return | |
| import genesis as gs | |
| from genesis.engine.entities.rigid_entity.rigid_entity import RigidEntity | |
| from genesis.engine.entities.rigid_entity.rigid_link import RigidLink | |
| def detect_collision_parallel( | |
| self, | |
| with_entity=None, | |
| exclude_self_contact=False, | |
| envs_idx=None, | |
| *, | |
| unsafe=False, | |
| ): | |
| """GPU-parallel collision query against the current contact buffers. | |
| Parameters | |
| ---------- | |
| with_entity : Entity, optional | |
| If given, only count contacts between `self` and this entity. | |
| exclude_self_contact : bool | |
| Ignore self-self contacts (only when `with_entity is None`). | |
| envs_idx : list[int], optional | |
| Indices of environments to report. Defaults to all envs. | |
| unsafe : bool | |
| If False (default), re-runs collision detection. Set True when | |
| buffers are already current. | |
| Returns | |
| ------- | |
| numpy.ndarray | |
| bool array, one entry per requested env. | |
| """ | |
| if not unsafe: | |
| self.solver.collider.clear() | |
| self.solver.collider.detection() | |
| n_collision = self.solver.collider._collider_state.n_contacts.to_numpy() | |
| geom_A = self.solver.collider._collider_state.contact_data.geom_a.to_numpy() | |
| geom_B = self.solver.collider._collider_state.contact_data.geom_b.to_numpy() | |
| n_collision = np.asarray(n_collision).reshape(-1) # [B] | |
| geom_A = np.asarray(geom_A) # [max_contacts, B] | |
| geom_B = np.asarray(geom_B) # [max_contacts, B] | |
| max_contacts, B = geom_A.shape | |
| if envs_idx is None: | |
| envs_idx = np.arange(B, dtype=int) | |
| else: | |
| envs_idx = np.asarray(envs_idx, dtype=int) | |
| valid_rows = (np.arange(max_contacts)[:, None] < n_collision[None, :]) | |
| selfA = (geom_A >= self.geom_start) & (geom_A < self.geom_end) | |
| selfB = (geom_B >= self.geom_start) & (geom_B < self.geom_end) | |
| if with_entity is not None: | |
| otherA = (geom_A >= with_entity.geom_start) & (geom_A < with_entity.geom_end) | |
| otherB = (geom_B >= with_entity.geom_start) & (geom_B < with_entity.geom_end) | |
| hits = ((selfA & otherB) | (selfB & otherA)) & valid_rows | |
| else: | |
| hits = (selfA | selfB) & valid_rows | |
| if exclude_self_contact: | |
| hits &= ~(selfA & selfB) | |
| collided = np.any(hits, axis=0) # [B] | |
| return collided[envs_idx] | |
| def link_detect_collision(self, env_idx=0): | |
| """Single-env collision query for one rigid link. Re-detects in real | |
| time (does not rely on `scene.step()`).""" | |
| all_collision_pairs = self._solver.detect_collision(env_idx) | |
| collision_pairs = all_collision_pairs[ | |
| np.logical_and( | |
| all_collision_pairs >= self.geom_start, | |
| all_collision_pairs < self.geom_end, | |
| ).any(axis=1) | |
| ] | |
| return collision_pairs | |
| if not hasattr(RigidEntity, "detect_collision_parallel"): | |
| RigidEntity.detect_collision_parallel = detect_collision_parallel | |
| if not hasattr(RigidLink, "detect_collision"): | |
| RigidLink.detect_collision = link_detect_collision | |
| _APPLIED = True | |