scikit-robot 0.4.0__tar.gz → 0.4.2__tar.gz

{scikit_robot-0.4.0/scikit_robot.egg-info → scikit_robot-0.4.2}/PKG-INFO

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

{scikit_robot-0.4.0 → scikit_robot-0.4.2}/pyproject.toml

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

{scikit_robot-0.4.0 → scikit_robot-0.4.2/scikit_robot.egg-info}/PKG-INFO

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

{scikit_robot-0.4.0 → scikit_robot-0.4.2}/scikit_robot.egg-info/SOURCES.txt

@@ -110,7 +110,10 @@ skrobot/interfaces/ros2/base.py
 skrobot/interfaces/ros2/gripper.py
 skrobot/interfaces/ros2/panda.py
 skrobot/kinematics/__init__.py
+skrobot/kinematics/_base_placement_jax.py
+skrobot/kinematics/base_placement.py
 skrobot/kinematics/differentiable.py
+skrobot/kinematics/inverse_reachability_map.py
 skrobot/kinematics/loop_closure.py
 skrobot/kinematics/reachability_map.py
 skrobot/model/__init__.py

scikit_robot-0.4.2/skrobot/backend/math_utils.py

@@ -0,0 +1,78 @@
+"""Backend-agnostic math utilities for differentiable computation.
+
+This module provides common mathematical operations that work with
+any backend (NumPy, JAX) for use in kinematics and dynamics computations.
+"""
+
+import numpy as np
+
+
+# _CROSS[i, j, k] = -epsilon_ijk, so _CROSS @ v is the cross-product
+# matrix of v. One matmul builds it for a single vector or a batch; nested
+# stacks would cost several times as much per call on the NumPy FK path.
+_CROSS = np.zeros((3, 3, 3))
+for _i, _j, _k in ((0, 1, 2), (1, 2, 0), (2, 0, 1)):
+    _CROSS[_i, _j, _k] = -1.0
+    _CROSS[_i, _k, _j] = 1.0
+
+
+def rodrigues_rotation(backend, axis, angle):
+    """Compute rotation matrix from axis-angle using Rodrigues' formula.
+
+    R = I + sin(θ)K + (1-cos(θ))K²
+
+    where K is the skew-symmetric matrix of the normalized axis.
+
+    Parameters
+    ----------
+    backend : DifferentiableBackend or module
+        Backend to use for computation (numpy or jax). The ``numpy`` and
+        ``jax.numpy`` modules work as well.
+    axis : array, shape (3,) or (..., 3)
+        Rotation axis (will be normalized), or a batch of them.
+    angle : float or array, shape () or (...)
+        Rotation angle in radians, one per axis.
+
+    Returns
+    -------
+    rotation : array, shape (3, 3) or (..., 3, 3)
+        Rotation matrix, or one per axis.
+
+    Examples
+    --------
+    >>> from skrobot.backend import get_backend
+    >>> from skrobot.backend.math_utils import rodrigues_rotation
+    >>> backend = get_backend('numpy')
+    >>> axis = backend.array([0.0, 0.0, 1.0])
+    >>> R = rodrigues_rotation(backend, axis, 0.5)
+    """
+    # Normalize axis
+    axis = axis / (backend.sqrt((axis ** 2).sum(axis=-1, keepdims=True))
+                   + 1e-10)
+    K = skew_symmetric(backend, axis)
+
+    # Rodrigues formula
+    sin = backend.sin(angle)[..., None, None]
+    cos = backend.cos(angle)[..., None, None]
+    return backend.eye(3) + sin * K + (1.0 - cos) * (K @ K)
+
+
+def skew_symmetric(backend, v):
+    """Create skew-symmetric matrix from a 3D vector.
+
+    The skew-symmetric matrix [v]_× satisfies: [v]_× @ u = v × u
+
+    Parameters
+    ----------
+    backend : DifferentiableBackend or module
+        Backend to use for computation. The ``numpy`` and ``jax.numpy``
+        modules work as well.
+    v : array, shape (3,) or (..., 3)
+        Input vector, or a batch of them.
+
+    Returns
+    -------
+    K : array, shape (3, 3) or (..., 3, 3)
+        Skew-symmetric matrix, or one per vector.
+    """
+    return (_CROSS @ v[..., None, :, None])[..., 0]

{scikit_robot-0.4.0 → scikit_robot-0.4.2}/skrobot/coordinates/base.py

@@ -1794,6 +1794,7 @@ class CascadedCoords(Coordinates):
                     "`relative_coords`'s type should be"
                     "skrobot.coordinates.Coordinates, but is {}"
                     .format(type(relative_coords)))
+            # The parent setter removes child from its previous parent.
             child.parent = self
             child.newcoords(relative_coords, check_validity=False, relative_coords='local')
             self._descendants.append(child)
@@ -1997,7 +1998,8 @@ class CascadedCoords(Coordinates):
         """Rotate this coordinate.
 
         Rotate this coordinate relative to axis by theta radians
-        with respect to wrt.
+        with respect to wrt. The origin of this coordinate is kept for
+        every ``wrt``; only its orientation changes.
 
         Parameters
         ----------
@@ -2006,6 +2008,13 @@ class CascadedCoords(Coordinates):
         axis : str or numpy.ndarray
             'x', 'y', 'z' or vector
         wrt : str or Coordinates
+            Frame in which ``axis`` is expressed.
+
+            - ``'local'`` or ``self``: this coordinate's own axes.
+            - ``'parent'`` or the parent object: the parent's axes. Without
+              a parent, this is the world frame.
+            - ``'world'``: the world axes.
+            - other ``Coordinates``: that coordinate's axes.
         skip_normalization : bool
             if `True`, skip normalization for axis.
 
@@ -2043,22 +2052,9 @@ class CascadedCoords(Coordinates):
         if isinstance(axis, np.ndarray) and axis.shape == (3, 3):
             return self.rotate_with_matrix(theta, wrt)
 
-        if wrt == 'local' or wrt == self:
-            rotation = rotate_matrix_by_axis_angle(
-                self._rotation, theta, axis,
-                skip_normalization=skip_normalization)
-            return self.newcoords(rotation, self._translation,
-                                  check_validity=False, relative_coords='local')
-        elif wrt == 'parent' or wrt == self.parent:
-            rotation = rotate_matrix_by_axis_angle(
-                self._rotation, theta, axis,
-                skip_normalization=skip_normalization)
-            return self.newcoords(rotation, self._translation,
-                                  check_validity=False, relative_coords='local')
-        else:
-            return self.rotate_with_matrix(
-                rotation_matrix(theta, axis,
-                                skip_normalization=skip_normalization), wrt)
+        return self.rotate_with_matrix(
+            rotation_matrix(theta, axis,
+                            skip_normalization=skip_normalization), wrt)
 
     def orient_with_matrix(self, rotation_matrix, wrt='world'):
         """Force update this coordinate system's rotation.
@@ -2192,7 +2188,27 @@ class CascadedCoords(Coordinates):
         if not (c is None or coordinates_p(c)):
             raise ValueError('parent should be None or Coordinates. '
                              'get type=={}'.format(type(c)))
+        previous = getattr(self, '_parent', None)
+        if previous is c:
+            self._parent = c
+            return
+        # A parent chain through self would make worldcoords() recurse
+        # forever.
+        ancestor = c
+        while ancestor is not None:
+            if ancestor is self:
+                raise ValueError(
+                    'Cannot make {!r} a parent of {!r}: it is already one '
+                    'of its descendants.'.format(c.name, self.name))
+            ancestor = getattr(ancestor, 'parent', None)
+        # Leave the previous parent's descendants, so that re-parenting by
+        # either assoc or a direct assignment leaves no stale entry there.
+        if (isinstance(previous, CascadedCoords)
+                and self in previous._descendants):
+            previous._descendants.remove(self)
         self._parent = c
+        # The cached world pose was taken under the previous parent.
+        self.changed()
 
     def __getstate__(self):
         assert self._worldcoords._hook == self.update

{scikit_robot-0.4.0 → scikit_robot-0.4.2}/skrobot/export/usd.py

@@ -3,8 +3,12 @@
 Walks the raw parsed URDF and emits a USD stage with a UsdPhysics
 articulation -- one rigid body per link (mass + regularized inertia), visual meshes embedded with
 per-vertex ``displayColor`` (USD renders vertex colours natively, unlike STL/
-MJCF), convex collision meshes, and revolute/prismatic/fixed joints (limits +
-position drives). A fixed joint welds the base to the world.
+MJCF) and, when the mesh file carries a PBR material (glTF ``metallicFactor`` /
+``roughnessFactor``, as sw2robot writes them from the SolidWorks appearance), a
+``UsdPreviewSurface`` material bound to the mesh so Isaac Sim's RTX renderer
+shows aluminium as aluminium; convex collision meshes, and
+revolute/prismatic/fixed joints (limits + position drives). A fixed joint welds
+the base to the world.
 
 USD authoring only needs ``usd-core`` (pip), so this runs anywhere -- author the
 USD on a laptop, load it in Isaac Sim on a GPU box. Entry point: :func:`urdf_to_usd`.
@@ -318,9 +322,33 @@ def _inertia_from_mesh(link, mass, return_reason=False):
     return None, last_error
 
 
+def _submesh_pbr(m):
+    """``(metallic, roughness, name)`` of a sub-mesh's PBR material, or None
+    when its visual carries no metallic/roughness (vertex colours, COLLADA
+    diffuse, no material at all).  glTF is the one URDF mesh format that can
+    say how shiny a part is; trimesh exposes it as ``visual.material`` with
+    ``metallicFactor`` / ``roughnessFactor``."""
+    mat = getattr(getattr(m, "visual", None), "material", None)
+    if mat is None:
+        return None
+    metallic = getattr(mat, "metallicFactor", None)
+    roughness = getattr(mat, "roughnessFactor", None)
+    if metallic is None and roughness is None:
+        return None
+    try:
+        metallic = 0.0 if metallic is None else float(metallic)
+        roughness = 0.5 if roughness is None else float(roughness)
+    except (TypeError, ValueError):
+        return None
+    name = getattr(mat, "name", None)
+    return (min(max(metallic, 0.0), 1.0), min(max(roughness, 0.0), 1.0),
+            str(name) if name else None)
+
+
 def _submesh_geometry(mesh_geometry):
-    """Yield (points, face_counts, face_indices, per_vertex_rgb_or_None, scale)
-    for each sub-mesh of a URDF Mesh geometry."""
+    """Yield (points, face_counts, face_indices, per_vertex_rgb_or_None, pbr)
+    for each sub-mesh of a URDF Mesh geometry; ``pbr`` is
+    :func:`_submesh_pbr` of that sub-mesh."""
     import trimesh
     subs = [m for m in (getattr(mesh_geometry, "meshes", None) or [])
             if isinstance(m, trimesh.Trimesh) and len(m.faces) > 0]
@@ -360,7 +388,7 @@ def _submesh_geometry(mesh_geometry):
                     c = c / 255.0
                 rgb = [c[:3].tolist()]
                 break
-        yield pts.tolist(), counts, indices, rgb
+        yield pts.tolist(), counts, indices, rgb, _submesh_pbr(m)
 
 
 def urdf_to_usd(urdf, out_path, floating_base=False, drive_stiffness=1000.0,
@@ -797,7 +825,7 @@ def _emit_one(stage, UsdGeom, UsdPhysics, Gf, Vt, link_path, vc, index, collisio
         # would make a huge degenerate convex hull that NaNs the articulation.
         if len(submeshes) > 1:
             cents = [np.mean(np.asarray(pts, dtype=float), axis=0)
-                     if pts else np.zeros(3) for pts, _, _, _ in submeshes]
+                     if pts else np.zeros(3) for pts, _, _, _, _ in submeshes]
             med = np.median(np.array(cents), axis=0)
             dist = [float(np.linalg.norm(c - med)) for c in cents]
             threshold = max(0.15, 3.0 * float(np.median(dist)))
@@ -806,7 +834,7 @@ def _emit_one(stage, UsdGeom, UsdPhysics, Gf, Vt, link_path, vc, index, collisio
         all_counts = []
         all_idx = []
         offset = 0
-        for pts, counts, idx, _rgb in submeshes:
+        for pts, counts, idx, _rgb, _pbr in submeshes:
             all_pts.extend(pts)
             all_counts.extend(counts)
             all_idx.extend(int(j) + offset for j in idx)
@@ -867,16 +895,18 @@ def _emit_one(stage, UsdGeom, UsdPhysics, Gf, Vt, link_path, vc, index, collisio
     urdf_rgb = _visual_rgb(vc)
 
     # visual: URDF material colour if given, else keep per-submesh colors
-    for sub_i, (pts, counts, idx, rgb) in enumerate(submeshes):
+    for sub_i, (pts, counts, idx, rgb, pbr) in enumerate(submeshes):
         p = link_path.AppendChild("visual_{}_{}".format(index, sub_i))
         mesh = UsdGeom.Mesh.Define(stage, p)
         mesh.CreatePointsAttr(Vt.Vec3fArray([Gf.Vec3f(*v) for v in pts]))
         mesh.CreateFaceVertexCountsAttr(Vt.IntArray(counts))
         mesh.CreateFaceVertexIndicesAttr(Vt.IntArray(idx))
         mesh.AddTransformOp().Set(_mat_to_gf(None, origin))
+        lin = None
         if urdf_rgb is not None:
             dc = mesh.CreateDisplayColorPrimvar(UsdGeom.Tokens.constant)
             dc.Set(Vt.Vec3fArray([Gf.Vec3f(*urdf_rgb)]))
+            lin = np.asarray([urdf_rgb], dtype=float)
         elif rgb is not None:
             # Mesh colours are sRGB too (COLLADA diffuse, glTF baseColorFactor),
             # so they need the same linearisation as the URDF ones.
@@ -887,6 +917,52 @@ def _emit_one(stage, UsdGeom, UsdPhysics, Gf, Vt, link_path, vc, index, collisio
                 UsdGeom.Tokens.vertex if len(rgb) == len(pts)
                 else UsdGeom.Tokens.constant)
             dc.Set(Vt.Vec3fArray([Gf.Vec3f(*c) for c in lin.tolist()]))
+        if pbr is not None:
+            # displayColor alone renders as a dielectric in RTX; the glTF
+            # metallic / roughness only reach the renderer through a bound
+            # UsdPreviewSurface, with the (one) colour as its diffuseColor.
+            diffuse = (np.mean(lin, axis=0).tolist() if lin is not None
+                       else [0.75, 0.75, 0.75])
+            material = _preview_surface(stage, diffuse, pbr)
+            from pxr import UsdShade
+            UsdShade.MaterialBindingAPI.Apply(mesh.GetPrim()).Bind(material)
+
+
+_LOOKS_PATH = "/robot/Looks"
+
+
+def _preview_surface(stage, diffuse_rgb, pbr):
+    """A ``UsdPreviewSurface`` material under ``/robot/Looks`` for a linear
+    diffuse colour and ``(metallic, roughness, name)``; one prim per distinct
+    combination, reused across meshes (a frame of forty aluminium extrusions
+    gets one material, not forty)."""
+    from pxr import Gf
+    from pxr import Sdf
+    from pxr import UsdGeom
+    from pxr import UsdShade
+
+    metallic, roughness, name = pbr
+    key = "{}_{:02x}{:02x}{:02x}_m{:02d}_r{:02d}".format(
+        sanitize_name(name) if name else "material",
+        *[int(round(min(max(c, 0.0), 1.0) * 255)) for c in diffuse_rgb[:3]],
+        int(round(metallic * 99)), int(round(roughness * 99)))
+    path = Sdf.Path(_LOOKS_PATH).AppendChild(key)
+    prim = stage.GetPrimAtPath(path)
+    if prim.IsValid():
+        return UsdShade.Material(prim)
+    if not stage.GetPrimAtPath(_LOOKS_PATH).IsValid():
+        UsdGeom.Scope.Define(stage, Sdf.Path(_LOOKS_PATH))
+    material = UsdShade.Material.Define(stage, path)
+    shader = UsdShade.Shader.Define(stage, path.AppendChild("Shader"))
+    shader.CreateIdAttr("UsdPreviewSurface")
+    shader.CreateInput("diffuseColor", Sdf.ValueTypeNames.Color3f).Set(
+        Gf.Vec3f(*[float(c) for c in diffuse_rgb[:3]]))
+    shader.CreateInput("metallic", Sdf.ValueTypeNames.Float).Set(float(metallic))
+    shader.CreateInput("roughness", Sdf.ValueTypeNames.Float).Set(float(roughness))
+    shader.CreateInput("useSpecularWorkflow", Sdf.ValueTypeNames.Int).Set(0)
+    material.CreateSurfaceOutput().ConnectToSource(
+        shader.ConnectableAPI(), "surface")
+    return material
 
 
 def _emit_joint(stage, UsdPhysics, Gf, Sdf, joint, link_path, stiffness, damping,

{scikit_robot-0.4.0 → scikit_robot-0.4.2}/skrobot/interfaces/ros2/base.py

@@ -124,12 +124,79 @@ class ROS2RobotInterfaceBase(Node):
         if wait_for_joint_states:
             self._wait_for_first_joint_state(joint_states_timeout)
 
+        # Action clients and subscriptions add_controller created, so that
+        # set_robot can take them down before building the new ones.
+        self._controller_entities = []
+        self._robot_changed_callbacks = []
         self.controller_table = {}
         self.controller_param_table = {}
         self.controller_type = default_controller
         self.controller_actions = self.add_controller(
             self.controller_type, create_actions=True, joint_enable_check=True)
 
+    def set_robot(self, robot, cancel_motion=True):
+        """Replace the robot model while the interface is running.
+
+        For a robot whose joints or kinematics change at runtime -- a tool
+        change, a module attached or removed -- the model, the joint-state
+        bookkeeping and the controllers have to change together: every
+        angle-vector of this interface is indexed by ``robot.joint_list``, and
+        the controllers come from :meth:`default_controller`, which subclasses
+        compute from that model. Replacing only ``self.robot`` would send the
+        new model's angles to the old controllers in the old order.
+
+        Parameters
+        ----------
+        robot : skrobot.model.RobotModel
+            The new model; copied, as in ``__init__``.
+        cancel_motion : bool
+            Cancel every goal in flight first (default). A trajectory planned
+            for the old model has no meaning for the new one.
+
+        Returns
+        -------
+        skrobot.model.RobotModel
+            The model that was replaced.
+        """
+        if cancel_motion:
+            self.cancel_angle_vector()
+        old = self.robot
+        for entity in self._controller_entities:
+            if isinstance(entity, ActionClient):
+                entity.destroy()
+            else:
+                self.destroy_subscription(entity)
+        self._controller_entities = []
+        self.robot = copy.deepcopy(robot)
+        self.robot_state = dict()
+        self.moving_status = dict()
+        self.prev_moving_status = dict()
+        self._not_updated_joints = []
+        if self._joint_state_msg is not None:
+            # Re-file the latest joint_states against the new joint list, and
+            # put them in the model: a fresh model holds every joint at its
+            # default angle, and anything built from robot.angle_vector() --
+            # angle_vector_from_names, for one -- would command those.
+            self.joint_state_callback(self._joint_state_msg)
+            self.update_robot_state()
+        self.joint_action_enable = True
+        self.controller_table = {}
+        self.controller_param_table = {}
+        self.controller_actions = self.add_controller(
+            self.controller_type, create_actions=True, joint_enable_check=True)
+        for callback in list(self._robot_changed_callbacks):
+            callback(old, self.robot)
+        return old
+
+    def add_robot_changed_callback(self, callback):
+        """Call ``callback(old_robot, new_robot)`` after each :meth:`set_robot`.
+
+        For code that holds the model (or links and joints of it): after a
+        change those are the old model's and must be fetched again from
+        ``self.robot``.
+        """
+        self._robot_changed_callbacks.append(callback)
+
     def _check_time(self, time, fastest_time, time_scale):
         """Check and Return send angle vector time
 
@@ -446,6 +513,7 @@ class ROS2RobotInterfaceBase(Node):
                 action = ControllerActionClient(self,
                                                 controller_action,
                                                 controller['action_type'])
+                self._controller_entities.append(action._action_client)
                 tmp_actions.append(action)
                 tmp_actions_name.append(controller_action)
                 if 'controller_type' in controller:
@@ -492,16 +560,16 @@ class ROS2RobotInterfaceBase(Node):
                 # Bind the key of this controller now. A bare closure reads
                 # the loop variable when a message arrives, so every
                 # subscription would store under the last controller's key.
-                self.create_subscription(
+                self._controller_entities.append(self.create_subscription(
                     control_msgs.msg.JointTrajectoryControllerState,
                     controller_state_topic_name,
                     partial(self.set_robot_state, controller_state),
-                    10)
-                self.create_subscription(
+                    10))
+                self._controller_entities.append(self.create_subscription(
                     action_msgs.msg.GoalStatusArray,
                     trajectory_status_topic_name,
                     partial(self.set_moving_status, param['controller_type']),
-                    10)
+                    10))
         else:
             self.controller_type = controller_type
         self.controller_table[controller_type] = tmp_actions
@@ -563,8 +631,11 @@ class ROS2RobotInterfaceBase(Node):
 
         Parameters
         ----------
-        av : list or numpy.ndarray
-            joint angle vector
+        av : list, numpy.ndarray or dict
+            joint angle vector, or ``{joint name: angle}`` for the joints to
+            move -- the others keep the model's current angles. A dict does
+            not depend on the order of ``robot.joint_list``, which changes
+            when the model does (see :meth:`set_robot`).
         time : None or float
             time to goal in [sec]
             if designated time is faster than fastest speed, use fastest speed
@@ -587,6 +658,8 @@ class ROS2RobotInterfaceBase(Node):
         if av is None:
             self.update_robot_state(wait_until_update=True)
             return self.robot.angle_vector()
+        if isinstance(av, dict):
+            av = self.angle_vector_from_names(av)
         if controller_type is None:
             controller_type = self.controller_type
         if controller_type not in self.controller_table:
@@ -619,6 +692,45 @@ class ROS2RobotInterfaceBase(Node):
                 traj_points)
         return av
 
+    def angle_vector_from_names(self, angles):
+        """An angle vector of the current model with ``angles`` set by name.
+
+        Parameters
+        ----------
+        angles : dict
+            ``{joint name: angle}``.
+
+        Returns
+        -------
+        numpy.ndarray
+            ``robot.angle_vector()`` with those joints replaced.
+
+        Raises
+        ------
+        KeyError
+            If a name is not a joint of the current model: dropping it would
+            send a motion without the joint the caller asked to move.
+        ValueError
+            If a joint left out has never been reported on joint_states: its
+            angle in the model is a default, not a pose, and the vector would
+            send it there.
+        """
+        names = [joint.name for joint in self.robot.joint_list]
+        unknown = sorted(set(angles) - set(names))
+        if unknown:
+            raise KeyError('not joints of {}: {}'.format(
+                self.robot.name, ', '.join(unknown)))
+        unmeasured = sorted(set(names) - set(angles) - self._received_joint_names)
+        if unmeasured:
+            raise ValueError(
+                'never measured, so their angles are defaults, not poses: {}. '
+                'Give them explicitly or wait for joint_states.'.format(
+                    ', '.join(unmeasured)))
+        av = np.array(self.robot.angle_vector(), dtype=np.float64)
+        for name, angle in angles.items():
+            av[names.index(name)] = angle
+        return av
+
     def potentio_vector(self):
         """Returns current robot angle vector, This method uses caced data."""
         return self.robot.angle_vector()

{scikit_robot-0.4.0 → scikit_robot-0.4.2}/skrobot/kinematics/__init__.py

@@ -11,6 +11,12 @@ The algorithms support multiple backends (NumPy, JAX) for
 different performance and autodiff requirements.
 """
 
+# Mobile-base placement for several end-effector targets
+from skrobot.kinematics.base_placement import BasePlacementResult
+from skrobot.kinematics.base_placement import find_base_placement
+from skrobot.kinematics.base_placement import set_base_pose
+from skrobot.kinematics.base_placement import vectorized_target
+
 # Differentiable kinematics (backend-agnostic)
 from skrobot.kinematics.differentiable import create_batch_ik_solver
 from skrobot.kinematics.differentiable import create_dynamic_limit_mask
@@ -18,6 +24,10 @@ from skrobot.kinematics.differentiable import extract_fk_parameters
 from skrobot.kinematics.differentiable import forward_kinematics
 from skrobot.kinematics.differentiable import forward_kinematics_ee
 
+# Inverse reachability map: base poses that reach a hand pose
+from skrobot.kinematics.inverse_reachability_map import BaseCandidates
+from skrobot.kinematics.inverse_reachability_map import InverseReachabilityMap
+
 # Loop-closure solving for cut kinematic loops
 from skrobot.kinematics.loop_closure import LoopClosureSolver
 
@@ -33,4 +43,10 @@ __all__ = [
     'create_dynamic_limit_mask',
     'LoopClosureSolver',
     'ReachabilityMap',
+    'BasePlacementResult',
+    'find_base_placement',
+    'set_base_pose',
+    'vectorized_target',
+    'BaseCandidates',
+    'InverseReachabilityMap',
 ]