ImageSets.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ImageSet Extended Examples\n",
    "\n",
    "A large group of images captured using a RedEdge over a central California orchard are available for [download here](https://s3-us-west-2.amazonaws.com/sample.micasense.com/imageprocessing/RedEdgeImageSet.zip).\n",
    "\n",
    "With this set extracted to a working folder, this notebook will load all of the images in the set and provide more usage examples of ImageSet data.\n",
    "\n",
    "## Load a directory of images into an ImageSet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from ipywidgets import FloatProgress, Layout\n",
    "from IPython.display import display\n",
    "import micasense.imageset as imageset\n",
    "import os\n",
    "\n",
    "## This progress widget is used for display of the long-running process\n",
    "f = FloatProgress(min=0, max=1, layout=Layout(width='100%'), description=\"Loading\")\n",
    "display(f)\n",
    "def update_f(val):\n",
    "    if (val - f.value) > 0.005 or val == 1: #reduces cpu usage from updating the progressbar by 10x\n",
    "        f.value=val\n",
    "\n",
    "images_dir = os.path.expanduser(os.path.join('~','Downloads','RedEdgeImageSet','0000SET'))\n",
    "%time imgset = imageset.ImageSet.from_directory(images_dir, progress_callback=update_f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import Capture data into Pandas DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "data, columns = imgset.as_nested_lists()\n",
    "print(\"Columns: {}\".format(columns))\n",
    "df = pd.DataFrame.from_records(data, index='timestamp', columns=columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mapping capture locations using MapboxGL\n",
    "\n",
    "Below we use the `mapboxgl` extension to plot the measured DLS yaw (or heading) angle from each image's meatadata over the whole imageset. We draw circles at each image location, and then color the circle based on the yaw value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "from mapboxgl.viz import *\n",
    "from mapboxgl.utils import df_to_geojson, create_radius_stops, scale_between\n",
    "from mapboxgl.utils import create_color_stops\n",
    "\n",
    "#Insert your mapbox token here\n",
    "token = 'pk.eyJ1IjoibWljYXNlbnNlIiwiYSI6ImNqYWx5dWNteTJ3cWYzMnBicmZid3g2YzcifQ.Zrq9t7GYocBtBzYyT3P4sw'\n",
    "color_stops = create_color_stops(np.linspace(-math.pi,math.pi,num=8),colors='YlOrRd')\n",
    "data = df_to_geojson(df,columns[3:],lat='latitude',lon='longitude')\n",
    "viz = CircleViz(data, access_token=token, color_property='dls-yaw',\n",
    "                color_stops=color_stops,\n",
    "                center=[df['longitude'].median(),df['latitude'].median()], \n",
    "                zoom=16, height='600px',\n",
    "                style='mapbox://styles/mapbox/satellite-streets-v9')\n",
    "viz.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting capture metadata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "ax=df.plot(y=columns[3:], subplots=True, figsize=(16, 10), style=['g','c','y','k','b','g','r','m','k']);\n",
    "for a in ax:\n",
    "    a.legend(loc='right', bbox_to_anchor=(1.1, 0.5), ncol=1, fancybox=True, shadow=True);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Separating ground and flight images\n",
    "\n",
    "We can plot a histogram of the image altitudes for all images in the flight and use the basic statistics to guess at an altitude below which the panel images were likely taken. This can give us an altitude threshold we can apply to separate images taken in flight and on the ground."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot the histogram of the altitude data\n",
    "df.altitude.hist();\n",
    "# find the altitude above which the flight images occur\n",
    "cutoff_altitude = df.altitude.mean()-3.0*df.altitude.std()\n",
    "plt.axvline(x=cutoff_altitude,c='r');\n",
    "plt.xlabel('Capture altitude (m)');\n",
    "plt.ylabel('Number of occurances');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Automatically extracting radiances of panel images\n",
    "Using the Panel class, we can automatically find and compute the radiance of panel regions within panel images. Each Capture object exposes a `panel_radiance()` method which can be used on panel images to get a list of the radiance of each band (in the native RedEdge band order)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "flight = df.altitude>cutoff_altitude\n",
    "ground = ~flight\n",
    "ground_idx = np.arange(len(ground))[ground]\n",
    "flight_idx = np.arange(len(ground))[flight]\n",
    "ground_captures = np.array(imgset.captures)[ground_idx]\n",
    "flight_captures = np.array(imgset.captures)[flight_idx]\n",
    "\n",
    "panel_radiances = []\n",
    "dls_irradiances = []\n",
    "panel_timestamps = []\n",
    "for cap in ground_captures:\n",
    "    if cap.panels_in_all_expected_images():\n",
    "        panel_timestamps.append(cap.utc_time())\n",
    "        panel_radiances.append(cap.panel_radiance())\n",
    "        dls_irradiances.append(cap.dls_irradiance())\n",
    "\n",
    "dls_irradiances = np.asarray(dls_irradiances)\n",
    "panel_radiances = np.asarray(panel_radiances)\n",
    "\n",
    "###\n",
    "panel_reflectance_by_band = [0.67, 0.69, 0.68, 0.61, 0.67] #RedEdge band_index order\n",
    "panel_irradiance = ground_captures[0].panel_irradiance(panel_reflectance_by_band)\n",
    "plt.figure()\n",
    "plt.scatter(ground_captures[0].center_wavelengths(), panel_irradiance);\n",
    "plt.xscale('log')\n",
    "plt.ylabel(\"Irradiance (w/m^2/nm)\");\n",
    "plt.xlabel(\"Wavelength (nm)\");\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting DLS Irradiances\n",
    "Once we have extracted the panel radiances from the ground images, we can convert them to irradiance as we did in tutorial #1 and plot the irradiances over time and extract radiance to reflectance conversion factors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "\n",
    "df[df.altitude>cutoff_altitude].plot(y=columns[8:13], figsize=(14,8))\n",
    "plt.ylabel(\"Irradiance (w/m^2/nm)\");\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "---\n",
    "Copyright (c) 2017-2018 MicaSense, Inc.  For licensing information see the [project git repository](https://github.com/micasense/imageprocessing)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.1"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": false,
   "toc_position": {
    "height": "1238px",
    "left": "0px",
    "right": "1114.56px",
    "top": "111px",
    "width": "383px"
   },
   "toc_section_display": "block",
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "position": {
    "height": "144px",
    "left": "1129px",
    "right": "20px",
    "top": "119px",
    "width": "350px"
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}