roboticstoolbox-python 1.4.0__py3-none-any.whl → 1.4.2__py3-none-any.whl

roboticstoolbox/__init__.py

@@ -61,6 +61,9 @@ __all__ = [
     "rtb_path_to_datafile",
     "rtb_set_param",
     "rtb_get_param",
+    "TrChainToken",
+    "trchain",
+    "trchain2",
     # mobile
     "VehicleBase",
     "Bicycle",

roboticstoolbox/backends/PyPlot/PyPlot.py

@@ -512,7 +512,8 @@ class PyPlot(Connector):
 
         # render the frame and save as a PIL image in the list
         canvas = self.fig.canvas
-        return _pil("RGB", canvas.get_width_height(), canvas.tostring_rgb())
+        image = _pil("RGBA", canvas.get_width_height(), bytes(canvas.buffer_rgba()))
+        return image.convert("RGB")
 
     def _push_inline_frame(self):
         # Push a snapshot into notebook output for inline animation.

roboticstoolbox/backends/PyPlot/RobotPlot.py

@@ -74,7 +74,15 @@ class RobotPlot:
 
         if options is not None:
             for key, value in options.items():
-                defaults[key] = {**defaults[key], **options[key]}
+                # Most options (colors, linewidths) are per-artefact dicts to
+                # merge with the default; a few (jointaxislength, eelength)
+                # are plain scalars to override outright -- **-unpacking a
+                # float raises TypeError, so only merge when both sides are
+                # dicts.
+                if isinstance(defaults.get(key), dict) and isinstance(value, dict):
+                    defaults[key] = {**defaults[key], **value}
+                else:
+                    defaults[key] = value
         self.options = defaults
 
     def draw(self):

roboticstoolbox/backends/PyPlot/RobotPlot2.py

@@ -35,7 +35,12 @@ class RobotPlot2(RobotPlot):
 
         if options is not None:
             for key, value in options.items():
-                defaults[key] = {**defaults[key], **options[key]}
+                # See RobotPlot.__init__'s comment: eelength is a plain
+                # scalar to override outright, not a dict to merge.
+                if isinstance(defaults.get(key), dict) and isinstance(value, dict):
+                    defaults[key] = {**defaults[key], **value}
+                else:
+                    defaults[key] = value
         self.options = defaults
 
     def draw(self):

roboticstoolbox/blocks/arm.py

@@ -1528,30 +1528,32 @@ class FDyn_X(ContinuousBlock):
             q0 = smb.getvector(q0, robot.n)
         # append qd0, assumed to be zero
         self._x0 = np.r_[q0, np.zeros((robot.n,))]
-        self._qdd = None
+        # Zero-acceleration placeholder for xdd until deriv() has run at
+        # least once. output() must not compute this itself: bdsim calls a
+        # continuous block's output() wherever the compute graph needs its
+        # *state*-derived ports (q, qd, x, xd here), which can happen before
+        # this block's own input is resolved -- notably here, where w
+        # (this block's input) is itself downstream of xd (this block's
+        # output) via the force-control feedback path in opspace.py. deriv()
+        # doesn't have that problem: the integrator only calls it with a
+        # genuinely resolved input. See petercorke/bdsim#81 for the general
+        # case (stateful blocks whose output() needs a resolved input).
+        self._qdd = np.zeros((robot.n,))
 
     def output(self, t, inports, x):
         n = self.robot.n
         q = x[:n]
         qd = x[n:]
-        qdd = self._qdd  # from last deriv
+        qdd = self._qdd  # cached from the last deriv() call, or the zero placeholder
 
         T = self.robot.fkine(q)
         x = smb.tr2x(T.A)
 
         Ja = self.robot.jacob0_analytical(q, self.representation)
         xd = Ja @ qd
-        # print(q)
-        # print(qd)
-        # print(xd)
-        # print(Ja)
-        # print()
-
-        if qdd is None:
-            xdd = None
-        else:
-            Ja_dot = self.robot.jacob0_dot(q, qd, J0=Ja)
-            xdd = Ja @ qdd + Ja_dot @ qd
+
+        Ja_dot = self.robot.jacob0_dot(q, qd, J0=Ja)
+        xdd = Ja @ qdd + Ja_dot @ qd
 
         return [q, qd, x, xd, xdd]
 

roboticstoolbox/ets/ETS.py

@@ -23,7 +23,7 @@ from spatialmath.base import (
     getmatrix,
 )
 from roboticstoolbox.tools.params import rtb_get_param
-from roboticstoolbox.robot.IK import IK_GN, IK_LM, IK_NR, IK_QP
+from roboticstoolbox.robot.IK import IK_GN, IK_LM, IK_NR, IK_QP, IKSolution
 
 from roboticstoolbox.ets.fknm import (
     ETS_init,
@@ -325,10 +325,17 @@ class ETS(BaseETS):
         """
         Forward kinematics (returns raw ndarray)
 
-        :param q: Joint coordinates
+        :param q: Joint coordinates -- either *global* (length
+            ``max(self.jindices) + 1``, addressed by each joint's own
+            ``jindex``) or *compact* (length ``self.n``, positionally
+            ordered to match :meth:`joints`). These only differ when this
+            ETS is one branch of a larger, branched robot -- e.g. it's what
+            ``ikine_LM``/``ik_LM`` return when solving for just this ETS.
+            For a whole, unbranched robot the two coincide.
         :param base: a base transform applied before the ETS
         :param tool: tool transform, optional
         :param include_base: set to True if the base transform should be considered
+        :raises ValueError: if ``q``'s length matches neither interpretation
         :returns: the transformation matrix representing the pose of the end-effector
         :rtype: ndarray(4,4) or ndarray(m,4,4)
 
@@ -360,6 +367,7 @@ class ETS(BaseETS):
 
         """
 
+        q = self._resolve_q(q, allow_trajectory=True)
         return ETS_fkine(self._fknm, q, base, tool, include_base, _data=self.data)
 
     def jacob0(
@@ -407,6 +415,7 @@ class ETS(BaseETS):
 
         """
 
+        q = self._resolve_q(q)
         return ETS_jacob0(self._fknm, q, tool, _data=self.data, _n=self.n)
 
     def jacobe(
@@ -454,6 +463,7 @@ class ETS(BaseETS):
 
         """
 
+        q = self._resolve_q(q)
         return ETS_jacobe(self._fknm, q, tool, _data=self.data, _n=self.n)
 
     def hessian0(
@@ -523,6 +533,8 @@ class ETS(BaseETS):
 
         """
 
+        if q is not None:
+            q = self._resolve_q(q)
         return ETS_hessian0(self._fknm, q, J0, tool, _data=self.data, _n=self.n)
 
     def hessiane(
@@ -592,6 +604,8 @@ class ETS(BaseETS):
 
         """
 
+        if q is not None:
+            q = self._resolve_q(q)
         return ETS_hessiane(self._fknm, q, Je, tool, _data=self.data, _n=self.n)
 
     def jacob0_analytical(
@@ -1000,7 +1014,7 @@ class ETS(BaseETS):
         joint_limits: bool = True,
         k: float = 1.0,
         method: L["chan", "wampler", "sugihara"] = "chan",
-    ) -> tuple[NDArray, int, int, int, float]:
+    ) -> IKSolution:
         r"""
         Fast Levenberg-Marquardt numerical inverse kinematics solver
 
@@ -1013,8 +1027,18 @@ class ETS(BaseETS):
         :param joint_limits: reject solutions with joint limit violations
         :param k: gain value for the damping matrix Wn
         :param method: one of ``"chan"`` (default), ``"sugihara"`` or ``"wampler"``
-        :returns: tuple (q, success, iterations, searches, residual)
-        :rtype: tuple
+        :returns: an IKSolution containing joint coordinates ``q``, ``success`` flag,
+            ``iterations``, ``searches`` and ``residual`` error value (``reason`` is
+            always empty -- this fast C++ solver doesn't produce a granular failure
+            reason string, unlike :meth:`ikine_LM`)
+        :rtype: IKSolution
+
+        .. warning::
+
+            This method requires the compiled C++ extension. It raises
+            ``RuntimeError`` if that extension is unavailable, e.g. in a
+            pure-Python build/wheel or under Pyodide/JupyterLite. Use
+            :meth:`ikine_LM` instead in those environments.
 
         A method which provides functionality to perform numerical inverse kinematics (IK)
         using the Levenberg-Marquardt method. This is a fast solver implemented in C++.
@@ -1024,7 +1048,7 @@ class ETS(BaseETS):
 
         The operation is defined by the choice of the ``method`` kwarg.
 
-        The step is deined as
+        The step is defined as
 
         .. math::
 
@@ -1112,16 +1136,23 @@ class ETS(BaseETS):
         - J. Haviland, and P. Corke. "Manipulator Differential Kinematics Part II:
           Acceleration and Advanced Applications." arXiv preprint arXiv:2207.01794 (2022).
 
-        .. seealso:: :meth:`ik_NR` :meth:`ik_GN`
+        .. seealso:: :meth:`ik_NR` :meth:`ik_GN` :meth:`ikine_LM`
 
         .. versionchanged:: 1.0.4
             Merged the Levenberg-Marquardt IK solvers into the ik_LM method
 
         """
 
-        return IK_LM_c(
+        q, success, iterations, searches, residual = IK_LM_c(
             self._fknm, Tep, q0, ilimit, slimit, tol, joint_limits, mask, k, method
         )
+        return IKSolution(
+            q=q,
+            success=bool(success),
+            iterations=iterations,
+            searches=searches,
+            residual=residual,
+        )
 
     def ik_NR(
         self,
@@ -1134,7 +1165,7 @@ class ETS(BaseETS):
         joint_limits: bool = True,
         pinv: int = True,
         pinv_damping: float = 0.0,
-    ) -> tuple[NDArray, int, int, int, float]:
+    ) -> IKSolution:
         r"""
         Fast numerical inverse kinematics using Newton-Raphson optimisation
 
@@ -1147,8 +1178,18 @@ class ETS(BaseETS):
         :param joint_limits: reject solutions with invalid joint configurations
         :param pinv: use the pseudo-inverse instead of the normal matrix inverse
         :param pinv_damping: damping factor for the pseudo-inverse
-        :returns: tuple (q, success, iterations, searches, residual)
-        :rtype: tuple
+        :returns: an IKSolution containing joint coordinates ``q``, ``success`` flag,
+            ``iterations``, ``searches`` and ``residual`` error value (``reason`` is
+            always empty -- this fast C++ solver doesn't produce a granular failure
+            reason string, unlike :meth:`ikine_NR`)
+        :rtype: IKSolution
+
+        .. warning::
+
+            This method requires the compiled C++ extension. It raises
+            ``RuntimeError`` if that extension is unavailable, e.g. in a
+            pure-Python build/wheel or under Pyodide/JupyterLite. Use
+            :meth:`ikine_NR` instead in those environments.
 
         ``sol = ets.ik_NR(Tep)`` are the joint coordinates (n) corresponding
         to the robot end-effector pose ``Tep`` which is an ``SE3`` or ``ndarray`` object.
@@ -1195,11 +1236,11 @@ class ETS(BaseETS):
         - J. Haviland, and P. Corke. "Manipulator Differential Kinematics Part II:
           Acceleration and Advanced Applications." arXiv preprint arXiv:2207.01794 (2022).
 
-        .. seealso:: :meth:`ik_LM` :meth:`ik_GN`
+        .. seealso:: :meth:`ik_LM` :meth:`ik_GN` :meth:`ikine_NR`
 
         """
 
-        return IK_NR_c(
+        q, success, iterations, searches, residual = IK_NR_c(
             self._fknm,
             Tep,
             q0,
@@ -1211,6 +1252,13 @@ class ETS(BaseETS):
             pinv,
             pinv_damping,
         )
+        return IKSolution(
+            q=q,
+            success=bool(success),
+            iterations=iterations,
+            searches=searches,
+            residual=residual,
+        )
 
     def ik_GN(
         self,
@@ -1223,7 +1271,7 @@ class ETS(BaseETS):
         joint_limits: bool = True,
         pinv: int = True,
         pinv_damping: float = 0.0,
-    ) -> tuple[NDArray, int, int, int, float]:
+    ) -> IKSolution:
         r"""
         Fast numerical inverse kinematics by Gauss-Newton optimisation
 
@@ -1299,11 +1347,11 @@ class ETS(BaseETS):
         - J. Haviland, and P. Corke. "Manipulator Differential Kinematics Part II:
           Acceleration and Advanced Applications." arXiv preprint arXiv:2207.01794 (2022).
 
-        .. seealso:: :meth:`ik_LM` :meth:`ik_NR`
+        .. seealso:: :meth:`ik_LM` :meth:`ik_NR` :meth:`ikine_GN`
 
         """
 
-        return IK_GN_c(
+        q, success, iterations, searches, residual = IK_GN_c(
             self._fknm,
             Tep,
             q0,
@@ -1315,6 +1363,13 @@ class ETS(BaseETS):
             pinv,
             pinv_damping,
         )
+        return IKSolution(
+            q=q,
+            success=bool(success),
+            iterations=iterations,
+            searches=searches,
+            residual=residual,
+        )
 
     def ikine_LM(
         self,
@@ -1351,7 +1406,10 @@ class ETS(BaseETS):
         :param km: gain for manipulability maximisation (0.0 disables)
         :param ps: minimum joint approach distance to limit (radians or metres)
         :param pi: null-space influence distance (radians or metres)
-        :returns: IK solution
+        :returns: an IKSolution containing joint coordinates ``q``, ``success`` flag,
+            ``iterations``, ``searches``, ``residual`` error value, and ``reason``
+            string if applicable
+        :rtype: IKSolution
 
         A method which provides functionality to perform numerical inverse kinematics (IK)
         using the Levenberg-Marquardt method.
@@ -1449,7 +1507,7 @@ class ETS(BaseETS):
         - J. Haviland, and P. Corke. "Manipulator Differential Kinematics Part II:
           Acceleration and Advanced Applications." arXiv preprint arXiv:2207.01794 (2022).
 
-        .. seealso:: :meth:`ikine_NR` :meth:`ikine_GN` :meth:`ikine_QP`
+        .. seealso:: :meth:`ikine_NR` :meth:`ikine_GN` :meth:`ikine_QP` :meth:`ik_LM`
 
         .. versionchanged:: 1.0.4
             Added the Levenberg-Marquardt IK solver method on the `ETS` class
@@ -1510,7 +1568,10 @@ class ETS(BaseETS):
         :param km: gain for manipulability maximisation (0.0 disables)
         :param ps: minimum joint approach distance to limit (radians or metres)
         :param pi: null-space influence distance (radians or metres)
-        :returns: IK solution
+        :returns: an IKSolution containing joint coordinates ``q``, ``success`` flag,
+            ``iterations``, ``searches``, ``residual`` error value, and ``reason``
+            string if applicable
+        :rtype: IKSolution
 
         A method which provides functionality to perform numerical inverse kinematics (IK)
         using the Newton-Raphson method.
@@ -1554,7 +1615,7 @@ class ETS(BaseETS):
         - J. Haviland, and P. Corke. "Manipulator Differential Kinematics Part II:
           Acceleration and Advanced Applications." arXiv preprint arXiv:2207.01794 (2022).
 
-        .. seealso:: :meth:`ikine_LM` :meth:`ikine_GN` :meth:`ikine_QP`
+        .. seealso:: :meth:`ikine_LM` :meth:`ikine_GN` :meth:`ikine_QP` :meth:`ik_NR`
 
         .. versionchanged:: 1.0.4
             Added the Newton-Raphson IK solver method on the `ETS` class
@@ -1614,7 +1675,10 @@ class ETS(BaseETS):
         :param km: gain for manipulability maximisation (0.0 disables)
         :param ps: minimum joint approach distance to limit (radians or metres)
         :param pi: null-space influence distance (radians or metres)
-        :returns: IK solution
+        :returns: an IKSolution containing joint coordinates ``q``, ``success`` flag,
+            ``iterations``, ``searches``, ``residual`` error value, and ``reason``
+            string if applicable
+        :rtype: IKSolution
 
         A method which provides functionality to perform numerical inverse kinematics (IK)
         using the Gauss-Newton method.
@@ -1673,7 +1737,7 @@ class ETS(BaseETS):
         - J. Haviland, and P. Corke. "Manipulator Differential Kinematics Part II:
           Acceleration and Advanced Applications." arXiv preprint arXiv:2207.01794 (2022).
 
-        .. seealso:: :meth:`ikine_LM` :meth:`ikine_NR` :meth:`ikine_QP`
+        .. seealso:: :meth:`ikine_LM` :meth:`ikine_NR` :meth:`ikine_QP` :meth:`ik_GN`
 
         .. versionchanged:: 1.0.4
             Added the Gauss-Newton IK solver method on the `ETS` class
@@ -1735,7 +1799,10 @@ class ETS(BaseETS):
         :param km: gain for manipulability maximisation (0.0 disables)
         :param ps: minimum joint approach distance to limit (radians or metres)
         :param pi: null-space influence distance (radians or metres)
-        :returns: IK solution
+        :returns: an IKSolution containing joint coordinates ``q``, ``success`` flag,
+            ``iterations``, ``searches``, ``residual`` error value, and ``reason``
+            string if applicable
+        :rtype: IKSolution
         :raises ImportError: if the package ``qpsolvers`` is not installed
 
         A method that provides functionality to perform numerical inverse kinematics

roboticstoolbox/ets/ETS2.py

@@ -309,7 +309,7 @@ class ETS2(BaseETS):
         - Kinematic Derivatives using the Elementary Transform Sequence, J. Haviland and P. Corke
         """
 
-        q = getmatrix(q, (None, None))
+        q = self._resolve_q(q, allow_trajectory=True)
         l, _ = q.shape  # type: ignore
         end = self[-1]
 
@@ -375,8 +375,6 @@ class ETS2(BaseETS):
     ) -> NDArray:
         # very inefficient implementation, just put a 1 in last row
         # if its a rotation joint
-        q = getvector(q)
-
         j = 0
         J = np.zeros((3, self.n))
         etjoints = self.joint_idx()
@@ -386,6 +384,9 @@ class ETS2(BaseETS):
             for j in range(self.n):
                 i = etjoints[j]
                 self[i].jindex = j
+            self.__dict__.pop("jindices", None)  # invalidate cached_property
+
+        q = self._resolve_q(q)
 
         for j in range(self.n):
             i = etjoints[j]

roboticstoolbox/ets/_ETS.py

@@ -399,6 +399,78 @@ class BaseETS(MutableSequence):
 
         return np.array([j.jindex for j in self.joints()])  # type: ignore
 
+    def _resolve_q(self, q: ArrayLike, allow_trajectory: bool = False) -> NDArray:
+        """
+        Resolve q to a full jindex-addressed vector
+
+        :param q: joint coordinates, either *compact* (length :attr:`n`,
+            positionally ordered to match this ETS's own :meth:`joints`) or
+            *global* (length ``max(jindices) + 1``, addressed by each
+            joint's global ``jindex`` -- e.g. the whole robot's ``q`` on a
+            branched robot, when this ETS is only one branch of it)
+        :param allow_trajectory: if True, ``q`` is normalised with
+            :func:`getmatrix` (preserving a genuine ``(m, n)`` trajectory's
+            row count, matching :meth:`eval`'s own convention); if False,
+            ``q`` is flattened with :func:`getvector` first, matching
+            :meth:`jacob0`/:meth:`jacobe`/:meth:`hessian0`/:meth:`hessiane`,
+            none of which accept a trajectory
+        :raises TypeError: if ``q`` isn't numeric (from :func:`getvector`)
+        :raises ValueError: if ``q``'s length matches neither interpretation
+        :returns: a global jindex-addressed array; unchanged if ``q`` was
+            already global, scattered via :attr:`jindices` if ``q`` was
+            compact
+
+        This is the single place that disambiguates the two ``q`` shapes
+        accepted by :meth:`eval`, :meth:`jacob0`, :meth:`jacobe`,
+        :meth:`hessian0` and :meth:`hessiane` -- everything downstream of
+        this (the C++ extension and the pure-Python fallback) only ever
+        sees a global, jindex-addressed vector, exactly as before this
+        method existed.
+
+        Checking the compact length first means the common case -- a
+        single-chain robot, or any ETS whose own joints already happen to
+        carry global jindex 0..n-1 in order -- is unaffected: scattering
+        via :attr:`jindices` is then just the identity.
+        """
+        n = self.n
+        jindices = self.jindices
+
+        q = getmatrix(q, (None, None)) if allow_trajectory else getvector(q, None)
+
+        if n == 0 or jindices.dtype == object:
+            # no joints, or at least one joint has no jindex assigned yet
+            # (e.g. an ETS2 instance before its lazy auto-assignment runs)
+            # -- nothing to safely disambiguate, leave q exactly as given
+            return q
+
+        global_len = int(jindices.max()) + 1
+        length = q.shape[-1]
+
+        if length == n and n < global_len:
+            # a genuine sub-chain (this ETS's own joints don't span the
+            # full global jindex range) -- scatter positionally
+            full = np.zeros(q.shape[:-1] + (global_len,), dtype=q.dtype)
+            full[..., jindices] = q
+            return full
+
+        if length >= global_len:
+            # already global-addressed; longer-than-needed is accepted
+            # (matches the pre-existing convention of indexing q by
+            # jindex and ignoring unused trailing entries). This also
+            # covers n == global_len, where compact and global lengths
+            # coincide -- always treating that as global (not scattering)
+            # matters when this ETS's own joints don't carry jindex in
+            # increasing order (e.g. a reversed chain from .inv()), where
+            # scattering would silently reorder q instead of leaving it
+            # alone.
+            return q
+
+        raise ValueError(
+            f"q has length {length}, expected {n} (compact, positionally "
+            f"matching this ETS's own joint order) or at least {global_len} "
+            f"(global, addressed by jindex -- e.g. the whole robot's q)"
+        )
+
     @property
     def qlim(self):
         r"""

roboticstoolbox/ets/cpp-extensions/ik.cpp

@@ -7,9 +7,13 @@
 
 #include <Python.h>
 #include <math.h>
+#include <cmath>
 #include <iostream>
 #include <functional>
 #include <Eigen/Dense>
+#include <nanobind/nanobind.h>
+
+namespace nb = nanobind;
 
 // ---------------------------------------------------------------------------
 // Shared loop kernel — all five IK solvers use this.
@@ -290,6 +294,19 @@ extern "C"
         Eigen::Map<Eigen::ArrayXd> qlim_l(ets->qlim_l, ets->n);
         Eigen::Map<Eigen::ArrayXd> q_range2(ets->q_range2, ets->n);
 
+        // A joint with a non-finite limit (inf/-inf/NaN, typically a bad
+        // value baked into a robot model's own joint-limit data) would
+        // otherwise silently propagate inf/NaN into q below, with no
+        // diagnostic at all -- mirrors the equivalent check in the
+        // pure-Python solver path (IK.py's _random_q()).
+        for (int i = 0; i < ets->n; i++)
+        {
+            if (!std::isfinite(qlim_l(i)) || !std::isfinite(q_range2(i)))
+                throw nb::value_error(
+                    "Joint limit(s) are not finite -- can't generate a "
+                    "random configuration within an infinite/undefined range.");
+        }
+
         q = VectorX::Random(ets->n);
 
         q = (q.array() + 1) * q_range2;

roboticstoolbox/mobile/DistanceTransformPlanner.py

@@ -9,7 +9,7 @@ from spatialmath.pose2d import SE2
 from spatialmath import base
 from scipy.ndimage import *
 import matplotlib.pyplot as plt
-from matplotlib import cm
+from matplotlib import colormaps
 from roboticstoolbox.mobile.PlannerBase import PlannerBase
 
 
@@ -163,7 +163,7 @@ class DistanceTransformPlanner(PlannerBase):
                 [0, -1],
                 [1, -1],
                 [-1, 0],
-                [0, 0],
+                [-1, 1],
                 [1, 0],
                 [0, 1],
                 [1, 1],
@@ -324,9 +324,7 @@ def distancexform(occgrid, goal, metric="cityblock", animate=False, summary=Fals
                 plt.ylabel("y")
                 ax = plt.gca()
                 plt.pause(0.001)
-                cmap = cm.get_cmap("gray")
-                cmap.set_bad("red")
-                cmap.set_over("white")
+                cmap = colormaps.get_cmap("gray").with_extremes(bad="red", over="white")
                 h = plt.imshow(display, cmap=cmap)
                 plt.colorbar(label="distance")
             else:

roboticstoolbox/models/URDF/URDFRobot.py

@@ -90,6 +90,31 @@ def _load_rd_module(robot_name: str):
             "URDF model."
         )
 
+    # robot_descriptions clones a git repository (via GitPython, which shells
+    # out to a real git binary) the first time a given model is imported.
+    # Pyodide/JupyterLite has no subprocess execution and no git binary, so
+    # this always fails there -- not a bug, an environment limitation.
+    # Checked up front, before the candidates loop below, rather than caught
+    # per-attempt: GitPython's failure in this sandbox surfaces as a plain
+    # ImportError (message: "emscripten does not support processes"), which
+    # the loop's `except ImportError` treats as "this candidate name doesn't
+    # exist, try the next one" -- so after exhausting every candidate it fell
+    # through to a misleading "model not found"/"renamed" error instead of
+    # this one. The outcome here is deterministic regardless of which
+    # candidate name is tried, so there is nothing to gain by attempting the
+    # loop at all on this platform.
+    if sys.platform == "emscripten":
+        raise ValueError(
+            f"Toolbox uses {_rd_link()} to provide URDF robot models, "
+            "which clones a git repository on first use. That isn't "
+            "possible in this browser (Pyodide/JupyterLite) sandbox -- "
+            f'this is an expected limitation loading "{robot_name}" '
+            "here, not a bug. Try a DH- or ETS-based model instead "
+            "(e.g. rtb.models.DH.Panda()), or run this notebook in a "
+            "regular Python environment to use robot_descriptions-"
+            "backed models."
+        )
+
     candidates = [f"{robot_name}_description", f"{robot_name}_official_description"]
     last_error: ImportError | None = None
     for candidate in candidates:
@@ -103,26 +128,6 @@ def _load_rd_module(robot_name: str):
         except ImportError as e:
             last_error = e
             continue
-        except Exception as e:
-            # robot_descriptions clones a git repository (via GitPython,
-            # which shells out to a real git binary) the first time a given
-            # model is imported. Pyodide/JupyterLite has no subprocess
-            # execution and no git binary, so this always fails there --
-            # not a bug, an environment limitation. The exact exception type
-            # depends on how GitPython fails in that sandbox, so this is
-            # deliberately broad, but only ever intercepts on Pyodide.
-            if sys.platform == "emscripten":
-                raise ValueError(
-                    f"Toolbox uses {_rd_link()} to provide URDF robot models, "
-                    "which clones a git repository on first use. That isn't "
-                    "possible in this browser (Pyodide/JupyterLite) sandbox -- "
-                    f'this is an expected limitation loading "{robot_name}" '
-                    "here, not a bug. Try a DH- or ETS-based model instead "
-                    "(e.g. rtb.models.DH.Panda()), or run this notebook in a "
-                    "regular Python environment to use robot_descriptions-"
-                    "backed models."
-                ) from e
-            raise
 
     renamed_to = _find_rd_rename(robot_name, candidates)
     if renamed_to is not None:

roboticstoolbox/models/URDF/YuMi.py

@@ -52,8 +52,8 @@ class YuMi(Robot):
         l_gripper_links = [link for link in links if link.parent == gripper_l_base]
 
         # New intermediate links
-        r_gripper = Link(name="r_gripper", parent=gripper_l_base)
-        l_gripper = Link(name="l_gripper", parent=gripper_r_base)
+        r_gripper = Link(name="r_gripper", parent=gripper_r_base)
+        l_gripper = Link(name="l_gripper", parent=gripper_l_base)
         links.append(r_gripper)
         links.append(l_gripper)
 

roboticstoolbox/robot/BaseRobot.py

@@ -2058,6 +2058,9 @@ class BaseRobot(SceneNode, DynamicsMixin, RobotPlottingMPLMixin, ABC, Generic[Li
 
         env = self._get_graphical_backend(backend)
 
+        if movie is not None:
+            from roboticstoolbox.backends.PyPlot import PyPlot
+
         launch_kwargs = {}
         for key in ("render_mode", "inline_every_n", "inline_format", "inline_dpi"):
             if key in kwargs:
@@ -2225,11 +2228,13 @@ class BaseRobot(SceneNode, DynamicsMixin, RobotPlottingMPLMixin, ABC, Generic[Li
         already_blocked = env._add_teach_panel(self, q, handle, block)
 
         if vellipse:
-            vell = self.vellipse(q, centre="ee", scale=0.5, add=False)
+            vell = self.vellipse(q, centre="ee", add=False)
+            env._teach_vellipse = vell
             env.add(vell)
 
         if fellipse:
             fell = self.fellipse(q, centre="ee", add=False)
+            env._teach_fellipse = fell
             env.add(fell)
 
         # Keep the plot open -- skipped if the backend already blocked