jaxsim 0.4.1__tar.gz → 0.4.1.dev6__tar.gz

{jaxsim-0.4.1 → jaxsim-0.4.1.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaxsim
-Version: 0.4.1
+Version: 0.4.1.dev6
 Summary: A differentiable physics engine and multibody dynamics library for control and robot learning.
 Author-email: Diego Ferigo <dgferigo@gmail.com>
 Maintainer-email: Diego Ferigo <dgferigo@gmail.com>, Filippo Luca Ferretti <filippo.ferretti@iit.it>
@@ -80,7 +80,6 @@ Provides-Extra: viz
 Requires-Dist: lxml; extra == "viz"
 Requires-Dist: mediapy; extra == "viz"
 Requires-Dist: mujoco>=3.0.0; extra == "viz"
-Requires-Dist: scipy>=1.14.0; extra == "viz"
 Provides-Extra: all
 Requires-Dist: jaxsim[style,testing,viz]; extra == "all"
 

{jaxsim-0.4.1 → jaxsim-0.4.1.dev6}/environment.yml

@@ -5,7 +5,7 @@ dependencies:
   # ===========================
   # Dependencies from setup.cfg
   # ===========================
-  - python >= 3.12.0
+  - python=3.11
   - coloredlogs
   - jax >= 0.4.13
   - jaxlib >= 0.4.13
@@ -30,7 +30,6 @@ dependencies:
   - lxml
   - mediapy
   - mujoco >= 3.0.0
-  - scipy >= 1.14.0
   # ==========================
   # Documentation dependencies
   # ==========================

{jaxsim-0.4.1 → jaxsim-0.4.1.dev6}/pyproject.toml

@@ -69,7 +69,6 @@ viz = [
     "lxml",
     "mediapy",
     "mujoco >= 3.0.0",
-    "scipy >= 1.14.0",
 ]
 all = [
     "jaxsim[style,testing,viz]",

{jaxsim-0.4.1 → jaxsim-0.4.1.dev6}/src/jaxsim/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.4.1'
-__version_tuple__ = version_tuple = (0, 4, 1)
+__version__ = version = '0.4.1.dev6'
+__version_tuple__ = version_tuple = (0, 4, 1, 'dev6')

{jaxsim-0.4.1 → jaxsim-0.4.1.dev6}/src/jaxsim/integrators/common.py

@@ -5,12 +5,11 @@ from typing import Any, ClassVar, Generic, Protocol, Type, TypeVar
 import jax
 import jax.numpy as jnp
 import jax_dataclasses
+import jaxlie
 from jax_dataclasses import Static
 
 import jaxsim.api as js
-import jaxsim.math
 import jaxsim.typing as jtp
-from jaxsim import exceptions
 from jaxsim.utils.jaxsim_dataclass import JaxsimDataclass, Mutability
 
 try:
@@ -540,38 +539,48 @@ class ExplicitRungeKuttaSO3Mixin:
     `PyTreeType = ODEState` to integrate the quaternion on SO(3).
     """
 
+    @classmethod
+    def integrate_rk_stage(
+        cls, x0: js.ode_data.ODEState, t0: Time, dt: TimeStep, k: js.ode_data.ODEState
+    ) -> js.ode_data.ODEState:
+
+        op = lambda x0_leaf, k_leaf: x0_leaf + dt * k_leaf
+        xf: js.ode_data.ODEState = jax.tree_util.tree_map(op, x0, k)
+
+        W_Q_B_tf = xf.physics_model.base_quaternion
+
+        return xf.replace(
+            physics_model=xf.physics_model.replace(
+                base_quaternion=W_Q_B_tf / jnp.linalg.norm(W_Q_B_tf)
+            )
+        )
+
     @classmethod
     def post_process_state(
         cls, x0: js.ode_data.ODEState, t0: Time, xf: js.ode_data.ODEState, dt: TimeStep
     ) -> js.ode_data.ODEState:
 
-        # Extract the initial base quaternion.
-        W_Q_B_t0 = x0.physics_model.base_quaternion
+        # Indices to convert quaternions between serializations.
+        to_xyzw = jnp.array([1, 2, 3, 0])
 
-        # We assume that the initial quaternion is already unary.
-        exceptions.raise_runtime_error_if(
-            condition=jnp.logical_not(jnp.allclose(W_Q_B_t0.dot(W_Q_B_t0), 1.0)),
-            msg="The SO(3) integrator received a quaternion at t0 that is not unary.",
+        # Get the initial rotation.
+        W_R_B_t0 = jaxlie.SO3.from_quaternion_xyzw(
+            xyzw=x0.physics_model.base_quaternion[to_xyzw]
         )
 
-        # Get the angular velocity ω to integrate the quaternion.
-        # This velocity ω[t0] is computed in the previous timestep by averaging the kᵢ
-        # corresponding to the active RK-based scheme. Therefore, by using the ω[t0],
-        # we obtain an explicit RK scheme operating on the SO(3) manifold.
-        # Note that the current integrator is not a semi-implicit scheme, therefore
-        # using the final ω[tf] would be not correct.
-        W_ω_WB_t0 = x0.physics_model.base_angular_velocity
-
-        # Integrate the quaternion on SO(3).
-        W_Q_B_tf = jaxsim.math.Quaternion.integration(
-            quaternion=W_Q_B_t0,
-            dt=dt,
-            omega=W_ω_WB_t0,
-            omega_in_body_fixed=False,
-        )
+        # Get the final angular velocity.
+        # This is already computed by averaging the kᵢ in RK-based schemes.
+        # Therefore, by using the ω at tf, we obtain a RK scheme operating
+        # on the SO(3) manifold.
+        W_ω_WB_tf = xf.physics_model.base_angular_velocity
+
+        # Integrate the orientation on SO(3).
+        # Note that we left-multiply with the exponential map since the angular
+        # velocity is expressed in the inertial frame.
+        W_R_B_tf = jaxlie.SO3.exp(tangent=dt * W_ω_WB_tf) @ W_R_B_t0
 
         # Replace the quaternion in the final state.
         return xf.replace(
-            physics_model=xf.physics_model.replace(base_quaternion=W_Q_B_tf),
+            physics_model=xf.physics_model.replace(base_quaternion=W_R_B_tf.wxyz),
             validate=True,
         )

{jaxsim-0.4.1 → jaxsim-0.4.1.dev6}/src/jaxsim/mujoco/loaders.py

@@ -1,17 +1,12 @@
-from __future__ import annotations
-
 import dataclasses
 import pathlib
 import tempfile
 import warnings
-from typing import Any, Sequence
+from typing import Any
 
 import mujoco as mj
-import numpy as np
-import numpy.typing as npt
 import rod.urdf.exporter
 from lxml import etree as ET
-from scipy.spatial.transform import Rotation
 
 
 def load_rod_model(
@@ -165,13 +160,7 @@ class RodModelToMjcf:
         considered_joints: list[str] | None = None,
         plane_normal: tuple[float, float, float] = (0, 0, 1),
         heightmap: bool | None = None,
-        heightmap_samples_xy: tuple[int, int] = (101, 101),
-        cameras: (
-            MujocoCamera
-            | Sequence[MujocoCamera]
-            | dict[str, str]
-            | Sequence[dict[str, str]]
-        ) = (),
+        cameras: list[dict[str, str]] | dict[str, str] | None = None,
     ) -> tuple[str, dict[str, Any]]:
         """
         Converts a ROD model to a Mujoco MJCF string.
@@ -181,11 +170,10 @@ class RodModelToMjcf:
             considered_joints: The list of joint names to consider in the conversion.
             plane_normal: The normal vector of the plane.
             heightmap: Whether to generate a heightmap.
-            heightmap_samples_xy: The number of points in the heightmap grid.
-            cameras: The custom cameras to add to the scene.
+            cameras: The list of cameras to add to the scene.
 
         Returns:
-            A tuple containing the MJCF string and the dictionary of assets.
+            tuple: A tuple containing the MJCF string and the assets dictionary.
         """
 
         # -------------------------------------
@@ -260,6 +248,7 @@ class RodModelToMjcf:
 
         parser = ET.XMLParser(remove_blank_text=True)
         root: ET._Element = ET.fromstring(text=urdf_string.encode(), parser=parser)
+        import numpy as np
 
         # Give a tiny radius to all dummy spheres
         for geometry in root.findall(".//visual/geometry[sphere]"):
@@ -415,11 +404,9 @@ class RodModelToMjcf:
                 asset_element,
                 "hfield",
                 name="terrain",
-                nrow=f"{int(heightmap_samples_xy[0])}",
-                ncol=f"{int(heightmap_samples_xy[1])}",
-                # The following 'size' is a placeholder, it is updated dynamically
-                # when a hfield/heightmap is stored into MjData.
-                size="1 1 1 1",
+                nrow="100",
+                ncol="100",
+                size="5 5 1 1",
             )
             if heightmap
             else None
@@ -487,17 +474,14 @@ class RodModelToMjcf:
             fovy="60",
         )
 
-        # Add user-defined camera.
-        for camera in cameras if isinstance(cameras, Sequence) else [cameras]:
-
-            mj_camera = (
-                camera
-                if isinstance(camera, MujocoCamera)
-                else MujocoCamera.build(**camera)
+        # Add user-defined camera
+        cameras = cameras if cameras is not None else []
+        for camera in cameras if isinstance(cameras, list) else [cameras]:
+            mj_camera = MujocoCamera.build(**camera)
+            _ = ET.SubElement(
+                worldbody_element, "camera", dataclasses.asdict(mj_camera)
             )
 
-            _ = ET.SubElement(worldbody_element, "camera", mj_camera.asdict())
-
         # ------------------------------------------------
         # Add a light following the  CoM of the first link
         # ------------------------------------------------
@@ -610,114 +594,21 @@ class SdfToMjcf:
 
 @dataclasses.dataclass
 class MujocoCamera:
-    """
-    Helper class storing parameters of a Mujoco camera.
-
-    Refer to the official documentation for more details:
-    https://mujoco.readthedocs.io/en/stable/XMLreference.html#body-camera
-    """
-
-    mode: str = "fixed"
-
-    target: str | None = None
-    fovy: str = "45"
-    pos: str = "0 0 0"
-
-    quat: str | None = None
-    axisangle: str | None = None
-    xyaxes: str | None = None
-    zaxis: str | None = None
-    euler: str | None = None
-
-    name: str | None = None
+    name: str
+    mode: str
+    pos: str
+    xyaxes: str
+    fovy: str
 
     @classmethod
-    def build(cls, **kwargs) -> MujocoCamera:
-
+    def build(cls, **kwargs):
         if not all(isinstance(value, str) for value in kwargs.values()):
             raise ValueError("Values must be strings")
 
-        return cls(**kwargs)
-
-    @staticmethod
-    def build_from_target_view(
-        camera_name: str,
-        lookat: Sequence[float | int] | npt.NDArray = (0, 0, 0),
-        distance: float | int | npt.NDArray = 3,
-        azimut: float | int | npt.NDArray = 90,
-        elevation: float | int | npt.NDArray = -45,
-        fovy: float | int | npt.NDArray = 45,
-        degrees: bool = True,
-        **kwargs,
-    ) -> MujocoCamera:
-        """
-        Create a custom camera that looks at a target point.
-
-        Note:
-            The choice of the parameters is easier if we imagine to consider a target
-            frame `T` whose origin is located over the lookat point and having the same
-            orientation of the world frame `W`. We also introduce a camera frame `C`
-            whose origin is located over the lower-left corner of the image, and having
-            the x-axis pointing right and the y-axis pointing up in image coordinates.
-            The camera renders what it sees in the -z direction of frame `C`.
-
-        Args:
-            camera_name: The name of the camera.
-            lookat: The target point to look at (origin of `T`).
-            distance:
-                The distance from the target point (displacement between the origins
-                of `T` and `C`).
-            azimut:
-                The rotation around z of the camera. With an angle of 0, the camera
-                would loot at the target point towards the positive x-axis of `T`.
-            elevation:
-                The rotation around the x-axis of the camera frame `C`. Note that if
-                you want to lift the view angle, the elevation is negative.
-            fovy: The field of view of the camera.
-            degrees: Whether the angles are in degrees or radians.
-            **kwargs: Additional camera parameters.
+        if len(kwargs["pos"].split()) != 3:
+            raise ValueError("pos must have three values separated by space")
 
-        Returns:
-            The custom camera.
-        """
+        if len(kwargs["xyaxes"].split()) != 6:
+            raise ValueError("xyaxes must have six values separated by space")
 
-        # Start from a frame whose origin is located over the lookat point.
-        # We initialize a -90 degrees rotation around the z-axis because due to
-        # the default camera coordinate system (x pointing right, y pointing up).
-        W_H_C = np.eye(4)
-        W_H_C[0:3, 3] = np.array(lookat)
-        W_H_C[0:3, 0:3] = Rotation.from_euler(
-            seq="ZX", angles=[-90, 90], degrees=True
-        ).as_matrix()
-
-        # Process the azimut.
-        R_az = Rotation.from_euler(seq="Y", angles=azimut, degrees=degrees).as_matrix()
-        W_H_C[0:3, 0:3] = W_H_C[0:3, 0:3] @ R_az
-
-        # Process elevation.
-        R_el = Rotation.from_euler(
-            seq="X", angles=elevation, degrees=degrees
-        ).as_matrix()
-        W_H_C[0:3, 0:3] = W_H_C[0:3, 0:3] @ R_el
-
-        # Process distance.
-        tf_distance = np.eye(4)
-        tf_distance[2, 3] = distance
-        W_H_C = W_H_C @ tf_distance
-
-        # Extract the position and the quaternion.
-        p = W_H_C[0:3, 3]
-        Q = Rotation.from_matrix(W_H_C[0:3, 0:3]).as_quat(scalar_first=True)
-
-        return MujocoCamera.build(
-            name=camera_name,
-            mode="fixed",
-            fovy=f"{fovy if degrees else np.rad2deg(fovy)}",
-            pos=" ".join(p.astype(str).tolist()),
-            quat=" ".join(Q.astype(str).tolist()),
-            **kwargs,
-        )
-
-    def asdict(self) -> dict[str, str]:
-
-        return {k: v for k, v in dataclasses.asdict(self).items() if v is not None}
+        return cls(**kwargs)

{jaxsim-0.4.1 → jaxsim-0.4.1.dev6}/src/jaxsim/mujoco/model.py

@@ -7,7 +7,6 @@ from typing import Any, Callable
 import mujoco as mj
 import numpy as np
 import numpy.typing as npt
-import xmltodict
 from scipy.spatial.transform import Rotation
 
 import jaxsim.typing as jtp
@@ -43,27 +42,16 @@ class MujocoModelHelper:
         mjcf_description: str | pathlib.Path,
         assets: dict[str, Any] | None = None,
         heightmap: HeightmapCallable | None = None,
-        heightmap_name: str = "terrain",
-        heightmap_radius_xy: tuple[float, float] = (1.0, 1.0),
     ) -> MujocoModelHelper:
         """
-        Build a Mujoco model from an MJCF description.
+        Build a Mujoco model from an XML description and an optional assets dictionary.
 
         Args:
-            mjcf_description:
-                A string containing the XML description of the Mujoco model
+            mjcf_description: A string containing the XML description of the Mujoco model
                 or a path to a file containing the XML description.
             assets: An optional dictionary containing the assets of the model.
-            heightmap:
-                A function in two variables that returns the height of a terrain
+            heightmap: A function in two variables that returns the height of a terrain
                 in the specified coordinate point.
-            heightmap_name:
-                The default name of the heightmap in the MJCF description
-                to load the corresponding configuration.
-            heightmap_radius_xy:
-                The extension of the heightmap in the x-y surface corresponding to the
-                plane over which the grid of the sampled heightmap is generated.
-
         Returns:
             A MujocoModelHelper object.
         """
@@ -75,61 +63,15 @@ class MujocoModelHelper:
             else mjcf_description
         )
 
-        if heightmap is None:
-            hfield = None
-
-        else:
-
-            mjcf_description_dict = xmltodict.parse(xml_input=mjcf_description)
-
-            # Create a dictionary of all hfield configurations from the MJCF.
-            hfields = mjcf_description_dict["mujoco"]["asset"].get("hfield", [])
-            hfields = hfields if isinstance(hfields, list) else [hfields]
-            hfields_dict = {hfield["@name"]: hfield for hfield in hfields}
-
-            if heightmap_name not in hfields_dict:
-                raise ValueError(f"Heightmap '{heightmap_name}' not found in MJCF")
-
-            hfield_element = hfields_dict[heightmap_name]
-
-            # Generate the hfield by sampling the heightmap function.
-            hfield = generate_hfield(
-                heightmap=heightmap,
-                samples_xy=(int(hfield_element["@nrow"]), int(hfield_element["@ncol"])),
-                radius_xy=heightmap_radius_xy,
-            )
-
-            # Update dynamically the '/asset/hfield[@name=heightmap_name]@size' attribute
-            # with the information of the sampled points.
-            # This is necessary for correctly rendering the heightmap over the
-            # specified xy area with the correct z elevation.
-            size = [float(el) for el in hfield_element["@size"].split(" ")]
-            size[0], size[1] = heightmap_radius_xy
-            size[2] = 1.0
-            size[3] = max(0, -min(hfield))
-
-            # Replace the 'size' attribute.
-            hfields_dict[heightmap_name]["@size"] = " ".join(str(el) for el in size)
-
-            # Update the hfield elements of the original MJCF.
-            # Only the hfield corresponding to 'heightmap_name' was actually edited.
-            mjcf_description_dict["mujoco"]["asset"]["hfield"] = list(
-                hfields_dict.values()
-            )
-
-            # Serialize the updated MJCF to XML.
-            mjcf_description = xmltodict.unparse(
-                input_dict=mjcf_description_dict, pretty=True
-            )
-
-        # Create the Mujoco model from the XML and, optionally, the dictionary of assets.
+        # Create the Mujoco model from the XML and, optionally, the assets dictionary.
         model = mj.MjModel.from_xml_string(xml=mjcf_description, assets=assets)
         data = mj.MjData(model)
 
-        # Store the sampled heightmap into the Mujoco model.
-        if heightmap is not None:
-            assert hfield is not None
-            model.hfield_data = hfield
+        if heightmap:
+            nrow = model.hfield_nrow.item()
+            ncol = model.hfield_ncol.item()
+            new_hfield = generate_hfield(heightmap, (nrow, ncol))
+            model.hfield_data = new_hfield
 
         return MujocoModelHelper(model=model, data=data)
 
@@ -443,13 +385,10 @@ class MujocoModelHelper:
 
 
 def generate_hfield(
-    heightmap: HeightmapCallable,
-    samples_xy: tuple[int, int] = (11, 11),
-    radius_xy: tuple[float, float] = (1.0, 1.0),
+    heightmap: HeightmapCallable, size: tuple[int, int] = (10, 10)
 ) -> npt.NDArray:
     """
-    Generate an array with elevation points sampled from a heightmap function.
-
+    Generates a numpy array representing the heightmap of
     The map will have the following format:
     ```
     heightmap[0, 0] heightmap[0, 1] ... heightmap[0, size[1]-1]
@@ -459,22 +398,17 @@ def generate_hfield(
     ```
 
     Args:
-        heightmap:
-            A function that takes two arguments (x, y) and returns the height
+        heightmap: A function that takes two arguments (x, y) and returns the height
             at that point.
-        samples_xy: A tuple of two integers representing the size of the grid.
-        radius_xy:
-            A tuple of two floats representing extension of the heightmap in the
-            x-y surface corresponding to the area over which the grid of the sampled
-            heightmap is generated.
+        size: A tuple of two integers representing the size of the grid.
 
     Returns:
-        A flat array of the sampled terrain heightmap.
+        np.ndarray: The terrain heightmap
     """
 
     # Generate the grid.
-    x = np.linspace(-radius_xy[0], radius_xy[0], samples_xy[0])
-    y = np.linspace(-radius_xy[1], radius_xy[1], samples_xy[1])
+    x = np.linspace(0, 1, size[0])
+    y = np.linspace(0, 1, size[1])
 
     # Generate the heightmap.
     return np.array([[heightmap(xi, yi) for xi in x] for yi in y]).flatten()

{jaxsim-0.4.1 → jaxsim-0.4.1.dev6}/src/jaxsim/mujoco/visualizer.py

@@ -1,11 +1,10 @@
 import contextlib
 import pathlib
-from typing import ContextManager, Sequence
+from typing import ContextManager
 
 import mediapy as media
 import mujoco as mj
 import mujoco.viewer
-import numpy as np
 import numpy.typing as npt
 
 
@@ -63,16 +62,18 @@ class MujocoVideoRecorder:
         self.data = data if data is not None else self.data
         self.model = model if model is not None else self.model
 
-    def render_frame(self, camera_name: str = "track") -> npt.NDArray:
+    def render_frame(self, camera_name: str | None = None) -> npt.NDArray:
         """Renders a frame."""
+        camera_name = camera_name or "track"
 
         mujoco.mj_forward(self.model, self.data)
         self.renderer.update_scene(data=self.data, camera=camera_name)
 
         return self.renderer.render()
 
-    def record_frame(self, camera_name: str = "track") -> None:
+    def record_frame(self, camera_name: str | None = None) -> None:
         """Stores a frame in the buffer."""
+        camera_name = camera_name or "track"
 
         frame = self.render_frame(camera_name=camera_name)
         self.frames.append(frame)
@@ -166,72 +167,13 @@ class MujocoVisualizer:
         self,
         model: mj.MjModel | None = None,
         data: mj.MjData | None = None,
-        *,
         close_on_exit: bool = True,
-        lookat: Sequence[float | int] | npt.NDArray | None = None,
-        distance: float | int | npt.NDArray | None = None,
-        azimut: float | int | npt.NDArray | None = None,
-        elevation: float | int | npt.NDArray | None = None,
     ) -> ContextManager[mujoco.viewer.Handle]:
-        """
-        Context manager to open the Mujoco passive viewer.
-
-        Note:
-            Refer to the Mujoco documentation for details of the camera options:
-            https://mujoco.readthedocs.io/en/stable/XMLreference.html#visual-global
-        """
+        """Context manager to open a viewer."""
 
         handle = self.open_viewer(model=model, data=data)
 
-        handle = MujocoVisualizer.setup_viewer_camera(
-            viewer=handle,
-            lookat=lookat,
-            distance=distance,
-            azimut=azimut,
-            elevation=elevation,
-        )
-
         try:
             yield handle
         finally:
             _ = handle.close() if close_on_exit else None
-
-    @staticmethod
-    def setup_viewer_camera(
-        viewer: mj.viewer.Handle,
-        *,
-        lookat: Sequence[float | int] | npt.NDArray | None,
-        distance: float | int | npt.NDArray | None = None,
-        azimut: float | int | npt.NDArray | None = None,
-        elevation: float | int | npt.NDArray | None = None,
-    ) -> mj.viewer.Handle:
-        """
-        Configure the initial viewpoint of the Mujoco passive viewer.
-
-        Note:
-            Refer to the Mujoco documentation for details of the camera options:
-            https://mujoco.readthedocs.io/en/stable/XMLreference.html#visual-global
-
-        Returns:
-            The viewer with configured camera.
-        """
-
-        if lookat is not None:
-
-            lookat_array = np.array(lookat, dtype=float).squeeze()
-
-            if lookat_array.size != 3:
-                raise ValueError(lookat)
-
-            viewer.cam.lookat = lookat_array
-
-        if distance is not None:
-            viewer.cam.distance = float(distance)
-
-        if azimut is not None:
-            viewer.cam.azimuth = float(azimut) % 360
-
-        if elevation is not None:
-            viewer.cam.elevation = float(elevation)
-
-        return viewer

{jaxsim-0.4.1 → jaxsim-0.4.1.dev6}/src/jaxsim/rbda/utils.py

@@ -2,7 +2,6 @@ import jax.numpy as jnp
 
 import jaxsim.api as js
 import jaxsim.typing as jtp
-from jaxsim import exceptions
 from jaxsim.math import StandardGravity
 
 
@@ -132,13 +131,6 @@ def process_inputs(
     if W_Q_B.shape != (4,):
         raise ValueError(W_Q_B.shape, (4,))
 
-    # Check that the quaternion is unary since our RBDAs make this assumption in order
-    # to prevent introducing additional normalizations that would affect AD.
-    exceptions.raise_value_error_if(
-        condition=jnp.logical_not(jnp.allclose(W_Q_B.dot(W_Q_B), 1.0)),
-        msg="A RBDA received a quaternion that is not normalized.",
-    )
-
     # Pack the 6D base velocity and acceleration.
     W_v_WB = jnp.hstack([W_vl_WB, W_ω_WB])
     W_v̇_WB = jnp.hstack([W_v̇l_WB, W_ω̇_WB])

{jaxsim-0.4.1 → jaxsim-0.4.1.dev6}/src/jaxsim/terrain/terrain.py

@@ -73,7 +73,7 @@ class FlatTerrain(Terrain):
 class PlaneTerrain(FlatTerrain):
 
     plane_normal: tuple[float, float, float] = jax_dataclasses.field(
-        default=(0.0, 0.0, 1.0), kw_only=True
+        default=(0.0, 0.0, 0.0), kw_only=True
     )
 
     @staticmethod

{jaxsim-0.4.1 → jaxsim-0.4.1.dev6}/src/jaxsim.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaxsim
-Version: 0.4.1
+Version: 0.4.1.dev6
 Summary: A differentiable physics engine and multibody dynamics library for control and robot learning.
 Author-email: Diego Ferigo <dgferigo@gmail.com>
 Maintainer-email: Diego Ferigo <dgferigo@gmail.com>, Filippo Luca Ferretti <filippo.ferretti@iit.it>
@@ -80,7 +80,6 @@ Provides-Extra: viz
 Requires-Dist: lxml; extra == "viz"
 Requires-Dist: mediapy; extra == "viz"
 Requires-Dist: mujoco>=3.0.0; extra == "viz"
-Requires-Dist: scipy>=1.14.0; extra == "viz"
 Provides-Extra: all
 Requires-Dist: jaxsim[style,testing,viz]; extra == "all"
 

{jaxsim-0.4.1 → jaxsim-0.4.1.dev6}/src/jaxsim.egg-info/requires.txt

@@ -27,4 +27,3 @@ robot-descriptions
 lxml
 mediapy
 mujoco>=3.0.0
-scipy>=1.14.0

{jaxsim-0.4.1 → jaxsim-0.4.1.dev6}/tests/test_automatic_differentiation.py

@@ -93,7 +93,7 @@ def test_ad_aba(
     aba = lambda W_p_B, W_Q_B, s, W_v_WB, ṡ, τ, W_f_L, g: jaxsim.rbda.aba(
         model=model,
         base_position=W_p_B,
-        base_quaternion=W_Q_B / jnp.linalg.norm(W_Q_B),
+        base_quaternion=W_Q_B,
         joint_positions=s,
         base_linear_velocity=W_v_WB[0:3],
         base_angular_velocity=W_v_WB[3:6],
@@ -150,7 +150,7 @@ def test_ad_rnea(
     rnea = lambda W_p_B, W_Q_B, s, W_v_WB, ṡ, W_v̇_WB, s̈, W_f_L, g: jaxsim.rbda.rnea(
         model=model,
         base_position=W_p_B,
-        base_quaternion=W_Q_B / jnp.linalg.norm(W_Q_B),
+        base_quaternion=W_Q_B,
         joint_positions=s,
         base_linear_velocity=W_v_WB[0:3],
         base_angular_velocity=W_v_WB[3:6],
@@ -229,7 +229,7 @@ def test_ad_fk(
     fk = lambda W_p_B, W_Q_B, s: jaxsim.rbda.forward_kinematics_model(
         model=model,
         base_position=W_p_B,
-        base_quaternion=W_Q_B / jnp.linalg.norm(W_Q_B),
+        base_quaternion=W_Q_B,
         joint_positions=s,
     )
 

{jaxsim-0.4.1 → jaxsim-0.4.1.dev6}/tests/test_simulations.py

@@ -6,7 +6,7 @@ import jaxsim.api as js
 import jaxsim.integrators
 import jaxsim.rbda
 from jaxsim import VelRepr
-from jaxsim.utils import Mutability
+from jaxsim.rbda.contacts.soft import SoftContactsParams
 
 
 def test_box_with_external_forces(
@@ -102,19 +102,23 @@ def test_box_with_zero_gravity(
 
     model = jaxsim_model_box
 
-    # Move the terrain (almost) infinitely far away from the box.
-    with model.mutable_context(mutability=Mutability.MUTABLE_NO_VALIDATION):
-        model.terrain = jaxsim.terrain.FlatTerrain.build(height=-1e9)
-
     # Split the PRNG key.
-    _, subkey = jax.random.split(prng_key, num=2)
+    _, subkey, subkey2 = jax.random.split(prng_key, num=3)
 
     # Build the data of the model.
     data0 = js.data.JaxSimModelData.build(
         model=model,
-        base_position=jax.random.uniform(subkey, shape=(3,)),
+        base_position=jax.random.uniform(subkey2, shape=(3,)),
         velocity_representation=velocity_representation,
         standard_gravity=0.0,
+        contacts_params=SoftContactsParams.build(K=0.0, D=0.0, mu=0.0),
+    )
+
+    # Generate a random linear force.
+    L_f = (
+        jax.random.uniform(subkey, shape=(model.number_of_links(), 6))
+        .at[:, 3:]
+        .set(jnp.zeros(3))
     )
 
     # Initialize a references object that simplifies handling external forces.
@@ -125,29 +129,13 @@ def test_box_with_zero_gravity(
     )
 
     # Apply a link forces to the base link.
-    with references.switch_velocity_representation(jaxsim.VelRepr.Mixed):
-
-        # Generate a random linear force.
-        # We enforce them to be the same for all velocity representations so that
-        # we can compare their outcomes.
-        LW_f = 10.0 * (
-            jax.random.uniform(jax.random.key(0), shape=(model.number_of_links(), 6))
-            .at[:, 3:]
-            .set(jnp.zeros(3))
-        )
-
-        # Note that the context manager does not switch back the newly created
-        # `references` (that is not the yielded object) to the original representation.
-        # In the simulation loop below, we need to make sure that we switch both `data`
-        # and `references` to the same representation before extracting the information
-        # passed to the step function.
-        references = references.apply_link_forces(
-            forces=jnp.atleast_2d(LW_f),
-            link_names=model.link_names(),
-            model=model,
-            data=data0,
-            additive=False,
-        )
+    references = references.apply_link_forces(
+        forces=jnp.atleast_2d(L_f),
+        link_names=model.link_names(),
+        model=model,
+        data=data0,
+        additive=False,
+    )
 
     # Create the integrator.
     integrator = jaxsim.integrators.fixed_step.RungeKutta4SO3.build(
@@ -157,7 +145,8 @@ def test_box_with_zero_gravity(
     )
 
     # Initialize the integrator.
-    tf, dt = 1.0, 0.010
+    tf = 1.0
+    dt = 0.010
     T = jnp.arange(start=0, stop=tf * 1e9, step=dt * 1e9, dtype=int)
     integrator_state = integrator.init(x0=data0.state, t0=0.0, dt=dt)
 
@@ -167,28 +156,19 @@ def test_box_with_zero_gravity(
     # ... and step the simulation.
     for t_ns in T:
 
-        assert data.time() == t_ns / 1e9
-
-        with (
-            data.switch_velocity_representation(velocity_representation),
-            references.switch_velocity_representation(velocity_representation),
-        ):
-
-            data, integrator_state = js.model.step(
-                model=model,
-                data=data,
-                dt=dt,
-                integrator=integrator,
-                integrator_state=integrator_state,
-                link_forces=references.link_forces(model=model, data=data),
-            )
-
-    # Check the final simulation time.
-    assert data.time() == T[-1] / 1e9 + dt
+        data, integrator_state = js.model.step(
+            model=model,
+            data=data,
+            dt=dt,
+            integrator=integrator,
+            integrator_state=integrator_state,
+            link_forces=references.link_forces(model=model, data=data),
+        )
 
     # Check that the box moved as expected.
+    assert data.time() == t_ns / 1e9 + dt
     assert data.base_position() == pytest.approx(
         data0.base_position()
-        + 0.5 * LW_f[:, :3].squeeze() / js.model.total_mass(model=model) * tf**2,
+        + 0.5 * L_f[:, :3].squeeze() / js.model.total_mass(model=model) * tf**2,
         abs=1e-3,
     )