updated voila demo with new ipyleaflet support

Author: jpswinski

examples/voila_demo.ipynb

@@ -76,6 +76,9 @@
     "import numpy as np\n",
     "import matplotlib.lines\n",
     "import matplotlib.pyplot as plt\n",
+    "# autoreload\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
     "%matplotlib inline"
    ]
   },
@@ -124,6 +127,7 @@
     "results = []\n",
     "SRwidgets = ipysliderule.widgets()\n",
     "points_dropdown = None\n",
+    "update_button = widgets.Button(description=\"Update Map\")\n",
     "run_button = widgets.Button(description=\"Run SlideRule!\")\n",
     "run_output = widgets.Output()\n",
     "refresh_button = widgets.Button(description=\"Refresh Plot\")\n",
@@ -151,11 +155,49 @@
    "outputs": [],
    "source": [
     "# create ipyleaflet map in specified projection\n",
-    "m = ipysliderule.leaflet('Global', layer_control=False)\n",
+    "m = ipysliderule.leaflet(SRwidgets.projection.value)\n",
+    "# install click handler callback\n",
+    "m.add_selected_callback(SRwidgets.atl06_click_handler)\n",
     "display(m.map)\n",
     "display(run_output)"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "extensions": {
+     "jupyter_dashboards": {
+      "version": 1,
+      "views": {
+       "default_view": {
+        "hidden": true
+       }
+      }
+     }
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# update map\n",
+    "def on_update_clicked(b):\n",
+    "    m.add_layer(\n",
+    "        layers=SRwidgets.layers.value,\n",
+    "        rendering_rule=SRwidgets.rendering_rule\n",
+    "    )\n",
+    "    \n",
+    "# map widgets\n",
+    "display(widgets.VBox([\n",
+    "    SRwidgets.projection,\n",
+    "    SRwidgets.layers,\n",
+    "    SRwidgets.raster_functions\n",
+    "]))\n",
+    "\n",
+    "# update button\n",
+    "update_button.on_click(on_update_clicked)\n",
+    "display(update_button)"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -251,14 +293,14 @@
     "def on_refresh_clicked(b):\n",
     "    global atl06_rsps\n",
     "    with refresh_output:\n",
-    "        if atl06_rsps.shape[0] > 0:\n",
+    "        if atl06_rsps and atl06_rsps.shape[0] > 0:\n",
     "            max_plot_points = 10000\n",
     "            if points_dropdown.value == \"100K\":\n",
     "                max_plot_points = 100000\n",
     "            elif points_dropdown.value == \"unlimited\":\n",
     "                max_plot_points = 1000000000\n",
     "            m.GeoData(atl06_rsps, column_name=SRwidgets.variable.value, cmap=SRwidgets.colormap, max_plot_points=max_plot_points)\n",
-    "        \n",
+    "\n",
     "# link buttons\n",
     "run_button.on_click(on_run_clicked)\n",
     "refresh_button.on_click(on_refresh_clicked)"
@@ -316,7 +358,7 @@
     "    SRwidgets.variable,\n",
     "    SRwidgets.cmap,\n",
     "    points_dropdown,\n",
-    "    SRwidgets.reverse\n",
+    "    SRwidgets.reverse,\n",
     "]))\n",
     "\n",
     "# display buttons\n",
@@ -518,6 +560,13 @@
     "display(pc_button)\n",
     "display(pc_output)"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {

sliderule/icesat2.py

@@ -303,21 +303,7 @@ def __get_values(data, dtype, size):
     """
 
     raw = bytes(data)
-    datatype = {
-        "INT8":     numpy.int8,
-        "INT16":    numpy.int16,
-        "INT32":    numpy.int32,
-        "INT64":    numpy.int64,
-        "UINT8":    numpy.uint8,
-        "UINT16":   numpy.uint16,
-        "UINT32":   numpy.uint32,
-        "UINT64":   numpy.uint64,
-        "BITFIELD": numpy.byte, # unsupported
-        "FLOAT":    numpy.single,
-        "DOUBLE":   numpy.double,
-        "TIME8":    numpy.byte,
-        "STRING":   numpy.byte
-    }[sliderule.codedtype2str[dtype]]
+    datatype = sliderule.basictypes[sliderule.codedtype2str[dtype]]["nptype"]
     num_elements = int(size / numpy.dtype(datatype).itemsize)
     slicesize = num_elements * numpy.dtype(datatype).itemsize # truncates partial bytes
     values = numpy.frombuffer(raw[:slicesize], dtype=datatype, count=num_elements)

sliderule/sliderule.py

@@ -36,6 +36,7 @@
 import time
 import logging
 from datetime import datetime, timedelta
+import numpy
 
 ###############################################################################
 # GLOBALS
@@ -83,19 +84,19 @@
 }
 
 basictypes = {
-    "INT8":     { "fmt": 'b', "size": 1 },
-    "INT16":    { "fmt": 'h', "size": 2 },
-    "INT32":    { "fmt": 'i', "size": 4 },
-    "INT64":    { "fmt": 'q', "size": 8 },
-    "UINT8":    { "fmt": 'B', "size": 1 },
-    "UINT16":   { "fmt": 'H', "size": 2 },
-    "UINT32":   { "fmt": 'I', "size": 4 },
-    "UINT64":   { "fmt": 'Q', "size": 8 },
-    "BITFIELD": { "fmt": 'x', "size": 0 },  # unsupported
-    "FLOAT":    { "fmt": 'f', "size": 4 },
-    "DOUBLE":   { "fmt": 'd', "size": 8 },
-    "TIME8":    { "fmt": 'Q', "size": 8 },
-    "STRING":   { "fmt": 's', "size": 1 }
+    "INT8":     { "fmt": 'b', "size": 1, "nptype": numpy.int8   },
+    "INT16":    { "fmt": 'h', "size": 2, "nptype": numpy.int16  },
+    "INT32":    { "fmt": 'i', "size": 4, "nptype": numpy.int32  },
+    "INT64":    { "fmt": 'q', "size": 8, "nptype": numpy.int64  },
+    "UINT8":    { "fmt": 'B', "size": 1, "nptype": numpy.uint8  },
+    "UINT16":   { "fmt": 'H', "size": 2, "nptype": numpy.uint16 },
+    "UINT32":   { "fmt": 'I', "size": 4, "nptype": numpy.uint32 },
+    "UINT64":   { "fmt": 'Q', "size": 8, "nptype": numpy.uint64 },
+    "BITFIELD": { "fmt": 'x', "size": 0, "nptype": numpy.byte   },  # unsupported
+    "FLOAT":    { "fmt": 'f', "size": 4, "nptype": numpy.single },
+    "DOUBLE":   { "fmt": 'd', "size": 8, "nptype": numpy.double },
+    "TIME8":    { "fmt": 'Q', "size": 8, "nptype": numpy.byte   },
+    "STRING":   { "fmt": 's', "size": 1, "nptype": numpy.byte   }
 }
 
 codedtype2str = {