acrobot_obs_path_visualization_sst.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "generated.\n",
      "(4, 2)\n"
     ]
    }
   ],
   "source": [
    "## from ctypes import *\n",
    "#ctypes.cdll.LoadLibrary('')\n",
    "#lib1 = CDLL(\"deps/sparse_rrt/deps/trajopt/build/lib/libsco.so\")\n",
    "#lib2 = CDLL(\"deps/sparse_rrt/deps/trajopt/build/lib/libutils.so\")\n",
    "\n",
    "import sys\n",
    "sys.path.append('deps/sparse_rrt')\n",
    "sys.path.append('.')\n",
    "\n",
    "from sparse_rrt.planners import SST\n",
    "#from env.cartpole_obs import CartPoleObs\n",
    "#from env.cartpole import CartPole\n",
    "from sparse_rrt.systems.acrobot import Acrobot\n",
    "from sparse_rrt.systems import standard_cpp_systems\n",
    "from sparse_rrt import _sst_module\n",
    "import numpy as np\n",
    "import time\n",
    "from tools.pcd_generation import rectangle_pcd\n",
    "from plan_utility.line_line_cc import *\n",
    "import pickle\n",
    "obs_list = []\n",
    "LENGTH = 20.\n",
    "width = 6.\n",
    "near = width * 1.2\n",
    "# convert from obs to point cloud\n",
    "# load generated point cloud\n",
    "obs_list_total = []\n",
    "obc_list_total = []\n",
    "for i in range(10):\n",
    "    file = open('/media/arclabdl1/HD1/YLmiao/data/kinodynamic/acrobot_obs_backup/obs_%d.pkl' % (i), 'rb')\n",
    "    obs_list_total.append(pickle.load(file))\n",
    "    file = open('/media/arclabdl1/HD1/YLmiao/data/kinodynamic/acrobot_obs_backup/obc_%d.pkl' % (i), 'rb')\n",
    "    obc_list_total.append(pickle.load(file))\n",
    "\n",
    "#[(0, 932), (1, 935), (2, 923), (8, 141), (5,931), (6, 969), (7, 927)]\n",
    "# (5,931), (6, 286)\n",
    "obs_idx = 1\n",
    "\n",
    "p_idx = 972\n",
    "# Create custom system\n",
    "#obs_list = [[-10., -3.],\n",
    "#            [0., 3.],\n",
    "#            [10, -3.]]\n",
    "obs_list = obs_list_total[obs_idx]\n",
    "obc_list = obc_list_total[obs_idx]\n",
    "print('generated.')\n",
    "print(obs_list.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# search for goal\n",
    "# for p_idx in range(900, 1000):\n",
    "#     sgs = open('/media/arclabdl1/HD1/YLmiao/data/kinodynamic/acrobot_obs_backup/%d/start_goal_%d.pkl' % (obs_idx, p_idx), 'rb')\n",
    "#     sgs = pickle.load(sgs)\n",
    "#     dis = np.abs(sgs[1]-np.array([np.pi, 0, 0., 0.]))\n",
    "#     if dis[0] >= np.pi:\n",
    "#         dis[0] = 2*np.pi - dis[0]\n",
    "#     if dis[1] >= np.pi:\n",
    "#         dis[1] = 2*np.pi - dis[1]\n",
    "        \n",
    "#     if np.linalg.norm(dis) <= 1e-1:\n",
    "#         break\n",
    "# print(p_idx)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# load path\n",
    "path = open('/media/arclabdl1/HD1/YLmiao/data/kinodynamic/acrobot_obs_backup/%d/path_%d.pkl' % (obs_idx, p_idx), 'rb')\n",
    "path = pickle.load(path)\n",
    "controls = open('/media/arclabdl1/HD1/YLmiao/data/kinodynamic/acrobot_obs_backup/%d/control_%d.pkl' % (obs_idx, p_idx), 'rb')\n",
    "controls = pickle.load(controls)\n",
    "costs = open('/media/arclabdl1/HD1/YLmiao/data/kinodynamic/acrobot_obs_backup/%d/cost_%d.pkl' % (obs_idx, p_idx), 'rb')\n",
    "costs = pickle.load(costs)\n",
    "sgs = open('/media/arclabdl1/HD1/YLmiao/data/kinodynamic/acrobot_obs_backup/%d/start_goal_%d.pkl' % (obs_idx, p_idx), 'rb')\n",
    "sgs = pickle.load(sgs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from plan_utility.line_line_cc import line_line_cc\n",
    "\n",
    "def IsInCollision(x, obc, obc_width=6.):\n",
    "    STATE_THETA_1, STATE_THETA_2, STATE_V_1, STATE_V_2 = 0, 1, 2, 3\n",
    "    MIN_V_1, MAX_V_1 = -6., 6.\n",
    "    MIN_V_2, MAX_V_2 = -6., 6.\n",
    "    MIN_TORQUE, MAX_TORQUE = -4., 4.\n",
    "\n",
    "    MIN_ANGLE, MAX_ANGLE = -np.pi, np.pi\n",
    "\n",
    "    LENGTH = 20.\n",
    "    m = 1.0\n",
    "    lc = 0.5\n",
    "    lc2 = 0.25\n",
    "    l2 = 1.\n",
    "    I1 = 0.2\n",
    "    I2 = 1.0\n",
    "    l = 1.0\n",
    "    g = 9.81\n",
    "    pole_x0 = 0.\n",
    "    pole_y0 = 0.\n",
    "    pole_x1 = LENGTH * np.cos(x[STATE_THETA_1] - np.pi / 2)\n",
    "    pole_y1 = LENGTH * np.sin(x[STATE_THETA_1] - np.pi / 2)\n",
    "    pole_x2 = pole_x1 + LENGTH * np.cos(x[STATE_THETA_1] + x[STATE_THETA_2] - np.pi / 2)\n",
    "    pole_y2 = pole_y1 + LENGTH * np.sin(x[STATE_THETA_1] + x[STATE_THETA_2] - np.pi / 2)\n",
    "    for i in range(len(obc)):\n",
    "        for j in range(0, 8, 2):\n",
    "            x1 = obc[i][j]\n",
    "            y1 = obc[i][j+1]\n",
    "            x2 = obc[i][(j+2) % 8]\n",
    "            y2 = obc[i][(j+3) % 8]\n",
    "            if line_line_cc(pole_x0, pole_y0, pole_x1, pole_y1, x1, y1, x2, y2):\n",
    "                return True\n",
    "            if line_line_cc(pole_x1, pole_y1, pole_x2, pole_y2, x1, y1, x2, y2):\n",
    "                return True\n",
    "    return False\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def wrap_angle(x, system):\n",
    "    circular = system.is_circular_topology()\n",
    "    res = np.array(x)\n",
    "    for i in range(len(x)):\n",
    "        if circular[i]:\n",
    "            # use our previously saved version\n",
    "            res[i] = x[i] - np.floor(x[i] / (2*np.pi))*(2*np.pi)\n",
    "            if res[i] > np.pi:\n",
    "                res[i] = res[i] - 2*np.pi\n",
    "    return res\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from visual.visualizer import Visualizer\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.animation as animation\n",
    "import matplotlib as mpl\n",
    "import matplotlib.patches as patches\n",
    "from matplotlib.colors import LinearSegmentedColormap\n",
    "class AcrobotVisualizer(Visualizer):\n",
    "    def __init__(self, system, params):\n",
    "        super(AcrobotVisualizer, self).__init__(system, params)\n",
    "        self.dt = 2\n",
    "        self.fig = plt.gcf()\n",
    "        self.fig.set_figheight(5)\n",
    "        self.fig.set_figwidth(10)\n",
    "        self.ax1 = plt.subplot(121)\n",
    "        self.ax2 = plt.subplot(122)\n",
    "\n",
    "    def _state_to_xy(self, state):\n",
    "        angle0 = state[0]\n",
    "        angle1 = state[1]\n",
    "        x0 = 0.\n",
    "        y0 = 0.\n",
    "        x1 = LENGTH * np.cos(angle0 - np.pi/2)\n",
    "        y1 = LENGTH * np.sin(angle0 - np.pi/2)\n",
    "        x2 = x1 + LENGTH * np.cos(angle0 + angle1 - np.pi/2)\n",
    "        y2 = y1 + LENGTH * np.sin(angle0 + angle1 - np.pi/2)\n",
    "        return x0, y0, x1, y1, x2, y2\n",
    "\n",
    "    def _init(self):\n",
    "        ##### handle the animation\n",
    "        # clear the current ax\n",
    "        print(\"in init\")\n",
    "        ax = self.ax1\n",
    "        ax.clear()\n",
    "        # add patches\n",
    "        state = self.states[0]\n",
    "        print('state:')\n",
    "        print(state)\n",
    "        x0, y0, x1, y1, x2, y2 = self._state_to_xy(state)\n",
    "        print('x1: %f, y1: %f, x2: %f, y2: %f' % (x1, y1, x2, y2))\n",
    "        self.l1 = ax.plot([x0,x1,x2], [y0,y1,y2])[0]\n",
    "        self.recs = []\n",
    "        for i in range(len(self.obs)):\n",
    "            x, y = self.obs[i]\n",
    "            obs = patches.Rectangle((x-self.params['obs_w']/2,y-params['obs_h']/2),\\\n",
    "                                       self.params['obs_w'],self.params['obs_h'],\\\n",
    "                                      linewidth=.5,edgecolor='black',facecolor='black')\n",
    "            self.recs.append(obs)\n",
    "            ax.add_patch(obs)\n",
    "        self.recs.append(self.l1)\n",
    "\n",
    "        #### handle search space\n",
    "        ax = self.ax2\n",
    "        ax.clear()\n",
    "        ax.set_xlim(-np.pi, np.pi)\n",
    "        ax.set_ylim(-np.pi, np.pi)\n",
    "\n",
    "\n",
    "        dtheta = 0.1\n",
    "        feasible_points = []\n",
    "        infeasible_points = []\n",
    "        imin = 0\n",
    "        imax = int(2*np.pi/dtheta)\n",
    "\n",
    "\n",
    "        for i in range(imin, imax):\n",
    "            for j in range(imin, imax):\n",
    "                x = np.array([dtheta*i-np.pi, dtheta*j-np.pi, 0., 0.])\n",
    "                if IsInCollision(x, self.cc_obs):\n",
    "                    infeasible_points.append(x)\n",
    "                else:\n",
    "                    feasible_points.append(x)\n",
    "        feasible_points = np.array(feasible_points)\n",
    "        infeasible_points = np.array(infeasible_points)\n",
    "\n",
    "        print('feasible points')\n",
    "        print(feasible_points)\n",
    "        print('infeasible points')\n",
    "        print(infeasible_points)\n",
    "        #scat_feas =ax.scatter(feasible_points[:,0], feasible_points[:,1], c='white')\n",
    "        scat_infeas = ax.scatter(infeasible_points[:,0], infeasible_points[:,1], c='black')\n",
    "\n",
    "        #self.recs.append(scat_feas)\n",
    "        self.recs.append(scat_infeas)\n",
    "\n",
    "        #scat_state = ax.scatter(state[0], state[1], c='green')\n",
    "        #self.recs.append(scat_state)\n",
    "        print(\"after init\")\n",
    "\n",
    "        return self.recs\n",
    "    def _animate(self, i):\n",
    "        print('animating, frame %d/%d' % (i, self.total))\n",
    "\n",
    "        ax = self.ax1\n",
    "        ax.set_xlim(-40, 40)\n",
    "        ax.set_ylim(-40, 40)\n",
    "        state = self.states[i]\n",
    "        x0, y0, x1, y1, x2, y2 = self._state_to_xy(state)\n",
    "        self.l1.set_xdata([x0,x1,x2])\n",
    "        self.l1.set_ydata([y0,y1,y2])\n",
    "\n",
    "        # handle search space\n",
    "        ax = self.ax2\n",
    "        ax.set_xlim(-np.pi, np.pi)\n",
    "        ax.set_ylim(-np.pi, np.pi)\n",
    "        self.recs[-1].set_offsets([state[0], state[1]])\n",
    "        # print location of point\n",
    "        return self.recs\n",
    "\n",
    "\n",
    "\n",
    "    def animate(self, states, actions, costs, obstacles, sg, wrap_system):\n",
    "        '''\n",
    "        given a list of states, actions and obstacles, animate the robot\n",
    "        '''\n",
    "\n",
    "        new_obs_i = []\n",
    "        obs_width = 6.0\n",
    "        for k in range(len(obstacles)):\n",
    "            obs_pt = []\n",
    "            obs_pt.append(obstacles[k][0]-obs_width/2)\n",
    "            obs_pt.append(obstacles[k][1]-obs_width/2)\n",
    "            obs_pt.append(obstacles[k][0]-obs_width/2)\n",
    "            obs_pt.append(obstacles[k][1]+obs_width/2)\n",
    "            obs_pt.append(obstacles[k][0]+obs_width/2)\n",
    "            obs_pt.append(obstacles[k][1]+obs_width/2)\n",
    "            obs_pt.append(obstacles[k][0]+obs_width/2)\n",
    "            obs_pt.append(obstacles[k][1]-obs_width/2)\n",
    "            new_obs_i.append(obs_pt)\n",
    "        obs_i = new_obs_i\n",
    "        self.cc_obs = obs_i\n",
    "\n",
    "        # transform the waypoint states and actions into trajectory\n",
    "        traj = []\n",
    "        s = states[0]\n",
    "        for i in range(len(states)-1):\n",
    "            print('state: %d, remaining: %d' % (i, len(states)-i))\n",
    "            \n",
    "            \n",
    "            action = actions[i]\n",
    "            # number of steps for propagtion\n",
    "            #num_steps = int(np.round(costs[i]/self.params['integration_step']))\n",
    "            num_steps = 100000\n",
    "            for j in range(num_steps):\n",
    "                traj.append(np.array(s))\n",
    "                #print(\"porpagating...\")\n",
    "                #print(s)\n",
    "                #print('st:')\n",
    "                #print(sT)\n",
    "                s = self.system(s, action, self.params['integration_step'])\n",
    "                assert not IsInCollision(s, obs_i)\n",
    "                if np.linalg.norm(s - states[i+1]) <= 1e-3:\n",
    "                    break\n",
    "\n",
    "\n",
    "\n",
    "        traj = np.array(traj)\n",
    "        print(\"animating...\")\n",
    "        # animate\n",
    "        self.states = traj\n",
    "        self.obs = obstacles\n",
    "        print(len(self.states))\n",
    "        self.total = len(self.states)\n",
    "        self._init()\n",
    "        \n",
    "        to_plot_list_x = []\n",
    "        to_plot_list_y = []\n",
    "        for i in range(len(traj)):\n",
    "            if i % 10 == 0:\n",
    "                x0, y0, x1, y1, x2, y2 = self._state_to_xy(traj[i])\n",
    "                ax = self.ax1\n",
    "                ax.set_xlim(-40, 40)\n",
    "                ax.set_ylim(-40, 40)\n",
    "                #if i == 0:\n",
    "                #    ax.plot([x0,x1,x2],[y0,y1,y2],alpha=1, c='green')\n",
    "                #else:\n",
    "                #    ax.plot([x0,x1,x2],[y0,y1,y2],alpha=float(i)/len(traj), c='blue')\n",
    "                to_plot_list_x.append([x0,x1,x2])\n",
    "                to_plot_list_y.append([y0,y1,y2])\n",
    "            ax = self.ax2\n",
    "            traj_to_plot = wrap_angle(traj[i], wrap_system)\n",
    "            scat_state = ax.scatter(traj_to_plot[0], traj_to_plot[1], c='blue', s=25.0)\n",
    "\n",
    "        colors = ['green', 'red']\n",
    "        \n",
    "        ax = self.ax1\n",
    "        cm = LinearSegmentedColormap.from_list(\"Custom\", colors, N=len(to_plot_list_x))\n",
    "        for i in range(len(to_plot_list_x)):\n",
    "            #ax.plot(to_plot_list_x[i], to_plot_list_y[i], alpha=float(i)/len(to_plot_list_x), c=cm(float(i)/len(to_plot_list_x)))\n",
    "            if i == 0:\n",
    "                ax.plot(to_plot_list_x[i], to_plot_list_y[i], alpha=1, c='green')\n",
    "            else:\n",
    "                ax.plot(to_plot_list_x[i], to_plot_list_y[i], alpha=float(i)/len(to_plot_list_x), c='blue')\n",
    "\n",
    "            \n",
    "        # start and goal\n",
    "        x0, y0, x1, y1, x2, y2 = self._state_to_xy(sg[1])\n",
    "        ax = self.ax1\n",
    "        ax.set_xlim(-40, 40)\n",
    "        ax.set_ylim(-40, 40)\n",
    "        ax.plot([x0,x1,x2],[y0,y1,y2],alpha=1, c='red')\n",
    "        ax.axis('off')\n",
    "\n",
    "        ax = self.ax2\n",
    "        scat_state = ax.scatter(sg[0][0], sg[0][1], c='green', s=50.0)\n",
    "        scat_state = ax.scatter(sg[1][0], sg[1][1], c='red', s=50.0, marker='*')\n",
    "        \n",
    "        \n",
    "        ax.axis('off')\n",
    "        #plt.show()\n",
    "        plt.savefig(\"acrobot_sst_obs_%d_p_%d.png\" % (obs_idx, p_idx), bbox_inches='tight')\n",
    "\n",
    "        # for thesis\n",
    "        fig = plt.figure()\n",
    "        ax = plt.subplot(121)\n",
    "        ax.set_xlim(-40, 40)\n",
    "        ax.set_ylim(-40, 40)\n",
    "        fig.set_figheight(5)\n",
    "        fig.set_figwidth(10)\n",
    "        \n",
    "        for i in range(len(self.obs)):\n",
    "            x, y = self.obs[i]\n",
    "            obs = patches.Rectangle((x-self.params['obs_w']/2,y-params['obs_h']/2),\\\n",
    "                                       self.params['obs_w'],self.params['obs_h'],\\\n",
    "                                      linewidth=.5,edgecolor='black',facecolor='black')\n",
    "            self.recs.append(obs)\n",
    "            ax.add_patch(obs)\n",
    "        ax.plot(to_plot_list_x[0], to_plot_list_y[0], alpha=1, c='green')\n",
    "        ax.plot(to_plot_list_x[-1], to_plot_list_y[-1], alpha=1, c='red')\n",
    "\n",
    "        \n",
    "        ax = plt.subplot(122)\n",
    "        ax.set_xlim(-np.pi, np.pi)\n",
    "        ax.set_ylim(-np.pi, np.pi)\n",
    "        dtheta = 0.1\n",
    "        feasible_points = []\n",
    "        infeasible_points = []\n",
    "        imin = 0\n",
    "        imax = int(2*np.pi/dtheta)\n",
    "\n",
    "        for i in range(imin, imax):\n",
    "            for j in range(imin, imax):\n",
    "                x = np.array([dtheta*i-np.pi, dtheta*j-np.pi, 0., 0.])\n",
    "                if IsInCollision(x, self.cc_obs):\n",
    "                    infeasible_points.append(x)\n",
    "                else:\n",
    "                    feasible_points.append(x)\n",
    "        feasible_points = np.array(feasible_points)\n",
    "        infeasible_points = np.array(infeasible_points)\n",
    "\n",
    "        print('feasible points')\n",
    "        print(feasible_points)\n",
    "        print('infeasible points')\n",
    "        print(infeasible_points)\n",
    "        #scat_feas =ax.scatter(feasible_points[:,0], feasible_points[:,1], c='white')\n",
    "        scat_infeas = ax.scatter(infeasible_points[:,0], infeasible_points[:,1], c='black')\n",
    "        scat_state = ax.scatter(sg[0][0], sg[0][1], c='green', s=50.0)\n",
    "        scat_state = ax.scatter(sg[1][0], sg[1][1], c='red', s=50.0, marker='*')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "states:\n",
      "[[ 0.          0.          0.          0.        ]\n",
      " [ 0.09890424 -0.39835898 -0.29554773  0.21533826]\n",
      " [-0.24645337  0.71319078  0.92181739 -0.45454409]\n",
      " [ 0.17315784  0.55735503 -0.49333383  0.8630138 ]\n",
      " [-0.17559293 -1.49901806 -0.13851613 -0.32639743]\n",
      " [-0.16923314 -1.55167437  0.29207695 -0.44212925]\n",
      " [ 0.8266118  -3.11162283 -0.89622611  4.10857949]\n",
      " [-1.02832889  2.57504045  4.17758981 -0.71623321]\n",
      " [-0.48807996  2.43177585  4.84051478 -1.83602583]\n",
      " [ 0.58749771  1.79857035  4.4776132  -3.7959772 ]\n",
      " [-2.15913071 -1.91757152 -2.32864879  2.66036076]\n",
      " [-2.68827824 -1.2184716  -0.64924568  1.05323536]\n",
      " [-2.84262368 -0.89882737 -0.24593594  0.75408063]\n",
      " [-2.90141651 -0.5351539  -0.05652873  0.84146968]]\n",
      "state: 0, remaining: 14\n",
      "state: 1, remaining: 13\n",
      "state: 2, remaining: 12\n",
      "state: 3, remaining: 11\n",
      "state: 4, remaining: 10\n",
      "state: 5, remaining: 9\n",
      "state: 6, remaining: 8\n",
      "state: 7, remaining: 7\n",
      "state: 8, remaining: 6\n",
      "state: 9, remaining: 5\n",
      "state: 10, remaining: 4\n",
      "state: 11, remaining: 3\n",
      "state: 12, remaining: 2\n",
      "animating...\n",
      "558\n",
      "in init\n",
      "state:\n",
      "[0. 0. 0. 0.]\n",
      "x1: 0.000000, y1: -20.000000, x2: 0.000000, y2: -40.000000\n",
      "feasible points\n",
      "[[-3.14159265 -3.14159265  0.          0.        ]\n",
      " [-3.14159265 -3.04159265  0.          0.        ]\n",
      " [-3.14159265 -2.94159265  0.          0.        ]\n",
      " ...\n",
      " [ 2.95840735  2.75840735  0.          0.        ]\n",
      " [ 2.95840735  2.85840735  0.          0.        ]\n",
      " [ 2.95840735  2.95840735  0.          0.        ]]\n",
      "infeasible points\n",
      "[[-3.14159265  1.45840735  0.          0.        ]\n",
      " [-3.14159265  1.55840735  0.          0.        ]\n",
      " [-3.14159265  1.65840735  0.          0.        ]\n",
      " ...\n",
      " [ 2.95840735  1.75840735  0.          0.        ]\n",
      " [ 2.95840735  1.85840735  0.          0.        ]\n",
      " [ 2.95840735  1.95840735  0.          0.        ]]\n",
      "after init\n",
      "feasible points\n",
      "[[-3.14159265 -3.14159265  0.          0.        ]\n",
      " [-3.14159265 -3.04159265  0.          0.        ]\n",
      " [-3.14159265 -2.94159265  0.          0.        ]\n",
      " ...\n",
      " [ 2.95840735  2.75840735  0.          0.        ]\n",
      " [ 2.95840735  2.85840735  0.          0.        ]\n",
      " [ 2.95840735  2.95840735  0.          0.        ]]\n",
      "infeasible points\n",
      "[[-3.14159265  1.45840735  0.          0.        ]\n",
      " [-3.14159265  1.55840735  0.          0.        ]\n",
      " [-3.14159265  1.65840735  0.          0.        ]\n",
      " ...\n",
      " [ 2.95840735  1.75840735  0.          0.        ]\n",
      " [ 2.95840735  1.85840735  0.          0.        ]\n",
      " [ 2.95840735  1.95840735  0.          0.        ]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "params = {}\n",
    "params['obs_w'] = width\n",
    "params['obs_h'] = width\n",
    "params['integration_step'] = 0.02\n",
    "system = _sst_module.PSOPTAcrobot()\n",
    "cpp_propagator = _sst_module.SystemPropagator()\n",
    "dynamics = lambda x, u, t: cpp_propagator.propagate(system, x, u, t)\n",
    "\n",
    "vis = AcrobotVisualizer(dynamics, params)\n",
    "states = path\n",
    "actions = controls\n",
    "sgs[0] = wrap_angle(sgs[0], system)\n",
    "sgs[1] = wrap_angle(sgs[1], system)\n",
    "print('states:')\n",
    "print(states)\n",
    "anim = vis.animate(np.array(states), np.array(actions), np.array(costs), obs_list, np.array(sgs), system)\n",
    "#HTML(anim.to_html5_video())\n",
    "#anim.save('acrobot_env%d_path%d.mp4' % (obs_idx, p_idx))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 1400, 2)\n",
      "(5600, 2)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visualize point cloud\n",
    "import matplotlib.pyplot as plt\n",
    "print(obc_list.shape)\n",
    "obc_all = np.concatenate(obc_list_total[obs_idx], axis=0)\n",
    "print(obc_all.shape)\n",
    "plt.scatter(obc_all[:,0], obc_all[:,1])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5600, 2)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5600, 2)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAD4CAYAAAAJmJb0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAASTElEQVR4nO3df4wcZ33H8c/H54t1hoqziQPxxeAodQ02AVyt8kPpH6UhskEQGwSqrdBaAiWqFFSiUosER01QiYR0EqqqQlsjEKlwE6AkF6chNU6UCjVNAmscnBjH2Ami9tlKDjkGFJ/s8923f+w43tjrO9/t7M3Ms++XdLrdeXZnvo9/fG7u2WeecUQIAJCmOUUXAADoHEIeABJGyANAwgh5AEgYIQ8ACZtbdAHNLr744li6dGnRZQBApezcufM3EbGoVVupQn7p0qWq1+tFlwEAlWL71+drY7gGABJGyANAwgh5AEgYIQ8ACSPkASBhpZpdg9k3tGtYg9v36fCxUS3u79MH3rVIT7wwouFjo+qxNR6hgf4+bVq9XOtWDbzhvXcOPaf7njmo8QjZUt/cORodmzhnP5Z0ehm8+b1zNK+3R68eH5ty/wDa5zKtQlmr1YIplLPnpm88pSdfPFp0GZKk3h5r8BPvI+iBGbC9MyJqrdoYrulSZQp4SRobD33p4T1FlwEkh5DvQkO7hksV8Ke9enys6BKA5BDyXeiLD+wuugQAs4SQ70LHxyaKLqElF10AkCBCHqVRnikAQDoIeZTGgvm9RZcAJIeQR2mcGBsvugQgOYQ8SqOsnxUAVdZ2yNteYvsJ23tt77H9uWz7Qts7bO/Pvi9ov1zkocd8xAl0izzO5E9J+nxEvFvSNZJutb1C0u2SHo+IZZIez56jBDZcvaToEgDMkrZDPiKORMTPsse/l7RX0oCktZLuzV52r6R17R4L+fjyuiuLLgHALMl1TN72UkmrJD0j6W0RcURq/CCQdMl53nOL7brt+sjISJ7lAEDXyy3kbb9Z0g8k3RYRv7vQ90XEloioRURt0aKW96FFzoZ2DRddQktMoQTyl0vI2+5VI+C3RsQD2eaXbV+atV8q6ZU8joX2DW7fV3QJLd310ZVFlwAkJ4/ZNZb0TUl7I+KrTU3bJG3MHm+U9FC7x0I+Dh8bLbqEluq/Lt+iaUDV5XEmf52kv5D0Z7afzb4+LOkrkm6wvV/SDdlzlMDi/r6iS2jpvmcOFl0CkJy27wwVEf+j868tdX27+0f+Nq1ertu++2zRZZxjvEQ3sAFSwRWvAJAwQr4LcQcmoHsQ8l2IOzAB3YOQB4CEEfIAkDBCvgvN7+WvHegW/G/vQvN6e4ouoSV++AD5439VFyrrB69l/eEDVBkh34XKetOQYyX94QNUGSHfhcp6ZWlZl1sAqoyQ70IDJQzT3jnWptXLiy4DSA4h34U2rV6uOSUasZkjafCT79O6VQNFlwIkp+0FylA9p8P0iw/s1vGxiUJrue6Khdp687WF1gCkjJDvUutWDbwe9ncOPaf7njmo8Qj12Npw9ZLX7wM7tGtYX3p4z+szcvr7enX3jY2be9y9bY+OjZ75sLS/r1crF/+Bnn7p1XP2NbRrWIPb9+nwsVEt7u/TptXLOXMHZoGjRB/C1Wq1qNfrRZcBAJVie2dE1Fq1MSYPAAkj5AEgYYQ8ACSMkAeAhBHyAJAwplACQJOzp/sufWuf/velo2qeiLhgfq/u+ujKC54G3LzPt/T1ym6s1TQb04mZQgmgq50O4OFjo4XW8aaLenTPx66cUeBPNoWSM3kAXWto17A2ff/nGpso/mT3tZPjuu27z0pSrmf2jMkD6Fp3b9tTioBv9rff/3mu+yPkAXSt5mU5yuLURGho13Bu+yPkAaBkBrfvy21fhDwAlMzhHD8EJuQBoGTyvEsaIQ8AJfOBdy3KbV+EPACUzCO7j+S2L0IeAErm9E168kDIA0DCCHkAKJn+vt7c9pVLyNv+lu1XbD/ftG2h7R2292ffF+RxLABI3en7KOchrzP5b0tac9a22yU9HhHLJD2ePQcATKF0a9dExI8lHT1r81pJ92aP75W0Lo9jAUDqqrKswdsi4ogkZd8v6eCxACAZSS1rYPsW23Xb9ZGRkaLLAYDCVWVZg5dtXypJ2fdXWr0oIrZERC0iaosW5XeVFwBUVVWWNdgmaWP2eKOkhzp4LABIxqbVy3PbV15TKO+T9JSk5bYP2f6MpK9IusH2fkk3ZM8BALMol9v/RcSG8zRdn8f+AaCb3L1tT27TKAv/4BUA8EZ53rGKkAfQteb3ph+B6fcQAM5jdGyi6BI6jpAH0LWi6AJmASEPACVzUY9z2xchDwAlMzae3+8YhDyArpXnuu15ynMYiZAH0LXyXLc9Tz1muAYA2rZu1YCuu2Jh0WWcY8PVS3LbFyEPoKttvfnaUgX9p655h7687src9pfLsgYAUGVbb75WQ7uGNbh9nw4fG9Xi/j5tWr38DUsLNLe/pa9XY+MTeu3kuCSpr3eOTo1P6Oxp9z22Nly9RLV3Ljxn35ImPV5eHFGemaK1Wi3q9XrRZQBApdjeGRG1Vm0M1wBAwgh5AEgYIQ8ACSPkASBhhDwAJIyQB4CEEfIAkDBCHgASRsgDQMIIeQBIGCEPAAkj5AEgYYQ8ACSMkAeAhBHyAJAwQh4AEkbIA0DCCHkASBghDwAJI+QBIGGEPAAkjJAHgIR1PORtr7G9z/YB27d3+ngAgDM6GvK2eyR9TdKHJK2QtMH2ik4eEwBwRqfP5K+SdCAiXoqIk5Lul7S2w8cEAGQ6HfIDkg42PT+UbXud7Vts123XR0ZGOlwOAHSXToe8W2yLNzyJ2BIRtYioLVq0qMPlAEB36XTIH5K0pOn5ZZIOd/iYAIBMp0P+p5KW2b7c9kWS1kva1uFjAgAyczu584g4ZfuzkrZL6pH0rYjY08ljAgDO6GjIS1JE/FDSDzt9HADAubjiFQAS1vEz+dlw0zee0pMvHp3x+3tsXfzmXr38+5OTvm7e3DmaY2l0bOKctuuuWKitN1874xoAoBMqfybfbsBL0njElAEvSSdOTbQMeEl68sWjWn7noxraNdxWLQCQp8qHfLsBn6cTpya06T9+TtADKI3Kh3zZjI2HvvQwE4gAlAMh3wGvHh8rugQAkETIA0DSKh3yjH0DwOQqHfKD2/cVXQIAlFqlQ/7wsdGiSwCAUqt0yC/u7yu6BAAotUqH/KbVy4suAQBKrdIhv27VwNQvAoAuVumQBwBMjpAHgIQR8gCQMEIeABJW6ZDnilcAmFylQ54rXgFgcpUOea54BYDJVTrkueIVACZX6ZDnilcAmFylQ54rXgFgcpUOeQDA5Cod8kyhBIDJVTrkmUIJAJOrdMgzhRIAJlfpkGcKJQBMrtIhX9YplPN7K/3HCiAhlU6jsk6hHB2bKLoEAJBU8ZCXpB676BLOwTASgLKofMhvuHpJ0SW8QV9vT2mHkQB0n7lFF9CuL6+7UpJ03zMHNR6R+/5750hTjb5YUkga6O/TptXLSzuMBKD7ONoIRtuflHS3pHdLuioi6k1td0j6jKRxSX8dEdun2l+tVot6vT7VywAATWzvjIhaq7Z2z+Sfl/RxSf961gFXSFovaaWkxZIes/1HETHe5vEAANPQ1ph8ROyNiFaXna6VdH9EnIiIX0k6IOmqdo4FAJi+Tn3wOiDpYNPzQ9m2c9i+xXbddn1kZKRD5QBAd5pyuMb2Y5Le3qJpc0Q8dL63tdjWcvA/IrZI2iI1xuSnqgcAcOGmDPmI+OAM9ntIUvPcxsskHZ7BfgAAbejUcM02Settz7N9uaRlkn7SoWMBAM6jrZC3/THbhyRdK+kR29slKSL2SPqepF9I+i9JtzKzBgBmX1tTKCPiQUkPnqftHkn3tLN/AEB7Kr+sAQDg/Ah5AEgYIQ8ACSPkASBhhDwAJIyQB4CEEfIAkDBCHgASRsgDQMIIeQBIGCEPAAkj5AEgYYQ8ACSMkAeAhBHyAJAwQh4AEkbIA0DCCHkASBghDwAJI+QBIGGEPAAkjJAHgIQR8gCQMEIeABJGyANAwgh5AEjY3KILAIA8De0a1uD2fTp8bFSL+/u0afVyrVs1UHRZhXFEFF3D62q1WtTr9aLLAFASN33jKT354tFCa1gwv1d3fXRlqX9Q2N4ZEbVWbQzXACilG77634UHvCS9enxMt333Wd059FzRpcwIIQ+gdIZ2DWv/K68VXcYbfOfp/9PQruGiy5g2Qh5A6Wx+sJxnzYPb9xVdwrQR8gBK57WT40WX0NLhY6NFlzBthDwAXKDF/X1FlzBthDwAXKAPvGtR0SVMW1shb3vQ9gu2d9t+0HZ/U9sdtg/Y3md7dfulAkCxvl8/VHQJ09bumfwOSe+JiPdK+qWkOyTJ9gpJ6yWtlLRG0tdt97R5LAAo1IlTE0WXMG1thXxE/CgiTmVPn5Z0WfZ4raT7I+JERPxK0gFJV7VzLADA9OU5Jv9pSY9mjwckHWxqO5RtO4ftW2zXbddHRkZyLAcAMOXaNbYfk/T2Fk2bI+Kh7DWbJZ2StPX021q8vuX6CRGxRdIWqbGswQXUDAC4QFOGfER8cLJ22xslfUTS9XFmIZxDkpY0vewySYdnWiQAYGbanV2zRtIXJN0YEcebmrZJWm97nu3LJS2T9JN2jgUAmL52lxr+J0nzJO2wLUlPR8RfRcQe29+T9As1hnFujYhyXsIGAAlrK+Qj4g8nabtH0j3t7B8A0B6ueAWAhBHyAJAwQh5A6czvLWc09ff1Fl3CtJXzTxJAV7tobjlXQTl5qnrzRwh5AKXz29Gxokto6fhYl61dAwCdUMV128uKkAdQOlVct72sCHkApfPECyxWmBdCHkDpDFfwXqplRcgDKJ0et1rIFjNByAMonfFg1fG8EPIASocz+fwQ8gBKp6xn8tddsbDoEqaNkAdQOgMlnCe/7JI3aevN1xZdxrQR8gBKZ9Pq5ertKc+QzXVXLNSOv/nTosuYEUIeQOmsWzWgwU+8Twvmn1kQrHdO65tH29JMfh5Y0qeueYf+4c/fP+lvDp+65h2VPIM/zVGisa9arRb1er3oMgCgUmzvjIhaqzbO5AEgYYQ8ACSMkAeAhBHyAJAwQh4AElaq2TW2RyT9epYPe7Gk38zyMTuNPlUDfaqGKvTpnRHRchH+UoV8EWzXzzf1qKroUzXQp2qoep8YrgGAhBHyAJAwQl7aUnQBHUCfqoE+VUOl+9T1Y/IAkDLO5AEgYYQ8ACSsK0Pe9t/b3m37Wds/sr04227b/2j7QNb+x0XXeqFsD9p+Iav7Qdv9TW13ZH3aZ3t1kXVOh+1P2t5je8J27ay2SvZJkmyvyeo+YPv2ouuZKdvfsv2K7eebti20vcP2/uz7giJrnA7bS2w/YXtv9u/uc9n2yvZJ6tKQlzQYEe+NiPdL+k9Jf5dt/5CkZdnXLZL+uaD6ZmKHpPdExHsl/VLSHZJke4Wk9ZJWSloj6eu2ewqrcnqel/RxST9u3ljlPmV1fk2Nf2srJG3I+lNF31bjz7/Z7ZIej4hlkh7PnlfFKUmfj4h3S7pG0q3Z302V+9SdIR8Rv2t6+iZJpz99Xivp36LhaUn9ti+d9QJnICJ+FBGnsqdPS7ose7xW0v0RcSIifiXpgKSriqhxuiJib0Tsa9FU2T6pUeeBiHgpIk5Kul+N/lRORPxY0tGzNq+VdG/2+F5J62a1qDZExJGI+Fn2+PeS9koaUIX7JHVpyEuS7XtsH5R0k86cyQ9IOtj0skPZtqr5tKRHs8ep9KlZlftU5dovxNsi4ojUCE1JlxRcz4zYXipplaRnVPE+zS26gE6x/Zikt7do2hwRD0XEZkmbbd8h6bOS7lLru4uVZo7pVH3KXrNZjV87t55+W4vXV6pPrd7WYltp+jSFKtfeFWy/WdIPJN0WEb+zy3Ov2ZlINuQj4oMX+NJ/l/SIGiF/SNKSprbLJB3OubQZm6pPtjdK+oik6+PMBRCV7tN5lLpPU6hy7RfiZduXRsSRbKjzlaILmg7bvWoE/NaIeCDbXOk+deVwje1lTU9vlPRC9nibpL/MZtlcI+m3p39NKzvbayR9QdKNEXG8qWmbpPW259m+XI0PlX9SRI05qnKffippme3LbV+kxgfI2wquKU/bJG3MHm+UdL7fxkrHjVP2b0raGxFfbWqqbJ8kSRHRdV9q/KR+XtJuSQ9LGsi2W42ZDy9Kek5Srehap9GnA2qM9T6bff1LU9vmrE/7JH2o6Fqn0aePqXHme0LSy5K2V71PWe0fVmMG1ItqDEsVXtMM+3GfpCOSxrK/p89IeqsaM1D2Z98XFl3nNPrzJ2oMne1u+n/04Sr3KSJY1gAAUtaVwzUA0C0IeQBIGCEPAAkj5AEgYYQ8ACSMkAeAhBHyAJCw/wekruXTHIk9PQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i in range(2):\n",
    "    obc_all = np.concatenate(obc_list_total[i], axis=0)\n",
    "    print(obc_all.shape)\n",
    "    plt.scatter(obc_all[:,0], obc_all[:,1])\n",
    "    plt.show()"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda env:ylmiao_kino]",
   "language": "python",
   "name": "conda-env-ylmiao_kino-py"
  },
  "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}