roboticstoolbox-python 1.4.0__py3-none-any.whl → 1.4.1__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/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
 
 
@@ -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/robot/BaseRobot.py

@@ -2225,11 +2225,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

roboticstoolbox/robot/DHLink.py

@@ -616,7 +616,7 @@ class DHLink(Link):
         sa = _sin(self.alpha)
         ca = _cos(self.alpha)
 
-        if self.ets[-1].isflip:
+        if self.isflip:
             q = -q + self.offset
         else:
             q = q + self.offset

roboticstoolbox/robot/Dynamics.py

@@ -1256,21 +1256,23 @@ class DynamicsMixin:
         :returns: Operational space accelerations of the end-effector
         :rtype: ndarray(6,)
 
-        ``xdd = accel_x(q, qd, wrench)`` is the operational space acceleration
+        ``xdd = accel_x(q, xd, wrench)`` is the operational space acceleration
         due to ``wrench`` applied to the end-effector of a robot in joint
-        configuration ``q`` and joint velocity ``qd``.
+        configuration ``q`` and operational space velocity ``xd``.
 
         .. math::
 
-            \ddot{x} = \mathbf{J}(q) \mathbf{M}(q)^{-1} \left(
-                \mathbf{J}(q)^T w - \mathbf{C}(q)\dot{q} - \mathbf{g}(q)
+            \ddot{x} = \dot{\mathbf{J}}_a(q, \dot{q})\dot{q}
+                + \mathbf{J}_a(q) \mathbf{M}(q)^{-1} \left(
+                    \mathbf{J}_a(q)^T w - \mathbf{C}(q)\dot{q}
+                    - \mathbf{g}(q)
                 \right)
 
         **Trajectory operation**
 
-        If `q`, `qd`, torque are matrices (m,n) then ``qdd`` is a matrix (m,n)
-        where each row is the acceleration corresponding to the equivalent rows
-        of q, qd, wrench.
+        If ``q`` is a matrix (m,n), and ``xd`` and ``wrench`` are matrices
+        (m,6), then ``xdd`` is a matrix (m,6) where each row is the acceleration
+        corresponding to the equivalent rows of ``q``, ``xd``, and ``wrench``.
 
         .. rubric:: Notes
 
@@ -1294,7 +1296,7 @@ class DynamicsMixin:
         if q.shape[1] != 6:
             pinv = True
 
-        xdd = np.zeros((q.shape[0], self.n))
+        xdd = np.zeros((q.shape[0], 6))
 
         for k, (qk, xdk, wk) in enumerate(zip(q, xd, w)):
             Ja = self.jacob0_analytical(qk, representation=representation)
@@ -1322,16 +1324,10 @@ class DynamicsMixin:
 
             # xd = Ja qd
             # xdd = Jad qd + Ja qdd
-            #
-            # Ja = T J
-            # Jad = Td J + T Jd
-            # assume Td = 0, not sure how valid that is
-
-            # need Jacobian dot
             qdk = Ji @ xdk
-            Jd = self.jacob0_dot(qk, qdk, J0=Ja)
+            Jad = self.jacob0_dot(qk, qdk, representation=representation)
 
-            xdd[k, :] = T @ (Jd @ qdk + J @ qdd)
+            xdd[k, :] = Jad @ qdk + Ja @ qdd
 
         if q.shape[0] == 1:
             return xdd[0, :]

roboticstoolbox/robot/RobotPlottingMPL.py

@@ -62,12 +62,12 @@ class RobotPlottingMPLMixin:
 
         """
 
-        from matplotlib import cm, colors
+        from matplotlib import colormaps, colors
 
-        if isinstance(linkcolors, list) and len(linkcolors) == self.n:  # type: ignore[attr-defined]  # pragma: nocover
+        if isinstance(linkcolors, list) and len(linkcolors) == self.n:  # type: ignore[attr-defined]
             return colors.ListedColormap(linkcolors)
-        else:  # pragma: nocover
-            return cm.get_cmap(linkcolors, 6)  # type: ignore[arg-type]
+        else:
+            return colormaps.get_cmap(linkcolors).resampled(6)
 
     # ------------------------------------------------------------------
     # Ellipse creation

roboticstoolbox/tools/__init__.py

@@ -22,6 +22,7 @@ from roboticstoolbox.tools.data import (
 )
 from roboticstoolbox.tools.plot import xplot
 from roboticstoolbox.tools.params import rtb_set_param, rtb_get_param
+from roboticstoolbox.tools.trchain import TrChainToken, trchain, trchain2
 from roboticstoolbox.tools.types import ArrayLike, NDArray, PyArrayLike
 
 __all__ = [
@@ -48,6 +49,9 @@ __all__ = [
     "rtb_path_to_datafile",
     "rtb_set_param",
     "rtb_get_param",
+    "TrChainToken",
+    "trchain",
+    "trchain2",
     "PyArrayLike",
     "ArrayLike",
     "NDArray",

roboticstoolbox/tools/trchain.py

@@ -0,0 +1,233 @@
+"""Evaluate chains of elementary homogeneous transforms."""
+
+import ast
+import operator
+import re
+from collections.abc import Callable, Mapping, Sequence
+from typing import NamedTuple
+
+import numpy as np
+from spatialmath.base import symbolic as sym
+from spatialmath.base import transl, transl2, trot2, trotx, troty, trotz
+
+
+class TrChainToken(NamedTuple):
+    """A parsed elementary-transform token.
+
+    :param op: elementary-transform operator
+    :param arg: expression inside the operator's parentheses
+    :param index: one-based joint index, or zero for a constant expression
+    """
+
+    op: str
+    arg: str
+    index: int
+
+
+_TOKEN_RE = re.compile(r"(?P<op>R.?|T.)\(")
+_BINARY_OPERATORS: dict[type[ast.operator], Callable[[object, object], object]] = {
+    ast.Add: operator.add,
+    ast.Sub: operator.sub,
+    ast.Mult: operator.mul,
+    ast.Div: operator.truediv,
+    ast.FloorDiv: operator.floordiv,
+    ast.Mod: operator.mod,
+    ast.Pow: operator.pow,
+}
+_UNARY_OPERATORS: dict[type[ast.unaryop], Callable[[object], object]] = {
+    ast.UAdd: operator.pos,
+    ast.USub: operator.neg,
+}
+_DEFAULT_VALUES = {
+    "pi": np.pi,
+    "sin": sym.sin,
+    "cos": sym.cos,
+    "tan": sym.tan,
+    "sqrt": sym.sqrt,
+}
+
+_Transform = Callable[[object, str], np.ndarray]
+_TRANSFORMS_3D: dict[str, _Transform] = {
+    "Rx": lambda value, unit: trotx(value, unit),
+    "Ry": lambda value, unit: troty(value, unit),
+    "Rz": lambda value, unit: trotz(value, unit),
+    "Tx": lambda value, _unit: transl(value, 0, 0),
+    "Ty": lambda value, _unit: transl(0, value, 0),
+    "Tz": lambda value, _unit: transl(0, 0, value),
+}
+_TRANSFORMS_2D: dict[str, _Transform] = {
+    "R": lambda value, unit: trot2(value, unit),
+    "Rz": lambda value, unit: trot2(value, unit),
+    "Tx": lambda value, _unit: transl2(value, 0),
+    "Ty": lambda value, _unit: transl2(0, value),
+}
+
+
+def _parse(chain: str, qvar: str) -> tuple[TrChainToken, ...]:
+    q_re = re.compile(rf"\b{re.escape(qvar)}([1-9][0-9]*)\b")
+    tokens = []
+    position = 0
+
+    while match := _TOKEN_RE.search(chain, position):
+        depth = 1
+        for position in range(match.end(), len(chain)):
+            if chain[position] == "(":
+                depth += 1
+            elif chain[position] == ")":
+                depth -= 1
+                if depth == 0:
+                    break
+        else:
+            raise ValueError(f"unclosed transform {match['op']!r}")
+
+        arg = chain[match.end() : position]
+        indices = q_re.findall(arg)
+        if len(indices) > 1:
+            raise ValueError("only one joint variable is allowed in each transform")
+        tokens.append(TrChainToken(match["op"], arg, int(indices[0]) if indices else 0))
+        position += 1
+
+    return tuple(tokens)
+
+
+def _eval_expression(expression: str, values: Mapping[str, object]) -> object:
+    try:
+        tree = ast.parse(expression, mode="eval")
+    except SyntaxError as exc:
+        raise ValueError(f"cannot evaluate expression {expression!r}") from exc
+
+    def evaluate(node: ast.AST) -> object:
+        if isinstance(node, ast.Constant) and isinstance(node.value, (int, float)):
+            return node.value
+        if isinstance(node, ast.Name):
+            try:
+                return values[node.id]
+            except KeyError as exc:
+                raise ValueError(
+                    f"unknown name {node.id!r} in expression {expression!r}"
+                ) from exc
+        if isinstance(node, ast.BinOp) and type(node.op) in _BINARY_OPERATORS:
+            return _BINARY_OPERATORS[type(node.op)](
+                evaluate(node.left), evaluate(node.right)
+            )
+        if isinstance(node, ast.UnaryOp) and type(node.op) in _UNARY_OPERATORS:
+            return _UNARY_OPERATORS[type(node.op)](evaluate(node.operand))
+        if (
+            isinstance(node, ast.Call)
+            and isinstance(node.func, ast.Name)
+            and not node.keywords
+        ):
+            function = values.get(node.func.id)
+            if callable(function):
+                return function(*(evaluate(arg) for arg in node.args))
+        raise ValueError(f"unsupported expression {expression!r}")
+
+    return evaluate(tree.body)
+
+
+def _evaluate_chain(
+    chain: str | Sequence[TrChainToken],
+    q: Sequence[object] | np.ndarray | None,
+    unit: str,
+    qvar: str,
+    variables: Mapping[str, object] | None,
+    transforms: Mapping[str, _Transform],
+    size: int,
+) -> tuple[np.ndarray, tuple[TrChainToken, ...]]:
+    if unit not in {"rad", "deg"}:
+        raise ValueError("unit must be 'rad' or 'deg'")
+    if not qvar.isidentifier():
+        raise ValueError("qvar must be a valid identifier")
+
+    if isinstance(chain, str):
+        tokens = _parse(chain, qvar)
+    else:
+        tokens = tuple(chain)
+        if not all(isinstance(token, TrChainToken) for token in tokens):
+            raise TypeError("chain must be a string or a sequence of TrChainToken")
+
+    q_values = np.asarray(()) if q is None else np.asarray(q).reshape(-1)
+    values = {**_DEFAULT_VALUES, **(variables or {})}
+    T = np.eye(size)
+
+    for token in tokens:
+        try:
+            transform = transforms[token.op]
+        except KeyError as exc:
+            raise ValueError(f"unknown transform {token.op!r}") from exc
+
+        token_values = values
+        if token.index:
+            if token.index > len(q_values):
+                raise ValueError("q has insufficient values")
+            token_values = {
+                **values,
+                f"{qvar}{token.index}": q_values[token.index - 1],
+            }
+
+        T = T @ transform(_eval_expression(token.arg, token_values), unit)
+
+    return T, tokens
+
+
+def trchain(
+    chain: str | Sequence[TrChainToken],
+    q: Sequence[object] | np.ndarray | None = None,
+    unit: str = "rad",
+    *,
+    qvar: str = "q",
+    variables: Mapping[str, object] | None = None,
+    return_tokens: bool = False,
+) -> np.ndarray | tuple[np.ndarray, tuple[TrChainToken, ...]]:
+    """Compound SE(3) elementary transforms from a string.
+
+    :param chain: transform chain or tokens returned by an earlier call
+    :param q: joint values referenced as ``q1``, ``q2``, and so on
+    :param unit: angular unit, ``"rad"`` or ``"deg"``
+    :param qvar: joint-variable prefix
+    :param variables: values and functions used by token expressions
+    :param return_tokens: also return the parsed tokens for reuse
+    :returns: the SE(3) matrix, optionally followed by its parsed tokens
+    :rtype: ndarray(4, 4) or tuple
+
+    The chain contains ``Rx``, ``Ry``, ``Rz``, ``Tx``, ``Ty``, and ``Tz``
+    tokens. Expressions support arithmetic, named values, ``pi``, and direct
+    calls to named functions. Names other than joint variables are supplied by
+    ``variables``.
+
+    :seealso: :func:`trchain2`, :class:`roboticstoolbox.ETS`
+    """
+    result = _evaluate_chain(chain, q, unit, qvar, variables, _TRANSFORMS_3D, 4)
+    return result if return_tokens else result[0]
+
+
+def trchain2(
+    chain: str | Sequence[TrChainToken],
+    q: Sequence[object] | np.ndarray | None = None,
+    unit: str = "rad",
+    *,
+    qvar: str = "q",
+    variables: Mapping[str, object] | None = None,
+    return_tokens: bool = False,
+) -> np.ndarray | tuple[np.ndarray, tuple[TrChainToken, ...]]:
+    """Compound SE(2) elementary transforms from a string.
+
+    :param chain: transform chain or tokens returned by an earlier call
+    :param q: joint values referenced as ``q1``, ``q2``, and so on
+    :param unit: angular unit, ``"rad"`` or ``"deg"``
+    :param qvar: joint-variable prefix
+    :param variables: values and functions used by token expressions
+    :param return_tokens: also return the parsed tokens for reuse
+    :returns: the SE(2) matrix, optionally followed by its parsed tokens
+    :rtype: ndarray(3, 3) or tuple
+
+    The chain contains ``R`` (or ``Rz``), ``Tx``, and ``Ty`` tokens.
+    Expressions are evaluated as described by :func:`trchain`.
+
+    :seealso: :func:`trchain`, :class:`roboticstoolbox.ETS2`
+    """
+    result = _evaluate_chain(chain, q, unit, qvar, variables, _TRANSFORMS_2D, 3)
+    return result if return_tokens else result[0]
+
+
+__all__ = ["TrChainToken", "trchain", "trchain2"]

{roboticstoolbox_python-1.4.0.dist-info → roboticstoolbox_python-1.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: roboticstoolbox-python
-Version: 1.4.0
+Version: 1.4.1
 Summary: A Python library for robotics education and research
 Keywords: python,robotics,robotics-toolbox,kinematics,dynamics,motion-planning,trajectory-generation,jacobian,hessian,control,simulation,robot-manipulator,mobile-robot
 Author-Email: Jesse Haviland <j.haviland@qut.edu.au>, Peter Corke <rvc@petercorke.com>
@@ -33,6 +33,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Project-URL: homepage, https://petercorke.github.io/robotics-toolbox-python/
 Project-URL: documentation, https://petercorke.github.io/robotics-toolbox-python/
 Project-URL: repository, https://github.com/petercorke/robotics-toolbox-python

{roboticstoolbox_python-1.4.0.dist-info → roboticstoolbox_python-1.4.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-roboticstoolbox/__init__.py,sha256=XBSwVd_-stPceD89wai-tVOg2LXHOek8WLqIYEJgRpw,1921
+roboticstoolbox/__init__.py,sha256=D_IIMDfJ3IFnjkA1BS9ujcmIvBU5fCtJ4ETPNX-o1Uo,1972
 roboticstoolbox/backends/Connector.py,sha256=oIIoFQdCgCyRvv6dlaCSopYmBRG7h-sUmlT_9Qf6Vkg,2655
 roboticstoolbox/backends/Dynamixel/README.md,sha256=XSljkUIzB6DIyfih5RS-TlM_MFxHAE3VDr5yzQ8TgOM,289
 roboticstoolbox/backends/Dynamixel/dynamixel.json,sha256=au-Yh-LPG1Tm9nMRxWrziatPs3ZSziGLdTam98JMVXQ,14181
@@ -480,7 +480,7 @@ roboticstoolbox/ets/fknm.py,sha256=vuZ_eEJiob3pvsjCBgH_Bq8rfc_NVXLCRECkSKTA0G4,1
 roboticstoolbox/mobile/Animations.py,sha256=Z6VneDvf0fW0gFYQXVLoqBvq3qDKfK-y1cOa18S_cWs,15929
 roboticstoolbox/mobile/Bug2.py,sha256=tp7NLJBHJcH_W43YQv_zeTBClLfwDbTOjtrHjvDCoOM,14510
 roboticstoolbox/mobile/CurvaturePolyPlanner.py,sha256=vSqcsPxGwzeDzDbr6itKFUaKByth8jkynQs6UESdBjE,5464
-roboticstoolbox/mobile/DistanceTransformPlanner.py,sha256=avs9BIHIUZbGFxUy6VOJuBo5LjFBo5BfVuOKbVfQGk8,12246
+roboticstoolbox/mobile/DistanceTransformPlanner.py,sha256=Nf4E-dBp5StzdLIk__8m_CNFedtbWXgJPVj1rGsPk5I,12224
 roboticstoolbox/mobile/DstarPlanner.py,sha256=eZvgw3zYUPgc5SjgMzBd7No3m20xCRySgj89u4fnNB0,19219
 roboticstoolbox/mobile/DubinsPlanner.py,sha256=HH62OZR4QTL1cUUVcrJsy7nCXNqHnikUH0ytp81tnSc,14087
 roboticstoolbox/mobile/EKF.py,sha256=4ZJvnSNULUQNf67spJVJTmzse9NIC1aeAbsz-kfekJE,52390
@@ -548,7 +548,7 @@ roboticstoolbox/models/URDF/Puma560.py,sha256=1WHxYNXkYgJ6TJ9xJpJzfkZlfHZA2N9HFS
 roboticstoolbox/models/URDF/UR10.py,sha256=OIw8-f3diIytx9M4FKofNOlduEDRiYTVQZdvZjY5Zo4,1073
 roboticstoolbox/models/URDF/UR3.py,sha256=T0pd-KtNQYoqmONkfMaqWKZSA6WS3Wq0JzS3NIL1lvg,1066
 roboticstoolbox/models/URDF/UR5.py,sha256=DDLzthyJ0fyylxijTZ14X_KZIYsCgLO1S6Pk5vecQZ0,1671
-roboticstoolbox/models/URDF/URDFRobot.py,sha256=XVL-mVMcj98RGPe6OvTX634cnWBmxN_EDWHFfEYHCJk,15158
+roboticstoolbox/models/URDF/URDFRobot.py,sha256=cEyhWSozFhvQwJsYZ8hhGjkByzChGjHWXahTjiK6a7k,15441
 roboticstoolbox/models/URDF/Valkyrie.py,sha256=7LLgVRXFZ_NM5lksNW7jx6jugSDEJ4uylqqqfwkbPP0,4133
 roboticstoolbox/models/URDF/YuMi.py,sha256=IZQWtVrolGdhug08bm7rk5esirIdas4L_VBuWl0yupc,3245
 roboticstoolbox/models/URDF/__init__.py,sha256=G4PNTfYRiYekdxssVHN8v3zPUWPhbcOrffJR9u6lWDo,1599
@@ -563,11 +563,11 @@ roboticstoolbox/models/URDF/wx250.py,sha256=1vu7dnbnG72P46d0ThP5Yx0I56aCl-sPXYll
 roboticstoolbox/models/URDF/wx250s.py,sha256=A_BptSxGEBHXLauvB6TepFYHS5owvlHOPxpJbDK8QPA,1254
 roboticstoolbox/models/__init__.py,sha256=HTx6EusezeH5Qq2wDwDqaI6JCcp9cDWeaYAgQL62VmI,245
 roboticstoolbox/models/catalog.py,sha256=R-Lc_vHoOfae-afVS1olmoPu9cq7YTDfYqtCJeM3W9g,8694
-roboticstoolbox/robot/BaseRobot.py,sha256=yNBzD6XXKZ6Da4tZbQZR-OxhITU_k_qP9CBpqyy9vVg,82209
+roboticstoolbox/robot/BaseRobot.py,sha256=WK2pSU9Oqi_ARQtzv78wA-a4xK3NDyddnjZKqi3hfQo,82276
 roboticstoolbox/robot/DHFactor.py,sha256=Bf-j7IvBKRA6_k3uev_ceQRMAC79D7W0Ir7kCJt4mec,15981
-roboticstoolbox/robot/DHLink.py,sha256=QhVUKdEiqC_dhIc7rwpDP5cGgU7A4dW_WTx4T-de-Ts,27823
+roboticstoolbox/robot/DHLink.py,sha256=_7FtGDuS_dVxFGUQx9-Vqj7EoLsMIhV9SwVDFpWBPWs,27815
 roboticstoolbox/robot/DHRobot.py,sha256=AzGahOI9zs5A-3H5klUASKyaP_N1on9QGJ_TzTTpIJw,91705
-roboticstoolbox/robot/Dynamics.py,sha256=Uqud9jdiujcJAv5Fqxrw-oUL-EIdOkGnWiO85VQhBls,52475
+roboticstoolbox/robot/Dynamics.py,sha256=iCplz4L1wT2OeXuS0acO9x8h4uxsifT67PV4TViUwZw,52479
 roboticstoolbox/robot/ELink.py,sha256=sgA-1c-U0Gz6TxABSJvfauq2L0Wu_1_pGJVKfLgrGP8,525
 roboticstoolbox/robot/ERobot.py,sha256=aUnSg91PwHyIHO6ipWtnNBNLYCftKGIxgYz1qX8wghg,567
 roboticstoolbox/robot/Gripper.py,sha256=CYyXFBYbEp52-RX-b6xGWS3EH-Y2BsYdtaR8Q0yAm3s,6954
@@ -576,7 +576,7 @@ roboticstoolbox/robot/Link.py,sha256=m98nfpv61C5Z1GDrOV_iN6gxyh9qj8URwiju9ssKXxw
 roboticstoolbox/robot/PoERobot.py,sha256=mByMjb3P5FrW3Z8zyLS5waYcKBy8lpHG44g2uBUyB70,11053
 roboticstoolbox/robot/Robot.py,sha256=cIixw_nx1ZzpzSVL_GzT6Hlf-HABK9aE856DPFWKGoM,77812
 roboticstoolbox/robot/RobotKinematics.py,sha256=4aXOGhc2oGOCbr0tB4ruT1Od5nJMV5WL9Q3tmb2IU74,58631
-roboticstoolbox/robot/RobotPlottingMPL.py,sha256=uLm3NlaPACty_3M9dfzsu4WGuONGEz7duIPWuBWzza4,14247
+roboticstoolbox/robot/RobotPlottingMPL.py,sha256=tmIGievDZwtLkd0To0Of2MeAB38yvbUd8T0bF0qwLd8,14207
 roboticstoolbox/robot/RobotProto.py,sha256=os5bJSXp4ZO-ANJjaSF8_Xb-TJxbCg1Ry_obS3A6LqM,4339
 roboticstoolbox/robot/__init__.py,sha256=RUeji1GTnAL3U3mn0ae6W1lnmvC-CFlUw5U7RTQnvO8,1237
 roboticstoolbox/robot/cpp-extensions/README.md,sha256=hmXhlk7PVPmaLMXMmM1_IiI-AQpUKFqMyPvdx9kt0OU,1235
@@ -588,7 +588,7 @@ roboticstoolbox/robot/cpp-extensions/vmath.h,sha256=CEYvZMjVCNFrJQXts32iKskcliXh
 roboticstoolbox/robot/frne.py,sha256=PjUxGEl3dRcPe-PZJwsH3LivGha6bgo7JJjhwOxTcZ8,1810
 roboticstoolbox/tools/DHFactor.py,sha256=y_UOLTnFEAZJU7Vw2wPBREOxx5zph1VMXxVELGb8zFc,11815
 roboticstoolbox/tools/Ticker.py,sha256=MxEWyDn1eAd6keZtyhfts2LmMe8rt-AUh3kN9zBtAKc,1204
-roboticstoolbox/tools/__init__.py,sha256=iMWqOImcGgR5VhgTNZh9W_AZKwmcoKP0mZOllK3fBzk,1335
+roboticstoolbox/tools/__init__.py,sha256=PRmXLt-qi26A25_c5XwvR6JSAUlkWFlJUI8wWb-cNM8,1460
 roboticstoolbox/tools/data.py,sha256=ms51jPRCETDr_AGV1-OG-xocGIPOblHUYu-wekkq56o,5550
 roboticstoolbox/tools/jsingu.py,sha256=4drWqPGNz4VBnMIcTxqkExmTiKu6v49r9yRzC7WDF4Q,1398
 roboticstoolbox/tools/null.py,sha256=ZBBM4GN9f0d2xBaXpJL8n51_tEjeJuFhxfPjOpUJvNk,1507
@@ -597,14 +597,15 @@ roboticstoolbox/tools/p_servo.py,sha256=KpFoe2sgeYG_plr2kTwb0nRlVfKKCdaGR82NnD-1
 roboticstoolbox/tools/params.py,sha256=2DRBgmjVFxulh-5u8rAiiqYQQycZEsAEoho4lVX0CoY,151
 roboticstoolbox/tools/plot.py,sha256=THXEaz_R-J57FhL3gq_rdRVz9B6UykZQYxbIEvtkGv8,2896
 roboticstoolbox/tools/trajectory.py,sha256=D0gJwuFvpkuYkVJkXwLRJYJaROwwad85-2JWBMkkISA,34214
+roboticstoolbox/tools/trchain.py,sha256=p6MUo8m1Ydnjmu0SBtUWe-ODNO-s4WkLbqu7teI2V6A,8185
 roboticstoolbox/tools/types.py,sha256=d9Oqs44fio7vI4myf4s4tqgoX83YDLqU_LOH7T4E6FM,231
 roboticstoolbox/tools/urdf/__init__.py,sha256=tlo9oTXh3evQweOP3Hch-u3GiL_2NWavWHDBnk7BfKY,693
 roboticstoolbox/tools/urdf/tests/data/ur5.urdf,sha256=9g0uYkRHRsWHWl6vn5lIK_JMHqhaUOi4HaBanuXco4A,11927
 roboticstoolbox/tools/urdf/tests/test_urdf.py,sha256=MoRP8DolFu7RXxrKkwEWJOSfVygX7UJwEv-hLZkdlKw,3445
 roboticstoolbox/tools/urdf/urdf.py,sha256=IE5EUSNjkOAZZUOkuhXKDhYRq2AuJGulIvfbsRHy7pI,58743
 roboticstoolbox/tools/urdf/utils.py,sha256=6g1uuI2u7CUaWhKavI7wDHT3a2T3ijb92JByQ1lNq6w,1483
-roboticstoolbox_python-1.4.0.dist-info/METADATA,sha256=16-BiOiSk9VmdYxId4q2mu1qGqHA7kWPscyOI_3tmIo,30164
-roboticstoolbox_python-1.4.0.dist-info/WHEEL,sha256=DJBbB-IMWy7eyPvSdm5L2t-BbrULtweJWf0YC-blkl0,95
-roboticstoolbox_python-1.4.0.dist-info/entry_points.txt,sha256=m9xEI6rJsYQL0HosyeS-4TUPzxOR3kqx4vbJVVxwo7k,214
-roboticstoolbox_python-1.4.0.dist-info/licenses/LICENSE,sha256=oXNGHTPcMKl8PPZWk_4NIWGAtiaQcTgVJ1hpnTcnKFA,1062
-roboticstoolbox_python-1.4.0.dist-info/RECORD,,
+roboticstoolbox_python-1.4.1.dist-info/METADATA,sha256=77rLsFDnkDFxePDwO-G0X0KaUElESjFTeSYCTEObUy0,30215
+roboticstoolbox_python-1.4.1.dist-info/WHEEL,sha256=DJBbB-IMWy7eyPvSdm5L2t-BbrULtweJWf0YC-blkl0,95
+roboticstoolbox_python-1.4.1.dist-info/entry_points.txt,sha256=m9xEI6rJsYQL0HosyeS-4TUPzxOR3kqx4vbJVVxwo7k,214
+roboticstoolbox_python-1.4.1.dist-info/licenses/LICENSE,sha256=oXNGHTPcMKl8PPZWk_4NIWGAtiaQcTgVJ1hpnTcnKFA,1062
+roboticstoolbox_python-1.4.1.dist-info/RECORD,,