repo stringclasses 454
values | file_path stringlengths 5 201 | extension stringclasses 1
value | content stringlengths 8 509k | num_lines int64 3 16.9k | size_bytes int64 8 511k |
|---|---|---|---|---|---|
genesis-world | genesis/engine/entities/rigid_entity/rigid_geom.py | .py | import os
import pickle as pkl
from typing import TYPE_CHECKING
import igl
import numpy as np
import skimage
import torch
import trimesh
import genesis as gs
import genesis.utils.geom as gu
import genesis.utils.mesh as mu
from genesis.repr_base import RBC
from genesis.utils.misc import tensor_to_array, qd_to_torch, D... | 1,171 | 41,001 |
genesis-world | genesis/engine/entities/rigid_entity/rigid_equality.py | .py | import genesis as gs
from genesis.repr_base import RBC
class RigidEquality(RBC):
"""
Equality class for rigid body entities.
"""
def __init__(
self,
entity,
name,
idx,
type,
eq_obj1id,
eq_obj2id,
eq_data,
sol_params,
):
... | 139 | 3,582 |
genesis-world | genesis/engine/couplers/sap_coupler.py | .py | from typing import TYPE_CHECKING
import math
import igl
import numpy as np
import quadrants as qd
import genesis as gs
import genesis.utils.element as eu
import genesis.utils.array_class as array_class
import genesis.utils.geom as gu
from genesis.constants import IntEnum
from genesis.engine.bvh import AABB, LBVH, FEM... | 3,925 | 179,350 |
genesis-world | genesis/engine/couplers/legacy_coupler.py | .py | from typing import TYPE_CHECKING
import numpy as np
import quadrants as qd
import genesis as gs
import genesis.utils.sdf as sdf
from genesis.options.solvers import LegacyCouplerOptions
from genesis.repr_base import RBC
from genesis.utils import array_class
from genesis.utils.array_class import LinksState
from genesi... | 968 | 46,462 |
genesis-world | genesis/engine/couplers/ipc_coupler/utils.py | .py | """
Utility functions for IPC coupler.
Stateless helper functions extracted from IPCCoupler for clarity.
"""
from typing import TYPE_CHECKING
import numba as nb
import numpy as np
import genesis as gs
import genesis.utils.geom as gu
from uipc.core import Scene
if TYPE_CHECKING:
from genesis.engine.entities im... | 243 | 8,409 |
genesis-world | genesis/engine/couplers/ipc_coupler/coupler.py | .py | import logging
import os
import sys
import tempfile
import weakref
from functools import partial
from typing import TYPE_CHECKING, cast
import numpy as np
import genesis as gs
import genesis.utils.geom as gu
from genesis.engine.entities.rigid_entity.rigid_link import RHO_MUJOCO, RHO_OBJECT, RHO_ROBOT
from genesis.eng... | 1,146 | 55,423 |
genesis-world | genesis/engine/couplers/ipc_coupler/__init__.py | .py | from .coupler import IPCCoupler
__all__ = ["IPCCoupler"]
| 4 | 58 |
genesis-world | genesis/engine/couplers/ipc_coupler/data.py | .py | """
Data classes for IPC coupler.
"""
from enum import IntEnum
from dataclasses import dataclass
from typing import NamedTuple, TYPE_CHECKING
import numpy as np
from uipc.geometry import GeometrySlot
import genesis as gs
if TYPE_CHECKING:
from genesis.engine.entities.rigid_entity import RigidLink
class COUPL... | 79 | 2,394 |
genesis-world | genesis/engine/solvers/base_solver.py | .py | import dataclasses
import enum
import functools
import inspect
from typing import TYPE_CHECKING, Any, Callable
import quadrants as qd
import numpy as np
import torch
import genesis as gs
import genesis.utils.array_class as array_class
from genesis.utils.misc import qd_to_torch, sanitize_index, tensor_to_array
from ge... | 379 | 17,018 |
genesis-world | genesis/engine/solvers/sf_solver.py | .py | import quadrants as qd
import genesis as gs
from .base_solver import Solver
@qd.data_oriented
class SFSolver(Solver):
"""
Stable Fluid solver for eulerian-based gaseous simulation.
"""
# ------------------------------------------------------------------------------------
# ---------------------... | 311 | 10,744 |
genesis-world | genesis/engine/solvers/pbd_solver.py | .py | import math
from typing import TYPE_CHECKING
import numpy as np
import quadrants as qd
import genesis as gs
import genesis.utils.geom as gu
from genesis.engine.boundaries import CubeBoundary
from genesis.engine.entities import (
PBD2DEntity,
PBD3DEntity,
PBDFreeParticleEntity,
PBDParticleEntity,
)
fro... | 1,091 | 46,874 |
genesis-world | genesis/engine/solvers/sph_solver.py | .py | from typing import TYPE_CHECKING
import numpy as np
import quadrants as qd
import genesis as gs
import genesis.utils.geom as gu
from genesis.engine.boundaries import CubeBoundary
from genesis.engine.entities import SPHEntity
from genesis.engine.states.solvers import SPHSolverState
from .base_solver import Solver
if... | 994 | 39,978 |
genesis-world | genesis/engine/solvers/kinematic_solver.py | .py | from typing import TYPE_CHECKING, Literal
import numpy as np
import torch
import genesis as gs
import genesis.utils.array_class as array_class
import genesis.utils.geom as gu
from genesis.engine.entities.rigid_entity import KinematicEntity
from genesis.engine.solvers.rigid.abd.inverse_kinematics import (
kernel_f... | 1,535 | 72,349 |
genesis-world | genesis/engine/solvers/tool_solver.py | .py | from typing import TYPE_CHECKING
import quadrants as qd
from genesis.engine.boundaries import FloorBoundary
from genesis.engine.states.solvers import ToolSolverState
from genesis.engine.entities.tool_entity.tool_entity import ToolEntity
from genesis.utils.misc import *
from .base_solver import Solver
if TYPE_CHECKI... | 130 | 4,055 |
genesis-world | genesis/engine/solvers/mpm_solver.py | .py | from typing import TYPE_CHECKING
import numpy as np
import quadrants as qd
import torch
import genesis as gs
import genesis.utils.array_class as array_class
import genesis.utils.geom as gu
import genesis.utils.sdf as sdf
from genesis.engine.boundaries import CubeBoundary
from genesis.engine.entities import MPMEntity
... | 1,350 | 61,892 |
genesis-world | genesis/engine/solvers/fem_solver.py | .py | # pylint: disable=no-value-for-parameter
from typing import TYPE_CHECKING
import numpy as np
import igl
import quadrants as qd
import torch
import genesis as gs
import genesis.utils.array_class as array_class
from genesis.engine.boundaries import FloorBoundary
from genesis.engine.entities.fem_entity import FEMEntity... | 1,595 | 66,512 |
genesis-world | genesis/engine/solvers/rigid/rigid_solver.py | .py | import math
import os
import sys
from typing import TYPE_CHECKING, Literal
import quadrants as qd
import numpy as np
import torch
import genesis as gs
import genesis.utils.array_class as array_class
import genesis.utils.geom as gu
from genesis.engine.entities import DroneEntity, RigidEntity
from genesis.engine.entiti... | 3,506 | 188,945 |
genesis-world | genesis/engine/solvers/rigid/collider/multi_contact.py | .py | """
Multi-contact detection for collision handling.
This module contains the multi-contact detection algorithm based on
Sutherland-Hodgman polygon clipping for finding multiple contact points
between colliding geometric entities (face-face, edge-face pairs).
"""
import quadrants as qd
import genesis as gs
import gen... | 1,140 | 42,598 |
genesis-world | genesis/engine/solvers/rigid/collider/epa.py | .py | """
Expanding Polytope Algorithm (EPA) for penetration depth computation.
This module contains the EPA algorithm implementation for computing exact
penetration depth and contact normals for intersecting convex objects.
Includes both standard and numerically robust ("safe") variants.
"""
import quadrants as qd
import... | 1,353 | 50,408 |
genesis-world | genesis/engine/solvers/rigid/collider/utils.py | .py | import quadrants as qd
import genesis as gs
import genesis.utils.array_class as array_class
from genesis.constants import GEOM_TYPE
@qd.func
def func_closest_points_on_segments(seg_a_p1, seg_a_p2, seg_b_p1, seg_b_p2, EPS):
"""
Compute closest points on two line segments using analytical solution.
Refere... | 114 | 3,561 |
genesis-world | genesis/engine/solvers/rigid/collider/box_contact.py | .py | """
Box collision contact detection functions.
This module contains specialized contact detection algorithms for box geometries:
- Plane-box contact detection
- Sphere-box contact detection
- Box-box contact detection (MuJoCo algorithm)
"""
import quadrants as qd
import genesis as gs
import genesis.utils.geom as gu
... | 877 | 35,060 |
genesis-world | genesis/engine/solvers/rigid/collider/gjk_support.py | .py | """
Support function utilities for GJK algorithm.
This module contains support point computation functions used by both GJK and EPA algorithms.
"""
import quadrants as qd
import genesis as gs
import genesis.utils.geom as gu
import genesis.utils.array_class as array_class
from . import support_field
@qd.func
def su... | 190 | 5,719 |
genesis-world | genesis/engine/solvers/rigid/collider/mpr.py | .py | import quadrants as qd
import genesis as gs
import genesis.utils.geom as gu
import genesis.utils.array_class as array_class
from . import support_field
from .constants import PORTAL_STATUS
from .contact import func_compute_geom_pair_scale
class MPR:
def __init__(self, rigid_solver):
self._solver = rigid_... | 960 | 37,383 |
genesis-world | genesis/engine/solvers/rigid/collider/diff_gjk.py | .py | import quadrants as qd
import genesis as gs
import genesis.utils.geom as gu
import genesis.utils.array_class as array_class
from . import gjk as GJK, contact, epa
@qd.func
def func_gjk_contact(
i_ga,
i_gb,
i_b,
ga_pos: qd.types.vector(3),
ga_quat: qd.types.vector(4),
gb_pos: qd.types.vector(3)... | 980 | 39,381 |
genesis-world | genesis/engine/solvers/rigid/collider/__init__.py | .py | """
Collider submodule for collision detection.
Contains broad-phase, narrow-phase, contact management, and geometric algorithms.
Modules:
- collider: Main Collider class
- broadphase: AABB and sweep-and-prune algorithms
- narrowphase: SDF, convex-convex, terrain collision
- box_contact: Specialized box collision (pl... | 25 | 798 |
genesis-world | genesis/engine/solvers/rigid/collider/capsule_contact.py | .py | import quadrants as qd
import genesis as gs
import genesis.utils.geom as gu
from . import utils
import genesis.utils.array_class as array_class
@qd.func
def func_capsule_capsule_contact(
i_ga, i_gb, ga_pos, ga_quat, gb_pos, gb_quat, dyn_info: array_class.DynInfo, rigid_info: array_class.RigidInfo
):
"""
... | 218 | 8,126 |
genesis-world | genesis/engine/solvers/rigid/collider/contact.py | .py | """
Contact management and utility functions for the rigid body collider.
This module contains functions for adding contacts, computing tolerances,
and managing contact data including reset/clear operations.
"""
import quadrants as qd
import genesis as gs
import genesis.utils.array_class as array_class
import genesi... | 1,465 | 84,450 |
genesis-world | genesis/engine/solvers/rigid/collider/constants.py | .py | """
Constants and enums for the collider module.
"""
from enum import IntEnum
class CCD_ALGORITHM_CODE(IntEnum):
"""Convex collision detection algorithm codes."""
# Our MPR (with SDF)
MPR = 0
# MuJoCo MPR
MJ_MPR = 1
# Our GJK
GJK = 2
# MuJoCo GJK
MJ_GJK = 3
class RETURN_CODE(In... | 78 | 2,119 |
genesis-world | genesis/engine/solvers/rigid/collider/broadphase.py | .py | """
Broad-phase collision detection functions.
This module contains AABB operations, sweep-and-prune algorithms,
and collision pair validation for the rigid body collider.
"""
import quadrants as qd
import genesis as gs
import genesis.utils.array_class as array_class
from .utils import func_is_geom_aabbs_overlap
... | 454 | 23,777 |
genesis-world | genesis/engine/solvers/rigid/collider/support_field.py | .py | import math
from typing import TYPE_CHECKING
import numpy as np
import quadrants as qd
import genesis as gs
import genesis.utils.array_class as array_class
import genesis.utils.geom as gu
if TYPE_CHECKING:
from genesis.engine.solvers.rigid.rigid_solver import RigidSolver
class SupportField:
def __init__(... | 462 | 18,009 |
genesis-world | genesis/engine/solvers/rigid/collider/gjk.py | .py | import math
import quadrants as qd
import genesis as gs
import genesis.utils.geom as gu
import genesis.utils.array_class as array_class
from .constants import RETURN_CODE, GJK_RETURN_CODE, EPA_POLY_INIT_RETURN_CODE
from .gjk_utils import (
func_ray_triangle_intersection,
func_triangle_affine_coords,
func_... | 1,796 | 71,429 |
genesis-world | genesis/engine/solvers/rigid/collider/gjk_utils.py | .py | """
Utility functions for GJK/EPA algorithms.
This module contains shared utility functions used by both GJK and EPA algorithms.
"""
import quadrants as qd
import genesis as gs
import genesis.utils.array_class as array_class
from .constants import RETURN_CODE
from .utils import func_det3
@qd.func
def func_ray_tria... | 211 | 6,767 |
genesis-world | genesis/engine/solvers/rigid/collider/narrowphase.py | .py | """
Narrow-phase collision detection functions.
This module contains SDF-based contact detection, convex-convex contact,
terrain detection, box-box contact, and multi-contact search algorithms.
"""
import quadrants as qd
import genesis as gs
import genesis.utils.array_class as array_class
import genesis.utils.geom a... | 3,511 | 189,217 |
genesis-world | genesis/engine/solvers/rigid/collider/collider.py | .py | """
Collider module for rigid body collision detection.
This module provides collision detection functionality for the rigid body solver,
including broad-phase (sweep-and-prune), narrow-phase (convex-convex, SDF-based,
terrain), and contact management.
"""
import math
from typing import TYPE_CHECKING
import numpy as... | 1,149 | 61,562 |
genesis-world | genesis/engine/solvers/rigid/constraint/noslip.py | .py | import quadrants as qd
import genesis as gs
import genesis.utils.array_class as array_class
@qd.func
def func_solve_mass_block(i_d0, i_b, vec: qd.Tensor, rigid_info: array_class.RigidInfo):
"""LDL^T forward-backward substitution on vec, restricted to the mass block containing dof i_d0.
The factor is block-d... | 497 | 24,077 |
genesis-world | genesis/engine/solvers/rigid/constraint/__init__.py | .py | """
Constraint solver submodule for rigid body simulation.
Contains constraint solving, island detection, and backward pass.
"""
from .solver import ConstraintSolver
# first declare func_solve_body:
from . import solver
# now register decomposed with func_solve_body:
from . import solver_breakdown
| 14 | 303 |
genesis-world | genesis/engine/solvers/rigid/constraint/solver_breakdown.py | .py | import sys
import numpy as np
import quadrants as qd
import genesis as gs
import genesis.utils.array_class as array_class
from . import solver
# Shared-memory reduction block size for the _jv path.
_JV_BLOCK = 32
# Maximum allowed alpha (prevents divergence from degenerate steps).
LS_ALPHA_MAX = 1e4
@qd.func
def ... | 919 | 47,211 |
genesis-world | genesis/engine/solvers/rigid/constraint/solver.py | .py | from typing import TYPE_CHECKING
import numpy as np
import quadrants as qd
import torch
from frozendict import frozendict
import genesis as gs
import genesis.utils.array_class as array_class
import genesis.utils.geom as gu
from genesis.engine.solvers.rigid.abd import func_solve_mass_batch
from genesis.engine.solvers... | 7,165 | 376,441 |
genesis-world | genesis/engine/solvers/rigid/constraint/island.py | .py | import quadrants as qd
import genesis as gs
import genesis.utils.array_class as array_class
import genesis.utils.geom as gu
from ..collider.contact import func_contact_order_key
# Partition LINKS into islands: connected components of the coupling graph whose edges are (1) kinematic - every link
# to its parent, so ... | 527 | 30,065 |
genesis-world | genesis/engine/solvers/rigid/constraint/backward.py | .py | import quadrants as qd
import genesis as gs
import genesis.utils.array_class as array_class
import genesis.utils.geom as gu
from . import solver
@qd.func
def func_matvec_Ap(
i_b,
constraint_state: array_class.ConstraintState,
dyn_info: array_class.DynInfo,
rigid_info: array_class.RigidInfo,
rigi... | 1,507 | 79,244 |
genesis-world | genesis/engine/solvers/rigid/abd/inverse_kinematics.py | .py | """
Inverse kinematics for rigid body entities.
This module contains the inverse kinematics kernel for computing joint configurations
that achieve desired end-effector poses.
"""
import quadrants as qd
import genesis as gs
import genesis.utils.geom as gu
import genesis.utils.linalg as lu
import genesis.utils.array_c... | 797 | 34,307 |
genesis-world | genesis/engine/solvers/rigid/abd/forward_dynamics.py | .py | """
Rigid solver dynamics kernel and function definitions.
This module contains Quadrants kernel and function definitions for rigid body dynamics
simulation, including:
- Mass matrix computation and factorization
- Force calculations (torque, passive, bias, actuation)
- Forward dynamics computation
- Velocity and acce... | 1,622 | 88,782 |
genesis-world | genesis/engine/solvers/rigid/abd/accessor.py | .py | """
Rigid solver control, getter, and setter kernel functions.
This module contains Quadrants kernel functions for controlling rigid body simulations,
including state getters/setters, link position/quaternion manipulation, DOF control,
and drone-specific operations.
These functions are used by the RigidSolver class t... | 1,268 | 51,827 |
genesis-world | genesis/engine/solvers/rigid/abd/misc.py | .py | import quadrants as qd
import genesis as gs
import genesis.utils.array_class as array_class
import genesis.utils.geom as gu
@qd.func
def linear_to_lower_tri(i_pair: qd.i32, strict: qd.template() = False):
"""Convert a linear index into (row, col) of a lower-triangular matrix.
Maps i_pair -> (i_d1, i_d2) ove... | 990 | 43,459 |
genesis-world | genesis/engine/solvers/rigid/abd/diff.py | .py | """
Backward pass functions for the rigid body solver.
This module contains functions used during the backward pass (gradient computation)
of the rigid body simulation. These functions handle:
- Copying state between next and current time steps
- Saving and loading adjoint cache for gradient computation
- Preparing an... | 354 | 14,847 |
genesis-world | genesis/engine/solvers/rigid/abd/__init__.py | .py | """
Articulated Body Dynamics (ABD) submodule for rigid body simulation.
Contains forward kinematics, inverse kinematics, forward dynamics, accessor, differentiation, and misc computations.
"""
from .forward_kinematics import *
from .inverse_kinematics import *
from .forward_dynamics import *
from .accessor import *
... | 13 | 360 |
genesis-world | genesis/engine/solvers/rigid/abd/manual_bw.py | .py | """Manual reverse-mode kernels for the rigid backward pass.
They hand-compute the Jacobian-transpose products of forward stages whose reverse Quadrants automatic differentiation
silently drops (forward kinematics, forward velocity) or cannot express (the mass solve, reversed via the implicit
function theorem). The cha... | 513 | 30,312 |
genesis-world | genesis/engine/solvers/rigid/abd/forward_kinematics.py | .py | """
Forward kinematics, velocity propagation, and geometry updates for rigid body simulation.
This module contains Quadrants kernels and functions for:
- Forward kinematics computation (link and joint pose updates)
- Velocity propagation through kinematic chains
- Geometry pose and vertex updates
- Center of mass calc... | 1,201 | 54,438 |
genesis-world | genesis/engine/states/solvers.py | .py | import genesis as gs
from genesis.repr_base import RBC
class SimState(RBC):
"""
Dynamic state queried from a Scene's Simulator.
"""
def __init__(
self,
scene,
s_global,
f_local,
solvers,
):
self._scene = scene
self._s_global = s_global
... | 316 | 8,738 |
genesis-world | genesis/engine/states/entities.py | .py | import genesis as gs
from genesis.repr_base import RBC
class ToolEntityState:
"""
Dynamic state queried from a genesis ToolEntity.
"""
def __init__(self, entity, s_global):
self.entity = entity
self.s_global = s_global
args = {
"dtype": gs.tc_float,
"r... | 229 | 5,668 |
genesis-world | genesis/engine/states/cache.py | .py | from genesis.utils.repr import brief
class StateList(list):
def __getitem__(self, item):
result = super().__getitem__(item)
if isinstance(item, slice):
return StateList(result)
else:
return result
def __repr__(self):
repr_str = "["
for link_i in... | 56 | 1,583 |
genesis-world | genesis/engine/boundaries/boundaries.py | .py | import numpy as np
import quadrants as qd
import genesis as gs
from genesis.utils.misc import *
from genesis.utils.repr import brief
@qd.data_oriented
class CubeBoundary:
def __init__(self, lower, upper, restitution=0.0):
self.restitution = restitution
self.upper = np.array(upper, dtype=gs.np_fl... | 72 | 2,018 |
genesis-world | genesis/utils/point_cloud.py | .py | """
Furthest point sampling (FPS) on triangle mesh surfaces.
"""
import numpy as np
import trimesh
import genesis as gs
from . import mesh as msu
from .misc import get_fps_pc_cache_dir
def get_fps_pc_cache(verts, faces, n_points: int, n_candidates: int, return_normals: bool, seed: int):
return msu.MeshCache(ge... | 157 | 5,506 |
genesis-world | genesis/utils/particle.py | .py | import ctypes
import os
import platform
import subprocess
import sys
import shutil
import tempfile
from multiprocessing import Process, Queue
import igl
import numpy as np
import trimesh
import genesis as gs
from . import geom as gu
from . import mesh as msu
from . import misc as miu
# Make sure ParticleMesherPy sh... | 460 | 16,310 |
genesis-world | genesis/utils/terrain.py | .py | import os
import math
import pickle as pkl
from pathlib import Path
import fast_simplification
import numpy as np
import trimesh
import genesis as gs
from genesis.ext.isaacgym import terrain_utils as isaacgym_terrain_utils
from genesis.options.morphs import Terrain
from .mesh import get_gnd_path
def parse_terrain(... | 487 | 20,760 |
genesis-world | genesis/utils/emoji.py | .py | import random
def random_scene():
return random.choice(["🏟️", "🏯", "🏰", "🌃", "🌇", "🌉", "🎡", "⛰️", "🏖️", "🏜️", "🏘️"])
def get_clock(t, speed=10):
return "🕐🕑🕒🕓🕔🕕🕖🕗🕘🕙🕚🕛"[int(t * speed) % 12]
| 10 | 278 |
genesis-world | genesis/utils/repr.py | .py | import numpy as np
import torch
def brief(x):
if hasattr(x, "_repr_brief"):
return x._repr_brief()
elif isinstance(x, (int, float, dict, bool, list, tuple, np.integer, np.floating)):
return f"{__repr_name__(x)}: {x}"
elif isinstance(x, str):
return f"{__repr_name__(x)}: '{x}'"
... | 42 | 1,047 |
genesis-world | genesis/utils/misc.py | .py | import ctypes
import datetime
import functools
import io
import logging
import math
import numbers
import os
import random
import sys
from collections import OrderedDict
from collections.abc import Callable, Mapping
from dataclasses import field
from importlib import import_module
from itertools import combinations
fro... | 1,090 | 43,235 |
genesis-world | genesis/utils/path_planning.py | .py | import time
from abc import ABC, abstractmethod
from typing import TYPE_CHECKING
import quadrants as qd
import torch
import torch.nn.functional as F
import genesis as gs
import genesis.utils.geom as gu
from genesis.utils import array_class
if TYPE_CHECKING:
from genesis.engine.solvers.rigid.rigid_solver import R... | 1,073 | 45,527 |
genesis-world | genesis/utils/geom.py | .py | import math
from typing import Literal
import numba as nb
import numpy as np
import quadrants as qd
import torch
import torch.nn.functional as F
import genesis as gs
from genesis.typing import Vec3FType
# ------------------------------------------------------------------------------------
# -------------------------... | 2,674 | 94,768 |
genesis-world | genesis/utils/collision.py | .py | """Shared helpers for translating a desired collision matrix into contype/conaffinity bitmasks."""
import z3
def solve_contype_conaffinity(
n: int, invalid_pairs: set[frozenset[int]], max_bits: int = 31
) -> list[tuple[int, int]] | None:
"""
Synthesize per-geom ``(contype, conaffinity)`` bitmasks realizi... | 60 | 2,876 |
genesis-world | genesis/utils/video_encoder.py | .py | import logging
import os
import queue
import tempfile
import threading
from fractions import Fraction
from functools import lru_cache
from pathlib import Path
import numpy as np
import av
import genesis as gs
LOGGER = logging.getLogger(__name__)
# Ordered by preference: hardware encoders first, software last.
H26... | 279 | 12,115 |
genesis-world | genesis/utils/warnings.py | .py | import genesis as gs
_seen: set[str] = set()
def warn_once(message: str):
global _seen
if message in _seen:
return
_seen.add(message)
gs.logger.warning(message)
| 13 | 189 |
genesis-world | genesis/utils/raycast.py | .py | from typing import TYPE_CHECKING, NamedTuple
import numpy as np
import genesis as gs
if TYPE_CHECKING:
from genesis.engine.entities.rigid_entity.rigid_geom import RigidGeom, RigidVisGeom
class Ray(NamedTuple):
origin: np.ndarray # (3,)
direction: np.ndarray # (3,)
class RayHit(NamedTuple):
dist... | 42 | 1,214 |
genesis-world | genesis/utils/array_class.py | .py | import dataclasses
import math
from enum import IntEnum
from typing import NamedTuple
import quadrants as qd
from typing_extensions import dataclass_transform # Made it into standard lib from Python 3.12
import numpy as np
import torch
import genesis as gs
def _tensor_backend():
return qd.Backend.NDARRAY if gs... | 2,796 | 130,725 |
genesis-world | genesis/utils/mjcf.py | .py | import os
import xml.etree.ElementTree as ET
from pathlib import Path
from itertools import chain
from bisect import bisect_right
# Note the importing mujoco with env var `MUJOCO_GL=EGL` forcibly defines `PYOPENGL_PLATFORM=egl`
import mujoco
import numpy as np
import trimesh
from trimesh.visual.texture import Texture... | 909 | 40,687 |
genesis-world | genesis/utils/image_exporter.py | .py | import os
from collections.abc import Iterable, Sequence
from concurrent.futures import ThreadPoolExecutor, Executor
from functools import partial
import torch
import numpy as np
import genesis as gs
from genesis.constants import IMAGE_TYPE
from genesis.utils.misc import tensor_to_array
def as_grayscale_image(
... | 239 | 10,279 |
genesis-world | genesis/utils/mesh.py | .py | import hashlib
import marshal
import math
import os
import pickle as pkl
from functools import lru_cache
from pathlib import Path
import coacd
import igl
import Imath
import numpy as np
import OpenEXR
import tetgen
import trimesh
from PIL import Image
import genesis as gs
from . import geom as gu
from .misc import (... | 1,510 | 64,962 |
genesis-world | genesis/utils/uid.py | .py | import uuid
from genesis.repr_base import RBC
class UID(RBC):
def __init__(self) -> None:
self.uid = uuid.uuid4().hex
def _repr_brief(self):
return self.__repr__()
def __repr__(self) -> str:
return f"{self.__repr_name__()}('{self.full()}')"
def __format__(self, format_spec)... | 48 | 1,163 |
genesis-world | genesis/utils/ring_buffer.py | .py | import torch
import genesis as gs
class TensorRingBuffer:
"""
A helper class for storing a buffer of `torch.Tensor`s without allocating new tensors.
Parameters
----------
N : int
The number of tensors to store.
shape : tuple[int, ...]
The shape of the tensors to store.
dt... | 159 | 6,072 |
genesis-world | genesis/utils/element.py | .py | import numpy as np
import igl
import genesis as gs
from . import mesh as mu
def mesh_to_elements(mesh, tet_cfg=dict()):
"""Tetrahedralize a surface trimesh, with the result cached on disk keyed on vertices, faces and configuration."""
cache = mu.get_tet_cache(mesh.vertices, mesh.faces, tet_cfg)
# loadi... | 50 | 1,794 |
genesis-world | genesis/utils/watertighten.py | .py | """Watertight wrap of a triangle soup via SDF dual contouring + feature-preserving quadric-error decimation.
The main entrypoint is `watertighten_mesh`; see its docstring for the algorithm steps, parameter meanings, and the
adaptive defaults.
"""
from typing import Tuple
import igl
import numba as nb
import numpy as... | 1,297 | 62,121 |
genesis-world | genesis/utils/gltf.py | .py | from io import BytesIO
from urllib import request
import DracoPy
import numpy as np
import pygltflib
import trimesh
from PIL import Image
import genesis as gs
from . import mesh as mu
from . import geom as gu
ctype_to_numpy = {
5120: np.int8, # BYTE
5121: np.uint8, # UNSIGNED_BYTE
5122: np.int16, # ... | 415 | 18,263 |
genesis-world | genesis/utils/deprecated_module_wrapper.py | .py | import sys
from types import ModuleType
import genesis as gs
class _DeprecatedModuleWrapper(ModuleType):
"""
A module wrapper that shows a deprecation warning when accessed.
This allows us to support the old module name while
warning users to update their imports.
"""
def __init__(self, actua... | 42 | 1,412 |
genesis-world | genesis/utils/tools.py | .py | import os
import time
import numpy as np
import quadrants as qd
from PIL import Image
import genesis as gs
from genesis.utils.misc import get_entry_point_name
def animate(imgs, filename=None, fps=60):
"""
Create a video from a list of images.
Args:
imgs (list): List of input images.
fil... | 235 | 7,877 |
genesis-world | genesis/utils/urdf.py | .py | import os
import xml.etree.ElementTree as ET
from pathlib import Path
import numpy as np
import trimesh
import xacro
import genesis as gs
import genesis.utils.gltf as gltf_utils
from genesis.ext import urdfpy
from . import geom as gu
from .misc import get_assets_dir
def get_robot_name(file_path):
"""
Extr... | 652 | 25,785 |
genesis-world | genesis/utils/raycast_qd.py | .py | import quadrants as qd
import genesis as gs
import genesis.utils.array_class as array_class
import genesis.utils.geom as gu
from genesis.engine.bvh import STACK_SIZE
from genesis.engine.solvers.rigid.rigid_solver import func_update_all_verts
# FIXME: get_triangle_vertices/bvh_ray_cast/update_aabbs duplicate their vi... | 960 | 40,206 |
genesis-world | genesis/utils/hybrid.py | .py | import hashlib
import os
import platform
import sys
import time
from itertools import combinations
import networkx as nx
import numpy as np
from matplotlib.patches import FancyArrowPatch
import genesis as gs
from .misc import get_gel_cache_dir
def load_hmesh(fpath: str):
if sys.platform == "linux" and platform... | 296 | 8,884 |
genesis-world | genesis/utils/linalg.py | .py | import quadrants as qd
import genesis as gs
@qd.func
def mat_mul(A: qd.Tensor, B: qd.Tensor, res: qd.Tensor, n, m, l, i_b):
"""
Performs matrix multiplication between matrices A and B and stores the result in res.
Args:
A (qd.field): The first matrix of shape (n, m, B).
B (qd.field): The... | 102 | 2,854 |
genesis-world | genesis/utils/sdf.py | .py | import numpy as np
import quadrants as qd
import genesis as gs
import genesis.utils.geom as gu
import genesis.utils.array_class as array_class
class SDF:
def __init__(self, rigid_solver):
self.solver = rigid_solver
self._geoms_sdf_coarse_res = np.array(
[(geom.sdf_res - 2) // 4 + 1 fo... | 583 | 22,856 |
genesis-world | genesis/utils/usd/usd_material.py | .py | import io
import numpy as np
from PIL import Image
from pxr import Ar, Usd, UsdShade
import genesis as gs
from genesis.utils import mesh as mu
CS_ENCODE = {
"raw": "linear",
"sRGB": "srgb",
"auto": None,
"": None,
}
def get_input_attribute_value(shader: UsdShade.Shader, input_name, input_type=None... | 181 | 7,604 |
genesis-world | genesis/utils/usd/usd_utils.py | .py | import math
from typing import List, Tuple
import numpy as np
from pxr import Gf, Usd, UsdGeom
import genesis as gs
from genesis.utils import geom as gu
AXES_VECTOR = {
"X": np.array([1, 0, 0], dtype=np.float32),
"Y": np.array([0, 1, 0], dtype=np.float32),
"Z": np.array([0, 0, 1], dtype=np.float32),
}
... | 324 | 10,138 |
genesis-world | genesis/utils/usd/__init__.py | .py | """
USD (Universal Scene Description) utilities for parsing and processing USD files.
This module provides functionality for parsing USD stages and converting them into Genesis
entities. It supports parsing rigid bodies, articulations, materials, and geometry from
USD files.
The module requires the `usd-core` package... | 53 | 1,976 |
genesis-world | genesis/utils/usd/usd_rigid_entity.py | .py | from typing import Dict, List, NamedTuple, Tuple
import numpy as np
from pxr import Usd, UsdPhysics
import genesis as gs
from genesis.utils import geom as gu
from genesis.utils import urdf as urdf_utils
from .usd_context import (
UsdContext,
extract_links_referenced_by_joints,
find_joints_in_range,
f... | 746 | 35,103 |
genesis-world | genesis/utils/usd/usd_geometry.py | .py | import re
from typing import Dict, List
import numpy as np
import trimesh
from pxr import Usd, UsdGeom, UsdPhysics
import genesis as gs
from genesis.utils import geom as gu
from .usd_context import UsdContext
from .usd_utils import AXES_T, AXES_VECTOR, usd_attr_array_to_numpy, usd_primvar_array_to_numpy
# UsdPhysi... | 437 | 21,105 |
genesis-world | genesis/utils/usd/usd_collision.py | .py | """Translate USD collision filtering (CollisionGroup / FilteredPairsAPI) into contype/conaffinity."""
from pxr import Usd, UsdPhysics
import genesis as gs
from genesis.utils.collision import solve_contype_conaffinity
def _geoms_under(cg_infos: list[dict], path: str) -> list[int]:
"""Indices of collision g_infos... | 135 | 6,401 |
genesis-world | genesis/utils/usd/usd_context.py | .py | import io
import logging
import os
import shutil
import subprocess
import sys
import tempfile
from pathlib import Path
from typing import NamedTuple
import filelock
import numpy as np
import torch
from pxr import Sdf, Usd, UsdGeom, UsdPhysics, UsdShade
import genesis as gs
import genesis.utils.mesh as mu
from .usd_m... | 558 | 23,941 |
genesis-world | genesis/utils/usd/usd_bake.py | .py | import argparse
import asyncio
import logging
import os
import time
def omni_bootstrap(device=0, log_level="warning"):
import omni.kit_app
app = omni.kit_app.KitApp()
kit_dir = os.path.dirname(os.path.abspath(os.path.realpath(omni.kit_app.__file__)))
kit_path = os.path.join(kit_dir, "apps", "omni.app... | 116 | 4,448 |
genesis-world | genesis/utils/usd/usd_stage.py | .py | from typing import List, Set
import genesis as gs
from pxr import Sdf, Usd, UsdPhysics
from .usd_context import (
UsdContext,
extract_links_referenced_by_joints,
find_joints_in_range,
find_rigid_bodies_in_range,
resolve_rigid_body_link_path,
)
from .usd_utils import UnionFind
def _find_common_an... | 198 | 7,684 |
genesis-world | genesis/recorders/recorder_manager.py | .py | from typing import TYPE_CHECKING, Any, Callable
import genesis as gs
if TYPE_CHECKING:
from .base_recorder import Recorder, RecorderOptions
class RecorderManager:
"""
Manage the creation, processing, and cleanup of all data recorders.
Parameters
----------
step_dt: float
The simulat... | 104 | 2,984 |
genesis-world | genesis/recorders/base_recorder.py | .py | import queue
import threading
import time
from typing import TYPE_CHECKING, Callable, Generic, TypeVar
import genesis as gs
from genesis.options.recorders import RecorderOptions
from genesis.utils import data_to_array
if TYPE_CHECKING:
from .recorder_manager import RecorderManager
T = TypeVar("T")
class Recor... | 225 | 8,085 |
genesis-world | genesis/recorders/file_writers.py | .py | import csv
import logging
import os
from collections import defaultdict
import numpy as np
import genesis as gs
from genesis.options.recorders import (
CSVFile as CSVFileWriterOptions,
NPZFile as NPZFileWriterOptions,
VideoFile as VideoFileWriterOptions,
)
from genesis.utils.video_encoder import VideoEnco... | 195 | 6,754 |
genesis-world | genesis/recorders/plotters.py | .py | import io
import itertools
import logging
import sys
import threading
import time
from collections import defaultdict
from collections.abc import Sequence
from functools import cached_property, partial
from typing import Any, Callable, TypeVar
import numpy as np
from PIL import Image
import genesis as gs
import genes... | 868 | 34,654 |
genesis-world | genesis/logging/time_elapser.py | .py | import threading
import time
import numpy as np
from genesis.utils.emoji import get_clock
class TimeElapser:
"""
A tool that can be called with `with` statement, and starts a separate thread that continuously outputs logger message with elasped time.
"""
def __init__(self, logger, refresh_rate, end... | 61 | 2,209 |
genesis-world | genesis/logging/logger.py | .py | import sys
import logging
import threading
from contextlib import contextmanager
from genesis.styles import colors, formats
from .time_elapser import TimeElapser
class GenesisFormatter(logging.Formatter):
def __init__(self, verbose_time=True):
super().__init__()
self.mapping = {
log... | 164 | 4,695 |
genesis-world | genesis/options/options.py | .py | from typing import Any
from typing_extensions import Self
from pydantic import BaseModel, ConfigDict, ValidationError
import genesis as gs
import genesis.utils.repr as ru
from genesis.repr_base import RBC
from genesis.styles import colors, formats
class Options(RBC, BaseModel):
"""
This is the base class fo... | 143 | 6,735 |
genesis-world | genesis/options/misc.py | .py | from typing import Literal
from pydantic import Field, StrictBool, StrictInt, model_validator
from typing_extensions import Self
import genesis as gs
from genesis.typing import NonNegativeInt, PositiveInt, Vec4FType
from .options import Options
class FoamOptions(Options):
"""
Options for foam generation.
... | 60 | 2,122 |
genesis-world | genesis/options/textures.py | .py | import os
from functools import cached_property
from typing import Annotated, Sequence, Literal, Iterable, cast
import numpy as np
from PIL import Image
from pydantic import model_validator, computed_field, BeforeValidator, Field
import genesis as gs
import genesis.utils.mesh as mu
from genesis.typing import LaxUnitI... | 383 | 14,575 |
genesis-world | genesis/options/solvers.py | .py | from typing import Any, Literal
import numpy as np
from pydantic import PrivateAttr, StrictBool, model_validator
import genesis as gs
from genesis.typing import NonNegativeFloat, NonNegativeInt, PositiveFloat, PositiveInt, UnitVec4FType, Vec3FType
from .options import Options
############################ Top level:... | 938 | 48,794 |
genesis-world | genesis/options/morphs.py | .py | """
We define all types of morphologies here: shape primitives, meshes, URDF, MJCF, and soft robot description files.
These are independent of backend solver type and are shared by different solvers, e.g. a mesh can be either loaded as a
rigid object / MPM object / FEM object.
"""
import os
import xml.etree.ElementTr... | 1,727 | 99,044 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.