wolfhece 2.1.82__py3-none-any.whl → 2.1.84__py3-none-any.whl

wolfhece/PyConfig.py

@@ -27,6 +27,8 @@ class ConfigurationKeys(Enum):
     TICKS_SIZE = "TicksSize"
     TICKS_BOUNDS = "TicksBounds"
     COLOR_BACKGROUND = "ColorBackground"
+    ACTIVE_ARRAY_PALETTE_FOR_IMAGE = "Use active array palette for image"
+    ACTIVE_RES2D_PALETTE_FOR_IMAGE = "Use active result palette for image"
 
 class WolfConfiguration:
     """ Holds the PyWolf configuration.
@@ -66,6 +68,8 @@ class WolfConfiguration:
             ConfigurationKeys.VERSION.value: 1,
             ConfigurationKeys.PLAY_WELCOME_SOUND.value: True,
             ConfigurationKeys.TICKS_SIZE.value: 500.,
+            ConfigurationKeys.ACTIVE_ARRAY_PALETTE_FOR_IMAGE.value: True,
+            ConfigurationKeys.ACTIVE_RES2D_PALETTE_FOR_IMAGE.value: False,
             ConfigurationKeys.TICKS_BOUNDS.value: True,
             ConfigurationKeys.COLOR_BACKGROUND.value: [255, 255, 255, 255]
         }
@@ -73,6 +77,8 @@ class WolfConfiguration:
             ConfigurationKeys.VERSION.value: int,
             ConfigurationKeys.PLAY_WELCOME_SOUND.value: bool,
             ConfigurationKeys.TICKS_SIZE.value: float,
+            ConfigurationKeys.ACTIVE_ARRAY_PALETTE_FOR_IMAGE.value: bool,
+            ConfigurationKeys.ACTIVE_RES2D_PALETTE_FOR_IMAGE.value: bool,
             ConfigurationKeys.TICKS_BOUNDS.value: bool,
             ConfigurationKeys.COLOR_BACKGROUND.value: list
         }
@@ -116,12 +122,13 @@ class WolfConfiguration:
 
 
 class GlobalOptionsDialog(wx.Dialog):
+    """ A dialog to set global options for a WolfMapViewer. """
 
     def __init__(self, *args, **kw):
         super(GlobalOptionsDialog, self).__init__(*args, **kw)
 
         self.InitUI()
-        self.SetSize((400, 200))
+        self.SetSize((400, 300))
         self.SetTitle(_("Global options"))
 
     def push_configuration(self, configuration):
@@ -129,12 +136,16 @@ class GlobalOptionsDialog(wx.Dialog):
         self.cfg_ticks_size.SetValue(str(configuration[ConfigurationKeys.TICKS_SIZE]))
         self.cfg_ticks_bounds.SetValue(configuration[ConfigurationKeys.TICKS_BOUNDS])
         self.cfg_bkg_color.SetColour(configuration[ConfigurationKeys.COLOR_BACKGROUND])
+        self.cfg_active_array_pal.SetValue(configuration[ConfigurationKeys.ACTIVE_ARRAY_PALETTE_FOR_IMAGE])
+        self.cfg_active_res_pal.SetValue(configuration[ConfigurationKeys.ACTIVE_RES2D_PALETTE_FOR_IMAGE])
 
     def pull_configuration(self, configuration):
         configuration[ConfigurationKeys.PLAY_WELCOME_SOUND] = self.cfg_welcome_voice.IsChecked()
         configuration[ConfigurationKeys.TICKS_SIZE] = float(self.cfg_ticks_size.Value)
         configuration[ConfigurationKeys.TICKS_BOUNDS] = self.cfg_ticks_bounds.IsChecked()
         configuration[ConfigurationKeys.COLOR_BACKGROUND] = list(self.cfg_bkg_color.GetColour())
+        configuration[ConfigurationKeys.ACTIVE_ARRAY_PALETTE_FOR_IMAGE] = self.cfg_active_array_pal.IsChecked()
+        configuration[ConfigurationKeys.ACTIVE_RES2D_PALETTE_FOR_IMAGE] = self.cfg_active_res_pal.IsChecked()
 
     def InitUI(self):
 
@@ -147,13 +158,26 @@ class GlobalOptionsDialog(wx.Dialog):
         sbs = wx.StaticBoxSizer(sb , orient=wx.VERTICAL)
 
         self.cfg_welcome_voice = wx.CheckBox(pnl, label=_('Welcome voice'))
+        self.cfg_welcome_voice.SetToolTip(_('Play a welcome message when opening the application'))
         sbs.Add(self.cfg_welcome_voice)
 
+        sbs.AddSpacer(5)
+
+        hsizer = wx.BoxSizer(wx.HORIZONTAL)
+        self.label_background_color = wx.StaticText(pnl, label=_('Background color'))
         self.cfg_bkg_color = wx.ColourPickerCtrl(pnl, colour=(255,255,255,255))
-        sbs.Add(self.cfg_bkg_color)
+        self.cfg_bkg_color.SetToolTip(_('Background color for the viewer'))
+
+        hsizer.Add(self.label_background_color, 1, wx.EXPAND)
+        hsizer.Add(self.cfg_bkg_color, 1, wx.EXPAND)
+
+        sbs.Add(hsizer, 1, wx.EXPAND)
+
+        sbs.AddSpacer(5)
 
         pnl.SetSizer(sbs)
         pnl.Layout()
+
         vbox.Add(pnl, proportion=1, flag=wx.ALL|wx.EXPAND, border=5)
 
         ### Panel 'Copy to clipboard'
@@ -163,19 +187,29 @@ class GlobalOptionsDialog(wx.Dialog):
         sbs = wx.StaticBoxSizer(sb, orient=wx.VERTICAL)
 
         hboxticks = wx.BoxSizer(wx.HORIZONTAL)
-        self.label_ticks_size = wx.StaticText(pnl, label=_('Default ticks size for copy to clipboard'))
+        self.label_ticks_size = wx.StaticText(pnl, label=_('Default ticks size [m]'))
         self.cfg_ticks_size = wx.TextCtrl(pnl, value='500.',style = wx.TE_CENTRE )
+
         hboxticks.Add(self.label_ticks_size, 1, wx.EXPAND)
-        hboxticks.AddSpacer(5)
-        hboxticks.Add(self.cfg_ticks_size, 0, wx.EXPAND)
+        hboxticks.Add(self.cfg_ticks_size, 1, wx.EXPAND)
 
         sbs.Add(hboxticks, 1, wx.EXPAND)
 
         self.cfg_ticks_bounds = wx.CheckBox(pnl, label=_('Add bounds to ticks'))
+        self.cfg_ticks_bounds.SetToolTip(_('If not checked, the extreme values of the ticks will not be displayed'))
         sbs.Add(self.cfg_ticks_bounds, 1, wx.EXPAND, 5)
 
+        self.cfg_active_array_pal = wx.CheckBox(pnl, label=_('Use active array palette for image'))
+        self.cfg_active_array_pal.SetToolTip(_('If checked, the active array palette will be used for the image'))
+        sbs.Add(self.cfg_active_array_pal, 1, wx.EXPAND, 5)
+
+        self.cfg_active_res_pal = wx.CheckBox(pnl, label=_('Use active result palette for image'))
+        self.cfg_active_res_pal.SetToolTip(_('If checked, the active result palette will be used for the image (but priority to active array palette if checked)'))
+        sbs.Add(self.cfg_active_res_pal, 1, wx.EXPAND, 5)
+
         pnl.SetSizer(sbs)
         pnl.Layout()
+
         vbox.Add(pnl, proportion=1, flag=wx.ALL|wx.EXPAND, border=5)
 
         # Buttons

wolfhece/PyDraw.py

@@ -2059,6 +2059,34 @@ class WolfMapViewer(wx.Frame):
         else:
             return config[ConfigurationKeys.TICKS_BOUNDS]
 
+    @property
+    def palette_for_copy(self) -> wolfpalette:
+        """ Return the palette for copy from configs """
+
+        config = self.get_configuration()
+        if config is None:
+            if self.active_array is not None:
+                return self.active_array.palette
+            elif self.active_res2d is not None:
+                return self.active_res2d.palette
+            else:
+                return wolfpalette()
+        else:
+            act_array = config[ConfigurationKeys.ACTIVE_ARRAY_PALETTE_FOR_IMAGE]
+            act_res2d = config[ConfigurationKeys.ACTIVE_RES2D_PALETTE_FOR_IMAGE]
+
+            if act_array:
+                if self.active_array is not None:
+                    return self.active_array.mypal
+                else:
+                    return wolfpalette()
+            elif act_res2d:
+                if self.active_res2d is not None:
+                    return self.active_res2d.mypal
+                else:
+                    return wolfpalette()
+            else:
+                return wolfpalette()
 
     def GlobalOptionsDialog(self, event):
         handle_configuration_dialog(self, self.get_configuration())
@@ -2191,29 +2219,33 @@ class WolfMapViewer(wx.Frame):
 
             self.active_array.compare_tri(self.active_tri)
 
-    def copy_canvasogl(self, mpl=True, ds=0., figsizes=[10.,10.], palette:wolfpalette = None):
+    def copy_canvasogl(self, mpl:bool= True, ds:float= 0., figsizes= [10.,10.], palette:wolfpalette = None):
         """
-
         Generate image based on UI context and copy to the Clipboard
 
-        Args:
-            mpl (bool, optional): Using Matplolib as renderer. Defaults to True.
-            ds (float, optional): Ticks size. Defaults to 0..
-            figsizes : fig size in inches
+        :param mpl: Using Matplolib as renderer. Defaults to True.
+        :type mpl: bool, optional
+        :parem ds: Ticks size. Defaults to 0..
+        :type ds: float, optional
+        :parem figsizes: fig size in inches
+        :type figsizes: list, optional
         """
+
         if wx.TheClipboard.Open():
             self.Paint()
 
             if self.SetCurrentContext():
 
-                # Récupération  du buffer OpenGL
-                glPixelStorei(GL_PACK_ALIGNMENT, 1)
-                data = glReadPixels(0, 0, self.canvaswidth, self.canvasheight, GL_RGBA, GL_UNSIGNED_BYTE)
-                # Création d'une image sur base du buffer
-                myimage: Image.Image
-                myimage = Image.frombuffer("RGBA", (self.canvaswidth, self.canvasheight), data)
-                # On tranpose car OpenGL travaille avec comme référence le coin inférieur gauche
-                myimage = myimage.transpose(1)
+                myimage = self.get_canvas_as_image()
+
+                # # Récupération  du buffer OpenGL
+                # glPixelStorei(GL_PACK_ALIGNMENT, 1)
+                # data = glReadPixels(0, 0, self.canvaswidth, self.canvasheight, GL_RGBA, GL_UNSIGNED_BYTE)
+                # # Création d'une image sur base du buffer
+                # myimage: Image.Image
+                # myimage = Image.frombuffer("RGBA", (self.canvaswidth, self.canvasheight), data)
+                # # On tranpose car OpenGL travaille avec comme référence le coin inférieur gauche
+                # myimage = myimage.transpose(1)
 
                 metadata = PngInfo()
                 metadata.add_text('xmin', str(self.xmin))
@@ -2223,20 +2255,17 @@ class WolfMapViewer(wx.Frame):
 
                 if mpl:
                     if ds == 0.:
-                        ds = self.ticks_size
-                        # dlg = wx.NumberEntryDialog(self,
-                        #                         _("xmin : {:.3f} \nxmax : {:.3f} \nymin : {:.3f} \nymax : {:.3f} \n\n  dx : {:.3f}\n  dy : {:.3f}").format(
-                        #                             self.xmin, self.xmax, self.ymin, self.ymax, self.xmax - self.xmin,
-                        #                             self.ymax - self.ymin),
-                        #                         _("Interval [m]"), _("Ticks interval ?"), 500, 1, 10000)
-                        # ret = dlg.ShowModal()
+                        ds = self.ticks_size # Global parameters
 
-                        # if ret == wx.ID_CANCEL:
-                        #     dlg.Destroy()
-                        #     return
+                        if ds == 0.:
+                            ds = 100.
 
-                        # ds = float(dlg.GetValue())
-                        # dlg.Destroy()
+                        nb_ticks_x = (self.xmax - self.xmin) // ds
+                        nb_ticks_y = (self.ymax - self.ymin) // ds
+
+                        if nb_ticks_x > 10 or nb_ticks_y > 10:
+                            logging.error(_('Too many ticks for the image. Please raise the ticks size in the global options.'))
+                            return
 
                     # Création d'une graphique Matplotlib
                     extent = (self.xmin, self.xmax, self.ymin, self.ymax)
@@ -2253,7 +2282,6 @@ class WolfMapViewer(wx.Frame):
                     pos = ax.imshow(myimage,
                                     origin='upper',
                                     extent=extent)
-                    # fig.colorbar(pos,ax=ax)
 
                     x1 = np.ceil((self.xmin // ds) * ds)
                     if x1 < self.xmin:
@@ -2301,10 +2329,11 @@ class WolfMapViewer(wx.Frame):
                     im = Image.open(buf)
 
                     if palette is None:
-                        if self.active_array is not None:
-                            palette = self.active_array.mypal
-                        elif self.active_res2d is not None:
-                            palette = self.active_res2d.mypal
+                        palette = self.palette_for_copy
+                        # if self.active_array is not None:
+                        #     palette = self.active_array.mypal
+                        # elif self.active_res2d is not None:
+                        #     palette = self.active_res2d.mypal
 
                     if palette is not None:
                         bufpal = io.BytesIO()
@@ -2360,6 +2389,7 @@ class WolfMapViewer(wx.Frame):
         This method takes a matplotlib figure and axe and,
         returns a clear screenshot of the information displayed in the wolfpy GUI.
         """
+
         self.Paint()
         myax = ax
         if redraw:
@@ -2431,18 +2461,21 @@ class WolfMapViewer(wx.Frame):
 
     def get_mpl_plot(self, center = [0., 0.], width = 500., height = 500., title='', toshow=True) -> tuple[Figure, Axes]:
         """
-        Récupère un graphique matplotlib sur base de la fenêtre OpenGL et de la palette de la matrice active
+        Récupère un graphique matplotlib sur base de la fenêtre OpenGL et de la palette de la matrice/résultat actif.
         """
-        self.zoom_on(center=center, width=width, height= height, canvas_height=self.canvasheight, forceupdate=True)
 
+        self.zoom_on(center=center, width=width, height= height, canvas_height=self.canvasheight, forceupdate=True)
 
         fig,axes = plt.subplots(1,2, gridspec_kw={'width_ratios': [20, 1]})
         self.display_canvasogl(fig=fig,ax=axes[0])
 
-        if self.active_array is not None:
-            self.active_array.mypal.export_image(None, h_or_v='v', figax=(fig,axes[1]))
-        elif self.active_res2d is not None:
-            self.active_res2d.mypal.export_image(None, h_or_v='v', figax=(fig,axes[1]))
+        palette = self.palette_for_copy
+        palette.export_image(None, h_or_v='v', figax=(fig,axes[1]))
+
+        # if self.active_array is not None:
+        #     self.active_array.mypal.export_image(None, h_or_v='v', figax=(fig,axes[1]))
+        # elif self.active_res2d is not None:
+        #     self.active_res2d.mypal.export_image(None, h_or_v='v', figax=(fig,axes[1]))
 
         axes[0].xaxis.set_ticks_position('bottom')
         axes[0].xaxis.set_label_position('bottom')
@@ -2594,17 +2627,16 @@ class WolfMapViewer(wx.Frame):
 
             return myimage
 
-    def save_canvasogl(self, fn:str='', mpl:bool=True, ds:float=0.):
+    def save_canvasogl(self, fn:str='', mpl:bool=True, ds:float=0., dpi:int= 300):
         """
         Sauvegarde de la fenêtre d'affichage dans un fichier
 
-        fn : File name (.png file)
+        :param fn: File name (.png or .jpg file)
+        :param mpl: Using Matplotlib as renderer
+        :param ds: Ticks interval
         """
 
-        if not fn.endswith('.png'):
-            fn += '.png'
-
-        self.Paint()
+        fn = str(fn)
 
         if fn == '':
             dlg = wx.FileDialog(None, _('Choose file name'), wildcard='PNG (*.png)|*.png|JPG (*.jpg)|*.jpg',
@@ -2615,13 +2647,17 @@ class WolfMapViewer(wx.Frame):
                 return
             fn = dlg.GetPath()
             dlg.Destroy()
+        elif not fn.endswith('.png'):
+            fn += '.png'
 
         if self.SetCurrentContext():
-            glPixelStorei(GL_PACK_ALIGNMENT, 1)
-            data = glReadPixels(0, 0, self.canvaswidth, self.canvasheight, GL_RGBA, GL_UNSIGNED_BYTE)
-            myimage: Image.Image
-            myimage = Image.frombuffer("RGBA", (self.canvaswidth, self.canvasheight), data)
-            myimage = myimage.transpose(1)
+            # glPixelStorei(GL_PACK_ALIGNMENT, 1)
+            # data = glReadPixels(0, 0, self.canvaswidth, self.canvasheight, GL_RGBA, GL_UNSIGNED_BYTE)
+            # myimage: Image.Image
+            # myimage = Image.frombuffer("RGBA", (self.canvaswidth, self.canvasheight), data)
+            # myimage = myimage.transpose(1)
+
+            myimage = self.get_canvas_as_image()
 
             metadata = PngInfo()
             metadata.add_text('xmin', str(self.xmin))
@@ -2646,9 +2682,14 @@ class WolfMapViewer(wx.Frame):
                     dlg.Destroy()
 
                 extent = (self.xmin, self.xmax, self.ymin, self.ymax)
-                fig, ax = plt.subplots(1, 1)
-                pos = ax.imshow(myimage, origin='upper',
-                          extent=extent)
+                # fig, ax = plt.subplots(1, 1)
+                fig,axes = plt.subplots(1,2, gridspec_kw={'width_ratios': [20, 1]})
+
+                ax = axes[0]
+                self.display_canvasogl(fig=fig,ax=axes[0])
+
+                # pos = ax.imshow(myimage, origin='upper',
+                #           extent=extent)
                 # fig.colorbar(pos,ax=ax)
 
                 x1 = np.ceil((self.xmin // ds) * ds)
@@ -2683,7 +2724,19 @@ class WolfMapViewer(wx.Frame):
                 ax.set_xlabel('X [m]')
                 ax.set_ylabel('Y [m]')
 
-                plt.savefig(fn, dpi=300)
+                self.palette_for_copy.export_image(None, h_or_v='v', figax=(fig,axes[1]))
+
+                # if self.active_array is not None:
+                #     self.active_array.mypal.export_image(None, h_or_v='v', figax=(fig,axes[1]))
+                # elif self.active_res2d is not None:
+                #     self.active_res2d.mypal.export_image(None, h_or_v='v', figax=(fig,axes[1]))
+
+                # self.Paint()
+
+                fig.set_size_inches(12, 10)
+                fig.tight_layout()
+
+                fig.savefig(fn, dpi=dpi)
             else:
                 myimage.save(fn, pnginfo=metadata)
 
@@ -2693,6 +2746,9 @@ class WolfMapViewer(wx.Frame):
                 'Opengl setcurrent -- maybe a conflict with an existing opengl32.dll file - please rename the opengl32.dll in the libs directory and retry')
 
     def reporting(self, dir=''):
+        """ Firsdt attempr to create a reporting.
+        !! Must be improved !!
+        """
         if dir == '':
             dlg = wx.DirDialog(None, "Choose directory to store reporting", style=wx.FD_SAVE)
             ret = dlg.ShowModal()
@@ -2736,6 +2792,7 @@ class WolfMapViewer(wx.Frame):
                     curvec.myprop.width = oldwidth
 
     def InitUI(self):
+        """ Initialisation de l'interface utilisateur """
 
         self.Bind(wx.EVT_SIZE, self.OnSize)
         self.Bind(wx.EVT_CLOSE, self.OnClose)
@@ -6134,6 +6191,8 @@ class WolfMapViewer(wx.Frame):
         return linkedarrays
 
     def save_linked_canvas(self, fn, mpl=True, ds=0.):
+        """ Save canvas of all linked viewers """
+
         if self.linked:
             for idx, curel in enumerate(self.linkedList):
                 curel.save_canvasogl(fn + '_' + str(idx) + '.png', mpl, ds)

wolfhece/apps/version.py

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