wolfhece 2.2.2__py3-none-any.whl → 2.2.4__py3-none-any.whl

wolfhece/PyDraw.py

@@ -7,6 +7,11 @@ Copyright (c) 2024 University of Liege. All rights reserved.
 This script and its content are protected by copyright law. Unauthorized
 copying or distribution of this file, via any medium, is strictly prohibited.
 """
+try:
+    from osgeo import gdal
+except ImportError as e:
+    print(e)
+    raise ImportError("I can't find the 'gdal' package. You should get it from https://www.lfd.uci.edu/~gohlke/pythonlibs/")
 
 try:
     import numpy as np
@@ -24,24 +29,18 @@ try:
     import json
     import glob
     import traceback
-    from datetime import datetime, timedelta
+    from datetime import datetime
     from sklearn import linear_model, datasets
 
 except ImportError as e:
     print(e)
     raise ImportError("Error importing wxPython, numpy, PIL, json, glob, traceback, sklearn. Please check your installation.")
 
-try:
-    from osgeo import gdal
-except ModuleNotFoundError:
-    raise Exception("I can't find the 'gdal' package. You should get it from https://www.lfd.uci.edu/~gohlke/pythonlibs/")
-
 try:
     from time import sleep
     from datetime import timedelta
     from multiprocessing import Pool
     from pathlib import Path
-    from time import sleep
 except ImportError as e:
     print(e)
     raise ImportError("Error importing time, datetime, multiprocessing, pathlib. Please check your installation.")
@@ -97,6 +96,11 @@ except ImportError as e:
     print(e)
     raise ImportError("Error importing wolf_texture, xyz_file, mesh2d, PyPalette, wolfresults_2D, PyTranslate, PyVertex, RatingCurve, wolf_array, PyParams, mesh2d.bc_manager, PyVertexvectors, Results2DGPU, PyCrosssections, GraphNotebook, lazviewer, picc, wolf_zi_db, math_parser.calculator, wintab. Please check your installation.")
 
+try:
+    from .dike import DikeWolf, Wolf_Param_dike
+except:
+    logging.warning(_("Missing package. Install wolfpydike module via pip."))
+
 try:
     from .hydrometry.kiwis_wolfgui import hydrometry_wolfgui
 except ImportError as e:
@@ -125,6 +129,12 @@ except ImportError as e:
     print(e)
     raise ImportError("Error importing apps.curvedigitizer. Please check your installation.")
 
+try:
+    from .drowning_victims.drowning_class import Drowning_victim_Viewer
+except ImportError as e:
+    print(e)
+    raise ImportError("Error importing Drowning_victims.Class. Please check your installation.")
+
 ID_SELECTCS = 1000
 ID_SORTALONG = 1001
 ID_LOCMINMAX = 1002
@@ -603,6 +613,8 @@ class draw_type(Enum):
     TILES = 'tiles'
     IMAGESTILES = 'imagestiles'
     LAZ = 'laz'
+    DROWNING = 'drowning'
+    DIKE = 'dike'
 
 class Colors_1to9(wx.Frame):
 
@@ -1197,6 +1209,273 @@ class Sim_Explorer(wx.Frame):
         self._step_num.Set([str(i) for i in self._all_times_steps[1]])
 
 
+class Drowning_Explorer(wx.Frame):
+
+    def __init__(self, parent, title, mapviewer:any, sim:Drowning_victim_Viewer):
+
+        super().__init__(parent, title=title, size=(150, 250), style = wx.DEFAULT_FRAME_STYLE & ~ (wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX))
+
+        self._panel = wx.Panel(self)
+
+        self.mapviewer = mapviewer
+        self.active_drowning:Drowning_victim_Viewer = sim
+
+        main_sizer = wx.BoxSizer(wx.HORIZONTAL)
+
+        left_bar = wx.BoxSizer(wx.VERTICAL)
+        right_bar = wx.BoxSizer(wx.VERTICAL)
+
+        self._all_times_steps = self.active_drowning.wanted_time
+
+        # Right bar
+        # ---------
+
+        # Slider
+        self._slider_steps = wx.Slider(self._panel, minValue=1, maxValue=len(self.active_drowning.wanted_time)-1, style=wx.SL_HORIZONTAL | wx.SL_AUTOTICKS | wx.SL_MIN_MAX_LABELS | wx.SL_LABELS)
+        self._slider_steps.Bind(wx.EVT_SLIDER, self.OnSliderSteps)
+        right_bar.Add(self._slider_steps, 1, wx.EXPAND | wx.ALL, 2)
+
+        self._time_drowning = wx.TextCtrl(self._panel, value=f"Drowning at 0 days, 0 hours,\n0 minutes and 0 seconds", style=wx.TE_MULTILINE | wx.TE_READONLY | wx.TE_CENTER)
+        right_bar.Add(self._time_drowning, 0, wx.EXPAND | wx.ALL, 2)
+
+        # Explore by time
+        self._label_time = wx.StaticText(self._panel, label=_('Time [s]'))
+        right_bar.Add(self._label_time, 1, wx.EXPAND | wx.ALL, 2)
+
+        _now = datetime.now()
+        self._starting_date = datetime(year=_now.year, month=_now.month, day=_now.day, hour=0, minute=0, second=0)
+        self._texttime = wx.TextCtrl(self._panel, value=self._starting_date.strftime('%Y-%m-%d %H:%M:%S'))
+        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[:-1]], 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)
+
+        self._step_idx = wx.ListBox(self._panel, choices=[str(i) for i in range(1, len(self.active_drowning.wanted_time)-1+1)], style=wx.LB_SINGLE)
+        self._step_idx.Bind(wx.EVT_LISTBOX, self.OnSelectIdxStep)
+        right_bar.Add(self._step_idx, 1, wx.EXPAND | wx.ALL, 5)
+
+        # Left bar
+        # --------
+
+        # Apply selected step
+        self._cmd_apply = wx.Button(self._panel, wx.ID_APPLY, _('Apply'))
+        self._cmd_apply.SetToolTip(_('Apply the selected parameters to the map'))
+        self._cmd_apply.Bind(wx.EVT_BUTTON, self.OnApply)
+        left_bar.Add(self._cmd_apply, 1, wx.EXPAND | wx.ALL, 5)
+
+        # Next step
+        self._cmd_next = wx.Button(self._panel, wx.ID_FORWARD, _('Next'))
+        self._cmd_next.SetToolTip(_('Go to the next step -- using the selected mode'))
+        self._cmd_next.Bind(wx.EVT_BUTTON, self.OnNext)
+        left_bar.Add(self._cmd_next, 1, wx.EXPAND | wx.ALL, 5)
+
+        # Previous step
+        self._cmd_prev = wx.Button(self._panel, wx.ID_BACKWARD, _('Previous'))
+        self._cmd_prev.SetToolTip(_('Go to the previous step -- using the selected mode'))
+        self._cmd_prev.Bind(wx.EVT_BUTTON, self.OnPrev)
+        left_bar.Add(self._cmd_prev, 1, wx.EXPAND | wx.ALL, 5)
+
+        self.Bind(wx.EVT_CLOSE, self.OnClose)
+
+        main_sizer.Add(left_bar, 1, wx.EXPAND | wx.ALL, 2)
+        main_sizer.Add(right_bar, 1, wx.EXPAND | wx.ALL, 2)
+
+        self._panel.SetSizer(main_sizer)
+        self._panel.SetAutoLayout(True)
+
+        self.MinSize = (450, 500)
+
+        self.Fit()
+        self.Show()
+
+        self.SetIcon(wx.Icon(str(Path(__file__).parent / "apps/wolf_logo2.bmp")))
+
+        self._set_all(0)
+
+    def _find_next(self, idx:int):
+        """ Find the next step based on the mode and interval """
+
+        mode = 2
+        if mode == 0:
+            # By time [s]
+            next_time = self._all_times_steps[idx] + float(self._interval.GetValue())
+            diff = [abs(next_time - i) for i in self._all_times_steps[idx:]]
+            next_idx = diff.index(min(diff)) + idx
+
+            return next_idx
+
+        elif mode == 1:
+            # By time [hour]
+            next_time = self._all_times_steps[idx] + float(self._interval.GetValue())*3600
+            diff = [abs(next_time - i) for i in self._all_times_steps[idx:]]
+            next_idx = diff.index(min(diff)) + idx
+
+            return next_idx
+
+        elif mode == 2:
+            # By index
+            next_idx = min(idx + int(1), len(self._all_times_steps)-1)
+
+            return next_idx
+
+        elif mode == 3:
+            # By time step
+            next_idx = self._all_times_steps[1].index(self._all_times_steps[idx] + int(1))
+            diff = [abs(next_idx - i) for i in self._all_times_steps[idx:]]
+            next_idx = diff.index(min(diff)) + idx
+
+            return next_idx
+
+    def _find_prev(self, idx:int):
+        """ Find the previous step based on the mode and interval """
+
+        mode = 2
+
+        if mode == 0:
+            # By time [s]
+            prev_time = self._all_times_steps[idx] - float(1)
+            diff = [abs(prev_time - i) for i in self._all_times_steps[:idx]]
+            prev_idx = diff.index(min(diff))
+
+            return prev_idx
+
+        elif mode == 1:
+            # By time [hour]
+            prev_time = self._all_times_steps[idx] - float(1)*3600
+            diff = [abs(prev_time - i) for i in self._all_times_steps[:idx]]
+            prev_idx = diff.index(min(diff))
+
+            return prev_idx
+
+        elif mode == 2:
+            # By index
+            prev_idx = max(idx - int(1), 0)
+
+            return prev_idx
+
+        elif mode == 3:
+            # By time step
+            prev_idx = self._all_times_steps[1].index(self._all_times_steps[idx] - int(1))
+            diff = [abs(prev_idx - i) for i in self._all_times_steps[:idx]]
+            prev_idx = diff.index(min(diff))
+
+            return prev_idx
+
+    def OnNext(self, event):
+        """ Go to the next step """
+
+        selected_step = self._slider_steps.GetValue()+1
+        next_idx = self._find_next(selected_step)
+
+        if next_idx != selected_step:
+            self._set_all(next_idx)
+            self.Refresh(next_idx)
+
+    def OnTextTime(self, event):
+        try:
+            self._starting_date = datetime.strptime(self._texttime.GetValue(), '%Y-%m-%d %H:%M:%S')
+            self._step_time.Set(['{:.3f} - {}'.format(int(i/3600/24), datetime.strftime(self._starting_date + timedelta(seconds=i), '%Y-%m-%d %H:%M:%S')) for i in self._all_times_steps[:-1]])
+        except:
+            pass
+
+    def OnPrev(self, event):
+        """ Go to the previous step """
+
+        selected_step = self._slider_steps.GetValue()-1
+        prev_idx = self._find_prev(selected_step)
+
+        if prev_idx != selected_step:
+            self._set_all(prev_idx)
+            self.Refresh(prev_idx)
+
+    def OnClose(self, event):
+        """ Close the simulation explorer """
+
+        self.mapviewer._pop_sim_explorer(self.active_drowning)
+        self.Destroy()
+
+    def OnUpdate(self, event):
+        self._update()
+
+    def OnApply(self, event):
+        selected_step = self._slider_steps.GetValue()-1
+
+        self._cmd_apply.SetBackgroundColour(wx.Colour(255, 0, 0))  # Set button color to red
+        self._cmd_apply.Refresh()  # Refresh the button to apply the color change
+
+        self.Refresh(selected_step)
+
+        self._cmd_apply.SetBackgroundColour(wx.NullColour)  # Reset button color to default
+        self._cmd_apply.Refresh()  # Refresh the button to apply the color change
+
+    def _set_all(self, idx:int):
+        self._slider_steps.SetValue(idx+1)
+        self._step_idx.SetSelection(idx)
+
+    def Refresh(self, idx:int):
+        self.active_drowning.read_oneresult(idx)
+        self.mapviewer.Refresh()
+
+    def OnSliderSteps(self, event):
+        selected_step = self._slider_steps.GetValue()-1
+        self.active_drowning.time_id = selected_step
+        time_id = self._slider_steps.GetValue()-1
+        time_value = self.active_drowning.wanted_time[time_id]
+
+        days = np.floor(time_value // 86400)
+        hours = np.floor((time_value % 86400) / 3600)
+        minutes = np.floor(((time_value % 86400) % 3600) / 60)
+        seconds = np.floor(((time_value % 86400) % 3600) % 60)
+
+        self._time_drowning.SetValue(
+            f"Drowning at {int(days)} days, {int(hours)} hours,\n"
+            f"{int(minutes)} minutes and {int(seconds)} seconds"
+        )
+        self._set_all(selected_step)
+
+    def OnSelectNumStep(self, event):
+        selected_step = self._step_time.GetSelection()
+        self.active_drowning.time_id = selected_step
+        time_id = selected_step
+        time_value = self.active_drowning.wanted_time[time_id]
+
+        days = np.floor(time_value // 86400)
+        hours = np.floor((time_value % 86400) / 3600)
+        minutes = np.floor(((time_value % 86400) % 3600) / 60)
+        seconds = np.floor(((time_value % 86400) % 3600) % 60)
+
+        self._time_drowning.SetValue(
+            f"Drowning at {int(days)} days, {int(hours)} hours,\n"
+            f"{int(minutes)} minutes and {int(seconds)} seconds"
+        )
+        self._set_all(selected_step)
+
+    def OnSelectIdxStep(self, event):
+        selected_step = self._step_idx.GetSelection()
+        self.active_drowning.time_id = selected_step
+        time_id = selected_step
+        time_value = self.active_drowning.wanted_time[time_id]
+
+        days = np.floor(time_value // 86400)
+        hours = np.floor((time_value % 86400) / 3600)
+        minutes = np.floor(((time_value % 86400) % 3600) / 60)
+        seconds = np.floor(((time_value % 86400) % 3600) % 60)
+
+        self._time_drowning.SetValue(
+            f"Drowning at {int(days)} days, {int(hours)} hours,\n"
+            f"{int(minutes)} minutes and {int(seconds)} seconds"
+        )
+        self._set_all(selected_step)
+
+    def _update(self):
+        nb = len(self.active_drowning.wanted_time)
+        self._all_times_steps = self.active_drowning.wanted_time
+
+        self._slider_steps.SetMax(nb)
+        self._step_idx.Set([str(i) for i in range(1,nb+1)])
+
 class Select_Begin_end_interval_step(wx.Dialog):
     """ wx.frame to select the begin and end of the interval to extract """
 
@@ -1636,6 +1915,8 @@ class WolfMapViewer(wx.Frame):
     mypartsystems: list[Particle_system]
     myviewers3d:list[Wolf_Viewer3D]
     mylazdata:list[Wolf_LAZ_Data]
+    mydrownings: list[Drowning_victim_Viewer]
+    mydikes: list[DikeWolf]
 
     mymplfigs:list[MplFigViewer]
 
@@ -1670,9 +1951,32 @@ class WolfMapViewer(wx.Frame):
     active_weirs : Weirs
     active_weir : Weir
     active_laz : Wolf_LAZ_Data
+    active_drowning: Drowning_victim_Viewer
+    active_dike : DikeWolf
 
     active_fig: MplFigViewer
 
+
+    # def check_user_activity(self, *args):
+    #     while True:
+    #         sleep(1)
+    #         if datetime.now() - self._last_activity_time > timedelta(seconds=3): # 5 secondes d'inactivité
+    #             args[0]._user_active = False
+
+    # def _user_activity_true(self):
+    #     self._user_active = True
+    #     self._last_activity_time = datetime.now()
+
+    # def background_task(self, *args):
+
+    #     while args[0]._user_active:
+    #         sleep(1)
+
+    #     args[0]._update_background()
+    #     args[0].Paint()
+
+    #     args[0]._thread_update_background = None
+
     def __init__(self,
                  wxparent = None,
                  title:str = _('Default Wolf Map Viewer'),
@@ -1695,6 +1999,12 @@ class WolfMapViewer(wx.Frame):
 
         """
 
+        # self._user_active = True # True if the user is active in the viewer
+        # self._last_activity_time  = datetime.now() # last time the user was active in the viewer
+        # self._check_activity_thread = threading.Thread(target=self.check_user_activity, args=[self]) # thread to check user activity
+        # self._check_activity_thread.start() # start the thread
+        # self._thread_update_background = None # thread to update the background
+
         self.treewidth = treewidth
         super(WolfMapViewer, self).__init__(wxparent, title=title, size=(w + self.treewidth, h))
 
@@ -1758,7 +2068,7 @@ class WolfMapViewer(wx.Frame):
         self.popupmenu = wx.Menu()
         self.popupmenu.Bind(wx.EVT_MENU, self.OnPopupItemSelected)
 
-        for text in [_('Save'), _('Save as'), _('Rename'), _('Duplicate'), _('Delete'), _('Up'), _('Down'), _('Properties')]:
+        for text in [_('Save'), _('Save as'), _('Rename'), _('Duplicate'), _('Delete'), _('Up'), _('Down'), _('Check/Uncheck'), _('Properties')]:
             item = self.popupmenu.Append(-1, text)
 
         self.menubar = wx.MenuBar()
@@ -1777,6 +2087,8 @@ class WolfMapViewer(wx.Frame):
         self.menulaz    = None
         self.menutiles  = None
         self.menuimagestiles = None
+        self.menudrowning = None
+        self.menudike = None
 
         self.filemenu = wx.Menu()
         openitem = self.filemenu.Append(wx.ID_OPEN, _('Open/Add project'), _('Open a full project from file'))
@@ -1854,6 +2166,8 @@ class WolfMapViewer(wx.Frame):
         createbcmanager2D = self.menucreateobj.Append(wx.ID_ANY, _('Create BC manager Wolf2D...'), _('New BC manager 2D'))
         createpartsystem = self.menucreateobj.Append(wx.ID_ANY, _('Create particle system...'), _('Create a particle system - Lagrangian view'))
         create_acceptability = self.menucreateobj.Append(wx.ID_ANY, _('Create acceptability manager...'), _('Create acceptability manager'))
+        createdrowning = self.menucreateobj.Append(wx.ID_ANY, _('Create a drowning...'),_('Create a drowning'))
+        createdike = self.menucreateobj.Append(wx.ID_ANY, _('Create dike...'), _('New dike'))
 
         self.filemenu.AppendSeparator()
 
@@ -1879,6 +2193,8 @@ class WolfMapViewer(wx.Frame):
         addbridges = self.menuaddobj.Append(wx.ID_ANY, _('Add bridges...'), _('Add bridges from directory'))
         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'))
+        adddrowning = self.menuaddobj.Append(wx.ID_ANY, _('Add a drowning result...'),_('Add a drowning result'))
+        adddike = self.menuaddobj.Append(wx.ID_ANY, _('Add dike...'), _('Add dike'))
 
         self.precomputed_menu = None
         if self.default_dem != "":
@@ -2047,8 +2363,10 @@ class WolfMapViewer(wx.Frame):
         self.active_weirs = None
         self.active_weir = None
         self.active_laz = None
+        self.active_dike = None
 
         self.active_fig = None
+        self.active_drowning = None
 
         curtool = self.tools[ID_SORTALONG] = {}
         curtool['menu'] = self.sortalong
@@ -2108,6 +2426,8 @@ class WolfMapViewer(wx.Frame):
         self.myitemsviews  = self.treelist.AppendItem(self.root, _("Views"))
         self.myitemswmsback = self.treelist.AppendItem(self.root, _("WMS-background"))
         self.myitemswmsfore = self.treelist.AppendItem(self.root, _("WMS-foreground"))
+        self.myitemsdrowning = self.treelist.AppendItem(self.root,_("Drowning"))
+        self.myitemsdike    = self.treelist.AppendItem(self.root, _("Dikes"))
 
         width, height = self.GetClientSize()
         self.bordersize = int((w - width + self.treewidth) / 2)
@@ -2584,6 +2904,62 @@ class WolfMapViewer(wx.Frame):
 
             self.menuwalous.Bind(wx.EVT_MENU, self.Onmenuwalous)
 
+    def menu_drowning(self):
+
+        if self.menudrowning is None:
+
+            self.menudrowning = wx.Menu()
+
+            self.menudrowning_plot = wx.Menu()
+
+            self.menudrowning_explore_results = self.menudrowning.Append(wx.ID_ANY, _("Explore time/index results"), _("Open a dialog to explore time/index results"))
+
+            self.menudrowning.AppendSeparator()
+
+            self.menudrowning.Append(wx.ID_ANY, _("Plot..."),self.menudrowning_plot)
+            self.plot_runs = self.menudrowning_plot.Append(wx.ID_ANY, _("Plot runs positions"), _("Plot runs positions"),kind=wx.ITEM_CHECK)
+            self.plot_cells = self.menudrowning_plot.Append(wx.ID_ANY, _("Plot cells positions"), _("Plot the cells where bodies colored as a function of bodies in it"),kind=wx.ITEM_CHECK)
+            self.plot_KDE = self.menudrowning_plot.Append(wx.ID_ANY, _("Plot KDE"), _("Plot Kernel Density Estimation - Map of probability of presence"),kind=wx.ITEM_CHECK)
+
+            self.menudrowning_lastres = self.menudrowning.Append(wx.ID_ANY, _("Read last result"), _("Current view"))
+
+            self.menudrowning_zoom = self.menudrowning.Append(wx.ID_ANY, _("Zoom on hotspots"), _("Zoom on areas where you have the highest probability of presence"))
+
+            self.menudrowning.AppendSeparator()
+
+            self.menudrowning_get_bodies = self.menudrowning.Append(wx.ID_ANY, _("Get bodies characteristics"), _("Get a table of the characteristics of all simulated bodies"))
+            self.menudrowning_get_perc = self.menudrowning.Append(wx.ID_ANY, _("Vertical position proportion"), _("Get proportion of runs at the surface and at the bottom at selected time"))
+
+            self.menudrowning.AppendSeparator()
+
+            self.menudrowning_video = self.menudrowning.Append(wx.ID_ANY, _("Create video..."), _("Video/Movie"))
+
+            self.menubar.Append(self.menudrowning, _('Drowning'))
+
+            self.menudrowning.Bind(wx.EVT_MENU, self.Onmenudrowning)
+
+    def menu_dike(self):
+
+        if self.menudike is None:
+            self.menudike = wx.Menu()
+
+            self.menudike_launchsimu = self.menudike.Append(wx.ID_ANY, _("Launch simulation"), _("Launch simulation"))
+
+            self.menudike.AppendSeparator()
+
+            self.menudike_showtri = self.menudike.Append(wx.ID_ANY, _("Show triangulation"), _("Show triangulation"))
+            self.menudike_plotQ = self.menudike.Append(wx.ID_ANY, _("Plot discharges"), _("Plot discharges"))
+            self.menudike_plotz = self.menudike.Append(wx.ID_ANY, _("Plot water levels/breach bottom"), _("Plot water levels/breach bottom"))
+            self.menudike_plotB = self.menudike.Append(wx.ID_ANY, _("Plot breach width"), _("Plot breach width"))
+
+            self.menudike.AppendSeparator()
+
+            self.menudike_showparam = self.menudike.Append(wx.ID_ANY, _("Show parameters"), _("Show parameters"))
+
+            self.menubar.Append(self.menudike, _('Dike'))
+
+            self.menudike.Bind(wx.EVT_MENU, self.Onmenudike)
+
 
     def get_canvas_bounds(self, gridsize:float = None):
         """
@@ -2786,6 +3162,115 @@ class WolfMapViewer(wx.Frame):
         if which in self.sim_explorers:
             self.sim_explorers[which]._set_all(which.current_result)
 
+    def Onmenudrowning(self, event: wx.MenuEvent):
+
+        id = event.GetId()
+        item = self.menubar.FindItemById(event.GetId())
+
+        if item is None:
+            return
+
+        itemlabel = item.ItemLabel
+
+
+        if itemlabel == _("Read last result"):
+
+            self.active_drowning.read_last_result()
+            self.Refresh()
+            self._update_mytooltip()
+
+        elif itemlabel == _("Explore time/index results"):
+            if self.active_drowning is None:
+                logging.warning(_('No active drowning ! -- Please activate a drowning first'))
+                return
+            which = self.active_drowning
+            self.sim_explorers[which] = Drowning_Explorer(self,title=f'Explore drowning results: {self.active_drowning.idx}',mapviewer=self, sim=which)
+
+        elif itemlabel == _("Plot runs positions"):
+            if self.plot_runs.IsChecked():
+                self.active_drowning.prepare_plot_runs_positions()
+            else:
+                self.active_drowning.reset_plot_runs_positions()
+            self._update_mytooltip()
+            self.Refresh()
+
+
+        elif itemlabel == _("Plot cells positions"):
+            if self.plot_cells.IsChecked():
+                self._update_mytooltip()
+                self.active_drowning.prepare_plot_cells_positions()
+            else:
+                self.active_drowning.reset_plot_cells_positions()
+            self._update_mytooltip()
+            self.Refresh()
+
+        elif itemlabel == _("Plot KDE"):
+            if self.plot_KDE.IsChecked():
+                self.active_drowning.prepare_plot_kde()
+            else:
+                self.active_drowning.reset_plot_kde()
+            self._update_mytooltip()
+            self.Refresh()
+
+        elif itemlabel == _("Zoom on hotspots"):
+            self.memory_views = Memory_Views()
+            self.active_drowning.zoom_on_hotspots(self.memory_views)
+            self._memory_views_gui = Memory_Views_GUI(self, _('Memory view manager'), self.memory_views, mapviewer = self)
+
+        elif itemlabel == _("Get bodies characteristics"):
+            self.active_drowning.get_bodies_characteristics()
+
+        elif itemlabel == _("Vertical position proportion"):
+            self.active_drowning.get_vertical_position_proportion()
+
+        elif itemlabel == _("Create video..."):
+            logging.info(_("Not yet implemeted"))
+            return
+
+
+    def Onmenudike(self, event: wx.MenuEvent):
+
+        id = event.GetId()
+        item = self.menubar.FindItemById(event.GetId())
+
+        if item is None:
+            return
+
+        itemlabel = item.ItemLabel
+
+        if self.active_dike is None:
+            logging.warning(_('No active dike -- Please activate a dike first'))
+            return
+
+        class plot_types(Enum):
+            """
+            Enum class for plot types.
+            """
+            DISCHARGES = 0
+            LEVELS = 1
+            BREACHWIDTH = 2
+
+        if itemlabel == _("Launch simulation"):
+
+            self.active_dike.run()
+
+        elif itemlabel == _("Show triangulation"):
+
+            self.active_dike.show_triangulation()
+
+        elif itemlabel == _("Plot discharges"):
+            self.active_dike.plot_mainOutputs(plot_types.DISCHARGES.value)
+
+        elif itemlabel == _("Plot water levels/breach bottom"):
+            self.active_dike.plot_mainOutputs(plot_types.LEVELS.value)
+
+        elif itemlabel == _("Plot breach width"):
+            self.active_dike.plot_mainOutputs(plot_types.BREACHWIDTH.value)
+
+        elif itemlabel == _("Show parameters"):
+            self.active_dike.show_properties()
+
+
     def Onmenuwolf2d(self, event: wx.MenuEvent):
 
         id = event.GetId()
@@ -4519,6 +5004,7 @@ class WolfMapViewer(wx.Frame):
         self.canvas.Bind(wx.EVT_RIGHT_DCLICK, self.On_Right_Double_Clicks)
         self.canvas.Bind(wx.EVT_LEFT_DCLICK, self.On_Left_Double_Clicks)
         self.canvas.Bind(wx.EVT_LEFT_DOWN, self.On_Mouse_Left_Down)
+        self.canvas.Bind(wx.EVT_LEFT_UP, self.On_Mouse_Left_Up)
         self.canvas.Bind(wx.EVT_MIDDLE_DOWN, self.On_Mouse_Left_Down)
         self.canvas.Bind(wx.EVT_RIGHT_DOWN, self.On_Mouse_Right_Down)
         self.canvas.Bind(wx.EVT_RIGHT_UP, self.On_Mouse_Right_Up)
@@ -4551,13 +5037,15 @@ class WolfMapViewer(wx.Frame):
         self.myviewers3d = []
         self.myviewerslaz = []
         self.mylazdata = []
+        self.mydrownings = []
+        self.mydikes = []
 
         self.mymplfigs = []
 
         self.sim_explorers = {}
 
         # liste des éléments modifiable dans l'arbre
-        self.all_lists = [self.myarrays, self.myvectors, self.myclouds, self.mytri, self.myothers, self.myviews, self.myres2D, self.mytiles, self.myimagestiles, self.mypartsystems, self.myviewers3d, self.myviewerslaz]
+        self.all_lists = [self.myarrays, self.myvectors, self.myclouds, self.mytri, self.myothers, self.myviews, self.myres2D, self.mytiles, self.myimagestiles, self.mypartsystems, self.myviewers3d, self.myviewerslaz, self.mydikes, self.mydrownings]
 
         self.menu_options = wx.Menu()
         self._change_title = self.menu_options.Append(wx.ID_ANY, _('Change title'), _('Change title of the window'))
@@ -4787,6 +5275,16 @@ class WolfMapViewer(wx.Frame):
                              'Emprise': 'ZONES_INONDEES',
                              'Emprise wo Alea': 'ZONES_INONDEES_wo_alea'}}
 
+        lifewatch = {'LW_ecotopes_lc_hr_raster': {'2006': '2006',
+                                     '2010': '2010',
+                                     '2015': '2015',
+                                     '2018': '2018',
+                                     '2019': '2019',
+                                     '2020': '2020',
+                                     '2021': '2021',
+                                     '2022': '2022',
+                                     }}
+
         for idx, (k, item) in enumerate(orthos.items()):
             for kdx, (m, subitem) in enumerate(item.items()):
                 self.add_object(which='wmsback',
@@ -4801,11 +5299,19 @@ class WolfMapViewer(wx.Frame):
                                                     self, xmin, xmax, ymin, ymax, -99999, 1024),
                                 ToCheck=False, id='Data 2021 ' + m)
 
+        for idx, (k, item) in enumerate(lifewatch.items()):
+            for kdx, (m, subitem) in enumerate(item.items()):
+                self.add_object(which='wmsback',
+                                newobj=imagetexture('LanCover', m, k, subitem,
+                                                    self, xmin, xmax, ymin, ymax, -99999, 1024, LifeWatch=True),
+                                ToCheck=False, id='LifeWatch LC' + m)
+
         self.add_object(which='wmsback',
                         newobj=imagetexture('PPNC', 'Orthos France', 'OI.OrthoimageCoverage.HR', '',
                                             self, xmin, xmax, ymin, ymax, -99999, 1024, France=True, epsg='EPSG:27563'),
                         ToCheck=False, id='Orthos France')
 
+
         forelist = {'EAU': {'Aqualim': 'RES_LIMNI_DGARNE', 'Alea': 'ALEA_INOND', 'Lidaxes': 'LIDAXES'},
                     'LIMITES': {'Secteurs Statistiques': 'LIMITES_QS_STATBEL',
                                 'Limites administratives': 'LIMITES_ADMINISTRATIVES'},
@@ -5379,9 +5885,6 @@ class WolfMapViewer(wx.Frame):
     def zoom_on_array(self, array:WolfArray, forceupdate=True, canvas_height=1024):
         """ Zoom on array """
 
-        if array.xmin == -99999:
-            array.find_minmax()
-
         bounds = array.get_bounds()
 
         center = [(bounds[0][1] + bounds[0][0]) / 2., (bounds[1][1] + bounds[1][0]) / 2.]
@@ -6932,6 +7435,44 @@ class WolfMapViewer(wx.Frame):
 
         return ass_values[idx]
 
+    def newdrowning(self,itemlabel):
+
+        if itemlabel == ('Create a drowning...'):
+            new_drowning = Drowning_victim_Viewer(mapviewer = self)
+            self.add_object(which='drowning',newobj=new_drowning,ToCheck=True)
+
+        elif itemlabel == ('Add a drowning result...'):
+            dialog = wx.DirDialog(None,_("Select the folder containing your drowning"), style=wx.DD_DEFAULT_STYLE)
+            if dialog.ShowModal() == wx.ID_OK:
+                # Récupérer le chemin sélectionné
+                filedir = dialog.GetPath()
+                dialog.Destroy()
+
+            if not os.path.exists(os.path.join(filedir, "Results.npz")):
+                logging.error(_("The selected folder does not contain any Results.npz"))
+                return
+
+            new_drowning = Drowning_victim_Viewer(mapviewer = self,filedir=filedir)
+            new_drowning.file_drowning = 1
+            self.add_object(which='drowning',newobj=new_drowning,ToCheck=True)
+            new_drowning.load_results()
+            new_drowning.time_id = len(new_drowning.wanted_time)-2
+            new_drowning.init_plot()
+            self.menu_drowning()
+
+    def new_dike(self, itemlabel):
+        """
+        Called when 'Create dike...' or 'Add dike...' are selected in the viewer
+        """
+        newdike = DikeWolf(mapviewer = self)
+
+        if _('Add dike...') in itemlabel:
+            newdike.load_results()
+
+        self.add_object(which='dike', newobj=newdike, ToCheck = True)#, filename=newdike.filename, id=newdike.filename)
+
+        self.menu_dike()
+        autoscale = True
 
     def OnMenubar(self, event: wx.MenuEvent):
         """
@@ -7941,7 +8482,6 @@ class WolfMapViewer(wx.Frame):
                 if self.mylazgrid is None:
                     logging.warning(_('No gridded LAZ data loaded !'))
                     return
-                autoscale=False
                 self.clip_laz_gridded()
 
                 if self.active_laz.nb_points ==0:
@@ -8351,8 +8891,16 @@ class WolfMapViewer(wx.Frame):
             self.frame_create1Dfrom2D = GuiNotebook1D(mapviewer= self)
             logging.info(_(f'New window available - Wolf1D.'))
 
-        elif id == wx.ID_FILE7:
+        elif itemlabel in [_('Create dike...'), _('Add dike...')]:
+            self.new_dike(itemlabel)
 
+        elif itemlabel in [_('Create a drowning...'), _('Add a drowning result...')]:
+
+            self.newdrowning(itemlabel)
+
+
+        elif id == wx.ID_FILE7:
+            autoscale = False
             # Création de nouveaux vecteurs
             newzones = Zones(parent=self)
             self.add_object('vector', newobj=newzones)
@@ -8554,8 +9102,8 @@ class WolfMapViewer(wx.Frame):
                     if ret == wx.ID_OK:
                         obj.saveas(fdlg.GetPath())
 
-        if len(self.myarrays) + len(self.myvectors) + len(self.myclouds) + len(self.mytri) + len(self.myres2D) + len(self.mytiles) + len(self.myimagestiles) + len(self.mypartsystems) == 2 and autoscale:
-            # Trouve les bornzs si un seul élément est présent, sinon on conserve l'état du zoom
+        if len(self.myarrays) + len(self.myvectors) + len(self.myclouds) + len(self.mytri) + len(self.myres2D) + len(self.mytiles) + len(self.myimagestiles) + len(self.mypartsystems) + len(self.mydikes) + len(self.mydrownings) == 2 or autoscale:
+            # Trouve les bornes si un seul élément est présent, sinon on conserve l'état du zoom
             self.Autoscale()
 
     def pop_boundary_manager(self, which:BcManager):
@@ -9131,7 +9679,9 @@ class WolfMapViewer(wx.Frame):
                                  'particlesystem',
                                  'wmsback',
                                  'wmsfore',
-                                 'imagestiles'] = 'array',
+                                 'drowning',
+                                 'imagestiles',
+                                 'dike'] = 'array',
                    filename='',
                    newobj=None,
                    ToCheck=True,
@@ -9187,7 +9737,11 @@ class WolfMapViewer(wx.Frame):
             elif which.lower() == 'res2d':
                 file = wx.FileDialog(self, "Choose file", wildcard=filterres2d)
             elif which.lower() == 'res2d_gpu':
-                file = wx.DirDialog(self, "Choose directory containging WolfGPU results")
+                file = wx.DirDialog(self, "Choose directory containing WolfGPU results")
+            elif which.lower() == 'drowning':
+                file = wx.DirDialog(self, "Choose directory containing the drowning")
+            elif which.lower() == 'dike':
+                file = wx.DirDialog(self, "Choose directory", wildcard=filterall)
 
             # FIXME : particularize filters for wmsback and wmsfore
             elif which.lower() == 'wmsback':
@@ -9810,7 +10364,7 @@ class WolfMapViewer(wx.Frame):
                 self.myothers.append(newobj)
                 newobj.mapviewer = self
             else:
-                logging.warning('No object to add in "Other" category -- Please provide an object to add or check your code')
+                logging.warning(_('No object to add in "Other" category -- Please provide an object to add or check your code'))
 
         elif which.lower() == 'views':
 
@@ -9829,7 +10383,7 @@ class WolfMapViewer(wx.Frame):
                 curtree = self.myitemswmsback
                 self.mywmsback.append(newobj)
             else:
-                logging.warning('No object to add in "WMS background" category -- Please provide an object to add or check your code')
+                logging.warning(_('No object to add in "WMS background" category -- Please provide an object to add or check your code'))
 
         elif which.lower() == 'wmsfore':
 
@@ -9838,7 +10392,7 @@ class WolfMapViewer(wx.Frame):
                 curtree = self.myitemswmsfore
                 self.mywmsfore.append(newobj)
             else:
-                logging.warning('No object to add in "WMS foreground" category -- Please provide an object to add or check your code')
+                logging.warning(_('No object to add in "WMS foreground" category -- Please provide an object to add or check your code'))
 
         elif which.lower() == 'particlesystem':
 
@@ -9851,6 +10405,23 @@ class WolfMapViewer(wx.Frame):
             self.mypartsystems.append(newobj)
             self.active_particle_system = newobj
 
+        elif which.lower() == 'drowning':
+
+            curdict = self.mydrownings
+            curtree = self.myitemsdrowning
+
+            self.mydrownings.append(newobj)
+            self.active_drowning = newobj
+
+
+        elif which.lower() == 'dike':
+
+            curdict = self.mydikes
+            curtree = self.myitemsdike
+
+            self.mydikes.append(newobj)
+            self.active_dike = newobj
+
         # ID chooser
         if id == '':
             dlg = wx.TextEntryDialog(self, 'ID ? (case insensitive)', 'Choose an identifier', '')
@@ -9965,7 +10536,7 @@ class WolfMapViewer(wx.Frame):
 
         if drawing_type is None:
             # return all_lists
-            return self.myarrays + self.myvectors + self.myclouds + self.mytri + self.mypartsystems + self.myothers + self.myviews + self.myres2D
+            return self.myarrays + self.myvectors + self.myclouds + self.mytri + self.mypartsystems + self.myothers + self.myviews + self.myres2D + self.mydikes + self.mydrownings
 
         if drawing_type == draw_type.ARRAYS:
             return self.myarrays
@@ -9993,6 +10564,10 @@ class WolfMapViewer(wx.Frame):
             return self.myimagestiles
         elif drawing_type == draw_type.LAZ:
             return self.mylazdata
+        elif drawing_type == draw_type.DROWNING:
+            return self.mydrownings
+        elif drawing_type == draw_type.DIKE:
+            return self.mydikes
         else:
             logging.error('Unknown drawing type : ' + drawing_type)
             return None
@@ -10120,6 +10695,24 @@ class WolfMapViewer(wx.Frame):
 
         self.removeobj_from_id(id)
 
+    def checkuncheckobj(self):
+        """ Check/uncheck selected item from general tree """
+
+        if self.selected_treeitem is None:
+            return
+
+        id = self.treelist.GetItemText(self.selected_treeitem).lower()
+
+        current_check = self.treelist.GetCheckedState(self.selected_treeitem)
+        myobj = self.getobj_from_id(id)
+        if myobj is not None:
+            if current_check == 0:
+                self.treelist.CheckItem(self.selected_treeitem)
+                myobj.check_plot()
+            else:
+                self.treelist.CheckItem(self.selected_treeitem, False)
+                myobj.uncheck_plot()
+
     def removeobj_from_id(self, id:str):
         """ Remove object from id """
 
@@ -10169,6 +10762,12 @@ class WolfMapViewer(wx.Frame):
             elif myobj is self.active_zones:
                 self.active_zones = None
                 self.set_label_selecteditem('')
+            elif myobj is self.active_drowning:
+                self.active_drowning = None
+                self.set_label_selecteditem('')
+            elif myobj is self.active_dike:
+                self.active_dike = None
+                self.set_label_selecteditem('')
 
     def upobj(self):
         """Up selected item into general tree"""
@@ -10297,6 +10896,11 @@ class WolfMapViewer(wx.Frame):
                     self.selected_object.saveas()
                 elif isinstance(self.selected_object, Particle_system):
                     self.selected_object.save()
+                elif isinstance(self.selected_object, Drowning_victim_Viewer):
+                    self.selected_object.save()
+                elif isinstance(self.selected_object, DikeWolf):
+                    self.selected_object.save()
+
         elif text==_('Up'):
             self.upobj()
 
@@ -10306,6 +10910,9 @@ class WolfMapViewer(wx.Frame):
         elif text == _('Delete'):
             self.removeobj()
 
+        elif text == ('Check/Uncheck'):
+            self.checkuncheckobj()
+
         elif text == _('Rename'):
             #Modification du nom de l'objet sélectionné
             if self.selected_object is not None:
@@ -10439,6 +11046,8 @@ class WolfMapViewer(wx.Frame):
                         self.selected_object.save(fdlg.GetPath())
 
                     fdlg.Destroy()
+                elif isinstance(self.selected_object, DikeWolf):
+                    self.selected_object.save_as()
 
                 elif isinstance(self.selected_object, Wolf_LAZ_Data):
                     filterArray = "Dump (*.dump)|*.dmp|all (*.*)|*.*"
@@ -10450,10 +11059,16 @@ class WolfMapViewer(wx.Frame):
 
                     fdlg.Destroy()
 
+                elif isinstance(self.selected_object, Particle_system):
+                    self.selected_object.saveas()
+
+                elif isinstance(self.selected_object, Drowning_victim_Viewer):
+                    self.selected_object.saveas()
+
         elif text == _('Properties'):
 
             myobj = self.selected_object
-            if type(myobj) in [WolfArray, WolfArrayMB, WolfArrayMNAP, Zones, Wolfresults_2D, wolfres2DGPU, Particle_system, Picc_data, Cadaster_data, hydrometry_wolfgui, Bridge, Weir, Wolf_LAZ_Data]:
+            if type(myobj) in [WolfArray, WolfArrayMB, WolfArrayMNAP, Zones, Wolfresults_2D, wolfres2DGPU, Particle_system, Picc_data, Cadaster_data, hydrometry_wolfgui, Bridge, Weir, Wolf_LAZ_Data, DikeWolf, Drowning_victim_Viewer]:
                 myobj.show_properties()
 
             elif isinstance(myobj, cloud_vertices):
@@ -10802,9 +11417,10 @@ class WolfMapViewer(wx.Frame):
 
         self.treelist.SetToolTip(self.treelist.GetItemText(myitem))
 
-        myparent = self.treelist.GetItemParent(myitem)
-        check = self.treelist.GetCheckedState(myitem)
-        nameparent = self.treelist.GetItemText(myparent).lower()
+        # myparent = self.treelist.GetItemParent(myitem)
+        # check = self.treelist.GetCheckedState(myitem)
+        # if myparent is not None:
+        #     nameparent = self.treelist.GetItemText(myparent).lower()
 
         self.selected_object = curobj
         self.selected_treeitem = myitem
@@ -10947,6 +11563,7 @@ class WolfMapViewer(wx.Frame):
         We use this event to manage "action" set by others objects.
 
         """
+        #self._user_activity_true()
 
         pos = e.GetPosition()
         x, y = self.getXY(pos)
@@ -11366,6 +11983,9 @@ class WolfMapViewer(wx.Frame):
 
 
     def On_Mouse_Right_Up(self, e):
+
+        #self._user_activity_true()
+
         pos = e.GetPosition()
         x, y = self.getXY(pos)
 
@@ -11394,6 +12014,9 @@ class WolfMapViewer(wx.Frame):
                     pass
 
     def On_Mouse_Button(self, e: wx.MouseEvent):
+
+        #self._user_activity_true()
+
         d = e.GetWheelDelta()
         r = e.GetWheelRotation()
         a = e.GetWheelAxis()
@@ -11502,6 +12125,7 @@ class WolfMapViewer(wx.Frame):
 
     def On_Mouse_Left_Down(self, e):
         """ Event when the left button of the mouse is pressed """
+        #self._user_activity_true()
 
         # if not self.move:
         pos = e.GetPosition()
@@ -11509,6 +12133,14 @@ class WolfMapViewer(wx.Frame):
         self.mousedown = (x, y)
         # self.move = True
 
+    def On_Mouse_Left_Up(self, e):
+        """ Event when the left button of the mouse is released """
+
+        pass
+        # if self._thread_update_background is None:
+        #     self._thread_update_background = threading.Thread(target=self.background_task, args=[self]) # thread to update the background
+        #     self._thread_update_background.start() # start the thread
+
     def _set_active_bc(self):
         """Search and activate BCManager according to active_array"""
         if self.active_bc is not None:
@@ -11671,6 +12303,13 @@ class WolfMapViewer(wx.Frame):
             if ctrl:
                 myobj.show_properties()
 
+        elif type(myobj) == Drowning_victim_Viewer:
+            logging.info(_('Activating Drowning victim event : ' + nameitem))
+            self.active_drowning = myobj
+
+            if ctrl:
+                myobj.show_properties()
+
     def _update_mytooltip(self):
         """ Update the tooltip with the values of the active arrays and results at position x,y """
 
@@ -11978,12 +12617,42 @@ class WolfMapViewer(wx.Frame):
                 except:
                     pass
 
-        self.mytooltip.PopulateOnePage()
+        for loc_drowning in self.mydrownings:
+            if loc_drowning.checked:
+                try:
+                    if loc_drowning.bottom_cells is not None:
+                        curgroup = loc_drowning.idx
+                        try:
+                            i_bottom, j_bottom = loc_drowning.bottom_cells.get_ij_from_xy(x, y)
+                            i_surface, j_surface = loc_drowning.surface_cells.get_ij_from_xy(x, y)
+                        except:
+                            pass
+                        value = loc_drowning.bottom_cells.array[i_bottom,j_bottom]
+                        if not np.ma.is_masked(value) and value >0:
+                            self.mytooltip.add_param(groupname = curgroup,
+                                                        name = 'Bottom - percentage of the whole sample',
+                                                        value =  value,
+                                                        type = Type_Param.Float,
+                                                        comment = '')
+                        value = loc_drowning.surface_cells.array[i_surface,j_surface]
+                        if not np.ma.is_masked(value) and value >0:
+                            self.mytooltip.add_param(groupname = curgroup,
+                                                        name = 'Surface - percentage of the whole sample',
+                                                        value =  value,
+                                                        type = Type_Param.Float,
+                                                        comment = '')
+                except:
+                    pass
 
 
+        self.mytooltip.PopulateOnePage()
+
     def On_Mouse_Motion(self, e: wx.MouseEvent):
         """ Mouse move event """
 
+
+        #self._user_activity_true()
+
         # Déplacement de la souris sur le canvas OpenGL
         posframe = self.GetPosition() # Get the position of the frame -> useful to set the tooltip position
         pos = e.GetPosition() # Get the position of the mouse in the canvas
@@ -13094,6 +13763,7 @@ class WolfMapViewer(wx.Frame):
                 self.active_particle_system = None
                 self.active_vertex = None
                 self.active_cloud = None
+                self.active_dike = None
 
                 self.active_laz = None
 
@@ -13481,22 +14151,36 @@ class WolfMapViewer(wx.Frame):
         self.height = ymax - ymin
 
         self.setbounds()
+        self.update()
 
 
-    def update(self):
+    def _update_background(self):
         """
-        Update backgournd et foreground elements and arrays if local minmax is checked.
-
+        Update background
         """
 
         # dessin du background
         for obj in self.iterator_over_objects(draw_type.WMSBACK):
             obj.reload()
 
+    def _update_foreground(self):
+        """
+        Update foreground
+        """
         # dessin du foreground
         for obj in self.iterator_over_objects(draw_type.WMSFORE):
             obj.reload()
 
+    def update(self):
+        """
+        Update backgournd et foreground elements and arrays if local minmax is checked.
+
+        """
+
+        self._update_background()
+
+        self._update_foreground()
+
         if self.locminmax.IsChecked() or self.update_absolute_minmax:
             for curarray in self.iterator_over_objects(draw_type.ARRAYS):
                 curarray: WolfArray
@@ -13616,6 +14300,9 @@ class WolfMapViewer(wx.Frame):
             # Dessin du reste
             self._plotting(draw_type.OTHER)
 
+            # Dessin du noyé
+            self._plotting(draw_type.DROWNING)
+
             # Dessin du Front
             self._plotting(draw_type.WMSFORE)
 
@@ -13654,10 +14341,11 @@ class WolfMapViewer(wx.Frame):
         k = 0
         for locarray in self.myarrays:
             if locarray.plotted or force:
-                xmin = min(locarray.origx + locarray.translx, xmin)
-                xmax = max(locarray.origx + locarray.translx + float(locarray.nbx) * locarray.dx, xmax)
-                ymin = min(locarray.origy + locarray.transly, ymin)
-                ymax = max(locarray.origy + locarray.transly + float(locarray.nby) * locarray.dy, ymax)
+                [xmin_arr, xmax_arr], [ymin_arr, ymax_arr] = locarray.get_bounds()
+                xmin = min(xmin, xmin_arr)
+                xmax = max(xmax, xmax_arr)
+                ymin = min(ymin, ymin_arr)
+                ymax = max(ymax, ymax_arr)
                 k += 1
 
         for locvector in self.myvectors:
@@ -13773,6 +14461,16 @@ class WolfMapViewer(wx.Frame):
                     ymax = max(locothers.ymax, ymax)
                     k += 1
 
+        for drown in self.mydrownings:
+            if drown.plotted or force:
+                drown.find_minmax(force)
+                xmin = min(drown.xmin, xmin)
+                xmax = max(drown.xmax, xmax)
+                ymin = min(drown.ymin, ymin)
+                ymax = max(drown.ymax, ymax)
+                k += 1
+
+
         if k > 0:
             self.xmin = xmin
             self.xmax = xmax