test_detect_car.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import keras\n",
    "from keras.models import load_model\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "from sklearn.cluster import DBSCAN\n",
    "\n",
    "from keras.optimizers import Adam\n",
    "\n",
    "from full_view_model import fcn_model\n",
    "from util_func import *\n",
    "from full_view_train import *\n",
    "from test_on_udacity_data import *\n",
    "from convert_to_full_view_panorama import *\n",
    "\n",
    "from keras.utils.generic_utils import get_custom_objects\n",
    "get_custom_objects().update({\"my_loss\": my_loss})\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<tf.Tensor 'gradients/split_1_grad/concat:0' shape=(?, 16, 320, 8) dtype=float32>, None, None]\n"
     ]
    }
   ],
   "source": [
    "# load trained model\n",
    "model = load_model('./saved_model/fv_model_for_car_June_30_63.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "len(list_of_view):  17977\n"
     ]
    }
   ],
   "source": [
    "data_dir = './data/training_didi_data/car_train_edited/'\n",
    "list_of_view = list_of_data(data_dir)\n",
    "print('len(list_of_view): ', len(list_of_view))\n",
    "#list_of_view = ['./data/training_didi_data/car_train_edited/suburu_leading_front_left/view/view_281.npy',\n",
    "#                './data/training_didi_data/car_train_edited/cmax_following_long/view/view_6631.npy']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "./data/training_didi_data/car_train_edited/suburu_driving_towards_it/lidar/lidar_196.npy\n",
      "./data/training_didi_data/car_train_gt_box_edited/suburu_driving_towards_it/gt_boxes3d/gt_boxes3d_196.npy\n"
     ]
    }
   ],
   "source": [
    "list_of_lidar = [file.replace('view','lidar') for file in list_of_view]\n",
    "list_of_gtbox = [file.replace('car_train_edited', 'car_train_gt_box_edited').replace('view','gt_boxes3d') \n",
    "                 for file in list_of_view]\n",
    "print(list_of_lidar[0])\n",
    "print(list_of_gtbox[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predict and clustering predicted box"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def one_box_clustering(boxes, eps = 1, min_samples = 1):\n",
    "    # Extract the center from predicted boxes\n",
    "    box_centers = np.mean(boxes[:,[0,2],:2], axis = 1)\n",
    "    # Do clustering\n",
    "    db = DBSCAN(eps=eps, min_samples=min_samples).fit(box_centers)\n",
    "    labels = db.labels_\n",
    "       \n",
    "    n_clusters = len(set(labels))\n",
    "    n_points = [np.sum([labels == i]) for i in range(n_clusters) ]\n",
    "    max_point_cluster = np.argmax(n_points)\n",
    "    \n",
    "    index = (labels == max_point_cluster)\n",
    "    box = np.mean(boxes[index],axis = 0)\n",
    "    return np.expand_dims(box, 0)\n",
    "\n",
    "\n",
    "def multi_box_clustering(boxes, eps = 1, min_samples = 1):\n",
    "    # Extract the center from predicted boxes\n",
    "    box_centers = np.mean(boxes[:,[0,2],:2], axis = 1)\n",
    "    # Do clustering\n",
    "    db = DBSCAN(eps=eps, min_samples=min_samples).fit(box_centers)\n",
    "    labels = db.labels_\n",
    "       \n",
    "    n_clusters = len(set(labels))\n",
    "    mul_clusters = np.array([np.mean(boxes[labels == i],axis = 0) for i in range(n_clusters)])\n",
    "    \n",
    "    return mul_clusters\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def distance(p,q):\n",
    "    return np.sqrt(np.sum(np.square(p-q)))\n",
    "\n",
    "def length(v):\n",
    "    return distance(v,0)\n",
    "\n",
    "def rotate(angle, lidar):\n",
    "    return np.array([rotation(angle, lidar[i]) for i in range(len(lidar))])\n",
    "\n",
    "def fit_box(lidar, nb_d = 128):\n",
    "    \n",
    "    lidar_2d = lidar[:,:2]\n",
    "    angle = np.pi/(nb_d*2)\n",
    "    center = (np.max(lidar_2d, axis = 0) + np.min(lidar_2d, axis = 0))/2\n",
    "    center = np.expand_dims(center,0)\n",
    "    #rotated\n",
    "    lidar_2d = lidar_2d - center\n",
    "    rotated_lidar = [rotate(angle*i, lidar_2d) for i in range(nb_d)]\n",
    "        \n",
    "    max_lidars = np.array([np.max(rotated_lidar[i],axis = 0) for i in range(nb_d)])\n",
    "    min_lidars = np.array([np.min(rotated_lidar[i],axis = 0) for i in range(nb_d)])\n",
    "    #print(max_lidars.shape, min_lidars.shape)\n",
    "    #max_lidars = np.max(rotated_lidar, axis = 1)\n",
    "    #min_lidars = np.min(rotated_lidar, axis = 1)\n",
    "    range_lidars = max_lidars - min_lidars\n",
    "    areas = range_lidars[:,0]*range_lidars[:,1]\n",
    "    #print(areas.shape)\n",
    "    \n",
    "    arg_min = np.argmin(areas)\n",
    "    \n",
    "    rp0, rp2 = min_lidars[arg_min], max_lidars[arg_min]\n",
    "    rp1, rp3 = np.array([rp2[0], rp0[1]]), np.array([rp0[0], rp2[1]])\n",
    "    \n",
    "    box_2d = np.array([rotation(-angle*arg_min, p) for p in [rp0,rp1,rp2,rp3]]) + center\n",
    "    \n",
    "    #box = -1.5*np.ones((1,8,3))\n",
    "    #box[0,:4,:2] = box_2d\n",
    "    #box[0,4:,:2] = box_2d\n",
    "    #box[0,4:,2] = np.max(lidar[:,2])\n",
    "    return box_2d#, box\n",
    "\n",
    "def move_box(box, side):\n",
    "    '''\n",
    "    box: 2d box of shape (4,2)\n",
    "    side: array of shape (2,2)\n",
    "    '''\n",
    "\n",
    "    #print(box)\n",
    "    #print(side)\n",
    "    v_box = box[1] - box[0]\n",
    "    v_side = side[1] - side[0]\n",
    "    angle_offset = np.arctan2(v_side[1], v_side[0]) - np.arctan2(v_box[1], v_box[0])\n",
    "    #print(np.arctan2(v_side[1], v_side[0]), np.arctan2(v_box[1], v_box[0]))\n",
    "    #print(angle_offset)\n",
    "    \n",
    "    rot_box = np.array([rotation(-angle_offset, box[i] - box[0]) + box[0] for i in range(4)])\n",
    "    #print('rot_box')\n",
    "    #print(rot_box)\n",
    "    \n",
    "    pos_offset = side[0] - box[0]\n",
    "    correct_box = rot_box + np.expand_dims(pos_offset, axis = 0)\n",
    "     \n",
    "    return correct_box\n",
    "\n",
    "def correct_box(predbox, fitbox):\n",
    "    '''\n",
    "    box, fitbox: 2d box of shape (4,2)\n",
    "    Move box to the right position based on position of fitbox \n",
    "    '''\n",
    "    pred_sides = np.array([distance(predbox[0], predbox[1]), distance(predbox[1], predbox[2])])\n",
    "    min_pred_side = np.min(pred_sides)\n",
    "    min_pred_ind = np.argmin(pred_sides)\n",
    "    \n",
    "    fit_distances = np.array([length(fitbox[i]) for i in range(4)])  \n",
    "    min_fit_ind = np.argmin(fit_distances)\n",
    "    next_fit_ind = (min_fit_ind + 1)%4\n",
    "    prev_fit_ind = (min_fit_ind + 3)%4\n",
    "    \n",
    "    next_fit_side = distance(fitbox[min_fit_ind],fitbox[next_fit_ind])\n",
    "    prev_fit_side = distance(fitbox[min_fit_ind],fitbox[prev_fit_ind])\n",
    "    \n",
    "    nearest_fit_point = fitbox[min_fit_ind]\n",
    "    \n",
    "    diff_next_side = abs(next_fit_side - min_pred_side)\n",
    "    diff_prev_side = abs(prev_fit_side - min_pred_side)\n",
    "    if diff_next_side < diff_prev_side:\n",
    "        side = fitbox[[min_fit_ind, next_fit_ind],:]\n",
    "    else:\n",
    "        side = fitbox[[prev_fit_ind, min_fit_ind],:]\n",
    "    \n",
    "    indices = [(min_pred_ind + i)%4 for i in range(4)]\n",
    "    box = np.array([predbox[i] for i in indices])\n",
    "    box = move_box(box, side)\n",
    "    box_distances = np.array([length(box[i]) for i in range(4)])\n",
    "    min_ind = np.argmin(box_distances)\n",
    "    if min_ind == min_fit_ind:\n",
    "        return box\n",
    "    else:\n",
    "        indices = [(min_pred_ind + i + 2)%4 for i in range(4)]\n",
    "        box = np.array([predbox[i] for i in indices])\n",
    "        box = move_box(box, side)\n",
    "        return box\n",
    "    \n",
    "def correct_box_3d(predbox, fitbox, min_z = -1.5):\n",
    "    '''\n",
    "    box: 3d box of shape (8,3)\n",
    "    fitbox: 2d box of shape (4,2)\n",
    "    Move box to the right position based on position of fitbox \n",
    "    '''\n",
    "    box2d = correct_box(predbox[:4,:2], fitbox)\n",
    "    box = min_z*np.ones_like(predbox)\n",
    "    box[:4,:2] = box2d\n",
    "    box[4:,:2] = box2d\n",
    "    box[4:,2] = abs(predbox[4,2] - predbox[0,2])+min_z\n",
    "    return box"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def correct_predicted_box(clusters, labels, boxes):\n",
    "    list_clusters = list(set(labels))\n",
    "    nb_clusters = len(list_clusters)\n",
    "    if nb_clusters == 0:\n",
    "        return np.array([])\n",
    "#     if nb_clusters == 1:\n",
    "#         assert len(boxes) == 1, 'nb_clusters == 1 but len(boxes) = {0}'.format(len(boxes))\n",
    "#         fitbox = fit_box(clusters)\n",
    "#         correctbox = correct_box_3d(boxes[0], fitbox)\n",
    "#         correctbox = np.expand_dims(correctbox, axis = 0)\n",
    "#         return correctbox\n",
    "    else:\n",
    "        correctboxes = np.zeros((len(boxes), 8, 3))\n",
    "        list_of_cluster = [clusters[labels == list_clusters[i]] for i in range(nb_clusters)]\n",
    "        center_clusters = [np.mean(list_of_cluster[i][:,:2], axis = 0) for i in range(nb_clusters)]\n",
    "        for b in range(len(boxes)):\n",
    "            box = boxes[b]\n",
    "            center_box = np.mean(box[:4,:2], axis = 0)\n",
    "            distances = [distance(center_box, center_clusters[i]) for i in range(nb_clusters)]\n",
    "            ind = np.argmin(distances)\n",
    "            nearest_cluster = list_of_cluster[ind]\n",
    "            \n",
    "            fitbox = fit_box(nearest_cluster)\n",
    "            correctbox = correct_box_3d(box, fitbox)\n",
    "            \n",
    "            correctboxes[b] = correctbox\n",
    "        return correctboxes\n",
    "            \n",
    "            \n",
    "            \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def predict(model,lidar, cluster = True, seg_thres=0.5, multi_box = True):\n",
    "    \n",
    "    test_view, clusters, labels =  fv_cylindrical_projection_for_test(lidar)\n",
    "    \n",
    "    view = test_view[:,:,[5,2]].reshape(1,16,320,2)\n",
    "    \n",
    "    list_boxes = []\n",
    "\n",
    "    test_view_reshape = test_view.reshape(-1,6)\n",
    "    pred = model.predict(view)\n",
    "    pred = pred[0].reshape(-1,8)\n",
    "    \n",
    "    thres_pred = pred[pred[:,0] > seg_thres]\n",
    "    thres_view = test_view_reshape[pred[:,0] > seg_thres]\n",
    "    \n",
    "    \n",
    "    num_boxes = len(thres_pred)\n",
    "    if num_boxes == 0:\n",
    "        return np.array([]), np.array([])\n",
    "    boxes = np.zeros((num_boxes,8,3))\n",
    "    \n",
    "    for i in range(num_boxes):\n",
    "        boxes[i,0] = thres_view[i,:3] - rotation(thres_view[i,3],thres_pred[i,1:4])\n",
    "        boxes[i,6] = thres_view[i,:3] - rotation(thres_view[i,3],thres_pred[i,4:7])\n",
    "\n",
    "        boxes[i,2,:2] = boxes[i,6,:2]\n",
    "        boxes[i,2,2] = boxes[i,0,2]\n",
    "\n",
    "        phi = thres_pred[i,-1]\n",
    "\n",
    "        z = boxes[i,2] - boxes[i,0]\n",
    "        boxes[i,1,0] = (np.cos(phi)*z[0] + np.sin(phi)*z[1])*np.cos(phi) + boxes[i,0,0]\n",
    "        boxes[i,1,1] = (-np.sin(phi)*z[0] + np.cos(phi)*z[1])*np.cos(phi) + boxes[i,0,1]\n",
    "        boxes[i,1,2] = boxes[i,0,2]\n",
    "\n",
    "        boxes[i,3] = boxes[i,0] + boxes[i,2] - boxes[i,1]\n",
    "        boxes[i,4] = boxes[i,0] + boxes[i,6] - boxes[i,2]\n",
    "        boxes[i,5] = boxes[i,1] + boxes[i,4] - boxes[i,0]\n",
    "        boxes[i,7] = boxes[i,4] + boxes[i,6] - boxes[i,5]\n",
    "        \n",
    "    list_boxes.append(boxes)\n",
    "\n",
    "    boxes = np.concatenate(list_boxes, axis = 0)\n",
    "    if not cluster:\n",
    "        return boxes\n",
    "    \n",
    "    elif multi_box:\n",
    "        mul_clusters = multi_box_clustering(boxes)\n",
    "        return boxes, mul_clusters\n",
    "    else:\n",
    "        one_cluster = one_box_clustering(boxes)\n",
    "        return boxes, one_cluster\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def predict_and_correct(model,lidar, cluster = True, seg_thres=0.5, multi_box = True):\n",
    "    \n",
    "    test_view, clusters, labels =  fv_cylindrical_projection_for_test(lidar)\n",
    "    \n",
    "    view = test_view[:,:,[5,2]].reshape(1,16,320,2)\n",
    "    \n",
    "    list_boxes = []\n",
    "\n",
    "    test_view_reshape = test_view.reshape(-1,6)\n",
    "    pred = model.predict(view)\n",
    "    pred = pred[0].reshape(-1,8)\n",
    "    \n",
    "    thres_pred = pred[pred[:,0] > seg_thres]\n",
    "    thres_view = test_view_reshape[pred[:,0] > seg_thres]\n",
    "    \n",
    "    \n",
    "    num_boxes = len(thres_pred)\n",
    "    if num_boxes == 0:\n",
    "        return np.array([]), np.array([])\n",
    "    boxes = np.zeros((num_boxes,8,3))\n",
    "    \n",
    "    for i in range(num_boxes):\n",
    "        boxes[i,0] = thres_view[i,:3] - rotation(thres_view[i,3],thres_pred[i,1:4])\n",
    "        boxes[i,6] = thres_view[i,:3] - rotation(thres_view[i,3],thres_pred[i,4:7])\n",
    "\n",
    "        boxes[i,2,:2] = boxes[i,6,:2]\n",
    "        boxes[i,2,2] = boxes[i,0,2]\n",
    "\n",
    "        phi = thres_pred[i,-1]\n",
    "\n",
    "        z = boxes[i,2] - boxes[i,0]\n",
    "        boxes[i,1,0] = (np.cos(phi)*z[0] + np.sin(phi)*z[1])*np.cos(phi) + boxes[i,0,0]\n",
    "        boxes[i,1,1] = (-np.sin(phi)*z[0] + np.cos(phi)*z[1])*np.cos(phi) + boxes[i,0,1]\n",
    "        boxes[i,1,2] = boxes[i,0,2]\n",
    "\n",
    "        boxes[i,3] = boxes[i,0] + boxes[i,2] - boxes[i,1]\n",
    "        boxes[i,4] = boxes[i,0] + boxes[i,6] - boxes[i,2]\n",
    "        boxes[i,5] = boxes[i,1] + boxes[i,4] - boxes[i,0]\n",
    "        boxes[i,7] = boxes[i,4] + boxes[i,6] - boxes[i,5]\n",
    "        \n",
    "    list_boxes.append(boxes)\n",
    "\n",
    "    boxes = np.concatenate(list_boxes, axis = 0)\n",
    "    if not cluster:\n",
    "        return boxes\n",
    "    \n",
    "    elif multi_box:\n",
    "        mul_boxes = multi_box_clustering(boxes)\n",
    "        mul_boxes = correct_predicted_box(clusters, labels, mul_boxes)\n",
    "        return boxes, mul_boxes\n",
    "    else:\n",
    "        one_box = one_box_clustering(boxes)\n",
    "        one_box = correct_predicted_box(clusters, labels, one_box)\n",
    "        return boxes, one_box\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# randomly choose a frame \n",
    "i = 400\n",
    "#i = np.random.randint(len(list_of_lidar))\n",
    "lidar = np.load(list_of_lidar[i])\n",
    "gtbox = np.load(list_of_gtbox[i])\n",
    "\n",
    "boxes, box_cluster = predict(model, lidar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 8, 3)\n",
      "(1, 8, 3)\n",
      "Number of predited boxes: 4\n",
      "Number of boxes after clustering: 1\n",
      "Randomly display 10 boxes then display clustered boxes\n"
     ]
    }
   ],
   "source": [
    "print(boxes.shape), print(box_cluster.shape)\n",
    "n_boxes = len(boxes)\n",
    "print('Number of predited boxes: {}'.format(n_boxes))\n",
    "print('Number of boxes after clustering: {}'.format(len(box_cluster)))\n",
    "print('Randomly display 10 boxes then display clustered boxes')\n",
    "choosen_boxes = np.random.randint(n_boxes, size = 10)\n",
    "viz_mayavi_with_labels(lidar, boxes[choosen_boxes])\n",
    "viz_mayavi_with_labels(lidar, box_cluster)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "boxes, box_cluster = predict_and_correct(model, lidar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "viz_mayavi_with_labels(lidar, box_cluster)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### predict on test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of predited boxes: 5\n",
      "Number of boxes after clustering: 1\n",
      "Randomly display 10 boxes then display clustered boxes\n"
     ]
    }
   ],
   "source": [
    "#test_dir = './data/test_cars/'\n",
    "test_lidar = np.load('./data/training_didi_data/car_train_edited/suburu_driving_towards_it/lidar/lidar_140.npy')\n",
    "#test_lidar = np.load('./data/test_cars/ford01/lidar_0.npy')\n",
    "boxes, box_cluster = predict(model, test_lidar)\n",
    "n_boxes = len(boxes)\n",
    "print('Number of predited boxes: {}'.format(n_boxes))\n",
    "print('Number of boxes after clustering: {}'.format(len(box_cluster)))\n",
    "print('Randomly display 10 boxes then display clustered boxes')\n",
    "choosen_boxes = np.random.randint(n_boxes, size = 10)\n",
    "viz_mayavi_with_labels(test_lidar, boxes[choosen_boxes])\n",
    "viz_mayavi_with_labels(test_lidar, box_cluster)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of predited boxes: 5\n",
      "Number of boxes after clustering: 1\n",
      "Randomly display 10 boxes then display clustered boxes\n"
     ]
    }
   ],
   "source": [
    "boxes, new_box_cluster = predict_and_correct(model, test_lidar)\n",
    "n_boxes = len(boxes)\n",
    "print('Number of predited boxes: {}'.format(n_boxes))\n",
    "print('Number of boxes after clustering: {}'.format(len(box_cluster)))\n",
    "print('Randomly display 10 boxes then display clustered boxes')\n",
    "choosen_boxes = np.random.randint(n_boxes, size = 10)\n",
    "viz_mayavi_with_labels(test_lidar, boxes[choosen_boxes])\n",
    "viz_mayavi_with_labels(test_lidar, new_box_cluster)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def predict_bags(model, test_dir, box_test_dir):\n",
    "    '''\n",
    "    This function predict all the test file and save predicted boxes in box_test_dir\n",
    "    '''\n",
    "    if not os.path.exists(box_test_dir):\n",
    "        os.mkdir(box_test_dir)\n",
    "    \n",
    "    bags = os.listdir(test_dir)\n",
    "    for bag in bags:\n",
    "        box_dir = os.path.join(box_test_dir, bag)\n",
    "        if not os.path.exists(box_dir):\n",
    "            os.mkdir(box_dir)\n",
    "        lidar_dir = os.path.join(test_dir, bag)\n",
    "        for f in os.listdir(lidar_dir):\n",
    "            lidar = np.load(os.path.join(lidar_dir,f))\n",
    "            #print(lidar_dir, f)\n",
    "            boxes, box_cluster = predict_and_correct(model, lidar)\n",
    "            #print('-----------------')\n",
    "            #f_box = f.replace('lidar', 'boxes')\n",
    "            f_cluster = f.replace('lidar', 'boxes')\n",
    "            #box_file = os.path.join(box_dir, f_box)\n",
    "            #np.save(box_file, boxes)\n",
    "            cluster_file = os.path.join(box_dir, f_cluster)\n",
    "            np.save(cluster_file, box_cluster)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "test_dir = './data/test_cars/'\n",
    "box_test_dir = './data/new_predicted_test_cars/'\n",
    "predict_bags(model, test_dir, box_test_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 8, 3) (1, 8, 3)\n"
     ]
    }
   ],
   "source": [
    "lidar = np.load('./data/test_cars/ford03/lidar_100.npy')\n",
    "pred_boxes = np.load('./data/box_test_cars/ford03/boxes_100.npy')\n",
    "pred_box = np.load('./data/box_test_cars/ford03/clustered_box_100.npy')\n",
    "print(pred_boxes.shape, pred_box.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "viz_mayavi_with_labels(lidar, pred_boxes)\n",
    "viz_mayavi_with_labels(lidar, pred_box)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda env:tensorflow]",
   "language": "python",
   "name": "conda-env-tensorflow-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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}