wolfhece 2.1.94__py3-none-any.whl → 2.1.96__py3-none-any.whl

wolfhece/PyDraw.py

@@ -1027,10 +1027,6 @@ class WolfMapViewer(wx.Frame):
                                            _("Apply mask from sim2D"))
         filterinund = self.analyzemenu.Append(wx.ID_ANY, _("Filter inundation arrays..."),
                                            _("Filter arrays"))
-        exporttif = self.analyzemenu.Append(wx.ID_ANY, _("Export arrays as Geotif..."),
-                                           _("Export arrays as Geotif"))
-        exportshape = self.analyzemenu.Append(wx.ID_ANY, _("Export arrays as Shapefile..."),
-                                           _("Export arrays as Shapefile"))
         plotqvect = self.analyzemenu.Append(wx.ID_ANY, _("Integrate Q along active vector..."),
                                            _("Integrate Q along the active vector"))
         plotqvect = self.analyzemenu.Append(wx.ID_ANY, _("Integrate Q along active zone..."),
@@ -1462,6 +1458,11 @@ class WolfMapViewer(wx.Frame):
 
             self.menuwolf2d.AppendSeparator()
 
+            self.menu2d_export_as = self.menuwolf2d.Append(wx.ID_ANY, _("Export results as..."), _("Export results as Geotif or Shapefile"))
+
+            self.menuwolf2d.AppendSeparator()
+            # Possible cache entries will be added after this separator
+
             self.menubar.Append(self.menuwolf2d, _('Results 2D'))
 
             self.menuwolf2d.Bind(wx.EVT_MENU, self.Onmenuwolf2d)
@@ -1665,6 +1666,10 @@ class WolfMapViewer(wx.Frame):
 
             self.read_last_result()
 
+        elif itemlabel == _("Export results as..."):
+
+            self.export_results_as()
+
         elif itemlabel == _("Change current view"):
 
             # Change view for results
@@ -5385,16 +5390,6 @@ class WolfMapViewer(wx.Frame):
                 fig.canvas.draw()
                 fig.canvas.flush_events()
 
-        elif itemlabel == _("Export arrays as Geotif..."):
-            autoscale = False
-
-            self.export_results_as('geotiff')
-
-        elif itemlabel == _("Export arrays as Shapefile..."):
-            autoscale = False
-
-            self.export_results_as('shape')
-
         elif itemlabel == _("Compute and apply unique colormap on all..."):
             autoscale = False
 
@@ -6407,16 +6402,13 @@ class WolfMapViewer(wx.Frame):
 
         logging.info(_('Filtering done !'))
 
-    def export_results_as(self,which='geotiff'):
-
+    def export_results_as(self, which:Literal['geotiff','shape'] = None, multiband:bool = None):
         """
         Export des résultats WOLF2D vers le format GeoTiff
         On attend que les matrices ".hbin" aient été chargées dans l'interface
-
-        TODO : Modifier la routine pour prendre les classe de résultats 2D
         """
 
-        dlg = wx.DirDialog(self,_('Choose output directory'),style = wx.DD_DIR_MUST_EXIST)
+        dlg = wx.DirDialog(self,_('Choose output directory'), style = wx.DD_DIR_MUST_EXIST)
         ret=dlg.ShowModal()
 
         if ret == wx.ID_CANCEL:
@@ -6426,63 +6418,81 @@ class WolfMapViewer(wx.Frame):
         outdir = dlg.GetPath()
         dlg.Destroy()
 
-        with wx.lib.busy.BusyInfo(_('Exporting arrays')):
-            wait = wx.BusyCursor()
-            curarray:WolfArray
-            for curarray in self.myarrays:
-                if curarray.plotted:
+        if which not in ['geotiff','shape']:
+            dlg = wx.SingleChoiceDialog(self,_('Choose output format'), _('Format'), ['Geotiff','Shape file'])
+            dlg.ShowModal()
+            sel = dlg.GetSelection()
 
-                    fn = os.path.splitext(curarray.filename)[0] #curarray.filename[:-4]
-                    top = WolfArray(fn+'.topini_fine')
-                    top.array.mask = curarray.array.mask
-                    top.array.data[np.where(top.array.mask)] = 0.
-                    qx = WolfArray(fn+'.qxbin')
-                    qx.array.mask = curarray.array.mask
-                    qx.array.data[np.where(qx.array.mask)] = 0.
-                    qy = WolfArray(fn+'.qybin')
-                    qy.array.mask = curarray.array.mask
-                    qy.array.data[np.where(qy.array.mask)] = 0.
+            if sel == 0:
+                which = 'geotiff'
+            else:
+                which = 'shape'
 
-                    qnorm = (qx**2.+qy**2.)**.5
-                    vnorm=qnorm/curarray
-                    froude=vnorm/(curarray*9.81)**.5
+            dlg.Destroy()
 
-                    frott = WolfArray(fn+'.frot')
+        if which == 'geotiff':
+            if multiband is None:
+                dlg = wx.SingleChoiceDialog(self,_('Choose output format'), _('Format'), ['Multiband (single file)',
+                                                                                          'Single band (multiple files)'])
+                dlg.ShowModal()
 
-                    def compute_critdiam(h:WolfArray,qnorm:WolfArray,n:WolfArray):
+                sel = dlg.GetSelection()
+                if sel == 1:
+                    multiband = False
+                else:
+                    multiband = True
+                dlg.Destroy()
 
-                        ij = np.argwhere(h.array>0.)
+        logging.info(_('Exporting results -- Be patient !'))
 
-                        diamcrit_shields = WolfArray(mold=h)
-                        diamcrit_izbach = WolfArray(mold=h)
+        loaded_res = self.get_list_keys(drawing_type= draw_type.RES2D, checked_state=None)
 
-                        diam = np.asarray([get_d_cr(qnorm.array[i,j],h.array[i,j],1./n.array[i,j]) for i,j in ij])
+        dlg = wx.MultiChoiceDialog(self,_('Choose results to export'), _('Results'), choices=loaded_res)
+        dlg.SetSelections([idx for idx, res in enumerate(loaded_res) if self.get_obj_from_id(res, drawtype=draw_type.RES2D).plotted])
+        dlg.ShowModal()
+        sel = dlg.GetSelections() # Get a list if integers
+        sel_res = [self.get_obj_from_id(loaded_res[cursel], drawtype=draw_type.RES2D) for cursel in sel] # convert to list of objects
 
-                        diamcrit_shields.array[ij[:,0],ij[:,1]] = diam[:,0]
-                        diamcrit_izbach.array[ij[:,0],ij[:,1]] = diam[:,1]
+        dlg.Destroy()
 
-                        return diamcrit_shields,diamcrit_izbach
+        if len(sel) == 0:
+            logging.warning(_('No results selected for export'))
+            return
+
+        fields = [(views_2D.TOPOGRAPHY, True),
+                  (views_2D.WATERDEPTH, True),
+                  (views_2D.QX, True),
+                  (views_2D.QY, True),
+                  (views_2D.UNORM, True),
+                  (views_2D.FROUDE, True),
+                  (views_2D.HEAD, True),
+                  (views_2D.CRITICAL_DIAMETER_SHIELDS, False),
+                  (views_2D.CRITICAL_DIAMETER_IZBACH, False),
+                  (views_2D.QNORM, False),
+                  (views_2D.WATERLEVEL, False),
+                  (views_2D.CRITICAL_DIAMETER_SUSPENSION_50, False),
+                  (views_2D.CRITICAL_DIAMETER_SUSPENSION_100, False),]
+
+        dlg = wx.MultiChoiceDialog(self,_('Choose fields to export'), _('Fields'), choices= [str(field[0]) for field in fields])
+        dlg.SetSelections([idx for idx, field in enumerate(fields) if field[1]])
+        dlg.ShowModal()
+        sel_fields = dlg.GetSelections() # Get a list if integers
+        dlg.Destroy()
 
-                    shields,izbach = compute_critdiam(curarray,qnorm,frott)
+        if len(sel_fields) == 0:
+            logging.warning(_('No fields selected for export'))
+            return
 
-                    myarrays=[top,curarray,qx,qy,vnorm,froude,shields,izbach]
-                    mynames=['Z [mDNG]',
-                             'H [m]',
-                             'QX [m2s-1]',
-                             'QY [m2s-1]',
-                             'Un [ms-1]',
-                             'Fr [-]',
-                             'D_Sh [m]',
-                             'D_Iz [m]']
+        # Get the views_2D values associated with the selected field names
+        fields = [fields[cursel][0] for cursel in sel_fields]
 
-                    if which =='geotiff':
-                        self.export_geotif(outdir,curarray.idx,myarrays,mynames)
+        for cur_res in tqdm(sel_res):
+            cur_res:Wolfresults_2D
+            cur_res.export_as(outdir, fields, which, multiband)
 
-                    elif which=='shape':
-                        self.export_shape(outdir,curarray.idx,myarrays,mynames,curarray)
-            del wait
+        logging.info(_('Export done -- Thanks for your patience !'))
 
-    def export_shape(self, outdir='', fn = '', myarrays=[], descr=[], mask:WolfArray=None):
+    def export_shape(self, outdir:str= '', fn:str = '', myarrays:list[WolfArray]= [], descr:list[str]= [], mask:WolfArray=None):
         """ Export multiple arrays to shapefile
 
         :param outdir: output directory
@@ -6559,7 +6569,7 @@ class WolfMapViewer(wx.Frame):
         # Save and close DataSource
         ds = None
 
-    def export_geotif(self, outdir='', fn = '', myarrays=[], descr=[]):
+    def export_geotif(self, outdir:str= '', fn:str = '', myarrays:list[WolfArray]= [], descr:list[str]= [], multiband:bool= True):
         """ Export multiple arrays to geotiff
 
         :param outdir: output directory
@@ -6578,38 +6588,62 @@ class WolfMapViewer(wx.Frame):
         srs = osr.SpatialReference()
         srs.ImportFromEPSG(31370)
 
-        filename = join(outdir,fn)
-        if not filename.endswith('.tif'):
-            filename+='.tif'
-
-        arr=myarrays[0].array
-        if arr.dtype == np.float32:
-            arr_type = gdal.GDT_Float32
-        else:
-            arr_type = gdal.GDT_Int32
-
         driver: gdal.Driver
         out_ds: gdal.Dataset
         band: gdal.Band
         driver = gdal.GetDriverByName("GTiff")
-        out_ds = driver.Create(filename, arr.shape[0], arr.shape[1], len(myarrays), arr_type, options=['COMPRESS=LZW'])
-        out_ds.SetProjection(srs.ExportToWkt())
-        out_ds.SetGeoTransform([myarrays[0].origx+myarrays[0].translx,
-                                myarrays[0].dx,
-                                0.,
-                                myarrays[0].origy+myarrays[0].transly,
-                                0.,
-                                myarrays[0].dy])
-
-        k=1
-        for arr, name in zip(myarrays,descr):
-            band = out_ds.GetRasterBand(k)
-            band.SetNoDataValue(0.)
-            band.SetDescription(name)
-            band.WriteArray(arr.array.transpose())
-            band.FlushCache()
-            band.ComputeStatistics(True)
-            k+=1
+
+        if multiband:
+            filename = join(outdir,fn)
+            if not filename.endswith('.tif'):
+                filename+='.tif'
+
+            arr = myarrays[0]
+            out_ds = driver.Create(filename, arr.shape[0], arr.shape[1], len(myarrays), arr.dtype_gdal, options=['COMPRESS=LZW'])
+            out_ds.SetProjection(srs.ExportToWkt())
+            out_ds.SetGeoTransform([myarrays[0].origx+myarrays[0].translx,
+                                    myarrays[0].dx,
+                                    0.,
+                                    myarrays[0].origy+myarrays[0].transly,
+                                    0.,
+                                    myarrays[0].dy])
+
+            k=1
+            for arr, name in zip(myarrays,descr):
+                band = out_ds.GetRasterBand(k)
+                band.SetNoDataValue(0.)
+                band.SetDescription(name)
+                band.WriteArray(arr.array.transpose())
+                band.FlushCache()
+                band.ComputeStatistics(True)
+                k+=1
+
+            out_ds = None
+
+        else:
+            for arr, name in zip(myarrays,descr):
+
+                if filename.endswith('.tif'):
+                    filename = filename[:-4]
+                filename = join(outdir,fn+'_'+name)
+                filename += '.tif'
+
+                out_ds = driver.Create(filename, arr.shape[0], arr.shape[1], 1, arr.dtype_gdal, options=['COMPRESS=LZW'])
+                out_ds.SetProjection(srs.ExportToWkt())
+                out_ds.SetGeoTransform([myarrays[0].origx+myarrays[0].translx,
+                                        myarrays[0].dx,
+                                        0.,
+                                        myarrays[0].origy+myarrays[0].transly,
+                                        0.,
+                                        myarrays[0].dy])
+
+                band = out_ds.GetRasterBand(1)
+                band.SetNoDataValue(0.)
+                band.SetDescription(name)
+                band.WriteArray(arr.array.transpose())
+                band.FlushCache()
+                band.ComputeStatistics(True)
+                out_ds = None
 
     def get_linked_arrays(self, linked:bool = True) -> dict:
         """ Get all arrays in the viewer and linked viewers """

wolfhece/apps/version.py

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

wolfhece/scenario/config_manager.py

@@ -49,6 +49,14 @@ try:
 except:
     logging.error(_('WOLFGPU not installed !'))
 
+# *****************
+#  ACCEPTED PREFIX
+# *****************
+# bath_*.tif
+# mann_*.tif
+# infil_*.tif
+
+ACCEPTED_PREFIX = ['bath_', 'mann_', 'infil_']
 
 def delete_folder(pth:Path):
     for sub in pth.iterdir():
@@ -410,6 +418,48 @@ class Config_Manager_2D_GPU:
         _flatten(self.configs, self._flat_configs)
 
 
+    def check_prefix(self, list_tif:list[Path]) -> bool:
+        """ Check if all files have the right prefix """
+
+        logging.info(_('Checking if prefix of all files are right...\n'))
+
+        logging.info(_('Number of tif files : {}'.format(len(list_tif))))
+
+        standard_files = ['bathymetry.tif', 'manning.tif', 'infiltration.tif', 'h.tif', 'qx.tif', 'qy.tif']
+
+        log = ''
+        for curtif in list_tif:
+
+            if curtif.name.lower() in standard_files:
+                # No need to test the prefix
+                break
+
+            # test if the prefix is in the accepted prefix
+            if not any([curtif.name.lower().startswith(curprefix) for curprefix in ACCEPTED_PREFIX]):
+                loclog = _('Bad prefix for {} !'.format(curtif.name)) + '\n'
+
+                tests = ['man_', 'mnn_', 'ann_', 'mamn_', 'mannn_']
+                for test in tests:
+                    if curtif.name.lower().startswith(test):
+                        loclog += _('Did you mean "mann_" ?') + '\n'
+                        break
+
+                tests = ['bath_', 'bth_', 'ath_', 'bat_', 'bathymetry_']
+                for test in tests:
+                    if curtif.name.lower().startswith(test):
+                        loclog += _('Did you mean "bath_" ?') + '\n'
+                        break
+
+                tests = ['infil_', 'infl_', 'nfil_', 'ifil_', 'infiltration_']
+                for test in tests:
+                    if curtif.name.lower().startswith(test):
+                        loclog += _('Did you mean "infil_" ?') + '\n'
+                        break
+
+                logging.warning(loclog)
+
+        return loclog
+
     def check_consistency(self) -> str:
         """
         Check consistency of all files
@@ -657,10 +707,9 @@ class Config_Manager_2D_GPU:
 
         return curdict
 
-    def _select_tif_partname(self, curdict:dict, tifstr:Literal['bath', 'mann']):
-        """ Select tif files with a 'str' in their name """
-
-        tif_list = [curtif for curtif in curdict[GPU_2D_file_extensions.TIF.value] if tifstr in curtif.name]
+    def _select_tif_partname(self, curdict:dict, tifstr:Literal['bath_', 'mann_', 'infil_']):
+        """ Select tif files with a 'str' as name's prefix """
+        tif_list = [curtif for curtif in curdict[GPU_2D_file_extensions.TIF.value] if curtif.name.lower().startswith(tifstr)]
 
         return tif_list
 
@@ -671,9 +720,9 @@ class Config_Manager_2D_GPU:
         curdicts = self.get_dicts(curtree)
 
         # tous les fichiers tif -> list of lists
-        all_tif_bath = [self._select_tif_partname(curdict, 'bath') for curdict in curdicts]
-        all_tif_mann = [self._select_tif_partname(curdict, 'mann') for curdict in curdicts]
-        all_tif_infil = [self._select_tif_partname(curdict, 'infil') for curdict in curdicts]
+        all_tif_bath = [self._select_tif_partname(curdict, 'bath_') for curdict in curdicts]
+        all_tif_mann = [self._select_tif_partname(curdict, 'mann_') for curdict in curdicts]
+        all_tif_infil = [self._select_tif_partname(curdict, 'infil_') for curdict in curdicts]
 
         # flatten list of lists
         all_tif_bath = [curel for curlist in all_tif_bath if len(curlist)>0 for curel in curlist]
@@ -702,9 +751,9 @@ class Config_Manager_2D_GPU:
         curdicts = self.get_dicts(curtree)
 
         # tous les fichiers tif -> list of lists
-        all_tif_bath = [self._select_tif_partname(curdict, 'bath') for curdict in curdicts]
-        all_tif_mann = [self._select_tif_partname(curdict, 'mann') for curdict in curdicts]
-        all_tif_infil = [self._select_tif_partname(curdict, 'infil') for curdict in curdicts]
+        all_tif_bath = [self._select_tif_partname(curdict, 'bath_') for curdict in curdicts]
+        all_tif_mann = [self._select_tif_partname(curdict, 'mann_') for curdict in curdicts]
+        all_tif_infil = [self._select_tif_partname(curdict, 'infil_') for curdict in curdicts]
 
         # flatten list of lists
         all_tif_bath = [curel for curlist in all_tif_bath if len(curlist)>0 for curel in curlist]
@@ -719,10 +768,10 @@ class Config_Manager_2D_GPU:
 
     def create_vec(self,
                    from_path:Path,
-                   which:Literal['bath', 'mann', 'infil'] = 'bath') -> Zones:
+                   which:Literal['bath_', 'mann_', 'infil_'] = 'bath_') -> Zones:
         """ Create a vec file from a path """
 
-        assert which in ['bath', 'mann', 'infil']
+        assert which in ACCEPTED_PREFIX, _('Bad prefix !')
 
         curtree = self.get_tree(from_path)
         curdicts = self.get_dicts(curtree)
@@ -1342,6 +1391,10 @@ class UI_Manager_2D_GPU():
         self._create_vec.Bind(wx.EVT_BUTTON,self.oncreatevec)
         self._create_vec.SetToolTip(_('Create a .vecz file (with contour and global bounds) from all bathymetry and manning .tif files\nBe sure that all files are right named !\n\n - bathymetry must contain "bath"\n - manning must contain "mann"\n - infiltration must contain "infil"'))
 
+        self._check_prefix = wx.Button(self._frame,label = _('Check prefix (tif files)'))
+        self._check_prefix.Bind(wx.EVT_BUTTON,self.oncheck_prefix)
+        self._check_prefix.SetToolTip(_('Check prefix of .tif files\n\n - bath_*.tif\n - mann_*.tif\n - infil_*.tif\n\nThe prefix must be "bath_", "mann_" and "infil_"'))
+
         self._checkconsistency = wx.Button(self._frame,label = _('Check consistency'))
         self._checkconsistency.Bind(wx.EVT_BUTTON,self.oncheck_consistency)
         self._checkconsistency.SetToolTip(_('Check consistency of the scenario\n\n - bathymetry.tif\n - manning.tif\n - infiltration.tif\n - hydrographs\n - initial conditions\n - boundary conditions\n - scripts'))
@@ -1393,6 +1446,7 @@ class UI_Manager_2D_GPU():
         sizer_buttons.Add(self._create_void_scripts,1,wx.EXPAND)
         sizer_buttons.Add(self._create_vrt,1,wx.EXPAND)
         sizer_buttons.Add(self._translate_vrt,1,wx.EXPAND)
+        sizer_buttons.Add(self._check_prefix,1,wx.EXPAND)
         sizer_buttons.Add(self._checkconsistency,1,wx.EXPAND)
         sizer_buttons.Add(self._create_vec,1,wx.EXPAND)
         sizer_buttons.Add(self.listsims,1,wx.EXPAND)
@@ -1548,12 +1602,41 @@ class UI_Manager_2D_GPU():
         """ Traduction d'un fichier vrt en tif """
 
         logging.info(_('Translating vrt to tif ...'))
-        mydata = self._treelist.GetItemData(self._selected_item)
+        if self._selected_item is None or self._selected_item == self._treelist.GetRootItem():
+            logging.info(_('No item selected ! -- using root item'))
+            with wx.MessageDialog(None, _('No item selected ! -- using root item'), _('Warning'), wx.OK | wx.CANCEL | wx.ICON_WARNING) as dlg:
+                ret = dlg.ShowModal()
+                if ret != wx.ID_OK:
+                    return
+            mydata = self._parent.configs
+        else:
+            mydata = self._treelist.GetItemData(self._selected_item)
 
         # création du fichier vrt
         self._parent.translate_vrt2tif(mydata['path'])
         logging.info(_('... done !'))
 
+    def oncheck_prefix(self,e:wx.MouseEvent):
+        """ Vérification des préfixes des fichiers tif """
+
+        logging.info(_('Checking prefix ...'))
+        if self._selected_item is None or self._selected_item == self._treelist.GetRootItem():
+            logging.info(_('No item selected ! -- using root item'))
+            with wx.MessageDialog(None, _('No item selected ! -- using root item'), _('Warning'), wx.OK | wx.CANCEL | wx.ICON_WARNING) as dlg:
+                ret = dlg.ShowModal()
+                if ret != wx.ID_OK:
+                    return
+            mydata = self._parent.configs
+        else:
+            mydata = self._treelist.GetItemData(self._selected_item)
+
+        # création du fichier vrt
+        log = self._parent.check_prefix(mydata['.tif']+mydata['.tiff'])
+        if log =='':
+            self._txtctrl.WriteText(_("All is fine !"))
+        else:
+            self._txtctrl.WriteText(log)
+
     def oncheck_consistency(self,e:wx.MouseEvent):
         """ Vérification de la cohérence des fichiers """
 

wolfhece/wolf_array.py

@@ -2600,7 +2600,7 @@ class Ops_Array(wx.Frame):
 
     def OnContourInt(self, event:wx.MouseEvent):
         """ Create contour - number of contours """
-        
+
         with wx.NumberEntryDialog(None, 'Number of contours', 'Number of contours', 'Number of contours', 20, 1, 1000) as dlg:
             if dlg.ShowModal() == wx.ID_OK:
                 nbcontours = dlg.GetValue()
@@ -2617,7 +2617,7 @@ class Ops_Array(wx.Frame):
     def OnContourList(self, event:wx.MouseEvent):
         """ Create contour - list of values """
 
-        with wx.TextEntryDialog(None, 'List of specific values separated by comma or tuple (min;max;step)', 
+        with wx.TextEntryDialog(None, 'List of specific values separated by comma or tuple (min;max;step)',
                                 'List of values', f'{self.parentarray.array.min()}, {self.parentarray.array.max()}') as dlg:
 
             if dlg.ShowModal() == wx.ID_OK:
@@ -5358,6 +5358,25 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return dtype
 
+    @property
+    def dtype_gdal(self):
+        """ Return the GDAL dtype corresponding to the WOLF type """
+
+        if self.wolftype in [WOLF_ARRAY_FULL_DOUBLE, WOLF_ARRAY_SYM_DOUBLE, WOLF_ARRAY_CSR_DOUBLE]:
+            dtype = gdal.GDT_Float64
+        elif self.wolftype in [WOLF_ARRAY_FULL_SINGLE, WOLF_ARRAY_FULL_SINGLE_3D, WOLF_ARRAY_MB_SINGLE]:
+            dtype = gdal.GDT_Float32
+        elif self.wolftype in [WOLF_ARRAY_FULL_INTEGER, WOLF_ARRAY_MB_INTEGER, WOLF_ARRAY_MNAP_INTEGER]:
+            dtype = gdal.GDT_Int32
+        elif self.wolftype in [WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_FULL_INTEGER16_2]:
+            dtype = gdal.GDT_Int16
+        elif self.wolftype == WOLF_ARRAY_FULL_INTEGER8:
+            dtype = gdal.GDT_Byte
+        elif self.wolftype == WOLF_ARRAY_FULL_LOGICAL:
+            dtype = gdal.GDT_Int16
+
+        return dtype
+
     @property
     def dtype_str(self):
         """
@@ -5597,7 +5616,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         # Check if estimated file size exceeds 4GB
         if (estimated_file_size > 4 * 1024**3):  # 4GB in bytes
             options = ['COMPRESS=LZW', 'BIGTIFF=YES']
-            print('BigTIFF format will be used!')
+            logging.info('BigTIFF format will be used!')
         else:
             options = ['COMPRESS=LZW']
 
@@ -9059,7 +9078,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         if isinstance(levels, int):
             levels = np.linspace(self.array.min(), self.array.max(), levels)
-        
+
         x, y = self.meshgrid()
         cs = plt.contour(x, y, self.array, levels=levels)
 
@@ -10275,7 +10294,7 @@ class WolfArrayMNAP(WolfArrayMB):
             key = which
 
         return self.myblocks[key].array.data != 1
-    
+
     def get_all_masks(self):
         """
         Return all masks

wolfhece/wolfresults_2D.py

@@ -1430,6 +1430,17 @@ class views_2D(Enum):
     T_WD_Q = _('Top + WD + Q')
     T_WD_U = _('Top + WD + U')
 
+    @classmethod
+    def get_view(cls, value):
+        for cur in views_2D:
+            if cur.value == value:
+                return cur
+
+        return None
+
+    def __str__(self):
+        return self.value
+
 VIEWS_SEDIMENTARY = [views_2D.SHIELDS_NUMBER,
                      views_2D.CRITICAL_DIAMETER_SHIELDS,
                      views_2D.CRITICAL_DIAMETER_IZBACH,
@@ -1899,7 +1910,7 @@ class OneWolfResult:
         logging.info(_('End of computing critical diameters'))
 
         return diamcrit
-    
+
     def get_u_shear(self) -> WolfArray:
         """
         Calcul de la vitesse de cisaillement
@@ -4420,3 +4431,255 @@ class Wolfresults_2D(Element_To_Draw):
         danger_map_matrix_h.mask_lower(self.epsilon)
 
         return danger_map_matrix_h
+
+    def export_as(self,
+                  outdir:str,
+                  fields:list[views_2D],
+                  which:Literal['geotiff', 'shape'],
+                  multiband:bool=True):
+        """ Export as geotiff or shapefile """
+
+        oldview = self.get_currentview()
+        old_plotted = self.plotted
+
+        arrays:dict[views_2D, WolfArray] = {}
+        for curfield in tqdm(fields, _('Concatenating fields')):
+            self.set_currentview(curfield)
+            arrays[curfield] = self.as_WolfArray()
+            arrays[curfield].nullvalue = 0.
+            arrays[curfield].set_nullvalue_in_mask()
+
+        if which =='geotiff':
+            self.export_as_geotif(outdir,
+                                self.idx,
+                                [arr for arr in arrays.values()],
+                                [key.value for key,arr in arrays.items()],
+                                multiband= multiband)
+
+        elif which=='shape':
+            if views_2D.WATERDEPTH in arrays:
+                shape_mask = arrays[views_2D.WATERDEPTH]
+            else:
+                logging.warning(_('No waterdepth found for shape export'))
+                logging.warning(_('The first field will be used as mask for shape export'))
+                shape_mask = arrays[fields[0]]
+
+            self.export_as_shape(outdir,
+                            self.idx,
+                            [arr for arr in arrays.values()],
+                            [key.value for key,arr in arrays.items()],
+                            shape_mask)
+
+        self.plotted = old_plotted
+        self.set_currentview(oldview)
+
+    def export_as_shape(self,
+                        outdir:str= '',
+                        fn:str = '',
+                        myarrays:list[WolfArray]= [],
+                        descr:list[str]= [],
+                        mask:WolfArray=None):
+        """ Export multiple arrays to shapefile
+
+        :param outdir: output directory
+        :param fn: filename -- .shp will be added if not present
+        :param myarrays: list of Wolfarrays to export
+        :param descr: list of descriptions
+        :param mask: mask array -- export only where mask > 0
+        """
+
+        if len(myarrays)==0:
+            logging.warning(_('No arrays provided for shapefile export'))
+            return
+
+        if mask is None:
+            logging.warning(_('No mask provided for shapefile export'))
+            return
+
+        from osgeo import gdal, osr, gdalconst,ogr
+
+        # create the spatial reference system, Lambert72
+        srs = osr.SpatialReference()
+        srs.ImportFromEPSG(31370)
+
+        # create the data source
+        driver: ogr.Driver
+        driver = ogr.GetDriverByName("ESRI Shapefile")
+
+        # create the data source
+        filename = join(outdir,fn)
+        if not filename.endswith('.shp'):
+            filename+='.shp'
+
+        ds = driver.CreateDataSource(filename)
+
+        # create one layer
+        layer = ds.CreateLayer("results", srs, ogr.wkbPolygon)
+
+        # Convert Fields
+        new_descr = []
+        for curfield in descr:
+            if curfield == views_2D.TOPOGRAPHY.value:
+                new_descr.append('TOP[m]')
+            elif curfield == views_2D.WATERDEPTH.value:
+                new_descr.append('WD[m]')
+            elif curfield == views_2D.QX.value:
+                new_descr.append('QX[m2/s]')
+            elif curfield == views_2D.QY.value:
+                new_descr.append('QY[m2/s]')
+            elif curfield == views_2D.UNORM.value:
+                new_descr.append('UN[m/s]')
+            elif curfield == views_2D.FROUDE.value:
+                new_descr.append('FR[-]')
+            elif curfield == views_2D.HEAD.value:
+                new_descr.append('HEAD[m]')
+            elif curfield == views_2D.CRITICAL_DIAMETER_SHIELDS.value:
+                new_descr.append('DSh[m]')
+            elif curfield == views_2D.CRITICAL_DIAMETER_IZBACH.value:
+                new_descr.append('DIz[m]')
+            elif curfield == views_2D.QNORM.value:
+                new_descr.append('QN[m2/s]')
+            elif curfield == views_2D.WATERLEVEL.value:
+                new_descr.append('WL[m]')
+            elif curfield == views_2D.CRITICAL_DIAMETER_SUSPENSION_50.value:
+                new_descr.append('DS50[m]')
+            elif curfield == views_2D.CRITICAL_DIAMETER_SUSPENSION_100.value:
+                new_descr.append('DS100[m]')
+
+        descr = new_descr
+
+        # Add ID fields
+        idFields=[]
+        for curlab in descr:
+            idFields.append(ogr.FieldDefn(curlab, ogr.OFTReal))
+            layer.CreateField(idFields[-1])
+
+        # Create the feature and set values
+        featureDefn = layer.GetLayerDefn()
+        feature = ogr.Feature(featureDefn)
+
+        usednodes = np.argwhere(mask.array>0.)
+        for i,j in tqdm(usednodes):
+
+            x,y = mask.get_xy_from_ij(i,j)
+            # Creating a line geometry
+            ring = ogr.Geometry(ogr.wkbLinearRing)
+            ring.AddPoint(x-mask.dx/2,y-mask.dy/2)
+            ring.AddPoint(x+mask.dx/2,y-mask.dy/2)
+            ring.AddPoint(x+mask.dx/2,y+mask.dy/2)
+            ring.AddPoint(x-mask.dx/2,y+mask.dy/2)
+            ring.AddPoint(x-mask.dx/2,y-mask.dy/2)
+
+            # Create polygon
+            poly = ogr.Geometry(ogr.wkbPolygon)
+            poly.AddGeometry(ring)
+
+            feature.SetGeometry(poly)
+
+            for arr, id in zip(myarrays,descr):
+
+                feature.SetField(id, float(arr.array[i,j]))
+
+            layer.CreateFeature(feature)
+
+        feature = None
+
+        # Save and close DataSource
+        ds = None
+
+    def export_as_geotif(self,
+                         outdir:str= '',
+                         fn:str = '',
+                         myarrays:list[WolfArray]= [],
+                         descr:list[str]= [],
+                         multiband:bool= True):
+        """ Export results as geotiff
+
+        :param outdir: output directory
+        :param fn: filename -- .tif will be added if not present
+        :param myarrays: list of Wolfarrays to export
+        :param descr: list of descriptions -- Bands names
+
+        """
+
+        if len(myarrays)==0:
+            logging.warning(_('No arrays provided for geotiff export'))
+            return
+
+        from osgeo import gdal, osr, gdalconst
+
+        srs = osr.SpatialReference()
+        srs.ImportFromEPSG(31370)
+
+        driver: gdal.Driver
+        out_ds: gdal.Dataset
+        band: gdal.Band
+        driver = gdal.GetDriverByName("GTiff")
+
+        if multiband:
+            filename = join(outdir,fn)
+            if not filename.endswith('.tif'):
+                filename+='.tif'
+
+            arr = myarrays[0]
+
+            # Check if estimated file size exceeds 4GB
+            estimated_file_size = arr.memory_usage * len(myarrays)
+            if (estimated_file_size > 4 * 1024**3):  # 4GB in bytes
+                options = ['COMPRESS=LZW', 'BIGTIFF=YES']
+                logging.info('BigTIFF format will be used!')
+            else:
+                options = ['COMPRESS=LZW']
+
+            out_ds = driver.Create(filename, arr.shape[0], arr.shape[1], len(myarrays), arr.dtype_gdal, options= options)
+            out_ds.SetProjection(srs.ExportToWkt())
+            out_ds.SetGeoTransform([myarrays[0].origx+myarrays[0].translx,
+                                    myarrays[0].dx,
+                                    0.,
+                                    myarrays[0].origy+myarrays[0].transly,
+                                    0.,
+                                    myarrays[0].dy])
+
+            k=1
+            for arr, name in tqdm(zip(myarrays,descr), 'Writing geotiff - bands'):
+                band = out_ds.GetRasterBand(k)
+                band.SetNoDataValue(arr.nullvalue)
+                band.SetDescription(name)
+                band.WriteArray(arr.array.transpose())
+                band.FlushCache()
+                band.ComputeStatistics(True)
+                k+=1
+
+            out_ds = None
+
+        else:
+            for arr, name in tqdm(zip(myarrays,descr), 'Writing geotiff'):
+
+                filename = join(outdir,fn)
+                if filename.endswith('.tif'):
+                    filename = filename[:-4]
+                filename = filename+'_'+name+'.tif'
+
+                estimated_file_size = arr.memory_usage
+                if (estimated_file_size > 4 * 1024**3):  # 4GB in bytes
+                    options = ['COMPRESS=LZW', 'BIGTIFF=YES']
+                    logging.info('BigTIFF format will be used!')
+                else:
+                    options = ['COMPRESS=LZW']
+
+                out_ds = driver.Create(filename, arr.shape[0], arr.shape[1], 1, arr.dtype_gdal, options= options)
+                out_ds.SetProjection(srs.ExportToWkt())
+                out_ds.SetGeoTransform([myarrays[0].origx+myarrays[0].translx,
+                                        myarrays[0].dx,
+                                        0.,
+                                        myarrays[0].origy+myarrays[0].transly,
+                                        0.,
+                                        myarrays[0].dy])
+
+                band = out_ds.GetRasterBand(1)
+                band.SetNoDataValue(arr.nullvalue)
+                band.SetDescription(name)
+                band.WriteArray(arr.array.transpose())
+                band.FlushCache()
+                band.ComputeStatistics(True)
+                out_ds = None

{wolfhece-2.1.94.dist-info → wolfhece-2.1.96.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.1.94
+Version: 2.1.96
 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.94.dist-info → wolfhece-2.1.96.dist-info}/RECORD

@@ -7,7 +7,7 @@ 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=CiXP4_VfENyacuzwp-AzIPSkZKtlW6xHN6I8jYJBqY0,442203
+wolfhece/PyDraw.py,sha256=k1XDmBIohV4sGYxotU-BTD4m0KXQh-VbT6nv2itS_Oo,443861
 wolfhece/PyGui.py,sha256=HY0beOMSp1JEyq8-vfVynzVrmKxvaO_sJSMwlNqCNrg,105289
 wolfhece/PyGuiHydrology.py,sha256=f60E8K9eGTnRq5RDF6yvt-ahf2AYegwQ9t25zZ2Mk1A,14946
 wolfhece/PyHydrographs.py,sha256=jwtSNMMACwarxrtN1UeQYth99UNrhwPx1IGgUwcooHA,3774
@@ -48,13 +48,13 @@ wolfhece/pywalous.py,sha256=yRaWJjKckXef1d9D5devP0yFHC9uc6kRV4G5x9PNq9k,18972
 wolfhece/rain_SPWMI.py,sha256=qCfcmF7LajloOaCwnTrrSMzyME03YyilmRUOqrPrv3U,13846
 wolfhece/textpillow.py,sha256=map7HsGYML_o5NHRdFg2s_TVQed_lDnpYNDv27MM0Vw,14130
 wolfhece/tools_mpl.py,sha256=gQ3Jg1iuZiecmMqa5Eli2ZLSkttu68VXL8YmMDBaEYU,564
-wolfhece/wolf_array.py,sha256=HasKFOCiFzM55YSXPvpWJ7O4tOoxyTm_LHytE2ZQq8o,406444
+wolfhece/wolf_array.py,sha256=Pv7Kbimou7t-wXkixwZ0Gcv2N9kTPWJxiHI8VYD8sCk,407304
 wolfhece/wolf_hist.py,sha256=7jeVrgSkM3ErJO6SRMH_PGzfLjIdw8vTy87kesldggk,3582
 wolfhece/wolf_texture.py,sha256=DS5eobLxrq9ljyebYfpMSQPn8shkUAZZVfqrOKN_QUU,16951
 wolfhece/wolf_tiles.py,sha256=2Ho2I20rHRY81KXxjgLOYISdF4OkJ2d6omeY4shDoGI,10386
 wolfhece/wolf_vrt.py,sha256=89XoDhCJMHiwPQUuOduxtTRKuIa8RDxgNqX65S4xp9M,10569
 wolfhece/wolf_zi_db.py,sha256=baE0niMCzybWGSvPJc5FNxo9ZxsGfU4p-FmfiavFHAs,12967
-wolfhece/wolfresults_2D.py,sha256=p0v3FT6CAzf6aP4AEEXNkuHG01c2Eqbio_a8ghJIt7k,169709
+wolfhece/wolfresults_2D.py,sha256=-Un0F7GsfSJetycyYc-6UeOrXEFCu9eH9Fumj-Qe4cM,179603
 wolfhece/xyz_file.py,sha256=Se4nCPwYAYLSA5i0zsbnZUKoAMAD0mK1FJea5WSZUkk,5755
 wolfhece/acceptability/Parallels.py,sha256=h4tu3SpC_hR5Hqa68aruxhtAyhs8u666YuZ40_fR5zg,3979
 wolfhece/acceptability/__init__.py,sha256=hfgoPKLDpX7drN1Vpvux-_5Lfyc_7feT2C2zQr5v-Os,258
@@ -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=rZi-X4W-8UB0KrenDxLV9h-lnAEpdduh_0hJNqjLsoY,388
+wolfhece/apps/version.py,sha256=5EAPTzfatYqx9GXoy44yzHoCW1DnjWdiOvkS-fo60-c,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
@@ -262,7 +262,7 @@ wolfhece/report/reporting.py,sha256=JUEXovx_S4jpYkJEBU0AC-1Qw2OkkWyV3VAp6iOfSHc,
 wolfhece/report/wolf_report.png,sha256=NoSV58LSwb-oxCcZScRiJno-kxDwRdm_bK-fiMsKJdA,592485
 wolfhece/scenario/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/scenario/check_scenario.py,sha256=VVjtxfcLAgq_Pf8VSqRq6BJ-y4Zi24CntJpZWxAv3n8,5162
-wolfhece/scenario/config_manager.py,sha256=0B_ZtMkcbZRwzkXHwT6jSC3-Lq85P2oBiq1Qxjkfh2w,86869
+wolfhece/scenario/config_manager.py,sha256=aQFqY2aDcKR5r7NIFqjcO1VJngajK_lOE1ZX5LVKKpc,90591
 wolfhece/scenario/imposebc_void.py,sha256=PqA_99hKcaqK5zsK6IRIc5Exgg3WVpgWU8xpwNL49zQ,5571
 wolfhece/scenario/update_void.py,sha256=ay8C_FxfXN627Hx46waaAO6F3ovYmOCTxseUumKAY7c,7474
 wolfhece/shaders/fragment_shader_texture.glsl,sha256=w6h8d5mJqFaGbao0LGmjRcFFdcEQ3ICIl9JpuT71K5k,177
@@ -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.94.dist-info/METADATA,sha256=7QKX23LbIgX7dd_Qxm_3o1ItJk0-1y0clPJ_xQP3wwU,2570
-wolfhece-2.1.94.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-wolfhece-2.1.94.dist-info/entry_points.txt,sha256=ZZ-aSfbpdcmo-wo84lRFzBN7LaSnD1XRGSaAKVX-Gpc,522
-wolfhece-2.1.94.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.1.94.dist-info/RECORD,,
+wolfhece-2.1.96.dist-info/METADATA,sha256=woDxgeDItCFEgqYP3HLrY3xiLGjHxXRQ-rV9TyNDgFQ,2570
+wolfhece-2.1.96.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+wolfhece-2.1.96.dist-info/entry_points.txt,sha256=ZZ-aSfbpdcmo-wo84lRFzBN7LaSnD1XRGSaAKVX-Gpc,522
+wolfhece-2.1.96.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.1.96.dist-info/RECORD,,