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

wolfhece/PyDraw.py

@@ -7974,11 +7974,24 @@ class WolfMapViewer(wx.Frame):
 
                     if ret == wx.ID_YES:
                         loadhead = True
+                    
+                    types = None
 
-                with wx.lib.busy.BusyInfo(_('Importing cloud points')):
-                    wait = wx.BusyCursor()
-                    newobj = cloud_vertices(filename, header=loadhead, mapviewer=self)
-                    del wait
+                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

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):
@@ -3353,6 +3355,105 @@ class zone:
         mytri.find_minmax(True)
 
         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:
         """
@@ -4818,28 +4919,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 +4974,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 +5311,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 +5444,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 +6232,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

wolfhece/apps/version.py

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

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-2.1.104.dist-info → wolfhece-2.1.105.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.1.104
+Version: 2.1.105
 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.105.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=ZlPWb2KNua6uhZFp9-Uq8TPOnksXSr8__Qanctidzns,477115
+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=vnl0a4yy3K4814i0EZRqJsKTryZLT52nqX0RXbMjxks,258906
 wolfhece/PyWMS.py,sha256=fyyzm2HFwq8aRwVYHKiBatcZOeKnFi6DWhv4nfscySQ,4602
 wolfhece/RatingCurve.py,sha256=bUjIrQjvIjkD4V-z8bZmA6pe1ILtYNM0-3fT6YUY1RU,22498
 wolfhece/RatingCurveData.py,sha256=5UvnIm89BwqjnEbLCcY3CA8WoFd_xHJbooNy62fX5iY,57660
@@ -51,7 +51,7 @@ 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
@@ -79,7 +79,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=t4cIWqspnu6lsPYUT6cJplsMKfsss5TlTOmf7GsQ45o,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
@@ -292,8 +292,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.105.dist-info/METADATA,sha256=5jWtyY__Cbebr4RvRW19ufqWB6mnLyqq7cvgtaQwiVA,2618
+wolfhece-2.1.105.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+wolfhece-2.1.105.dist-info/entry_points.txt,sha256=ZZ-aSfbpdcmo-wo84lRFzBN7LaSnD1XRGSaAKVX-Gpc,522
+wolfhece-2.1.105.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.1.105.dist-info/RECORD,,