generate_data.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_pc_from_bin(bin_path):\n",
    "    obj= np.fromfile(bin_path,dtype=np.float32).reshape(-1,4)\n",
    "    return obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# scale to 255\n",
    "def scale_to_255(a, min,max,dtype=np.uint8):\n",
    "    return (((a-min)/float(max-min))*255).astype(dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def point_cloud_to_panorama(points,\n",
    "                            v_res=0.42,\n",
    "                            h_res = 0.08,\n",
    "                            v_fov = (-24.9, 2.0),\n",
    "                            d_range = (0,100),\n",
    "                            y_fudge=3\n",
    "                            ):\n",
    "    \"\"\" Takes point cloud data as input and creates a 360 degree panoramic\n",
    "        image, returned as a numpy array.\n",
    "    Args:\n",
    "        points: (np array)\n",
    "            The numpy array containing the point cloud. .\n",
    "            The shape should be at least Nx3 (allowing for more columns)\n",
    "            - Where N is the number of points, and\n",
    "            - each point is specified by at least 3 values (x, y, z)\n",
    "        v_res: (float)\n",
    "            vertical angular resolution in degrees. This will influence the\n",
    "            height of the output image.\n",
    "        h_res: (float)\n",
    "            horizontal angular resolution in degrees. This will influence\n",
    "            the width of the output image.\n",
    "        v_fov: (tuple of two floats)\n",
    "            Field of view in degrees (-min_negative_angle, max_positive_angle)\n",
    "        d_range: (tuple of two floats) (default = (0,100))\n",
    "            Used for clipping distance values to be within a min and max range.\n",
    "        y_fudge: (float)\n",
    "            A hacky fudge factor to use if the theoretical calculations of\n",
    "            vertical image height do not match the actual data.\n",
    "    Returns:\n",
    "        A numpy array representing a 360 degree panoramic image of the point\n",
    "        cloud.\n",
    "    \"\"\"\n",
    "    # Projecting to 2D\n",
    "    x_points = points[:, 0]\n",
    "    y_points = points[:, 1]\n",
    "    z_points = points[:, 2]\n",
    "    r_points = points[:, 3]\n",
    "    d_points = np.sqrt(x_points ** 2 + y_points ** 2)  # map distance relative to origin\n",
    "    #d_points = np.sqrt(x_points**2 + y_points**2 + z_points**2) # abs distance\n",
    "\n",
    "    # We use map distance, because otherwise it would not project onto a cylinder,\n",
    "    # instead, it would map onto a segment of slice of a sphere.\n",
    "\n",
    "    # RESOLUTION AND FIELD OF VIEW SETTINGS\n",
    "    v_fov_total = -v_fov[0] + v_fov[1]\n",
    "\n",
    "    # CONVERT TO RADIANS\n",
    "    v_res_rad = v_res * (np.pi / 180)\n",
    "    h_res_rad = h_res * (np.pi / 180)\n",
    "\n",
    "    # MAPPING TO CYLINDER\n",
    "    x_img = np.arctan2(y_points, x_points) / h_res_rad\n",
    "    y_img = -(np.arctan2(z_points, d_points) / v_res_rad)\n",
    "\n",
    "    # THEORETICAL MAX HEIGHT FOR IMAGE\n",
    "    d_plane = (v_fov_total/v_res) / (v_fov_total* (np.pi / 180))\n",
    "    h_below = d_plane * np.tan(-v_fov[0]* (np.pi / 180))\n",
    "    h_above = d_plane * np.tan(v_fov[1] * (np.pi / 180))\n",
    "    y_max = int(np.ceil(h_below+h_above + y_fudge))\n",
    "\n",
    "    # SHIFT COORDINATES TO MAKE 0,0 THE MINIMUM\n",
    "    x_min = -360.0 / h_res / 2\n",
    "    x_img = np.trunc(-x_img - x_min).astype(np.int32)\n",
    "    x_max = int(np.ceil(360.0 / h_res))\n",
    "\n",
    "    y_min = -((v_fov[1] / v_res) + y_fudge)\n",
    "    y_img = np.trunc(y_img - y_min).astype(np.int32)\n",
    "\n",
    "    # CLIP DISTANCES\n",
    "    d_points = np.clip(d_points, a_min=d_range[0], a_max=d_range[1])\n",
    "\n",
    "    # CONVERT TO IMAGE ARRAY\n",
    "    img = np.zeros([y_max + 1, x_max + 1], dtype=np.uint8)\n",
    "    img[y_img, x_img] = scale_to_255(d_points, min=d_range[0], max=d_range[1])\n",
    "\n",
    "    return img\n",
    "\n",
    "def lidar_to_2d_front_view(points,\n",
    "                           v_res,\n",
    "                           h_res,\n",
    "                           v_fov,\n",
    "                           val=\"depth\",\n",
    "                           cmap=\"jet\",\n",
    "                           saveto=None,\n",
    "                           y_fudge=0.0\n",
    "                           ):\n",
    "    \"\"\" Takes points in 3D space from LIDAR data and projects them to a 2D\n",
    "        \"front view\" image, and saves that image.\n",
    "    Args:\n",
    "        points: (np array)\n",
    "            The numpy array containing the lidar points.\n",
    "            The shape should be Nx4\n",
    "            - Where N is the number of points, and\n",
    "            - each point is specified by 4 values (x, y, z, reflectance)\n",
    "        v_res: (float)\n",
    "            vertical resolution of the lidar sensor used.\n",
    "        h_res: (float)\n",
    "            horizontal resolution of the lidar sensor used.\n",
    "        v_fov: (tuple of two floats)\n",
    "            (minimum_negative_angle, max_positive_angle)\n",
    "        val: (str)\n",
    "            What value to use to encode the points that get plotted.\n",
    "            One of {\"depth\", \"height\", \"reflectance\"}\n",
    "        cmap: (str)\n",
    "            Color map to use to color code the `val` values.\n",
    "            NOTE: Must be a value accepted by matplotlib's scatter function\n",
    "            Examples: \"jet\", \"gray\"\n",
    "        saveto: (str or None)\n",
    "            If a string is provided, it saves the image as this filename.\n",
    "            If None, then it just shows the image.\n",
    "        y_fudge: (float)\n",
    "            A hacky fudge factor to use if the theoretical calculations of\n",
    "            vertical range do not match the actual data.\n",
    "            For a Velodyne HDL 64E, set this value to 5.\n",
    "    \"\"\"\n",
    "\n",
    "    # DUMMY PROOFING\n",
    "    assert len(v_fov) ==2, \"v_fov must be list/tuple of length 2\"\n",
    "    assert v_fov[0] <= 0, \"first element in v_fov must be 0 or negative\"\n",
    "    assert val in {\"depth\", \"height\", \"reflectance\"}, \\\n",
    "        'val must be one of {\"depth\", \"height\", \"reflectance\"}'\n",
    "\n",
    "\n",
    "    x_lidar = points[:, 0]\n",
    "    y_lidar = points[:, 1]\n",
    "    z_lidar = points[:, 2]\n",
    "    r_lidar = points[:, 3] # Reflectance\n",
    "    # Distance relative to origin when looked from top\n",
    "    #d_lidar = np.sqrt(x_lidar ** 2 + y_lidar ** 2)\n",
    "    # Absolute distance relative to origin\n",
    "    d_lidar = np.sqrt(x_lidar ** 2 + y_lidar ** 2, z_lidar ** 2)\n",
    "\n",
    "    v_fov_total = -v_fov[0] + v_fov[1]\n",
    "\n",
    "    # Convert to Radians\n",
    "    v_res_rad = v_res * (np.pi/180)\n",
    "    h_res_rad = h_res * (np.pi/180)\n",
    "\n",
    "    # PROJECT INTO IMAGE COORDINATES\n",
    "    x_img = np.arctan2(-y_lidar, x_lidar)/ h_res_rad\n",
    "    y_img = np.arctan2(z_lidar, d_lidar)/ v_res_rad\n",
    "\n",
    "    # SHIFT COORDINATES TO MAKE 0,0 THE MINIMUM\n",
    "    x_min = -360.0 / h_res / 2  # Theoretical min x value based on sensor specs\n",
    "    x_img -= x_min              # Shift\n",
    "    x_max = 360.0 / h_res       # Theoretical max x value after shifting\n",
    "\n",
    "    y_min = v_fov[0] / v_res    # theoretical min y value based on sensor specs\n",
    "    y_img -= y_min              # Shift\n",
    "    y_max = v_fov_total / v_res # Theoretical max x value after shifting\n",
    "\n",
    "    y_max += y_fudge            # Fudge factor if the calculations based on\n",
    "                                # spec sheet do not match the range of\n",
    "                                # angles collected by in the data.\n",
    "    #print x_min,y_min\n",
    "    #print x_max,y_max\n",
    "    # WHAT DATA TO USE TO ENCODE THE VALUE FOR EACH PIXEL\n",
    "    if val == \"reflectance\":\n",
    "        pixel_values = r_lidar\n",
    "    elif val == \"height\":\n",
    "        pixel_values = z_lidar\n",
    "    else:\n",
    "        pixel_values = -d_lidar\n",
    "\n",
    "    # PLOT THE IMAGE\n",
    "    cmap = \"jet\"            # Color map to use\n",
    "    dpi = 100               # Image resolution\n",
    "    fig, ax = plt.subplots(figsize=(x_max/dpi, y_max/dpi), dpi=dpi)\n",
    "    ax.scatter(x_img,y_img, s=1, c=pixel_values, linewidths=0, alpha=1, cmap=cmap)\n",
    "    \n",
    "    ax.set_axis_bgcolor((0, 0, 0)) # Set regions with no points to black\n",
    "    ax.axis('scaled')              # {equal, scaled}\n",
    "    ax.xaxis.set_visible(False)    # Do not draw axis tick marks\n",
    "    ax.yaxis.set_visible(False)    # Do not draw axis tick marks\n",
    "    plt.xlim([0, x_max])   # prevent drawing empty space outside of horizontal FOV\n",
    "    plt.ylim([0, y_max])   # prevent drawing empty space outside of vertical FOV\n",
    "\n",
    "    if saveto is not None:\n",
    "        fig.savefig(saveto, dpi=dpi, bbox_inches='tight', pad_inches=0.0)\n",
    "    else:\n",
    "        fig.show()\n",
    "\n",
    "        \n",
    "def lidar_to_2d_front_view_for_npy(points,\n",
    "                           v_res,\n",
    "                           h_res,\n",
    "                           v_fov,\n",
    "                           val=\"depth\",\n",
    "                           cmap=\"jet\",\n",
    "                           saveto=None,\n",
    "                           y_fudge=0.0\n",
    "                           ):\n",
    "    \"\"\" Takes points in 3D space from LIDAR data and projects them to a 2D\n",
    "        \"front view\" image, and saves that image.\n",
    "    Args:\n",
    "        points: (np array)\n",
    "            The numpy array containing the lidar points.\n",
    "            The shape should be Nx4\n",
    "            - Where N is the number of points, and\n",
    "            - each point is specified by 4 values (x, y, z, reflectance)\n",
    "        v_res: (float)\n",
    "            vertical resolution of the lidar sensor used.\n",
    "        h_res: (float)\n",
    "            horizontal resolution of the lidar sensor used.\n",
    "        v_fov: (tuple of two floats)\n",
    "            (minimum_negative_angle, max_positive_angle)\n",
    "        val: (str)\n",
    "            What value to use to encode the points that get plotted.\n",
    "            One of {\"depth\", \"height\", \"reflectance\"}\n",
    "        cmap: (str)\n",
    "            Color map to use to color code the `val` values.\n",
    "            NOTE: Must be a value accepted by matplotlib's scatter function\n",
    "            Examples: \"jet\", \"gray\"\n",
    "        saveto: (str or None)\n",
    "            If a string is provided, it saves the image as this filename.\n",
    "            If None, then it just shows the image.\n",
    "        y_fudge: (float)\n",
    "            A hacky fudge factor to use if the theoretical calculations of\n",
    "            vertical range do not match the actual data.\n",
    "            For a Velodyne HDL 64E, set this value to 5.\n",
    "    \"\"\"\n",
    "\n",
    "    # DUMMY PROOFING\n",
    "    assert len(v_fov) ==2, \"v_fov must be list/tuple of length 2\"\n",
    "    assert v_fov[0] <= 0, \"first element in v_fov must be 0 or negative\"\n",
    "    assert val in {\"depth\", \"height\", \"reflectance\"}, \\\n",
    "        'val must be one of {\"depth\", \"height\", \"reflectance\"}'\n",
    "\n",
    "\n",
    "    x_lidar = points[:,:,0]\n",
    "    y_lidar = points[:,:,1]\n",
    "    z_lidar = points[:,:,2]\n",
    "    r_lidar = points[:,:,3] # Reflectance\n",
    "    # Distance relative to origin when looked from top\n",
    "    #d_lidar = np.sqrt(x_lidar ** 2 + y_lidar ** 2)\n",
    "    # Absolute distance relative to origin\n",
    "    d_lidar = np.sqrt(x_lidar ** 2 + y_lidar ** 2, z_lidar ** 2)\n",
    "\n",
    "    v_fov_total = -v_fov[0] + v_fov[1]\n",
    "\n",
    "    # Convert to Radians\n",
    "    v_res_rad = v_res * (np.pi/180)\n",
    "    h_res_rad = h_res * (np.pi/180)\n",
    "\n",
    "    # PROJECT INTO IMAGE COORDINATES\n",
    "    x_img = np.arctan2(-y_lidar, x_lidar)/ h_res_rad\n",
    "    y_img = np.arctan2(z_lidar, d_lidar)/ v_res_rad\n",
    "\n",
    "    # SHIFT COORDINATES TO MAKE 0,0 THE MINIMUM\n",
    "    x_min = -360.0 / h_res / 2  # Theoretical min x value based on sensor specs\n",
    "    x_img -= x_min              # Shift\n",
    "    x_max = 360.0 / h_res       # Theoretical max x value after shifting\n",
    "\n",
    "    y_min = v_fov[0] / v_res    # theoretical min y value based on sensor specs\n",
    "    y_img -= y_min              # Shift\n",
    "    y_max = v_fov_total / v_res # Theoretical max x value after shifting\n",
    "\n",
    "    y_max += y_fudge            # Fudge factor if the calculations based on\n",
    "                                # spec sheet do not match the range of\n",
    "                                # angles collected by in the data.\n",
    "    # WHAT DATA TO USE TO ENCODE THE VALUE FOR EACH PIXEL\n",
    "    if val == \"reflectance\":\n",
    "        pixel_values = r_lidar\n",
    "    elif val == \"height\":\n",
    "        pixel_values = z_lidar\n",
    "    else:\n",
    "        pixel_values = -d_lidar\n",
    "\n",
    "    # PLOT THE IMAGE\n",
    "    cmap = \"jet\"            # Color map to use\n",
    "    dpi = 100               # Image resolution\n",
    "    fig, ax = plt.subplots(figsize=(x_max/dpi, y_max/dpi), dpi=dpi)\n",
    "    ax.scatter(x_img,y_img, s=1, c=pixel_values, linewidths=0, alpha=1, cmap=cmap)\n",
    "    \n",
    "    ax.set_axis_bgcolor((0, 0, 0)) # Set regions with no points to black\n",
    "    ax.axis('scaled')              # {equal, scaled}\n",
    "    ax.xaxis.set_visible(False)    # Do not draw axis tick marks\n",
    "    ax.yaxis.set_visible(False)    # Do not draw axis tick marks\n",
    "    plt.xlim([0, x_max])   # prevent drawing empty space outside of horizontal FOV\n",
    "    plt.ylim([0, y_max])   # prevent drawing empty space outside of vertical FOV\n",
    "\n",
    "    if saveto is not None:\n",
    "        fig.savefig(saveto, dpi=dpi, bbox_inches='tight', pad_inches=0.0)\n",
    "    else:\n",
    "        fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#record = np.load('data/Mems/004004.npy').astype(np.float32,copy=False)\n",
    "record = np.load('data/lidar_2d/2011_09_26_0001_0000000054.npy').astype(np.float32,copy=False)\n",
    "#lidar=record[:,:,:4]\n",
    "record = record.reshape((64,512,6))\n",
    "lidar=record[:,:,:4]\n",
    "\n",
    "# print record.shape\n",
    "# print lidar[:,:,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f3ed3224190>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "plt.imshow(record[:,:,0:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "Missing parentheses in call to 'print' (<ipython-input-10-0897369d8e87>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-10-0897369d8e87>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m    print a[0:25,300:325]\u001b[0m\n\u001b[0m          ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m Missing parentheses in call to 'print'\n"
     ]
    }
   ],
   "source": [
    "plt.imshow(record[:,:,5])\n",
    "a=record[:,:,5]\n",
    "print a[0:25,300:325]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "record = np.load('data/Mems/2011_09_26_drive_0001_sync/0000000002.npy').astype(np.float32,copy=False)\n",
    "\n",
    "plt.imshow(record[:,:,5])\n",
    "print a[0:25,300:325]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(record[:,:,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "root = lidar[:,:,0]\n",
    "root = root.reshape(-1,1)\n",
    "for i in range(lidar.shape[2]-1):\n",
    "    \n",
    "    tran = lidar[:,:,i+1]\n",
    "    tran = tran.reshape(-1,1)\n",
    "    buffe_ =tran\n",
    "    root = np.hstack((root,buffe_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print root.shape\n",
    "print root[:,0]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "HRES = 0.35        # horizontal resolution (assuming 20Hz setting)\n",
    "VRES = 0.4       # vertical res\n",
    "VFOV = (-24,9) # Field of view (-ve, +ve) along vertical axis\n",
    "Y_FUDGE = 4  \n",
    "img=point_cloud_to_panorama(root, v_res=VRES, h_res=HRES, v_fov=VFOV,\n",
    "                       y_fudge=Y_FUDGE)\n",
    "\n",
    "plt.imshow(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "record = np.fromfile('0000000003.bin',dtype=np.float32).reshape(-1,4)\n",
    "print record.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "HRES = 0.35         # horizontal resolution (assuming 20Hz setting)\n",
    "VRES = 0.4          # vertical res\n",
    "VFOV = (-24.9, 2.0) # Field of view (-ve, +ve) along vertical axis\n",
    "Y_FUDGE = 5  \n",
    "lidar_to_2d_front_view(record, v_res=VRES, h_res=HRES, v_fov=VFOV,\n",
    "                       val=\"depth\", saveto=None,\n",
    "                       y_fudge=Y_FUDGE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}