Demo2-RPLidar.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LIDAR Scanner Control and Data Visualization in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Demo 2**  \n",
    "\n",
    "This program will collect LIDAR measurements and servo positions from Arduino microcontrollers conencted to serial ports and create an interactive point cloud visualization using PyVista. Users can either run a scan or import data from a CSV file.   \n",
    "\n",
    "Out-of-the box data collection requires a [Slamtec RPLIDAR A1](https://www.adafruit.com/product/4010) module attached to a tilt mount, but data can be imported form prior scans by skipping to Step 2b below after importing packages (Step 1). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Import packages and get serial port info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import pandas as pd\n",
    "from rplidar import RPLidar\n",
    "import serial\n",
    "import serial.tools.list_ports\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "from pathlib import Path \n",
    "import os\n",
    "import numpy as np\n",
    "import pyvista as pv\n",
    "from pyvistaqt import BackgroundPlotter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get serial port info\n",
    "Use pyserial to list serial port details. These will be used to listen for data printed to the serial monitor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cu.Bluetooth-Incoming-Port\n",
      "n/a\n",
      "n/a\n",
      "None\n",
      "None\n",
      "None\n",
      "None\n",
      "None\n",
      "None\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# Show ports\n",
    "ports = list(serial.tools.list_ports.comports())\n",
    "for item in ports:\n",
    "    print( item.name )\n",
    "    print( item.description )\n",
    "    print( item.hwid )\n",
    "    print( item.vid )\n",
    "    print( item.pid )\n",
    "    print( item.serial_number )\n",
    "    print( item.location )\n",
    "    print( item.manufacturer )\n",
    "    print( item.product )\n",
    "    print( item.interface )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2a. Run scan \n",
    "Collect data from two serial ports. Only works with device attached.     \n",
    "Skip if importing data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declare ports\n",
    "PORT_1 = '/dev/cu.usbserial-0001'  # Lidar\n",
    "PORT_2 = serial.Serial('/dev/cu.usbserial-110', 1200)  # Servos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Funcitons for starting and stopping lidar module\n",
    "lidar = RPLidar(PORT_1)\n",
    "def startLidar():\n",
    "    print('Scanning...')\n",
    "    lidar.start_motor()\n",
    "\n",
    "def stopLidar():\n",
    "    print('Stoping...')\n",
    "    lidar.stop_motor()\n",
    "    print('Stopped.')\n",
    "        \n",
    "data = []\n",
    "def run_scan():\n",
    "    \n",
    "    for measurment in lidar.iter_measures():\n",
    "        row = []\n",
    "        line = '\\t'.join(str(v) for v in measurment)\n",
    "        cc = str(PORT_2.readline())\n",
    "    \n",
    "        row.append(line)\n",
    "        row.append(cc) \n",
    "        # print(row)\n",
    "        # data.append(row)\n",
    "\n",
    "        if re.search(\"000\", cc):\n",
    "            break\n",
    "        else:\n",
    "            data.append(row)\n",
    "            print(row)\n",
    "\n",
    "# Run scan\n",
    "startLidar()\n",
    "run_scan()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2b. Import data\n",
    "Skip if collecting data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>False\\t15\\t105.703125\\t0.0</td>\n",
       "      <td>b'0\\r\\n'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>False\\t15\\t107.0\\t1372.75</td>\n",
       "      <td>b'0\\r\\n'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>False\\t15\\t108.34375\\t1389.0</td>\n",
       "      <td>b'0\\r\\n'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>False\\t15\\t109.671875\\t1403.75</td>\n",
       "      <td>b'0\\r\\n'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>False\\t15\\t110.984375\\t1420.75</td>\n",
       "      <td>b'0\\r\\n'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1271</th>\n",
       "      <td>False\\t15\\t7.171875\\t0.0</td>\n",
       "      <td>b'178\\r\\n'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1272</th>\n",
       "      <td>False\\t15\\t8.5\\t2781.0</td>\n",
       "      <td>b'178\\r\\n'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1273</th>\n",
       "      <td>False\\t15\\t9.78125\\t0.0</td>\n",
       "      <td>b'178\\r\\n'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1274</th>\n",
       "      <td>False\\t15\\t11.140625\\t0.0</td>\n",
       "      <td>b'178\\r\\n'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1275</th>\n",
       "      <td>False\\t15\\t12.46875\\t2805.0</td>\n",
       "      <td>b'178\\r\\n'</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1276 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                   0           1\n",
       "0         False\\t15\\t105.703125\\t0.0    b'0\\r\\n'\n",
       "1          False\\t15\\t107.0\\t1372.75    b'0\\r\\n'\n",
       "2       False\\t15\\t108.34375\\t1389.0    b'0\\r\\n'\n",
       "3     False\\t15\\t109.671875\\t1403.75    b'0\\r\\n'\n",
       "4     False\\t15\\t110.984375\\t1420.75    b'0\\r\\n'\n",
       "...                              ...         ...\n",
       "1271        False\\t15\\t7.171875\\t0.0  b'178\\r\\n'\n",
       "1272          False\\t15\\t8.5\\t2781.0  b'178\\r\\n'\n",
       "1273         False\\t15\\t9.78125\\t0.0  b'178\\r\\n'\n",
       "1274       False\\t15\\t11.140625\\t0.0  b'178\\r\\n'\n",
       "1275     False\\t15\\t12.46875\\t2805.0  b'178\\r\\n'\n",
       "\n",
       "[1276 rows x 2 columns]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# # Import data\n",
    "data = pd.read_csv('./data-exports/raw-sensor-data-office.csv')\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convert Cartesian coordinates to spherical coordinates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "r = radius   \n",
    "θ (theta) = inclination (pitch angle)  \n",
    "φ (phi) = azimuth (yaw angle)\n",
    "\n",
    "x = rsinθ cosφ  \n",
    "y = rsinθ sinφ   \n",
    "z = rcosθ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>False\\t15\\t107.0\\t1372.75</td>\n",
       "      <td>b'0\\r\\n'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>False\\t15\\t108.34375\\t1389.0</td>\n",
       "      <td>b'0\\r\\n'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>False\\t15\\t109.671875\\t1403.75</td>\n",
       "      <td>b'0\\r\\n'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>False\\t15\\t110.984375\\t1420.75</td>\n",
       "      <td>b'0\\r\\n'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>False\\t15\\t112.28125\\t1437.5</td>\n",
       "      <td>b'0\\r\\n'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1270</th>\n",
       "      <td>False\\t15\\t5.84375\\t2661.75</td>\n",
       "      <td>b'178\\r\\n'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1271</th>\n",
       "      <td>False\\t15\\t7.171875\\t0.0</td>\n",
       "      <td>b'178\\r\\n'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1272</th>\n",
       "      <td>False\\t15\\t8.5\\t2781.0</td>\n",
       "      <td>b'178\\r\\n'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1273</th>\n",
       "      <td>False\\t15\\t9.78125\\t0.0</td>\n",
       "      <td>b'178\\r\\n'</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1274</th>\n",
       "      <td>False\\t15\\t11.140625\\t0.0</td>\n",
       "      <td>b'178\\r\\n'</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1274 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                   0           1\n",
       "1          False\\t15\\t107.0\\t1372.75    b'0\\r\\n'\n",
       "2       False\\t15\\t108.34375\\t1389.0    b'0\\r\\n'\n",
       "3     False\\t15\\t109.671875\\t1403.75    b'0\\r\\n'\n",
       "4     False\\t15\\t110.984375\\t1420.75    b'0\\r\\n'\n",
       "5       False\\t15\\t112.28125\\t1437.5    b'0\\r\\n'\n",
       "...                              ...         ...\n",
       "1270     False\\t15\\t5.84375\\t2661.75  b'178\\r\\n'\n",
       "1271        False\\t15\\t7.171875\\t0.0  b'178\\r\\n'\n",
       "1272          False\\t15\\t8.5\\t2781.0  b'178\\r\\n'\n",
       "1273         False\\t15\\t9.78125\\t0.0  b'178\\r\\n'\n",
       "1274       False\\t15\\t11.140625\\t0.0  b'178\\r\\n'\n",
       "\n",
       "[1274 rows x 2 columns]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get spherical coordinates\n",
    "def make_spherical(xpos, ypos, distance):\n",
    "    # Variables\n",
    "    # xpos = servo yaw angle between 0 and 180\n",
    "    # ypos = lidar pitch angle between 0 and 360\n",
    "    # distance = lidar distance reading\n",
    "    pi = math.pi\n",
    "\n",
    "    theta = float((xpos * pi) / 180)  # pan servo\n",
    "    phi = float((ypos * pi) / 180)  # tilt servo\n",
    "\n",
    "    z = distance * math.cos(phi)\n",
    "    x = z * math.cos(phi) * math.cos(theta)\n",
    "    y = z * math.cos(phi) * math.sin(theta)\n",
    "    \n",
    "    return [x, y, z]\n",
    "\n",
    "# Make df from data\n",
    "df = pd.DataFrame(data)\n",
    "df = df.drop([0])\n",
    "\n",
    "for index, row in df.iterrows():\n",
    "    if re.search(\"^b\", row[0]):\n",
    "        move = row[0]\n",
    "        row[0] = row[1]\n",
    "        row[1] = move\n",
    "\n",
    "last_row = len(df)\n",
    "df = df.drop([last_row])\n",
    "df\n",
    "\n",
    "# Get angle and distance\n",
    "new_data = []\n",
    "tilt = df[1]  # change index to \"1\" (str) if importing data \n",
    "\n",
    "for index, row in df.iterrows():\n",
    "    # print(row[0], row[1])\n",
    "    new_row = []\n",
    "\n",
    "    measurement = re.split(\"\\t\", row[0])\n",
    "\n",
    "    distance = float(measurement[3])\n",
    "    new_row.append(distance)\n",
    "\n",
    "    angle = float(measurement[2])\n",
    "    new_row.append(angle)\n",
    "    \n",
    "    tilt = re.search(\"\\d{1,3}\", row[1])\n",
    "    if tilt:\n",
    "        number = float(tilt.group(0))\n",
    "        new_row.append(number)\n",
    "    \n",
    "    spherical_data = make_spherical(new_row[0], new_row[1], new_row[2])\n",
    "    new_row = spherical_data\n",
    "\n",
    "    new_data.append(new_row)\n",
    "\n",
    "    # new_row = make_spherical(angle, tilt, distance)\n",
    "    # newdata.append(make_spherical(angle, tilt, distance))\n",
    "\n",
    "point_cloud_data = pd.DataFrame(new_data)\n",
    "point_cloud_data = point_cloud_data.rename(columns={0: \"x\", 1: \"y\", 2: \"z\"})\n",
    "point_cloud_data\n",
    "\n",
    "# Convert data for PyVista\n",
    "points = point_cloud_data.to_numpy()\n",
    "points\n",
    "\n",
    "# Create point cloud\n",
    "point_cloud = pv.PolyData(points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export data  \n",
    "Skip if not exporting data. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uncomment and run if exporting data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Handle directory\n",
    "# os.makedirs('./data-exports', exist_ok=True) \n",
    "\n",
    "# # Export raw sensor data\n",
    "# df.to_csv('./data-exports/raw-sensor-data.csv', index=False)  \n",
    "\n",
    "# # Export spherical data\n",
    "# point_cloud_data.to_csv('./data-exports/spherical-data.csv', index=False)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Create PyVista plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Basic plot\n",
    "Render a point cloud plot in the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jamescole/anaconda3/lib/python3.11/site-packages/pyvista/jupyter/notebook.py:33: UserWarning: Failed to use notebook backend: \n",
      "\n",
      "No module named 'trame'\n",
      "\n",
      "Falling back to a static output.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "image/jpeg": "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",
      "image/png": "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",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=400x400>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Set plot theme styles\n",
    "pv.global_theme.background = 'black'\n",
    "pv.global_theme.font.color = 'grey'\n",
    "\n",
    "# Basic plot\n",
    "pl = pv.Plotter()\n",
    "pl.add_mesh(point_cloud, \n",
    "            render_points_as_spheres = True,\n",
    "            scalars = points[:, 2],\n",
    "            point_size = 2,\n",
    "            show_scalar_bar = False,\n",
    "            )\n",
    "camera = pv.Camera()\n",
    "pl.camera = camera\n",
    "pl.camera_position = 'yz'\n",
    "pl.window_size = [400, 400]\n",
    "pl.camera.azimuth = 45\n",
    "pl.add_axes()\n",
    "pl.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Interactive 3D plot\n",
    "Render point cloud in new window. User can navigate around the point cloud. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Actor (0x15fd6e200)\n",
       "  Center:                     (10.27605553879458, 0.03346775364668986, 11.469525816649934)\n",
       "  Pickable:                   True\n",
       "  Position:                   (0.0, 0.0, 0.0)\n",
       "  Scale:                      (1.0, 1.0, 1.0)\n",
       "  Visible:                    True\n",
       "  X Bounds                    -1.574E+02, 1.780E+02\n",
       "  Y Bounds                    -1.720E+02, 1.720E+02\n",
       "  Z Bounds                    -1.551E+02, 1.780E+02\n",
       "  User matrix:                Unset\n",
       "  Has mapper:                 True\n",
       "\n",
       "Property (0x15fdeebc0)\n",
       "  Ambient:                     0.0\n",
       "  Ambient color:               Color(name='lightblue', hex='#add8e6ff', opacity=255)\n",
       "  Anisotropy:                  0.0\n",
       "  Color:                       Color(name='lightblue', hex='#add8e6ff', opacity=255)\n",
       "  Culling:                     \"none\"\n",
       "  Diffuse:                     1.0\n",
       "  Diffuse color:               Color(name='lightblue', hex='#add8e6ff', opacity=255)\n",
       "  Edge color:                  Color(name='black', hex='#000000ff', opacity=255)\n",
       "  Interpolation:               InterpolationType.FLAT\n",
       "  Lighting:                    True\n",
       "  Line width:                  1.0\n",
       "  Metallic:                    0.0\n",
       "  Opacity:                     1.0\n",
       "  Point size:                  3.0\n",
       "  Render lines as tubes:       False\n",
       "  Render points as spheres:    False\n",
       "  Roughness:                   0.5\n",
       "  Show edges:                  False\n",
       "  Specular:                    0.0\n",
       "  Specular color:              Color(name='lightblue', hex='#add8e6ff', opacity=255)\n",
       "  Specular power:              100.0\n",
       "  Style:                       \"Surface\"\n",
       "\n",
       "DataSetMapper (0x15fd6ef80)\n",
       "  Scalar visibility:           True\n",
       "  Scalar range:                (0.0, 1.0)\n",
       "  Interpolate before mapping:  True\n",
       "  Scalar map mode:             point\n",
       "  Color mode:                  direct\n",
       "\n",
       "Attached dataset:\n",
       "PolyData (0x15fdc66e0)\n",
       "  N Cells:    1274\n",
       "  N Points:   1274\n",
       "  N Strips:   0\n",
       "  X Bounds:   -1.574e+02, 1.780e+02\n",
       "  Y Bounds:   -1.720e+02, 1.720e+02\n",
       "  Z Bounds:   -1.551e+02, 1.780e+02\n",
       "  N Arrays:   1"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rgba = points - points.min(axis=0)\n",
    "rgba /= rgba.max(axis=0)\n",
    "# pv.plot(points, scalars=rgba, render_points_as_spheres=True, point_size=10, cpos='xy', rgba=True)\n",
    "\n",
    "plotter = BackgroundPlotter()\n",
    "plotter.add_mesh(point_cloud, scalars=rgba, rgba=True, point_size=3)\n",
    "\n",
    "# plotter.add_floor()\n",
    "# plotter.add_axes()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}