car_obs_vis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "generating obs...\n",
      "generated.\n",
      "(1, 5, 2)\n"
     ]
    }
   ],
   "source": [
    "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 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",
    "\n",
    "obs_list = []\n",
    "width = 8.\n",
    "near = width * 2\n",
    "car_width = 16.0\n",
    "car_len = 8.0\n",
    "print('generating obs...')\n",
    "for i in range(1):\n",
    "    obs_single = []\n",
    "    for j in range(5):\n",
    "        low_x = -25 + width/2\n",
    "        high_x = 25 - width/2\n",
    "        low_y = -35 + width/2\n",
    "        high_y = 35 - width/2\n",
    "        while True:\n",
    "            # randomly sample in the entire space\n",
    "            obs = np.random.uniform(low=[low_x, low_y], high=[high_x, high_y])\n",
    "            # check if it is near enough to previous obstacles\n",
    "            too_near = False\n",
    "            for k in range(len(obs_single)):\n",
    "                if np.linalg.norm(obs - obs_single[k]) < near:\n",
    "                    too_near = True\n",
    "                    break\n",
    "            if not too_near:\n",
    "                break\n",
    "            \n",
    "        obs_single.append(obs)\n",
    "    obs_single = np.array(obs_single)\n",
    "    obs_list.append(obs_single)\n",
    "obs_list = np.array(obs_list)\n",
    "# convert from obs to point cloud\n",
    "obc_list = rectangle_pcd(obs_list, width, 1400)\n",
    "print('generated.')\n",
    "print(obs_list.shape)\n",
    "\n",
    "# Create custom system\n",
    "#obs_list = [[-10., -3.],\n",
    "#            [0., 3.],\n",
    "#            [10, -3.]]\n",
    "obs_list = obs_list[0]\n",
    "\n",
    "obs_list_to_corner = []\n",
    "for i in range(len(obs_list)):\n",
    "    obs_list_to_corner_i = []\n",
    "    obs_list_to_corner_i.append(obs_list[i][0]-width/2)\n",
    "    obs_list_to_corner_i.append(obs_list[i][1]-width/2)\n",
    "    obs_list_to_corner_i.append(obs_list[i][0]+width/2)\n",
    "    obs_list_to_corner_i.append(obs_list[i][1]-width/2)\n",
    "    obs_list_to_corner_i.append(obs_list[i][0]+width/2)\n",
    "    obs_list_to_corner_i.append(obs_list[i][1]+width/2)\n",
    "    obs_list_to_corner_i.append(obs_list[i][0]-width/2)\n",
    "    obs_list_to_corner_i.append(obs_list[i][1]+width/2)\n",
    "    obs_list_to_corner.append(obs_list_to_corner_i)\n",
    "obs_list_to_corner = np.array(obs_list_to_corner)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def overlap(b1corner,b1axis,b1orign,b1dx,b1dy,b2corner,b2axis,b2orign,b2dx,b2dy):\n",
    "    # this only checks overlap of b1 w.r.t. b2\n",
    "    # a complete check should do in both directions\n",
    "    b2ds = [b2dx, b2dy]\n",
    "    for a in range(0,2):\n",
    "        t=b1corner[0][0]*b2axis[a][0]+b1corner[0][1]*b2axis[a][1] # project corner to the axis by inner product\n",
    "\n",
    "        tMin = t\n",
    "        tMax = t\n",
    "        for c in range(1,4):\n",
    "            t = b1corner[c][0]*b2axis[a][0]+b1corner[c][1]*b2axis[a][1] # project corner to the axis by inner product\n",
    "            # find range by [tMin, tMax]\n",
    "            if t < tMin:\n",
    "                tMin = t\n",
    "            elif t > tMax:\n",
    "                tMax = t\n",
    "        # since b2 the other corners (corner 1, 2, 3) are larger than b2orign (project of corner 0 to axis)\n",
    "        # specifically, the range is [b2orign[i], b2orign[i]+size(i)] (of the projected point by dot product)\n",
    "        # we only need to compare tMax with b2orign[i], and tMin with size(i)+b2orign[i]\n",
    "        if ((tMin > (b2ds[a] + b2orign[a])) or (tMax < b2orign[a])):\n",
    "            return False\n",
    "\n",
    "    return True\n",
    "\n",
    "\n",
    "def enforce_bounds(state):\n",
    "    '''\n",
    "\n",
    "    check if state satisfies the bound\n",
    "    apply threshold to velocity and angle\n",
    "    return a new state toward which the bound has been enforced\n",
    "    '''\n",
    "    WIDTH = 1.0\n",
    "    LENGTH = 2.0\n",
    "\n",
    "    STATE_X = 0\n",
    "    STATE_Y = 1\n",
    "\n",
    "    STATE_THETA = 2 \n",
    "    MIN_X = -25\n",
    "    AX_X = 25\n",
    "    MIN_Y = -35\n",
    "    MAX_Y = 35\n",
    "    \n",
    "    \n",
    "    new_state = np.array(state)\n",
    "    \"\"\"\n",
    "    if state[STATE_V] < MIN_V/30.:\n",
    "        new_state[STATE_V] = MIN_V/30.\n",
    "    elif state[STATE_V] > MAX_V/30.:\n",
    "        new_state[STATE_V] = MAX_V/30.\n",
    "    \"\"\"\n",
    "    if state[2] < -np.pi:\n",
    "        new_state[2] += 2*np.pi\n",
    "    elif state[2] > np.pi:\n",
    "        new_state[2] -= 2*np.pi\n",
    "    return new_state\n",
    "\n",
    "def IsInCollision(x, obc, obc_width=4.):\n",
    "\n",
    "    \n",
    "    WIDTH = car_width # 1.0\n",
    "    LENGTH = car_len # 2.0\n",
    "    STATE_X = 0\n",
    "    STATE_Y = 1\n",
    "    STATE_THETA = 2\n",
    "    MIN_X = -25\n",
    "    MAX_X = 25\n",
    "    MIN_Y = -35\n",
    "    MAX_Y = 35\n",
    "    if x[0] < MIN_X or x[0] > MAX_X or x[1] < MIN_Y or x[1] > MAX_Y:\n",
    "        return True\n",
    "        \n",
    "    robot_corner=np.zeros((4,2),dtype=np.float32)\n",
    "    robot_axis=np.zeros((2,2),dtype=np.float32)\n",
    "    robot_orign=np.zeros(2,dtype=np.float32)\n",
    "    length=np.zeros(2,dtype=np.float32)\n",
    "    X1=np.zeros(2,dtype=np.float32)\n",
    "    Y1=np.zeros(2,dtype=np.float32)\n",
    "\n",
    "    X1[0]=np.cos(x[STATE_THETA])*(WIDTH/2.0)\n",
    "    X1[1]=-np.sin(x[STATE_THETA])*(WIDTH/2.0)\n",
    "    Y1[0]=np.sin(x[STATE_THETA])*(LENGTH/2.0)\n",
    "    Y1[1]=np.cos(x[STATE_THETA])*(LENGTH/2.0)\n",
    "\n",
    "    for j in range(0,2):\n",
    "        # order: (left-bottom, right-bottom, right-upper, left-upper)\n",
    "        robot_corner[0][j]=x[j]-X1[j]-Y1[j]\n",
    "        robot_corner[1][j]=x[j]+X1[j]-Y1[j]\n",
    "        robot_corner[2][j]=x[j]+X1[j]+Y1[j]\n",
    "        robot_corner[3][j]=x[j]-X1[j]+Y1[j]\n",
    "\n",
    "        # axis: horizontal and vertical\n",
    "        robot_axis[0][j] = robot_corner[1][j] - robot_corner[0][j]\n",
    "        robot_axis[1][j] = robot_corner[3][j] - robot_corner[0][j]\n",
    "\n",
    "    print('robot corners:')\n",
    "    print(robot_corner)\n",
    "    length[0]=np.sqrt(robot_axis[0][0]*robot_axis[0][0]+robot_axis[0][1]*robot_axis[0][1])\n",
    "    length[1]=np.sqrt(robot_axis[1][0]*robot_axis[1][0]+robot_axis[1][1]*robot_axis[1][1])\n",
    "    # normalize the axis\n",
    "    for i in range(0,2):\n",
    "        for j in range(0,2):\n",
    "            robot_axis[i][j]=robot_axis[i][j]/float(length[i])\n",
    "\n",
    "    # obtain the projection of the left-bottom corner to the axis, to obtain the minimal projection length\n",
    "    robot_orign[0]=robot_corner[0][0]*robot_axis[0][0]+ robot_corner[0][1]*robot_axis[0][1]\n",
    "    robot_orign[1]=robot_corner[0][0]*robot_axis[1][0]+ robot_corner[0][1]*robot_axis[1][1]\n",
    "    print('robot orign:')\n",
    "    print(robot_orign)\n",
    "    for i in range(len(obc)):\n",
    "        cf=True\n",
    "\n",
    "        obs_corner=np.zeros((4,2),dtype=np.float32)\n",
    "        obs_axis=np.zeros((2,2),dtype=np.float32)\n",
    "        obs_orign=np.zeros(2,dtype=np.float32)\n",
    "        length2=np.zeros(2,dtype=np.float32)\n",
    "\n",
    "        for j in range(0,2):\n",
    "            # order: (left-bottom, right-bottom, right-upper, left-upper)\n",
    "            obs_corner[0][j] = obc[i][j]\n",
    "            obs_corner[1][j] = obc[i][2+j]\n",
    "            obs_corner[2][j] = obc[i][2*2+j]\n",
    "            obs_corner[3][j] = obc[i][3*2+j]\n",
    "            \n",
    "            # horizontal axis and vertical\n",
    "            obs_axis[0][j] = obs_corner[1][j] - obs_corner[0][j]\n",
    "            obs_axis[1][j] = obs_corner[3][j] - obs_corner[0][j]\n",
    "            #obs_axis[0][j] = obs_corner[3][j] - obs_corner[0][j]\n",
    "            #obs_axis[1][j] = obs_corner[1][j] - obs_corner[0][j]\n",
    "\n",
    "        length2[0]=np.sqrt(obs_axis[0][0]*obs_axis[0][0]+obs_axis[0][1]*obs_axis[0][1])\n",
    "        length2[1]=np.sqrt(obs_axis[1][0]*obs_axis[1][0]+obs_axis[1][1]*obs_axis[1][1])\n",
    "\n",
    "        # normalize the axis\n",
    "        for i1 in range(0,2):\n",
    "            for j1 in range(0,2):\n",
    "                obs_axis[i1][j1]=obs_axis[i1][j1]/float(length2[i1])\n",
    "\n",
    "        # obtain the inner product of the left-bottom corner with the axis to obtain the minimal of projection value\n",
    "        obs_orign[0]=obs_corner[0][0]*obs_axis[0][0]+ obs_corner[0][1]*obs_axis[0][1]  # dot product at 0-th corner\n",
    "        obs_orign[1]=obs_corner[0][0]*obs_axis[1][0]+ obs_corner[0][1]*obs_axis[1][1]\n",
    "        # do checking in both direction (b1 -> b2, b2 -> b1). If at least one shows not-overlapping, then it is not overlapping\n",
    "        cf=overlap(robot_corner,robot_axis,robot_orign,car_width,car_len,obs_corner,obs_axis,obs_orign,width,width)\n",
    "        cf=cf and overlap(obs_corner,obs_axis,obs_orign,width,width,robot_corner,robot_axis,robot_orign,car_width,car_len)\n",
    "        if cf==True:\n",
    "            return True\n",
    "    return False\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [],
   "source": [
    "# visualize the path\n",
    "\"\"\"\n",
    "Given a list of states, render the environment\n",
    "\"\"\"\n",
    "from numpy import sin, cos\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.integrate as integrate\n",
    "import matplotlib.animation as animation\n",
    "import matplotlib as mpl\n",
    "import matplotlib.patches as patches\n",
    "from IPython.display import HTML\n",
    "from visual.visualizer import Visualizer\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "\n",
    "\n",
    "class CarVisualizer(Visualizer):\n",
    "    def __init__(self, system, params):\n",
    "        super(CarVisualizer, 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",
    "        self.ax2 = self.fig.add_subplot(122, projection='3d')\n",
    "\n",
    "        \n",
    "    def _init(self):\n",
    "        # clear the current ax\n",
    "        ax = self.ax1\n",
    "        ax.clear()\n",
    "        ax.set_xlim(-25, 25)\n",
    "        ax.set_ylim(-35, 35)\n",
    "        # add patches\n",
    "        state = self.states[0]\n",
    "        self.car = patches.Rectangle((state[0]-self.params['car_w']/2,state[1]-self.params['car_l']/2),\\\n",
    "                                       self.params['car_w'],self.params['car_l'],\\\n",
    "                                      linewidth=.5,edgecolor='blue',facecolor='blue')\n",
    "        self.car_direction = patches.Arrow(state[0],state[1],\\\n",
    "                                           self.params['car_w']/2,0,\\\n",
    "                                           linewidth=1.0, edgecolor='black')\n",
    "        self.recs = []\n",
    "        self.recs.append(self.car)\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",
    "        # transform pole according to state\n",
    "        t = mpl.transforms.Affine2D().rotate_deg_around(state[0], state[1], \\\n",
    "                                                        -state[2]/np.pi * 180) + ax.transData\n",
    "        self.car.set_transform(t)\n",
    "        ax.add_patch(self.car)\n",
    "        self.car_direction.set_transform(t)\n",
    "        self.car_direction_patch = ax.add_patch(self.car_direction)\n",
    "\n",
    "        # add goal patch\n",
    "        state = self.states[-1]\n",
    "        self.car_goal = patches.Rectangle((state[0]-self.params['car_w']/2,state[1]-self.params['car_l']/2),\\\n",
    "                                       self.params['car_w'],self.params['car_l'],\\\n",
    "                                      linewidth=.5,edgecolor='red',facecolor='red')\n",
    "        self.recs.append(self.car_goal)\n",
    "        # transform pole according to state\n",
    "        t = mpl.transforms.Affine2D().rotate_deg_around(state[0], state[1], \\\n",
    "                                                        -state[2]/np.pi * 180) + ax.transData\n",
    "        self.car_goal.set_transform(t)\n",
    "        ax.add_patch(self.car_goal)\n",
    "\n",
    "        #self.cc_obs = np.array(self.cc_obs)\n",
    "        #ax.scatter(self.cc_obs[:,[0, 2, 4, 6]], self.cc_obs[:,[1, 3, 5, 7]], color='yellow')\n",
    "        \n",
    "        \n",
    "        # state\n",
    "        state = self.states[0]\n",
    "        ax = self.ax2\n",
    "        ax.clear()\n",
    "        ax.set_xlim3d(-25, 25)\n",
    "        ax.set_ylim3d(-35,35)\n",
    "        ax.set_zlim3d(-np.pi,np.pi)\n",
    "\n",
    "        \n",
    "        dx = 1\n",
    "        dtheta = 0.1\n",
    "        feasible_points = []\n",
    "        infeasible_points = []\n",
    "        imin = 0\n",
    "        imax = int(2*25./dx)\n",
    "        jmin = 0\n",
    "        jmax = int(2*35./dx)\n",
    "        zmin = 0\n",
    "        zmax = int(2*np.pi/dtheta)\n",
    "        \n",
    "        \"\"\"\n",
    "        for i in range(imin, imax):\n",
    "            for j in range(jmin, jmax):\n",
    "                for z in range(zmin, zmax):\n",
    "                    x = np.array([dx*i-25, dx*j-35, 0., 0., dtheta*z-np.pi, 0., 0., 0.])\n",
    "                    if IsInCollision(x, self.cc_obs):\n",
    "                        infeasible_points.append(x)\n",
    "                    else:\n",
    "                        feasible_points.append(x)\n",
    "        \n",
    "        feasible_points = np.array(feasible_points)\n",
    "        infeasible_points = np.array(infeasible_points)\n",
    "        #ax.scatter(feasible_points[:,0], feasible_points[:,2], c='yellow')\n",
    "        ax.scatter(infeasible_points[:,0], infeasible_points[:,1], infeasible_points[:,4], c='black')\n",
    "        \"\"\"\n",
    "        \n",
    "        scat_state = ax.scatter([state[0]], [state[1]], [state[2]], c='blue')\n",
    "        self.recs.append(scat_state)\n",
    "        \n",
    "        state = self.states[-1]\n",
    "        \n",
    "        ax.scatter([state[0]], [state[1]], [state[2]], c='red', marker='*')\n",
    "\n",
    "        \n",
    "        # draw the goal region\n",
    "        #ax = self.ax1\n",
    "        # randomly sample several points\n",
    "        \n",
    "        \n",
    "        \n",
    "        return self.recs\n",
    "    def _animate(self, i):\n",
    "        ax = plt.gca()\n",
    "        ax.set_xlim(-25, 25)\n",
    "        ax.set_ylim(-35, 35)\n",
    "        state = self.states[i]\n",
    "        self.recs[0].set_xy((state[0]-self.params['car_w']/2,state[1]-self.params['car_l']/2))\n",
    "        t = mpl.transforms.Affine2D().rotate_deg_around(state[0], state[1], \\\n",
    "                                                        -state[2]/np.pi * 180) + ax.transData\n",
    "        self.recs[0].set_transform(t)\n",
    "        # modify car_direction\n",
    "        self.car_direction_patch.remove()\n",
    "        self.car_direction = patches.Arrow(state[0],state[1],\\\n",
    "                                           self.params['car_w']/2,0,\\\n",
    "                                      linewidth=1.0, edgecolor='black')\n",
    "        self.recs[1] = self.car_direction\n",
    "        t = mpl.transforms.Affine2D().rotate_deg_around(state[0], state[1], \\\n",
    "                                                        -state[2]/np.pi * 180) + ax.transData\n",
    "        self.recs[1].set_transform(t)\n",
    "        self.car_direction_patch = ax.add_patch(self.car_direction)\n",
    "\n",
    "        # print location of cart\n",
    "        self.recs[-1].set_offsets([state[0], state[1], state[2]])\n",
    "\n",
    "        return self.recs\n",
    "\n",
    "\n",
    "    def animate(self, states, actions, costs, obstacles, mode='plot'):\n",
    "        '''\n",
    "        given a list of states, actions and obstacles, animate the robot\n",
    "        '''\n",
    "\n",
    "        new_obs_i = []\n",
    "        obs_width = width\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",
    "        self.states = states\n",
    "        self.obs = obstacles\n",
    "\n",
    "        if mode == 'animate':    \n",
    "            for i in range(len(states)-1):\n",
    "                print('state: %d, remaining: %d' % (i, len(states)-i))\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",
    "            traj = np.array(traj)\n",
    "            print(\"animating...\")\n",
    "            # animate\n",
    "            self.states = traj\n",
    "            print(traj)\n",
    "            self.obs = obstacles\n",
    "            print(len(self.states))\n",
    "            self.total = len(self.states)\n",
    "\n",
    "            ani = animation.FuncAnimation(plt.gcf(), self._animate, range(0, len(self.states)),\n",
    "                                          interval=self.dt, blit=True, init_func=self._init,\n",
    "                                          repeat=True)\n",
    "            return ani\n",
    "        else:\n",
    "            self._init()\n",
    "            plt.show()\n",
    "            return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start:\n",
      "[-7.88510301 13.27546067  2.65989592]\n",
      "robot corners:\n",
      "[[ -2.648556   20.52657  ]\n",
      " [-16.827919   13.114033 ]\n",
      " [-13.12165     6.024352 ]\n",
      " [  1.0577122  13.436888 ]]\n",
      "robot orign:\n",
      "[ -7.162444 -19.417887]\n",
      "isincollision:  False\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"
    }
   ],
   "source": [
    "low = []\n",
    "high = []\n",
    "system = standard_cpp_systems.RectangleObs(obs_list, width, 'car')\n",
    "\n",
    "state_bounds = system.get_state_bounds()\n",
    "for i in range(len(state_bounds)):\n",
    "    low.append(state_bounds[i][0])\n",
    "    high.append(state_bounds[i][1])\n",
    "    \n",
    "start = np.random.uniform(low=low, high=high)\n",
    "\n",
    "print('start:')\n",
    "print(start)\n",
    "print('isincollision: ', IsInCollision(start, obs_list_to_corner, width))\n",
    "\n",
    "\n",
    "params = {}\n",
    "params['car_w'] = car_width\n",
    "params['car_l'] = car_len\n",
    "params['obs_w'] = width\n",
    "params['obs_h'] = width\n",
    "params['integration_step'] = 0.002\n",
    "\n",
    "propagate_system = _sst_module.RallyCar()\n",
    "cpp_propagator = _sst_module.SystemPropagator()\n",
    "dynamics = lambda x, u, t: cpp_propagator.propagate(propagate_system, x, u, t)\n",
    "\n",
    "vis = CarVisualizer(dynamics, params)\n",
    "vis.animate([start, start], [], [], obs_list)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "robot corners:\n",
      "[[-12.565275  -17.384312 ]\n",
      " [ -2.3676317 -29.713467 ]\n",
      " [  3.7969458 -24.614645 ]\n",
      " [ -6.400697  -12.285491 ]]\n",
      "robot orign:\n",
      "[ 18.783224 -15.921164]\n",
      "obs_corner\n",
      "[[-14.874339   -5.7053375]\n",
      " [ -6.8743396  -5.7053375]\n",
      " [ -6.8743396   2.2946625]\n",
      " [-14.874339    2.2946625]]\n",
      "obstacle orign:\n",
      "[-14.874339   -5.7053375]\n",
      "obs_corner\n",
      "[[12.00148 26.55624]\n",
      " [20.00148 26.55624]\n",
      " [20.00148 34.55624]\n",
      " [12.00148 34.55624]]\n",
      "obstacle orign:\n",
      "[12.00148 26.55624]\n",
      "obs_corner\n",
      "[[-5.679159  21.654938 ]\n",
      " [ 2.3208406 21.654938 ]\n",
      " [ 2.3208406 29.654938 ]\n",
      " [-5.679159  29.654938 ]]\n",
      "obstacle orign:\n",
      "[-5.679159 21.654938]\n",
      "obs_corner\n",
      "[[10.201116  -4.5476875]\n",
      " [18.201115  -4.5476875]\n",
      " [18.201115   3.4523127]\n",
      " [10.201116   3.4523127]]\n",
      "obstacle orign:\n",
      "[10.201116  -4.5476875]\n",
      "obs_corner\n",
      "[[ -7.2552505 -30.458754 ]\n",
      " [  0.7447497 -30.458754 ]\n",
      " [  0.7447497 -22.458754 ]\n",
      " [ -7.2552505 -22.458754 ]]\n",
      "obstacle orign:\n",
      "[ -7.2552505 -30.458754 ]\n",
      "isincollision:  True\n"
     ]
    }
   ],
   "source": [
    "print('isincollision: ', IsInCollision(start, obs_list_to_corner, width))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "here\n",
      "start:\n",
      "[-23.18374994  20.3013484    1.01407324]\n",
      "end:\n",
      "[-15.74387414 -22.38961834   1.36926582]\n",
      "start:\n",
      "[10.21926641 -7.07042932 -0.73378125]\n",
      "end:\n",
      "[-10.02447197  28.9337733    2.92132825]\n",
      "start:\n",
      "[-20.01672449  30.54711821  -1.79929003]\n",
      "end:\n",
      "[-13.32658071  13.50535031  -1.40536629]\n",
      "start:\n",
      "[-16.57407621 -30.13021912   2.81836317]\n",
      "end:\n",
      "[-24.54739322   7.81463397  -0.93131549]\n",
      "start:\n",
      "[19.72898799 26.32512543  2.98964926]\n",
      "end:\n",
      "[ 9.81544449 -7.77173849  0.75211574]\n",
      "start:\n",
      "[22.30762296 14.682972    1.55683502]\n",
      "end:\n",
      "[21.67923694  8.56391385  1.32913996]\n",
      "start:\n",
      "[3.05520599 5.13200098 1.24215971]\n",
      "end:\n",
      "[ -3.06498194 -27.85333732  -0.40627581]\n",
      "start:\n",
      "[-13.24692278  22.72229894  -2.12161589]\n",
      "end:\n",
      "[ 20.57752661 -27.72964678  -0.65881617]\n",
      "start:\n",
      "[ 9.24228607 26.34016533  0.89018789]\n",
      "end:\n",
      "[-8.27686229 34.75953919 -0.34800412]\n",
      "start:\n",
      "[-6.1767754  20.78191558 -2.11606863]\n",
      "end:\n",
      "[-21.39014205   4.3081186   -0.07773923]\n",
      "start:\n",
      "[7.89783362 6.84956921 0.91945488]\n",
      "end:\n",
      "[ 16.7316225  -23.30434628  -2.36407758]\n",
      "start:\n",
      "[19.34251593  9.97640462 -2.56163927]\n",
      "end:\n",
      "[ 8.53585764 16.33193804 -1.60541003]\n",
      "start:\n",
      "[-21.49739165  17.63313161  -2.99824393]\n",
      "end:\n",
      "[ 6.62513216 20.34357807 -2.50993634]\n",
      "start:\n",
      "[-13.74675879 -22.44647761   0.09488342]\n",
      "end:\n",
      "[11.45784898 20.37669229 -0.72451426]\n",
      "start:\n",
      "[-24.47138459 -31.54130985   2.58737925]\n",
      "end:\n",
      "[  0.30796606 -13.12640323   1.00506601]\n",
      "start:\n",
      "[-10.92807096 -34.5785225    2.49666051]\n",
      "end:\n",
      "[-18.89909079   2.86457283   2.59779543]\n",
      "start:\n",
      "[ -6.61257298 -23.25033505   0.87692991]\n",
      "end:\n",
      "[11.7776655  -5.34123405  0.81609076]\n",
      "start:\n",
      "[-16.39962962   9.80246808  -2.71106731]\n",
      "end:\n",
      "[-17.39907655   8.07047594   0.85011783]\n",
      "start:\n",
      "[ 24.71957278 -31.13646378   0.43128639]\n",
      "end:\n",
      "[14.07166459  8.88333407  1.14639117]\n",
      "start:\n",
      "[  7.80079288 -29.2843545   -1.01881411]\n",
      "end:\n",
      "[11.20279319 18.46032417  1.54684776]\n",
      "start:\n",
      "[ 0.46419625 -7.43694444  3.04208288]\n",
      "end:\n",
      "[-15.53023827   1.79988195   0.9092086 ]\n",
      "start:\n",
      "[23.41128927 22.58264422 -1.68041767]\n",
      "end:\n",
      "[ 17.0472286  -10.49459064   1.63998754]\n",
      "start:\n",
      "[-7.03731561 -0.61446187 -1.41336069]\n",
      "end:\n",
      "[ -6.83274546 -15.03856039  -1.47988667]\n",
      "start:\n",
      "[-7.49839809 25.75817792  1.36208927]\n",
      "end:\n",
      "[-20.20663557  -2.1547226   -1.50063888]\n",
      "start:\n",
      "[ 10.47149053 -20.2993704   -0.66773322]\n",
      "end:\n",
      "[-17.27597358 -29.8942278    1.82704142]\n",
      "start:\n",
      "[  5.32660732 -23.59756633  -0.43988597]\n",
      "end:\n",
      "[ 11.82528974 -29.49419534   1.74124665]\n",
      "start:\n",
      "[12.18125226 16.36308905 -2.68668132]\n",
      "end:\n",
      "[ 22.14338481 -33.21980751  -0.35282357]\n",
      "start:\n",
      "[-1.31500773 34.38739459  0.30056205]\n",
      "end:\n",
      "[ 3.96112939 -4.81312892  3.07125022]\n",
      "start:\n",
      "[ -1.17782764 -18.43512193  -1.24809331]\n",
      "end:\n",
      "[-22.95690535 -22.3972455    2.90303042]\n",
      "start:\n",
      "[ 8.5196357  -9.28881734 -1.42723722]\n",
      "end:\n",
      "[-15.1648065  -23.97623414  -0.2210099 ]\n",
      "start:\n",
      "[10.92651436 21.17251961 -2.10821405]\n",
      "end:\n",
      "[-20.66087837 -15.38345808  -2.4088446 ]\n",
      "start:\n",
      "[-20.78577743 -26.44660033  -0.94299551]\n",
      "end:\n",
      "[20.54725567 17.76310908 -1.26034108]\n"
     ]
    }
   ],
   "source": [
    "print('here')\n",
    "#obs_list = np.array(obs_list)\n",
    "system = standard_cpp_systems.RectangleObs(obs_list, width, 'car')\n",
    "#system = CartPoleObs(obs_list)\n",
    "# Create SST planner\n",
    "min_time_steps = 10\n",
    "max_time_steps = 200\n",
    "integration_step = 0.002\n",
    "max_iter = 300000\n",
    "goal_radius=.5\n",
    "random_seed=0\n",
    "sst_delta_near=.6\n",
    "sst_delta_drain=.2\n",
    "\n",
    "low = []\n",
    "high = []\n",
    "state_bounds = system.get_state_bounds()\n",
    "for i in range(len(state_bounds)):\n",
    "    low.append(state_bounds[i][0])\n",
    "    high.append(state_bounds[i][1])\n",
    "    \n",
    "\n",
    "# make sure start and goal are collision-free\n",
    "while True:\n",
    "    start = np.random.uniform(low=low, high=high)\n",
    "    end = np.random.uniform(low=low, high=high)\n",
    "    print('start:')\n",
    "    print(start)\n",
    "    print('end:')\n",
    "    print(end)\n",
    "    if not IsInCollision(start, obs_list_to_corner, width) and not IsInCollision(end, obs_list_to_corner, width):\n",
    "        break\n",
    "    #break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start:\n",
      "[-20.78577743 -26.44660033  -0.94299551]\n",
      "end:\n",
      "[20.54725567 17.76310908 -1.26034108]\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"
    }
   ],
   "source": [
    "print('start:')\n",
    "print(start)\n",
    "print('end:')\n",
    "print(end)\n",
    "start[2] = 0\n",
    "end[2] = 0\n",
    "\n",
    "params = {}\n",
    "params['car_w'] = car_width\n",
    "params['car_l'] = car_len\n",
    "params['obs_w'] = width\n",
    "params['obs_h'] = width\n",
    "params['integration_step'] = integration_step\n",
    "\n",
    "propagate_system = _sst_module.Car()\n",
    "cpp_propagator = _sst_module.SystemPropagator()\n",
    "dynamics = lambda x, u, t: cpp_propagator.propagate(propagate_system, x, u, t)\n",
    "\n",
    "vis = CarVisualizer(dynamics, params)\n",
    "#states, actions, costs = solution\n",
    "#states, actions, costs, obstacles\n",
    "vis.animate([start, end], [], [], obs_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 0/300000\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-7-fca3cf47e65e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     49\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0miteration\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0.1\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mmax_iter\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     50\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'iteration: %d/%d'\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0miteration\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmax_iter\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 51\u001b[0;31m     \u001b[0msteer_start\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msteer_end\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplanner\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep_with_output\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msystem\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmin_time_steps\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmax_time_steps\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mintegration_step\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     52\u001b[0m     \u001b[0;31m#print('start:')\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     53\u001b[0m     \u001b[0;31m#print(steer_start)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "#start[2] = 0.\n",
    "#start[3] = 0.\n",
    "\n",
    "#end[1] = 0.\n",
    "#end[3] = 0.\n",
    "planner = SST(\n",
    "    state_bounds=system.get_state_bounds(),\n",
    "    control_bounds=system.get_control_bounds(),\n",
    "    distance=system.distance_computer(),\n",
    "    start_state=start,\n",
    "    goal_state=end,\n",
    "    goal_radius=goal_radius,\n",
    "    random_seed=0,\n",
    "    sst_delta_near=sst_delta_near,\n",
    "    sst_delta_drain=sst_delta_drain\n",
    ")\n",
    "\n",
    "\n",
    "params = {}\n",
    "params['car_w'] = car_width\n",
    "params['car_l'] = car_len\n",
    "params['obs_w'] = width\n",
    "params['obs_h'] = width\n",
    "params['integration_step'] = 0.02\n",
    "\n",
    "propagate_system = _sst_module.Car()\n",
    "cpp_propagator = _sst_module.SystemPropagator()\n",
    "dynamics = lambda x, u, t: cpp_propagator.propagate(propagate_system, x, u, t)\n",
    "\n",
    "vis = CarVisualizer(dynamics, params)\n",
    "#states, actions, costs = solution\n",
    "#states, actions, costs, obstacles\n",
    "vis.animate([start, end], [], [], obs_list)\n",
    "#HTML(anim.to_html5_video())\n",
    "\n",
    "\n",
    "\n",
    "# Run planning and print out solution is some statistics every few iterations.\n",
    "\n",
    "time0 = time.time()\n",
    "ax = vis.ax2\n",
    "\n",
    "for iteration in range(max_iter):\n",
    "    #if iteration % 50 == 0:\n",
    "    #    # from time to time use the goal\n",
    "    #    sample = end\n",
    "    #    planner.step_with_sample(system, sample, 20, 200, 0.002)\n",
    "    #else:\n",
    "    if iteration % int(0.1 * max_iter) == 0:        \n",
    "        print('iteration: %d/%d' % (iteration, max_iter))\n",
    "    steer_start, steer_end = planner.step_with_output(system, min_time_steps, max_time_steps, integration_step)\n",
    "    #print('start:')\n",
    "    #print(steer_start)\n",
    "    #print('end:')\n",
    "    #print(steer_end)\n",
    "    #ax.scatter(steer_start[0], steer_start[1], steer_start[4], c='red')\n",
    "    #ax.scatter(steer_end[0], steer_end[1], steer_end[4], c='blue')\n",
    "\n",
    "    #    #sample = np.random.uniform(low=low, high=high)\n",
    "    #print('iteration: %d' % (iteration))\n",
    "    # interation: 0.002\n",
    "    #planner.step_with_sample(system, sample, 2, 20, 0.01)\n",
    "    \n",
    "    #if iteration % 100 == 0:\n",
    "solution = planner.get_solution()\n",
    "print(\"Solution: %s, Number of nodes: %s\" % (planner.get_solution(), planner.get_number_of_nodes()))\n",
    "\n",
    "print('time spent: %f' % (time.time() - time0))\n",
    "assert solution is not None\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "states, actions, costs = solution\n",
    "print(states.shape)\n",
    "print(actions.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "params = {}\n",
    "params['car_w'] = car_width\n",
    "params['car_l'] = car_len\n",
    "params['obs_w'] = width\n",
    "params['obs_h'] = width\n",
    "params['integration_step'] = integration_step\n",
    "\n",
    "propagate_system = _sst_module.Car()\n",
    "cpp_propagator = _sst_module.SystemPropagator()\n",
    "dynamics = lambda x, u, t: cpp_propagator.propagate(propagate_system, x, u, t)\n",
    "\n",
    "vis = CarVisualizer(dynamics, params)\n",
    "states, actions, costs = solution\n",
    "anim = vis.animate(np.array(states), np.array(actions), np.array(costs), obs_list, mode='animate')\n",
    "HTML(anim.to_html5_video())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(obs_list)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda env:ylmiao_kino_c++] *",
   "language": "python",
   "name": "conda-env-ylmiao_kino_c__-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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}