wolfhece 1.8.13__py3-none-any.whl → 2.0.0__py3-none-any.whl

wolfhece/multiprojects.py

@@ -6,7 +6,7 @@ from typing import Literal
 from concurrent.futures import ThreadPoolExecutor
 import logging
 
-from .PyParams import Wolf_Param
+from .PyParams import Wolf_Param, key_Param
 from .PyVertexvectors import Zones, vector, zone
 from .PyPalette import wolfpalette
 from .PyTranslate import _
@@ -88,7 +88,7 @@ class Wolf2D_Project(Project):
             if verbose:
                 print(key)
 
-            cursim = self.mysims[key] = Wolfresults_2D(join(self.wdir, val['value']), eps=epsilon, idx=key)
+            cursim = self.mysims[key] = Wolfresults_2D(join(self.wdir, val[key_Param.VALUE]), eps=epsilon, idx=key)
             cursim.plotted=True
 
         self.set_vectors()
@@ -125,10 +125,10 @@ class Wolf2D_Project(Project):
         for curkey,curvec in vec.items():
 
             filename=''
-            if exists(curvec['value']):
+            if exists(curvec[key_Param.VALUE]):
                 filename = curvec
-            elif exists(join(self.wdir,curvec['value'])):
-                filename = join(self.wdir,curvec['value'])
+            elif exists(join(self.wdir,curvec[key_Param.VALUE])):
+                filename = join(self.wdir,curvec[key_Param.VALUE])
 
             if filename!='':
                 self.mycontours[curkey] = Zones(filename)
@@ -140,8 +140,8 @@ class Wolf2D_Project(Project):
                 locvec = None
                 cursim = None
 
-                if curname['value'] in self.mycontours.keys():
-                    locvec = self.mycontours[curname['value']]
+                if curname[key_Param.VALUE] in self.mycontours.keys():
+                    locvec = self.mycontours[curname[key_Param.VALUE]]
 
                 if curid in self.mysims.keys():
                     cursim = self.mysims[curid]
@@ -160,10 +160,10 @@ class Wolf2D_Project(Project):
 
         for curid, curname in pals.items():
             filename=''
-            if exists(curname['value']):
-                filename = curname['value']
-            elif exists(join(self.wdir, curname['value'])):
-                filename=join(self.wdir, curname['value'])
+            if exists(curname[key_Param.VALUE]):
+                filename = curname[key_Param.VALUE]
+            elif exists(join(self.wdir, curname[key_Param.VALUE])):
+                filename=join(self.wdir, curname[key_Param.VALUE])
 
             if filename!='':
                 mypal = wolfpalette(None, '')
@@ -175,10 +175,10 @@ class Wolf2D_Project(Project):
         palsarrays = self.get_group('palette-array')
         if palsarrays is not None:
             for curid, curname in palsarrays.items():
-                if curname['value'] in self.set_colormap.keys():
+                if curname[key_Param.VALUE] in self.set_colormap.keys():
                     if curid in self.mysims.keys():
                         curarray = self.mysims[curid]
-                        mypal = self.mycolormaps[curname['value']]
+                        mypal = self.mycolormaps[curname[key_Param.VALUE]]
                         curarray.mypal = mypal
                         curarray.mypal.automatic = False
 

wolfhece/pylogging.py

@@ -58,7 +58,7 @@ def create_wxlogwindow(winTitle='Log') -> wx.LogWindow:
             logging.getLogger().addHandler(log_bridge_handler)
 
             # Set some logging level, just to show up.
-            logging.getLogger().setLevel(logging.DEBUG)
+            logging.getLogger().setLevel(logging.INFO)
             log_bridge_handler.setLevel(logging.INFO)
             wx.Log.SetVerbose(True)
 

wolfhece/pyviews.py

@@ -2,7 +2,7 @@ import logging
 
 from .drawing_obj import Element_To_Draw
 from .wolf_array import WolfArray,WolfArrayMB
-from .PyParams import Wolf_Param
+from .PyParams import Wolf_Param, key_Param, Type_Param
 
 class WolfViews(Element_To_Draw):
 
@@ -24,62 +24,62 @@ class WolfViews(Element_To_Draw):
         #         for curid, curname in zip(myproject.myparams['cross_sections'].keys(),
         #                                 myproject.myparams['cross_sections'].values()):
         #             if curid != 'format' and curid != 'dirlaz':
-        #                 mycs = crosssections(curname['value'],
-        #                                     format=myproject.myparams['cross_sections']['format']['value'],
-        #                                     dirlaz=myproject.myparams['cross_sections']['dirlaz']['value'])
+        #                 mycs = crosssections(curname[key_Param.VALUE],
+        #                                     format=myproject.myparams['cross_sections']['format'][key_Param.VALUE],
+        #                                     dirlaz=myproject.myparams['cross_sections']['dirlaz'][key_Param.VALUE])
 
         #                 self.add_object('cross_sections', newobj=mycs, id=curid)
 
         #     if 'vector' in myproject.myparams.keys():
         #         for curid, curname in zip(myproject.myparams['vector'].keys(), myproject.myparams['vector'].values()):
-        #             if exists(curname['value']):
-        #                 myvec = Zones(curname['value'])
+        #             if exists(curname[key_Param.VALUE]):
+        #                 myvec = Zones(curname[key_Param.VALUE])
         #                 self.add_object('vector', newobj=myvec, id=curid)
         #             else:
-        #                 wx.LogMessage(_('Bad parameter in project file - vector : ')+ curname['value'])
+        #                 wx.LogMessage(_('Bad parameter in project file - vector : ')+ curname[key_Param.VALUE])
 
         #     if 'array' in myproject.myparams.keys():
         #         for curid, curname in zip(myproject.myparams['array'].keys(), myproject.myparams['array'].values()):
 
-        #             if exists(curname['value']):
-        #                 curarray = WolfArray(curname['value'])
+        #             if exists(curname[key_Param.VALUE]):
+        #                 curarray = WolfArray(curname[key_Param.VALUE])
         #                 self.add_object('array', newobj=curarray, id=curid)
         #             else:
-        #                 wx.LogMessage(_('Bad parameter in project file - array : ')+ curname['value'])
+        #                 wx.LogMessage(_('Bad parameter in project file - array : ')+ curname[key_Param.VALUE])
 
 
         #     if 'wolf2d' in myproject.myparams.keys():
         #         for curid, curname in zip(myproject.myparams['wolf2d'].keys(), myproject.myparams['wolf2d'].values()):
-        #             if exists(curname['value']):
-        #                 curwolf = Wolfresults_2D(curname['value'])
+        #             if exists(curname[key_Param.VALUE]):
+        #                 curwolf = Wolfresults_2D(curname[key_Param.VALUE])
         #                 self.add_object('res2d', newobj=curwolf, id=curid)
         #             else:
-        #                 wx.LogMessage(_('Bad parameter in project file - wolf2d : ')+ curname['value'])
+        #                 wx.LogMessage(_('Bad parameter in project file - wolf2d : ')+ curname[key_Param.VALUE])
 
         #         self.menu_wolf2d()
 
         #     if 'palette' in myproject.myparams.keys():
         #         self.project_pal = {}
         #         for curid, curname in zip(myproject.myparams['palette'].keys(), myproject.myparams['palette'].values()):
-        #             if exists(curname['value']):
+        #             if exists(curname[key_Param.VALUE]):
         #                 mypal = wolfpalette(None, '')
-        #                 mypal.readfile(curname['value'])
+        #                 mypal.readfile(curname[key_Param.VALUE])
         #                 mypal.automatic = False
 
         #                 self.project_pal[curid] = mypal
         #             else:
-        #                 wx.LogMessage(_('Bad parameter in project file - palette : ')+ curname['value'])
+        #                 wx.LogMessage(_('Bad parameter in project file - palette : ')+ curname[key_Param.VALUE])
 
         #     if 'palette-array' in myproject.myparams.keys():
         #         curarray: WolfArray
         #         if self.project_pal is not None:
         #             for curid, curname in zip(myproject.myparams['palette-array'].keys(),
         #                                     myproject.myparams['palette-array'].values()):
-        #                 if curname['value'] in self.project_pal.keys():
+        #                 if curname[key_Param.VALUE] in self.project_pal.keys():
         #                     curarray = self.getobj(curid)
         #                     if curarray is not None:
         #                         mypal:wolfpalette
-        #                         mypal = self.project_pal[curname['value']]
+        #                         mypal = self.project_pal[curname[key_Param.VALUE]]
         #                         curarray.mypal = mypal
         #                         if mypal.automatic:
         #                             curarray.myops.palauto.SetValue(1)
@@ -92,7 +92,7 @@ class WolfViews(Element_To_Draw):
 
         #     if 'cross_sections_link' in myproject.myparams.keys():
         #         if 'linkzones' in myproject.myparams['cross_sections_link'].keys():
-        #             idx = myproject.myparams['cross_sections_link']['linkzones']['value']
+        #             idx = myproject.myparams['cross_sections_link']['linkzones'][key_Param.VALUE]
 
         #             for curvect in self.added['vectors']:
         #                 myzones: Zones
@@ -104,9 +104,9 @@ class WolfViews(Element_To_Draw):
         #             vecname = ''
 
         #             if 'sortzone' in myproject.myparams['cross_sections_link'].keys():
-        #                 zonename = myproject.myparams['cross_sections_link']['sortzone']['value']
+        #                 zonename = myproject.myparams['cross_sections_link']['sortzone'][key_Param.VALUE]
         #             if 'sortname' in myproject.myparams['cross_sections_link'].keys():
-        #                 vecname = myproject.myparams['cross_sections_link']['sortname']['value']
+        #                 vecname = myproject.myparams['cross_sections_link']['sortname'][key_Param.VALUE]
 
         #             if zonename != '' and vecname != '':
         #                 names = [cur.myname for cur in myzones.myzones]
@@ -126,7 +126,7 @@ class WolfViews(Element_To_Draw):
         #             locvec = None
         #             locarray = None
         #             for curvec in self.myvectors:
-        #                 if curvec.idx == curname['value'].lower():
+        #                 if curvec.idx == curname[key_Param.VALUE].lower():
         #                     locvec=curvec
         #                     break
 
@@ -143,7 +143,7 @@ class WolfViews(Element_To_Draw):
 
         #                 wx.LogWarning(_('Bad vec-array association in project file !'))
         #                 wx.LogWarning(curid)
-        #                 wx.LogWarning(curname['value'])
+        #                 wx.LogWarning(curname[key_Param.VALUE])
         #     del wait
 
     def change_gui(self, newmapviewer):

wolfhece/wolf_array.py

@@ -404,8 +404,15 @@ class header_wolf():
         if isinstance(filename, Path):
             filename = str(filename)
 
+        if filename.endswith('.tif'):
+            return
+
         if filename.endswith('.flt'):
             # Fichier .flt
+            if not os.path.exists(filename[:-4] + '.hdr'):
+                logging.warning(_('File {} does not exist -- Retry!'.format(filename[:-4] + '.hdr')))
+                return
+
             f = open(filename[:-4] + '.hdr', 'r')
             lines = f.read().splitlines()
             f.close()
@@ -449,7 +456,7 @@ class header_wolf():
 
         else:
             if not os.path.exists(filename + '.txt'):
-                logging.info(_(f'File {os.path.curdir} does not exist -- Retry!'))
+                logging.info(_('File {} does not exist -- Retry!'.format(filename + '.txt')))
                 return
 
             with open(filename + '.txt', 'r') as f:
@@ -513,7 +520,10 @@ class header_wolf():
 
                     self.head_blocks[getkeyblock(i)] = curhead
 
-    def write_txt_header(self,filename,wolftype,forceupdate=False):
+    def write_txt_header(self,
+                         filename:str,
+                         wolftype:int,
+                         forceupdate:bool=False):
         """
         Ecriture du header dans un fichier texte
 
@@ -521,6 +531,9 @@ class header_wolf():
         wolftype : type de la matrice WOLF_ARRAY_*
 
         """
+
+        assert wolftype in [WOLF_ARRAY_CSR_DOUBLE, WOLF_ARRAY_FULL_SINGLE, WOLF_ARRAY_FULL_DOUBLE, WOLF_ARRAY_SYM_DOUBLE, WOLF_ARRAY_FULL_LOGICAL, WOLF_ARRAY_CSR_DOUBLE, WOLF_ARRAY_FULL_INTEGER, WOLF_ARRAY_FULL_SINGLE_3D, WOLF_ARRAY_FULL_INTEGER8, WOLF_ARRAY_MB_SINGLE, WOLF_ARRAY_MB_INTEGER, WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_MNAP_INTEGER]
+
         if not os.path.exists(filename) or forceupdate:
             with open(filename,'w') as f:
 
@@ -1946,6 +1959,7 @@ class SelectionData():
 
     def plot_selection(self):
 
+        update_select = self.update_plot_selection
         if self.myselection != 'all':
             if len(self.myselection) > 0:
                 self.numlist_select = self._plot_selection(self.myselection, (1., 0., 0.), self.numlist_select)
@@ -1953,6 +1967,7 @@ class SelectionData():
         if len(self.selections) > 0:
             for cur in self.selections.values():
                 if cur['select'] != 'all':
+                    self.update_plot_selection = update_select
                     col = cur['color']
                     cur['idgllist'] = self._plot_selection(cur['select'],
                                                            (float(col[0]) / 255., float(col[1]) / 255.,
@@ -4124,7 +4139,7 @@ class WolfArray(Element_To_Draw, header_wolf):
             self.loaded = True
 
         else:
-            self.read_txt_header(self.filename)
+            self.read_txt_header()
             if self.preload:
                 self.read_data()
                 self.loaded = True
@@ -4187,147 +4202,22 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.count()
 
-    # def read_txt_header(self):
-    #     """ Lecture du header .txt """
-    #     if self.filename.endswith('.flt'):
-    #         # Fichier .flt
-    #         f = open(self.filename[:-4] + '.hdr', 'r')
-    #         lines = f.read().splitlines()
-    #         f.close()
-
-    #         for curline in lines:
-    #             if 'NCOLS' in curline.upper():
-    #                 tmp = curline.split(' ')
-    #                 self.nbx = int(tmp[-1])
-    #             elif 'NROWS' in curline.upper():
-    #                 tmp = curline.split(' ')
-    #                 self.nby = int(tmp[-1])
-    #             elif 'XLLCORNER' in curline.upper():
-    #                 tmp = curline.split(' ')
-    #                 self.origx = float(tmp[-1])
-    #             elif 'YLLCORNER' in curline.upper():
-    #                 tmp = curline.split(' ')
-    #                 self.origy = float(tmp[-1])
-    #             elif 'ULXMAP' in curline.upper():
-    #                 tmp = curline.split(' ')
-    #                 self.origx = float(tmp[-1])
-    #                 self.flipupd=True
-    #             elif 'ULYMAP' in curline.upper():
-    #                 tmp = curline.split(' ')
-    #                 self.origy = float(tmp[-1])
-    #                 self.flipupd=True
-    #             elif 'CELLSIZE' in curline.upper():
-    #                 tmp = curline.split(' ')
-    #                 self.dx = self.dy = float(tmp[-1])
-    #             elif 'XDIM' in curline.upper():
-    #                 tmp = curline.split(' ')
-    #                 self.dx = float(tmp[-1])
-    #             elif 'YDIM' in curline.upper():
-    #                 tmp = curline.split(' ')
-    #                 self.dy = float(tmp[-1])
-    #             elif 'NODATA' in curline.upper():
-    #                 tmp = curline.split(' ')
-    #                 self.nullvalue = float(tmp[-1])
-
-    #         if self.flipupd:
-    #             self.origy -= self.dy*float(self.nby)
-
-    #     else:
-    #         if not os.path.exists(self.filename + '.txt'):
-    #             logging.info(_(f'File {os.path.curdir} does not exist -- Retry!'))
-    #             return
-
-    #         with open(self.filename + '.txt', 'r') as f:
-    #             lines = f.read().splitlines()
-
-    #         tmp = lines[0].split(':')
-    #         self.nbx = int(tmp[1])
-    #         tmp = lines[1].split(':')
-    #         self.nby = int(tmp[1])
-    #         tmp = lines[2].split(':')
-    #         self.origx = float(tmp[1])
-    #         tmp = lines[3].split(':')
-    #         self.origy = float(tmp[1])
-    #         tmp = lines[4].split(':')
-    #         self.dx = float(tmp[1])
-    #         tmp = lines[5].split(':')
-    #         self.dy = float(tmp[1])
-    #         tmp = lines[6].split(':')
-    #         self.wolftype = int(tmp[1])
-    #         tmp = lines[7].split(':')
-    #         self.translx = float(tmp[1])
-    #         tmp = lines[8].split(':')
-    #         self.transly = float(tmp[1])
-
-    #         decal = 9
-    #         if self.wolftype == WOLF_ARRAY_FULL_SINGLE_3D:
-    #             self.nbdims = 3
-    #             tmp = lines[9].split(':')
-    #             self.nbz = int(tmp[1])
-    #             tmp = lines[10].split(':')
-    #             self.origz = float(tmp[1])
-    #             tmp = lines[11].split(':')
-    #             self.dz = float(tmp[1])
-    #             tmp = lines[12].split(':')
-    #             self.translz = float(tmp[1])
-    #             decal = 13
-
-    #         if self.wolftype in WOLF_ARRAY_MB:
-    #             tmp = lines[decal].split(':')
-    #             nb_blocks = int(tmp[1])
-
-    #             decal += 1
-    #             for i in range(nb_blocks):
-    #                 curhead = header_wolf()
-    #                 tmp = lines[decal].split(':')
-    #                 curhead.nbx = int(tmp[1])
-    #                 tmp = lines[decal + 1].split(':')
-    #                 curhead.nby = int(tmp[1])
-    #                 tmp = lines[decal + 2].split(':')
-    #                 curhead.origx = float(tmp[1])
-    #                 tmp = lines[decal + 3].split(':')
-    #                 curhead.origy = float(tmp[1])
-    #                 tmp = lines[decal + 4].split(':')
-    #                 curhead.dx = float(tmp[1])
-    #                 tmp = lines[decal + 5].split(':')
-    #                 curhead.dy = float(tmp[1])
-    #                 decal += 6
-
-    #                 curhead.translx = self.translx + self.origx
-    #                 curhead.transly = self.transly + self.origy
-
-    #                 self.head_blocks[getkeyblock(i)] = curhead
-
-    # def write_txt_header(self):
-    #     """ Ecriture de l'en-tête de Wolf array """
-    #     f = open(self.filename + '.txt', 'w')
-    #     f.write('NbX :\t{0}\n'.format(str(self.nbx)))
-    #     f.write('NbY :\t{0}\n'.format(str(self.nby)))
-    #     f.write('OrigX :\t{0}\n'.format(str(self.origx)))
-    #     f.write('OrigY :\t{0}\n'.format(str(self.origy)))
-    #     f.write('DX :\t{0}\n'.format(str(self.dx)))
-    #     f.write('DY :\t{0}\n'.format(str(self.dy)))
-    #     f.write('TypeEnregistrement :\t{0}\n'.format(str(self.wolftype)))
-    #     f.write('TranslX :\t{0}\n'.format(str(self.translx)))
-    #     f.write('TranslY :\t{0}\n'.format(str(self.transly)))
-    #     if self.wolftype == WOLF_ARRAY_FULL_SINGLE_3D:
-    #         f.write('NbZ :\t{0}\n'.format(str(self.nbz)))
-    #         f.write('OrigZ :\t{0}\n'.format(str(self.origz)))
-    #         f.write('DZ :\t{0}\n'.format(str(self.dz)))
-    #         f.write('TranslZ :\t{0}\n'.format(str(self.translz)))
-
-    #     if self.wolftype in WOLF_ARRAY_MB:
-    #         f.write('Nb Blocs :\t{0}\n'.format(str(self.nb_blocks)))
-    #         for i in range(self.nb_blocks):
-    #             curhead = self.head_blocks[getkeyblock(i)]
-    #             f.write('NbX :\t{0}\n'.format(str(curhead.nbx)))
-    #             f.write('NbY :\t{0}\n'.format(str(curhead.nby)))
-    #             f.write('OrigX :\t{0}\n'.format(str(curhead.origx)))
-    #             f.write('OrigY :\t{0}\n'.format(str(curhead.origy)))
-    #             f.write('DX :\t{0}\n'.format(str(curhead.dx)))
-    #             f.write('DY :\t{0}\n'.format(str(curhead.dy)))
-
-    #     f.close()
+    def read_txt_header(self):
+        """
+        Read header from txt file
+        Supercharged by WolfArray to avoid explicit call to read_txt_header with parameters
+        """
+
+        super().read_txt_header(self.filename)
+        
+
+    def write_txt_header(self):
+        """
+        Write header to txt file
+        Supercharged by WolfArray to avoid explicit call to write_txt_header with parameters
+        """
+            
+        super().write_txt_header(self.filename+'.txt', self.wolftype, forceupdate=True)
 
     def read_data(self):
         """Opération de lecture des données depuis le fichier connu"""
@@ -4513,7 +4403,10 @@ class WolfArray(Element_To_Draw, header_wolf):
             # as expected, then we do: self.array.mask.fill(0.0)
             # to avoid replacing the linked mask by a (non linked) one.
 
-            self.array.mask.fill(False) # False == not masked
+            if isinstance(self.array.mask, np.bool_):
+                self.array.mask = np.zeros(self.array.shape)
+            else:
+                self.array.mask.fill(False) # False == not masked
             self.nbnotnull = self.nbx * self.nby
         elif self.nbdims == 3:
             self.array.mask = np.zeros((self.nbx, self.nby, self.nbz))
@@ -4769,7 +4662,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         if self.myops is not None:
             self.myops.update_palette()
 
-    def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None):
+    def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None):
 
         if not self.plotted:
             return
@@ -5132,6 +5025,30 @@ class WolfArray(Element_To_Draw, header_wolf):
         ax.set_yticklabels(y_pos)
 
         return fig,ax
+
+    def set_array_from_numpy(self, array:np.ndarray, nullvalue:float = None):
+        """
+        Set array from numpy array
+        """
+        if array.shape != (self.nbx, self.nby):
+            logging.warning(f"Array shape {array.shape} is not compatible with WolfArray shape {self.nbx, self.nby}")
+            return
+
+        def wolftype_from_npz(curarray:np.ndarray):
+            if curarray.dtype == np.float64:
+                return WOLF_ARRAY_FULL_DOUBLE
+            elif curarray.dtype == np.float32:
+                return WOLF_ARRAY_FULL_SINGLE
+            elif curarray.dtype == np.int32:
+                return WOLF_ARRAY_FULL_INTEGER
+
+        self.array = np.ma.array(array.copy())
+        self.wolftype = wolftype_from_npz(array)
+
+        if nullvalue is not None:
+            self.nullvalue = nullvalue
+        self.mask_data(self.nullvalue)
+        self.reset_plot()
 class WolfArrayMB(WolfArray):
     """
     Matrice multiblocks
@@ -5819,16 +5736,16 @@ class WolfArrayMNAP(WolfArrayMB):
                     curhead.translx = curarray.translx
                     curhead.transly = curarray.transly
 
-    def read_txt_header(self, filename:str):
+    def read_txt_header(self):
 
-        if os.path.exists(filename + '.trl'):
-            with open(filename + '.trl') as f:
+        if os.path.exists(self.filename + '.trl'):
+            with open(self.filename + '.trl') as f:
                 lines = f.read().splitlines()
                 self.translx = float(lines[1])
                 self.transly = float(lines[2])
 
-        if os.path.exists(filename + '.par'):
-            with open(filename + '.par') as f:
+        if os.path.exists(self.filename + '.par'):
+            with open(self.filename + '.par') as f:
                 lines = f.read().splitlines()
                 self.dx = float(lines[7])
                 self.dy = float(lines[8])
@@ -5886,7 +5803,7 @@ class WolfArray_Sim2D(WolfArray):
             if not os.path.exists(self.filename):
                 return
 
-            self.read_txt_header(self.filename)
+            self.read_txt_header()
             self.filename = fileold
             self.read_data()
         else:

wolfhece/wolf_texture.py

@@ -18,17 +18,14 @@ import numpy as np
 from .PyTranslate import _
 from .PyWMS import getIGNFrance, getWalonmap
 from .textpillow import Font_Priority, Text_Image,Text_Infos
+from .drawing_obj import Element_To_Draw
 
-class genericImagetexture():
+class genericImagetexture(Element_To_Draw):
     """
     Affichage d'une image en OpenGL via une texture
     """
     name: str
     idtexture: int
-    xmin: float
-    xmax: float
-    ymin: float
-    ymax: float
 
     width: int
     height: int
@@ -40,8 +37,12 @@ class genericImagetexture():
     def __init__(self, which: str, label: str, mapviewer, xmin, xmax, ymin, ymax, imageFile="",
                  imageObj=None) -> None:
 
-        mapviewer.canvas.SetCurrent(mapviewer.context)
-        self.mapviewer = mapviewer
+        super().__init__(label, True, mapviewer, False)
+
+        try:
+            self.mapviewer.canvas.SetCurrent(mapviewer.context)
+        except:
+            logging.error(_('Opengl setcurrent -- Do you have a active canvas ?'))
 
         self.xmin = xmin
         self.xmax = xmax
@@ -53,6 +54,7 @@ class genericImagetexture():
         except:
             raise NameError(
                 'Opengl glGenTextures -- maybe a conflict with an existing opengl32.dll file - please rename the opengl32.dll in the libs directory and retry')
+
         self.which = which.lower()
         self.name = label
         self.imageFile = imageFile
@@ -133,6 +135,17 @@ class genericImagetexture():
             self.load()
             self.oldview = self.newview
 
+    def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None):
+        """ alias for paint"""
+        self.paint()
+
+    def find_minmax(self,update=False):
+        """
+        Generic function to find min and max spatial extent in data
+        """
+        # Nothing to do, set during initialization phase
+        pass
+
     def paint(self):
 
         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
@@ -160,17 +173,13 @@ class genericImagetexture():
         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
 
 
-class imagetexture():
+class imagetexture(Element_To_Draw):
     """
     Affichage d'une image, obtenue depuis un Web service, en OpenGL via une texture
     """
 
     name: str
     idtexture: int
-    xmin: float
-    xmax: float
-    ymin: float
-    ymax: float
 
     width: int
     height: int
@@ -185,13 +194,16 @@ class imagetexture():
     def __init__(self, which: str, label: str, cat: str, subc: str, mapviewer, xmin, xmax, ymin, ymax, width=1000,
                  height=1000, France=False, epsg='31370') -> None:
 
-        mapviewer.canvas.SetCurrent(mapviewer.context)
-        self.mapviewer = mapviewer
+        super().__init__(label+cat+subc, plotted=False, mapviewer=mapviewer, need_for_wx=False)
+
+        try:
+            mapviewer.canvas.SetCurrent(mapviewer.context)
+        except:
+            logging.error(_('Opengl setcurrent -- Do you have a active canvas ?'))
+
         self.France = France
         self.epsg = epsg
 
-        self.plotted = False
-
         self.xmin = xmin
         self.xmax = xmax
         self.ymin = ymin
@@ -267,6 +279,17 @@ class imagetexture():
             self.load()
             self.oldview = self.newview
 
+    def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None):
+        """ alias for paint"""
+        self.paint()
+
+    def find_minmax(self,update=False):
+        """
+        Generic function to find min and max spatial extent in data
+        """
+        # Nothing to do, set during initialization phase
+        pass
+
     def paint(self):
 
         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)

wolfhece/wolfresults_2D.py

@@ -3366,7 +3366,7 @@ class Wolfresults_2D(Element_To_Draw):
             curblock.set_linkedvec(self.linkedvec)
             curblock.set_epsilon(self.epsilon)
 
-    def plot(self, sx=None, sy=None,xmin=None,ymin=None,xmax=None,ymax=None):
+    def plot(self, sx=None, sy=None,xmin=None,ymin=None,xmax=None,ymax=None, size=None):
         """Dessin OpenGL"""
         self.mimic_plotdata(True)