update

Dockerfile

@@ -9,7 +9,7 @@ RUN python3 -m pip install --no-cache-dir --upgrade -r /code/requirements.txt
 COPY . .
 RUN python3 download_datasets.py
 
-CMD ["panel", "serve", "/code/app.py", "--address", "0.0.0.0", "--port", "7860",  "--allow-websocket-origin", "*", "--num-procs", "4", "--index", "app"]
+CMD ["panel", "serve", "/code/app.py", "--address", "0.0.0.0", "--port", "7860",  "--allow-websocket-origin", "*", "--num-procs", "4", "--index", "app", "--reuse-sessions"]
 
 RUN chmod 777 data
 

app.py

@@ -1,6 +1,7 @@
 import dask.dataframe as dd
 import holoviews as hv
 import numpy as np
+import pandas as pd
 import panel as pn
 import param
 from holoviews.operation.datashader import dynspread, rasterize
@@ -10,10 +11,13 @@ from utils import (
     DATASHADER_LOGO,
     DATASHADER_URL,
     DESCRIPTION,
+    ESA_EASTING,
+    ESA_NORTHING,
     MAJOR_TOM_LOGO,
     MAJOR_TOM_LYRICS,
     MAJOR_TOM_PICTURE,
     MAJOR_TOM_REF_URL,
+    META_DATA_COLUMNS,
     PANEL_LOGO,
     PANEL_URL,
     get_closest_rows,
@@ -52,8 +56,11 @@ class MapInput(pn.viewable.Viewer):
     updating = param.Boolean()
 
     def __panel__(self):
-        return pn.pane.HoloViews(
-            self._plot, height=550, width=800, loading=self.param.updating
+        return pn.Column(
+            pn.pane.HoloViews(
+                self._plot, height=550, width=800, loading=self.param.updating
+            ),
+            self._description,
         )
 
     @param.depends("data", watch=True, on_init=True)
@@ -64,10 +71,8 @@ class MapInput(pn.viewable.Viewer):
                 data_dask, kdims=["centre_easting", "centre_northing"], vdims=[]
             )
 
-            mean_easting = np.mean(points.range("centre_easting"))
-            mean_northing = np.mean(points.range("centre_northing"))
             rangexy = hv.streams.RangeXY(source=points)
-            tap = hv.streams.Tap(source=points, x=mean_easting, y=mean_northing)
+            tap = hv.streams.Tap(source=points, x=ESA_EASTING, y=ESA_NORTHING)
 
             agg = rasterize(
                 points, link_inputs=True, x_sampling=0.0001, y_sampling=0.0001
@@ -75,13 +80,13 @@ class MapInput(pn.viewable.Viewer):
             dyn = dynspread(agg)
             dyn.opts(cmap="kr_r", colorbar=True)
 
-            pointerx = hv.streams.PointerX(x=mean_easting, source=points)
-            pointery = hv.streams.PointerY(y=mean_northing, source=points)
+            pointerx = hv.streams.PointerX(x=ESA_EASTING, source=points)
+            pointery = hv.streams.PointerY(y=ESA_NORTHING, source=points)
             vline = hv.DynamicMap(lambda x: hv.VLine(x), streams=[pointerx])
             hline = hv.DynamicMap(lambda y: hv.HLine(y), streams=[pointery])
             tiles = hv.Tiles(
                 "https://tile.openstreetmap.org/{Z}/{X}/{Y}.png", name="OSM"
-            ).opts(width=600, height=550, xlabel="Longitude", ylabel="Latitude")
+            ).opts(xlabel="Longitude", ylabel="Latitude")
 
             self.param.update(
                 _plot=tiles * agg * dyn * hline * vline,
@@ -106,7 +111,7 @@ class MapInput(pn.viewable.Viewer):
 
     def _update_data_in_view(self, x_range, y_range):
         if not x_range or not y_range:
-            self.data_in_view = self.data.head(0)
+            self.data_in_view = self.data
             return
 
         data = self.data
@@ -114,16 +119,24 @@ class MapInput(pn.viewable.Viewer):
             (data.centre_easting.between(*x_range))
             & (data.centre_northing.between(*y_range))
         ]
-        self.data_in_view = data.head(10).reset_index(drop=True)
+        self.data_in_view = data.reset_index(drop=True)
 
     def _update_data_selected(self, tap_x, tap_y):
         self.data_selected = get_closest_rows(self.data, tap_x, tap_y)
 
+    @pn.depends("data_in_view")
+    def _description(self):
+        return f"Rows: {len(self.data_in_view):,}"
+
 
 class ImageInput(pn.viewable.Viewer):
     data = param.DataFrame(allow_refs=True, allow_None=False)
-
+    column_name = param.Selector(
+        default="Thumbnail", objects=list(META_DATA_COLUMNS), label="Image Type"
+    )
     updating = param.Boolean()
+
+    meta_data = param.DataFrame()
     image = param.Parameter()
     plot = param.Parameter()
 
@@ -131,12 +144,19 @@ class ImageInput(pn.viewable.Viewer):
 
     def __panel__(self):
         return pn.Column(
-            pn.widgets.RadioButtonGroup.from_param(
-                self.param._timestamp, button_style="outline"
+            pn.Row(
+                pn.widgets.RadioButtonGroup.from_param(
+                    self.param._timestamp,
+                    button_style="outline",
+                    align="end",
+                ),
+                pn.widgets.Select.from_param(
+                    self.param.column_name, disabled=self.param.updating
+                ),
             ),
             pn.Tabs(
                 pn.pane.HoloViews(
-                    hv.DynamicMap(pn.bind(lambda plot: plot, self.param.plot)),
+                    self.param.plot,
                     loading=self.param.updating,
                     height=800,
                     width=800,
@@ -148,6 +168,13 @@ class ImageInput(pn.viewable.Viewer):
                     loading=self.param.updating,
                     width=800,
                 ),
+                pn.widgets.Tabulator(
+                    self.param.meta_data,
+                    name="Meta Data",
+                    loading=self.param.updating,
+                    disabled=True,
+                ),
+                pn.pane.Markdown(self.code, name="Code"),
                 dynamic=True,
             ),
         )
@@ -167,16 +194,69 @@ class ImageInput(pn.viewable.Viewer):
         if not self._timestamp in options:
             self._timestamp = default_value
 
-    @pn.depends("_timestamp", watch=True, on_init=True)
-    def tap_image(self):
+    @property
+    def column(self):
+        return META_DATA_COLUMNS[self.column_name]
+
+    @pn.depends("_timestamp", "column_name", watch=True, on_init=True)
+    def _update_plot(self):
         if self.data.empty or not self._timestamp:
-            self.image = hv.RGB(np.array([]))
+            self.meta_data = self.data.T
+            self.image = None
+            self.plot = hv.RGB(np.array([]))
         else:
             with self.param.update(updating=True):
                 row = self.data[self.data.timestamp == self._timestamp].iloc[0]
-                self.image = image = pn.cache(get_image)(row)
+                self.meta_data = pd.DataFrame(row)
+                self.image = image = pn.cache(get_image)(row, self.column)
                 image_array = np.array(image)
-                self.plot = hv.RGB(image_array).opts(xaxis=None, yaxis=None)
+                if image_array.ndim == 2:
+                    self.plot = hv.Image(image_array).opts(
+                        cmap="gray_r", xaxis=None, yaxis=None, colorbar=True
+                    )
+                else:
+                    self.plot = hv.RGB(image_array).opts(xaxis=None, yaxis=None)
+
+    @pn.depends("meta_data", "column_name")
+    def code(self):
+        if self.meta_data.empty:
+            return ""
+
+        parquet_url = self.meta_data.T["parquet_url"].iloc[0]
+        parquet_row = self.meta_data.T["parquet_row"].iloc[0]
+        return f"""\
+```python
+from io import BytesIO
+
+import holoviews as hv
+import numpy as np
+import panel as pn
+import pyarrow.parquet as pq
+from fsspec.parquet import open_parquet_file
+from PIL import Image
+
+pn.extension()
+
+parquet_url = "{parquet_url}"
+parquet_row = {parquet_row}
+column = "{self.column}"
+with open_parquet_file(parquet_url, columns=[column]) as f:
+    with pq.ParquetFile(f) as pf:
+        first_row_group = pf.read_row_group(parquet_row, columns=[column])
+
+stream = BytesIO(first_row_group[column][0].as_py())
+image = Image.open(stream)
+image_array = np.array(image)
+if image_array.ndim==2:
+    plot = hv.Image(image_array).opts(cmap="gray", colorbar=True)
+else:
+    plot = hv.RGB(image_array)
+
+plot.opts(xaxis=None, yaxis=None)
+
+pn.panel(plot).servable()
+```
+"""
 
 
 class App(param.Parameterized):

utils.py

@@ -20,6 +20,24 @@ DATASHADER_LOGO = "https://datashader.org/_static/logo_horizontal.svg"
 DATASHADER_URL = "https://datashader.org/"
 REPOSITORY = "Major-TOM"
 DATASETS = ["Core-S2L2A", "Core-S2L1C"]
+ESA_EASTING = 250668.73322714816
+ESA_NORTHING = 6259216.653115547
+META_DATA_COLUMNS = {
+    "Coastal aerosol": "B01",
+    "Blue": "B02",
+    "Green": "B03",
+    "Red": "B04",
+    "Vegetation Blue": "B05",
+    "Vegetation Green": "B06",
+    "Vegetation Red": "B07",
+    "NIR": "B08",
+    "Narrow NIR": "B8A",
+    "Water vapour": "B09",
+    "SWIR, 1613.7": "B11",
+    "SWIR, 2202.4": "B12",
+    "Cloud Mask": "cloud_mask",
+    "Thumbnail": "thumbnail",
+}
 
 DATA_PATH = Path(__file__).parent / "data"
 
@@ -129,16 +147,15 @@ def get_meta_data(dataset="Core-S2L2A", repository=REPOSITORY):
     return data
 
 
-def get_image(row):
+def get_image(row, column="thumbnail"):
     parquet_url = row["parquet_url"]
     parquet_row = row["parquet_row"]
-    print(parquet_url)
-    print(parquet_row)
-    with open_parquet_file(parquet_url, columns=["thumbnail"]) as f:
+    print(parquet_url, parquet_row, column)
+    with open_parquet_file(parquet_url, columns=[column]) as f:
         with pq.ParquetFile(f) as pf:
-            first_row_group = pf.read_row_group(parquet_row, columns=["thumbnail"])
+            first_row_group = pf.read_row_group(parquet_row, columns=[column])
 
-    stream = BytesIO(first_row_group["thumbnail"][0].as_py())
+    stream = BytesIO(first_row_group[column][0].as_py())
     image = Image.open(stream)
     return image