Added curobo v2 planner interface for SkillGen

docs/pages/advanced/motion_planners.rst

@@ -2,9 +2,34 @@ Motion Planners
 ===============
 
 SkillGen plans collision-free transit motions with a pluggable motion-planner backend. The
-shipped backend is `cuRobo <https://curobo.org/>`_ — GPU-accelerated, collision-aware
+shipped backends both wrap `cuRobo <https://curobo.org/>`_ — GPU-accelerated, collision-aware
 trajectory optimization. Planners live in ``isaac_autodata_interfaces/motion_planners/``.
 
+.. list-table::
+   :widths: 20 20 60
+   :header-rows: 1
+
+   * - ``--planner_backend``
+     - Classes
+     - cuRobo version
+   * - ``curobo`` (default)
+     - ``CuroboPlanner`` / ``CuroboPlannerCfg``
+     - v1 (``curobo.wrap.reacher.motion_gen``)
+   * - ``curobo_v2``
+     - ``CuroboV2Planner`` / ``CuroboV2PlannerCfg``
+     - v2 (``curobo.motion_planner.MotionPlanner``)
+
+Both cuRobo versions install as the same ``curobo`` package at incompatible versions, so each
+backend needs its own environment and only the selected one is ever imported. Resolve a backend
+by name rather than importing a class directly:
+
+.. code-block:: python
+
+   from isaac_autodata_interfaces.motion_planners import get_planner_backend
+
+   planner_cls, config_cls = get_planner_backend("curobo_v2")
+   planner = planner_cls(datastream=datastream, config=config_cls.from_profile("franka_stack_cube"), env_id=0)
+
 The Planner Interface
 ---------------------
 
@@ -36,19 +61,23 @@ constructed per environment (``--num_envs`` planners total).
 cuRobo Backend
 --------------
 
-``CuroboPlanner`` is configured by ``CuroboPlannerCfg``. Configurations are resolved from
-the task id:
+``CuroboPlanner`` is configured by ``CuroboPlannerCfg`` (and ``CuroboV2Planner`` by
+``CuroboV2PlannerCfg``). Both configs expose the same two selectors, so switching backends
+changes no other call site:
 
 .. code-block:: python
 
    from isaac_autodata_interfaces.motion_planners.curobo.curobo_planner_cfg import CuroboPlannerCfg
 
    config = CuroboPlannerCfg.from_task_name("Isaac-Stack-Cube-Franka-IK-Rel-v0")
+   config = CuroboPlannerCfg.from_profile("franka_stack_cube_bin")
 
 ``from_task_name()`` pattern-matches the task id to a named preset (e.g.
 ``franka_config()``, ``franka_stack_cube_bin_config()``); unknown robots fall back to the
-Franka preset with a printed warning. The ``generate_dataset.py`` entry point calls this
-automatically when ``--alg skillgen`` is selected — no CLI flags needed.
+Franka preset. ``from_profile()`` takes a profile name directly, which is how an
+:doc:`environment profile <../concepts/environment_profiles>` pins planner tuning to its
+scene; both backends register the same profile names. The ``generate_dataset.py`` entry
+point resolves the config automatically when ``--alg skillgen`` is selected.
 
 Key configuration fields:
 
@@ -94,10 +123,13 @@ Visualization and Debugging
 ---------------------------
 
 The cuRobo backend can visualize its collision-sphere model and planned trajectories via
-`rerun <https://rerun.io/>`_ (``visualize_spheres`` / ``visualize_plan`` config flags).
-During multi-env generation these are enabled only for env 0 to keep the simulation
-responsive. Planner diagnostics (success rates, timing) are available through
-``get_planner_info()``.
+`rerun <https://rerun.io/>`_ (``visualize_spheres`` / ``visualize_plan`` config flags, or
+``--visualize_plan`` on the CLI). During multi-env generation these are enabled only for env 0
+to keep the simulation responsive. The v2 backend renders in the robot base frame — the frame
+cuRobo collision-checks in — so spheres, obstacles, and the goal marker line up; it draws
+obstacles as their real meshes and colors attached-object spheres separately from the robot's
+own. ``visualize_spheres`` (in-sim sphere spawning) is v1-only. Planner diagnostics are
+available through ``get_planner_info()``.
 
 Adding a New Backend
 --------------------
@@ -107,5 +139,7 @@ Adding a New Backend
 2. Construct your planners where SkillGen expects them — one per env id, exposing
    ``update_world_and_plan_motion(...)`` and ``get_planned_poses()`` (this is all
    ``SkillGen`` requires of a planner).
-3. Wire construction into your entry point the way ``generate_dataset.py`` builds its cuRobo
-   planners (``_build_motion_planners``).
+3. Register the backend in ``motion_planners/__init__.py`` (``_BACKEND_SPECS``) so
+   ``get_planner_backend()`` resolves it by name, and add the name to
+   ``generate_dataset.py``'s ``--planner_backend`` choices. Import your planner lazily from
+   the subpackage's ``__init__``, so selecting a different backend never imports yours.

docs/pages/workflows/skillgen/index.rst

@@ -246,6 +246,11 @@ When motion planning fails for a trial — no collision-free path to the skill s
 trial is abandoned and counted as a failure; with ``guarantee_success: true`` generation
 simply retries with a new scene configuration until the trial target is met.
 
+``--planner_backend`` selects which cuRobo version plans those motions: ``curobo`` (v1,
+the default) or ``curobo_v2``. Both accept every flag shown above; each needs its matching
+cuRobo version installed, so they live in separate environments. See
+:doc:`../../advanced/motion_planners`.
+
 For a full-scale run, raise ``--generation_num_trials`` (hundreds to thousands for policy
 training) and keep ``--viz none`` — rendering slows generation considerably. See
 `Performance and Scaling`_ before choosing ``--num_envs``.

isaac_autodata_interfaces/motion_planners/__init__.py

@@ -3,34 +3,78 @@
 
 """Motion-planner backends for SkillGen.
 
-This branch ships the cuRobo v1 backend only. The package exposes the abstract
-:class:`MotionPlannerBase` and the v1 :class:`CuroboPlanner` / :class:`CuroboPlannerCfg`.
+Two cuRobo backends ship here, selected by name through :func:`get_planner_backend`:
 
-The planner class is imported lazily so the configuration dataclass and the abstract base can be
-loaded in sim-free contexts (e.g. unit tests or CLI argument parsing) without pulling in cuRobo
-or Isaac Lab.
+* ``"curobo"`` — :class:`CuroboPlanner` / :class:`CuroboPlannerCfg`, built on cuRobo v1.
+* ``"curobo_v2"`` — :class:`CuroboV2Planner` / :class:`CuroboV2PlannerCfg`, built on cuRobo v2.
+
+Both implement :class:`MotionPlannerBase` and accept the same profile names, so an entry point
+picks a backend without changing any other logic.
+
+Nothing is imported at module load. Both cuRobo versions install under the ``curobo`` package
+name at incompatible versions and live in separate environments, so importing a backend that is
+not installed would fail. Resolution waits until a backend is requested.
 """
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
-from isaac_autodata_interfaces.motion_planners.curobo import CuroboPlannerCfg
 from isaac_autodata_interfaces.motion_planners.motion_planner_base import MotionPlannerBase
 
 if TYPE_CHECKING:
-    from isaac_autodata_interfaces.motion_planners.curobo import CuroboPlanner
+    from isaac_autodata_interfaces.motion_planners.curobo import CuroboPlanner, CuroboPlannerCfg
+    from isaac_autodata_interfaces.motion_planners.curobo_v2 import CuroboV2Planner, CuroboV2PlannerCfg
 
 __all__ = [
     "MotionPlannerBase",
     "CuroboPlanner",
     "CuroboPlannerCfg",
+    "CuroboV2Planner",
+    "CuroboV2PlannerCfg",
+    "PLANNER_BACKENDS",
+    "get_planner_backend",
 ]
 
+# Backend name -> (subpackage, planner class name, config class name).
+_BACKEND_SPECS: dict[str, tuple[str, str, str]] = {
+    "curobo": ("curobo", "CuroboPlanner", "CuroboPlannerCfg"),
+    "curobo_v2": ("curobo_v2", "CuroboV2Planner", "CuroboV2PlannerCfg"),
+}
+
+PLANNER_BACKENDS: tuple[str, ...] = tuple(_BACKEND_SPECS)
+"""Names of the selectable planner backends, in registration order.
+
+``"curobo"`` is the cuRobo v1 backend and the default; ``"curobo_v2"`` is the cuRobo v2 backend.
+"""
+
+
+def get_planner_backend(name: str) -> tuple[type[MotionPlannerBase], type]:
+    """Resolve a backend name to its planner and configuration classes.
+
+    Importing the backend pulls in the matching cuRobo version, so only the requested backend
+    is loaded.
+
+    Args:
+        name: Backend name; one of :data:`PLANNER_BACKENDS`.
+
+    Returns:
+        The ``(planner_class, config_class)`` pair for the backend. The planner takes
+        ``(datastream, config, env_id)`` and the config exposes ``from_profile`` /
+        ``from_task_name``.
+    """
+    assert name in _BACKEND_SPECS, f"Unknown planner backend {name!r}. Available: {list(PLANNER_BACKENDS)}"
+    import importlib
+
+    subpackage, planner_name, config_name = _BACKEND_SPECS[name]
+    module = importlib.import_module(f"{__name__}.{subpackage}")
+    return getattr(module, planner_name), getattr(module, config_name)
+
 
-def __getattr__(name: str):
-    if name == "CuroboPlanner":
-        from isaac_autodata_interfaces.motion_planners.curobo import CuroboPlanner as _CuroboPlanner
+def __getattr__(name: str) -> Any:
+    for subpackage, planner_name, config_name in _BACKEND_SPECS.values():
+        if name in (planner_name, config_name):
+            import importlib
 
-        return _CuroboPlanner
-    raise AttributeError(f"module 'motion_planners' has no attribute {name!r}")
+            return getattr(importlib.import_module(f"{__name__}.{subpackage}"), name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

isaac_autodata_interfaces/motion_planners/curobo/plan_visualizer.py

@@ -405,7 +405,6 @@ def _clear_visualization(self) -> None:
             for entity in entities:
                 rr.log(f"world/{entity_type}/{entity}", rr.Clear(recursive=True))
             self._sphere_entities[entity_type] = []
-        self._current_frame = 0
 
     def clear_visualization(self) -> None:
         """Public method to clear the visualization."""

isaac_autodata_interfaces/motion_planners/curobo_v2/__init__.py

@@ -0,0 +1,35 @@
+# Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""cuRobo v2 motion-planner backend.
+
+Implements :class:`MotionPlannerBase` on :class:`curobo.motion_planner.MotionPlanner`.
+
+The planner is imported lazily so the configuration can be loaded without a simulator, for
+backend selection or CLI argument parsing. Both cuRobo versions install under the ``curobo``
+package name, so only the selected backend is ever imported.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from isaac_autodata_interfaces.motion_planners.curobo_v2.curobo_v2_planner import CuroboV2Planner
+
+from isaac_autodata_interfaces.motion_planners.curobo_v2.curobo_v2_planner_cfg import CuroboV2PlannerCfg
+
+__all__ = [
+    "CuroboV2Planner",
+    "CuroboV2PlannerCfg",
+]
+
+
+def __getattr__(name: str):
+    if name == "CuroboV2Planner":
+        from isaac_autodata_interfaces.motion_planners.curobo_v2.curobo_v2_planner import (
+            CuroboV2Planner as _CuroboV2Planner,
+        )
+
+        return _CuroboV2Planner
+    raise AttributeError(f"module 'curobo_v2' has no attribute {name!r}")