Update app.py

app.py

@@ -1,147 +1,499 @@
 import io
-import random
-from typing import List, Tuple
+import math
 
-import aiohttp
+# date=dataset['TIME']
+from datetime import date, datetime, timedelta
+
+import cartopy.crs as ccrs
+import cartopy.feature as cfeature
+import cftime
+import fsspec
+import hvplot.xarray
+import jdcal
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import panel as pn
+import xarray as xr
+from astropy.time import Time
+from ipywidgets import (
+    Checkbox,
+    Dropdown,
+    FloatRangeSlider,
+    FloatSlider,
+    IntRangeSlider,
+    IntSlider,
+    interactive,
+)
+
+pn.extension()
+
+#df = pd.read_csv("table.csv", index_col=None)
+#df = df.sort_values(by="year")
+#df2 = pd.read_csv("test_table.csv", index_col=None)
+#file_names = df["file_name"].tolist()
+#df = df.sort_values(by="year")
+#years = sorted(df["year"].unique())
+
+
+def greg_0h(jourjul):
+    # Julian days start and end at noon.
+    # Julian day 2440000 begins at 00 hours, May 23, 1968.
+
+    # Round the input Julian day number to avoid precision errors
+    fac = 10**9
+    jourjul = np.round(fac * jourjul + 0.5) / fac
+
+    # Calculate seconds in the day
+    secs = (jourjul % 1) * 24 * 3600
+
+    # Round seconds to avoid precision errors
+    secs = np.round(fac * secs + 0.5) / fac
+
+    # Gregorian calendar conversion
+    j = math.floor(jourjul) - 1721119
+    in_ = 4 * j - 1
+    y = math.floor(in_ / 146097)
+    j = in_ - 146097 * y
+    in_ = math.floor(j / 4)
+    in_ = 4 * in_ + 3
+    j = math.floor(in_ / 1461)
+    d = math.floor(((in_ - 1461 * j) + 4) / 4)
+    in_ = 5 * d - 3
+    m = math.floor(in_ / 153)
+    d = math.floor(((in_ - 153 * m) + 5) / 5)
+    y = y * 100 + j
+    if m < 10:
+        mo = m + 3
+        yr = y
+    else:
+        mo = m - 9
+        yr = y + 1
+
+    hour = math.floor(secs / 3600)
+    mins = math.floor((secs % 3600) / 60)
+    sec = int(secs % 60)
+
+    gtime = [yr, mo, d, hour, mins, sec]
+
+    return gtime
+
+
+def fix_time(dataset):
+    from datetime import datetime, timedelta
+
+    time = dataset["TIME"]
+    time2 = time.dropna(dim="MAXT")
+    time2 = time2.reindex_like(time, method='nearest')
+    jourjul = [greg_0h(jourjul) for jourjul in time2.values]
+    date = [
+        datetime(jourjul[0], jourjul[1], jourjul[2], jourjul[3], jourjul[4], jourjul[5])
+        for jourjul in jourjul
+    ]
+
+    return date
+
+from datetime import datetime, timedelta
+
+import cartopy.crs as ccrs
+import cartopy.feature as cfeature
+import fsspec
+import matplotlib.pyplot as plt
+import numpy as np
 import panel as pn
-from PIL import Image
-from transformers import CLIPModel, CLIPProcessor
+import xarray as xr
+from ipywidgets import (
+    Checkbox,
+    FloatRangeSlider,
+    FloatSlider,
+    IntRangeSlider,
+    IntSlider,
+    interactive,
+)
 
-pn.extension(design="bootstrap", sizing_mode="stretch_width")
+# Loaddonnées bathymétry data
+fs = fsspec.filesystem("https")
+# bathy = xr.open_dataset(fs.open('https://data-eurogoship.ifremer.fr/bathymetrie/bathy6min.nc'))
+bathy = xr.open_dataset(
+    "/Users/lfranc/Desktop/lea/CASCADE/exploitation/bathymetrie/bathy6min.nc"
+)
 
-ICON_URLS = {
-    "brand-github": "https://github.com/holoviz/panel",
-    "brand-twitter": "https://twitter.com/Panel_Org",
-    "brand-linkedin": "https://www.linkedin.com/company/panel-org",
-    "message-circle": "https://discourse.holoviz.org/",
-    "brand-discord": "https://discord.gg/AXRHnJU6sP",
-}
 
+import os
 
-async def random_url(_):
-    pet = random.choice(["cat", "dog"])
-    api_url = f"https://api.the{pet}api.com/v1/images/search"
-    async with aiohttp.ClientSession() as session:
-        async with session.get(api_url) as resp:
-            return (await resp.json())[0]["url"]
+import pandas as pd
+import panel as pn
+import param
+import xarray as xr
 
 
-@pn.cache
-def load_processor_model(
-    processor_name: str, model_name: str
-) -> Tuple[CLIPProcessor, CLIPModel]:
-    processor = CLIPProcessor.from_pretrained(processor_name)
-    model = CLIPModel.from_pretrained(model_name)
-    return processor, model
+class SADCP_Viewer(param.Parameterized):
+    df = pd.read_csv("table.csv", index_col=None).sort_values(by="year")
+    file_names = df["file_name"].tolist()
+    years = sorted(df["year"].unique())
 
+    year_slider = pn.widgets.IntRangeSlider(
+        name="Year Range", start=df["year"].min(), end=df["year"].max()
+    )
+    file_dropdown = pn.widgets.Select(name="File Selector")
+    data_table = pn.widgets.Tabulator(df, name="metadata", height=200, width=300)
+   # data_table2 = pn.widgets.Tabulator(df2, name="metadata", height=900, width=400)
+
+    longitude_slider = pn.widgets.RangeSlider(
+        name="Longitude Range", start=-180, end=180, step=1
+    )
+    latitude_slider = pn.widgets.RangeSlider(
+        name="Latitude Range", start=-90, end=90, step=1
+    )
 
-async def open_image_url(image_url: str) -> Image:
-    async with aiohttp.ClientSession() as session:
-        async with session.get(image_url) as resp:
-            return Image.open(io.BytesIO(await resp.read()))
+    depth_range_slider = pn.widgets.IntRangeSlider(
+        start=100, end=300, value=(100, 300), step=1, name="Depth Range"
+    )
+    depth_2_checkbox = pn.widgets.Checkbox(value=False, name="Depth 2 Checkbox")
+    depth_3_checkbox = pn.widgets.Checkbox(value=False, name="Depth 3 Checkbox")
 
+    depth2_range_slider = pn.widgets.IntRangeSlider(
+        start=100, end=300, value=(100, 300), step=1, name="Depth 2 Range"
+    )
+    depth3_range_slider = pn.widgets.IntRangeSlider(
+        start=100, end=300, value=(100, 300), step=1, name="Depth 3 Range"
+    )
 
-def get_similarity_scores(class_items: List[str], image: Image) -> List[float]:
-    processor, model = load_processor_model(
-        "openai/clip-vit-base-patch32", "openai/clip-vit-base-patch32"
+    num_vectors_slider = pn.widgets.IntSlider(
+        start=40, end=800, step=1, value=100, name="Number of Vectors"
     )
-    inputs = processor(
-        text=class_items,
-        images=[image],
-        return_tensors="pt",  # pytorch tensors
+    scale_factor_slider = pn.widgets.FloatSlider(
+        start=0.1, end=1, step=0.1, value=0.5, name="Scale Factor"
     )
-    outputs = model(**inputs)
-    logits_per_image = outputs.logits_per_image
-    class_likelihoods = logits_per_image.softmax(dim=1).detach().numpy()
-    return class_likelihoods[0]
-
-
-async def process_inputs(class_names: List[str], image_url: str):
-    """
-    High level function that takes in the user inputs and returns the
-    classification results as panel objects.
-    """
-    try:
-        main.disabled = True
-        if not image_url:
-            yield "##### ⚠️ Provide an image URL"
-            return
-    
-        yield "##### ⚙ Fetching image and running model..."
-        try:
-            pil_img = await open_image_url(image_url)
-            img = pn.pane.Image(pil_img, height=400, align="center")
-        except Exception as e:
-            yield f"##### 😔 Something went wrong, please try a different URL!"
-            return
-    
-        class_items = class_names.split(",")
-        class_likelihoods = get_similarity_scores(class_items, pil_img)
+    bathy_checkbox = pn.widgets.Checkbox(value=False, name="Bathy Checkbox")
+
+    plot = pn.pane.HoloViews()
+    plot_map = pn.pane.Matplotlib(width=800, height=600, sizing_mode="fixed")
     
-        # build the results column
-        results = pn.Column("##### 🎉 Here are the results!", img)
+    data_table = pn.widgets.Tabulator(
+        width=400, height=200
+    )
     
-        for class_item, class_likelihood in zip(class_items, class_likelihoods):
-            row_label = pn.widgets.StaticText(
-                name=class_item.strip(), value=f"{class_likelihood:.2%}", align="center"
+    metadata_table = pn.widgets.Tabulator(
+        width=600, height=800
+    )  
+    download_button = pn.widgets.Button(name="Download", button_type="primary")
+    # plot = pn.Column()
+
+    def __init__(self, **params):
+        super(SADCP_Viewer, self).__init__(**params)
+        self.file_dropdown.objects = self.get_file_list()
+        self.file_dropdown.value = (
+            self.file_dropdown.objects[0] if self.file_dropdown.objects else None
+        )
+        self.update_name_options()
+
+    @param.depends("year_slider.value", "file_dropdown.value", watch=True)
+    def update_name_options(self):
+        start_year, end_year = self.year_slider.value
+        mask = (self.df["year"] >= start_year) & (self.df["year"] <= end_year)
+        sorted_df = self.df[mask].sort_values(by="year")
+        files = sorted_df["file_name"].unique().tolist()
+
+        self.file_dropdown.options = files
+        if files:
+            selected_file = self.file_dropdown.value
+            if not selected_file or selected_file not in files:
+                selected_file = files[0]
+                self.file_dropdown.value = selected_file
+            dataframe = sorted_df[sorted_df["file_name"] == selected_file].drop(
+            columns=["file_name", "title", "Conventions", "featureType", "date_update", "ADCP_beam_angle", "ADCP_ship_angle", "middle_bin1_depth", "heading_corr", "pitch_corr", "ampli_corr", "pitch_roll_used", "date_creation", "ADCP_type", "data_type"]
             )
-            row_bar = pn.indicators.Progress(
-                value=int(class_likelihood * 100),
-                sizing_mode="stretch_width",
-                bar_color="secondary",
-                margin=(0, 10),
-                design=pn.theme.Material,
+            dataframe2 = sorted_df[sorted_df["file_name"] == selected_file].drop(
+            columns=["file_name","date_start","date_end","ADCP_frequency(kHz)","bin_length(meter)","year"])
+        
+            data_dir = "/Users/lfranc/Documents/octopus_ok/output/"
+            file_path = os.path.join(data_dir, selected_file)
+            self.ds = (
+                xr.open_dataset(
+                    file_path, decode_cf=True, decode_times=False, engine="scipy"
+                )
+                .squeeze()
+                .set_coords(["LONGITUDE", "LATITUDE", "TIME", "PROFZ"])
+                .set_xindex("PROFZ")
+                .set_xindex("TIME")
             )
-            results.append(pn.Column(row_label, row_bar))
-        yield results
-    finally:
-        main.disabled = False
 
+            lon_range = (
+                int(self.ds["LONGITUDE"].min().round() - 1),
+                int(self.ds["LONGITUDE"].max().round() + 1),
+            )
+            lat_range = (
+                int(self.ds["LATITUDE"].min().round() - 1),
+                int(self.ds["LATITUDE"].max().round() + 1),
+            )
+            self.depth1 = abs(self.ds.coords["PROFZ"])
+            date = fix_time(self.ds)
+            date = xr.DataArray(date, dims="MAXT")
+            # self.ds = self.ds.where(
+            # (self.ds.VCUR_SEADATANET_QC == 49)
+            # & (self.ds.UCUR_SEADATANET_QC == 49)
+            # & (self.ds.WCUR_SEADATANET_QC == 49)
+            # & (self.ds.ECUR_SEADATANET_QC == 49)
+            # & (self.ds.PGOOD_SEADATANET_QC == 49)
+            # & (self.ds.ECI_SEADATANET_QC == 49)
+            # & (self.ds.BOTTOM_DEPTH_SEADATANET_QC == 49),
+            # drop=True,)
+            self.ds = self.ds[
+                [
+                    "USHIP",
+                    "VSHIP",
+                    "ROLL",
+                    "PITCH",
+                    "TR_TEMP",
+                    "HEADING",
+                    "U_BOTTOM",
+                    "V_BOTTOM",
+                    "UCUR",
+                    "VCUR",
+                    "WCUR",
+                    "ECUR",
+                    "PGOOD",
+                    "ECI",
+                    "BATHY",
+                    "UTIDE",
+                    "VTIDE",
+                    "BOTTOM_DEPTH",
+                    "TIME",
+                ]
+            ]
+            deph_range = (int(self.depth1.min()), int(self.depth1.max()))
 
-# create widgets
-randomize_url = pn.widgets.Button(name="Randomize URL", align="end")
+            # Ku_std_dataarray = xr.DataArray(Ku_std,dims='dim1')
 
-image_url = pn.widgets.TextInput(
-    name="Image URL to classify",
-    value=pn.bind(random_url, randomize_url),
-)
-class_names = pn.widgets.TextInput(
-    name="Comma separated class names",
-    placeholder="Enter possible class names, e.g. cat, dog",
-    value="cat, dog, parrot",
-)
+            # date=dataset.assign(TIME=date)
 
-input_widgets = pn.Column(
-    "##### 😊 Click randomize or paste a URL to start classifying!",
-    pn.Row(image_url, randomize_url),
-    class_names,
-)
+            # dataset['TIME']=dataset['TIME'].assign_coords(dim=dataset.dims['MAXT'])
+            self.ds = self.ds.assign(TIME=date)
 
-# add interactivity
-interactive_result = pn.panel(
-    pn.bind(process_inputs, image_url=image_url, class_names=class_names),
-    height=600,
-)
+            self.longitude_slider.start = lon_range[0]
+            self.longitude_slider.end = lon_range[1]
+            self.longitude_slider.value = lon_range
+            self.latitude_slider.start = lat_range[0]
+            self.latitude_slider.end = lat_range[1]
+            self.latitude_slider.value = lat_range
+            self.depth_range_slider.start = deph_range[0]
+            self.depth_range_slider.end = deph_range[1]
+            self.depth_range_slider.value = deph_range
+            self.depth2_range_slider.start = deph_range[0]
+            self.depth2_range_slider.end = deph_range[1]
+            self.depth2_range_slider.value = deph_range
+            self.depth3_range_slider.start = deph_range[0]
+            self.depth3_range_slider.end = deph_range[1]
+            self.depth3_range_slider.value = deph_range
+            
+            
+
+
+            # self.update_plots()
+            self.ds.close()
+            self.dataframe = dataframe.transpose()
+            self.dataframe2 = dataframe2.transpose()
+            # self.transposed_dataframe = dataframe.transpose()
+            self.data_table.value = self.dataframe
+            self.metadata_table.value = self.dataframe2
+
+    @param.depends(
+        "year_slider.value",
+        "file_dropdown.value",
+        "depth_range_slider.value",
+        "depth_2_checkbox.value",
+        "depth_3_checkbox.value",
+        "depth2_range_slider.value",
+        "depth3_range_slider.value",
+        "longitude_slider.value",
+        "latitude_slider.value",
+        "num_vectors_slider.value",
+        "scale_factor_slider.value",
+        "bathy_checkbox.value",
+        watch=True,
+    )
+    def update_plots(self):
+        self.ds_filtered = self.filter_data()
+        # vector_plot = self.vectors_plot()
+        other_plots = self.plots()
+
+        # self.plot_map = pn.pane.Matplotlib(vector_plot, width=800, height=600, sizing_mode="fixed")
+        self.plot = pn.Column(
+            *(pn.pane.HoloViews(plot, width=400, height=200) for plot in other_plots),
+            sizing_mode="stretch_width"
+        )
+        vector_plot = self.vectors_plot()  # Update vector plot
+        self.plot_map.object = vector_plot
+        # other_plots = self.plots()  # Update other plots
+        # self.plot.objects = [*(pn.pane.HoloViews(p, width=400, height=200) for p in other_plots)]
+        # self.plot.object=plot
+
+        return pn.Row(self.plot_map, self.plot, sizing_mode="stretch_both")
+
+    def filter_data(self):
+        return self.ds.where(
+            (self.ds.LONGITUDE >= self.longitude_slider.start)
+            & (self.ds.LONGITUDE <= self.longitude_slider.end)
+            & (self.ds.LATITUDE >= self.latitude_slider.start)
+            & (self.ds.LATITUDE <= self.latitude_slider.end),
+            drop=True,
+        )
+
+    def vectors_plot(self):
+        import hvplot.xarray
+
+        self.ds_filtered = self.filter_data()
+        # return self.ds_filtered['VSHIP'].hvplot(x='TIME',width=400, height=200) #if 'BATHY' in self.ds_filtered else hvplot.show(hvplot.text(0, 0, "No data available", fontsize=12))
+
+        fig, ax = plt.subplots(
+            figsize=(8, 7), subplot_kw={"projection": ccrs.Mercator()}
+        )
+        coords = ["LATITUDE", "LONGITUDE"]
+        corsen = max(1, self.ds_filtered.MAXT.size // self.num_vectors_slider.value)
+        self.ds_filtered = (
+            self.ds_filtered.reset_coords(coords)
+            .coarsen({"MAXT": corsen}, boundary="trim")
+            .mean()
+            .set_coords(coords)
+        )
+        # self.ds_filtered =self.ds_filtered.coarsen(MAXT = corsen,  side = "center", boundary = "trim").mean()[["LONGITUDE", "LONGITUDE", "TIME"]].isel(MAXZ=0)
+        depth_filtered = self.ds_filtered.where(
+            (self.depth1 > self.depth_range_slider.value[0])
+            & (self.depth1 <= self.depth_range_slider.value[1])
+        )
+
+        lon = self.ds_filtered.coords["LONGITUDE"].values
+        lat = self.ds_filtered.coords["LATITUDE"].values
+        # skip = max(1, int(np.sqrt(lon.size) / self.num_vectors_slider.value))
+        # skip = (slice(None, None, skip), slice(None, None, skip))
 
-# add footer
-footer_row = pn.Row(pn.Spacer(), align="center")
-for icon, url in ICON_URLS.items():
-    href_button = pn.widgets.Button(icon=icon, width=35, height=35)
-    href_button.js_on_click(code=f"window.open('{url}')")
-    footer_row.append(href_button)
-footer_row.append(pn.Spacer())
-
-# create dashboard
-main = pn.WidgetBox(
-    input_widgets,
-    interactive_result,
-    footer_row,
+        # Moyenne des vecteurs de courant sur la plage de profondeur sélectionnée
+        u_mean = depth_filtered.UCUR.mean(dim="MAXZ", skipna=True)
+        v_mean = depth_filtered.VCUR.mean(dim="MAXZ", skipna=True)
+        ax.quiver(
+            lon,
+            lat,
+            u_mean * self.scale_factor_slider.value,
+            v_mean * self.scale_factor_slider.value,
+            color="blue",
+            scale=2,
+            width=0.001,
+            headwidth=3,
+            transform=ccrs.PlateCarree(),
+        )
+
+        if self.depth_2_checkbox.value:
+            depth_filtered = self.ds_filtered.where(
+                (self.depth1 > self.depth2_range_slider.value[0])
+                & (self.depth1 <= self.depth2_range_slider.value[1])
+            )
+            u_mean = depth_filtered.UCUR.mean(dim="MAXZ", skipna=True)
+            v_mean = depth_filtered.VCUR.mean(dim="MAXZ", skipna=True)
+            ax.quiver(
+                lon,
+                lat,
+                u_mean * self.scale_factor_slider.value,
+                v_mean * self.scale_factor_slider.value,
+                color="green",
+                scale=2,
+                width=0.001,
+                headwidth=3,
+                transform=ccrs.PlateCarree(),
+            )
+
+        if self.depth_3_checkbox.value:
+            depth_filtered = self.ds_filtered.where(
+                (self.depth1 > self.depth3_range_slider.value[0])
+                & (self.depth1 <= self.depth3_range_slider.value[1])
+            )
+            u_mean = depth_filtered.UCUR.mean(dim="MAXZ", skipna=True)
+            v_mean = depth_filtered.VCUR.mean(dim="MAXZ", skipna=True)
+            ax.quiver(
+                lon,
+                lat,
+                u_mean * self.scale_factor_slider.value,
+                v_mean * self.scale_factor_slider.value,
+                color="red",
+                scale=2,
+                width=0.001,
+                headwidth=3,
+                transform=ccrs.PlateCarree(),
+            )
+
+        ax.add_feature(cfeature.COASTLINE)
+        ax.add_feature(cfeature.BORDERS, linestyle=":")
+        ax.add_feature(cfeature.LAND, color="lightgray")
+
+        if self.bathy_checkbox.value:
+            contour_levels = [-2000]
+            ax.contour(
+                bathy.longitude,
+                bathy.latitude,
+                bathy.z,
+                levels=contour_levels,
+                colors="black",
+                transform=ccrs.PlateCarree(),
+            )
+
+        ax.set_extent(
+            [
+                self.longitude_slider.value[0],
+                self.longitude_slider.value[1],
+                self.latitude_slider.value[0],
+                self.latitude_slider.value[1],
+            ]
+        )
+        ax.gridlines(draw_labels=True)
+        plt.ylabel("Latitude", fontsize=15, labelpad=35)
+        plt.xlabel("Longitude", fontsize=15, labelpad=20)
+        return fig
+
+        # pn.pane.Matplotlib(fig,width=800, height=600, sizing_mode="fixed", name="Plot")
+
+    # @param.depends( 'file_dropdown.value', 'longitude_slider.value', 'latitude_slider.value',  watch=True)
+    def plots(self):
+        return [
+            self.ds_filtered["BATHY"].hvplot(x="TIME", width=400, height=200),
+            self.ds_filtered["USHIP"].hvplot(x="TIME", width=400, height=200),
+            self.ds_filtered["VSHIP"].hvplot(x="TIME", width=400, height=200),
+            self.ds_filtered["BOTTOM_DEPTH"].hvplot(x="TIME", width=400, height=200),
+        ]
+
+    def get_file_list(self):
+        return self.file_names
+
+
+
+
+# Instantiate the SADCP_Viewer class and create a template
+explorer = SADCP_Viewer()
+tabs = pn.Tabs(
+    ("Plots", pn.Column(explorer.update_plots)),
+    (
+        "Metadata",
+        pn.Column(
+            explorer.metadata_table, explorer.download_button, height=500, margin=10
+        ),
+    ),
 )
 
-title = "Panel Demo - Image Classification"
-pn.template.BootstrapTemplate(
-    title=title,
-    main=main,
-    main_max_width="min(50%, 698px)",
-    header_background="#F08080",
-).servable(title=title)
+sidebar = [
+    """This application, developed in the frame of Euro Go Shop, helps to interactively visualise and download ship ADCP data.""",
+    explorer.year_slider,
+    explorer.file_dropdown,
+    explorer.longitude_slider,
+    explorer.latitude_slider,
+    explorer.bathy_checkbox,
+    explorer.depth_range_slider,
+    explorer.depth_2_checkbox,
+    explorer.depth_3_checkbox,
+    explorer.depth2_range_slider,
+    explorer.depth3_range_slider,
+    explorer.num_vectors_slider,
+    explorer.scale_factor_slider,
+    explorer.data_table,
+]
+template = pn.template.FastListTemplate(title="SADCP data Viewer", sidebar=sidebar,main=[tabs])
+template.servable()
+