wolfhece 2.1.92__py3-none-any.whl → 2.1.93__py3-none-any.whl

wolfhece/PyDraw.py

@@ -121,6 +121,377 @@ ID_PLOTCS = 1003   #Manageactions ID for profile plots
 
 LIST_1TO9 = [wx.WXK_NUMPAD1, wx.WXK_NUMPAD2, wx.WXK_NUMPAD3, wx.WXK_NUMPAD4, wx.WXK_NUMPAD5, wx.WXK_NUMPAD6, wx.WXK_NUMPAD7, wx.WXK_NUMPAD8, wx.WXK_NUMPAD9 ] + [ord(str(cur)) for cur in range(1,10)]
 
+class Memory_View():
+    """ Memory view """
+
+    def __init__(self, screen_width, screen_height, xmin, xmax, ymin, ymax):
+        """ Constructor """
+
+        self.screen_width = screen_width
+        self.screen_height = screen_height
+        self.xmin = xmin
+        self.xmax = xmax
+        self.ymin = ymin
+        self.ymax = ymax
+
+    @property
+    def width(self):
+        """ Width of the view """
+        return self.xmax - self.xmin
+
+    @property
+    def height(self):
+        """ Height of the view """
+        return self.ymax - self.ymin
+
+    def __str__(self):
+        """ String representation of the view """
+
+        return f"Memory view : {self.screen_width}x{self.screen_height} ({self.xmin},{self.ymin})-({self.xmax},{self.ymax})"
+
+    def serialize(self):
+        """ Serialize the view """
+
+        return {
+            "screen_width": self.screen_width,
+            "screen_height": self.screen_height,
+            "xmin": self.xmin,
+            "xmax": self.xmax,
+            "ymin": self.ymin,
+            "ymax": self.ymax
+        }
+
+    @staticmethod
+    def deserialize(data:dict):
+        """ Deserialize the view """
+
+        return Memory_View(data["screen_width"], data["screen_height"], data["xmin"], data["xmax"], data["ymin"], data["ymax"])
+
+class Memory_View_encoder(json.JSONEncoder):
+    """ Memory view encoder """
+
+    def default(self, o):
+        """ Default method """
+
+        if isinstance(o, Memory_View):
+            return o.serialize()
+        else:
+            return super().default(o)
+
+class Memory_View_decoder(json.JSONDecoder):
+    """ Memory view decoder """
+
+    def __init__(self, *args, **kwargs):
+        """ Constructor """
+
+        super().__init__(object_hook=self.object_hook, *args, **kwargs)
+
+    def object_hook(self, obj):
+        """ Decode the object """
+
+        if "screen_width" in obj and "screen_height" in obj and "xmin" in obj and "xmax" in obj and "ymin" in obj and "ymax" in obj:
+            return Memory_View.deserialize(obj)
+        else:
+            return obj
+
+class Memory_Views():
+    """ Memory views """
+
+    def __init__(self):
+
+        self.views:dict[str,Memory_View] = {}
+
+    def __len__(self):
+        """ Number of views """
+
+        return len(self.views)
+
+    def add_view(self, name:str, screen_width:int, screen_height:int, xmin:float, xmax:float, ymin:float, ymax:float):
+        """ Add a new view to the memory views """
+        self.views[name] = Memory_View(screen_width, screen_height, xmin, xmax, ymin, ymax)
+
+    def remove_view(self, name:str):
+        """ Remove a view from the memory views """
+
+        if name in self.views:
+            self.views.pop(name)
+
+    def reset(self):
+        """ Reset the memory views """
+
+        self.views = {}
+
+    def __getitem__(self, name:str) -> Memory_View:
+        """ Get a view from the memory views """
+
+        if name in self.views:
+            return self.views[name]
+        else:
+            return None
+
+    def zoom_on(self, name:str, mapviewer:"WolfMapViewer"):
+        """ Zoom on a view """
+
+        if name not in self.views:
+            return
+
+        view = self.views[name]
+
+        mapviewer.zoom_on(width= view.width, height=view.height, xll=view.xmin, yll=view.ymin, canvas_height=view.screen_height)
+
+    def save(self, filename:str):
+        """ Save the memory views """
+
+        with open(filename, 'w') as f:
+            json.dump(self.views, f,
+                      cls=Memory_View_encoder,
+                      indent=4)
+
+    def load(self, filename:str):
+        """ Load the memory views """
+
+        with open(filename, 'r') as f:
+            self.views = json.load(f, cls=Memory_View_decoder)
+
+        # self.views = {k:Memory_View.deserialize(v) for k,v in tmp_views.items()}
+
+class Memory_Views_GUI(wx.Frame):
+    """ Memory views GUI """
+
+    def __init__(self, parent, title, memory_views:Memory_Views, mapviewer:"WolfMapViewer"):
+        """ Constructor """
+
+        super(Memory_Views_GUI, self).__init__(parent, title=title, size=(200, 400), style = wx.DEFAULT_FRAME_STYLE & ~ (wx.RESIZE_BORDER | wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX | wx.CLOSE_BOX))
+        self.mapviewer = mapviewer
+        self._memory_views = memory_views
+
+
+        panel = wx.Panel(self)
+        panel.SetBackgroundColour(wx.Colour(255, 255, 255))
+
+        sizer = wx.BoxSizer(wx.VERTICAL)
+
+        self._views = wx.ListBox(panel, choices= list(memory_views.views.keys()), style=wx.LB_SINGLE)
+
+        self._cmdZoom = wx.Button(panel, wx.ID_ANY, _('Zoom on'))
+        self._cmdZoom.SetToolTip(_('Zoom on the selected view'))
+
+        self._cmdAdd = wx.Button(panel, wx.ID_ADD, _('+'))
+        self._cmdAdd.SetToolTip(_('Add a view based on the current zoom and shape of the canvas'))
+
+        self._cmdDelete = wx.Button(panel, wx.ID_DELETE, _('-'))
+        self._cmdDelete.SetToolTip(_('Delete the selected view'))
+
+        self._cmdReset = wx.Button(panel, wx.ID_RESET, _('Reset'))
+        self._cmdReset.SetToolTip(_('Reset the views'))
+
+        sizer.Add(self._views, 5, wx.EXPAND | wx.ALL, 2)
+
+        sizer_but = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_but.Add(self._cmdAdd, 1, wx.EXPAND)
+        sizer_but.Add(self._cmdDelete, 1, wx.EXPAND)
+
+        sizer.Add(self._cmdZoom, 1, wx.EXPAND, 2)
+        sizer.Add(sizer_but, 1,  wx.EXPAND, 2)
+        sizer.Add(self._cmdReset, 1, wx.EXPAND , 2)
+
+        sizer_manual = wx.BoxSizer(wx.VERTICAL)
+
+        sizer_xmin = wx.BoxSizer(wx.HORIZONTAL)
+        self._label_xmin = wx.StaticText(panel, label=_('X min'))
+        self._xmin = wx.TextCtrl(panel, value=str(mapviewer.xmin), style=wx.ALIGN_CENTER_HORIZONTAL)
+        sizer_xmin.Add(self._label_xmin, 1, wx.ALL, 2)
+        sizer_xmin.Add(self._xmin, 1, wx.ALL, 2)
+
+        sizer_xmax = wx.BoxSizer(wx.HORIZONTAL)
+        self._label_xmax = wx.StaticText(panel, label=_('X max'))
+        self._xmax = wx.TextCtrl(panel, value=str(mapviewer.xmax), style=wx.ALIGN_CENTER_HORIZONTAL)
+        sizer_xmax.Add(self._label_xmax, 1, wx.ALL, 2)
+        sizer_xmax.Add(self._xmax, 1, wx.ALL, 2)
+
+        sizer_ymin = wx.BoxSizer(wx.HORIZONTAL)
+        self._label_ymin = wx.StaticText(panel, label=_('Y min'))
+        self._ymin = wx.TextCtrl(panel, value=str(mapviewer.ymin), style=wx.ALIGN_CENTER_HORIZONTAL)
+        sizer_ymin.Add(self._label_ymin, 1, wx.ALL, 2)
+        sizer_ymin.Add(self._ymin, 1, wx.ALL, 2)
+
+        sizer_ymax = wx.BoxSizer(wx.HORIZONTAL)
+        self._label_ymax = wx.StaticText(panel, label=_('Y max'))
+        self._ymax = wx.TextCtrl(panel, value=str(mapviewer.ymax), style=wx.ALIGN_CENTER_HORIZONTAL)
+        sizer_ymax.Add(self._label_ymax, 1, wx.ALL, 2)
+        sizer_ymax.Add(self._ymax, 1, wx.ALL, 2)
+
+        sizer_canvas_height = wx.BoxSizer(wx.HORIZONTAL)
+        self._label_canvas_height = wx.StaticText(panel, label=_('Canvas height'))
+        self._canvas_height = wx.TextCtrl(panel, value=str(mapviewer.canvasheight), style=wx.ALIGN_CENTER_HORIZONTAL)
+
+        self._label_canvas_height.SetToolTip(_('Height of the canvas in pixels'))
+        self._canvas_height.SetToolTip(_('Height of the canvas in pixels'))
+
+        sizer_canvas_height.Add(self._label_canvas_height, 1, wx.ALL, 2)
+        sizer_canvas_height.Add(self._canvas_height, 1, wx.ALL, 2)
+
+        sizer_manual.Add(sizer_xmin, 1, wx.ALL, 2)
+        sizer_manual.Add(sizer_xmax, 1, wx.ALL, 2)
+        sizer_manual.Add(sizer_ymin, 1, wx.ALL, 2)
+        sizer_manual.Add(sizer_ymax, 1, wx.ALL, 2)
+        sizer_manual.Add(sizer_canvas_height, 1, wx.ALL, 2)
+
+        sizer_but2 = wx.BoxSizer(wx.HORIZONTAL)
+        self._cmdGet = wx.Button(panel, wx.ID_ANY, _('Get'))
+        self._cmdGet.SetToolTip(_('Get the current bounds of the canvas and fill the fields'))
+
+        self._cmdApply = wx.Button(panel, wx.ID_APPLY, _('Apply'))
+        self._cmdApply.SetToolTip(_('Apply the values to the selected view'))
+
+        self._cmdApply.Bind(wx.EVT_BUTTON, self.OnApply)
+        self._cmdGet.Bind(wx.EVT_BUTTON, self.OnGet)
+
+        sizer_but2.Add(self._cmdGet, 1, wx.ALL, 2)
+        sizer_but2.Add(self._cmdApply, 1, wx.ALL, 2)
+
+        sizer_manual.Add(sizer_but2, 1, wx.EXPAND, 2)
+        sizer.Add(sizer_manual, 1, wx.ALL, 2)
+
+        sizer_save_load = wx.BoxSizer(wx.HORIZONTAL)
+        self._cmdSave = wx.Button(panel, wx.ID_SAVE, _('Save'))
+        self._cmdSave.SetToolTip(_('Save the memory views to a json file'))
+
+        self._cmdLoad = wx.Button(panel, wx.ID_OPEN, _('Load'))
+        self._cmdLoad.SetToolTip(_('Load the memory views from a json file'))
+
+        sizer_save_load.Add(self._cmdSave, 1, wx.ALL, 2)
+        sizer_save_load.Add(self._cmdLoad, 1, wx.ALL, 2)
+
+        sizer.Add(sizer_save_load, 1, wx.EXPAND, 2)
+
+        self._views.Bind(wx.EVT_LISTBOX, self.OnSelectView)
+        self.Bind(wx.EVT_BUTTON, self.OnAdd, self._cmdAdd)
+        self.Bind(wx.EVT_BUTTON, self.OnDelete, self._cmdDelete)
+        self.Bind(wx.EVT_BUTTON, self.OnReset, self._cmdReset)
+        self.Bind(wx.EVT_CLOSE, self.OnClose)
+        self.Bind(wx.EVT_BUTTON, self.OnSave, self._cmdSave)
+        self.Bind(wx.EVT_BUTTON, self.OnLoad, self._cmdLoad)
+        self.Bind(wx.EVT_BUTTON, self.OnZoom, self._cmdZoom)
+
+        panel.SetSizer(sizer)
+
+        self.CenterOnScreen()
+
+        icon = wx.Icon()
+        icon_path = Path(__file__).parent / "apps/wolf_logo2.bmp"
+        icon.CopyFromBitmap(wx.Bitmap(str(icon_path), wx.BITMAP_TYPE_ANY))
+        self.SetIcon(icon)
+
+        self.Show()
+
+    def OnSave(self, event):
+        """ Save the memory views """
+
+        with wx.FileDialog(self, _('Save the memory views'), wildcard="JSON files (*.json)|*.json",
+                            style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT) as fileDialog:
+            if fileDialog.ShowModal() == wx.ID_CANCEL:
+                return
+
+            self._memory_views.save(fileDialog.GetPath())
+
+    def OnLoad(self, event):
+        """ Load the memory views """
+
+        with wx.FileDialog(self, _('Load the memory views'), wildcard="JSON files (*.json)|*.json",
+                            style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST) as fileDialog:
+            if fileDialog.ShowModal() == wx.ID_CANCEL:
+                return
+
+            self._memory_views.load(fileDialog.GetPath())
+
+        if self._memory_views is None:
+            logging.error(_('Error while loading the memory views'))
+            return
+
+        if self._memory_views.views is None:
+            logging.error(_('Error while loading the memory views'))
+            return
+
+        self._views.Set(list(self._memory_views.views.keys()))
+
+    def OnClose(self, event):
+        """ Close the memory views GUI """
+
+        self.mapviewer._memory_views_gui = None
+        self.Destroy()
+
+    def OnSelectView(self, event):
+        """ Select a view """
+
+        view = self._views.GetStringSelection()
+        locview = self._memory_views[view]
+
+        if locview is None:
+            return
+
+        self._xmax.SetValue(str(self._memory_views[view].xmax))
+        self._xmin.SetValue(str(self._memory_views[view].xmin))
+        self._ymax.SetValue(str(self._memory_views[view].ymax))
+        self._ymin.SetValue(str(self._memory_views[view].ymin))
+        self._canvas_height.SetValue(str(self._memory_views[view].screen_height))
+
+    def OnZoom(self, event):
+        """ Zoom on the current view """
+
+        view = self._views.GetStringSelection()
+        self._memory_views.zoom_on(view, self.mapviewer)
+
+    def OnAdd(self, event):
+        """ Add a view """
+
+        name = "View " + str(len(self._memory_views.views) + 1)
+        with wx.TextEntryDialog(self, _('Enter the name of the view'), _('Add a view'), name) as dlg:
+            if dlg.ShowModal() == wx.ID_OK:
+                name = dlg.GetValue()
+
+        self._memory_views.add_view(name, self.mapviewer.canvaswidth, self.mapviewer.canvasheight, self.mapviewer.xmin, self.mapviewer.xmax, self.mapviewer.ymin, self.mapviewer.ymax)
+
+        self._views.Set(list(self._memory_views.views.keys()))
+
+    def OnDelete(self, event):
+        """ Delete a view """
+
+        view = self._views.GetStringSelection()
+        self._memory_views.remove_view(view)
+
+        self._views.Set(list(self._memory_views.views.keys()))
+
+    def OnReset(self, event):
+        """ Reset the views """
+
+        self._memory_views.reset()
+
+    def OnApply(self, event):
+        """ Apply the changes """
+
+        view = self._views.GetStringSelection()
+
+        try:
+            xmin = float(self._xmin.GetValue())
+            xmax = float(self._xmax.GetValue())
+            ymin = float(self._ymin.GetValue())
+            ymax = float(self._ymax.GetValue())
+            canvas_height = int(self._canvas_height.GetValue())
+
+            self._memory_views.add_view(view, self.mapviewer.canvaswidth, canvas_height, xmin, xmax, ymin, ymax)
+        except:
+            logging.error(_('Error while applying the changes'))
+
+    def OnGet(self, event):
+        """ Get the values """
+
+        self._xmin.SetValue(str(self.mapviewer.xmin))
+        self._xmax.SetValue(str(self.mapviewer.xmax))
+        self._ymin.SetValue(str(self.mapviewer.ymin))
+        self._ymax.SetValue(str(self.mapviewer.ymax))
+        self._canvas_height.SetValue(str(self.mapviewer.canvasheight))
+
 class draw_type(Enum):
     # FIXME: change this to be more robust -> Done !
     # Be careful with the enum name, it must be the same than the one used to create the tree list elements, but in lower case
@@ -600,7 +971,10 @@ class WolfMapViewer(wx.Frame):
 
         self.menu_contour_from_arrays = self.tools_menu.Append(wx.ID_ANY, _("Create contour from checked arrays..."), _("Create contour"))
         self.menu_calculator = self.tools_menu.Append(wx.ID_ANY, _("Calculator..."), _("Calculator"))
+        self.menu_views = self.tools_menu.Append(wx.ID_ANY, _("Memory views..."), _("Memory views"))
         self.calculator = None
+        self.memory_views = None
+        self._memory_views_gui = None
 
         # Cross sections
         # ----------------
@@ -5218,6 +5592,18 @@ class WolfMapViewer(wx.Frame):
             else:
                 self.calculator.Show()
 
+        elif itemlabel == _("Memory views..."):
+            autoscale = False
+
+            if self.memory_views is None:
+                self.memory_views = Memory_Views()
+                self._memory_views_gui = Memory_Views_GUI(self, _('Memory view manager'), self.memory_views, mapviewer = self)
+            else:
+                if self._memory_views_gui is None:
+                    self._memory_views_gui = Memory_Views_GUI(self, _('Memory view manager'), self.memory_views, mapviewer = self)
+
+                self._memory_views_gui.Show()
+
         elif itemlabel == _("Create bridge and export gltf..."):
             autoscale = False
 

wolfhece/PyPalette.py

@@ -16,7 +16,7 @@ import numpy as np
 import numpy.ma as ma
 from bisect import bisect_left
 import matplotlib.pyplot as plt
-from matplotlib.colors import LinearSegmentedColormap, Normalize
+from matplotlib.colors import LinearSegmentedColormap, Normalize, ListedColormap, BoundaryNorm
 from collections import OrderedDict
 import typing
 import io
@@ -207,6 +207,7 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
             logging.warning('No values in palette - Nothing to do !')
             return None, None
 
+
         if fn == '':
             file = wx.FileDialog(None, "Choose .pal file", wildcard="png (*.png)|*.png|all (*.*)|*.*", style=wx.FD_SAVE)
             if file.ShowModal() == wx.ID_CANCEL:
@@ -220,14 +221,31 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
                 fig, ax = plt.subplots(1, 1)
             else:
                 fig, ax = figax
-            plt.colorbar(ScalarMappable(Normalize(self.values[0], self.values[-1]), cmap=self),
-                         cax=ax,
-                         orientation='vertical',
-                         extend='both',
-                         aspect=20,
-                         spacing='proportional',
-                         ticks=self.values,
-                         format='%.3f')
+
+            if self.interval_cst:
+                discrete_cmap = ListedColormap(self.colorsflt[:, :3])
+                colorbar = plt.colorbar(ScalarMappable(BoundaryNorm(self.values, ncolors=self.nb-1),
+                                                      cmap=discrete_cmap),
+                            cax=ax,
+                            orientation='vertical',
+                            extend='both',
+                            aspect=20,
+                            spacing='proportional',
+                            ticks=self.values,
+                            format='%.3f')
+
+            else:
+                plt.colorbar(ScalarMappable(Normalize(self.values[0],
+                                                      self.values[-1]),
+                                                      cmap=self),
+                            cax=ax,
+                            orientation='vertical',
+                            extend='both',
+                            aspect=20,
+                            spacing='proportional',
+                            ticks=self.values,
+                            format='%.3f')
+
             plt.tick_params(labelsize=14)
             if figax is None:
                 fig.set_size_inches((2, 10))
@@ -241,13 +259,27 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
                 fig, ax = plt.subplots(1, 1)
             else:
                 fig, ax = figax
-            plt.colorbar(ScalarMappable(Normalize(self.values[0], self.values[-1]), cmap=self),
-                         cax=ax,
-                         orientation='horizontal',
-                         extend='both',
-                         spacing='proportional',
-                         ticks=self.values,
-                         format='%.3f')
+
+            if self.interval_cst:
+                discrete_cmap = ListedColormap(self.colorsflt[:, :3])
+                colorbar = plt.colorbar(ScalarMappable(BoundaryNorm(self.values, ncolors=self.nb-1),
+                                                      cmap=discrete_cmap),
+                            cax=ax,
+                            orientation='horizontal',
+                            extend='both',
+                            aspect=20,
+                            spacing='proportional',
+                            ticks=self.values,
+                            format='%.3f')
+            else:
+                plt.colorbar(ScalarMappable(Normalize(self.values[0], self.values[-1]), cmap=self),
+                            cax=ax,
+                            orientation='horizontal',
+                            extend='both',
+                            spacing='proportional',
+                            ticks=self.values,
+                            format='%.3f')
+
             plt.tick_params(labelsize=14, rotation=45)
             if figax is None:
                 fig.set_size_inches((2, 10))
@@ -264,13 +296,26 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
                 fig, ax = plt.subplots(1, 1)
             else:
                 fig, ax = figax
-            plt.colorbar(ScalarMappable(Normalize(self.values[0], self.values[-1]), cmap=self),
-                         cax=ax,
-                         orientation='vertical',
-                         extend='both',
-                         spacing='proportional',
-                         ticks=self.values,
-                         format='%.3f')
+
+            if self.interval_cst:
+                discrete_cmap = ListedColormap(self.colorsflt[:, :3])
+                colorbar = plt.colorbar(ScalarMappable(BoundaryNorm(self.values, ncolors=self.nb-1),
+                                                      cmap=discrete_cmap),
+                            cax=ax,
+                            orientation='vertical',
+                            extend='both',
+                            aspect=20,
+                            spacing='proportional',
+                            ticks=self.values,
+                            format='%.3f')
+            else:
+                plt.colorbar(ScalarMappable(Normalize(self.values[0], self.values[-1]), cmap=self),
+                            cax=ax,
+                            orientation='vertical',
+                            extend='both',
+                            spacing='proportional',
+                            ticks=self.values,
+                            format='%.3f')
             plt.tick_params(labelsize=14)
             fig.set_size_inches((2, 10))
             fig.tight_layout()
@@ -282,13 +327,25 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
             else:
                 fig, ax = figax
 
-            plt.colorbar(ScalarMappable(Normalize(self.values[0], self.values[-1]), cmap=self),
-                         cax=ax,
-                         orientation='horizontal',
-                         extend='both',
-                         spacing='proportional',
-                         ticks=self.values,
-                         format='%.3f')
+            if self.interval_cst:
+                discrete_cmap = ListedColormap(self.colorsflt[:, :3])
+                colorbar = plt.colorbar(ScalarMappable(BoundaryNorm(self.values, ncolors=self.nb-1),
+                                                      cmap=discrete_cmap),
+                            cax=ax,
+                            orientation='horizontal',
+                            extend='both',
+                            aspect=20,
+                            spacing='proportional',
+                            ticks=self.values,
+                            format='%.3f')
+            else:
+                plt.colorbar(ScalarMappable(Normalize(self.values[0], self.values[-1]), cmap=self),
+                            cax=ax,
+                            orientation='horizontal',
+                            extend='both',
+                            spacing='proportional',
+                            ticks=self.values,
+                            format='%.3f')
             plt.tick_params(labelsize=14, rotation=45)
             fig.set_size_inches((10, 2))
             fig.tight_layout()
@@ -298,26 +355,38 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
         return fig, ax
 
     def plot(self, fig: Figure, ax: plt.Axes):
+        """ Affichage de la palette de couleurs """
+
         gradient = np.linspace(0, 1, 256)
         gradient = np.vstack((gradient, gradient))
-        ax.imshow(gradient, aspect='auto', cmap=self)
-        ax.set_yticklabels([])
 
         pos = []
         txt = []
-
         dval = (self.values[-1]-self.values[0])
         if dval == 0.:
             dval = 1.
 
-        for curval in self.values:
-            pos.append((curval-self.values[0])/dval*256.)
-            txt.append("{0:.3f}".format(curval))
+        if self.interval_cst:
+            discrete_cmap = ListedColormap(self.colorsflt[:, :3])
+            ax.imshow(gradient, aspect='auto', cmap=discrete_cmap)
+
+            for idx, curval in enumerate(self.values):
+                pos.append(idx/self.nb*256.)
+                txt.append("{0:.3f}".format(curval))
+        else:
+            ax.imshow(gradient, aspect='auto', cmap=self)
+
+            for curval in self.values:
+                pos.append((curval-self.values[0])/dval*256.)
+                txt.append("{0:.3f}".format(curval))
 
+        ax.set_yticklabels([])
         ax.set_xticks(pos)
         ax.set_xticklabels(txt, rotation=30, fontsize=6)
 
     def fillgrid(self, gridto: CpGrid):
+        """ Remplissage d'une grille avec les valeurs de la palette """
+
         gridto.SetColLabelValue(0, 'Value')
         gridto.SetColLabelValue(1, 'R')
         gridto.SetColLabelValue(2, 'G')
@@ -344,6 +413,8 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
             k += 1
 
     def updatefromgrid(self, gridfrom: CpGrid):
+        """ Mise à jour de la palette sur base d'une grille """
+
         nbl = gridfrom.GetNumberRows()
 
         for i in range(nbl):

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 1
-        self.patch = 92
+        self.patch = 93
 
     def __str__(self):
 

wolfhece/pybridges.py

@@ -35,7 +35,7 @@ class stored_values_unk(Enum):
     WATERLEVEL = (7, views_2D.WATERLEVEL.value)
     WATERSTAGE = (7, views_2D.WATERLEVEL.value)
     TOPOGRAPHY = (8, views_2D.TOPOGRAPHY.value)
-    HEAD       = (-1, _('Difference of waterlevel (up-down)'))
+    HEAD       = (-1, views_2D.HEAD.value)
     DIFFERENCE_Z_UP_DOWN    = (-1, _('Difference of waterlevel (up-down)'))
     DIFFERENCE_HEAD_UP_DOWN = (-1, _('Difference of head  (up-down)'))
 

wolfhece/pypolygons_scen.py

@@ -392,16 +392,25 @@ class Polygons_Analyze(Zones):
         self.linked:Union[dict,list] = None # type is depending on the type of linked arrays
         self.river_values:dict = None
 
+        # The riverbed axis is the second vector of the first zone
         self.riverbed = self.get_zone(0).myvectors[1]
         self.riverbed.prepare_shapely()
 
         self.polygons_zone:zone
         self.polygons_zone = self.get_zone(-1)
 
+        # The curvilinear distance of the polygons is stored in the 'z' attribute of the vertices
         self.polygons_curvi = {}
         for curvert in self.polygons_zone.myvectors:
             self.polygons_curvi[curvert.myname] = curvert.myvertices[0].z
 
+        # The mean center of the polygons
+        self.polygons_meanxy = {}
+        for curvert in self.polygons_zone.myvectors:
+            # Centre du polygone
+            centroid = curvert.asshapely_pol().centroid
+            self.polygons_meanxy[curvert.myname] = (centroid.x, centroid.y)
+
         for vec in self.polygons_zone.myvectors:
             vec.myprop.used=False # cache les polygones pour ne pas surcharger l'affichage éventuel
 
@@ -495,7 +504,9 @@ class Polygons_Analyze(Zones):
                         locdict = self.river_values[curproj][curpoly][curgroup] = {}
 
                         for cursim, curnparray in curarray.items():
-                            locdict[cursim] = np.array([np.array([ tuple(lst1), np.array(lst2, dtype= np.int32)], dtype=object ) for lst1, lst2 in curnparray], dtype=object)
+                            vals = curnparray[0]
+                            xy   = curnparray[1]
+                            locdict[cursim] = (np.array([np.array([ tuple(lst1), np.array(lst2, dtype= np.int32)], dtype=object ) for lst1, lst2 in vals], dtype=object), np.array(xy))
 
         elif isinstance(tmp_linked, list):
             self.linked = [(curlink[0], Wolfresults_2D if curlink[1] == 'CPU' else wolfres2DGPU) for curlink in tmp_linked]
@@ -508,7 +519,9 @@ class Polygons_Analyze(Zones):
                         locdict = self.river_values[curpoly][curgroup] = {}
 
                         for cursim, curnparray in curarray.items():
-                            locdict[cursim] = np.array([np.array([ tuple(lst1), np.array(lst2, dtype= np.int32)], dtype=object ) for lst1, lst2 in curnparray], dtype=object)
+                            vals = curnparray[0]
+                            xy   = curnparray[1]
+                            locdict[cursim] = (np.array([np.array([ tuple(lst1), np.array(lst2, dtype= np.int32)], dtype=object ) for lst1, lst2 in vals], dtype=object), np.array(xy))
 
 
     def compute_distance(self, poly:LineString | vector):
@@ -523,10 +536,8 @@ class Polygons_Analyze(Zones):
 
         for curvert in self.polygons_zone.myvectors:
             # Centre du polygone
-            centerx = np.sum(np.asarray([cur.x for cur in curvert.myvertices[:4]]))/4.
-            centery = np.sum(np.asarray([cur.y for cur in curvert.myvertices[:4]]))/4.
-
-            self.polygons_curvi[curvert.myname] = poly.project(Point([centerx,centery]))
+            centroid = curvert.asshapely_pol().centroid
+            self.polygons_curvi[curvert.myname] = poly.project(Point([centroid.x, centroid.y]))
 
     def find_values_inside_parts(self, linked_arrays:Union[dict,list]):
         """
@@ -560,11 +571,11 @@ class Polygons_Analyze(Zones):
             if isinstance(linked_arrays, dict):
                 self.river_values={}
                 for curkey, curgroup in linked_arrays.items():
-                    self.river_values[curkey] = curzone.get_all_values_linked_polygon(curgroup, key_idx_names='name')
+                    self.river_values[curkey] = curzone.get_all_values_linked_polygon(curgroup, key_idx_names='name', getxy=True)
 
             elif isinstance(linked_arrays, list):
 
-                self.river_values = curzone.get_all_values_linked_polygon(linked_arrays, key_idx_names='name')
+                self.river_values = curzone.get_all_values_linked_polygon(linked_arrays, key_idx_names='name', getxy=True)
 
     def _get_river_heads(self, which_group= None):
         """Compute Head
@@ -586,7 +597,9 @@ class Polygons_Analyze(Zones):
         return head
 
     def get_river_values(self,
-                         which_value:Union[stored_values_unk,stored_values_pos],
+                         which_value:Union[stored_values_unk,
+                                           stored_values_pos,
+                                           stored_values_coords],
                          which_group=None) -> dict:
         """
         Get values for the river polygons
@@ -619,15 +632,35 @@ class Polygons_Analyze(Zones):
 
                 create=False
                 for curarray in curarrays.values():
-                    if len(curarray)>0:
-                        create=True
+                    # if len(curarray)>0:
+                    #     create=True
+                    if isinstance(curarray, tuple):
+                        # on a également repris les coordonnées
+                        if len(curarray[0])>0:
+                            create=True
+                    else:
+                        if len(curarray)>0:
+                            create=True
 
                 if create:
                     for idarray, curarray in enumerate(curarrays.values()):
-                        if len(curarray)>0:
-                            vallist = [curval[pos1][pos2] for curval in curarray]
-                            curdict[part_names[idarray][0]] = vallist
-
+                        # if len(curarray)>0:
+                        #     vallist = [curval[pos1][pos2] for curval in curarray]
+                        #     curdict[part_names[idarray][0]] = vallist
+
+                        if isinstance(curarray, tuple):
+                            if pos1==-1:
+                                if len(curarray[1])>0:
+                                    vallist = [curval[pos2] for curval in curarray[1]]
+                                    curdict[part_names[idarray][0]] = vallist
+                            else:
+                                if len(curarray[0])>0:
+                                    vallist = [curval[pos1][pos2] for curval in curarray[0]]
+                                    curdict[part_names[idarray][0]] = vallist
+                        else:
+                            if len(curarray)>0:
+                                vallist = [curval[pos1][pos2] for curval in curarray]
+                                curdict[part_names[idarray][0]] = vallist
             return locvalues
 
         if isinstance(self.linked, dict):
@@ -641,6 +674,9 @@ class Polygons_Analyze(Zones):
                 elif which_value in stored_values_pos:
                     values = fillin(1, which_value.value[0], self.river_values[which_group], self.linked[which_group])
                     return values
+                elif which_value in stored_values_coords:
+                    values = fillin(-1, which_value.value[0], self.river_values[which_group], self.linked[which_group])
+                    return values
                 else:
                     return None
             else:
@@ -653,6 +689,8 @@ class Polygons_Analyze(Zones):
                             values[curkey] = fillin(0, which_value.value[0], curgroup, curnames)
                     elif which_value in stored_values_pos:
                         values[curkey] = fillin(1, which_value.value[0], curgroup, curnames)
+                    elif which_value in stored_values_coords:
+                        values[curkey] = fillin(-1, which_value.value[0], curgroup, curnames)
                 return values
         else:
             if which_value in stored_values_unk:
@@ -666,11 +704,15 @@ class Polygons_Analyze(Zones):
             elif which_value in stored_values_pos:
                 values = fillin(1, which_value.value[0], self.river_values, self.linked)
                 return values
+            elif which_value in stored_values_coords:
+                values = fillin(-1, which_value.value[0], self.river_values, self.linked)
             else:
                 return None
 
     def get_river_values_op(self,
-                            which_value:Union[stored_values_unk,stored_values_pos],
+                            which_value:Union[stored_values_unk,
+                                              stored_values_pos,
+                                              stored_values_coords],
                             which_group=None,
                             operator:operators=operators.MEDIAN) -> dict:
         """
@@ -741,10 +783,13 @@ class Polygons_Analyze(Zones):
             return ret
 
     def get_s_values(self,
-                     which_value:Union[stored_values_unk,stored_values_pos]=stored_values_unk.WATERLEVEL,
+                     which_value:Union[stored_values_unk,
+                                       stored_values_pos,
+                                       stored_values_coords]=stored_values_unk.WATERLEVEL,
                      which_group:str=None,
                      which_sim:str=None,
                      operator:operators=operators.MEDIAN):
+
         """ Get the values of the river polygons for a specific simulation
 
         :param which_value: value to get
@@ -763,6 +808,10 @@ class Polygons_Analyze(Zones):
                 val.append(curval[which_sim])
                 s.append(self.polygons_curvi[curkey])
 
+        if len(s) != len(val):
+            logging.error(_('Error in get_s_values'))
+            return [], []
+
         # Tri des valeurs selon l'absisse curviligne
         ret = sorted(zip(s, val))
 
@@ -771,6 +820,97 @@ class Polygons_Analyze(Zones):
 
         return s, val
 
+    def get_s_xy(self):
+        """ Get the centroids of the river polygons """
+
+        s = []
+        x = []
+        y = []
+
+        for curval in self.polygons_curvi.values():
+            s.append(curval)
+
+        for curval in self.polygons_meanxy.values():
+            x.append(curval[0])
+            y.append(curval[1])
+
+        if len(s) != len(x) or len(s) != len(y):
+            logging.error(_('Error in get_s_centroidsxy'))
+            return [], [], []
+
+        # Tri des valeurs selon l'absisse curviligne
+        ret = sorted(zip(s, x, y))
+
+        # Séparation des listes triées
+        s, x, y = zip(*ret)
+
+        return s, x, y
+
+    def get_s_xy4sim(self, which_group:str, which_sim:str, operator:operators=operators.MEDIAN):
+        """ Get the position for a specific simulation """
+
+        s1, x = self.get_s_values(which_value= stored_values_coords.X, which_group= which_group, which_sim= which_sim, operator= operator)
+        s2, y = self.get_s_values(which_value= stored_values_coords.Y, which_group= which_group, which_sim= which_sim, operator= operator)
+
+        assert s1 == s2, _('Error in get_s_xy4sim')
+
+        return s1, x, y
+
+    def save_xy_s_tofile(self, outputfile:str):
+        """ Save the centroids of the river polygons to a file """
+
+        s, x, y = self.get_s_xy()
+
+        with open(outputfile, 'w') as f:
+            f.write('x,y,s\n')
+            for curs, curx, cury in zip(s, x, y):
+                f.write('{0},{1},{2}\n'.format(curx, cury, curs))
+
+    def save_xy_s_tofile_4sim(self, outputfile:str, which_group:str, which_sim:str):
+        """ Save the centroids of the river polygons to a file """
+
+        s, x, y = self.get_s_xy4sim(which_group= which_group, which_sim= which_sim)
+
+        with open(outputfile, 'w') as f:
+            f.write('x,y,s\n')
+            for curs, curx, cury in zip(s, x, y):
+                f.write('{0},{1},{2}\n'.format(curx, cury, curs))
+
+    def export_as(self, outputfile:Path, unks:list[stored_values_unk | stored_values_coords], which_group:str, which_sim:str, operator:operators=operators.MEDIAN):
+        """ Export the values of the river polygons to a file
+
+        :param outputfile: output file (supported formats: csv, xlsx)
+        :param unks: list of values to export
+        :param which_group: group to export
+        :param which_sim: simulation to export
+        :param operator: operator to use for values (coordinates will be exported as MEDIAN)
+        """
+
+        outputfile = Path(outputfile)
+        if not (outputfile.suffix == '.csv' or outputfile.suffix == '.xlsx'):
+            logging.error(_('Unsupported format for export -- Must be csv or xlsx'))
+            return
+
+        import pandas as pd
+
+        s,x,y = self.get_s_xy4sim(which_group, which_sim, operators.MEDIAN)
+
+        vals = {curunk.value[1]:self.get_s_values(which_value= curunk,
+                                                  which_group = which_group,
+                                                  which_sim= which_sim,
+                                                  operator= operator)[1] for curunk in unks}
+
+        cols_names = ['s [m]', 'x centroid [m]', 'y centroid [m]']
+        vals[cols_names[0]] = s
+        vals[cols_names[1]] = x
+        vals[cols_names[2]] = y
+
+        df = pd.DataFrame(vals, columns = [cur for cur in cols_names] + [curunk.value[1] for curunk in unks])
+
+        if outputfile.suffix == '.csv':
+            df.to_csv(outputfile, index=False)
+        elif outputfile.suffix == '.xlsx':
+            df.to_excel(outputfile, index=False)
 
     def plot_unk(self,
                  figax = None,

{wolfhece-2.1.92.dist-info → wolfhece-2.1.93.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.1.92
+Version: 2.1.93
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 License: Copyright (c) 2024 University of Liege. All rights reserved.
 Project-URL: Homepage, https://uee.uliege.be/hece

{wolfhece-2.1.92.dist-info → wolfhece-2.1.93.dist-info}/RECORD

@@ -7,11 +7,11 @@ wolfhece/ManageParams.py,sha256=EeuUI5Vvh9ixCvYf8YShMC1s1Yacc7OxOCN7q81gqiQ,517
 wolfhece/Model1D.py,sha256=SI4oNF_J3MdjiWZoizS8kuRXLMVyymX9dYfYJNVCQVI,476989
 wolfhece/PyConfig.py,sha256=UNtl5UzZ399JqjJT67-4DWaIkv76sc1FiEsSDJpXlL0,10458
 wolfhece/PyCrosssections.py,sha256=FnmM9DWY_SAF2EDH9Gu2PojXNtSTRF4-aYQuAAJXBh4,112771
-wolfhece/PyDraw.py,sha256=-WHY2_slvEwaK2FilmI8oLRcXZGTk2pkBwDt1qd66zY,427847
+wolfhece/PyDraw.py,sha256=KkqxUazcXhenwBVCE69EHd_lt0g9fiX6R4p3IBS2pnI,442172
 wolfhece/PyGui.py,sha256=HY0beOMSp1JEyq8-vfVynzVrmKxvaO_sJSMwlNqCNrg,105289
 wolfhece/PyGuiHydrology.py,sha256=f60E8K9eGTnRq5RDF6yvt-ahf2AYegwQ9t25zZ2Mk1A,14946
 wolfhece/PyHydrographs.py,sha256=jwtSNMMACwarxrtN1UeQYth99UNrhwPx1IGgUwcooHA,3774
-wolfhece/PyPalette.py,sha256=QCzXBnYlv7YfHjpJWyO_8F-uOLOe7O_RbkyrnMYzgM4,28146
+wolfhece/PyPalette.py,sha256=81n1P-olOe4wElTLv-miSDhqvJU_RHcxgfpHt794dSw,31436
 wolfhece/PyParams.py,sha256=6fREK5cUCGw84SDyPvuSzidnX-9BXOX3fve5XBG1K_I,98114
 wolfhece/PyPictures.py,sha256=m1kY0saW6Y9Q0bDCo47lW6XxDkBrbQG-Fd8uVn8G5ic,2514
 wolfhece/PyTranslate.py,sha256=4appkmNeHHZLFmUtaA_k5_5QL-5ymxnbVN4R2OblmtE,622
@@ -38,10 +38,10 @@ wolfhece/ismember.py,sha256=fkLvaH9fhx-p0QrlEzqa6ySO-ios3ysjAgXVXzLgSpY,2482
 wolfhece/multiprojects.py,sha256=Sd6Bl6YP33jlR79A6rvSLu23vq8sqbFYL8lWuVPkEpE,21549
 wolfhece/picc.py,sha256=ueujnw03BQz-nPxKGzfDzZbtruTzvnqd6Gm8lOvBYzw,8802
 wolfhece/pyGui1D.py,sha256=9g7OS3YiKsqy--6y0cBD7x2gaqTTYFXWkxImpgnTA20,121937
-wolfhece/pybridges.py,sha256=xbZPuX40c4EKqws4OKNbUVUBPKIzLTbSdYVyrNf_kIE,57418
+wolfhece/pybridges.py,sha256=EU_r6yRYDf5zKmwwXEBsGYvTKFbSfE3iTxPwusKR-1I,57398
 wolfhece/pydike.py,sha256=hPBQsmSTW4QAp1wcOzb-TL3L7eet2WT1sJx2q-WNQ-Q,2241
 wolfhece/pylogging.py,sha256=4TI8hgBB65z-zpvU5Rfa2jkPXPhJaqXjHVPwbcdzTNc,4528
-wolfhece/pypolygons_scen.py,sha256=C0qxVUsBHWZVkurZV-DI1GMN1J1B-ul93n2fs16UjoI,39718
+wolfhece/pypolygons_scen.py,sha256=vMfAKXKrW6vKR7l9Fl2hEt-jihLwIiMur7qNTNfwRg4,46101
 wolfhece/pyshields.py,sha256=6YncgmcA6QvbyIl4jbFRf24uJVjhiSplQKWtZH42lXI,24108
 wolfhece/pyviews.py,sha256=5Hqqo9MRw1eiomYkmc7QywNu1KmEkytLJG-wH_aG38Y,13748
 wolfhece/pywalous.py,sha256=yRaWJjKckXef1d9D5devP0yFHC9uc6kRV4G5x9PNq9k,18972
@@ -75,7 +75,7 @@ wolfhece/apps/curvedigitizer.py,sha256=Yps4bcayzbsz0AoVc_dkSk35dEhhn_esIBy1Ziefg
 wolfhece/apps/hydrometry.py,sha256=lhhJsFeb4zGL4bNQTs0co85OQ_6ssL1Oy0OUJCzhfYE,656
 wolfhece/apps/isocurrent.py,sha256=dagmGR8ja9QQ1gwz_8fU-N052hIw-W0mWGVkzLu6C7I,4247
 wolfhece/apps/splashscreen.py,sha256=SrustmIQeXnsiD-92OzjdGhBi-S7c_j-cSvuX4T6rtg,2929
-wolfhece/apps/version.py,sha256=_TUgNtGFMedLigBPzswBYH6ZQUUs5BrsfxgN7xUDxWI,388
+wolfhece/apps/version.py,sha256=uhn_xV3CTGZbQdI3Z2ZnOh4S6W8nowYt7Tj4x2XrHlo,388
 wolfhece/apps/wolf.py,sha256=j_CgvsL8rwixbVvVD5Z0s7m7cHZ86gmFLojKGuetMls,729
 wolfhece/apps/wolf2D.py,sha256=4z_OPQ3IgaLtjexjMKX9ppvqEYyjFLt1hcfFABy3-jU,703
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -285,8 +285,8 @@ wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=8PlMYrb_8jI8h9F0_EagpM
 wolfhece/ui/wolf_times_selection_comparison_models.py,sha256=ORy7fz4dcp691qKzaOZHrRLZ0uXNhL-LIHxmpDGL6BI,5007
 wolfhece/wintab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/wintab/wintab.py,sha256=8A-JNONV6ujgsgG3lM5Uw-pVgglPATwKs86oBzzljoc,7179
-wolfhece-2.1.92.dist-info/METADATA,sha256=B4LcZnRdMaSUQCv2aRIMVjVyH07wlmRL60l-8kWXXck,2548
-wolfhece-2.1.92.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
-wolfhece-2.1.92.dist-info/entry_points.txt,sha256=ZZ-aSfbpdcmo-wo84lRFzBN7LaSnD1XRGSaAKVX-Gpc,522
-wolfhece-2.1.92.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.1.92.dist-info/RECORD,,
+wolfhece-2.1.93.dist-info/METADATA,sha256=Rws7W6QN1NdDV2S30eXAeX-vTVauNTaWIzCTfEzkOpk,2548
+wolfhece-2.1.93.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+wolfhece-2.1.93.dist-info/entry_points.txt,sha256=ZZ-aSfbpdcmo-wo84lRFzBN7LaSnD1XRGSaAKVX-Gpc,522
+wolfhece-2.1.93.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.1.93.dist-info/RECORD,,

{wolfhece-2.1.92.dist-info → wolfhece-2.1.93.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.0.0)
+Generator: setuptools (75.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any