{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task and Motion Planning via UP Tampest\n",
    "\n",
    "This Python notebook demonstrates how to model and solve a Task and Motion Planning (TAMP) problem using the Unified Planning library and the Tampest engine.\n",
    "\n",
    "[![Open In GitHub](https://img.shields.io/badge/see-Github-579aca?logo=github)](https:///github.com/aiplan4eu/unified-planning/blob/master/docs/notebooks/14-task-and-motion-planning.ipynb)\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/aiplan4eu/unified-planning/blob/master/docs/notebooks/14-task-and-motion-planning.ipynb)\n",
    "\n",
    "## Install Requirements\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "H6za5Bu3IDUE",
    "outputId": "1f2e7a58-8626-40f4-b560-f9375f0c7d3b",
    "tags": [
     "remove_from_CI"
    ]
   },
   "outputs": [],
   "source": [
    "%pip install unified-planning\n",
    "%pip install \"tampest[plot] @ git+https://github.com/fbk-pso/tampest.git\"\n",
    "!yes | pysmt-install --z3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "xd9G9eWIHffc"
   },
   "outputs": [],
   "source": [
    "import math\n",
    "from unified_planning.shortcuts import *\n",
    "from unified_planning.model.motion import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JskjdsH-UFGf"
   },
   "source": [
    "## Creating Movable Robot\n",
    "\n",
    "We declare a type for robots using the `MovableType`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "YLiF_BdnUYYA"
   },
   "outputs": [],
   "source": [
    "t_robot = MovableType(\"robot\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "x7IxmDuPUggo"
   },
   "source": [
    "## Using a Map\n",
    "\n",
    "Next we add an occupancy map by using a reference to a YAML file in the format used by the Robot Operating System (ROS). See http://wiki.ros.org/map_server.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "qkpJ6v9wU14A"
   },
   "outputs": [],
   "source": [
    "occ_map = OccupancyMap(\"./maps/office-map-1.yaml\", SE2(0, 0, 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NGTBaSbNU9df"
   },
   "source": [
    "## Adding Configuration Types\n",
    "\n",
    "A configuration specifies a location and orientation in our map."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "UMtrja_7VO0g"
   },
   "outputs": [],
   "source": [
    "t_robot_config = ConfigurationType(\"robot_config\", occ_map, ConfigurationKind.SE2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WzKtAX8ZVVSh"
   },
   "source": [
    "## Adding Fluents\n",
    "\n",
    "Fluents are added as ususal, but we use our previously added `ConfigurationType` in place of a regular location."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "KOXaF3i9VoC3"
   },
   "outputs": [],
   "source": [
    "t_parcel = UserType(\"parcel\")\n",
    "\n",
    "robot_at = Fluent(\"robot_at\", BoolType(), robot=t_robot, configuration=t_robot_config)\n",
    "parcel_at = Fluent(\"parcel_at\", BoolType(), parcel=t_parcel, configuration=t_robot_config)\n",
    "carries = Fluent(\"carries\", BoolType(), robot=t_robot, parcel=t_parcel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "w2Ir9L0XVtQz"
   },
   "source": [
    "## Creating Configuration Objects\n",
    "\n",
    "Configuration objects combine a symbolic name like `parking-1` with a pose. Each pose is a tuple with the number of elements specified by the configuration type (so three in this case)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "HcXDje1hWXtJ"
   },
   "outputs": [],
   "source": [
    "park1 = ConfigurationObject(\"parking-1\", t_robot_config, SE2(46.0, 26.0, -math.pi / 2))\n",
    "park2 = ConfigurationObject(\"parking-2\", t_robot_config, SE2(40.0, 26.0, -math.pi / 2))\n",
    "\n",
    "office1 = ConfigurationObject(\"office-1\", t_robot_config, SE2(4.0, 4.0, -math.pi / 2))\n",
    "office2 = ConfigurationObject(\"office-2\", t_robot_config, SE2(14.0, 4.0, math.pi / 2))\n",
    "office3 = ConfigurationObject(\"office-3\", t_robot_config, SE2(24.0, 4.0, -math.pi / 2))\n",
    "office4 = ConfigurationObject(\"office-4\", t_robot_config, SE2(32.0, 4.0, -math.pi / 2))\n",
    "office5 = ConfigurationObject(\"office-5\", t_robot_config, SE2(4.0, 24.0, -math.pi / 2))\n",
    "office6 = ConfigurationObject(\"office-6\", t_robot_config, SE2(14.0, 24.0, math.pi / 2))\n",
    "office7 = ConfigurationObject(\"office-7\", t_robot_config, SE2(24.0, 24.0, math.pi / 2))\n",
    "office8 = ConfigurationObject(\"office-8\", t_robot_config, SE2(32.0, 24.0, math.pi / 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fcJPXKbGWZor"
   },
   "source": [
    "## Adding Movable Objects\n",
    "\n",
    "Motion planning requires objects that can move in our map. For this purpose we add two `MovableObject` instances for our robots names `r1` and `r2`.\n",
    "\n",
    "The footprint specifies the 2-dimensional outline of the robot. The motion model specifies how the robot moves. Here we use the Reeds-Shepp car model (see, e.g., https://lavalle.pl/planning/ch13.pdf) which allows movement forward and backwards, and turning at a specific `turning_radius`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "HZcbs359X1hf"
   },
   "outputs": [],
   "source": [
    "r1 = MovableObject(\n",
    "    \"r1\",\n",
    "    t_robot,\n",
    "    footprint=[(-1.0, 0.5), (1.0, 0.5), (1.0, -0.5), (-1.0, -0.5)],\n",
    "    motion_model=MotionModels.REEDSSHEPP,\n",
    "    motion_parameters={\"turning_radius\": 2.0},\n",
    ")\n",
    "\n",
    "r2 = MovableObject(\n",
    "    \"r2\",\n",
    "    t_robot,\n",
    "    footprint=[(-1.0, 0.5), (1.0, 0.5), (1.0, -0.5), (-1.0, -0.5)],\n",
    "    motion_model=MotionModels.REEDSSHEPP,\n",
    "    motion_parameters={\"turning_radius\": 2.0},\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "raMc5ephX6Sl"
   },
   "source": [
    "## Some Additional Objects\n",
    "\n",
    "Creating some parcels in the regular Unified Planning style."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "ABj9LOvjYIdh"
   },
   "outputs": [],
   "source": [
    "nothing = Object(\"nothing\", t_parcel)\n",
    "p1 = Object(\"parcel-1\", t_parcel)\n",
    "p2 = Object(\"parcel-2\", t_parcel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eQCtIejKYUd1"
   },
   "source": [
    "## Operators\n",
    "\n",
    "Now we can create operators that can use motion constraints.\n",
    "\n",
    "### Move\n",
    "\n",
    "The move operators has a motion constraint that requires the robot to move from its current configuration to the goal configuration. Apart from the last line that adds this constraints and the type `InstantaneousMotionAction`, this looks just like classical planning operators defined in Unified Planning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "cfvnsYFwYsP7"
   },
   "outputs": [],
   "source": [
    "move = InstantaneousMotionAction(\n",
    "    \"move\", robot=t_robot, c_from=t_robot_config, c_to=t_robot_config\n",
    ")\n",
    "robot = move.parameter(\"robot\")\n",
    "c_from = move.parameter(\"c_from\")\n",
    "c_to = move.parameter(\"c_to\")\n",
    "move.add_precondition(robot_at(robot, c_from))\n",
    "move.add_effect(robot_at(robot, c_from), False)\n",
    "move.add_effect(robot_at(robot, c_to), True)\n",
    "move.add_motion_constraint(Waypoints(robot, c_from, [c_to]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "o7OJ7t5zZBDT"
   },
   "source": [
    "### Pick\n",
    "\n",
    "Robots can pick parcels at their current location if they carry nothing. This operator does not use a motion planning constraint."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "P_Fz11DtZRR6"
   },
   "outputs": [],
   "source": [
    "pick = InstantaneousAction(\n",
    "    \"pick\", robot=t_robot, loc=t_robot_config, parcel=t_parcel\n",
    ")\n",
    "pick_robot = pick.parameter(\"robot\")\n",
    "pick_loc = pick.parameter(\"loc\")\n",
    "pick_parcel = pick.parameter(\"parcel\")\n",
    "pick.add_precondition(robot_at(pick_robot, pick_loc))\n",
    "pick.add_precondition(parcel_at(pick_parcel, pick_loc))\n",
    "pick.add_precondition(carries(pick_robot, nothing))\n",
    "pick.add_precondition(Not(carries(pick_robot, pick_parcel)))\n",
    "pick.add_effect(carries(pick_robot, pick_parcel), True)\n",
    "pick.add_effect(parcel_at(pick_parcel, pick_loc), False)\n",
    "pick.add_effect(carries(pick_robot, nothing), False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_gfOmdfnZTkI"
   },
   "source": [
    "### Place\n",
    "\n",
    "Robots can place objects they carry at their current location. Again, no special motion planning constraint is used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "9qf-WsdDZT2I"
   },
   "outputs": [],
   "source": [
    "place = InstantaneousAction(\n",
    "    \"place\", robot=t_robot, loc=t_robot_config, parcel=t_parcel\n",
    ")\n",
    "place_robot = place.parameter(\"robot\")\n",
    "place_loc = place.parameter(\"loc\")\n",
    "place_parcel = place.parameter(\"parcel\")\n",
    "place.add_precondition(robot_at(place_robot, place_loc))\n",
    "place.add_precondition(carries(place_robot, place_parcel))\n",
    "place.add_precondition(Not(parcel_at(place_parcel, place_loc)))\n",
    "place.add_precondition(Not(carries(place_robot, nothing)))\n",
    "place.add_effect(carries(place_robot, place_parcel), False)\n",
    "place.add_effect(carries(place_robot, nothing), True)\n",
    "place.add_effect(parcel_at(place_parcel, place_loc), True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NDu6DJzxZi6q"
   },
   "source": [
    "Finally, we can assemble the problem. There is nothing specific to motion planning here. We use the regular UP syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 248
    },
    "id": "sChGIwQ1Iomc",
    "outputId": "a290fbfe-5767-422b-8a0e-713b790282e2"
   },
   "outputs": [],
   "source": [
    "problem = Problem(\"TAMP\")\n",
    "problem.add_fluent(robot_at, default_initial_value=False)\n",
    "problem.add_fluent(parcel_at, default_initial_value=False)\n",
    "problem.add_fluent(carries, default_initial_value=False)\n",
    "problem.add_action(move)\n",
    "problem.add_action(pick)\n",
    "problem.add_action(place)\n",
    "\n",
    "problem.add_object(park1)\n",
    "problem.add_object(park2)\n",
    "problem.add_object(office1)\n",
    "problem.add_object(office2)\n",
    "problem.add_object(office3)\n",
    "problem.add_object(office4)\n",
    "problem.add_object(office5)\n",
    "problem.add_object(office6)\n",
    "problem.add_object(office7)\n",
    "problem.add_object(office8)\n",
    "\n",
    "problem.add_object(r1)\n",
    "problem.add_object(r2)\n",
    "\n",
    "problem.add_object(nothing)\n",
    "problem.add_object(p1)\n",
    "problem.add_object(p2)\n",
    "\n",
    "problem.set_initial_value(carries(r1, nothing), True)\n",
    "problem.set_initial_value(carries(r2, nothing), True)\n",
    "problem.set_initial_value(parcel_at(p1, office1), True)\n",
    "problem.set_initial_value(parcel_at(p2, office6), True)\n",
    "problem.set_initial_value(robot_at(r1, park1), True)\n",
    "problem.set_initial_value(robot_at(r2, park2), True)\n",
    "\n",
    "problem.add_goal(robot_at(r1, park1))\n",
    "problem.add_goal(parcel_at(p1, office2))\n",
    "problem.add_goal(parcel_at(p2, office3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gYQm4A8RZ-n6"
   },
   "source": [
    "## Solve the Problem and Show the Result\n",
    "\n",
    "Now we can solve the problem and print the result. If a path exists, we plot it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SOLUTION FOUND!\n",
      "status: SOLVED_SATISFICING\n",
      "engine: TAMPEST\n",
      "plan: SequentialPlan:\n",
      "    move(r1, parking-1, office-6)\n",
      "    move(r2, parking-2, office-1)\n",
      "    pick(r1, office-6, parcel-2)\n",
      "    move(r1, office-6, office-3)\n",
      "    pick(r2, office-1, parcel-1)\n",
      "    move(r2, office-1, office-2)\n",
      "    place(r1, office-3, parcel-2)\n",
      "    move(r1, office-3, parking-1)\n",
      "    place(r2, office-2, parcel-1)\n"
     ]
    }
   ],
   "source": [
    "env = get_environment()\n",
    "env.factory.add_engine(\"tampest\", \"tampest.engine\", \"TampestEngine\")\n",
    "\n",
    "with OneshotPlanner(name=\"tampest\") as planner:\n",
    "    res = planner.solve(problem)\n",
    "\n",
    "if res.plan:\n",
    "    print(\"SOLUTION FOUND!\")\n",
    "    print(res)\n",
    "else:\n",
    "    print(\"NO SOLUTION FOUND!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting the Solution\n",
    "\n",
    "Assuming there is a solution, we can use the `plot_plan` function to inspect it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from tampest.motion.plotting import plot_plan\n",
    "\n",
    "plot_plan(problem.all_objects, res)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}