komo_1_intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "dffc232a",
   "metadata": {},
   "source": [
    "# Intro: KOMO - Motion Optimization\n",
    "\n",
    "KOMO is a framework for designing motion by formulating optimization problems. Inverse kinematics (IK) is the special case of optimizing only over a single configuration rather than a path. Formulating KOMO problems is key to realizing motion in `rai`.\n",
    "\n",
    "The [Script:Inverse Kinematics](https://marctoussaint.github.io/robotics-course/script/script.html#general-concept-of-differentiable-features) and the [Appendix:NLP Interface](https://marctoussaint.github.io/robotics-course/script/script.html#nlp-interface) provide the mathematical background on inverse kinematics and especially the convention of how NLPs can be defined by adding objectives.\n",
    "\n",
    "This tutorial shows how IK, rough waypoint optimization, and fine path optimization can be formulated as non-linear mathematical program (NLP) using KOMO. Essentially, the `addObjective` allows to add costs or constraints over any `Feature` to the NLP (same features that can be evaluated with `C.eval`)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a177972b",
   "metadata": {},
   "source": [
    "## Minimal IK example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e07bf36",
   "metadata": {},
   "outputs": [],
   "source": [
    "import robotic as ry\n",
    "import numpy as np\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "059a8ee7",
   "metadata": {},
   "outputs": [],
   "source": [
    "C = ry.Config()\n",
    "C.addFile(ry.raiPath('scenarios/pandaSingle.g'))\n",
    "C.view()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "582b68ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "C.addFrame('box') \\\n",
    "    .setPosition([-.25,.1,1.]) \\\n",
    "    .setShape(ry.ST.ssBox, size=[.06,.06,.06,.005]) \\\n",
    "    .setColor([1,.5,0]) \\\n",
    "    .setContact(1)\n",
    "C.view()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac059dc2",
   "metadata": {},
   "source": [
    "The following defines an optimization problem over a single configuration. The KOMO object essentially contains:\n",
    "1. Copies of the configuration(s) over which we optimize\n",
    "2. The list of objectives (=costs & constraints) that define the optimization problem.\n",
    "\n",
    "The constructor declares over how many configurations (single, waypoints, path..) we optimize. The addObjective methods add costs or constraints:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bccb7b55",
   "metadata": {},
   "outputs": [],
   "source": [
    "qHome = C.getJointState()\n",
    "\n",
    "komo = ry.KOMO(C, phases=1, slicesPerPhase=1, kOrder=0, enableCollisions=False)\n",
    "komo.addObjective(\n",
    "    times=[], \n",
    "    feature=ry.FS.jointState, \n",
    "    frames=[],\n",
    "    type=ry.OT.sos, \n",
    "    scale=[1e-1], \n",
    "    target=qHome\n",
    ")\n",
    "komo.addObjective([], ry.FS.positionDiff, ['l_gripper', 'box'], ry.OT.eq, [1e1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76895850",
   "metadata": {},
   "source": [
    "We explain the KOMO constructor arguments later. (The above defines an IK problem.)\n",
    "\n",
    "The `addObjective` method has signature\n",
    "\n",
    "* `times`: the time intervals (subset of configurations in a path) over which this feature is active (irrelevant for IK)\n",
    "* `feature`: the feature symbol (see advanced `Feature` tutorial)\n",
    "* `frames`: the frames for which the feature is computed, given as list of frame names\n",
    "* `type`: whether this is a sum-of-squares (sos) cost, or eq or ineq constraint\n",
    "* `scale`: the matrix(!) by which the feature is multiplied\n",
    "* `target`: the offset which is substracted from the feature (before scaling)\n",
    "\n",
    "Please see more formal details [here](https://marctoussaint.github.io/robotics-course/script/script.html#nlp-interface)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e27cfa8",
   "metadata": {},
   "source": [
    "Given this definition of an optimization problem, we can call a generic NLP solver:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "178e3d42",
   "metadata": {},
   "outputs": [],
   "source": [
    "ret = ry.NLP_Solver(komo.nlp(), verbose=4) .solve()\n",
    "print(ret)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5481e8b8",
   "metadata": {},
   "source": [
    "With this high verbosity, individual newton steps and Augmented Lagrangian outer loops are displayed (we need only very few steps here).\n",
    "\n",
    "The KOMO view displays the optimized configuration(s) stored by KOMO. (For paths, this is an overlay of many configurations. For IK, just one.):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b727e37c",
   "metadata": {},
   "outputs": [],
   "source": [
    "komo.view(False, \"IK solution\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10840e1f",
   "metadata": {},
   "source": [
    "We can get the sequence of joint state vectors for the optimized configuration(s) with `getPath`. Since this is only an IK problem, the sequence contains only the joint state vector for the single optimized configuration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5adc15f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "q = komo.getPath()\n",
    "print(type(q), len(q))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f92e896",
   "metadata": {},
   "source": [
    "We're done with KOMO and can destroy it. Then set the optimal joint state in C and view it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b20fc581",
   "metadata": {},
   "outputs": [],
   "source": [
    "del komo #also closes komo view\n",
    "C.setJointState(q[0])\n",
    "C.view()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57ccf739",
   "metadata": {},
   "source": [
    "## Example for more constraints: box grasping IK\n",
    "\n",
    "The key to design motions is to add clever constraints. Here is an example for more realistic box grasping:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bdbbbe7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "komo = ry.KOMO(C, 1,1,0, True)\n",
    "komo.addObjective([], ry.FS.jointState, [], ry.OT.sos, [1e-1], qHome)\n",
    "komo.addObjective([], ry.FS.accumulatedCollisions, [], ry.OT.eq)\n",
    "komo.addObjective([], ry.FS.jointLimits, [], ry.OT.ineq)\n",
    "komo.addObjective([], ry.FS.positionDiff, ['l_gripper', 'box'], ry.OT.eq, [1e1])\n",
    "komo.addObjective([], ry.FS.scalarProductXX, ['l_gripper', 'box'], ry.OT.eq, [1e1], [0])\n",
    "komo.addObjective([], ry.FS.scalarProductXZ, ['l_gripper', 'box'], ry.OT.eq, [1e1], [0])\n",
    "komo.addObjective([], ry.FS.distance, ['l_palm', 'box'], ry.OT.ineq, [1e1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de8fe5b5",
   "metadata": {},
   "source": [
    "The two `scalarProduct` feature state that the gripper x-axis (which is the axis connecting the fingers) should be orthogonal to the object x- and z-axes. That implies fingers to normally oppose the object's y-planes.\n",
    "\n",
    "Note that grasping could also be opposing the object x- or z- planes -- see below. Let solve it and then set the joint state to the solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dab4fbee",
   "metadata": {},
   "outputs": [],
   "source": [
    "ret = ry.NLP_Solver(komo.nlp(), verbose=0 ) .solve()\n",
    "print(ret)\n",
    "if ret.feasible:\n",
    "    print('-- Always check feasibility flag of NLP solver return')\n",
    "else:\n",
    "    print('-- THIS IS INFEASIBLE!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1970bb1",
   "metadata": {},
   "outputs": [],
   "source": [
    "q = komo.getPath()\n",
    "C.setJointState(q[0])\n",
    "C.view(False, \"IK solution\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bef1a139",
   "metadata": {},
   "source": [
    "Reusing the KOMO instance is ok if some aspect of the configuration changes and you want to resolve the same problem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2d386d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "box = C.getFrame('box')\n",
    "box.setPosition([-.25,.1,1.])\n",
    "p0 = box.getPosition() # memory the start box position\n",
    "\n",
    "for t in range(10):\n",
    "    box.setPosition(p0 + .2 * np.random.randn(3)) # randomize box position\n",
    "    komo.updateRootObjects(C) # only works for root objects (the 'box' is one)\n",
    "    ret = ry.NLP_Solver(komo.nlp(), verbose=0 ) .solve()\n",
    "    print(ret)\n",
    "    q = komo.getPath()\n",
    "    C.setJointState(q[0])\n",
    "    C.view(False, 'IK solution - ' + ('*** INFEASIBLE ***' if not ret.feasible else 'feasible'))\n",
    "    time.sleep(1.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0e78a35",
   "metadata": {},
   "source": [
    "So the solver finds feasible grasps and exploits the null space of the constraints (grasps from different directions, but always opposing the y-planes).\n",
    "\n",
    "To make this proper, we should actually test all three possible grasps - so let's define 3 IK problems, solve each, and pick the best:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8222658d",
   "metadata": {},
   "outputs": [],
   "source": [
    "del komo\n",
    "komo = []\n",
    "for k in range(3):\n",
    "    komo.append(ry.KOMO(C, 1,1,0, True))\n",
    "    komo[k].addObjective([], ry.FS.jointState, [], ry.OT.sos, [1e-1], qHome)\n",
    "    komo[k].addObjective([], ry.FS.accumulatedCollisions, [], ry.OT.eq)\n",
    "    komo[k].addObjective([], ry.FS.jointLimits, [], ry.OT.ineq)\n",
    "    komo[k].addObjective([], ry.FS.positionDiff, ['l_gripper', 'box'], ry.OT.eq, [1e1])\n",
    "    komo[k].addObjective([], ry.FS.distance, ['l_palm', 'box'], ry.OT.ineq, [1e1])\n",
    "\n",
    "komo[0].addObjective([], ry.FS.scalarProductXY, ['l_gripper', 'box'], ry.OT.eq, [1e1], [0])\n",
    "komo[0].addObjective([], ry.FS.scalarProductXZ, ['l_gripper', 'box'], ry.OT.eq, [1e1], [0])\n",
    "\n",
    "komo[1].addObjective([], ry.FS.scalarProductXX, ['l_gripper', 'box'], ry.OT.eq, [1e1], [0])\n",
    "komo[1].addObjective([], ry.FS.scalarProductXZ, ['l_gripper', 'box'], ry.OT.eq, [1e1], [0])\n",
    "\n",
    "komo[2].addObjective([], ry.FS.scalarProductXX, ['l_gripper', 'box'], ry.OT.eq, [1e1], [0])\n",
    "komo[2].addObjective([], ry.FS.scalarProductXY, ['l_gripper', 'box'], ry.OT.eq, [1e1], [0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09c7a057",
   "metadata": {},
   "outputs": [],
   "source": [
    "for t in range(10):\n",
    "    box.setPosition(p0 + .2 * np.random.randn(3))\n",
    "    box.setQuaternion(np.random.randn(4)) # also set random orientation (quaternions get internally normalized)\n",
    "    \n",
    "    score = []\n",
    "    for k in range(3):\n",
    "        komo[k].updateRootObjects(C)\n",
    "        ret = ry.NLP_Solver(komo[k].nlp(), verbose=0 ) .solve()\n",
    "        score.append( 100.*(ret.eq+ret.ineq) + ret.sos )\n",
    "        \n",
    "    k = np.argmin(score)\n",
    "    C.setJointState(komo[k].getPath()[0])\n",
    "    C.view(False, f'IK solution {k} - ' + ('*** INFEASIBLE ***' if not ret.feasible else 'feasible'))\n",
    "    time.sleep(1.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cda905f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "del komo\n",
    "del C"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7d69b02",
   "metadata": {},
   "source": [
    "## Waypoints example\n",
    "\n",
    "Motion design can often be done by computing waypoints, i.e. a coarse-resolution sequence of poses. The BotOp interface can then spline-interpolate between them when executing them.\n",
    "\n",
    "Let's define a configuration where the desired gripper waypoints are pre-defined as marker frames. (That's a common pattern: Simplify defining constraints by adding helper reference frames in the configuration.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6da9bda",
   "metadata": {},
   "outputs": [],
   "source": [
    "C = ry.Config()\n",
    "C.addFile(ry.raiPath('scenarios/pandaSingle.g'))\n",
    "C.addFrame('way1'). setShape(ry.ST.marker, [.1]) .setPosition([.4, .2, 1.])\n",
    "C.addFrame('way2'). setShape(ry.ST.marker, [.1]) .setPosition([.4, .2, 1.4])\n",
    "C.addFrame('way3'). setShape(ry.ST.marker, [.1]) .setPosition([-.4, .2, 1.])\n",
    "C.addFrame('way4'). setShape(ry.ST.marker, [.1]) .setPosition([-.4, .2, 1.4])\n",
    "qHome = C.getJointState()\n",
    "C.view()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53a2b1c8",
   "metadata": {},
   "source": [
    "Now we can define a KOMO problem over 4 configurations, where at each configuration we impose position equality between gripper and a waypoint:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c3a74d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "komo = ry.KOMO(C, phases=4, slicesPerPhase=1, kOrder=1, enableCollisions=False)\n",
    "komo.addControlObjective([], 0, 1e-1)\n",
    "komo.addControlObjective([], 1, 1e0)\n",
    "komo.addObjective([1], ry.FS.positionDiff, ['l_gripper', 'way1'], ry.OT.eq, [1e1])\n",
    "komo.addObjective([2], ry.FS.positionDiff, ['l_gripper', 'way2'], ry.OT.eq, [1e1])\n",
    "komo.addObjective([3], ry.FS.positionDiff, ['l_gripper', 'way3'], ry.OT.eq, [1e1])\n",
    "komo.addObjective([4], ry.FS.positionDiff, ['l_gripper', 'way4'], ry.OT.eq, [1e1])\n",
    "\n",
    "ret = ry.NLP_Solver(komo.nlp(), verbose=0 ) .solve()\n",
    "print(ret)\n",
    "q = komo.getPath()\n",
    "print(q)\n",
    "\n",
    "for t in range(len(q)):\n",
    "    C.setJointState(q[t])\n",
    "    C.view(False, f'waypoint {t}')\n",
    "    time.sleep(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6263d5c",
   "metadata": {},
   "source": [
    "The `KOMO constructor` has arguments:\n",
    "\n",
    "* `config`: the configuration, which is copied once (for IK) or many times (for waypoints/paths) to be the optimization variable\n",
    "* `phases`: the number $P$ of phases (which essentially defines the real-valued interval $[0, P]$ over which objectives can be formulated)\n",
    "* `slicesPerPhase`: the discretizations per phase -> in total we have $\\texttt{phases} \\cdot \\texttt{slicesPerPhases}$ configurations which form the path and over which we optimize\n",
    "* `kOrder`: the \"Markov-order\", i.e., maximal tuple of configurations over which we formulate features (e.g. take finite differences)\n",
    "* enableCollisions: if True, KOMO runs a broadphase collision check (using libFCL) in each optimization step -- only then accumulative collision/penetration features will correctly evaluate to non-zero. But this is costly.\n",
    "\n",
    "In our waypoint case: We have 4 phases, one for each waypoint. We don't sub-sample the motion between waypoints, which is why we have slicesPerPhase=1. We formulate this as a 1-order problem: Some features take the finite difference between consecutive configurations (namely, to penalize velocities).\n",
    "\n",
    "The `addControlObjective` is /almost/ the same as adding a `FS.jointState` objective: It penalizes distances in joint space. It has three arguments:\n",
    "\n",
    "* `times`: (as for `addObjective`) the phase-interval in which this objective holds; [] means all times\n",
    "* `order`: Do we penalize the jointState directly (order=0: penalizing sqr distance to qHome, order=1: penalizing sqr distances between consecutive configurations (velocities), order=2: penalizing accelerations across 3 configurations)\n",
    "* `scale`: as usual, but modulated by a factor \"sqrt(delta t)\" that somehow ensures total control costs in approximately independent of the choice of stepsPerPhase\n",
    "\n",
    "In our waypoint case: We add control costs for both: homing (order 0, ensuring to stay close to homing), and velocities (order 1, penalizing movement between waypoints)\n",
    "\n",
    "And the `addObjective` method now makes use of `times` argument: Specifying [1] means that this objective only holds in the interval [1,1], i.e. at phase-time 1 only."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "132f82a0",
   "metadata": {},
   "source": [
    "## Path example\n",
    "\n",
    "Let's do almost the same, but for a fine path. First order=1, leading to zig-zag, then order=2, leading to smooth path."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd21ae9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note, the slicesPerPhase=10 is the only difference to above\n",
    "C.setJointState(qHome)\n",
    "komo = ry.KOMO(C, 4, 10, 1, False)\n",
    "komo.addControlObjective([], 0, 1e-1) # what happens if you change weighting to 1e0? why?\n",
    "komo.addControlObjective([], 1, 1e0)\n",
    "komo.addObjective([1], ry.FS.positionDiff, ['l_gripper', 'way1'], ry.OT.eq, [1e1])\n",
    "komo.addObjective([2], ry.FS.positionDiff, ['l_gripper', 'way2'], ry.OT.eq, [1e1])\n",
    "komo.addObjective([3], ry.FS.positionDiff, ['l_gripper', 'way3'], ry.OT.eq, [1e1])\n",
    "komo.addObjective([4], ry.FS.positionDiff, ['l_gripper', 'way4'], ry.OT.eq, [1e1])\n",
    "\n",
    "ret = ry.NLP_Solver(komo.nlp(), verbose=0 ) .solve()\n",
    "print(ret)\n",
    "q = komo.getPath()\n",
    "print('size of path:', q.shape)\n",
    "\n",
    "for t in range(q.shape[0]):\n",
    "    C.setJointState(q[t])\n",
    "    C.view(False, f'waypoint {t}')\n",
    "    time.sleep(.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40341e34",
   "metadata": {},
   "outputs": [],
   "source": [
    "# only differences: the kOrder=2, control objective order 2, constrain final jointState velocity to zero\n",
    "C.setJointState(qHome)\n",
    "komo = ry.KOMO(C, 4, 10, 2, False)\n",
    "komo.addControlObjective([], 0, 1e-1) # what happens if you change weighting to 1e0? why?\n",
    "komo.addControlObjective([], 2, 1e0)\n",
    "komo.addObjective([1], ry.FS.positionDiff, ['l_gripper', 'way1'], ry.OT.eq, [1e1])\n",
    "komo.addObjective([2], ry.FS.positionDiff, ['l_gripper', 'way2'], ry.OT.eq, [1e1])\n",
    "komo.addObjective([3], ry.FS.positionDiff, ['l_gripper', 'way3'], ry.OT.eq, [1e1])\n",
    "komo.addObjective([4], ry.FS.positionDiff, ['l_gripper', 'way4'], ry.OT.eq, [1e1])\n",
    "komo.addObjective([4], ry.FS.jointState, [], ry.OT.eq, [1e1], [], order=1)\n",
    "\n",
    "ret = ry.NLP_Solver(komo.nlp(), verbose=0 ) .solve()\n",
    "print(ret)\n",
    "q = komo.getPath()\n",
    "print('size of path:', q.shape)\n",
    "\n",
    "for t in range(q.shape[0]):\n",
    "    C.setJointState(q[t])\n",
    "    C.view(False, f'waypoint {t}')\n",
    "    time.sleep(.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "154ea039",
   "metadata": {},
   "source": [
    "Notice the new last objective! Without it, *final velocity* would not be zero. The last objective constrains the order=1 (i.e. velocity!) of the jointState feature to be zero.\n",
    "\n",
    "Let's plot the trajectory:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d47d887",
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "print(q.shape)\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(q)\n",
    "ax.set_xlabel(\"time slice (0=first-to-be-optimized)\")\n",
    "ax.set_ylabel(\"joint angles\")\n",
    "fig.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "748b6a95",
   "metadata": {},
   "source": [
    "Let's plot the errors/costs of the objectives over time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "add05d33",
   "metadata": {},
   "outputs": [],
   "source": [
    "err = komo.info_objectiveErrorTraces()\n",
    "labels = komo.info_objectiveNames()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(err, label=labels)\n",
    "ax.legend(loc=\"upper left\", prop={'size': 6})\n",
    "ax.set_xlabel(\"time slice (0=first-to-be-optimized)\")\n",
    "ax.set_ylabel(\"objectiv error\")\n",
    "fig.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b6968ec",
   "metadata": {},
   "source": [
    "And here is an interactive widget to slide through the solution. See the KOMO Viewer (raise to top). It follows the slider and displays the top error/cost objectives for the current time slice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3eff36e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib widget\n",
    "from matplotlib.widgets import Slider\n",
    "\n",
    "T = komo.getT()\n",
    "komo.view()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "fig.canvas.toolbar_visible = False\n",
    "fig.canvas.header_visible = False\n",
    "fig.canvas.footer_visible = False\n",
    "fig.subplots_adjust(left=.1, bottom=.2, right=.95, top=.9)\n",
    "\n",
    "ax.set_title('Use the slider to control view; raise KOMO Viewer \"Always on Top\"')\n",
    "ax.plot(err, label=labels)\n",
    "line, = ax.plot([0,0], ax.get_ylim(), linewidth=1.5, color='#b3b3b3')\n",
    "ax.legend(loc=\"upper left\", prop={'size': 6})\n",
    "ax.set_xlabel(\"time slice (0=first-to-be-optimized)\")\n",
    "ax.set_ylabel(\"objective error\")\n",
    "\n",
    "def slider_callback(val):\n",
    "    slice = max(-1, min(T-1, int(val)))\n",
    "    if slice==-1:\n",
    "        komo.view()\n",
    "    else:\n",
    "        komo.view_slice(slice, False)\n",
    "        line.set_xdata([slice, slice])\n",
    "    fig.canvas.draw_idle()\n",
    "\n",
    "axslider = fig.add_axes([0.05, 0.05, 0.9, 0.03])\n",
    "slider = Slider(ax=axslider, label='t', valmin=-1, valmax=T-1, valinit=0)\n",
    "slider.on_changed(slider_callback)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c39b8cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close('all')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08aacd1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "del komo\n",
    "del C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2a93b87",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {
     "118e7ef819c34a2aad5519c09ec55f33": {
      "model_module": "jupyter-matplotlib",
      "model_module_version": "^0.11",
      "model_name": "ToolbarModel",
      "state": {
       "_current_action": "",
       "_dom_classes": [],
       "_model_module": "jupyter-matplotlib",
       "_model_module_version": "^0.11",
       "_model_name": "ToolbarModel",
       "_view_count": null,
       "_view_module": "jupyter-matplotlib",
       "_view_module_version": "^0.11",
       "_view_name": "ToolbarView",
       "button_style": "",
       "collapsed": true,
       "layout": "IPY_MODEL_6ee562bd44d64f55b866d287eca76b22",
       "orientation": "vertical",
       "tabbable": null,
       "toolitems": [
        [
         "Home",
         "Reset original view",
         "home",
         "home"
        ],
        [
         "Back",
         "Back to previous view",
         "arrow-left",
         "back"
        ],
        [
         "Forward",
         "Forward to next view",
         "arrow-right",
         "forward"
        ],
        [
         "Pan",
         "Left button pans, Right button zooms\nx/y fixes axis, CTRL fixes aspect",
         "arrows",
         "pan"
        ],
        [
         "Zoom",
         "Zoom to rectangle\nx/y fixes axis",
         "square-o",
         "zoom"
        ],
        [
         "Download",
         "Download plot",
         "floppy-o",
         "save_figure"
        ]
       ],
       "tooltip": null
      }
     },
     "6ee562bd44d64f55b866d287eca76b22": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "2.0.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "2.0.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border_bottom": null,
       "border_left": null,
       "border_right": null,
       "border_top": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "7d99943a55f446f7b80cfb7d33792506": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "2.0.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "2.0.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border_bottom": null,
       "border_left": null,
       "border_right": null,
       "border_top": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "e7e99007eb644bf189db1d2a8d592d24": {
      "model_module": "jupyter-matplotlib",
      "model_module_version": "^0.11",
      "model_name": "MPLCanvasModel",
      "state": {
       "_cursor": "pointer",
       "_data_url": "data:image/png;base64,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",
       "_dom_classes": [],
       "_figure_label": "Figure",
       "_image_mode": "full",
       "_message": "",
       "_model_module": "jupyter-matplotlib",
       "_model_module_version": "^0.11",
       "_model_name": "MPLCanvasModel",
       "_rubberband_height": 0,
       "_rubberband_width": 0,
       "_rubberband_x": 0,
       "_rubberband_y": 0,
       "_size": [
        640.0,
        480.0
       ],
       "_view_count": null,
       "_view_module": "jupyter-matplotlib",
       "_view_module_version": "^0.11",
       "_view_name": "MPLCanvasView",
       "capture_scroll": false,
       "footer_visible": false,
       "header_visible": false,
       "layout": "IPY_MODEL_7d99943a55f446f7b80cfb7d33792506",
       "pan_zoom_throttle": 33.0,
       "resizable": true,
       "tabbable": null,
       "toolbar": "IPY_MODEL_118e7ef819c34a2aad5519c09ec55f33",
       "toolbar_position": "left",
       "toolbar_visible": false,
       "tooltip": null
      }
     }
    },
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}