roboticstoolbox-python 1.4.1__tar.gz → 1.4.2__tar.gz

roboticstoolbox_python-1.4.2/.github/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+    ".": "1.4.2"
+}

{roboticstoolbox_python-1.4.1 → roboticstoolbox_python-1.4.2}/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## [1.4.2](https://github.com/petercorke/robotics-toolbox-python/compare/v1.4.1...v1.4.2) (2026-08-26)
+
+**Headline**: Fixes to inverse kinematics and forward kinematics for branched robots. Arising from a big trawl through long standing issues (thanks to all those users), many were resolved by recent work, but some were not.
+Issues down from 104 to 43 of which 20 are `tech-debt` to be worked through.
+
+### Features
+
+* **ets:** fkine/jacob0/jacobe/hessian0/hessiane accept compact q ([#653](https://github.com/petercorke/robotics-toolbox-python/issues/653)) ([d5b6990](https://github.com/petercorke/robotics-toolbox-python/commit/d5b699025e48afeca147fb2e8b246557d2059c47))
+* **examples:** add ikine_XX (C++ and pure-Python ETS) to ik_speed.py ([2f41a71](https://github.com/petercorke/robotics-toolbox-python/commit/2f41a711eba92f97ad1ed38dcd4fa69a87bccb26))
+* **examples:** add ikine_XX timing columns to ik_speed.py ([#654](https://github.com/petercorke/robotics-toolbox-python/issues/654)) ([2f41a71](https://github.com/petercorke/robotics-toolbox-python/commit/2f41a711eba92f97ad1ed38dcd4fa69a87bccb26))
+
+
+### Bug Fixes
+
+* **blocks:** FDyn_X.output() crashed/asserted on unset xdd before deriv() ran ([#647](https://github.com/petercorke/robotics-toolbox-python/issues/647)) ([8caa363](https://github.com/petercorke/robotics-toolbox-python/commit/8caa363a98c158621d6418ccad8f0bbdc93fee11))
+* **examples,dhrobot:** repair broken ikine_LMS/ikine_min example references ([#650](https://github.com/petercorke/robotics-toolbox-python/issues/650)) ([6691113](https://github.com/petercorke/robotics-toolbox-python/commit/66911133fdbdb5cf73cb24fcca058f457270099c))
+* **ik:** _random_q() silently produces garbage for non-finite joint limits ([#648](https://github.com/petercorke/robotics-toolbox-python/issues/648)) ([2f43a3c](https://github.com/petercorke/robotics-toolbox-python/commit/2f43a3c2812dc8f30d8601a54d453ef158c8b8e0))
+* **ik:** unify ik_XX/ikine_XX return types and fix IK docs ([#652](https://github.com/petercorke/robotics-toolbox-python/issues/652)) ([07a60f4](https://github.com/petercorke/robotics-toolbox-python/commit/07a60f4a9fe9bf3de94aaf2428f93f75a7d77d3f))
+* **kinematics:** fkine_all() computes wrong poses for links past a nominal end-effector ([#643](https://github.com/petercorke/robotics-toolbox-python/issues/643)) ([25eedcd](https://github.com/petercorke/robotics-toolbox-python/commit/25eedcd4294856cab0a8de346c72ce0a48a50b2e))
+* **mobile:** restore missing distance-transform diagonal ([835457e](https://github.com/petercorke/robotics-toolbox-python/commit/835457e0428ade74b68220395a09224737f40d79))
+* **models,ik:** correct YuMi gripper parents and IK failure-path q compaction ([#649](https://github.com/petercorke/robotics-toolbox-python/issues/649)) ([7c40242](https://github.com/petercorke/robotics-toolbox-python/commit/7c40242dec4dafcc12940c3eeb9da67f9d2aa7fa))
+* **pyplot:** robot.plot(..., movie=...) crashes on save ([#645](https://github.com/petercorke/robotics-toolbox-python/issues/645)) ([2e2bfe2](https://github.com/petercorke/robotics-toolbox-python/commit/2e2bfe2ada4c43f3212db48f052986b25da6254d))
+* **pyplot:** scalar plot options (jointaxislength, eelength) crash on override ([a4aea19](https://github.com/petercorke/robotics-toolbox-python/commit/a4aea193354631dc5e208f00f556ff181ba713bb))
+* **pyplot:** scalar plot options crash on override ([#642](https://github.com/petercorke/robotics-toolbox-python/issues/642)) ([a4aea19](https://github.com/petercorke/robotics-toolbox-python/commit/a4aea193354631dc5e208f00f556ff181ba713bb))
+
+
+### Documentation
+
+* fix broken PyPlot backend example in intro.rst ([#641](https://github.com/petercorke/robotics-toolbox-python/issues/641)) ([5e8d2f9](https://github.com/petercorke/robotics-toolbox-python/commit/5e8d2f96f557d2a0014217e8820cbadcd9136889))
+
+
+### Miscellaneous
+
+* release 1.4.2 ([440a9ec](https://github.com/petercorke/robotics-toolbox-python/commit/440a9eca955430e1fd6f97ed63781e86648d1026))
+
 ## [1.4.1](https://github.com/petercorke/robotics-toolbox-python/compare/v1.4.0...v1.4.1) (2026-08-25)
 
 

{roboticstoolbox_python-1.4.1 → roboticstoolbox_python-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: roboticstoolbox-python
-Version: 1.4.1
+Version: 1.4.2
 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>

{roboticstoolbox_python-1.4.1 → roboticstoolbox_python-1.4.2}/docs/source/IK/ik_lm.rst

@@ -1,5 +1,5 @@
-IK_LM - Levemberg-Marquadt Numerical IK
----------------------------------------
+IK_LM - Levenberg-Marquardt Numerical IK
+----------------------------------------
 
 .. currentmodule:: roboticstoolbox.robot.IK
 

{roboticstoolbox_python-1.4.1 → roboticstoolbox_python-1.4.2}/docs/source/conf.py

@@ -198,6 +198,7 @@ rst_epilog = """
    :format: html
 .. |BlockOptions| replace:: :raw-html:`<a href="https://petercorke.github.io/bdsim/internals.html?highlight=block%20__init__#bdsim.Block.__init__">common Block options</a>`
 .. |GraphicsBlockOptions| replace:: :raw-html:`<a href="https://petercorke.github.io/bdsim/internals.html?highlight=graphicsblock%20__init__#bdsim.GraphicsBlock.__init__">common GraphicsBlock options</a>`
+.. |ikargs| replace:: additional keyword arguments accepted by the underlying numerical IK solver -- ``ilimit``, ``slimit``, ``tol``, ``mask``, ``joint_limits``, ``seed``, ``k``, ``method``, ``kq``, ``km`` -- see :meth:`~roboticstoolbox.ETS.ikine_LM` for details of each
 """
 
 # -------- Suppress common noisy warnings ----------------------------------------#

{roboticstoolbox_python-1.4.1 → roboticstoolbox_python-1.4.2}/docs/source/intro.rst

@@ -103,7 +103,7 @@ All robots can generate a random joint configuration informed by joint limits, i
     >>> puma.random_q()
 
 ``ikine_LM`` is a generalised iterative numerical solution based on
-Levenberg-Marquadt minimization, and additional status results are also
+Levenberg-Marquardt minimization, and additional status results are also
 returned as part of a named tuple.  
 
 .. warning:: 
@@ -634,11 +634,12 @@ the default ``PyPlot`` backend which draws a "noodle robot" using the PyPlot bac
 
 The more general solution, and what is implemented inside ``plot`` in the example above, is::
 
-    >>> pyplot = roboticstoolbox.backends.PyPlot()
+    >>> from roboticstoolbox.backends.PyPlot import PyPlot
+    >>> pyplot = PyPlot()
     >>> pyplot.launch()
     >>> pyplot.add(puma)
     >>> puma.q = q
-    >>> puma.step()
+    >>> pyplot.step()
 
 This makes it possible to animate multiple robots in the one graphical window, or the one robot in various environments either graphical
 or real.

roboticstoolbox_python-1.4.2/examples/ik_exp.py

@@ -0,0 +1,176 @@
+import numpy as np
+import roboticstoolbox as rtb
+from ansitable import ANSITable
+
+# Our robot and ETS
+robot = rtb.models.Panda()
+ets = robot.ets()
+
+### Experiment parameters
+# Number of problems to solve
+problems = 10000
+
+# Cartesion DoF priority matrix
+we = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
+
+# random valid q values which will define Tep
+q_rand = ets.random_q(problems)
+
+# Our desired end-effector poses
+Tep = np.zeros((problems, 4, 4))
+
+for i in range(problems):
+    Tep[i] = ets.eval(q_rand[i])
+
+# Maximum iterations allowed in a search
+ilimit = 30
+
+# Maximum searches allowed per problem
+slimit = 100
+
+# Solution tolerance
+tol = 1e-6
+
+# Reject solutions with invalid joint limits
+joint_limits = True
+
+
+class IK:
+    def __init__(self, name, solve, problems=problems):
+
+        # Solver attributes
+        self.name = name
+
+        self.solve = solve
+
+        # Solver results
+        self.iterations = np.zeros(problems)
+        self.searches = np.zeros(problems)
+        self.residual = np.zeros(problems)
+        self.success = np.zeros(problems)
+
+        self.total_iterations = 0
+        self.total_searches = 0
+
+
+solvers = [
+    IK(
+        "Newton Raphson Pinv",
+        lambda Tep: ets.ik_NR(
+            Tep,
+            q0=None,
+            ilimit=ilimit,
+            slimit=slimit,
+            tol=tol,
+            joint_limits=joint_limits,
+            mask=we,
+            pinv=True,
+            pinv_damping=0.0,
+        ),
+    ),
+    IK(
+        "Gauss Newton Pinv",
+        lambda Tep: ets.ik_GN(
+            Tep,
+            q0=None,
+            ilimit=ilimit,
+            slimit=slimit,
+            tol=tol,
+            joint_limits=joint_limits,
+            mask=we,
+            pinv=True,
+            pinv_damping=0.0,
+        ),
+    ),
+    IK(
+        "LM Chan 0.1",
+        lambda Tep: ets.ik_LM(
+            Tep,
+            q0=None,
+            ilimit=ilimit,
+            slimit=slimit,
+            tol=tol,
+            joint_limits=joint_limits,
+            mask=we,
+            k=0.1,
+            method="chan",
+        ),
+    ),
+    IK(
+        "LM Wampler 1e-4",
+        lambda Tep: ets.ik_LM(
+            Tep,
+            q0=None,
+            ilimit=ilimit,
+            slimit=slimit,
+            tol=tol,
+            joint_limits=joint_limits,
+            mask=we,
+            k=1e-4,
+            method="wampler",
+        ),
+    ),
+    IK(
+        "LM Sugihara 0.1",
+        lambda Tep: ets.ik_LM(
+            Tep,
+            q0=None,
+            ilimit=ilimit,
+            slimit=slimit,
+            tol=tol,
+            joint_limits=joint_limits,
+            mask=we,
+            k=0.1,
+            method="sugihara",
+        ),
+    ),
+]
+
+for i in range(problems):
+    print(i + 1)
+
+    for solver in solvers:
+        sol = solver.solve(Tep[i])
+
+        if sol.success:
+            solver.success[i] = sol.success
+            solver.iterations[i] = sol.iterations
+            solver.searches[i] = sol.searches
+            solver.residual[i] = sol.residual
+            solver.total_iterations += solver.iterations[i]
+            solver.total_searches += solver.searches[i]
+        else:
+            solver.success[i] = np.nan
+            solver.iterations[i] = np.nan
+            solver.searches[i] = np.nan
+            solver.residual[i] = np.nan
+
+
+print(f"\nNumerical Inverse Kinematics Methods Compared over {problems} problems\n")
+
+table = ANSITable(
+    "Method",
+    "sLimit/iLimit",
+    "Mean Steps",
+    "Median Steps",
+    "Infeasible",
+    "Infeasible %",
+    "Mean Attempts",
+    # "Median Attempts",
+    "Max Attempts",
+    border="thin",
+)
+
+for solver in solvers:
+    table.row(
+        solver.name,
+        f"{slimit}, {ilimit}",
+        np.round(np.nanmean(solver.iterations), 2),
+        np.nanmedian(solver.iterations),
+        np.sum(np.isnan(solver.success)),
+        np.round(np.sum(np.isnan(solver.success)) / problems * 100.0, 2),
+        np.round(np.nanmean(solver.searches), 2),
+        np.nanmax(solver.searches),
+    )
+
+table.print()

roboticstoolbox_python-1.4.2/examples/ik_speed.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python
+"""Benchmark numerical IK solver speed three ways: the fast, C-only ik_XX
+solvers; the pure-Python ikine_XX solvers backed by the C-accelerated ETS
+(fkine/jacobian evaluated in C++); and ikine_XX backed by the pure-Python
+ETS fallback (fkine/jacobian evaluated in Python too, as in a pure-Python
+wheel/Pyodide build).
+"""
+
+import time
+import sys
+
+import numpy as np
+from ansitable import ANSITable, Column
+
+import roboticstoolbox as rtb
+import roboticstoolbox.ets.fknm as fknm
+
+from _cpu_info import cpu_info
+
+# Our robot and ETS
+robot = rtb.models.Panda()
+ets = robot.ets()
+
+### Experiment parameters
+# Number of problems to solve for the C-accelerated columns (ik_XX and
+# ikine_XX with the C++ ETS)
+nproblems = 10_000
+
+# The pure-Python ETS fallback is interpreted at every iteration, not just
+# the outer solver loop -- 10,000 problems would take far too long, so use
+# a much smaller sample for that column alone.
+nproblems_slow = 1_000
+
+# Cartesion DoF priority matrix
+mask = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
+
+# random valid q values which will define Tep
+q_rand = ets.random_q(nproblems)
+
+# Our desired end-effector poses
+Tep = np.zeros((nproblems, 4, 4))
+
+for i in range(nproblems):
+    Tep[i] = ets.eval(q_rand[i])
+
+# Maximum iterations allowed in a search
+ilimit = 30
+
+# Maximum searches allowed per problem
+slimit = 100
+
+# Solution tolerance
+tol = 1e-6
+
+
+ik_solvers = [
+    lambda Tep: ets.ik_NR(
+        Tep,
+        q0=None,
+        ilimit=ilimit,
+        slimit=slimit,
+        tol=tol,
+        joint_limits=False,
+        mask=mask,
+        pinv=True,
+        pinv_damping=0.0,
+    ),
+    lambda Tep: ets.ik_GN(
+        Tep,
+        q0=None,
+        ilimit=ilimit,
+        slimit=slimit,
+        tol=tol,
+        joint_limits=False,
+        mask=mask,
+        pinv=False,
+        pinv_damping=0.2,
+    ),
+    lambda Tep: ets.ik_LM(
+        Tep,
+        q0=None,
+        ilimit=ilimit,
+        slimit=slimit,
+        tol=tol,
+        joint_limits=True,
+        mask=mask,
+        k=0.1,
+        method="chan",
+    ),
+    lambda Tep: ets.ik_LM(
+        Tep,
+        q0=None,
+        ilimit=ilimit,
+        slimit=slimit,
+        tol=tol,
+        joint_limits=True,
+        mask=mask,
+        k=1e-4,
+        method="wampler",
+    ),
+    lambda Tep: ets.ik_LM(
+        Tep,
+        q0=None,
+        ilimit=ilimit,
+        slimit=slimit,
+        tol=tol,
+        joint_limits=True,
+        mask=mask,
+        k=0.1,
+        method="sugihara",
+    ),
+]
+
+# ikine_XX equivalents -- same settings as above, minus pinv_damping (which
+# ikine_NR/ikine_GN don't accept; only the C-only ik_NR/ik_GN do)
+ikine_solvers = [
+    lambda Tep: ets.ikine_NR(
+        Tep,
+        q0=None,
+        ilimit=ilimit,
+        slimit=slimit,
+        tol=tol,
+        joint_limits=False,
+        mask=mask,
+        pinv=True,
+    ),
+    lambda Tep: ets.ikine_GN(
+        Tep,
+        q0=None,
+        ilimit=ilimit,
+        slimit=slimit,
+        tol=tol,
+        joint_limits=False,
+        mask=mask,
+        pinv=False,
+    ),
+    lambda Tep: ets.ikine_LM(
+        Tep,
+        q0=None,
+        ilimit=ilimit,
+        slimit=slimit,
+        tol=tol,
+        joint_limits=True,
+        mask=mask,
+        k=0.1,
+        method="chan",
+    ),
+    lambda Tep: ets.ikine_LM(
+        Tep,
+        q0=None,
+        ilimit=ilimit,
+        slimit=slimit,
+        tol=tol,
+        joint_limits=True,
+        mask=mask,
+        k=1e-4,
+        method="wampler",
+    ),
+    lambda Tep: ets.ikine_LM(
+        Tep,
+        q0=None,
+        ilimit=ilimit,
+        slimit=slimit,
+        tol=tol,
+        joint_limits=True,
+        mask=mask,
+        k=0.1,
+        method="sugihara",
+    ),
+]
+
+solver_names = [
+    "Newton Raphson",
+    "Gauss Newton",
+    "LM Chan",
+    "LM Wampler",
+    "LM Sugihara",
+]
+
+print(
+    f"\nNumerical Inverse Kinematics Methods benchmark:\n"
+    f"  * running on {cpu_info()},\n"
+    f"  * robot is {robot.name} with {robot.n} DoF,\n"
+    f"  * ik_XX and ikine_XX (C++ ETS) columns use {nproblems} random configurations,\n"
+    f"  * ikine_XX (pure Python ETS) column uses {nproblems_slow} (too slow at {nproblems}).\n"
+    f"\nTime per IK solution:\n"
+)
+
+ik_times: list[float] = []
+ikine_cpp_times: list[float] = []
+ikine_py_times: list[float] = []
+
+for solver in ik_solvers:
+    print(".", file=sys.stdout, end="", flush=True)  # show activity
+
+    start = time.time()
+    for i in range(nproblems):
+        solver(Tep[i])
+    ik_times.append(time.time() - start)
+
+for solver in ikine_solvers:
+    print(".", file=sys.stdout, end="", flush=True)
+
+    start = time.time()
+    for i in range(nproblems):
+        solver(Tep[i])
+    ikine_cpp_times.append(time.time() - start)
+
+# Force the pure-Python ETS fallback: a fresh ETS starts with no C++ handle
+# built, and robot.ets() returns a cached instance, so dirty this one's
+# cache while _C_AVAILABLE is patched off to make it rebuild as pure-Python.
+fknm._C_AVAILABLE = False
+ets._fknm_stale = True
+
+for solver in ikine_solvers:
+    print(".", file=sys.stdout, end="", flush=True)
+
+    start = time.time()
+    for i in range(nproblems_slow):
+        solver(Tep[i])
+    ikine_py_times.append(time.time() - start)
+
+fknm._C_AVAILABLE = True
+ets._fknm_stale = True
+
+print("\r", end="")  # clear the progress line
+
+table = ANSITable(
+    Column("Method", colalign="<", headalign="^"),
+    Column("ik_XX (μs)", fmt="{:.1f}", headalign="^"),
+    Column("ikine_XX, C++ ETS (μs)", fmt="{:.1f}", headalign="^"),
+    Column("ikine_XX, pure Python ETS (μs)", fmt="{:.1f}", headalign="^"),
+    border="thin",
+)
+
+for name, ik_t, ikine_cpp_t, ikine_py_t in zip(
+    solver_names, ik_times, ikine_cpp_times, ikine_py_times
+):
+    table.row(
+        name,
+        (ik_t / nproblems) * 1e6,
+        (ikine_cpp_t / nproblems) * 1e6,
+        (ikine_py_t / nproblems_slow) * 1e6,
+    )
+
+table.print()

{roboticstoolbox_python-1.4.1 → roboticstoolbox_python-1.4.2}/examples/ikine_evaluate.py

@@ -31,31 +31,25 @@ elif example == "panda":
 #  - the statement to execute for timeit
 ikfuncs = [
     (
-        robot.ikine_LM,  # Levenberg-Marquadt
+        lambda T, q0: robot.ikine_LM(T, q0=q0),  # Levenberg-Marquadt
         "ikine_LM",
-        "sol = robot.ikine_LM(T, q0)",
+        "sol = robot.ikine_LM(T, q0=q0)",
     ),
     (
-        robot.ikine_LMS,  # Levenberg-Marquadt (Sugihara)
-        "ikine_LMS",
-        "sol = robot.ikine_LMS(T, q0)",
+        lambda T, q0: robot.ikine_LM(T, q0=q0, method="sugihara", k=0.0001),
+        "ikine_LM (sugihara)",
+        "sol = robot.ikine_LM(T, q0=q0, method='sugihara', k=0.0001)",
     ),
     (
-        robot.ikine_min,  # numerical solution with no constraints
-        "ikine_min(qlim=False)",
-        "sol = robot.ikine_min(T, q0)",
+        lambda T, q0: robot.ikine_LM(T, q0=q0, joint_limits=False),
+        "ikine_LM(qlim=False)",
+        "sol = robot.ikine_LM(T, q0=q0, joint_limits=False)",
     ),
     (
-        lambda T, q0: robot.ikine_min(
-            T, q0, qlim=True
-        ),  # numerical solution with constraints
-        "ikine_min(qlim=True)",
-        "sol = robot.ikine_min(T, q0, qlim=True)",
+        lambda T, q0: robot.ikine_LM(T, q0=q0, joint_limits=True),
+        "ikine_LM(qlim=True)",
+        "sol = robot.ikine_LM(T, q0=q0, joint_limits=True)",
     ),
-    # (robot.ikine_mmc, #numerical solution with no constraints
-    #     "ikine_min(qlim=False)",
-    #     "sol = robot.ikine_min(T, q0)"
-    # ),
 ]
 if hasattr(robot, "ikine_a"):
     a = (

{roboticstoolbox_python-1.4.1 → roboticstoolbox_python-1.4.2}/examples/readme.py

@@ -11,7 +11,9 @@ print(T)
 # IK
 
 T = SE3(0.7, 0.2, 0.1) * SE3.OA([0, 1, 0], [0, 0, -1])
-sol = robot.ikine_LMS(T)  # solve IK, ignore additional outputs
+sol = robot.ikine_LM(
+    T, method="sugihara", k=0.0001
+)  # solve IK, ignore additional outputs
 print(sol.q)  # display joint angles
 # FK shows that desired end-effector pose was achieved
 print(robot.fkine(sol.q))

{roboticstoolbox_python-1.4.1 → roboticstoolbox_python-1.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ name = "roboticstoolbox-python"
 
 description = "A Python library for robotics education and research"
 
-version = "1.4.1"
+version = "1.4.2"
 
 authors = [
     { name = "Jesse Haviland", email = "j.haviland@qut.edu.au" },

{roboticstoolbox_python-1.4.1 → roboticstoolbox_python-1.4.2}/src/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_python-1.4.1 → roboticstoolbox_python-1.4.2}/src/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_python-1.4.1 → roboticstoolbox_python-1.4.2}/src/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_python-1.4.1 → roboticstoolbox_python-1.4.2}/src/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]