wolfhece 2.1.126__py3-none-any.whl → 2.1.128__py3-none-any.whl

wolfhece/PyDraw.py

@@ -875,7 +875,7 @@ class Sim_Explorer(wx.Frame):
         right_bar.Add(self._texttime, 1, wx.EXPAND | wx.ALL, 5)
         self._texttime.Bind(wx.EVT_TEXT, self.OnTextTime)
 
-        self._step_time = wx.ListBox(self._panel, choices=['{:.3f} - {}'.format(i, datetime.strftime(self._starting_date + timedelta(seconds=i), '%Y-%m-%d %H:%M:%S')) for i in self._all_times_steps[0]], style=wx.LB_SINGLE)
+        self._step_time = wx.ListBox(self._panel, choices=['{:.3f} - {}'.format(i, datetime.strftime(self._starting_date + timedelta(seconds=float(i)), '%Y-%m-%d %H:%M:%S')) for i in self._all_times_steps[0]], style=wx.LB_SINGLE)
         self._step_time.Bind(wx.EVT_LISTBOX, self.OnSelectNumStep)
         right_bar.Add(self._step_time, 1, wx.EXPAND | wx.ALL, 5)
 
@@ -1356,6 +1356,264 @@ class Select_Begin_end_interval_step(wx.Dialog):
 
         self.Hide()
 
+
+class PrecomputedDEM_DTM(Enum):
+    """ Enum for Precomputed DEM/DTM array """
+
+    DEMDTM_50cm = "AllData.vrt"
+    DEMDTM_1m_average = "Combine_1m_average.vrt"
+    DEMDTM_1m_min = "Combine_1m_minimum.vrt"
+    DEMDTM_1m_max = "Combine_1m_maximum.vrt"
+    DEMDTM_2m_average = "Combine_2m_average.vrt"
+    DEMDTM_2m_min = "Combine_2m_minimum.vrt"
+    DEMDTM_2m_max = "Combine_2m_maximum.vrt"
+    DEMDTM_5m_average = "Combine_5m_average.vrt"
+    DEMDTM_5m_min = "Combine_5m_minimum.vrt"
+    DEMDTM_5m_max = "Combine_5m_maximum.vrt"
+    DEMDTM_10m_average = "Combine_10m_average.vrt"
+    DEMDTM_10m_min = "Combine_10m_minimum.vrt"
+    DEMDTM_10m_max = "Combine_10m_maximum.vrt"
+
+class Precomputed_DEM_DTM_Dialog(wx.Dialog):
+    """ wx.Dialog to select Precomputed DEM/DTM array
+
+    Resolutions are 50cm, 1m, 2m, 5m, 10m
+    Operators are average, min, max
+    """
+
+    def __init__(self, parent, title, directory:Path | str, mapviewer:"WolfMapViewer"):
+
+        super(Precomputed_DEM_DTM_Dialog, self).__init__(parent, title=title, size=(500, 350), style = wx.DEFAULT_FRAME_STYLE & ~ (wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX))
+
+        self._dir = Path(directory)
+        self._header = None
+        self._vrt = None
+        self._mapviewer = mapviewer
+
+        self.available_vrt()
+
+        self._panel = wx.Panel(self)
+        sizer = wx.BoxSizer(wx.VERTICAL)
+
+        # Listbox with all available operators
+        self._res = ['50cm', '1m', '2m', '5m', '10m']
+        self._ops = ['average', 'minimum', 'maximum']
+        self._resolution = wx.ListBox(self._panel, choices=self._res, style=wx.LB_SINGLE)
+        self._resolution.Bind(wx.EVT_LISTBOX, self.OnSelectResolution)
+
+        self._operations = wx.ListBox(self._panel, choices=[], style=wx.LB_SINGLE)
+
+        sizer.Add(self._resolution, 1, wx.EXPAND | wx.ALL, 2)
+        sizer.Add(self._operations, 1, wx.EXPAND | wx.ALL, 2)
+
+        sizer_btns = wx.BoxSizer(wx.HORIZONTAL)
+        self._cmd_sameactive = wx.Button(self._panel, wx.ID_APPLY, _('Same as active array...'))
+        self._cmd_sameas = wx.Button(self._panel, wx.ID_APPLY, _('Same as file...'))
+        self._cmd_zoom = wx.Button(self._panel, wx.ID_APPLY, _('On current zoom...'))
+
+        self._cmd_sameas.Bind(wx.EVT_BUTTON, self.OnSameAs)
+        self._cmd_zoom.Bind(wx.EVT_BUTTON, self.OnZoom)
+        self._cmd_sameactive.Bind(wx.EVT_BUTTON, self.OnSameActive)
+
+        sizer_btns.Add(self._cmd_sameactive, 1, wx.EXPAND | wx.ALL, 2)
+        sizer_btns.Add(self._cmd_sameas, 1, wx.EXPAND | wx.ALL, 2)
+        sizer_btns.Add(self._cmd_zoom, 1, wx.EXPAND | wx.ALL, 2)
+
+        sizer.Add(sizer_btns, 1, wx.EXPAND | wx.ALL, 2)
+
+        self._panel.SetSizer(sizer)
+
+        self.CenterOnScreen()
+
+        self.SetIcon(wx.Icon(str(Path(__file__).parent / "apps/wolf_logo2.bmp")))
+
+        self.Show()
+
+    def OnSameAs(self, event):
+        """ Set the Precomputed DEM/DTM array to the same bounds as an existing array """
+
+        dlg = wx.FileDialog(self, _('Select a file'), str(self._dir), '', "All supported formats|*.bin;*.tif;*.tiff;*.top;*.flt;*.npy;*.npz;*.vrt|bin (*.bin)|*.bin|Elevation WOLF2D (*.top)|*.top|Geotif (*.tif)|*.tif|Float ESRI (*.flt)|*.flt|Numpy (*.npy)|*.npy|Numpy named arrays(*.npz)|*.npz|all (*.*)|*.*", wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
+        ret = dlg.ShowModal()
+
+        if ret == wx.ID_OK:
+            fname = Path(dlg.GetPath())
+
+            self._header = header_wolf()
+            self._header.read_txt_header(fname)
+
+            res = self._resolution.GetStringSelection()
+            if res == '50cm':
+                res = 0.5
+            elif res in ['1m', '2m', '5m', '10m']:
+                res = float(res[:-1])
+            else:
+                logging.error('Resolution not found')
+                return
+
+            if self._header.dx != res or self._header.dy != res:
+                logging.warning(_('Resolution not the same'))
+                logging.warning(_('Forcing resolution to {}m').format(res))
+
+                self._header.origx = float(int(self._header.origx / res) * res)
+                self._header.origy = float(int(self._header.origy / res) * res)
+                self._header.nbx = int(np.ceil(float(self._header.nbx) * self._header.dx / res))
+                self._header.nby = int(np.ceil(float(self._header.nby) * self._header.dy / res))
+                self._header.dx = res
+                self._header.dy = res
+
+                logging.info(_('New header:'))
+                logging.info(self._header)
+
+            self.add_array()
+            self.Hide()
+
+    def OnSameActive(self, event):
+        """ Set the Precomputed DEM/DTM array to the same bounds as the active array """
+
+        if self._mapviewer is None:
+            logging.error('No mapviewer to get the active array')
+            return
+
+        active = self._mapviewer.active_array
+        if active is None:
+            logging.error('No active array to get the bounds')
+            return
+
+        self._header = active.get_header()
+
+        res = self._resolution.GetStringSelection()
+        if res == '50cm':
+            res = 0.5
+        elif res in ['1m', '2m', '5m', '10m']:
+            res = float(res[:-1])
+        else:
+            logging.error('Resolution not found')
+            return
+
+        if self._header.dx != res or self._header.dy != res:
+            logging.warning(_('Resolution not the same'))
+            logging.warning(_('Forcing resolution to {}m').format(res))
+
+            self._header.origx = float(int(self._header.origx / res) * res)
+            self._header.origy = float(int(self._header.origy / res) * res)
+            self._header.nbx = int(np.ceil(float(self._header.nbx) * self._header.dx / res))
+            self._header.nby = int(np.ceil(float(self._header.nby) * self._header.dy / res))
+            self._header.dx = res
+            self._header.dy = res
+
+            logging.info(_('New header:'))
+            logging.info(self._header)
+
+        newarray = self.add_array()
+
+        #copy palette
+        if newarray is not None:
+            newarray.mypal.automatic = False
+            newarray.mypal.values = active.mypal.values
+
+        self.Hide()
+        self._mapviewer.Refresh()
+
+    def OnZoom(self, event):
+        """ Set the Precomputed DEM/DTM array to the current zoom """
+
+        if self._mapviewer is None:
+            logging.error('No mapviewer to get the current zoom')
+            return
+
+        onzoom = [self._mapviewer.xmin, self._mapviewer.xmax, self._mapviewer.ymin, self._mapviewer.ymax]
+
+        self._header = header_wolf()
+
+        # round to the nearest resolution
+        self._header.origx = float(int(onzoom[0]))
+        self._header.origy = float(int(onzoom[2]))
+
+        res = self._resolution.GetSelection()
+        if res == '50cm':
+            res = 0.5
+        elif res in ['1m', '2m', '5m', '10m']:
+            res = float(res[:-1])
+        else:
+            logging.error('Resolution not found')
+            return
+
+        self._header.dx = res
+        self._header.dy = res
+
+        self._header.nbx = int(float(np.ceil(onzoom[1]) - np.int(onzoom[0])) / res)
+        self._header.nby = int(float(np.ceil(onzoom[3]) - np.int(onzoom[2])) / res)
+
+        self.add_array()
+        self.Hide()
+        self._mapviewer.Refresh()
+
+    @property
+    def selected_vrt(self):
+
+        res = self._resolution.GetStringSelection()
+        op = self._operations.GetStringSelection()
+
+        vrt_names = [cur.name for cur in self._vrt]
+        if res == '50cm':
+            if PrecomputedDEM_DTM.DEMDTM_50cm.value in vrt_names:
+                return self._dir / PrecomputedDEM_DTM.DEMDTM_50cm.value
+        elif res in ['1m', '2m', '5m', '10m']:
+            to_test = 'Combine_{}_{}.vrt'.format(res, op)
+            if to_test in vrt_names:
+                return self._dir / to_test
+            else:
+                logging.error('Operator not found')
+                return None
+        else:
+            logging.error('Resolution not found')
+            return None
+
+    def add_array(self):
+        """ Add a new array to the viewer """
+
+        if self._mapviewer is None:
+            logging.error('No mapviewer to add the array')
+            return
+
+        if self._header is None:
+            logging.error('No header defined')
+            return
+
+        vrt = self.selected_vrt
+        if vrt is None:
+            logging.error('No vrt selected')
+            return
+
+        newarray = WolfArray(vrt, crop= [[self._header.origx, self._header.origx + self._header.nbx * self._header.dx], [self._header.origy, self._header.origy + self._header.nby * self._header.dy]])
+        self._mapviewer.add_object(newobj = newarray, id = vrt.stem)
+
+        return newarray
+
+    def OnSelectResolution(self, event):
+        """ Select the resolution """
+
+        res = self._resolution.GetStringSelection()
+
+        vrt_names = [i.name for i in self._vrt]
+        if res == '50cm':
+            if PrecomputedDEM_DTM.DEMDTM_50cm.value in vrt_names:
+                self._operations.Set(['No operator to choose - 50cm resolution'])
+        elif res in ['1m', '2m', '5m', '10m']:
+            to_test = {i: 'Combine_{}_{}.vrt'.format(res, i) for i in self._ops}
+            self._operations.Set([i for i, val in to_test.items() if val in vrt_names])
+        else:
+            self._operations.Set([''])
+
+
+    def available_vrt(self):
+        """ List all available vrt files in the directory """
+
+        self._vrt = [i for i in self._dir.iterdir() if i.suffix == '.vrt']
+        # test if vrt are in PrecomputedDEM_DTM
+        self._vrt = [i for i in self._vrt if i.name in [j.value for j in PrecomputedDEM_DTM]]
+
+
 class WolfMapViewer(wx.Frame):
     """
     Fenêtre de visualisation de données WOLF grâce aux WxWidgets
@@ -1622,6 +1880,20 @@ class WolfMapViewer(wx.Frame):
         addweirs = self.menuaddobj.Append(wx.ID_ANY, _('Add weirs...'), _('Add bridges from directory'))
         addview = self.menuaddobj.Append(wx.ID_ANY, _('Add view...'), _('Add view from project file'))
 
+        self.precomputed_menu = None
+        if self.default_dem != "":
+            self.filemenu.AppendSeparator()
+            self.precomputed_menu = wx.Menu()
+            self.precomputed_menu.Append(wx.ID_ANY,_('Precomputed DEM'))
+            self.filemenu.Append(wx.ID_ANY, _('Precomputed...'), self.precomputed_menu)
+        if self.default_dtm != "":
+            if self.precomputed_menu is None:
+                self.filemenu.AppendSeparator()
+                self.precomputed_menu = wx.Menu()
+                self.filemenu.Append(wx.ID_ANY, _('Precomputed...'), self.precomputed_menu)
+
+            self.precomputed_menu.Append(wx.ID_ANY,_('Precomputed DTM'))
+
         self.filemenu.AppendSeparator()
         addscan = self.filemenu.Append(wx.ID_FILE5, _('Recursive scan...'), _('Add recursively'))
 
@@ -1683,6 +1955,7 @@ class WolfMapViewer(wx.Frame):
 
         self.analyzeplot = wx.Menu()
         self.analyzeexport = wx.Menu()
+        self.analyzeinpaint = wx.Menu()
 
         plotvect = self.analyzeplot.Append(wx.ID_ANY, _("Plot active vector..."),
                                            _("Plot the active vector and linked arrays"))
@@ -1693,6 +1966,13 @@ class WolfMapViewer(wx.Frame):
 
         self.analyzemenu.Append(wx.ID_ANY,_('Plot...'),self.analyzeplot)
         self.analyzemenu.Append(wx.ID_ANY,_('Export...'),self.analyzeexport)
+        self.analyzemenu.Append(wx.ID_ANY,_('Inpaint...'),self.analyzeinpaint)
+
+
+        self.analyzeinpaint.Append(wx.ID_ANY, _("Inpaint active array..."), _("Inpaint active array"))
+        self.analyzeinpaint.Append(wx.ID_ANY, _("Inpaint waterlevel..."), _("Inpaint a waterlevel result array based on sepcified dem and dtm data"))
+        self.analyzeinpaint.Append(wx.ID_ANY, _("Inpaint array with mask..."), _("Inpaint an array based on sepcified mask and test data"))
+
         self.analyzemenu.AppendSeparator()
 
         masksimul = self.analyzemenu.Append(wx.ID_ANY, _("Load and apply mask (nap)..."), _("Apply mask from sim2D"))
@@ -3344,6 +3624,33 @@ class WolfMapViewer(wx.Frame):
         else:
             return None
 
+    @property
+    def default_dem(self) -> Path:
+        """ Return the default DEM file from configs """
+        config = self.get_configuration()
+        if config is None:
+            return Path('')
+        else:
+            return Path(config[ConfigurationKeys.DIRECTORY_DEM])
+
+    @property
+    def default_dtm(self) -> Path:
+        """ Return the default DTM file from configs """
+        config = self.get_configuration()
+        if config is None:
+            return Path('')
+        else:
+            return Path(config[ConfigurationKeys.DIRECTORY_DTM])
+
+    @property
+    def default_laz(self):
+        """ Return the default LAZ file from configs """
+        config = self.get_configuration()
+        if config is None:
+            return Path('')
+        else:
+            return Path(config[ConfigurationKeys.DIRECTORY_LAZ])
+
     @property
     def bkg_color(self):
         """ Return the background color from configs """
@@ -6322,10 +6629,10 @@ class WolfMapViewer(wx.Frame):
 
         return classification
 
-    def init_laz_from_gridinfos(self, dirlaz:str = None, classification:Literal['SPW-Geofit 2023', 'SPW 2013-2014'] = 'SPW-Geofit 2023'):
+    def init_laz_from_gridinfos(self, dirlaz:str = None, classification:Literal['SPW-Geofit 2023', 'SPW 2013-2014', 'SPW 2021-2022'] = 'SPW-Geofit 2023'):
 
         if dirlaz is None:
-            dlg = wx.DirDialog(None, _('Choose directory where LAZ data/gridinfo are stored'))
+            dlg = wx.DirDialog(None, _('Choose directory where LAZ data/gridinfo are stored'), defaultPath= str(self.default_laz))
             ret = dlg.ShowModal()
             if ret != wx.ID_OK:
                 return
@@ -6343,6 +6650,8 @@ class WolfMapViewer(wx.Frame):
             return
         elif classification == 'SPW 2013-2014':
             self.mylazgrid.colors.init_2013()
+        elif classification == "SPW 2021-2022":
+            self.mylazgrid.colors.init_2021_2022()
         else:
             self.mylazgrid.colors.init_2023()
 
@@ -7234,6 +7543,35 @@ class WolfMapViewer(wx.Frame):
         elif itemlabel == _("Load and apply mask (nap)..."):
             self.loadnap_and_apply()
 
+        elif itemlabel == _("Inpaint active array..."):
+
+            if self.active_array is None:
+                logging.warning(_('No active array !'))
+                return
+
+            nb = self.active_array.count_holes()
+            if nb == 0:
+                logging.warning(_('No hole in the array !'))
+                return
+
+            dlg = wx.SingleChoiceDialog(None, _('Ignore the last ones ?'), _('Holes'), [str(i) for i in range(10)], style=wx.CHOICEDLG_STYLE)
+            if dlg.ShowModal() == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+
+            nb = dlg.GetSelection()
+            dlg.Destroy()
+
+            self.active_array.inpaint(ignore_last=nb)
+
+        elif itemlabel == _("Inpaint waterlevel..."):
+
+            dlg = InPaint_waterlevel(None, _("Choose the array to inpaint"), (400,400), self)
+
+        elif itemlabel == _("Inpaint array with mask..."):
+
+            dlg = InPaint_array(None, _("Choose the array to inpaint"), (400,400), self)
+
         elif itemlabel == _("Filter inundation arrays..."):
             self.filter_inundation()
 
@@ -7872,6 +8210,16 @@ class WolfMapViewer(wx.Frame):
         elif itemlabel == _('Add array and crop...'):
             self.add_object(which='array_crop', ToCheck=True)
 
+        elif itemlabel == _('Precomputed DEM'):
+
+            dlg = Precomputed_DEM_DTM_Dialog(self, _('Precomputed DEM'), self.default_dem, self)
+            ret = dlg.ShowModal()
+
+        elif itemlabel == _('Precomputed DTM'):
+
+            dlg = Precomputed_DEM_DTM_Dialog(self, _('Precomputed DTM'), self.default_dtm, self)
+            ret = dlg.ShowModal()
+
         elif itemlabel == _('Create array from bathymetry file...'):
 
             self.add_object(which='array_xyz', ToCheck=True)
@@ -9361,7 +9709,7 @@ class WolfMapViewer(wx.Frame):
                     if ret == wx.ID_YES:
                         loadhead = True
 
-                    types = None
+                    newobj = cloud_vertices(filename, header=loadhead, mapviewer=self)
 
                 elif filename.endswith('.dxf'):
                     types = ['POLYLINE','LWPOLYLINE','LINE', 'MTEXT', 'INSERT']
@@ -9377,7 +9725,56 @@ class WolfMapViewer(wx.Frame):
                     types = [types[i] for i in dlg.GetSelections()]
                     dlg.Destroy()
 
-                newobj = cloud_vertices(filename, header=loadhead, mapviewer=self, dxf_imported_elts=types)
+                    newobj = cloud_vertices(filename, header=loadhead, mapviewer=self, dxf_imported_elts=types)
+
+                elif filename.endswith('.shp'):
+
+                    types = None
+
+                    if Path(filename).stem == 'Vesdre_Bridges':
+                        # We need to import the bridges from the clogging study/database
+                        data = gpd.read_file(filename)
+
+                        #filter 'Clogging' == Yes
+                        clogged = data[data['Clogging'] == 'Yes']
+                        unclogged = data[data['Clogging'] == 'No']
+                        notsure = data[data['Clogging'] == 'No information']
+
+                        from tempfile import TemporaryDirectory
+                        with TemporaryDirectory() as tmpdirname:
+                            clogged.to_file(tmpdirname + '/clogged.shp')
+                            unclogged.to_file(tmpdirname + '/unclogged.shp')
+                            notsure.to_file(tmpdirname + '/notsure.shp')
+
+                            newobj = cloud_vertices(tmpdirname + '/unclogged.shp', header=loadhead, mapviewer=self, idx='unclogged')
+                            self.myclouds.append(newobj)
+                            newobj.set_mapviewer(self)
+                            newobj.myprop.color = (0,255,0)
+                            newobj.myprop.size = 10
+
+                            myitem = self.treelist.AppendItem(curtree, newobj.idx, data=newobj)
+                            self.treelist.CheckItem(myitem)
+                            self.treelist.CheckItem(self.treelist.GetItemParent(myitem))
+                            newobj.check_plot()
+
+                            newobj = cloud_vertices(tmpdirname + '/notsure.shp', header=loadhead, mapviewer=self, idx='notsure')
+                            self.myclouds.append(newobj)
+                            newobj.set_mapviewer(self)
+                            newobj.myprop.color = (0,0,255)
+                            newobj.myprop.size = 10
+
+                            myitem = self.treelist.AppendItem(curtree, newobj.idx, data=newobj)
+                            self.treelist.CheckItem(myitem)
+                            self.treelist.CheckItem(self.treelist.GetItemParent(myitem))
+                            newobj.check_plot()
+
+                            newobj = cloud_vertices(tmpdirname + '/clogged.shp', header=loadhead, mapviewer=self, idx='clogged')
+                            newobj.myprop.color = (255,0,0)
+                            newobj.myprop.size = 15
+                            id = 'clogged'
+
+                    else:
+                        newobj = cloud_vertices(filename, header=loadhead, mapviewer=self)
 
             self.myclouds.append(newobj)
             self.active_cloud = newobj
@@ -9819,6 +10216,8 @@ class WolfMapViewer(wx.Frame):
                         curlist.pop(idx)
                         curlist.insert(idx-1,myobj)
 
+            self.Refresh()
+
     def downobj(self):
         """Down selected item into general tree"""
 
@@ -9851,13 +10250,20 @@ class WolfMapViewer(wx.Frame):
 
             for curlist in self.all_lists:
                 if myobj in curlist:
-                    idx = curlist.index(myobj)
-                    if idx==len(curlist)-2:
-                        curlist.append(myobj)
-                        curlist.pop(idx)
-                    elif idx<len(curlist)-1:
-                        curlist.insert(idx+1,myobj)
-                        curlist.pop(idx)
+                    if len(curlist)>1:
+                        idx = curlist.index(myobj)
+                        if idx == len(curlist)-1:
+                            # dernier --> rien à faire
+                            pass
+                        elif idx==len(curlist)-2:
+                            # avant-dernier --> passage en dernier
+                            curlist.append(myobj)
+                            curlist.pop(idx)
+                        elif idx<len(curlist)-2:
+                            curlist.insert(idx+2,myobj)
+                            curlist.pop(idx)
+
+            self.Refresh()
 
     def OnShowPopup(self, event):
         pos = event.GetPosition()
@@ -12008,6 +12414,7 @@ class WolfMapViewer(wx.Frame):
         #     CTRL+Shift+F4 : choix du pas sur base du temps (particle system)\n \
         #     F5 : autoscale\n \
         #     F7 : refresh\n \
+        #     F8 : Zoom on Whole Walonia\n \
         #     F9 : sélection de toutes les mailles dans la matrice courante\n \
         #     F11 : sélection sur matrice courante\n \
         #     F12 : opération sur matrice courante\n \
@@ -12075,6 +12482,7 @@ class WolfMapViewer(wx.Frame):
 
                      'F5': _('Drawing : autoscale'),
                      'F7': _('Drawing : refresh'),
+                     'F8': _('Drawing : zoom on whole Walonia'),
                      'Arrows': _('Drawing : lateral movements'),
                      'c or C': _('Drawing : copy canvas to Clipboard wo axes'),
                      'ALT+C': _('Drawing : copy canvas to Clipboard as Matplotlib image'),
@@ -12724,6 +13132,9 @@ class WolfMapViewer(wx.Frame):
             elif key == wx.WXK_F7:
                 self.update()
 
+            elif key == wx.WXK_F8:
+                self.zoom_on_whole_walonia()
+
             elif key == wx.WXK_F12 or key == wx.WXK_F11:
                 if self.active_array is not None:
                     self.active_array.myops.SetTitle(_('Operations on array: ')+self.active_array.idx)
@@ -12992,6 +13403,23 @@ class WolfMapViewer(wx.Frame):
 
             self.treelist.PopupMenu(self.popupmenu)
 
+    def zoom_on_whole_walonia(self):
+        """ Zoom on the whole Walonia """
+
+        xmin = 40_000
+        xmax = 300_000
+        ymin = 10_000
+        ymax = 175_000
+
+        self.mousex = (xmin + xmax) / 2.
+        self.mousey = (ymin + ymax) / 2.
+
+        self.width = xmax - xmin
+        self.height = ymax - ymin
+
+        self.setbounds()
+
+
     def update(self):
         """
         Update backgournd et foreground elements and arrays if local minmax is checked.
@@ -13898,4 +14326,328 @@ class Compare_Arrays_Results():
 
         self.set_elements()
         self.set_diff()
-        self.set_viewers()
+        self.set_viewers()
+
+class InPaint_waterlevel(wx.Dialog):
+
+    def __init__(self, parent, title:str = _('Inpainting'), size:tuple[int,int] = (400,400), mapviewer:WolfMapViewer=None, **kwargs):
+
+        super().__init__(parent, title = title, size = size, **kwargs)
+
+        self._array: WolfArray = None
+        self._dem: WolfArray = None
+        self._dtm: WolfArray = None
+
+        self._mapviewer = mapviewer
+
+        self._init_UI()
+
+    def _init_UI(self):
+        """ Create 2 listboxes for the arrays and the masks """
+        import shutil
+
+        if self._mapviewer is None:
+            logging.warning(_('No mapviewer --> Nothing to do'))
+            return
+
+        self._sizer = wx.BoxSizer(wx.VERTICAL)
+
+        self._sizer_lists = wx.BoxSizer(wx.HORIZONTAL)
+        self._sizer_arrays = wx.BoxSizer(wx.VERTICAL)
+        self._sizer_ignore = wx.BoxSizer(wx.VERTICAL)
+
+        self._label_arrays = wx.StaticText(self, wx.ID_ANY, _('Array'))
+        self._listbox_arrays = wx.ListBox(self, wx.ID_ANY, choices = self._mapviewer.get_list_keys(drawing_type = draw_type.ARRAYS), style = wx.LB_SINGLE)
+        self._label_dem = wx.StaticText(self, wx.ID_ANY, _('DEM'))
+        self._listbox_dems = wx.ListBox(self, wx.ID_ANY, choices = ['None'] + self._mapviewer.get_list_keys(drawing_type = draw_type.ARRAYS), style = wx.LB_SINGLE)
+        self._label_dtm = wx.StaticText(self, wx.ID_ANY, _('DTM'))
+        self._listbox_dtm = wx.ListBox(self, wx.ID_ANY, choices = ['None'] + self._mapviewer.get_list_keys(drawing_type = draw_type.ARRAYS), style = wx.LB_SINGLE)
+
+        self._label_ignore = wx.StaticText(self, wx.ID_ANY, _('Ignore last holes'))
+        self._listbox_ignore = wx.ListBox(self, wx.ID_ANY, choices = [str(i) for i in range(10)], style = wx.LB_SINGLE)
+
+        self._sizer_ignore.Add(self._label_ignore, 0, wx.EXPAND)
+        self._sizer_ignore.Add(self._listbox_ignore, 1, wx.EXPAND)
+
+        self._sizer_arrays.Add(self._label_arrays, 0, wx.EXPAND)
+        self._sizer_arrays.Add(self._listbox_arrays, 1, wx.EXPAND)
+        self._sizer_arrays.Add(self._label_dem, 0, wx.EXPAND)
+        self._sizer_arrays.Add(self._listbox_dems, 1, wx.EXPAND)
+        self._sizer_arrays.Add(self._label_dtm, 0, wx.EXPAND)
+        self._sizer_arrays.Add(self._listbox_dtm, 1, wx.EXPAND)
+
+        self._sizer_lists.Add(self._sizer_arrays, 1, wx.EXPAND)
+        self._sizer_lists.Add(self._sizer_ignore, 1, wx.EXPAND)
+
+        self._sizer.Add(self._sizer_lists, 1, wx.EXPAND)
+
+        self._sizer_btns = wx.BoxSizer(wx.HORIZONTAL)
+
+        self._sizer_inpaint = wx.BoxSizer(wx.VERTICAL)
+        self._btn_inpaint = wx.Button(self, wx.ID_ANY, _('Inpaint'))
+        self._sizer_inpaint.Add(self._btn_inpaint, 1, wx.EXPAND)
+
+        self._check_fortran = wx.CheckBox(self, wx.ID_ANY, _('Use Fortran'))
+        self._check_fortran.SetValue(False)
+        if shutil.which('holes.exe') is not None:
+            self._sizer_inpaint.Add(self._check_fortran, 1, wx.EXPAND)
+
+        self._btn_update_ids = wx.Button(self, wx.ID_ANY, _('Update IDs'))
+        self._btn_select_holes = wx.Button(self, wx.ID_ANY, _('Select holes'))
+        self._btn_create_mask = wx.Button(self, wx.ID_ANY, _('Create mask'))
+
+        self._sizer_btns.Add(self._sizer_inpaint, 1, wx.EXPAND)
+        self._sizer_btns.Add(self._btn_update_ids, 1, wx.EXPAND)
+        self._sizer_btns.Add(self._btn_select_holes, 1, wx.EXPAND)
+        self._sizer_btns.Add(self._btn_create_mask, 1, wx.EXPAND)
+
+        self._sizer.Add(self._sizer_btns, 1, wx.EXPAND)
+
+        self.SetSizer(self._sizer)
+
+        self._listbox_arrays.Bind(wx.EVT_LISTBOX, self.OnSelectArray)
+        self._listbox_dems.Bind(wx.EVT_LISTBOX, self.OnSelectMask)
+        self._listbox_dtm.Bind(wx.EVT_LISTBOX, self.OnSelectDTM)
+        self._btn_inpaint.Bind(wx.EVT_BUTTON, self.OnInpaint)
+        self._btn_update_ids.Bind(wx.EVT_BUTTON, self.OnUpdateIDs)
+        self._btn_select_holes.Bind(wx.EVT_BUTTON, self.OnSelectHoles)
+        self._btn_create_mask.Bind(wx.EVT_BUTTON, self.OnCreateMask)
+
+        self._listbox_dems.SetSelection(0)
+        self._listbox_dtm.SetSelection(0)
+        self._listbox_ignore.SetSelection(1)
+
+        self.CenterOnScreen()
+        self.Show()
+
+    def OnUpdateIDs(self, e):
+        """ Update the list of arrays/mask/dtm """
+
+        self._listbox_arrays.Set(self._mapviewer.get_list_keys(drawing_type = draw_type.ARRAYS))
+        self._listbox_dems.Set(['None'] + self._mapviewer.get_list_keys(drawing_type = draw_type.ARRAYS))
+        self._listbox_dtm.Set(['None'] + self._mapviewer.get_list_keys(drawing_type = draw_type.ARRAYS))
+
+    def OnSelectArray(self, e):
+        """ Select an array """
+
+        self._array = self._mapviewer.getobj_from_id(self._listbox_arrays.GetStringSelection())
+
+    def OnSelectMask(self, e):
+        """ Select a mask """
+
+        mask_ = self._listbox_dems.GetStringSelection()
+        if mask_ == 'None':
+            self._dem = None
+        else:
+            self._dem = self._mapviewer.getobj_from_id(self._listbox_dems.GetStringSelection())
+
+    def OnSelectDTM(self, e):
+        """ Select a DTM """
+
+        dtm_ = self._listbox_dtm.GetStringSelection()
+        if dtm_ == 'None':
+            self._dtm = None
+        else:
+            self._dtm = self._mapviewer.getobj_from_id(self._listbox_dtm.GetStringSelection())
+
+    def OnInpaint(self, e):
+        """ Inpaint the array with the mask """
+
+        if self._array is None:
+            logging.warning(_('Select an array, a mask and a DTM'))
+
+        else:
+            times, wl, wd = self._array._inpaint_waterlevel_dem_dtm(self._dem, self._dtm, ignore_last= self._listbox_ignore.GetSelection(), use_fortran= self._check_fortran.GetValue())
+            logging.info(_('Inpainting done !'))
+
+            dlg = wx.MessageDialog(None, _('Add water depth to the viewer ?'), _('Water depth'), style = wx.YES_NO|wx.YES_DEFAULT)
+            ret = dlg.ShowModal()
+
+            if ret == wx.ID_YES:
+                self._mapviewer.add_object('array', newobj = wd, id = 'wd_' + self._array.idx)
+
+            dlg.Destroy()
+
+    def OnSelectHoles(self, e):
+        """ Select the holes in the array """
+
+        if self._array is None:
+            logging.warning(_('Select an array'))
+            return
+
+        self._array.select_holes(ignore_last = self._listbox_ignore.GetSelection())
+        self._mapviewer.Paint()
+
+    def OnCreateMask(self, e):
+        """ Create a mask from the array """
+
+        if self._array is None:
+            logging.warning(_('Select an array, a mask and a DTM'))
+            return
+
+        if self._dem is None:
+            logging.warning(_('Select a dem'))
+            return
+
+        if self._dtm is None:
+            logging.warning(_('Select a dtm'))
+            return
+
+        newmask = self._array._create_building_holes_dem_dtm(self._dem, self._dtm, ignore_last= self._listbox_ignore.GetSelection())
+        self._mapviewer.add_object('array', newobj = newmask, id = 'mask_' + self._array.idx)
+
+class InPaint_array(wx.Dialog):
+
+    def __init__(self, parent, title:str = _('Inpainting'), size:tuple[int,int] = (400,400), mapviewer:WolfMapViewer=None, **kwargs):
+
+        super().__init__(parent, title = title, size = size, **kwargs)
+
+        self._array: WolfArray = None
+        self._mask: WolfArray = None
+        self._test: WolfArray = None
+
+        self._mapviewer = mapviewer
+
+        self._init_UI()
+
+    def _init_UI(self):
+        """ Create 2 listboxes for the arrays and the masks """
+        import shutil
+
+        if self._mapviewer is None:
+            logging.warning(_('No mapviewer --> Nothing to do'))
+            return
+
+        self._sizer = wx.BoxSizer(wx.VERTICAL)
+
+        self._sizer_lists = wx.BoxSizer(wx.HORIZONTAL)
+        self._sizer_arrays = wx.BoxSizer(wx.VERTICAL)
+        self._sizer_ignore = wx.BoxSizer(wx.VERTICAL)
+
+        self._label_arrays = wx.StaticText(self, wx.ID_ANY, _('Array'))
+        self._listbox_arrays = wx.ListBox(self, wx.ID_ANY, choices = self._mapviewer.get_list_keys(drawing_type = draw_type.ARRAYS), style = wx.LB_SINGLE)
+        self._label_masks = wx.StaticText(self, wx.ID_ANY, _('Mask == where to inpaint'))
+        self._listbox_masks = wx.ListBox(self, wx.ID_ANY, choices = ['None'] + self._mapviewer.get_list_keys(drawing_type = draw_type.ARRAYS), style = wx.LB_SINGLE)
+        self._label_test = wx.StaticText(self, wx.ID_ANY, _('Test == local inpainted value must be greater than this value'))
+        self._listbox_test = wx.ListBox(self, wx.ID_ANY, choices = ['None'] + self._mapviewer.get_list_keys(drawing_type = draw_type.ARRAYS), style = wx.LB_SINGLE)
+
+        self._label_ignore = wx.StaticText(self, wx.ID_ANY, _('Ignore last holes'))
+        self._listbox_ignore = wx.ListBox(self, wx.ID_ANY, choices = [str(i) for i in range(10)], style = wx.LB_SINGLE)
+
+        self._sizer_ignore.Add(self._label_ignore, 0, wx.EXPAND)
+        self._sizer_ignore.Add(self._listbox_ignore, 1, wx.EXPAND)
+
+        self._sizer_arrays.Add(self._label_arrays, 0, wx.EXPAND)
+        self._sizer_arrays.Add(self._listbox_arrays, 1, wx.EXPAND)
+        self._sizer_arrays.Add(self._label_masks, 0, wx.EXPAND)
+        self._sizer_arrays.Add(self._listbox_masks, 1, wx.EXPAND)
+        self._sizer_arrays.Add(self._label_test, 0, wx.EXPAND)
+        self._sizer_arrays.Add(self._listbox_test, 1, wx.EXPAND)
+
+        self._sizer_lists.Add(self._sizer_arrays, 1, wx.EXPAND)
+        self._sizer_lists.Add(self._sizer_ignore, 1, wx.EXPAND)
+
+        self._sizer.Add(self._sizer_lists, 1, wx.EXPAND)
+
+        self._sizer_btns = wx.BoxSizer(wx.HORIZONTAL)
+
+        self._sizer_inpaint = wx.BoxSizer(wx.VERTICAL)
+        self._btn_inpaint = wx.Button(self, wx.ID_ANY, _('Inpaint'))
+        self._sizer_inpaint.Add(self._btn_inpaint, 1, wx.EXPAND)
+
+        self._btn_update_ids = wx.Button(self, wx.ID_ANY, _('Update IDs'))
+        self._btn_select_holes = wx.Button(self, wx.ID_ANY, _('Select holes'))
+        self._btn_create_mask = wx.Button(self, wx.ID_ANY, _('Create mask'))
+
+        self._sizer_btns.Add(self._sizer_inpaint, 1, wx.EXPAND)
+        self._sizer_btns.Add(self._btn_update_ids, 1, wx.EXPAND)
+        self._sizer_btns.Add(self._btn_select_holes, 1, wx.EXPAND)
+        self._sizer_btns.Add(self._btn_create_mask, 1, wx.EXPAND)
+
+        self._sizer.Add(self._sizer_btns, 1, wx.EXPAND)
+
+        self.SetSizer(self._sizer)
+
+        self._listbox_arrays.Bind(wx.EVT_LISTBOX, self.OnSelectArray)
+        self._listbox_masks.Bind(wx.EVT_LISTBOX, self.OnSelectMask)
+        self._listbox_test.Bind(wx.EVT_LISTBOX, self.OnSelectTest)
+        self._btn_inpaint.Bind(wx.EVT_BUTTON, self.OnInpaint)
+        self._btn_update_ids.Bind(wx.EVT_BUTTON, self.OnUpdateIDs)
+        self._btn_select_holes.Bind(wx.EVT_BUTTON, self.OnSelectHoles)
+        self._btn_create_mask.Bind(wx.EVT_BUTTON, self.OnCreateMask)
+
+        self._listbox_masks.SetSelection(0)
+        self._listbox_test.SetSelection(0)
+        self._listbox_ignore.SetSelection(0)
+
+        self.CenterOnScreen()
+        self.Show()
+
+    def OnUpdateIDs(self, e):
+        """ Update the list of arrays/mask/dtm """
+
+        self._listbox_arrays.Set(self._mapviewer.get_list_keys(drawing_type = draw_type.ARRAYS))
+        self._listbox_masks.Set(['None'] + self._mapviewer.get_list_keys(drawing_type = draw_type.ARRAYS))
+        self._listbox_test.Set(['None'] + self._mapviewer.get_list_keys(drawing_type = draw_type.ARRAYS))
+
+    def OnSelectArray(self, e):
+        """ Select an array """
+
+        self._array = self._mapviewer.getobj_from_id(self._listbox_arrays.GetStringSelection())
+
+    def OnSelectMask(self, e):
+        """ Select a mask """
+
+        mask_ = self._listbox_masks.GetStringSelection()
+        if mask_ == 'None':
+            self._mask = None
+        else:
+            self._mask = self._mapviewer.getobj_from_id(self._listbox_masks.GetStringSelection())
+
+    def OnSelectTest(self, e):
+        """ Select a DTM """
+
+        dtm_ = self._listbox_test.GetStringSelection()
+        if dtm_ == 'None':
+            self._test = None
+        else:
+            self._test = self._mapviewer.getobj_from_id(self._listbox_test.GetStringSelection())
+
+    def OnInpaint(self, e):
+        """ Inpaint the array with the mask """
+
+        if self._array is None:
+            logging.warning(_('Select an array, a mask and a DTM'))
+
+        else:
+
+            times, wl, wd = self._array.inpaint(self._mask, self._test, ignore_last= self._listbox_ignore.GetSelection())
+            logging.info(_('Inpainting done !'))
+
+            dlg = wx.MessageDialog(None, _('Add extra array to the viewer ?'), _('Inerpolation - test data'), style = wx.YES_NO|wx.YES_DEFAULT)
+            ret = dlg.ShowModal()
+
+            if ret == wx.ID_YES:
+                self._mapviewer.add_object('array', newobj = wd, id = 'extra_' + self._array.idx)
+
+            dlg.Destroy()
+
+    def OnSelectHoles(self, e):
+        """ Select the holes in the array """
+
+        if self._mask is None:
+            logging.warning(_('Select a mask array'))
+            return
+
+        self._mask.select_holes(ignore_last = self._listbox_ignore.GetSelection())
+        self._mapviewer.Paint()
+
+    def OnCreateMask(self, e):
+        """ Create a mask from the array """
+
+        if self._array is None:
+            logging.warning(_('Select an array'))
+            return
+
+        newmask = self._array.create_mask_holes(ignore_last= self._listbox_ignore.GetSelection())
+        self._mapviewer.add_object('array', newobj = newmask, id = 'mask_' + self._array.idx)