wolfhece 2.2.37__py3-none-any.whl → 2.2.39__py3-none-any.whl

wolfhece/PyPalette.py

@@ -653,7 +653,6 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
         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]):
@@ -698,6 +697,16 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
 
         self.fill_segmentdata()
 
+    def set_values(self,
+                   values: typing.Union[list[float], np.ndarray]):
+        """ Mise à jour des valeurs de la palette """
+
+        assert len(values) == self.nb, "Length of values must match the number of colors"
+
+        self.values = np.asarray(values, dtype=np.float64)
+
+        self.fill_segmentdata()
+
     def defaultgray(self):
         """Palette grise par défaut dans WOLF"""
 
@@ -882,7 +891,8 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
         self.nb = 2
         self.values = np.asarray([np.min(array), np.max(array)], dtype=np.float64)
         self.colors = np.asarray([[255, 255, 255, 255], [0, 0, 255, 255]], dtype=np.int32)
-        self.colorsflt = np.asarray([[0., 0., 0., 1.], [1., 1., 1., 1.]], dtype=np.float64)
+        self.colorsflt = self.colors.astype(float)/255.
+        # self.colorsflt = np.asarray([[0., 0., 0., 1.], [1., 1., 1., 1.]], dtype=np.float64)
 
         self.fill_segmentdata()
 
@@ -892,7 +902,8 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
         self.nb = 2
         self.values = np.asarray([np.min(array), np.max(array)], dtype=np.float64)
         self.colors = np.asarray([[255, 255, 255, 255], [255, 0, 0, 255]], dtype=np.int32)
-        self.colorsflt = np.asarray([[0., 0., 0., 1.], [1., 1., 1., 1.]], dtype=np.float64)
+        self.colorsflt = self.colors.astype(float)/255.
+        # self.colorsflt = np.asarray([[0., 0., 0., 1.], [1., 1., 1., 1.]], dtype=np.float64)
 
         self.fill_segmentdata()
 
@@ -902,6 +913,17 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
         self.nb = 2
         self.values = np.asarray([0., 1.], dtype=np.float64)
         self.colors = np.asarray([[255, 255, 255, 255], [0, 0, 255, 255]], dtype=np.int32)
-        self.colorsflt = np.asarray([[0., 0., 0., 1.], [1., 1., 1., 1.]], dtype=np.float64)
+        self.colorsflt = self.colors.astype(float)/255.
+        # self.colorsflt = np.asarray([[0., 0., 0., 1.], [1., 1., 1., 1.]], dtype=np.float64)
+
+        self.fill_segmentdata()
+
+    def defaultblue3(self):
+        """Remplissage des valeurs de palette sur base d'une équirépartition de valeurs"""
+
+        self.nb = 3
+        self.values = np.asarray([0., 1., 10.], dtype=np.float64)
+        self.colors = np.asarray([[255, 255, 255, 255], [50, 130, 246, 255], [0, 0, 255, 255]], dtype=np.int32)
+        self.colorsflt = self.colors.astype(float)/255.
 
         self.fill_segmentdata()

wolfhece/PyParams.py

@@ -846,6 +846,39 @@ class Wolf_Param(wx.Frame):
                 dlg = wx.MessageDialog(None,'Nothing to do!')
                 dlg.ShowModal()
 
+    def compare_active_to_default(self, remove_from_active_if_same:bool = True):
+        """
+        Compare active parameters to default parameters and remove those that are the same.
+
+        :param remove_from_active_if_same: If True, remove parameters from active if they are the same as default.
+        """
+
+        for group in self.myparams_default.keys():
+            for param_name in self.myparams_default[group].keys():
+                if self.is_in_active(group, param_name):
+
+                    val_default = self.myparams_default[group][param_name][key_Param.VALUE]
+                    val_active = self.myparams[group][param_name][key_Param.VALUE]
+
+                    if val_active == val_default:
+                        if remove_from_active_if_same:
+                            # Remove from active parameters
+                            del self.myparams[group][param_name]
+                            # # Remove from property grid
+                            # if self._is_in_propperty_page(self.page_active, group, param_name):
+                            #     self.prop.DeleteProperty(group + param_name)
+                        else:
+                            logging.debug(_('Parameter {} is the same as default and will not be removed'.format(param_name)))
+
+        # Iterate through the groups and remove empty ones
+        groups_to_remove = []
+        for group in self.myparams.keys():
+            if not self.myparams[group]:
+                groups_to_remove.append(group)
+
+        for group in groups_to_remove:
+            del self.myparams[group]
+
     @property
     def page_active(self) -> pg.PropertyGridPage:
         """ Return the active page """

wolfhece/PyPictures.py

@@ -332,7 +332,7 @@ class PictureCollection(Zones):
 
         df = pd.read_excel(excel_file, sheet_name=sheet_name)
 
-        for _, row in df.iterrows():
+        for __, row in df.iterrows():
             picture = row['Picture']
             x = row.get('X', None)
             y = row.get('Y', None)
@@ -405,7 +405,7 @@ class PictureCollection(Zones):
                     name_column = column
                     break
 
-        for _, row in gdf.iterrows():
+        for __, row in gdf.iterrows():
             picture_path = row[name_column]
             if not isinstance(picture_path, str):
                 logging.error(f"Invalid picture path in shapefile: {picture_path}")

wolfhece/PyVertex.py

@@ -1011,6 +1011,18 @@ class cloud_vertices(Element_To_Draw):
             self._updatebounds(newcloud=cloud)
         pass
 
+    def remove_vertex(self, id: int):
+        """ Remove a vertex from the cloud
+
+        :param id: id of the vertex to remove
+        """
+
+        if id in self.myvertices:
+            del self.myvertices[id]
+            self._updatebounds()
+        else:
+            logging.warning(_('Vertex with id {} not found in the cloud').format(id))
+
     def add_vertices(self, vertices:list[wolfvertex]):
         """ Add a list of vertices to the cloud """
 
@@ -1061,6 +1073,13 @@ class cloud_vertices(Element_To_Draw):
 
         if self.myprop.legendvisible:
 
+            dx = xmax - xmin
+            dy = ymax - ymin
+
+            if dx > 50_000. or dy > 50_000.:
+                logging.warning(_('Too large bounds for legend plot -- skipping'))
+                return
+
             mapviewer = self.get_mapviewer()
 
             which_legend = self.myprop.legendtext
@@ -1102,6 +1121,19 @@ class cloud_vertices(Element_To_Draw):
 
                     text.paint()
 
+    def reset_listogl(self):
+        """
+        Reset the OpenGL list
+
+        """
+
+        if self.gllist != 0:
+            glDeleteLists(self.gllist, 1)
+            self.gllist = 0
+
+        self.forceupdategl = True
+        self.ongoing = False
+
     def plot(self, update:bool=False, *args, **kwargs):
         """
         OpenGL plot of the cloud of vertices

wolfhece/PyVertexvectors.py

@@ -877,11 +877,26 @@ class vectorproperties:
         added = '#TRUE#' if self.used else '#FALSE#'
         f.write(added+'\n')
 
+    @property
+    def image_path(self) -> Path:
+        """ Return the path of the attached image """
+        return Path(self.attachedimage)
+
+    @image_path.setter
+    def image_path(self, value:Path):
+        """ Set the path of the attached image """
+
+        if self.attachedimage != value:
+            self.unload_image()
+
+        self.attachedimage = Path(value)
+
     def load_unload_image(self):
         """ Load an attached image """
 
         if self.imagevisible:
             if self.attachedimage is not None:
+                self.attachedimage = Path(self.attachedimage)
                 if self.attachedimage.exists():
 
                     (xmin,xmax),(ymin,ymax) = self.parent.get_bounds_xx_yy()
@@ -911,9 +926,14 @@ class vectorproperties:
                 else:
                     logging.warning('Image not found : {}'.format(self.attachedimage))
         else:
-            if self.textureimage is not None:
-                self.textureimage.unload()
-                self.textureimage = None
+            self.unload_image()
+
+    def unload_image(self):
+        """ Unload the attached image """
+
+        if self.textureimage is not None:
+            self.textureimage.unload()
+            self.textureimage = None
 
     def fill_property(self, props:Wolf_Param = None, updateOGL:bool = True):
         """
@@ -1336,6 +1356,8 @@ class vector:
         self._lengthparts2D=None
         self._lengthparts3D=None
 
+        self._simplified_geometry = False
+
         if type(lines)==list:
             if len(lines)>0:
                 self.myname=lines[0]
@@ -2373,30 +2395,32 @@ class vector:
                 return tri.get_triangles_as_listwolfvertices()
 
             else:
-                # if self.myprop.closed and (self.myvertices[0].x != self.myvertices[-1].x or self.myvertices[0].y != self.myvertices[-1].y):
-                #     return [self.myvertices + [self.myvertices[0]]]
-                # else:
-                #     return [self.myvertices]
-                xx, yy = self.polygon.exterior.xy
+                if self._simplified_geometry:
+                    if self.myprop.closed and (self.myvertices[0].x != self.myvertices[-1].x or self.myvertices[0].y != self.myvertices[-1].y):
+                        return [self.myvertices + [self.myvertices[0]]]
+                    else:
+                        return [self.myvertices]
+                else:
+                    xx, yy = self.polygon.exterior.xy
 
-                # On translate les coordonnées pour éviter les erreurs de triangulation
-                tr_x = np.array(xx).min()
-                tr_y = np.array(yy).min()
+                    # On translate les coordonnées pour éviter les erreurs de triangulation
+                    tr_x = np.array(xx).min()
+                    tr_y = np.array(yy).min()
 
-                xx = np.array(xx)-tr_x
-                yy = np.array(yy)-tr_y
+                    xx = np.array(xx)-tr_x
+                    yy = np.array(yy)-tr_y
 
-                geom = {'vertices' : [[x,y] for x,y in zip(xx[:-1],yy[:-1])], 'segments' : [[i,i+1] for i in range(len(xx)-2)]+[[len(xx)-2,0]]}
+                    geom = {'vertices' : [[x,y] for x,y in zip(xx[:-1],yy[:-1])], 'segments' : [[i,i+1] for i in range(len(xx)-2)]+[[len(xx)-2,0]]}
 
-                try:
-                    delaunay = triangle.triangulate(geom, 'p')
-                    tri = []
-                    for curtri in delaunay['triangles']:
-                        # on traduit les coordonnées pour revenir dans le monde réel
-                        tri.append([wolfvertex(delaunay['vertices'][curtri[i]][0] + tr_x, delaunay['vertices'][curtri[i]][1] + tr_y) for i in range(3)])
-                    return tri
-                except:
-                    pass
+                    try:
+                        delaunay = triangle.triangulate(geom, 'p')
+                        tri = []
+                        for curtri in delaunay['triangles']:
+                            # on traduit les coordonnées pour revenir dans le monde réel
+                            tri.append([wolfvertex(delaunay['vertices'][curtri[i]][0] + tr_x, delaunay['vertices'][curtri[i]][1] + tr_y) for i in range(3)])
+                        return tri
+                    except:
+                        pass
 
         else:
             if self.has_interior:
@@ -2657,13 +2681,17 @@ class vector:
 
         if self.myprop.imagevisible and self.myprop.used:
 
-            if self.myprop.textureimage is None:
-                self.myprop.load_unload_image()
+            try:
 
-            if self.myprop.textureimage is not None:
-                self.myprop.textureimage.paint()
-            else:
-                logging.warning(_('No image texture available for plot'))
+                if self.myprop.textureimage is None:
+                    self.myprop.load_unload_image()
+
+                if self.myprop.textureimage is not None:
+                    self.myprop.textureimage.paint()
+                else:
+                    logging.warning(_('No image texture available for plot'))
+            except Exception as e:
+                logging.error(_('Error while plotting image texture: {}').format(e))
 
     def plot_matplotlib(self, ax:plt.Axes | tuple[Figure, Axes] = None):
         """
@@ -3310,8 +3338,8 @@ class vector:
         k1,cums1,lengthparts1=self.get_segment(s1,is3D,adim,True)
         k2,cums2,lengthparts2=self.get_segment(s2,is3D,adim,False)
 
-        pond1 = max((cums1-s1)/lengthparts1[k1],0.)
-        pond2 = min((cums2-s2)/lengthparts2[k2],1.)
+        pond1 = max((cums1-s1)/lengthparts1[k1],0.) if lengthparts1[k1] > 0. else 0.
+        pond2 = min((cums2-s2)/lengthparts2[k2],1.) if lengthparts2[k2] > 0. else 1.
 
         v1= wolfvertex(self.myvertices[k1].x*pond1+self.myvertices[k1+1].x*(1.-pond1),
                        self.myvertices[k1].y*pond1+self.myvertices[k1+1].y*(1.-pond1),
@@ -3521,6 +3549,12 @@ class vector:
         self.myprop.legendy = centroid.y
         self.myprop.legendtext = text if text else self.myname
 
+    def set_legend_visible(self, visible:bool=True):
+        """
+        Set the visibility of the legend.
+        """
+        self.myprop.legendvisible = visible
+
     def set_legend_position_to_centroid(self):
         """
         Positionne la légende au centre du vecteur
@@ -3882,6 +3916,8 @@ class vector:
         """ Permet de retrouver un vertex sur base de son index """
         if ndx>=0 and ndx < self.nbvertices:
             return self.myvertices[ndx]
+        elif ndx < 0 and abs(ndx) <= self.nbvertices:
+            return self.myvertices[ndx + self.nbvertices]
         else:
             logging.warning(_('Index out of range'))
 
@@ -3891,15 +3927,27 @@ class vector:
             self.myvertices[ndx] = value
             self._reset_listogl()
             self.reset_linestring()
+        elif ndx < 0 and abs(ndx) <= self.nbvertices:
+            self.myvertices[ndx + self.nbvertices] = value
+            self._reset_listogl()
+            self.reset_linestring()
         else:
             logging.warning(_('Index out of range'))
 
     def __delitem__(self, ndx:int):
-        """ Permet de supprimer un vertex sur base de son index """
+        """ Permet de supprimer un vertex sur base de son index.
+
+        Exemple:
+        del myvector[0]  # Supprime le premier vertex
+        """
         if ndx>=0 and ndx < self.nbvertices:
             self.myvertices.pop(ndx)
             self._reset_listogl()
             self.reset_linestring()
+        elif ndx < 0 and abs(ndx) <= self.nbvertices:
+            self.myvertices.pop(ndx + self.nbvertices)
+            self._reset_listogl()
+            self.reset_linestring()
         else:
             logging.warning(_('Index out of range'))
 
@@ -3966,6 +4014,25 @@ class vector:
         inside = [self.polygon.contains(Point(curxy)) for curxy in xy]
 
         return inside
+    
+    def get_first_point_inside(self, xy: cloud_vertices | np.ndarray):
+        """
+        Returns the first point (x, y) inside the polygon.
+
+        :param xy: Point cloud (cloud_vertices or np.ndarray)
+        :type xy: cloud_vertices | np.ndarray
+        :return: Coordinates (x, y) of the first point found inside, or None if none
+        :rtype: tuple[float, float] | None
+        """
+        self.prepare_shapely(True)
+        
+        if isinstance(xy, cloud_vertices):
+            xy = xy.get_xyz()[:, 0:2]
+
+        for curxy in xy:
+            if self.polygon.contains(Point(curxy)):
+                return float(curxy[0]), float(curxy[1])
+        return None
 
     def split_cloud(self, cloud_to_split:cloud_vertices):
         """ Split a cloud of vertices on the vector """
@@ -4023,7 +4090,7 @@ class vector:
     def area(self):
         """ Alias for surface """
         return self.surface
-
+       
     def interpolate_coordinates(self):
         """
         Interpole les valeurs Z des vertices sur base des seules valeurs connues,
@@ -4133,8 +4200,8 @@ class zone:
 
     def check_if_interior_exists(self):
         """ Check if the zone has at least one vector with interior points """
-        for curvec in self.myvectors:
-            curvec.check_if_interior_exists()
+
+        list(map(lambda curvec: curvec.check_if_interior_exists(), self.myvectors))
 
     def add_values(self, key:str, values:np.ndarray):
         """ add values to the zone """
@@ -4143,8 +4210,7 @@ class zone:
             logging.warning(_('Number of vectors and values do not match'))
             return
 
-        for curvec, curval in zip(self.myvectors, values):
-            curvec.add_value(key, curval)
+        list(map(lambda cur: cur[0].add_value(key, cur[1]), zip(self.myvectors, values)))
 
     def get_values(self, key:str) -> np.ndarray:
         """ get values from the zone """
@@ -4154,25 +4220,21 @@ class zone:
     def set_colors_from_value(self, key:str, cmap:wolfpalette | Colormap | cm.ScalarMappable, vmin:float= 0., vmax:float= 1.):
         """ Set the colors for the zone """
 
-        for curvec in self.myvectors:
-            curvec.set_color_from_value(key, cmap, vmin, vmax)
+        list(map(lambda curvec: curvec.set_color_from_value(key, cmap, vmin, vmax), self.myvectors))
 
     def set_alpha(self, alpha:int):
         """ Set the alpha for the zone """
 
-        for curvec in self.myvectors:
-            curvec.set_alpha(alpha)
+        list(map(lambda curvec: curvec.set_alpha(alpha), self.myvectors))
 
     def set_filled(self, filled:bool):
         """ Set the filled for the zone """
 
-        for curvec in self.myvectors:
-            curvec.set_filled(filled)
+        list(map(lambda curvec: curvec.set_filled(filled), self.myvectors))
 
     def check_if_open(self):
         """ Check if the vectors in the zone are open """
-        for curvec in self.myvectors:
-            curvec.check_if_open()
+        list(map(lambda curvect: curvect.check_if_open(), self.myvectors))
 
     def buffer(self, distance:float, resolution:int=16, inplace:bool = False) -> 'zone':
         """ Create a new zone with a buffer around each vector """
@@ -4197,24 +4259,21 @@ class zone:
         Set the legend text for the zone
         """
 
-        for curvect in self.myvectors:
-            curvect.set_legend_text(text)
+        list(map(lambda curvect: curvect.set_legend_text(text), self.myvectors))
 
     def set_legend_text_from_values(self, key:str):
         """
         Set the legend text for the zone from a value
         """
 
-        for curvect in self.myvectors:
-            curvect.set_legend_text_from_value(key)
+        list(map(lambda curvect: curvect.set_legend_text_from_value(key), self.myvectors))
+
 
     def set_legend_position(self, x, y):
         """
         Set the legend position for the zone
         """
-
-        for curvect in self.myvectors:
-            curvect.set_legend_position(x, y)
+        list(map(lambda curvect: curvect.set_legend_position(x, y), self.myvectors))
 
     @property
     def area(self):
@@ -4230,15 +4289,14 @@ class zone:
         """
         Set the cache for the zone and all its vectors
         """
-        for curvect in self.myvectors:
-            curvect.set_cache()
+
+        list(map(lambda curvect: curvect.set_cache(), self.myvectors))
 
     def clear_cache(self):
         """
         Clear the cache for the zone and all its vectors
         """
-        for curvect in self.myvectors:
-            curvect.clear_cache()
+        list(map(lambda curvect: curvect.clear_cache(), self.myvectors))
 
         self._move_start = None
         self._move_step = None
@@ -4598,8 +4656,9 @@ class zone:
         else:
             fig = ax.figure
 
-        for curvect in self.myvectors:
-            curvect.plot_matplotlib(ax)
+        # for curvect in self.myvectors:
+        #     curvect.plot_matplotlib(ax)
+        list(map(lambda curvect: curvect.plot_matplotlib(ax), self.myvectors))
 
         return fig, ax
 
@@ -4898,6 +4957,7 @@ class zone:
         # cs.set_zones(True)
 
         interp = Interpolators(banks, cs, ds)
+        interp.export_gltf()
 
         return interp
 
@@ -6290,9 +6350,13 @@ class zone:
         """
         Set the legend to the centroid of the vectors
         """
+        list(map(lambda curvec: curvec.set_legend_to_centroid(), self.myvectors))
 
-        for curvec in self.myvectors:
-            curvec.set_legend_position_to_centroid()
+    def set_legend_visible(self, visible:bool=True):
+        """
+        Set the visibility of the legend for all vectors in the zone
+        """
+        list(map(lambda curvec: curvec.set_legend_visible(visible), self.myvectors))
 
 class Zones(wx.Frame, Element_To_Draw):
     """
@@ -6321,6 +6385,7 @@ class Zones(wx.Frame, Element_To_Draw):
                  parent=None,
                  is2D=True,
                  idx: str = '',
+                 colname: str = None,
                  plotted: bool = True,
                  mapviewer=None,
                  need_for_wx: bool = False,
@@ -6427,7 +6492,7 @@ class Zones(wx.Frame, Element_To_Draw):
 
             elif self.filename.endswith('.shp'):
                 self.is2D=False
-                self.import_shapefile(self.filename, bbox=bbox)
+                self.import_shapefile(self.filename, bbox=bbox, colname=colname)
                 only_firstlast = True # We limit the number of vertices to the first and last ones to accelerate the process
 
             elif self.filename.endswith('.gpkg'):
@@ -6491,9 +6556,9 @@ class Zones(wx.Frame, Element_To_Draw):
             self.colorize_data(colors, filled=True)
 
         if plotted and self.has_OGLContext and not self.shared:
-            logging.info(_('Preparing OpenGL lists'))
+            logging.debug(_('Preparing OpenGL lists'))
             self.prep_listogl()
-            logging.info(_('OpenGL lists ready'))
+            logging.debug(_('OpenGL lists ready'))
 
     @property
     def mynames(self) -> list[str]:
@@ -6759,9 +6824,10 @@ class Zones(wx.Frame, Element_To_Draw):
 
         logging.info(_('Importing shapefile {}'.format(fn)))
         content = gpd.read_file(fn, bbox=bbox)
-
-        self.import_GeoDataFrame(content, colname=colname)
-
+        
+        self.import_GeoDataFrame(content=content, colname=colname)        
+    
+    
     def import_GeoDataFrame(self, content:gpd.GeoDataFrame,
                             bbox:Polygon = None, colname:str = None):
         """
@@ -6786,24 +6852,24 @@ class Zones(wx.Frame, Element_To_Draw):
             idx, row = row
             keys = list(row.keys())
             if colname in keys:
-                name = row[colname]
+                name = str(row[colname])
             elif 'NAME' in keys:
-                name = row['NAME']
+                name = str(row['NAME'])
             elif 'location' in keys:
-                name = row['location'] # tuilage gdal
+                name = str(row['location']) # tuilage gdal
             elif 'Communes' in keys:
-                name = row['Communes']
+                name = str(row['Communes'])
             elif 'name' in keys:
-                name = row['name']
+                name = str(row['name'])
             elif 'MAJ_NIV3T' in keys:
                 # WALOUS
-                name = row['MAJ_NIV3T']
+                name = str(row['MAJ_NIV3T'])
             elif 'NATUR_DESC' in keys:
-                name = row['NATUR_DESC']
+                name = str(row['NATUR_DESC'])
             elif 'mun_name_f' in keys:
-                name = row['mun_name_f'].replace('[','').replace(']','').replace("'",'')
+                name = str(row['mun_name_f']).replace('[','').replace(']','').replace("'",'')
             elif 'mun_name_fr' in keys:
-                name = row['mun_name_fr']
+                name = str(row['mun_name_fr'])
             else:
                 name = str(idx)
 
@@ -7300,6 +7366,12 @@ class Zones(wx.Frame, Element_To_Draw):
         if forceparent:
             addedzone.parent = self
 
+    def create_zone(self, name:str = '') -> zone:
+        """ Create a new zone and add it to the list of zones """
+        newzone = zone(name=name, parent=self, is2D=self.is2D)
+        self.myzones.append(newzone)
+        return newzone
+
     def find_minmax(self, update=False, only_firstlast:bool=False):
         """
         Trouve les bornes des vertices pour toutes les zones et tous les vecteurs