[Demo] 3. Camera Tracking.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "import cv2\n",
    "import joblib\n",
    "import quaternion as q\n",
    "import numpy as np\n",
    "from src.models.autoencoder.autoenc import Embedder\n",
    "import torch.nn.functional as F\n",
    "import imageio\n",
    "from IPython.display import clear_output, HTML, display\n",
    "import src.utils.pose_utils as pu\n",
    "import torchvision.transforms.functional as TF\n",
    "from einops import rearrange"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Models\n",
    "- The noise models are from [Active Neural SLAM](https://github.com/devendrachaplot/Neural-SLAM)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ad01493624/codes/venv_rnr/lib/python3.8/site-packages/sklearn/base.py:318: UserWarning: Trying to unpickle estimator GaussianMixture from version 0.22.2.post1 when using version 1.2.2. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n",
      "https://scikit-learn.org/stable/model_persistence.html#security-maintainability-limitations\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "device = 'cuda'\n",
    "embedder = Embedder(pretrained_ckpt='pretrained/autoenc_large.ckpt',\n",
    "                   img_res=128, w_size=128, coordinate_scale=32, w_ch=32, nerf_res=128, voxel_res=128)\n",
    "embedder = embedder.to(device)#.eval()\n",
    "\n",
    "import pickle\n",
    "noise_dir = 'src/noise_models/'\n",
    "sensor_noise_front = pickle.load(open(noise_dir + \"sensor_noise_fwd.pkl\", \"rb\"))\n",
    "sensor_noise_right = pickle.load(open(noise_dir + \"sensor_noise_right.pkl\", \"rb\"))\n",
    "sensor_noise_left = pickle.load(open(noise_dir + \"sensor_noise_left.pkl\", \"rb\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Set up Habitat Simulator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-06-09 17:42:01,638 Initializing dataset PointNav-v1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total 14 scenes found\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "os.environ['GLOG_minloglevel'] = \"3\"\n",
    "os.environ['MAGNUM_LOG'] = \"quiet\"\n",
    "os.environ['HABITAT_SIM_LOG'] = \"quiet\"\n",
    "import habitat\n",
    "from habitat import get_config\n",
    "from habitat.sims import make_sim\n",
    "\n",
    "config = get_config()\n",
    "cfg = config\n",
    "cfg.defrost()\n",
    "habitat_api_path = os.path.join(os.path.dirname(habitat.__file__), '../')\n",
    "cfg.DATASET.SCENES_DIR = os.path.join(habitat_api_path, cfg.DATASET.SCENES_DIR)\n",
    "cfg.DATASET.DATA_PATH = os.path.join(habitat_api_path, cfg.DATASET.DATA_PATH.replace(\"habitat-test-scenes\",\"gibson\"))\n",
    "cfg.SIMULATOR.SCENE_DATASET = 'data/scene_datasets/mp3d.scene_dataset_config.json'\n",
    "cfg.SIMULATOR.SCENE_DATASET = os.path.join(habitat_api_path, cfg.SIMULATOR.SCENE_DATASET)\n",
    "cfg.DATASET.TYPE = \"PointNav-v1\"\n",
    "cfg.SIMULATOR.RGB_SENSOR.HEIGHT = 128\n",
    "cfg.SIMULATOR.RGB_SENSOR.WIDTH = 128\n",
    "cfg.SIMULATOR.DEPTH_SENSOR.HEIGHT = 128\n",
    "cfg.SIMULATOR.DEPTH_SENSOR.WIDTH = 128\n",
    "cfg.TASK.SENSORS = cfg.SIMULATOR.AGENT_0.SENSORS = ['RGB_SENSOR', 'DEPTH_SENSOR']\n",
    "cfg.freeze()\n",
    "\n",
    "from habitat.datasets import make_dataset\n",
    "dataset = make_dataset('PointNav-v1')\n",
    "cfg.defrost()\n",
    "cfg.DATASET.SPLIT = 'val'\n",
    "cfg.freeze()\n",
    "val_scenes = dataset.get_scenes_to_load(cfg.DATASET)\n",
    "all_scenes =  val_scenes\n",
    "print(f'Total {len(all_scenes)} scenes found')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cantwell\n"
     ]
    }
   ],
   "source": [
    "scene = np.random.choice(all_scenes)\n",
    "print(scene)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-06-09 17:42:05,105 initializing sim Sim-v0\n"
     ]
    }
   ],
   "source": [
    "try: sim.close()\n",
    "except: pass\n",
    "cfg.defrost()\n",
    "cfg.SIMULATOR.SCENE = os.path.join(cfg.DATASET.SCENES_DIR,'gibson_habitat/{}.glb'.format(scene))\n",
    "cfg.freeze()\n",
    "past_room = scene\n",
    "sim = make_sim(id_sim=cfg.SIMULATOR.TYPE, config=cfg.SIMULATOR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAX_TIME = 1000\n",
    "VIS_RES = 256\n",
    "NUM_SAMPLE_PIXEL = 200\n",
    "OPT_LR = 0.001\n",
    "NUM_OPT = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# These two functions are from NICE-SLAM (https://github.com/cvg/nice-slam/blob/master/src/common.py)\n",
    "def quad2rotation(quad):\n",
    "    bs = quad.shape[0]\n",
    "    qr, qi, qj, qk = quad[:, 0], quad[:, 1], quad[:, 2], quad[:, 3]\n",
    "    two_s = 2.0 / (quad * quad).sum(-1)\n",
    "    rot_mat = torch.zeros(bs, 3, 3).to(quad.get_device())\n",
    "    rot_mat[:, 0, 0] = 1 - two_s * (qj ** 2 + qk ** 2)\n",
    "    rot_mat[:, 0, 1] = two_s * (qi * qj - qk * qr)\n",
    "    rot_mat[:, 0, 2] = two_s * (qi * qk + qj * qr)\n",
    "    rot_mat[:, 1, 0] = two_s * (qi * qj + qk * qr)\n",
    "    rot_mat[:, 1, 1] = 1 - two_s * (qi ** 2 + qk ** 2)\n",
    "    rot_mat[:, 1, 2] = two_s * (qj * qk - qi * qr)\n",
    "    rot_mat[:, 2, 0] = two_s * (qi * qk - qj * qr)\n",
    "    rot_mat[:, 2, 1] = two_s * (qj * qk + qi * qr)\n",
    "    rot_mat[:, 2, 2] = 1 - two_s * (qi ** 2 + qj ** 2)\n",
    "    return rot_mat\n",
    "\n",
    "def get_camera_from_tensor(inputs):\n",
    "    N = len(inputs.shape)\n",
    "    if N == 1:\n",
    "        inputs = inputs.unsqueeze(0)\n",
    "    quad, T = inputs[:, :4], inputs[:, 4:]\n",
    "    R = quad2rotation(quad)\n",
    "    RT = torch.cat([R, T[:, :, None]], 2)\n",
    "    RT = torch.cat((RT, torch.tensor((0,0,0,1)).to(RT.device).view(1, 1,4)),1)\n",
    "    if N == 1:\n",
    "        RT = RT[0]\n",
    "    return RT\n",
    "\n",
    "####\n",
    "## Visualization code\n",
    "def visualize_traj(gt_locs, pred_locs, bias_locs):\n",
    "    all_locs = np.concatenate([np.array(gt_locs),np.array(pred_locs),np.array(bias_locs)])\n",
    "    x_min, x_max = all_locs[:,0].min(), all_locs[:,0].max()\n",
    "    y_min, y_max = all_locs[:,1].min(), all_locs[:,1].max()\n",
    "    \n",
    "    x_min, x_max = x_min - 1.0, x_max + 1.0\n",
    "    y_min, y_max = y_min - 1.0, y_max + 1.0\n",
    "    \n",
    "    norm_gt_locs = np.array(gt_locs)\n",
    "    norm_gt_locs[:,0] = (norm_gt_locs[:,0]-x_min)/(x_max - x_min + 1e-9)\n",
    "    norm_gt_locs[:,1] = (norm_gt_locs[:,1]-y_min)/(y_max - y_min + 1e-9)\n",
    "    \n",
    "    norm_pred_locs = np.array(pred_locs)\n",
    "    norm_pred_locs[:,0] = (norm_pred_locs[:,0]-x_min)/(x_max - x_min + 1e-9)\n",
    "    norm_pred_locs[:,1] = (norm_pred_locs[:,1]-y_min)/(y_max - y_min + 1e-9)\n",
    "    \n",
    "    norm_bias_locs = np.array(bias_locs)\n",
    "    norm_bias_locs[:,0] = (norm_bias_locs[:,0]-x_min)/(x_max - x_min + 1e-9)\n",
    "    norm_bias_locs[:,1] = (norm_bias_locs[:,1]-y_min)/(y_max - y_min + 1e-9)\n",
    "    \n",
    "    hw_gt_locs = ((norm_gt_locs * 2 - 1) * (VIS_RES/2) + VIS_RES/2).astype(np.uint8)\n",
    "    hw_pred_locs = ((norm_pred_locs * 2 - 1) * (VIS_RES/2) + VIS_RES/2).astype(np.uint8)\n",
    "    hw_bias_locs = ((norm_bias_locs * 2 - 1) * (VIS_RES/2) + VIS_RES/2).astype(np.uint8)\n",
    "    \n",
    "    hw_gt_locs = np.linspace(hw_gt_locs, np.roll(hw_gt_locs,-1, axis=0)).astype(np.uint8)\n",
    "    hw_pred_locs = np.linspace(hw_pred_locs, np.roll(hw_pred_locs,-1, axis=0)).astype(np.uint8)\n",
    "    hw_bias_locs = np.linspace(hw_bias_locs, np.roll(hw_bias_locs,-1, axis=0)).astype(np.uint8)\n",
    "    vis_traj = np.full((VIS_RES, VIS_RES, 3), 255, dtype=np.uint8)\n",
    "    for t in range(len(gt_locs)-1):\n",
    "        for ii in range(-2,3):\n",
    "            for jj in range(-2,3):\n",
    "                old = min(len(gt_locs) - t, 100)/100\n",
    "                vis_traj[hw_gt_locs[:,t,0]+ii, hw_gt_locs[:,t,1]+jj] = [int(255*old),int(255*old),int(255*old)]\n",
    "                vis_traj[hw_bias_locs[:,t,0]+ii, hw_bias_locs[:,t,1]+jj] = [int(255*old),255,int(255*old)]\n",
    "                vis_traj[hw_pred_locs[:,t,0]+ii, hw_pred_locs[:,t,1]+jj] = [255,int(255*old),int(255*old)]\n",
    "    return vis_traj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pose Optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from habitat.tasks.nav.shortest_path_follower import ShortestPathFollower\n",
    "\n",
    "# Sample an episode\n",
    "follower = ShortestPathFollower(sim, 0.5, return_one_hot=False)\n",
    "\n",
    "start_position = sim.sample_navigable_point()\n",
    "start_rotation = q.from_euler_angles([0., np.random.rand() * 2 * np.pi, 0.])\n",
    "\n",
    "\n",
    "sim.set_agent_state(start_position, start_rotation)\n",
    "done = False\n",
    "while True:\n",
    "    goal_point = sim.sample_navigable_point()\n",
    "    if abs(goal_point[1]-start_position[1]) > 0.5: continue\n",
    "    break\n",
    "    \n",
    "\n",
    "# Setup Initial RNR-Map\n",
    "K = torch.eye(3)\n",
    "K[0,0] = (embedder.img_res/2.) / np.tan(np.deg2rad(90.0) / 2)\n",
    "K[1,1] = -(embedder.img_res/2.) / np.tan(np.deg2rad(90.0) / 2)\n",
    "K = K.unsqueeze(0).to(device)\n",
    "\n",
    "orig_Rt = np.eye(4)\n",
    "orig_Rt[:3,3] = start_position\n",
    "orig_Rt[:3,:3] = q.as_rotation_matrix(start_rotation)\n",
    "orig_Rt = torch.from_numpy(np.linalg.inv(orig_Rt)).float()\n",
    "\n",
    "w, w_mask = None, None\n",
    "\n",
    "# Start an episode\n",
    "start_loc = curr_bias_loc = curr_gt_loc = curr_loc = pu.get_sim_location(start_position,start_rotation)\n",
    "\n",
    "action = None\n",
    "time_t = 0\n",
    "\n",
    "gt_locs, bias_locs, adjust_locs = [], [], []\n",
    "vis_traj = np.full((VIS_RES, VIS_RES, 3),255, dtype=np.uint8)\n",
    "images = []\n",
    "while not done:\n",
    "    state = sim.get_agent_state()\n",
    "    obs = sim.get_observations_at(state.position, state.rotation)\n",
    "    \n",
    "    new_gt_loc = pu.get_sim_location(state.position, state.rotation) \n",
    "    dx_gt, dy_gt, do_gt = pu.get_rel_pose_change(new_gt_loc, curr_gt_loc) # gt odometry\n",
    "    \n",
    "    if action is not None:\n",
    "        # Add noise to odometry\n",
    "        if action == 1:  ## Forward\n",
    "            dx, dy, do = sensor_noise_front.sample()[0][0]\n",
    "        elif action == 2:  ## Left\n",
    "            dx, dy, do = sensor_noise_left.sample()[0][0]\n",
    "        elif action == 3:  ## Right\n",
    "            dx, dy, do = sensor_noise_right.sample()[0][0]\n",
    "        do = np.deg2rad(do)\n",
    "        dp_gt = (dx_gt, dy_gt, do_gt)\n",
    "        curr_gt_loc = pu.get_new_pose(curr_gt_loc, dp_gt) # gt position\n",
    "        dp = (dx_gt + dx, dy_gt + dy, do_gt + do)\n",
    "        curr_loc = pu.get_new_pose(curr_loc, dp) # predicted position\n",
    "        curr_bias_loc = pu.get_new_pose(curr_bias_loc, dp) # predicted poistion without pose adjustment\n",
    "        \n",
    "    rgb_t = torch.from_numpy(obs['rgb']/255.).unsqueeze(0).permute(0,3,1,2).to(device)\n",
    "    depth_t = torch.from_numpy(obs['depth']).unsqueeze(0).permute(0,3,1,2).to(device)\n",
    "    if time_t > 0:\n",
    "        # Optimize pose\n",
    "        with torch.enable_grad():\n",
    "            x = torch.tensor(-curr_loc[1]).float().cuda()\n",
    "            y = torch.tensor(-curr_loc[0]).float().cuda()\n",
    "            z = torch.tensor(start_position[1]).float().cuda()\n",
    "            a = torch.tensor(curr_loc[2]).float().cuda()\n",
    "            x.requires_grad = y.requires_grad = a.requires_grad = True\n",
    "\n",
    "            K.requires_grad = False\n",
    "            w = w.detach()\n",
    "            w.requires_grad = False\n",
    "            optim = torch.optim.Adam([x, y, a], lr=OPT_LR)\n",
    "            \n",
    "            quad = torch.stack([torch.cos(a/2), torch.tensor(0.).cuda(), torch.sin(a/2), torch.tensor(0.).cuda()])\n",
    "            trans = torch.stack([x,z,y])\n",
    "            inputs = torch.cat((quad, trans))\n",
    "            Rt = get_camera_from_tensor(inputs)\n",
    "            Rt = Rt.inverse() @ orig_Rt.inverse().cuda()\n",
    "\n",
    "            \n",
    "            min_loss = 100\n",
    "            min_inputs = inputs.clone()\n",
    "            min_Rt = Rt.clone()\n",
    "            for i in range(NUM_OPT):\n",
    "                quad = torch.stack([torch.cos(a / 2), torch.tensor(0.).cuda(), torch.sin(a / 2), torch.tensor(0.).cuda()])\n",
    "                trans = torch.stack([x, z, y])\n",
    "                inputs = torch.cat((quad, trans))\n",
    "                Rt = get_camera_from_tensor(inputs)\n",
    "                Rt = Rt.inverse() @ orig_Rt.inverse().cuda()\n",
    "                rgb, depth, indices = embedder.sample_generate(w,{\"Rt\": Rt.unsqueeze(0).unsqueeze(1).float(),\n",
    "                                                                'K': K.unsqueeze(0).cuda()},\n",
    "                                                                  out_res=128, num_samples=NUM_SAMPLE_PIXEL)\n",
    "                flattened_rgb_t = rearrange(rgb_t, 'b c h w -> b (h w) c')[0]\n",
    "                rgb_loss = F.l1_loss(rgb[0], flattened_rgb_t[indices])\n",
    "                depth_loss = F.l1_loss(depth/10.0, depth_t.view(rgb_t.shape[0], -1)[:, indices])\n",
    "                loss = rgb_loss + depth_loss\n",
    "                if min_loss > loss:\n",
    "                    min_Rt = Rt.clone()\n",
    "                    min_loss = loss\n",
    "                    min_inputs = inputs.clone()\n",
    "                optim.zero_grad()\n",
    "                loss.backward()\n",
    "                #grad = torch.nn.utils.clip_grad_norm_(Rt, 0.1)\n",
    "                optim.step()  \n",
    "\n",
    "        Rt_t = min_Rt.detach()\n",
    "        world_position = min_inputs[-3:].detach().cpu().numpy()\n",
    "        world_rotation = q.from_float_array(min_inputs[:4].detach().cpu().numpy())\n",
    "        curr_loc = pu.get_sim_location(world_position, world_rotation)\n",
    "    else:\n",
    "        Rt_t = torch.eye(4).to(device)\n",
    "\n",
    "    adjust_locs.append(curr_loc)\n",
    "    gt_locs.append(curr_gt_loc)\n",
    "    bias_locs.append(curr_bias_loc)\n",
    "    \n",
    "    vis_traj = visualize_traj(gt_locs, adjust_locs, bias_locs)\n",
    "    \n",
    "    Rt_t = Rt_t.unsqueeze(0)\n",
    "\n",
    "    with torch.no_grad():\n",
    "        output = embedder.calculate_mask_func(depth_t*10.0, Rt_t, K)\n",
    "        sorted_indices, seq_unique_list, seq_unique_counts, _ = output\n",
    "        input_dict = {'rgb': rgb_t.unsqueeze(1), \n",
    "                      'depth': depth_t.unsqueeze(1), \n",
    "                    'sorted_indices': sorted_indices.unsqueeze(1), \n",
    "                    'seq_unique_counts': seq_unique_counts.unsqueeze(1),\n",
    "                      'seq_unique_list': seq_unique_list.unsqueeze(1)}\n",
    "        w, w_mask = embedder.embed_obs(input_dict, past_w=w, past_w_num_mask=w_mask)\n",
    "    \n",
    "        w_im = w.mean(0).mean(0).detach().cpu().numpy()\n",
    "        w_im = ((w_im - w_im.min())/(w_im.max()-w_im.min()) * 255).astype(np.uint8)\n",
    "        w_im = cv2.applyColorMap(w_im, cv2.COLORMAP_VIRIDIS)[:,:,::-1]\n",
    "    \n",
    "    view_im = np.concatenate([vis_traj, cv2.resize(obs['rgb'], (VIS_RES,VIS_RES)), \n",
    "                                       cv2.resize(w_im, (VIS_RES, VIS_RES))],1)\n",
    "    images.append(view_im)\n",
    "    cv2.imshow(\"View\", view_im[:,:,::-1])\n",
    "    key = cv2.waitKey(1)\n",
    "    if key == ord(\"q\"): break\n",
    "    \n",
    "    # robot action\n",
    "    action = follower.get_next_action(goal_point)\n",
    "    if time_t > MAX_TIME: break\n",
    "    if action is None or action == 0:\n",
    "        while True:\n",
    "            goal_point = sim.sample_navigable_point()\n",
    "            if abs(goal_point[1]-start_position[1]) > 0.5: continue\n",
    "            break\n",
    "        action = follower.get_next_action(goal_point)\n",
    "    sim.step(action)\n",
    "    time_t += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=demo/camera-tracking.gif>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "imageio.mimwrite(\"demo/camera-tracking.gif\", small_images, fps=10)\n",
    "display(HTML('<img src={}>'.format(\"demo/camera-tracking.gif\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "T = len(gt_locs)\n",
    "plt.plot(np.array(gt_locs)[:T,0],np.array(gt_locs)[:T,1], label='gt', color='black')\n",
    "plt.plot(np.array(adjust_locs)[:T,0],np.array(adjust_locs)[:T,1],label='w/ pose_opt', color='red')\n",
    "plt.plot(np.array(bias_locs)[:T,0],np.array(bias_locs)[:T,1], label='w/o pose_opt', color='green')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "rnr",
   "language": "python",
   "name": "rnr"
  },
  "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}