eval_synthetic.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [],
   "source": [
    "# Copyright (c) 2022, Gonzalo Ferrer, Dmitrii Iarosh, Anastasiia Kornilova\n",
    "#\n",
    "# Licensed under the Apache License, Version 2.0 (the \"License\");\n",
    "# you may not use this file except in compliance with the License.\n",
    "# You may obtain a copy of the License at\n",
    "#\n",
    "# http://www.apache.org/licenses/LICENSE-2.0\n",
    "#\n",
    "# Unless required by applicable law or agreed to in writing, software\n",
    "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
    "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
    "# See the License for the specific language governing permissions and\n",
    "# limitations under the License."
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [],
   "source": [
    "import mrob\n",
    "import numpy as np\n",
    "import os\n",
    "import pandas as pd\n",
    "import open3d as o3d\n",
    "import pickle\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "from tqdm import tqdm"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [],
   "source": [
    "from plane_backends.solver_factory import create_solver_by_name\n",
    "\n",
    "from metrics.ape import ape\n",
    "from metrics.rpe import rpe\n",
    "\n",
    "from perturbation.perturbation import Perturbation, generate_random_pose_shift"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [],
   "source": [
    "def save_generated_data(generated_data, perturbed_poses, folder_name):\n",
    "    os.mkdir(folder_name)\n",
    "    for i, _ in enumerate(perturbed_poses):\n",
    "        points = np.vstack(generated_data.get_point_cloud(i))\n",
    "        pcd = o3d.geometry.PointCloud()\n",
    "        pcd.points = o3d.utility.Vector3dVector(points)\n",
    "        o3d.io.write_point_cloud(os.path.join(folder_name, f'{i}.pcd'), pcd)\n",
    "\n",
    "    gt_poses = [T.T() for T in generated_data.get_trajectory()]\n",
    "    with open(os.path.join(folder_name, 'gt_poses.pkl'), 'wb') as f:\n",
    "        pickle.dump(gt_poses, f)\n",
    "\n",
    "    with open(os.path.join(folder_name, 'pert_poses.pkl'), 'wb') as f:\n",
    "        pickle.dump(perturbed_poses, f)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [],
   "source": [
    "def generated_data_to_observations(generated_data, poses_count):\n",
    "    observations = []\n",
    "    for i in range(poses_count):\n",
    "        observation = {}\n",
    "        points = np.vstack(generated_data.get_point_cloud(i))\n",
    "        labels = generated_data.get_point_plane_ids(i)\n",
    "        for label in np.unique(labels):\n",
    "            point_indices = np.where(labels == label)[0]\n",
    "            observation[label] = points[point_indices]\n",
    "\n",
    "        observations.append(observation)\n",
    "    return observations"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1/1 [00:52<00:00, 52.47s/it]\n",
      "100%|██████████| 1/1 [02:13<00:00, 133.57s/it]\n",
      "100%|██████████| 1/1 [04:06<00:00, 246.04s/it]\n",
      "100%|██████████| 1/1 [05:55<00:00, 355.86s/it]\n",
      "100%|██████████| 1/1 [06:51<00:00, 411.78s/it]\n"
     ]
    }
   ],
   "source": [
    "planes_count_list = [5] # [5, 10, 25, 50, 100]\n",
    "poses_count_list = [5, 10, 25, 50, 75]\n",
    "point_noise_list = [0.005] # [0.005, 0.01, 0.02, 0.04, 0.08]\n",
    "points_count_list = [5] # [5, 10, 25, 50, 100, 200]\n",
    "perturbations = [\n",
    "    Perturbation(rotation_shift=1, translation_shift=0.01),\n",
    "    Perturbation(rotation_shift=5, translation_shift=0.05),\n",
    "    Perturbation(rotation_shift=10, translation_shift=0.1),\n",
    "    Perturbation(rotation_shift=15, translation_shift=0.15),\n",
    "    Perturbation(rotation_shift=20, translation_shift=0.2),\n",
    "]\n",
    "bias_noise = 0.01\n",
    "T0 = mrob.geometry.SE3(np.eye(4))\n",
    "solvers = [\n",
    "    'bareg',\n",
    "    'pi-factor',\n",
    "    'ef-centered',\n",
    "]\n",
    "df_stat = pd.DataFrame()\n",
    "\n",
    "SAMPLES_COUNT = 100\n",
    "\n",
    "ind = 0\n",
    "for perturbation in perturbations:\n",
    "    for points_count in points_count_list:\n",
    "        for point_noise in point_noise_list:\n",
    "            for planes_count in tqdm(planes_count_list):\n",
    "                for poses_count in poses_count_list:\n",
    "                    for sample_index in range(SAMPLES_COUNT):\n",
    "                        # Generate synthetic data\n",
    "                        total_points_count = planes_count * points_count\n",
    "                        generated_data = mrob.registration.CreatePoints(\n",
    "                            total_points_count,\n",
    "                            planes_count,\n",
    "                            poses_count,\n",
    "                            point_noise,\n",
    "                            bias_noise,\n",
    "                            T0\n",
    "                        )\n",
    "                        name = '_'.join(\n",
    "                            [\n",
    "                                str(points_count),\n",
    "                                str(planes_count),\n",
    "                                str(poses_count),\n",
    "                                str(point_noise),\n",
    "                                str(sample_index),\n",
    "                                str(perturbation.rotation_shift),\n",
    "                                str(perturbation.translation_shift)\n",
    "                            ]\n",
    "                        )\n",
    "                        observations = generated_data_to_observations(generated_data, poses_count)\n",
    "                        gt_poses = [T.T() for T in generated_data.get_trajectory()]\n",
    "\n",
    "                        # Apply perturbations\n",
    "                        perturbed_poses = []\n",
    "                        for i, gt_pose in enumerate(gt_poses):\n",
    "                            perturbed_poses.append(\n",
    "                                gt_pose @ generate_random_pose_shift(\n",
    "                                    perturbation.rotation_shift / 180 * np.pi,\n",
    "                                    perturbation.translation_shift\n",
    "                                )\n",
    "                            )\n",
    "\n",
    "                        # save_generated_data(generated_data, perturbed_poses, name)\n",
    "\n",
    "                        # Estimate trajectory with each backend\n",
    "                        initial_trajectory = perturbed_poses\n",
    "                        for solver_name in solvers:\n",
    "                            solver = create_solver_by_name(solver_name, iterations_count=300)\n",
    "                            refined_poses, iterations_used_count, optimization_time = solver.solve(\n",
    "                                observations,\n",
    "                                initial_trajectory\n",
    "                            )\n",
    "                            ape_translation, ape_rotation = ape(gt_poses[:poses_count], refined_poses[:poses_count])\n",
    "                            rpe_translation, rpe_rotation = rpe(gt_poses[:poses_count], refined_poses[:poses_count])\n",
    "                            stat = {\n",
    "                                'sample': sample_index,\n",
    "                                'pose_perturbation': '{}'.format(str(perturbation)),\n",
    "                                'point_noise': point_noise,\n",
    "                                'planes_count': planes_count,\n",
    "                                'poses_count': poses_count,\n",
    "                                'points_count': points_count,\n",
    "                                'time': optimization_time,\n",
    "                                'solver': solver_name,\n",
    "                                'iterations': iterations_used_count,\n",
    "                                'ape_rotation': ape_rotation,\n",
    "                                'rpe_rotation': rpe_rotation,\n",
    "                                'ape_translation': ape_translation,\n",
    "                                'rpe_translation': rpe_translation\n",
    "                            }\n",
    "\n",
    "                            df_stat = pd.concat([df_stat, pd.DataFrame(stat, index=[ind])])\n",
    "                            ind += 1"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 10, 25, 50, 75]\n",
      "[0.07795214 0.10587338 0.12453548 0.13431448 0.15047763]\n",
      "[5, 10, 25, 50, 75]\n",
      "[0.01248174 0.01384102 0.01419566 0.0154653  0.01837304]\n",
      "[5, 10, 25, 50, 75]\n",
      "[0.10144651 0.11953621 0.15279705 0.1662112  0.17449846]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\dimaj\\AppData\\Local\\Temp\\ipykernel_8268\\4065899866.py:2: UserWarning: Boolean Series key will be reindexed to match DataFrame index.\n",
      "  median_stat = df_stat[df_stat['solver'] == solver_name][df_stat['planes_count'] == 5].groupby(\n",
      "C:\\Users\\dimaj\\AppData\\Local\\Temp\\ipykernel_8268\\4065899866.py:2: FutureWarning: The default value of numeric_only in DataFrameGroupBy.median is deprecated. In a future version, numeric_only will default to False. Either specify numeric_only or select only columns which should be valid for the function.\n",
      "  median_stat = df_stat[df_stat['solver'] == solver_name][df_stat['planes_count'] == 5].groupby(\n",
      "C:\\Users\\dimaj\\AppData\\Local\\Temp\\ipykernel_8268\\4065899866.py:2: UserWarning: Boolean Series key will be reindexed to match DataFrame index.\n",
      "  median_stat = df_stat[df_stat['solver'] == solver_name][df_stat['planes_count'] == 5].groupby(\n",
      "C:\\Users\\dimaj\\AppData\\Local\\Temp\\ipykernel_8268\\4065899866.py:2: FutureWarning: The default value of numeric_only in DataFrameGroupBy.median is deprecated. In a future version, numeric_only will default to False. Either specify numeric_only or select only columns which should be valid for the function.\n",
      "  median_stat = df_stat[df_stat['solver'] == solver_name][df_stat['planes_count'] == 5].groupby(\n",
      "C:\\Users\\dimaj\\AppData\\Local\\Temp\\ipykernel_8268\\4065899866.py:2: UserWarning: Boolean Series key will be reindexed to match DataFrame index.\n",
      "  median_stat = df_stat[df_stat['solver'] == solver_name][df_stat['planes_count'] == 5].groupby(\n",
      "C:\\Users\\dimaj\\AppData\\Local\\Temp\\ipykernel_8268\\4065899866.py:2: FutureWarning: The default value of numeric_only in DataFrameGroupBy.median is deprecated. In a future version, numeric_only will default to False. Either specify numeric_only or select only columns which should be valid for the function.\n",
      "  median_stat = df_stat[df_stat['solver'] == solver_name][df_stat['planes_count'] == 5].groupby(\n"
     ]
    },
    {
     "data": {
      "text/plain": "[]"
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for solver_name in solvers:\n",
    "    median_stat = df_stat[df_stat['solver'] == solver_name][df_stat['planes_count'] == 5].groupby(\n",
    "        ['planes_count', 'poses_count', 'points_count']\n",
    "    ).median()\n",
    "    indices = list(median_stat.index)\n",
    "    print(poses_count_list)\n",
    "    print(median_stat['ape_translation'].values)\n",
    "    plt.plot(poses_count_list, median_stat['ape_translation'].values)\n",
    "\n",
    "plt.legend(['BAREG', 'Pi-factor', 'EF-Centered'])\n",
    "plt.semilogy()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}