find_markers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Where are my trees?\n",
    "\n",
    "This notebook runs through using `qrDAR` to identify fiducial markers (akin to QR codes) in laser scans. Currently only the AruCo `aruco_mip_16h3` dictionary of codes is compatible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pylab\n",
    "%matplotlib inline\n",
    "import os\n",
    "import glob\n",
    "import pandas as pd\n",
    "\n",
    "import qrdar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example using a single tile\n",
    "This example dataset is from a Malaysian forest plot. The dataset would be too big for a repository, it can be downloaded from <a href=http://www2.geog.ucl.ac.uk/~ucfaptv/qrdar_example.ply>here</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load data\n",
    "pc = qrdar.io.read_ply('example/example.ply')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# and filter bright points (ensure value is high enough to detect only targets)\n",
    "bright = pc[pc.intensity >= 5].copy()\n",
    "\n",
    "# seearch for and label stickers\n",
    "bright = qrdar.search4stickers.find(bright)\n",
    "\n",
    "# filter out large targets (co-registraion markers etc.)\n",
    "bright = qrdar.search4stickers.filterBySize(bright, verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# group stickers into targets\n",
    "bright = qrdar.locateTargets(bright)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# and extract\n",
    "expected_codes = np.arange(100, 105)\n",
    "marker_df = qrdar.readMarker.singleTile(bright, pc, expected_codes=expected_codes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print marker_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example workflow if area is large \n",
    "For example if you have a large forest plot, where the data is tiled"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make a working directory e.g. `qrdar_output` and navigate to it "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "cd /path/for/storing/output\n",
    "mkdir qrdar_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "os.chdir('/path/for/storing/output/qrdar_output')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load point cloud\n",
    "Load point cloud and filter leaving only bright points e.g. for the <i>REIGL VZ-400</i>, points where reflectance >5 db should do. There is a function to load points from a `.pcd` (the output of `mon2pcd` if using a <i>RIEGL / treeseg</i> workflow, download <a href=https://github.com/philwilkes/treeseg/blob/master/src/mon2pcd.cpp>`mon2pcd.cpp`</a>) but any `pd.DataFrame` with `['x', 'y', 'z', 'reflectance']` columns will work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bright = qrdar.io.read_pcd('../saf03_mon.pcd')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Search for potential stickers\n",
    "This step aseearches the point cloud looking for clusters of points that could be stickers (or something else e.g. co-registration targets, reflective strips on bags etc.). Larger objects are then filtered using `filterBySize()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pc = qrdar.search4stickers.find(pc, verbose=True)\n",
    "\n",
    "# as this step can take a while it is a good idea to save the output to read in at a later date.\n",
    "qrdar.io.write_ply('potential_points.ply', pc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# read in previously identified points\n",
    "pc = qrdar.io.read_ply('potential_points.ply')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# filter points by size\n",
    "pc = qrdar.search4stickers.filterBySize(pc, verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Group stickers into potential tree codes\n",
    "Stickers are grouped into potential tree codes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "pc = qrdar.locateTargets(pc, verbose=True)\n",
    "qrdar.io.write_ply('target_centres.ply', pc.groupby('target_labels_').mean().reset_index())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# again these can be written out\n",
    "qrdar.io.write_ply('potential_points_w_targets.ply', pc)\n",
    "\n",
    "# also grouped into targets and saved\n",
    "qrdar.io.write_ply('possible_targets.ply', pc.groupby('target_labels_').mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "pc = qrdar.io.read_ply('potential_points_w_targets.ply')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read codes\n",
    "If codes are spread over a large dataset it is common for that dataset to be tiled therefore you would need a tile index and to run using <code><span style=\"background-color:lightgrey\">readMarkersFromTiles()</span></code> method.\n",
    "\n",
    "This requires a tile index including the tile x and y centre as well as tile number. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "tile_index = pd.read_csv('../tile_index.dat', names=['tile', 'x', 'y'], sep=' ')\n",
    "marker_df = qrdar.readMarker.fromTiles(pc,  \n",
    "                                       tile_index, \n",
    "                                       '../rxp2pcd_i/saf03_{}.pcd',  \n",
    "                                       verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write output to .ply file\n",
    "qrdar.io.write_ply('marker_df.ply', marker_df[['x', 'y', 'z', 'code', 'confidence']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot target location\n",
    "plt.figure(figsize=(8, (marker_df.y.ptp() / marker_df.x.ptp()) * 5))\n",
    "plt.scatter(marker_df.x, marker_df.y, s=5, facecolor='none')\n",
    "[plt.text(row.x, row.y, row.code) for ix, row in marker_df.iterrows() if not np.isnan(row.code)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extract features\n",
    "Once codes have been identified the features they are attachted to can be extracted. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%mkdir clusters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qrdar.extractFeatures(marker_df[marker_df.code >= 0], tile_index, \n",
    "                      '../downsample_p/saf03_{}.downsample.pcd', \n",
    "                      'clusters', verbose=True)"
   ]
  }
 ],
 "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.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}