scikit-robot 0.4.3__tar.gz → 0.4.4__tar.gz

{scikit_robot-0.4.3/scikit_robot.egg-info → scikit_robot-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scikit-robot
-Version: 0.4.3
+Version: 0.4.4
 Summary: A Flexible Framework for Robot Control in Python
 Author-email: iory <ab.ioryz@gmail.com>
 License: MIT

{scikit_robot-0.4.3 → scikit_robot-0.4.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scikit-robot"
-version = "0.4.3"
+version = "0.4.4"
 description = "A Flexible Framework for Robot Control in Python"
 readme = "README.md"
 license = {text = "MIT"}

{scikit_robot-0.4.3 → scikit_robot-0.4.4/scikit_robot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scikit-robot
-Version: 0.4.3
+Version: 0.4.4
 Summary: A Flexible Framework for Robot Control in Python
 Author-email: iory <ab.ioryz@gmail.com>
 License: MIT

{scikit_robot-0.4.3 → scikit_robot-0.4.4}/scikit_robot.egg-info/SOURCES.txt

@@ -214,6 +214,7 @@ skrobot/viewers/_base.py
 skrobot/viewers/_manipulability_ellipse.py
 skrobot/viewers/_mitsuba.py
 skrobot/viewers/_notebook.py
+skrobot/viewers/_offscreen.py
 skrobot/viewers/_path_utils.py
 skrobot/viewers/_pyrender.py
 skrobot/viewers/_trimesh.py

{scikit_robot-0.4.3 → scikit_robot-0.4.4}/skrobot/model/robot_model.py

@@ -1433,18 +1433,36 @@ class CascadedLink(CascadedCoords):
                 % (use_base,))
         root_link = self._find_fullbody_root_link()
         virtual_link = Link(name='_fullbody_ik_virtual_world')
+        # The virtual joint moves root_link relative to root_link's
+        # coordinate parent (usually the robot model), so the joint's
+        # frame is that parent's world frame. Left at the world origin,
+        # the Jacobian's base columns ignore the robot's own pose: once
+        # the robot is turned, x/y/yaw point the wrong way and the solve
+        # diverges.
+        if root_link.parent is not None:
+            virtual_link.newcoords(root_link.parent.copy_worldcoords())
         state = {
             'root_link': root_link,
             'virtual_link': virtual_link,
             'orig_parent_link': root_link._parent_link,
             'orig_joint': root_link.joint,
             'rel_entries': [],
+            # root_link's own coords, relative to its coordinate parent
+            'orig_local': Coordinates(pos=root_link.translation.copy(),
+                                      rot=root_link.rotation.copy()),
         }
         virtual_joint = joint_cls(
             parent_link=virtual_link,
             child_link=root_link,
             name='_fullbody_ik_base_joint',
         )
+        # joint_angle writes default_coords (+ the joint's motion) into
+        # root_link's local coords, but Joint.__init__ took them from
+        # copy_coords(), which is the world pose: away from the origin,
+        # the first step would move root_link by the robot's own pose.
+        virtual_joint.default_coords = Coordinates(
+            pos=root_link.translation.copy(),
+            rot=root_link.rotation.copy())
         # Detach root_link from its original parent's _child_links before
         # reparenting so the kinematic graph stays consistent (a link must
         # appear in at most one parent's child list at a time).
@@ -1496,6 +1514,18 @@ class CascadedLink(CascadedCoords):
         if self._relevance_predicate_table is not None:
             for key in state['rel_entries']:
                 self._relevance_predicate_table.pop(key, None)
+        # The solve left the base pose in root_link's local coords, i.e.
+        # root_link is now offset from the robot. Move that pose onto the
+        # robot and put root_link back where it was in it, so the robot's
+        # coords are its base pose (as batch IK's base_poses are) and a
+        # later robot.newcoords() does not carry the offset along.
+        if root_link.parent is self:
+            root_world = root_link.copy_worldcoords()
+            root_link.newcoords(state['orig_local'].copy_worldcoords())
+            self.newcoords(
+                root_world.transform(
+                    state['orig_local'].inverse_transformation()),
+                relative_coords='world')
 
     def _attach_batch_virtual_base_chain(self, use_base, link_list):
         """Inject a chain of single-DoF virtual joints above ``root_link``.
@@ -1541,7 +1571,14 @@ class CascadedLink(CascadedCoords):
                 % (use_base,))
 
         root_link = self._find_fullbody_root_link()
+        # The chain starts where root_link stands, so its DoFs move the
+        # base in the base's own frame (as PlanarJoint / FloatingJoint do
+        # with their default_coords). At the world origin they would turn
+        # the robot about the origin, and the angles would mean nothing
+        # without the start pose.
+        root0 = root_link.copy_worldcoords()
         virtual_world = Link(name='_batch_ik_virtual_world')
+        virtual_world.newcoords(root0.copy_worldcoords())
 
         chain_links = []
         chain_joints = []
@@ -1553,6 +1590,7 @@ class CascadedLink(CascadedCoords):
             else:
                 child = Link(name='_batch_ik_virtual_{}_{}'.format(
                     i, axis))
+                child.newcoords(root0.copy_worldcoords())
                 chain_links.append(child)
             if kind == 'lin':
                 j = LinearJoint(
@@ -1592,6 +1630,12 @@ class CascadedLink(CascadedCoords):
             'orig_parent_link': root_link._parent_link,
             'orig_joint': root_link.joint,
             'orig_parent_had_child': False,
+            # The chain's angles move root_link from root0, in its own
+            # frame; keep root0 (and root_link in the robot's frame) so
+            # base_poses can be returned as the robot's world pose.
+            'base_frame': (root0,
+                           self.copy_worldcoords().inverse_transformation()
+                           .transform(root0)),
         }
         # Detach root_link from its original parent's child list before
         # reparenting so the graph stays consistent (a link must appear in
@@ -2800,7 +2844,8 @@ class BatchIKAttempts(object):
 
     def __init__(self, solutions, success, errors, angle_vector,
                  robot_joint_indices, solution_indices,
-                 use_base=None, base_solution_indices=None):
+                 use_base=None, base_solution_indices=None,
+                 base_frame=None):
         self._solutions = solutions
         self.success = success
         self.errors = errors
@@ -2809,6 +2854,7 @@ class BatchIKAttempts(object):
         self._solution_indices = solution_indices
         self._use_base = use_base
         self._base_solution_indices = base_solution_indices
+        self._base_frame = base_frame
         self._angle_vectors = None
         self._base_poses = None
 
@@ -2859,7 +2905,8 @@ class BatchIKAttempts(object):
             indices = self._base_solution_indices
             self._base_poses = [
                 [RobotModel._virtual_chain_angles_to_base_pose(
-                    self._solutions[pose][attempt][indices], self._use_base)
+                    self._solutions[pose][attempt][indices], self._use_base,
+                    self._base_frame)
                  for attempt in range(self.n_attempts)]
                 for pose in range(self._solutions.shape[0])
             ]
@@ -4452,7 +4499,8 @@ class RobotModel(CascadedLink):
             base_solution_indices = np.arange(n_dof, dtype=np.int64)
             base_poses = [
                 self._virtual_chain_angles_to_base_pose(
-                    solutions_np[i, :n_dof], use_base)
+                    solutions_np[i, :n_dof], use_base,
+                    _base_state['base_frame'])
                 for i in range(n_poses)
             ]
 
@@ -4464,20 +4512,38 @@ class RobotModel(CascadedLink):
             joint_indices,
             fk_indices_for_actual_joints,
             use_base=use_base,
-            base_solution_indices=base_solution_indices)
+            base_solution_indices=base_solution_indices,
+            base_frame=(None if _base_state is None
+                        else _base_state['base_frame']))
 
         return BatchIKResult(full_solutions, success_flags, attempt_counts,
                              base_poses=base_poses, attempts=attempts)
 
     @staticmethod
-    def _virtual_chain_angles_to_base_pose(joint_angles, use_base):
+    def _virtual_chain_angles_to_base_pose(joint_angles, use_base,
+                                           base_frame=None):
         """Convert virtual-chain joint angles to a world-frame base pose.
 
         The decomposition in :meth:`_attach_batch_virtual_base_chain` means
         the per-DoF angles compose exactly like the corresponding
         :class:`PlanarJoint` / :class:`FloatingJoint` applied to
         ``default_coords = identity``.
+
+        The angles move root_link from where it stood when the solve
+        started, in its own frame. With ``base_frame`` (root_link's world
+        pose at the start, and root_link in the robot's frame) the result
+        is the robot's world pose, ready for ``robot.newcoords``; without
+        it, the bare move.
         """
+        move = RobotModel._virtual_chain_move(joint_angles, use_base)
+        if base_frame is None:
+            return move
+        root0, root_in_robot = base_frame
+        return root0.copy_worldcoords().transform(move).transform(
+            root_in_robot.inverse_transformation())
+
+    @staticmethod
+    def _virtual_chain_move(joint_angles, use_base):
         if use_base == 'planar':
             x, y, yaw = float(joint_angles[0]), float(joint_angles[1]), float(
                 joint_angles[2])
@@ -4776,7 +4842,7 @@ class RobotModel(CascadedLink):
             virtual_angles = solutions_np[:, virtual_idx_arr]
             base_poses = [
                 self._virtual_chain_angles_to_base_pose(
-                    virtual_angles[i], use_base)
+                    virtual_angles[i], use_base, _base_state['base_frame'])
                 for i in range(n_poses)
             ]
 
@@ -4788,7 +4854,9 @@ class RobotModel(CascadedLink):
             robot_idx_arr.tolist(),
             union_idx_arr.tolist(),
             use_base=use_base,
-            base_solution_indices=virtual_idx_arr)
+            base_solution_indices=virtual_idx_arr,
+            base_frame=(None if _base_state is None
+                        else _base_state['base_frame']))
 
         return BatchIKResult(full_solutions, success_flags, attempt_counts,
                              base_poses=base_poses, attempts=attempts)

{scikit_robot-0.4.3 → scikit_robot-0.4.4}/skrobot/viewers/__init__.py

@@ -71,6 +71,19 @@ except (ImportError, RuntimeError) as error_log:
     class PyrenderViewer(DummyViewer):
         _import_error = error_log
 
+try:
+    from ._offscreen import OffscreenRenderer
+    from ._offscreen import look_at_pose
+    from ._offscreen import merge_by_material
+    from ._offscreen import render_parallel
+except ImportError as error_log:
+    _offscreen_import_error = error_log
+
+    class OffscreenRenderer(object):
+        def __init__(self, *args, **kwargs):
+            raise ImportError('OffscreenRenderer needs pyrender: {}'.format(
+                _offscreen_import_error))
+
 try:
     from ._notebook import JupyterNotebookViewer
 except ImportError:
@@ -114,13 +127,15 @@ _VIEWER_CLASSES = {
     'viser': ViserViewer,
     'notebook': JupyterNotebookViewer,
     'mitsuba': MitsubaViewer,
+    # headless: same calls, nothing on screen (save_image renders the camera's view)
+    'offscreen': OffscreenRenderer,
 }
 
 # Viewer names suitable for a command-line ``--viewer`` choice (every backend
 # except the notebook-only one). Examples import this so a newly added viewer
 # automatically becomes selectable everywhere.
 VIEWER_TYPES = tuple(
-    name for name in _VIEWER_CLASSES if name != 'notebook')
+    name for name in _VIEWER_CLASSES if name not in ('notebook', 'offscreen'))
 
 # Shared ``help=`` text for a ``--viewer`` argparse argument, kept next to
 # VIEWER_TYPES so the wording (and the listed backends) stay in sync.