wolfhece 2.1.90__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
 
@@ -7441,6 +7827,13 @@ class WolfMapViewer(wx.Frame):
             if bc is not None:
                 bc.Show()
 
+        elif text == _('Contours'):
+            if isinstance(self.selected_object, WolfArray):
+                cont = self.selected_object.contour()
+                cont.prep_listogl()
+                self.add_object('vector', newobj= cont, id= cont.idx)
+                self.Paint()
+
         elif _('Convert to mono-block') in text:
 
             if isinstance(self.selected_object, WolfArrayMB):
@@ -9611,6 +10004,7 @@ class WolfMapViewer(wx.Frame):
 
             # Chaînes à supprimer
             tracks=[]
+            tracks.append(_('Contours'))
             tracks.append(_('Boundary conditions'))
             tracks.append(_('Convert to mono-block'))
             tracks.append(_('Convert to mono-block (result)'))
@@ -9641,6 +10035,7 @@ class WolfMapViewer(wx.Frame):
                 bc = self.get_boundary_manager(self.selected_object)
                 if bc is not None:
                     self.popupmenu.Append(wx.ID_ANY, _('Boundary conditions'), _('Boundary conditions'))
+                self.popupmenu.Append(wx.ID_ANY, _('Contours'))
 
             # Add specific menu items for WolfArrayMB
             if isinstance(self.selected_object, WolfArrayMB):

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 = 90
+        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)'))