mujoco-mojo 2.2.0__tar.gz → 2.2.2__tar.gz

{mujoco_mojo-2.2.0 → mujoco_mojo-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mujoco-mojo
-Version: 2.2.0
+Version: 2.2.2
 Summary: A complete MJCF lifecycle and trial orchestration suite for MuJoCo, powered by Pydantic v2.
 Author-email: David Gable <dave.a.gable@gmail.com>
 Maintainer-email: David Gable <dave.a.gable@gmail.com>

{mujoco_mojo-2.2.0 → mujoco_mojo-2.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mujoco-mojo"
-version = "2.2.0"
+version = "2.2.2"
 description = "A complete MJCF lifecycle and trial orchestration suite for MuJoCo, powered by Pydantic v2."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -68,11 +68,8 @@ keywords = [
     "mjcf",
 ]
 
-[project.scripts]
-mujoco-mojo = "mujoco_mojo.utils.layers.cli:cli_app"
-
-[tool.setuptools.package-data]
-"*" = ["*.html", "*.js", "*.mp3", "*.svg", "*.css"]
+[project.optional-dependencies]
+reloaded = ["mjviser>=0.0.11", "viser>=1.0.26"]
 
 [dependency-groups]
 dev = [
@@ -94,8 +91,11 @@ dev = [
     "zensical>=0.0.31",
 ]
 
-[project.optional-dependencies]
-reloaded = ["mjviser>=0.0.11", "viser>=1.0.26"]
+[project.scripts]
+mujoco-mojo = "mujoco_mojo.utils.layers.cli:cli_app"
+
+[tool.setuptools.package-data]
+"*" = ["*.html", "*.js", "*.mp3", "*.svg", "*.css"]
 
 [tool.ruff]
 exclude = ["typings", "scripts/templating/sensor_template.py"]

{mujoco_mojo-2.2.0 → mujoco_mojo-2.2.2}/src/mujoco_mojo/mjcf/mujoco_attr/asset_attr/mesh.py

@@ -1,10 +1,23 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Annotated, Any, ClassVar, Literal, Self, overload
+from typing import (
+    TYPE_CHECKING,
+    Annotated,
+    Any,
+    ClassVar,
+    Literal,
+    NotRequired,
+    Self,
+    TypedDict,
+    Unpack,
+    overload,
+)
 
 import mujoco
 import numpy as np
+import trimesh
+import trimesh.visual
 from pydantic import Field, field_validator, model_validator
 
 from mujoco_mojo.mjcf.dependency_path import DepPath
@@ -12,6 +25,8 @@ from mujoco_mojo.mjcf.xml_model import XMLModel
 from mujoco_mojo.typing import Inertia, MaterialName, MeshName, Vec3, Vec4
 from mujoco_mojo.utils.log import get_logger
 
+if TYPE_CHECKING:
+    from trimesh.typed import BooleanEngineType
 logger = get_logger(__name__)
 
 __all__ = [
@@ -29,6 +44,7 @@ _mesh_attr = (
     "name",
     "class_",
     "content_type",
+    "scale",
     "file",
     "vertex",
     "normal",
@@ -36,7 +52,6 @@ _mesh_attr = (
     "face",
     "refpos",
     "refquat",
-    "scale",
     "smoothnormal",
     "maxhullvert",
     "inertia",
@@ -44,6 +59,24 @@ _mesh_attr = (
 )
 
 
+class MeshAttributes(TypedDict):
+    name: NotRequired[MeshName | None]
+    class_: NotRequired[str | None]
+    content_type: NotRequired[str | None]
+    file: NotRequired[DepPath | None]
+    scale: NotRequired[Vec3]
+    inertia: NotRequired[Inertia]
+    smoothnormal: NotRequired[bool]
+    maxhullvert: NotRequired[int]
+    vertex: NotRequired[tuple[tuple[float, float, float], ...] | None]
+    normal: NotRequired[tuple[tuple[float, float, float], ...] | None]
+    texcoord: NotRequired[tuple[tuple[float, float], ...] | None]
+    face: NotRequired[tuple[tuple[int, int, int], ...] | None]
+    refpos: NotRequired[Vec3]
+    refquat: NotRequired[Vec4]
+    material: NotRequired[MaterialName | None]
+
+
 class MeshBase(XMLModel):
     """Base class from which other mesh classes are built from."""
 
@@ -314,6 +347,157 @@ class Mesh(MeshBase):
 
     builtin: Literal["none"] = "none"
 
+    @classmethod
+    def new_from_trimesh(
+        cls,
+        mesh: trimesh.Trimesh | trimesh.Scene,
+        **kwargs: Unpack[MeshAttributes],
+    ) -> Self:
+        """
+        Creates a Mesh instance from a trimesh object.
+
+        Automatically extracts vertices, faces, and (if present) normals/texcoords.
+        """
+        if isinstance(mesh, trimesh.Scene):
+            mesh = mesh.to_mesh()
+
+        assert isinstance(mesh, trimesh.Trimesh)
+        mesh.process(validate=True)
+        mesh.fill_holes()
+
+        # mandatory geometry data
+        extracted_data: dict[str, Any] = {
+            "vertex": tuple(map(tuple, mesh.vertices.tolist())),
+            "face": tuple(map(tuple, mesh.faces.tolist())),
+        }
+
+        # extract normals (if they exist and weren't provided)
+        if "normal" not in kwargs:
+            # only pull if the count matches
+            v_normals = getattr(mesh, "vertex_normals", None)
+            if v_normals is not None and len(v_normals) == len(mesh.vertices):
+                extracted_data["normal"] = tuple(map(tuple, v_normals.tolist()))
+
+        # extract texture coordinates (if they exist and weren't provided)
+        if "texcoord" not in kwargs:
+            if isinstance(mesh.visual, trimesh.visual.TextureVisuals):
+                uvs = mesh.visual.uv
+                if uvs is not None and len(uvs) == len(mesh.vertices):
+                    extracted_data["texcoord"] = tuple(map(tuple, uvs.tolist()))
+
+        # merge kwargs
+        final_attrs = {**extracted_data, **kwargs}
+
+        return cls(**final_attrs)
+
+    @classmethod
+    def new_frustum(
+        cls,
+        radius_bottom: float,
+        radius_top: float,
+        height: float,
+        sections: int = 32,
+        wall_thickness: float = 0.0,
+        engine: BooleanEngineType = None,
+        base_at_zero: bool = True,
+        **kwargs: Unpack[MeshAttributes],
+    ) -> Self:
+        """
+        Generates a conical frustum (tapered cylinder).
+
+        Args:
+            radius_bottom (float): Radius at z = -height/2.
+            radius_top (float): Radius at z = +height/2.
+            height (float): Total height of the frustum.
+            sections (int): Number of radial segments.
+            wall_thickness (float): Thickness of the walls (makes a hollow frustum if not equal to zero).
+            engine (BooleanEngineType): Which engine to use for boolean subtraction (only used for hollow volumes, reccomended to use "manifold" but requires `manifold3d`).
+            base_at_zero (bool): Whether or not to shift the volume so it sits on z=0 instead of underground.
+            **kwargs (MeshAttributes): Standard MuJoCo mesh attributes (name, inertia, etc.)
+
+        Example:
+            <img src="https://raw.githubusercontent.com/Hydrowelder/mujoco-mojo/refs/heads/master/docs/assets/mesh/frustums.jpg" width="300" />
+
+            Two frustums generated using this method. The red frustum has its wall thickness set to 0 and its bottom radius is greater than the top. The cyan frustum has a non-zero wall thickness and a larger top radius than the bottom resulting in a hollow volume. The cyan frustum has more sections than the red.
+
+        """
+        # create the outer mesh
+        mesh = trimesh.creation.cylinder(radius=1.0, height=height, sections=sections)
+
+        def taper_mesh(m: trimesh.Trimesh, r_b: float, r_t: float) -> None:
+            verts = m.vertices.copy()
+            # Dynamically find the midpoint of the specific mesh's height extent
+            z_ext = m.bounds[:, 2]
+            z_mid = (z_ext[1] - z_ext[0]) / 4
+
+            mask_top = verts[:, 2] > z_mid
+            mask_bottom = verts[:, 2] < -z_mid
+
+            verts[mask_top, :2] *= r_t
+            verts[mask_bottom, :2] *= r_b
+            m.vertices = verts
+
+        taper_mesh(mesh, radius_bottom, radius_top)
+
+        if wall_thickness != 0:
+            inner = trimesh.creation.cylinder(
+                radius=1.0, height=height + 0.02, sections=sections
+            )
+            taper_mesh(
+                inner, radius_bottom - wall_thickness, radius_top - wall_thickness
+            )
+
+            # perform boolean subtraction to make it hollow
+            # Note: This requires the 'manifold' or 'blender' engine installed for trimesh,
+            # otherwise it falls back to a simpler but less robust internal boolean.
+            mesh = mesh.difference(inner, engine=engine)
+
+        if base_at_zero:
+            mesh.apply_translation([0, 0, height / 2])
+        return cls.new_from_trimesh(mesh, **kwargs)
+
+    @classmethod
+    def new_hollow_box(
+        cls,
+        width: float,
+        depth: float,
+        height: float,
+        wall_thickness: float = 0.02,
+        engine: BooleanEngineType = None,
+        base_at_zero: bool = True,
+        **kwargs: Unpack[MeshAttributes],
+    ) -> Self:
+        """
+        Generates an open-top box with physical wall thickness (concave bin).
+
+        Args:
+            width (float): Total outer dimension along X.
+            depth (float): Total outer dimension along Y.
+            height (float): Total outer dimension along Z.
+            wall_thickness (float): Thickness of the walls and bottom floor.
+            engine (BooleanEngineType): Engine to use for boolean subtraction.
+            base_at_zero (bool): Shift volume so it sits on z=0 instead of underground.
+            **kwargs (MeshAttributes): Standard MuJoCo mesh attributes (name, inertia, etc.)
+
+        """
+        # outer box centered at (0, 0, 0)
+        outer = trimesh.creation.box(extents=(width, depth, height))
+
+        # inner cutout box
+        inner = trimesh.creation.box(
+            extents=(width - (2 * wall_thickness), depth - (2 * wall_thickness), height)
+        )
+
+        # shift the inner tool up by the floor thickness
+        inner.apply_translation([0, 0, wall_thickness])
+
+        mesh = outer.difference(inner, engine=engine)
+
+        if base_at_zero:
+            mesh.apply_translation([0, 0, height / 2])
+
+        return cls.new_from_trimesh(mesh, **kwargs)
+
 
 class MeshSphere(MeshBase):
     """

{mujoco_mojo-2.2.0 → mujoco_mojo-2.2.2}/src/mujoco_mojo/mjcf/mujoco_attr/body_attr/geom.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Annotated, ClassVar, Literal
 
 import mujoco
 import numpy as np
+import trimesh
 from pydantic import ConfigDict, Field
 
 from mujoco_mojo.mjcf.defaults import SOLIMP_DEFAULT, SOLREF_DEFAULT
@@ -262,10 +263,7 @@ class GeomBase(XMLModel):
         signal_manager: SignalManager,
         attrs: list[
             Literal["xpos", "xmat", "xvelp", "xvelr", "xaccp", "xaccr", "quat"]
-        ] = [
-            "xpos",
-            "quat",
-        ],
+        ] = ["xpos", "quat"],
     ):
         """
         Registers specific geom attributes for logging.
@@ -476,6 +474,31 @@ class GeomMesh(GeomBase, ProximityMixin):
     mesh: MeshName
     """If the geom type is "mesh", this attribute is required. It references the mesh asset to be instantiated. This attribute can also be specified if the geom type corresponds to a geometric primitive, namely one of "sphere", "capsule", "cylinder", "ellipsoid", "box". In that case the primitive is automatically fitted to the mesh asset referenced here. The fitting procedure uses either the equivalent inertia box or the axis-aligned bounding box of the mesh, as determined by the attribute fitaabb of compiler. The resulting size of the fitted geom is usually what one would expect, but if not, it can be further adjusted with the fitscale attribute below. In the compiled mjModel the geom is represented as a regular geom of the specified primitive type, and there is no reference to the mesh used for fitting."""
 
+    def trimesh(self, mj_model: mujoco.MjModel) -> trimesh.Trimesh:
+        # get mesh id and data from mujoco
+        mesh_id = mj_model.geom_dataid[self.get_id(mj_model)]
+
+        if mesh_id == -1:
+            msg = "Exact proximity mesh tool is not currently supported for geoms of this type. Please use the `SPHERE_TO_SPHERE`/`CONVEX_HULL` algorithm, or convert the Geom to a GeomMesh."
+            logger.error(msg)
+            raise TypeError(msg)
+
+        # extract vertices and faces
+        if self._local_verts is None:
+            adr = mj_model.mesh_vertadr[mesh_id]
+            num = mj_model.mesh_vertnum[mesh_id]
+            self._local_verts = mj_model.mesh_vert[adr : adr + num].copy()
+
+        f_adr = mj_model.mesh_faceadr[mesh_id]
+        f_num = mj_model.mesh_facenum[mesh_id]
+        self._local_faces = mj_model.mesh_face[f_adr : f_adr + f_num].copy()
+
+        # create a trimesh and its proximity query
+        self._baked_mesh = trimesh.Trimesh(
+            vertices=self._local_verts, faces=self._local_faces
+        )
+        return self._baked_mesh
+
 
 class GeomSDF(GeomBase):
     attributes = (*_geom_attr, "type")

{mujoco_mojo-2.2.0 → mujoco_mojo-2.2.2}/src/mujoco_mojo/utils/filters/filters.py

@@ -11,6 +11,7 @@ from pydantic import BaseModel, ConfigDict, Field, TypeAdapter, model_validator
 from scipy.signal import savgol_filter
 
 __all__ = [
+    "UNIT_GROUPS",
     "AbsoluteValueFilter",
     "AnyFilter",
     "ClipFilter",
@@ -302,56 +303,50 @@ class SavitzkyGolayFilter(BaseFilter):
 
 
 ureg = pint.UnitRegistry()
-# --- Kinematics ---
-AngleUnit = Literal["rad", "deg", "rad/s", "deg/s", "rad/s^2", "deg/s^2", "rev", "rpm"]
-LenUnit = Literal["m", "mm", "cm", "km", "in", "ft", "thou"]
-VelUnit = Literal["m/s", "ft/s", "in/s", "km/h", "mph"]
-AccUnit = Literal["m/s^2", "g", "ft/s^2", "in/s^2"]
-
-# --- Dynamics & Statics ---
-MassUnit = Literal["kg", "lbm", "slug", "g", "mg"]
-ForceUnit = Literal["N", "lbf", "kN", "mN"]
-TorqueUnit = Literal["N*m", "N*mm", "mN*m", "lbf*ft", "lbf*in", "ozf*in"]
-InertiaUnit = Literal["kg*m^2", "lbm*in^2", "lbm*ft^2", "slug*ft^2"]
-
-# --- Work & Thermodynamics ---
-EnergyUnit = Literal["J", "kJ", "mJ", "W*s", "ft*lbf", "BTU"]
-PowerUnit = Literal["W", "kW", "hp", "ft*lbf/s"]
-PressureUnit = Literal["Pa", "kPa", "psi", "bar", "atm", "torr"]
-
-# --- Temporal & Electronics ---
-TimeUnit = Literal["s", "ms", "us", "ns", "min", "hr"]
-FreqUnit = Literal["Hz", "kHz", "MHz", "rad/s"]
-
-# --- Dimensionless & Ratios ---
-MiscUnit = Literal["dimensionless", "pct", "count", "bit", "V", "A"]
-
-SignalUnit = (
-    AngleUnit
-    | LenUnit
-    | VelUnit
-    | AccUnit
-    | MassUnit
-    | ForceUnit
-    | TorqueUnit
-    | InertiaUnit
-    | EnergyUnit
-    | PowerUnit
-    | PressureUnit
-    | TimeUnit
-    | FreqUnit
-    | MiscUnit
-    | str
-)
-
 try:
-    # explicitly map lbm and lbf to avoid ambiguity
     ureg.define("lbm = pound")
     ureg.define("lbf = force_pound")
+    ureg.define("ozf = force_ounce")
 except pint.errors.RedefinitionError:
-    # already defined in some Pint versions
     pass
 
+# ---------------------------------------------------------------------------
+# Unit groups — single source of truth for both the frontend smart dropdown
+# and the SignalUnit type annotation on UnitFilter.  To add a new unit,
+# add it here; SignalUnit is derived automatically.  Verify that pint can
+# parse any new string via `ureg.parse_units(...)` before committing.
+# ---------------------------------------------------------------------------
+UNIT_GROUPS: list[tuple[str, list[str]]] = [
+    # --- Kinematics ---
+    ("Angle", ["rad", "deg", "mrad", "rev", "rpm"]),
+    ("Angular Velocity", ["rad/s", "deg/s"]),
+    ("Angular Accel.", ["rad/s^2", "deg/s^2"]),
+    ("Length", ["m", "mm", "cm", "um", "km", "in", "ft", "thou"]),
+    ("Velocity", ["m/s", "mm/s", "cm/s", "ft/s", "in/s", "km/h", "mph"]),
+    ("Acceleration", ["m/s^2", "mm/s^2", "ft/s^2", "in/s^2"]),
+    # --- Dynamics & Statics ---
+    ("Mass", ["kg", "g", "mg", "lbm", "slug"]),
+    ("Force", ["N", "mN", "uN", "kN", "lbf"]),
+    ("Torque", ["N*m", "N*mm", "mN*m", "kN*m", "lbf*ft", "lbf*in", "ozf*in"]),
+    ("Inertia", ["kg*m^2", "kg*mm^2", "lbm*in^2", "lbm*ft^2", "slug*ft^2"]),
+    # --- Work & Thermodynamics ---
+    ("Energy", ["J", "mJ", "kJ", "W*s", "W*h", "kW*h", "ft*lbf", "BTU"]),
+    ("Power", ["W", "mW", "kW", "MW", "hp", "ft*lbf/s"]),
+    ("Pressure", ["Pa", "kPa", "MPa", "psi", "bar", "atm", "torr"]),
+    # --- Temporal & Electronics ---
+    ("Time", ["s", "ms", "us", "ns", "min", "hr"]),
+    ("Frequency", ["Hz", "kHz", "MHz"]),
+    ("Voltage", ["V", "mV", "kV"]),
+    ("Current", ["A", "mA"]),
+    # --- Dimensionless & Ratios ---
+    ("Misc.", ["dimensionless", "pct", "count", "bit"]),
+]
+
+# Derived automatically — Literal[tuple_of_strings] is equivalent to Literal["a", "b", ...]
+# in Python 3.9+ because x[a, b] and x[(a, b)] make the same __getitem__ call.
+_ALL_UNITS: tuple[str, ...] = tuple(u for _, us in UNIT_GROUPS for u in us)
+SignalUnit = Literal[_ALL_UNITS] | str
+
 
 class UnitFilter(BaseFilter):
     """
@@ -362,9 +357,10 @@ class UnitFilter(BaseFilter):
     type: Literal[FilterType.UNIT] = FilterType.UNIT
     """The discriminator type for Pydantic."""
 
-    from_unit: SignalUnit
+    from_unit: SignalUnit  # pyright: ignore[reportInvalidTypeForm]
     """The original unit of the telemetry data (e.g., 'rad')."""
-    to_unit: SignalUnit
+
+    to_unit: SignalUnit  # pyright: ignore[reportInvalidTypeForm]
     """The target unit for analysis/display (e.g., 'deg')."""
 
     @model_validator(mode="after")