wolfhece 2.2.27__py3-none-any.whl → 2.2.29__py3-none-any.whl

wolfhece/PyConfig.py

@@ -35,6 +35,8 @@ class ConfigurationKeys(Enum):
     DIRECTORY_DEM = "Default DEM directory"
     DIRECTORY_DTM = "Default DTM directory"
     DIRECTORY_LAZ = "Default LAZ directory"
+    ACTIVE_VECTOR_COLOR = "Active vector color"
+    ACTIVE_VECTOR_SIZE_SQUARE = "Active vector square size"
 
 class WolfConfiguration:
     """ Holds the PyWolf configuration """
@@ -82,7 +84,9 @@ class WolfConfiguration:
             ConfigurationKeys.TICKS_FONTSIZE.value: 12,
             ConfigurationKeys.DIRECTORY_DEM.value: "",
             ConfigurationKeys.DIRECTORY_DTM.value: "",
-            ConfigurationKeys.DIRECTORY_LAZ.value: ""
+            ConfigurationKeys.DIRECTORY_LAZ.value: "",
+            ConfigurationKeys.ACTIVE_VECTOR_COLOR.value: [0, 0, 0, 255],
+            ConfigurationKeys.ACTIVE_VECTOR_SIZE_SQUARE.value: 5
 
         }
         self._types = {
@@ -98,7 +102,9 @@ class WolfConfiguration:
             ConfigurationKeys.TICKS_FONTSIZE.value: int,
             ConfigurationKeys.DIRECTORY_DEM.value: str,
             ConfigurationKeys.DIRECTORY_DTM.value: str,
-            ConfigurationKeys.DIRECTORY_LAZ.value: str
+            ConfigurationKeys.DIRECTORY_LAZ.value: str,
+            ConfigurationKeys.ACTIVE_VECTOR_COLOR.value: list,
+            ConfigurationKeys.ACTIVE_VECTOR_SIZE_SQUARE.value: int
         }
 
         self._check_config()
@@ -145,7 +151,7 @@ class GlobalOptionsDialog(wx.Dialog):
         super(GlobalOptionsDialog, self).__init__(*args, **kw)
 
         self.InitUI()
-        self.SetSize((600, 500))
+        self.SetSize((600, 550))
         self.SetTitle(_("Global options"))
 
     def push_configuration(self, configuration):
@@ -161,6 +167,8 @@ class GlobalOptionsDialog(wx.Dialog):
         self.cfg_directory_dem.SetValue(str(configuration[ConfigurationKeys.DIRECTORY_DEM]))
         self.cfg_directory_dtm.SetValue(str(configuration[ConfigurationKeys.DIRECTORY_DTM]))
         self.cfg_directory_laz.SetValue(str(configuration[ConfigurationKeys.DIRECTORY_LAZ]))
+        self.cfg_vector_color.SetColour(configuration[ConfigurationKeys.ACTIVE_VECTOR_COLOR])
+        self.cfg_square_size.SetValue(str(configuration[ConfigurationKeys.ACTIVE_VECTOR_SIZE_SQUARE]))
 
     def pull_configuration(self, configuration):
         configuration[ConfigurationKeys.PLAY_WELCOME_SOUND] = self.cfg_welcome_voice.IsChecked()
@@ -175,6 +183,8 @@ class GlobalOptionsDialog(wx.Dialog):
         configuration[ConfigurationKeys.DIRECTORY_DEM] = str(self.cfg_directory_dem.Value)
         configuration[ConfigurationKeys.DIRECTORY_DTM] = str(self.cfg_directory_dtm.Value)
         configuration[ConfigurationKeys.DIRECTORY_LAZ] = str(self.cfg_directory_laz.Value)
+        configuration[ConfigurationKeys.ACTIVE_VECTOR_COLOR] = list(self.cfg_vector_color.GetColour())
+        configuration[ConfigurationKeys.ACTIVE_VECTOR_SIZE_SQUARE] = int(self.cfg_square_size.Value)
 
     def InitUI(self):
 
@@ -298,6 +308,20 @@ class GlobalOptionsDialog(wx.Dialog):
         sbs.Add(dir_dtm, 1, wx.EXPAND, 5)
         sbs.Add(dir_laz, 1, wx.EXPAND, 5)
 
+        # Vector color
+        color_vector = wx.BoxSizer(wx.HORIZONTAL)
+        self.label_vector_color = wx.StaticText(pnl, label=_('Default vector color'))
+        self.cfg_vector_color = wx.ColourPickerCtrl(pnl, colour=(0, 0, 0, 255))
+        self.cfg_vector_color.SetToolTip(_('Color for active vector in the viewer'))
+
+        self.cfg_square_size = wx.TextCtrl(pnl, value='5', style=wx.TE_CENTRE)
+        self.cfg_square_size.SetToolTip(_('Size of the square for active vector in the viewer'))
+
+        color_vector.Add(self.label_vector_color, 1, wx.EXPAND, 2)
+        color_vector.Add(self.cfg_vector_color, 1, wx.EXPAND, 5)
+        color_vector.Add(self.cfg_square_size, 1, wx.EXPAND, 5)
+        sbs.Add(color_vector, 1, wx.EXPAND, 5)
+
         pnl.SetSizer(sbs)
         pnl.Layout()
 

wolfhece/PyDraw.py

@@ -76,7 +76,7 @@ try:
     from .PyPalette import wolfpalette
     from .wolfresults_2D import Wolfresults_2D, views_2D, Extractable_results
     from .PyTranslate import _
-    from .PyVertex import cloud_vertices, getIfromRGB
+    from .PyVertex import cloud_vertices, getIfromRGB, getRGBfromI
     from .RatingCurve import SPWMIGaugingStations, SPWDCENNGaugingStations
     from .wolf_array import WOLF_ARRAY_MB, SelectionData, WolfArray, WolfArrayMB, CropDialog, header_wolf, WolfArrayMNAP, WOLF_ARRAY_FULL_SINGLE, WOLF_ARRAY_FULL_INTEGER8, WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_FULL_DOUBLE, WOLF_ARRAY_FULL_INTEGER
     from .PyParams import Wolf_Param, key_Param, Type_Param
@@ -2306,10 +2306,15 @@ class WolfMapViewer(wx.Frame):
 
         self.analyzesimsheet.Append(wx.ID_ANY, _("Active simulation..."), _("Generate a summary PDF report for the active simulation"))
         self.analyzesimsheet.Append(wx.ID_ANY, _("All checked simulations..."), _("Generate a summary PDF report for all checked simulations"))
+        self.analyzesimsheet.AppendSeparator()
+        self.analyzesimsheet.Append(wx.ID_ANY, _("One simulation from disk..."), _("Generate a summary PDF report for one simulation"))
         self.analyzesimsheet.Append(wx.ID_ANY, _("All simulations in directory..."), _("Generate a summary PDF report for all simulations in the current directory"))
         self.analyzesimsheet.AppendSeparator()
         self.analyzesimsheet.Append(wx.ID_ANY, _("Compare checked simulations..."), _("Generate a summary PDF report for all the loaded simulations"))
         self.analyzesimsheet.Append(wx.ID_ANY, _("Compare all simulations in a directory..."), _("Generate a summary PDF report for all the simulations in a directory"))
+        self.analyzesimsheet.AppendSeparator()
+        self.analyzesimsheet.Append(wx.ID_ANY, _("Compare arrays..."), _("Generate a summary PDF report for two loaded arrays"))
+        self.analyzesimsheet.Append(wx.ID_ANY, _("Compare arrays from files..."), _("Generate a summary PDF report for two arrays from files"))
 
 
         self.analyzeinpaint.Append(wx.ID_ANY, _("Inpaint active array..."), _("Inpaint active array"))
@@ -4194,6 +4199,15 @@ class WolfMapViewer(wx.Frame):
         else:
             return None
 
+    @property
+    def active_vector_color(self) -> list[int]:
+        """ Return the active vector color from configs """
+        config = self.get_configuration()
+        if config is None:
+            return [0, 0, 0, 255]  # Default black color
+        else:
+            return config[ConfigurationKeys.ACTIVE_VECTOR_COLOR]
+
     @property
     def default_dem(self) -> Path:
         """ Return the default DEM file from configs """
@@ -4300,12 +4314,20 @@ class WolfMapViewer(wx.Frame):
                 if self.active_array is not None:
                     return self.active_array.mypal
                 else:
-                    return wolfpalette()
+                    if self.active_res2d is not None:
+                        logging.warning(_('No active array -- Using active 2D result palette instead'))
+                        return self.active_res2d.mypal
+                    else:
+                        return wolfpalette()
             elif act_res2d:
                 if self.active_res2d is not None:
                     return self.active_res2d.mypal
                 else:
-                    return wolfpalette()
+                    if self.active_array is not None:
+                        logging.warning(_('No active 2D result -- Using active array palette instead'))
+                        return self.active_array.mypal
+                    else:
+                        return wolfpalette()
             else:
                 return wolfpalette()
 
@@ -7702,6 +7724,78 @@ class WolfMapViewer(wx.Frame):
         self.menu_dike()
         autoscale = True
 
+    def _run_compare_arrays(self, dlg):
+        """ Run the comparison of two arrays"""
+
+        from .ui.wolf_multiselection_collapsiblepane import Wolf_CompareArrays_Selection
+
+        assert isinstance(dlg, Wolf_CompareArrays_Selection), 'Dialog must be a wx.Dialog instance'
+
+        dlg: Wolf_CompareArrays_Selection
+
+        vals = dlg.get_values()
+        id1 = vals[_('Reference array')][0]
+        id2 = vals[_('Comparison array')][0]
+        min_area = dlg.get_min_area()
+        threshold = dlg.get_threshold()
+        nb_patches = dlg.get_max_patches()
+
+        ref:WolfArray
+        comp:WolfArray
+        ref = self.get_obj_from_id(id1, draw_type.ARRAYS)
+        comp = self.get_obj_from_id(id2, draw_type.ARRAYS)
+
+        if ref is None or comp is None:
+            logging.warning(_('You must select two arrays to compare !'))
+            return
+
+        assert isinstance(ref, WolfArray), 'Reference object must be a WolfArray instance'
+        assert isinstance(comp, WolfArray), 'Comparison object must be a WolfArray instance'
+
+        if not ref.is_like(comp):
+            logging.error(_('The two arrays must have the same shape and type !'))
+            return
+
+        # if only 2 arrays, we can use the CompareArrays_wx directly
+        from .report.compare_arrays import CompareArrays_wx
+
+        try:
+            newsheet = CompareArrays_wx(ref, comp,
+                                        size=(800, 600),
+                                        ignored_patche_area= min_area,
+                                        threshold=threshold,
+                                        nb_max_patches = nb_patches,)
+            newsheet.Show()
+
+            self.add_object('vector', newobj = newsheet.get_zones(), ToCheck = True, id = 'compare_arrays_{}'.format(ref.idx + comp.idx))
+        except:
+            logging.error(_('Error in comparing arrays\n'))
+            dlg.Destroy()
+
+    def _compare_arrays(self):
+        """ Compare two arrays """
+        arrays = self.get_list_keys(draw_type.ARRAYS, checked_state = None)
+
+        if len(arrays) == 0:
+            logging.warning(_('No arrays to compare !'))
+            return
+        elif len(arrays) == 1:
+            logging.warning(_('Only one array to compare - Nothing to do !'))
+            return
+
+        from .ui.wolf_multiselection_collapsiblepane import Wolf_CompareArrays_Selection
+
+        dlg = Wolf_CompareArrays_Selection(parent = self,
+                                            title = _("Choose the arrays to compare"),
+                                            info = _("Select the reference and comparison arrays"),
+                                            values_dict = {_('Reference array'): arrays,
+                                                            _('Comparison array'): arrays},
+                                            callback= self._run_compare_arrays,
+                                            destroyOK = True,
+                                            styles = [wx.LB_SINGLE, wx.LB_SINGLE]
+                                            )
+        dlg.ShowModal()
+
     def OnMenubar(self, event: wx.MenuEvent):
         """
         Gestion des clicks sur le menu quel que soit le niveau
@@ -8346,6 +8440,29 @@ class WolfMapViewer(wx.Frame):
                 else:
                     logging.warning(_('Simulation {} is not a GPU simulation - Not yet implemented for CPU simulations !').format(curmodel.idx))
 
+        elif itemlabel == _("One simulation from disk..."):
+            dlg = wx.DirDialog(None, _('Choose the directory containing the simulation'), style=wx.DD_DEFAULT_STYLE)
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+            directory = Path(dlg.GetPath())
+            dlg.Destroy()
+            if not directory.exists():
+                logging.error(_('Directory {} does not exist !').format(directory))
+                wx.MessageBox(_('Directory {} does not exist !').format(directory), _('Error'), wx.OK | wx.ICON_ERROR)
+                return
+            if not directory.is_dir():
+                logging.error(_('Path {} is not a directory !').format(directory))
+                wx.MessageBox(_('Path {} is not a directory !').format(directory), _('Error'), wx.OK | wx.ICON_ERROR)
+                return
+
+            from .report.simplesimgpu import SimpleSimGPU_Report_wx
+
+            # check if we want to show all wx reports
+            newsheet = SimpleSimGPU_Report_wx(directory, size=(800, 600), show=True)
+
+
         elif itemlabel == _("All simulations in directory..."):
             dlg = wx.DirDialog(None, _('Choose the directory containing the simulations'), style=wx.DD_DEFAULT_STYLE)
             ret = dlg.ShowModal()
@@ -8364,7 +8481,6 @@ class WolfMapViewer(wx.Frame):
                 return
             from .report.simplesimgpu import SimpleSimGPU_Reports_wx
 
-
             # check if we want to show all wx reports
             dlg = wx.MessageDialog(None, _('Do you want to show all reports ?'), _('Show all reports'), style=wx.YES_NO | wx.YES_DEFAULT)
             ret = dlg.ShowModal()
@@ -8372,6 +8488,50 @@ class WolfMapViewer(wx.Frame):
 
             newsheets = SimpleSimGPU_Reports_wx(directory, show = ret == wx.ID_YES, size=(800, 600))
 
+        elif itemlabel == _("Compare arrays..."):
+
+            self._compare_arrays()
+
+        elif itemlabel == _("Compare arrays from files..."):
+
+            from .report.compare_arrays import CompareArrays_wx
+
+            dlg = wx.FileDialog(None, _('Choose the reference file'), wildcard='*.tif, *.bin, *.npy|*.tif;*.bin;*.npy|all (*.*)|*.*', style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+            ref_filename = dlg.GetPath()
+            dlg.Destroy()
+
+            dlg = wx.FileDialog(None, _('Choose the comparison file'), wildcard='*.tif, *.bin, *.npy|*.tif;*.bin;*.npy|all (*.*)|*.*', style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+            comp_filename = dlg.GetPath()
+            dlg.Destroy()
+
+            try:
+                wa_ref = WolfArray(ref_filename)
+                wa_comp = WolfArray(comp_filename)
+
+                if not (wa_ref.loaded and wa_comp.loaded):
+                    logging.error(_('Error in loading arrays from files'))
+                    wx.MessageBox(_('Error in loading arrays from files'), _('Error'), wx.OK | wx.ICON_ERROR)
+                    return
+
+                if wa_ref.is_like(wa_comp):
+                    newsheet = CompareArrays_wx(wa_ref, wa_comp, size=(800, 600))
+                    newsheet.Show()
+                else:
+                    logging.error(_('The two arrays are not compatible - Cannot compare !'))
+                    wx.MessageBox(_('The two arrays are not compatible - Cannot compare !'), _('Error'), wx.OK | wx.ICON_ERROR)
+
+                logging.info(_('Arrays {} and {} compared successfully').format(ref_filename, comp_filename))
+            except Exception as e:
+                logging.error(_('Error in comparing arrays from files\n{}'.format(e)))
+
         elif itemlabel == _("Compare checked simulations..."):
 
             sims = self.get_list_keys(draw_type.RES2D, checked_state=True)
@@ -12372,6 +12532,7 @@ class WolfMapViewer(wx.Frame):
                     logging.warning(_('No array available and ctrl is pressed -- Please load a file or create data !'))
 
             self.active_vector.add_vertex(wolfvertex(x, y))
+            self.active_vertex = self.active_vector.myvertices[-1]
 
             self.active_vector.find_minmax()
             self.active_zone.find_minmax()
@@ -12480,6 +12641,7 @@ class WolfMapViewer(wx.Frame):
 
                 if ctrl:
                     if self.active_array is not None:
+                        # Get the value of the array at the position of the vertex
                         z = self.active_array.get_value(x, y)
                         self.active_vertex.z = z
                     else:
@@ -13268,6 +13430,8 @@ class WolfMapViewer(wx.Frame):
                self.action == 'insert vertices':
                 if self.active_vertex is not None:
                     if shiftdown:
+                        # Shift key is pressed
+                        # We move/Insert the vertex along the segment linking the first and last vertices of the active vector
                         ox = self.active_vector.myvertices[0].x
                         oy = self.active_vector.myvertices[0].y
 
@@ -13492,7 +13656,8 @@ class WolfMapViewer(wx.Frame):
 
         if self.action is not None:
             locaction = self.action
-            if 'select by tmp vector' in self.action or 'select by vector' in self.action:
+
+            if 'select by tmp vector' in locaction or 'select by vector' in locaction:
                 inside_under = 'inside' in self.action
 
                 self.end_action(_('End of vector selection'))
@@ -13509,7 +13674,7 @@ class WolfMapViewer(wx.Frame):
                     # we must reset the temporary vector
                     self.active_vector.reset()
 
-            if self.action == 'distance along vector':
+            elif locaction == 'distance along vector':
 
                 dlg = wx.MessageDialog(None, _('Memorize the vector ?'), _('Confirm'), wx.YES_NO | wx.YES_DEFAULT | wx.ICON_QUESTION)
                 ret = dlg.ShowModal()
@@ -13520,17 +13685,17 @@ class WolfMapViewer(wx.Frame):
 
                 self._tmp_vector_distance = None
 
-            elif self.action == 'pick landmap':
+            elif locaction == 'pick landmap':
 
                 self.end_action(_('End of landmap picking'))
 
-            elif self.action == 'laz tmp vector':
+            elif locaction == 'laz tmp vector':
                 self.end_action(_('End of LAZ selection'))
                 self.active_vector.myvertices.pop(-1)
                 self.plot_laz_around_active_vec()
                 self.active_vector.reset()
 
-            elif self.action == 'create polygon - tiles':
+            elif locaction == 'create polygon - tiles':
                 self.end_action(_('End of polygon creation'))
                 self.active_vector.myvertices.pop(-1)
                 self.active_vector.close_force()
@@ -13568,7 +13733,7 @@ class WolfMapViewer(wx.Frame):
 
                 self._create_data_from_tiles_common()
 
-            elif self.action == 'capture vertices':
+            elif locaction == 'capture vertices':
                 self.end_action(_('End of points capturing'))
                 self.active_vector.myvertices.pop(-1)
                 r = wx.MessageDialog(
@@ -13587,7 +13752,7 @@ class WolfMapViewer(wx.Frame):
                 # C'est donc plus lent mais plus sûr pour que l'affichage dynamique soit correct
                 self.active_vector.parentzone.plot(prep = self.linkedList is None or not(self in self.linkedList))
 
-            elif self.action == 'modify vertices':
+            elif locaction == 'modify vertices':
 
                 # end of vertices modification
                 self.end_action(_('End of vertices modification'))
@@ -13601,7 +13766,7 @@ class WolfMapViewer(wx.Frame):
 
                 self.active_vertex = None
 
-            elif self.action == 'insert vertices':
+            elif locaction == 'insert vertices':
                 self.end_action(_('End of vertices insertion'))
 
                 # force to prepare OpenGL to accelerate the plot
@@ -13613,7 +13778,7 @@ class WolfMapViewer(wx.Frame):
 
                 self.active_vertex = None
 
-            elif self.action == 'dynamic parallel':
+            elif locaction == 'dynamic parallel':
                 self.active_vector.myvertices.pop(-1)
                 self.active_zone.parallel_active(self.dynapar_dist)
 
@@ -13630,11 +13795,11 @@ class WolfMapViewer(wx.Frame):
 
                 self.end_action(_('End of dynamic parallel'))
 
-            elif 'select active vector' in self.action:
+            elif 'select active vector' in locaction:
 
                 self.end_action(_('End of vector selection'))
 
-            elif 'select node by node' in self.action:
+            elif 'select node by node' in locaction:
                 self.end_action(_('End of node by node selection'))
 
         self.copyfrom = None
@@ -13902,6 +14067,7 @@ class WolfMapViewer(wx.Frame):
         """ Message to end action """
 
         self.action = None
+        self.active_vertex = None
         logging.info(_('ACTION : ') + _(message) if message != '' else _('ACTION : End of action') )
         self.msg_action(1)
 
@@ -14290,7 +14456,7 @@ class WolfMapViewer(wx.Frame):
                     logging.info(_('Paste selection position'))
 
                     if cursel == 'all':
-                        self.active_array.SelectionData.OnAllSelect(0)
+                        self.active_array.SelectionData.myselection = 'all'
                     elif len(cursel) > 0:
                         self.active_array.SelectionData.myselection = cursel.copy()
                         self.active_array.SelectionData.update_nb_nodes_selection()
@@ -14910,13 +15076,27 @@ class WolfMapViewer(wx.Frame):
             if self._tmp_vector_distance is not None:
                 self._tmp_vector_distance.plot()
 
-            # try:
-            #     if self.active_bc is not None:
-            #         self.active_bc.plot()
-            # except:
-            #     pass
+            if self.active_vector is not None:
+                if getIfromRGB(self.active_vector_color) != self.active_vector.myprop.color:
+                    old = self.active_vector.myprop.color
+                    self.active_vector.myprop.color = getIfromRGB(self.active_vector_color)
+                    self.active_vector.plot()
+                    self.active_vector._plot_square_at_vertices()
+                    self.active_vector.myprop.color = old
+
+                if self.active_vector.myprop.plot_indices:
+                    self.active_vector._plot_all_indices(sx = self.sx, sy=self.sy,
+                                                            xmin=self.xmin, ymin=self.ymin,
+                                                            xmax=self.xmax, ymax=self.ymax,
+                                                            size = (self.xmax - self.xmin) / 100.)
+
+                elif self.active_vertex is not None:
+                    self.active_vector._plot_index_vertex(idx = self.active_vector.myvertices.index(self.active_vertex),
+                                                          sx = self.sx, sy=self.sy,
+                                                          xmin=self.xmin, ymin=self.ymin,
+                                                          xmax=self.xmax, ymax=self.ymax,
+                                                          size = (self.xmax - self.xmin) / 100.)
 
-            # glFlush()
             self.canvas.SwapBuffers()
         else:
             raise NameError(

wolfhece/PyPalette.py

@@ -278,6 +278,11 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
             logging.warning('No values in palette - Nothing to do !')
             return None, None
 
+        if len(self.values) ==0:
+            logging.warning('No values in palette - Nothing to do !')
+            logging.info(_('Do you have defined the palette values ?'))
+            logging.info(_('If yes, please check your Global Options. You may not have defined the correct palette to use.'))
+            return None, None
 
         if fn == '':
             file = wx.FileDialog(None, "Choose .pal file", wildcard="png (*.png)|*.png|all (*.*)|*.*", style=wx.FD_SAVE)
@@ -288,6 +293,7 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
                 fn = file.GetPath()
 
         if h_or_v == 'v':
+
             if figax is None:
                 fig, ax = plt.subplots(1, 1)
             else:
@@ -636,6 +642,18 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
 
         self.fill_segmentdata()
 
+    def default_difference3(self):
+        """ Palette 3 couleurs pour les différences par défaut dans WOLF """
+        self.nb = 3
+        self.values = np.asarray([-10., 0., 10.], dtype=np.float64)
+        self.colors = np.zeros((self.nb, 4), dtype=int)
+        self.colorsflt = np.zeros((self.nb, 4), dtype=np.float64)
+        self.colors[0, :] = [0, 0, 255, 255]   # Bleu
+        self.colors[1, :] = [255, 255, 255, 255]  # Blanc
+        self.colors[2, :] = [255, 0, 0, 255]   # Rouge
+        self.fill_segmentdata()
+
+
     def set_values_colors(self,
                           values: typing.Union[list[float], np.ndarray],
                           colors: typing.Union[list[tuple[int]], np.ndarray]):