wolfhece 2.1.104__py3-none-any.whl → 2.1.106__py3-none-any.whl

wolfhece/PyDraw.py

@@ -90,6 +90,7 @@ try:
     from .wolf_zi_db import ZI_Databse_Elt, PlansTerrier
     from .math_parser.calculator import Calculator
     from .wintab.wintab import Wintab
+    from .images_tiles import ImagesTiles
 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.")
@@ -511,6 +512,7 @@ class draw_type(Enum):
     WMSBACK = 'wms-background'
     WMSFORE = 'wms-foreground'
     TILES = 'tiles'
+    IMAGESTILES = 'imagestiles'
 
 class Colors_1to9(wx.Frame):
 
@@ -1116,6 +1118,7 @@ class WolfMapViewer(wx.Frame):
     mywmsfore: list
     myres2D: list
     mytiles: list[Tiles]
+    myimagestiles: list[ImagesTiles]
     mypartsystems: list[Particle_system]
     myviewers3d:list[Wolf_Viewer3D]
     sim_explorers: dict[Wolfresults_2D:Sim_Explorer]
@@ -1140,6 +1143,7 @@ class WolfMapViewer(wx.Frame):
     active_cs: crosssections
     active_tri: Triangulation
     active_tile: Tiles
+    active_imagestiles: ImagesTiles
     active_particle_system: Particle_system
     active_viewer3d: Wolf_Viewer3D
 
@@ -1244,6 +1248,7 @@ class WolfMapViewer(wx.Frame):
         self.menusim2D_GPU = None
         self.menulaz    = None
         self.menutiles  = None
+        self.menuimagestiles = None
 
         self.filemenu = wx.Menu()
         openitem = self.filemenu.Append(wx.ID_OPEN, _('Open project'), _('Open a complete project from file'))
@@ -1334,8 +1339,9 @@ class WolfMapViewer(wx.Frame):
                                             _('Add array and crop (binary file - real)'))
         addvector = self.menuaddobj.Append(wx.ID_FILE2, _('Add vectors...'), _('Add vectors'))
         addtiles = self.menuaddobj.Append(wx.ID_ANY, _('Add tiles...'), _('Add tiles'))
+        addimagestiles = self.menuaddobj.Append(wx.ID_ANY, _('Add images tiles...'), _('Add georeferenced images tiles'))
         addtilescomp = self.menuaddobj.Append(wx.ID_ANY, _('Add tiles comparator...'), _('Add tiles comparator'))
-        addtiles = self.menuaddobj.Append(wx.ID_ANY, _('Add tiles GPU...'), _('Add tiles from 2D GPU model -- 2 arrays will be added'))
+        addtilesgpu = self.menuaddobj.Append(wx.ID_ANY, _('Add tiles GPU...'), _('Add tiles from 2D GPU model -- 2 arrays will be added'))
         addcloud = self.menuaddobj.Append(wx.ID_FILE3, _('Add cloud...'), _('Add cloud'))
         addtri = self.menuaddobj.Append(wx.ID_ANY, _('Add triangulation...'), _('Add triangulation'))
         addprofiles = self.menuaddobj.Append(wx.ID_FILE4, _('Add cross sections...'), _('Add cross sections'))
@@ -1751,6 +1757,25 @@ class WolfMapViewer(wx.Frame):
             self.Bind(wx.EVT_MENU, self.create_data_from_tiles_activevec, data_active_polygon_tiles)
             self.Bind(wx.EVT_MENU, self.create_data_from_tiles_tmpvec, data_tmpvec_tiles)
 
+    def pîck_image_tile(self, event: wx.Event):
+
+        if self.active_imagestiles is None:
+            logging.warning(_('No active image tile -- Please load data first'))
+            return
+
+        self.action = 'select active image tile'
+        logging.info(_('Select active image tile'))
+
+    def menu_imagestiles(self):
+        """ Menu for image tiles """
+        if self.menuimagestiles is None:
+            self.menuimagestiles = wx.Menu()
+            self.menubar.Append(self.menuimagestiles, _('&Image tiles'))
+
+            picktiles = self.menuimagestiles.Append(wx.ID_ANY, _('Pick a tile and (un)load data'), _('Right click to pick a tile'))
+            self.Bind(wx.EVT_MENU, self.pîck_image_tile, picktiles)
+
+
     def pick_tile(self, event: wx.Event):
 
         if self.active_tile is None:
@@ -3750,6 +3775,7 @@ class WolfMapViewer(wx.Frame):
         self.mypartsystems = []
         self.myvectors = []
         self.mytiles = []
+        self.myimagestiles = []
         self.myclouds = []
         self.mytri = []
         self.myothers = []
@@ -3761,7 +3787,7 @@ class WolfMapViewer(wx.Frame):
         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.mypartsystems, self.myviewers3d]
+        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.menu_options = wx.Menu()
         self._change_title = self.menu_options.Append(wx.ID_ANY, _('Change title'), _('Change title of the window'))
@@ -5045,6 +5071,14 @@ class WolfMapViewer(wx.Frame):
 
         logging.info(_('Clip LAZ grid on current zoom {}-{}  {}-{}').format(curbounds[0][0],curbounds[0][1],curbounds[1][0],curbounds[1][1]))
 
+    def decimate_data(self, factor:int = 10):
+        """ Decimate data """
+
+        if self.mylazdata is None:
+            return
+
+        self.mylazdata = self.mylazdata[::factor]
+
     def select_active_array_from_laz(self, array:WolfArray = None, used_codes:list = None, chunk_size:float = 500.):
         """ select some nodes from laz data
 
@@ -6394,6 +6428,27 @@ class WolfMapViewer(wx.Frame):
             autoscale=False
             self.clip_laz_gridded()
 
+            if self.mylazdata is None:
+                return
+
+            if self.mylazdata.shape[0] > 100_000_000:
+
+                # Choose a decimation factor - integer
+                dlg = wx.NumberEntryDialog(None, _('Your data selection is very large (>100 M)\nWould you like to decimate?'),
+                                           _('Decaimate factor'), _('Decimation'), 0, 0, 100)
+
+                ret = dlg.ShowModal()
+
+                if ret == wx.ID_CANCEL:
+                    dlg.Destroy()
+                    return
+
+                decimate_fact = dlg.GetValue()
+                dlg.Destroy()
+
+                if decimate_fact > 0:
+                    self.decimate_data(decimate_fact)
+
         elif itemlabel == _('Fill active array from LAZ data'):
             if self.mylazgrid is None:
                 logging.warning('')
@@ -6530,6 +6585,9 @@ class WolfMapViewer(wx.Frame):
         elif itemlabel == _('Add tiles...'):
             self.add_object(which='tiles', ToCheck=True)
 
+        elif itemlabel ==_('Add images tiles...'):
+            self.add_object(which='imagestiles', ToCheck=True)
+
         elif itemlabel == _('Add tiles comparator...'):
             self.add_object(which='tilescomp', ToCheck=True)
 
@@ -6914,7 +6972,7 @@ class WolfMapViewer(wx.Frame):
         #     print("Simulation")
         #     load_sim_to_gpu()
 
-        if len(self.myarrays) + len(self.myvectors) + len(self.myclouds) + len(self.mytri) + len(self.myres2D) + len(self.mytiles) + len(self.mypartsystems) == 2 and autoscale:
+        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
             self.Autoscale()
 
@@ -7439,7 +7497,8 @@ class WolfMapViewer(wx.Frame):
                                  'res2d_gpu',
                                  'particlesystem',
                                  'wmsback',
-                                 'wmsfore'] = 'array',
+                                 'wmsfore',
+                                 'imagestiles'] = 'array',
                    filename='',
                    newobj=None,
                    ToCheck=True,
@@ -7463,6 +7522,8 @@ class WolfMapViewer(wx.Frame):
             # ouverture d'une boîte de dialogue
             if which.lower() == 'array' or which.lower() == 'array_crop':
                 file = wx.FileDialog(self, "Choose file", wildcard=filterArray)
+            elif which.lower() == 'imagestiles':
+                file = wx.DirDialog(self, "Choose directory containing images")
             elif which.lower() == 'particlesystem':
                 file = wx.FileDialog(self, "Choose file", wildcard=filterjson)
             elif which.lower() == 'array_lidar_first' or which.lower() == 'array_lidar_second':
@@ -7670,6 +7731,21 @@ class WolfMapViewer(wx.Frame):
 
             return
 
+
+        elif which.lower() == 'imagestiles':
+
+            curdict = self.myimagestiles
+            curtree = self.myitemsvector
+
+            if newobj is None:
+
+                newobj = ImagesTiles('', parent=self, mapviewer=self)
+                newobj.scan_dir(Path(filename))
+
+            self.myimagestiles.append(newobj)
+            self.active_imagestiles = newobj
+            self.menu_imagestiles()
+
         elif which.lower() == 'bridges':
             curdict = self.myvectors
             curtree = self.myitemsvector
@@ -7975,10 +8051,23 @@ class WolfMapViewer(wx.Frame):
                     if ret == wx.ID_YES:
                         loadhead = True
 
-                with wx.lib.busy.BusyInfo(_('Importing cloud points')):
-                    wait = wx.BusyCursor()
-                    newobj = cloud_vertices(filename, header=loadhead, mapviewer=self)
-                    del wait
+                    types = None
+
+                elif filename.endswith('.dxf'):
+                    types = ['POLYLINE','LWPOLYLINE','LINE', 'MTEXT', 'INSERT']
+
+                    dlg = wx.MultiChoiceDialog(None, _('Choose the types of entities to import'), _('Choose entities'), types)
+                    dlg.SetSelections = [3,4]
+
+                    ret = dlg.ShowModal()
+                    if ret == wx.ID_CANCEL:
+                        dlg.Destroy()
+                        return -1
+
+                    types = [types[i] for i in dlg.GetSelections()]
+                    dlg.Destroy()
+
+                newobj = cloud_vertices(filename, header=loadhead, mapviewer=self, dxf_imported_elts=types)
 
             self.myclouds.append(newobj)
             self.active_cloud = newobj
@@ -8181,6 +8270,8 @@ class WolfMapViewer(wx.Frame):
             return self.mywmsback
         elif drawing_type == draw_type.WMSFORE:
             return self.mywmsfore
+        elif drawing_type == draw_type.IMAGESTILES:
+            return self.myimagestiles
         else:
             logging.error('Unknown drawing type : ' + drawing_type)
             return None
@@ -9032,6 +9123,13 @@ class WolfMapViewer(wx.Frame):
 
                 self.add_object('array', newobj = tilearray, ToCheck=True, id=id_label)
 
+        elif self.action == 'select active image tile':
+            # select active image tile
+
+            self.active_imagestiles.select_vectors_from_point(x, y, True)
+            active_tile = self.active_imagestiles.get_selected_vectors()
+            active_tile.myprop.imagevisible = not active_tile.myprop.imagevisible
+
         elif self.action.find('select active vector') > -1:
             # Select active vector
 
@@ -11012,6 +11110,7 @@ class WolfMapViewer(wx.Frame):
 
             # Dessin des tuiles
             self._plotting(draw_type.TILES)
+            self._plotting(draw_type.IMAGESTILES)
 
             if self.active_vector is not None:
                 if self.active_vector.parentzone is None:
@@ -11098,6 +11197,16 @@ class WolfMapViewer(wx.Frame):
                         ymax = max(locvector.ymax, ymax)
                     k += 1
 
+        for locvector in self.myimagestiles:
+            if locvector.plotted or force:
+                locvector.find_minmax()
+                if isinstance(locvector,ImagesTiles):
+                    xmin = min(locvector.xmin, xmin)
+                    xmax = max(locvector.xmax, xmax)
+                    ymin = min(locvector.ymin, ymin)
+                    ymax = max(locvector.ymax, ymax)
+                k += 1
+
         for locvector in self.mytiles:
             if locvector.plotted or force:
                 if locvector.idx != 'grid':

wolfhece/PyGui.py

@@ -178,14 +178,23 @@ class MapManager(GenMapManager):
 
 
         # Set directory for hydrometry data, relative to the current file
-        dir_hydro = Path(__file__).parent / "data/hydrometry"
-        if not exists(dir_hydro):
-            makedirs(dir_hydro, exist_ok=True)
+        dir_data = Path(__file__).parent / "data"
+        dir_hydro = dir_data / "hydrometry"
+        if not dir_hydro.exists():
+            dir_hydro.mkdir(parents=True, exist_ok=True)
+
+        dir_cadaster = dir_data / "Cadaster"
+        if not dir_cadaster.exists():
+            dir_cadaster.mkdir(parents=True, exist_ok=True)
+
+        dir_picc = dir_data / "PICC"
+        if not dir_picc.exists():
+            dir_picc.mkdir(parents=True, exist_ok=True)
 
         try:
             self.SPWhydrometry = hydrometry_wolfgui(dir=dir_hydro, idx = 'SPW hydrometry', mapviewer=self.mapviewer, parent = self, plotted=False)
-            self.picc          = Picc_data(data_dir=Path(r'data/PICC'), mapviewer=self.mapviewer)
-            self.cadaster      = Cadaster_data(data_dir=Path(r'data/Cadaster'), mapviewer=self.mapviewer)
+            self.picc          = Picc_data(data_dir=dir_picc, mapviewer=self.mapviewer)
+            self.cadaster      = Cadaster_data(data_dir=dir_cadaster, mapviewer=self.mapviewer)
             self.landmaps      = PlansTerrier(mapviewer=self.mapviewer, parent = self, idx='LandMaps', plotted=True)
 
             self.mapviewer.add_object(which='other',

wolfhece/PyVertex.py

@@ -468,7 +468,8 @@ class cloud_vertices(Element_To_Draw):
                  plotted: bool = True,
                  mapviewer=None,
                  need_for_wx: bool = False,
-                 bbox:Polygon = None) -> None:
+                 bbox:Polygon = None,
+                 dxf_imported_elts = ['MTEXT', 'INSERT']) -> None:
         """
         Init cloud of vertices
 
@@ -508,7 +509,7 @@ class cloud_vertices(Element_To_Draw):
         if self.filename != '':
             if toload:
                 if Path(fname).suffix.lower() == '.dxf':
-                    self.import_from_dxf(self.filename)
+                    self.import_from_dxf(self.filename, imported_elts=dxf_imported_elts)
                 elif Path(fname).suffix.lower() == '.shp':
                     self.import_shapefile(self.filename, bbox=bbox)
                 else:
@@ -703,7 +704,7 @@ class cloud_vertices(Element_To_Draw):
 
             self.loaded = True
 
-    def import_from_dxf(self,fn:str=''):
+    def import_from_dxf(self, fn:str='', imported_elts=['MTEXT', 'INSERT']):
         """
         Importing DXF file using ezdxf library
 
@@ -717,27 +718,73 @@ class cloud_vertices(Element_To_Draw):
         import ezdxf
 
         # Lecture du fichier dxf et identification du modelspace
+        logging.info(_('Reading DXF file : ')+fn)
         doc = ezdxf.readfile(fn)
         msp = doc.modelspace()
 
+        logging.info(_('Number of entities : ')+str(len(msp)))
+        logging.info(_('Number of layers : ')+str(len(doc.layers)))
+        logging.info(_('Treating entities... '))
+                     
         # Bouclage sur les éléments du DXF
         k=0
         for e in msp:
-            if e.dxftype() == "MTEXT" or e.dxftype()=='INSERT':
-                x = e.dxf.insert[0]
-                y = e.dxf.insert[1]
-                z = e.dxf.insert[2]
+            if doc.layers.get(e.dxf.layer).is_on():
+                if e.dxftype() in imported_elts:
+                    if e.dxftype() == "MTEXT" or e.dxftype()=='INSERT':
+                        x = e.dxf.insert[0]
+                        y = e.dxf.insert[1]
+                        z = e.dxf.insert[2]
+
+                        if z!=0.:
+                            curvert = wolfvertex(x, y, z)
+                            curdict = self.myvertices[k] = {}
+                            curdict['vertex'] = curvert
+                            k += 1
+
+                    elif e.dxftype() == "POLYLINE":
+                        # récupération des coordonnées
+                        verts = [cur.dxf.location.xyz for cur in e.vertices]
+                        for cur in verts:
+                            curvert = wolfvertex(cur[0],cur[1],cur[2])
+                            curdict = self.myvertices[k] = {}
+                            curdict['vertex'] = curvert
+                            k += 1
+
+                    elif e.dxftype() == "LWPOLYLINE":
+                        # récupération des coordonnées
+                        verts = np.array(e.lwpoints.values)
+                        verts = verts.reshape([verts.size // 5,5])[:,:2]   #  in ezdxf 1.3.5, the lwpoints.values attribute is a np.ndarray [n,5]
+                        verts = np.column_stack([verts,[e.dxf.elevation]*len(verts)])
+
+                        for cur in verts:
+                            curvert = wolfvertex(cur[0],cur[1],cur[2])
+                            curdict = self.myvertices[k] = {}
+                            curdict['vertex'] = curvert
+                            k += 1
+
+                    elif e.dxftype() == "LINE":
+                        # récupération des coordonnées
+                        curvert = wolfvertex(e.dxf.start[0],e.dxf.start[1],e.dxf.start[2])
+                        curdict = self.myvertices[k] = {}
+                        curdict['vertex'] = curvert
+                        k += 1
+
+                        curvert = wolfvertex(e.dxf.end[0],e.dxf.end[1],e.dxf.end[2])
+                        curdict = self.myvertices[k] = {}
+                        curdict['vertex'] = curvert
+                        k += 1
 
-                if z!=0.:
-                    curvert = wolfvertex(x, y, z)
-                    curdict = self.myvertices[k] = {}
-                    curdict['vertex'] = curvert
-                    k += 1
+                else:
+                    logging.warning(_('DXF element not supported/ignored : ') + e.dxftype())
+            else:
+                logging.info(_('Layer {} is off'.format(e.dxf.layer)))
 
         self.find_minmax(True)
         self.loaded = True
 
         logging.info(_('Number of imported points : ')+str(k))
+        logging.info(_('Importation finished'))
 
         return k
 

wolfhece/PyVertexvectors.py

@@ -48,7 +48,7 @@ from .wolf_texture import Text_Image_Texture,Text_Infos
 from .drawing_obj import Element_To_Draw
 
 class Triangulation(Element_To_Draw):
-    def __init__(self, fn='', pts=[],tri=[], idx: str = '', plotted: bool = True, mapviewer=None, need_for_wx: bool = False) -> None:
+    def __init__(self, fn='', pts=[], tri=[], idx: str = '', plotted: bool = True, mapviewer=None, need_for_wx: bool = False) -> None:
         super().__init__(idx, plotted, mapviewer, need_for_wx)
 
         self.filename = ''
@@ -62,6 +62,8 @@ class Triangulation(Element_To_Draw):
         if fn !='':
             self.filename=fn
             self.read(fn)
+        else:
+            self.valid_format()
         pass
 
     def valid_format(self):
@@ -3354,6 +3356,105 @@ class zone:
 
         return mytri
 
+    def create_constrainedDelaunay(self, nb=None) -> Triangulation:
+        """
+        Création d'une triangulation Delaunay contrainte sur base des vecteurs
+
+        Utilisation de la librairie "triangle" (https://www.cs.cmu.edu/~quake/triangle.delaunay.html)
+
+        :param nb: nombre de points de découpe des vecteurs (0 pour ne rien redécouper)
+        """
+
+        wx_exists = wx.App.Get() is not None
+
+        # Transformation des vecteurs en polylines shapely
+        # Utile pour le redécoupage
+        myls = []
+        for curv in self.myvectors:
+            myls.append(curv.asshapely_ls())
+
+        meanlength = np.mean([curline.length for curline in myls])
+
+        if nb is None and wx_exists:
+            dlg=wx.NumberEntryDialog(None,
+                                     _('How many points along polylines ? (0 to use as it is)')+'\n'+
+                                     _('Mean length size is {} meters').format(meanlength),
+                                     'nb',
+                                     'dl size',
+                                     100,
+                                     0,
+                                     10000)
+            ret=dlg.ShowModal()
+            if ret==wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+
+            nb=int(dlg.GetValue())
+            dlg.Destroy()
+        else:
+            logging.warning( _('Bad parameter nb'))
+
+        if nb==0:
+            # no decimation
+            newls = myls
+        else:
+            # redécoupage des polylines
+            s = np.linspace(0.,1.,num=nb,endpoint=True)
+
+            newls = [LineString([curls.interpolate(curs,True) for curs in s]) for curls in myls]
+
+        # Récupération des coordonnées des points
+        xyz = [np.asarray(curls.coords[:]) for curls in newls]
+        xyz = np.concatenate(xyz)
+
+        # Recherche du minimum pour recentrer les coordonnées et éviter des erreurs de calcul
+        xmin = xyz[:,0].min()
+        ymin = xyz[:,1].min()
+
+        xyz[:,0] -= xmin
+        xyz[:,1] -= ymin
+
+        # Remove duplicate points
+        xyz, indices = np.unique(xyz, axis=0, return_inverse=True)
+
+        # Numérotation des segments
+        segments = []
+        k = 0
+        for cur in newls:
+            for i in range(len(cur.coords)-1):
+                segments.append([indices[k], indices[k+1]])
+                k+=1
+
+        # Création de la géométrie pour la triangulation
+        geom = {'vertices' : [[x,y] for x,y in xyz[:,:2]],
+                'segments' : segments}
+
+        try:
+            # Triangulation
+            delaunay = triangle.triangulate(geom, 'p') # d'autres options sont possibles (voir la doc de triangle)
+
+            # Recover z values from xyz for each vertex
+            # Searching value in xyz is not the best way
+            # We create a dictionary to avoid searching manually
+            xyz_dict = {(curxyz[0], curxyz[1]): curxyz[2] for curxyz in xyz}
+            allvert = []
+            for curvert in delaunay['vertices']:
+                x = curvert[0]
+                y = curvert[1]
+                z = xyz_dict.get((x, y), 0.)
+                allvert.append([x + xmin, y + ymin, z])
+
+            # Create the Triangulation object
+            mytri=Triangulation(pts= allvert,
+                                tri= [curtri for curtri in delaunay['triangles']])
+            mytri.find_minmax(True)
+
+        except Exception as e:
+            logging.error(_('Error in constrained Delaunay triangulation - {e}'))
+            return None
+
+        return mytri
+
     def createmultibin_proj(self, nb=None, nb2=0) -> Triangulation:
         """
         Création d'une triangulation sur base des vecteurs par projection au plus proche du vecteur central
@@ -4562,6 +4663,8 @@ class Zones(wx.Frame, Element_To_Draw):
         for idx, row in content.iterrows():
             if 'NAME' in row.keys():
                 name = row['NAME']
+            elif 'name' in row.keys():
+                name = row['name']
             elif 'MAJ_NIV3T' in row.keys():
                 # WALOUS
                 name = row['MAJ_NIV3T']
@@ -4818,28 +4921,31 @@ class Zones(wx.Frame, Element_To_Draw):
         # Bouclage sur les éléments du DXF pour identifier les layers utiles et ensuite créer les zones adhoc
         for e in msp:
             if doc.layers.get(e.dxf.layer).is_on():
-                if e.dxftype() == "POLYLINE":
-                    if e.dxf.layer not in used_layers.keys():
-                        curlayer = used_layers[e.dxf.layer]={}
-                    else:
-                        curlayer = used_layers[e.dxf.layer]
-                    curlayer[e.dxftype().lower()]=0
+                if e.dxftype() in imported_elts:
+                    if e.dxftype() == "POLYLINE":
+                        if e.dxf.layer not in used_layers.keys():
+                            curlayer = used_layers[e.dxf.layer]={}
+                        else:
+                            curlayer = used_layers[e.dxf.layer]
+                        curlayer[e.dxftype().lower()]=0
 
-                elif e.dxftype() == "LWPOLYLINE":
-                    if e.dxf.layer not in used_layers.keys():
-                        curlayer = used_layers[e.dxf.layer]={}
-                    else:
-                        curlayer = used_layers[e.dxf.layer]
-                    curlayer[e.dxftype().lower()]=0
+                    elif e.dxftype() == "LWPOLYLINE":
+                        if e.dxf.layer not in used_layers.keys():
+                            curlayer = used_layers[e.dxf.layer]={}
+                        else:
+                            curlayer = used_layers[e.dxf.layer]
+                        curlayer[e.dxftype().lower()]=0
 
-                elif e.dxftype() == "LINE": # dans ce cas spécifique, ce sont a priori les lignes composant les croix sur les points levés
-                    if e.dxf.layer not in used_layers.keys():
-                        curlayer = used_layers[e.dxf.layer]={}
-                    else:
-                        curlayer = used_layers[e.dxf.layer]
-                    curlayer[e.dxftype().lower()]=0
+                    elif e.dxftype() == "LINE": # dans ce cas spécifique, ce sont a priori les lignes composant les croix sur les points levés
+                        if e.dxf.layer not in used_layers.keys():
+                            curlayer = used_layers[e.dxf.layer]={}
+                        else:
+                            curlayer = used_layers[e.dxf.layer]
+                        curlayer[e.dxftype().lower()]=0
+                else:
+                    logging.warning(_('DXF element not supported : ') + e.dxftype())
             else:
-                pass
+                logging.info(_('Layer {} is off'.format(e.dxf.layer)))
 
         # Création des zones
         for curlayer in used_layers.keys():
@@ -4870,7 +4976,8 @@ class Zones(wx.Frame, Element_To_Draw):
                     nbid+=1
                     # récupération des coordonnées
                     verts = np.array(e.lwpoints.values)
-                    verts = verts.reshape([int(len(verts)/5),5])[:,:2]
+                    verts = verts.reshape([verts.size // 5,5])[:,:2]   #  in ezdxf 1.3.5, the lwpoints.values attribute is a np.ndarray [n,5]
+                    # verts = verts.reshape([len(verts) // 5,5])[:,:2] #  in ezdxf 1.2.0, the lwpoints.values attribute was flattened
                     verts = np.column_stack([verts,[e.dxf.elevation]*len(verts)])
 
                     curzone = used_layers[e.dxf.layer][e.dxftype().lower()]
@@ -5206,6 +5313,10 @@ class Zones(wx.Frame, Element_To_Draw):
             self.trifromall_proj.SetToolTip(_("Create a triangular mesh based on all vectors in the currently active zone.\nGenerate vertices by projecting the central polyline, or the nearest one if there is an even number of polylines, onto the other polylines.\nAdd the resulting mesh to the GUI.\nThis can be useful in certain interpolation methods."))
             self.trifromall_proj.Bind(wx.EVT_BUTTON,self.Oncreatemultibin_project)
 
+            self.constrainedDelaunay = wx.Button(self,label=_('Constrained Delaunay'))
+            self.constrainedDelaunay.SetToolTip(_("Create a triangular mesh based on all vectors in the currently active zone."))
+            self.constrainedDelaunay.Bind(wx.EVT_BUTTON,self.OnconstrainedDelaunay)
+
             self.polyfrompar = wx.Button(self,label=_('Create polygons from parallels'))
             self.polyfrompar.SetToolTip(_("Create polygons in a new zone from parallels defined by " + _('Add and parallel') + _(" and a 2D curvilinear distance \n Useful for plotting some results or analyse data inside each polygon")))
             self.polyfrompar.Bind(wx.EVT_BUTTON,self.Oncreatepolygons)
@@ -5335,6 +5446,7 @@ class Zones(wx.Frame, Element_To_Draw):
             boxtri.Add(self.binfrom3,1,wx.EXPAND)
             boxtri.Add(self.trifromall,1,wx.EXPAND)
             boxtri.Add(self.trifromall_proj,1,wx.EXPAND)
+            boxtri.Add(self.constrainedDelaunay,1,wx.EXPAND)
             boxtri.Add(self.polyfrompar,1,wx.EXPAND)
             boxtri.Add(self.slidingpoly,1,wx.EXPAND)
 
@@ -6122,6 +6234,21 @@ class Zones(wx.Frame, Element_To_Draw):
             self.mapviewer.add_object('triangulation',newobj=mytri)
             self.mapviewer.Refresh()
 
+    def OnconstrainedDelaunay(self, event:wx.MouseEvent):
+        """
+        Create a constrained Delaunay triangulation from the active zone
+        """
+        if self.wx_exists:
+            if self.active_zone is None:
+                return
+
+            myzone = self.active_zone
+
+            mytri = myzone.create_constrainedDelaunay()
+
+            self.mapviewer.add_object('triangulation',newobj=mytri)
+            self.mapviewer.Refresh()
+
     def Oncreatemultibin_project(self, event:wx.MouseEvent):
         """
         Création d'une triangulation sur base de plusieurs vecteurs
@@ -6917,5 +7044,5 @@ class Grid(Zones):
         contour.add_vertex(newvert)
         newvert=wolfvertex(locox,locey)
         contour.add_vertex(newvert)
-        
+
         self.find_minmax(True)

wolfhece/apps/version.py

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

wolfhece/images_tiles.py

@@ -0,0 +1,84 @@
+from osgeo import gdal
+import logging
+from pathlib import Path
+
+from .PyTranslate import _
+from .wolf_array import WolfArray, WolfArrayMB
+from .PyVertexvectors import zone,Zones,vector, wolfvertex
+
+
+class ImagesTiles(Zones):
+    """ Class to manage images tiles.
+
+    Images must be stored in the same directory.
+    """
+
+    def __init__(self,
+                 filename = '',
+                 ox = 0, oy = 0,
+                 tx = 0, ty = 0,
+                 parent=None, is2D=True,
+                 idx = '', plotted = True,
+                 mapviewer=None, need_for_wx = False,
+                 bbox = None, find_minmax = True,
+                 shared = False, colors = None):
+
+        super().__init__(filename, ox, oy, tx, ty, parent, is2D, idx, plotted, mapviewer, need_for_wx, bbox, find_minmax, shared, colors)
+
+    def scan_dir(self, directory:Path, extensions:list[str] = ['tif', 'tiff']):
+        """ Scan directory for images tiles.
+
+        :param directory: directory to scan.
+        :param extensions: list of extensions to search for.
+        """
+
+        self.myzones = []
+        for ext in extensions:
+            self.myzones += self.scan_dir_ext(directory, ext)
+
+        self.find_minmax(True)
+
+    def scan_dir_ext(self, directory:Path, ext:str, force_visible:bool = False):
+        """ Scan directory for images tiles with a specific extension.
+
+        :param directory: directory to scan.
+        :param ext: extension to search for.
+        """
+
+        all_files = directory.glob(f'*.{ext}')
+
+        zones = []
+        for file in all_files:
+            try:
+                ds:gdal.Dataset
+                ds = gdal.Open(str(file))
+                if ds is None:
+                    logging.error(f'Could not open {file}')
+                    continue
+
+                ulx, xres, xskew, uly, yskew, yres  = ds.GetGeoTransform()
+                lrx = ulx + (ds.RasterXSize * xres)
+                lry = uly + (ds.RasterYSize * yres)
+
+                xmin, xmax = min(ulx, lrx), max(ulx, lrx)
+                ymin, ymax = min(uly, lry), max(uly, lry)
+
+                loczone = zone(name = file, parent= self)
+                vect = vector(name='image', parentzone=loczone)
+                loczone.add_vector(vect)
+
+                vect.myprop.attachedimage = Path(file)
+                vect.myprop.imagevisible = True if ds.RasterXSize * ds.RasterYSize < 8_000_000 or force_visible else False
+
+                vect.add_vertex(wolfvertex(xmin, ymin))
+                vect.add_vertex(wolfvertex(xmax, ymin))
+                vect.add_vertex(wolfvertex(xmax, ymax))
+                vect.add_vertex(wolfvertex(xmin, ymax))
+                vect.close_force()
+
+                zones.append(loczone)
+
+            except Exception as e:
+                logging.error(f'Error while opening {file}: {e}')
+
+        return zones

wolfhece/lazviewer/laz_viewer.py

@@ -451,6 +451,11 @@ class xyz_laz_grid():
         self.endy = ybounds[1]
         self.nbx = gridsize[0]
         self.nby = gridsize[1]
+
+        if self.nbx == 0 or self.nby == 0:
+            logging.error(_('Grid size is 0 - abort !'))
+            return
+
         self.dx = (self.endx-self.origx)/float(self.nbx)
         self.dy = (self.endy-self.origy)/float(self.nby)
         self.genfile=fn_out+'_'+'x1'+'_'+'y1'+'_xyz.bin'
@@ -503,9 +508,12 @@ class xyz_laz_grids():
         ret = [cur for cur in ret if len(cur)>0]
 
         if len(ret)==0:
+            logging.info(_('No data found'))
             return np.asarray([])
         else:
-            return np.concatenate(ret)
+            ret = np.concatenate(ret)
+            logging.info(_('Data found -- {} points'.format(ret.shape[0])))
+            return ret
 
     def read_dir(self, dir_grids):
         dirs = listdir(dir_grids)
@@ -633,6 +641,9 @@ class xyz_laz_grids():
                         vec = vecs.get_zone(file_wo_suf)
                         bounds = vec.myvectors[0].get_bounds()
 
+                        bounds = [[math.floor(bounds[0][0]/ds)*ds, math.floor(bounds[0][1]/ds)*ds],
+                                            [math.ceil(bounds[1][0]/ds)*ds, math.ceil(bounds[1][1]/ds)*ds]]
+
                         dx = bounds[1][0] -bounds[0][0]
                         dy = bounds[1][1] -bounds[0][1]
                         nb = max(int(dx/ds), int(dy/ds))
@@ -640,7 +651,7 @@ class xyz_laz_grids():
                         self.grids.append(newlaz._sort_grid_np(entry.path,
                                                             join(dirname, file_wo_suf),
                                                             bounds=[[bounds[0][0], bounds[1][0]], [bounds[0][1], bounds[1][1]]],
-                                                            gridsize=[int(dx/ds), int(dy/ds)],
+                                                            gridsize=[max(int(dx/ds),1), max(int(dy/ds),1)],
                                                             force_format=force_format))
 
 def find_pointsXYZ(xyz:np.ndarray, bounds:Union[tuple[tuple[float,float],tuple[float,float]], list[list[float, float],list[float, float]]]) -> np.ndarray:

wolfhece/wolf_array.py

@@ -5614,21 +5614,32 @@ class WolfArray(Element_To_Draw, header_wolf):
         if reset_plot:
             self.reset_plot()
 
-    def export_geotif(self, outdir='', extent = '', EPSG:int = 31370):
+    def export_geotif(self, outdir:str= '', extent:str= '', EPSG:int = 31370):
         """
         Export de la matrice au format Geotiff (Lambert 72 - EPSG:31370)
 
+        Pour sauvegarder l'objet au format Geotiff, il est recommandé d'utiliser
+        la fonction write_all plutôt que celle-ci directement.
+
         Formats supportés :
             - Int32
+            - Int16
+            - Int8
+            - Byte
             - Float32
             - Float64
 
-        :param outdir: directory
-        :param extent: suffix to add to the filename before the extension '.tif'
+        :param outdir: directory - If provided, the file will be savd as "outdir/idx+extent.tif" 
+                                   If not provided, we use the filename attribute
+
+        :param extent: suffix to add to the filename before the extension '.tif' (only if outdir is provided)
         :param EPSG: EPSG code, by default 31370 (Lambert 72)
         """
         from osgeo import gdal, osr, gdalconst
 
+        outdir = str(outdir)
+        extent = str(extent)
+
         srs = osr.SpatialReference()
         srs.ImportFromEPSG(EPSG)
 
@@ -5650,6 +5661,9 @@ class WolfArray(Element_To_Draw, header_wolf):
         elif arr.dtype == np.int16:
             arr_type = gdal.GDT_Int16
             nullvalue = int(self.nullvalue)
+        elif arr.dtype == np.uint8:
+            arr_type = gdal.GDT_Byte
+            nullvalue = int(self.nullvalue)
         else:
             arr_type = gdal.GDT_Int32
             nullvalue = int(self.nullvalue)
@@ -5668,7 +5682,12 @@ class WolfArray(Element_To_Draw, header_wolf):
         else:
             options = ['COMPRESS=LZW']
 
-        out_ds = driver.Create(filename, arr.shape[0], arr.shape[1], 1, arr_type, options=options)
+        out_ds = driver.Create(str(filename), arr.shape[0], arr.shape[1], 1, arr_type, options=options)
+
+        if out_ds is None:
+            logging.error(_('Could not create the file {filename}'))
+            return
+
         out_ds.SetProjection(srs.ExportToWkt())
 
 
@@ -7688,7 +7707,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         if newpath is not None:
             self.filename = newpath
 
-        if self.filename.endswith('.tif'):
+        if self.filename.endswith('.tif') or self.filename.endswith('.tiff'):
             self.export_geotif(EPSG=EPSG)
         elif self.filename.endswith('.npy'):
 

wolfhece/wolf_tiles.py

@@ -44,8 +44,8 @@ class Tiles(Zones):
                  need_for_wx: bool = False,
                  linked_data_dir=None) -> None:
         """
-        filename : le fichier de forme (ShapeFile) de tuilage
-        linked_data_dir : le répertoire des données .tif
+        :param filename: le fichier de forme (ShapeFile) de tuilage
+        :param linked_data_dir: le répertoire des données .tif
         """
         super().__init__(filename, ox, oy, tx, ty, parent, is2D, idx, plotted, mapviewer, need_for_wx)
 

{wolfhece-2.1.104.dist-info → wolfhece-2.1.106.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.1.104
+Version: 2.1.106
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 License: Copyright (c) 2024 University of Liege. All rights reserved.
 Project-URL: Homepage, https://uee.uliege.be/hece

{wolfhece-2.1.104.dist-info → wolfhece-2.1.106.dist-info}/RECORD

@@ -7,16 +7,16 @@ wolfhece/ManageParams.py,sha256=EeuUI5Vvh9ixCvYf8YShMC1s1Yacc7OxOCN7q81gqiQ,517
 wolfhece/Model1D.py,sha256=SI4oNF_J3MdjiWZoizS8kuRXLMVyymX9dYfYJNVCQVI,476989
 wolfhece/PyConfig.py,sha256=Bb1T8qjgKMChadJYDrHO9uo6CwItiAXScZpYkDXqZF8,11387
 wolfhece/PyCrosssections.py,sha256=FnmM9DWY_SAF2EDH9Gu2PojXNtSTRF4-aYQuAAJXBh4,112771
-wolfhece/PyDraw.py,sha256=p1lxn2ScM3f5QI97r80XDg4pgWSc6T-craaPVPfcX2Y,476586
-wolfhece/PyGui.py,sha256=jyeYF7srKH3HLZQGQIqcRW3u308KUDA-oLwzX-jkDzQ,143843
+wolfhece/PyDraw.py,sha256=pSNMh5KuYXgw4CMA0b5tbGni2QfEc2V2IRVmPMz4ntM,480761
+wolfhece/PyGui.py,sha256=pD_t3leVt8U9tzFnSMGsF-Ds4m0qPwLb_Tc8fQT34GQ,144147
 wolfhece/PyGuiHydrology.py,sha256=f60E8K9eGTnRq5RDF6yvt-ahf2AYegwQ9t25zZ2Mk1A,14946
 wolfhece/PyHydrographs.py,sha256=jwtSNMMACwarxrtN1UeQYth99UNrhwPx1IGgUwcooHA,3774
 wolfhece/PyPalette.py,sha256=81n1P-olOe4wElTLv-miSDhqvJU_RHcxgfpHt794dSw,31436
 wolfhece/PyParams.py,sha256=GRp1zZDUJIjs8PtjwScDdov-E9orr1JWOntDazN5AOw,98577
 wolfhece/PyPictures.py,sha256=m1kY0saW6Y9Q0bDCo47lW6XxDkBrbQG-Fd8uVn8G5ic,2514
 wolfhece/PyTranslate.py,sha256=4appkmNeHHZLFmUtaA_k5_5QL-5ymxnbVN4R2OblmtE,622
-wolfhece/PyVertex.py,sha256=3-1zV8-U8bcf9wUL0mJao54Sf3Ew-wmzxhRWUajnGXM,42210
-wolfhece/PyVertexvectors.py,sha256=bwXWtZ9qjrrf94G8n_Ne5qETExB9p4oUR6GDDuCBVH0,253864
+wolfhece/PyVertex.py,sha256=0TATf_Se6E7_P-kR1_DMEzRw_zy8-5cGFnc3yAod7yQ,44754
+wolfhece/PyVertexvectors.py,sha256=F2ZtinpWk1ms7e-lDG_9WzD3waLbkVTKXTD5k6BhMpw,258966
 wolfhece/PyWMS.py,sha256=fyyzm2HFwq8aRwVYHKiBatcZOeKnFi6DWhv4nfscySQ,4602
 wolfhece/RatingCurve.py,sha256=bUjIrQjvIjkD4V-z8bZmA6pe1ILtYNM0-3fT6YUY1RU,22498
 wolfhece/RatingCurveData.py,sha256=5UvnIm89BwqjnEbLCcY3CA8WoFd_xHJbooNy62fX5iY,57660
@@ -32,6 +32,7 @@ wolfhece/drawing_obj.py,sha256=7vY04B6r08nurTTFmBXHyR5tVIF1YzAEw_uz4pqTDIw,4233
 wolfhece/flow_SPWMI.py,sha256=XDAelwAY-3rYOR0WKW3fgYJ_r8DU4IP6Y5xULW421tk,20956
 wolfhece/friction_law.py,sha256=MtZJLo-pTj3-Fw-w12z1LSgSIDrH-JGR0iD9wer_fpQ,5498
 wolfhece/gpuview.py,sha256=Jql8pLZ0PpvZ_ScT-U4jsXANZ9j4-m_RWhsLA2HISuQ,24544
+wolfhece/images_tiles.py,sha256=npR3IJTVEsmgNQP0opVD8g40sBruxLNdmq29A90cVUY,2929
 wolfhece/import_ascfiles.py,sha256=6Zl8qBR9c6VtyziookQ8YE9KC0GtW_J9WFt5ubyGp-s,4465
 wolfhece/ins.py,sha256=uUeLMS1n3GPnfJhxl0Z2l-UXpmPUgthuwct282OOEzk,36184
 wolfhece/irm_qdf.py,sha256=KyrIk0Gu50Q702EWxRpwKTWI2KGjtHA1l8CL-Y469O0,26394
@@ -51,10 +52,10 @@ wolfhece/pywalous.py,sha256=mWB7UxlYMIbPxNUDlONQEjcOOy9VSaRU9aYWZ5IFLu8,19164
 wolfhece/rain_SPWMI.py,sha256=qCfcmF7LajloOaCwnTrrSMzyME03YyilmRUOqrPrv3U,13846
 wolfhece/textpillow.py,sha256=map7HsGYML_o5NHRdFg2s_TVQed_lDnpYNDv27MM0Vw,14130
 wolfhece/tools_mpl.py,sha256=gQ3Jg1iuZiecmMqa5Eli2ZLSkttu68VXL8YmMDBaEYU,564
-wolfhece/wolf_array.py,sha256=ZJ_HvlN2GeuW4lNJ15-HZSOK5iNc_t5eN4YmL3lJYbY,420268
+wolfhece/wolf_array.py,sha256=_UYxRGF8T0rHTv-1uDJ9opHHwBE7bh39XXnhhUgIcKM,421010
 wolfhece/wolf_hist.py,sha256=7jeVrgSkM3ErJO6SRMH_PGzfLjIdw8vTy87kesldggk,3582
 wolfhece/wolf_texture.py,sha256=DS5eobLxrq9ljyebYfpMSQPn8shkUAZZVfqrOKN_QUU,16951
-wolfhece/wolf_tiles.py,sha256=2Ho2I20rHRY81KXxjgLOYISdF4OkJ2d6omeY4shDoGI,10386
+wolfhece/wolf_tiles.py,sha256=VWaWtKlS0RMv_qb5qiPmZdKFJRGgJ3DQEeV_ryfCRMo,10398
 wolfhece/wolf_vrt.py,sha256=NcPZYW4bu06IpqQuiutoAhCvDkeZ3TzOVb8z4wTQ1h8,14319
 wolfhece/wolf_zi_db.py,sha256=baE0niMCzybWGSvPJc5FNxo9ZxsGfU4p-FmfiavFHAs,12967
 wolfhece/wolfresults_2D.py,sha256=Z-SKkipwbChyf9V4777nacKNd5p0aimORjC6evg5zeI,184819
@@ -79,7 +80,7 @@ wolfhece/apps/curvedigitizer.py,sha256=Yps4bcayzbsz0AoVc_dkSk35dEhhn_esIBy1Ziefg
 wolfhece/apps/hydrometry.py,sha256=lhhJsFeb4zGL4bNQTs0co85OQ_6ssL1Oy0OUJCzhfYE,656
 wolfhece/apps/isocurrent.py,sha256=dagmGR8ja9QQ1gwz_8fU-N052hIw-W0mWGVkzLu6C7I,4247
 wolfhece/apps/splashscreen.py,sha256=SrustmIQeXnsiD-92OzjdGhBi-S7c_j-cSvuX4T6rtg,2929
-wolfhece/apps/version.py,sha256=n7akH_alRd4UzgK20bebXm0Lqdk8wOrmsDS7aC8QH_E,389
+wolfhece/apps/version.py,sha256=U-1Ed3Iyh77BiyLsxRW_EJiRSbsCERPs30JqPCz2o6s,389
 wolfhece/apps/wolf.py,sha256=j_CgvsL8rwixbVvVD5Z0s7m7cHZ86gmFLojKGuetMls,729
 wolfhece/apps/wolf2D.py,sha256=4z_OPQ3IgaLtjexjMKX9ppvqEYyjFLt1hcfFABy3-jU,703
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -153,7 +154,7 @@ wolfhece/lagrangian/particles.py,sha256=S52_-3rzgVhift6l4Gznvsf_RTggzvNaD1dPvQUr
 wolfhece/lagrangian/velocity_field.py,sha256=oGVjNm98gEpawreFIrC1lDyC5bEhkk2CsyYAlF1Kq50,10574
 wolfhece/lazviewer/__init__.py,sha256=lz60EpQOBZ-zjvYzff6Y11jzAmC7mjOaxRYAfoqizQs,473
 wolfhece/lazviewer/_add_path.py,sha256=GDwPnzHuGRXGriDNcu1SQ6HetFDGIApeAQZEzYArGvI,605
-wolfhece/lazviewer/laz_viewer.py,sha256=zuXMSh50HZGcduD5dWsrxrNu9qcxg-NfQr6Rg5sKxO8,42746
+wolfhece/lazviewer/laz_viewer.py,sha256=woY6BTu6_Qomx_UsVxHXPuD8j-r9CemM0pJ-H9OMNU8,43244
 wolfhece/lazviewer/libs/Qt5Core.dll,sha256=sTJ_ctYFY9KHMNytF-lzH_078zIvnKTjN-71FDkOWPw,4924928
 wolfhece/lazviewer/libs/Qt5Gui.dll,sha256=07BeaOeYByraGkKYeDiSDYLawHM8tyd55pVJlKbZ4Y0,5436416
 wolfhece/lazviewer/libs/Qt5Network.dll,sha256=U-9FiLE9LUKru8r8EQxTnwwlMpwS8JzUtenhkKTCox0,1038336
@@ -292,8 +293,8 @@ wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=8PlMYrb_8jI8h9F0_EagpM
 wolfhece/ui/wolf_times_selection_comparison_models.py,sha256=ORy7fz4dcp691qKzaOZHrRLZ0uXNhL-LIHxmpDGL6BI,5007
 wolfhece/wintab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/wintab/wintab.py,sha256=8A-JNONV6ujgsgG3lM5Uw-pVgglPATwKs86oBzzljoc,7179
-wolfhece-2.1.104.dist-info/METADATA,sha256=ccImhLoF0Q0GeJKNyWSqPXzau2pP4yJQNfwWdsJO4Z4,2618
-wolfhece-2.1.104.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-wolfhece-2.1.104.dist-info/entry_points.txt,sha256=ZZ-aSfbpdcmo-wo84lRFzBN7LaSnD1XRGSaAKVX-Gpc,522
-wolfhece-2.1.104.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.1.104.dist-info/RECORD,,
+wolfhece-2.1.106.dist-info/METADATA,sha256=zF3O-oD6-npmbSexAZwCntdKPYpjKbK8GvjIoufqoU8,2618
+wolfhece-2.1.106.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+wolfhece-2.1.106.dist-info/entry_points.txt,sha256=ZZ-aSfbpdcmo-wo84lRFzBN7LaSnD1XRGSaAKVX-Gpc,522
+wolfhece-2.1.106.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.1.106.dist-info/RECORD,,