wolfhece 2.2.8__py3-none-any.whl → 2.2.9__py3-none-any.whl

wolfhece/PyDraw.py

@@ -4305,7 +4305,7 @@ class WolfMapViewer(wx.Frame):
         if self.active_cloud is not None and self.active_array is not None:
 
             keyvalue='z'
-            if self.active_cloud.header:
+            if self.active_cloud.has_values:
                 choices = list(self.active_cloud.myvertices[0].keys())
                 dlg = wx.SingleChoiceDialog(None, "Pick the value to interpolate", "Choices", choices)
                 ret = dlg.ShowModal()

wolfhece/PyVertex.py

@@ -549,7 +549,7 @@ class cloud_vertices(Element_To_Draw):
 
         self.loaded = False
 
-        self.header = header
+        self._header = header
 
         self.gllist = 0
         self.forceupdategl = False
@@ -570,7 +570,7 @@ class cloud_vertices(Element_To_Draw):
                 if Path(fname).suffix.lower() == '.dxf':
                     self.import_from_dxf(self.filename, imported_elts=dxf_imported_elts)
                 elif Path(fname).suffix.lower() == '.shp':
-                    self.import_shapefile(self.filename, bbox=bbox)
+                    self.import_from_shapefile(self.filename, bbox=bbox)
                 else:
                     self.readfile(self.filename, header)
 
@@ -586,24 +586,53 @@ class cloud_vertices(Element_To_Draw):
         xyz = self.get_xyz()
         self.mytree = KDTree(xyz)
 
-    def find_nearest(self, xy:np.ndarray, nb:int =1):
+    def find_nearest(self, xyz:np.ndarray | list, nb:int =1):
         """
-        Find nearest neighbors from Scipy KDTree structure based on a copy of the vertices
+        Find nearest neighbors from Scipy KDTree structure based on a copy of the vertices.
 
-        Return :
-            - list of distances
-            - list of "Wolfvertex"
-            - list of elements stored in self.myvertices
+        See : https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.KDTree.query.html
+
+        :param xyz: coordinates to find nearest neighbors -- shape (n, m) - where m is the number of coordinates (2 or 3)
+        :param nb: number of nearest neighbors to find
+        :return: list of distances, list of "Wolfvertex", list of elements stored in self.myvertices - or list of lists if xyz is a list of coordinates
         """
 
-        keys = self.myvertices.keys()
-        if self.mytree is None:
-            self.create_kdtree()
+        if isinstance(xyz, list):
+            if len(xyz) > 0:
+                if isinstance(xyz[0], float | int):
+                    logging.warning(_('xyz is a list of floats -- converting to a list of lists'))
+                    xyz = [xyz]
+
+            xyz = np.array(xyz)
+
+        try:
+            keys = list(self.myvertices.keys())
+            if self.mytree is None:
+                self.create_kdtree()
+
+            if xyz.shape[1] != self.mytree.m:
+                logging.error(_('Error in find_nearest -- xyz must be a list or 2D array with {} columns').format(self.mytree.m))
+                return None, None, None
+
+            dist, ii = self.mytree.query(xyz, k=nb)
 
-        dist, ii = self.mytree.query(xy, k=nb)
-        return dist, [self.myvertices[keys[curi]]['vertex'] for curi in ii], [self.myvertices[keys[curi]] for curi in ii]
+            if xyz.shape[0] == 1:
+                if nb == 1:
+                    return dist[0], self.myvertices[keys[ii[0]]]['vertex'], self.myvertices[keys[ii[0]]]
+                else:
+                    return dist[0], [self.myvertices[keys[curi]]['vertex'] for curi in ii[0]], [self.myvertices[keys[curi]] for curi in ii[0]]
+            else:
+                if nb == 1:
+                    return dist, [self.myvertices[keys[curi]]['vertex'] for curi in ii], [self.myvertices[keys[curi]] for curi in ii]
+                else:
+                    return dist, [[self.myvertices[keys[curi]]['vertex'] for curi in curii] for curii in ii], [[self.myvertices[keys[curi]] for curi in curii] for curii in ii]
 
-    def init_from_nparray(self, array):
+        except Exception as e:
+            logging.error(_('Error in find_nearest -- {}').format(e))
+            logging.error(_('Check your input data -- it must be a list or 2D array with 3 columns'))
+            return None, None, None
+
+    def init_from_nparray(self, array:np.ndarray):
         """
         Fill-in from nparray -- shape (n,3)
         """
@@ -624,7 +653,7 @@ class cloud_vertices(Element_To_Draw):
 
         self.plotted = True
         if not self.loaded:
-            self.readfile(self.filename, self.header)
+            self.readfile(self.filename, self._header)
             self.loaded = True
 
     def uncheck_plot(self, unload=True):
@@ -703,11 +732,11 @@ class cloud_vertices(Element_To_Draw):
                 nbcols = len(curval)
 
             if nbcols < 2:
-                print('Not enough values on one line -- Retry !!')
+                logging.warning(_('Not enough values on one line -- Retry !!'))
                 return
             elif nbcols > 3:
                 if headers is None:
-                    print('No headers -- Retry !!')
+                    logging.warning(_('No headers -- Retry !!'))
                     return
                 else:
                     if headers[2].lower() == 'z':
@@ -847,7 +876,7 @@ class cloud_vertices(Element_To_Draw):
 
         return k
 
-    def import_shapefile(self, fn:str='', targetcolumn:str = 'X1_Y1_Z1', bbox:Polygon = None):
+    def import_from_shapefile(self, fn:str='', targetcolumn:str = 'X1_Y1_Z1', bbox:Polygon = None):
         """
         Importing Shapefile using geopandas library
 
@@ -1235,7 +1264,7 @@ class cloud_vertices(Element_To_Draw):
 
         """
 
-        if self.header:
+        if self._header:
             if key=='vertex':
                 xyz = [[curvert['vertex'].x, curvert['vertex'].y, curvert['vertex'].z]  for curvert in self.myvertices.values()]
             else:
@@ -1244,6 +1273,63 @@ class cloud_vertices(Element_To_Draw):
             xyz = [[curvert['vertex'].x, curvert['vertex'].y, curvert['vertex'].z]  for curvert in self.myvertices.values()]
         return np.array(xyz)
 
+    @property
+    def has_values(self) -> bool:
+        """
+        Check if the cloud has values (other than X,Y,Z)
+        """
+
+        if self._header:
+            return len(self.myvertices[0]) > 1
+        else:
+            return False
+
+    @property
+    def header(self) -> list[str]:
+        """
+        Return the headers of the cloud
+        """
+
+        if self._header:
+            return list(self.myvertices[0].keys())
+        else:
+            return []
+
+    def add_values_by_id_list(self, id:str, values:list[float]):
+        """
+        Add values to the cloud
+
+        :param id: use as key for the values
+        :param values: list of values to be added - must be the same length as number of vertices
+
+        """
+
+        if len(values) != len(self.myvertices):
+            logging.warning(_('Number of values does not match the number of vertices -- Retry !!'))
+            logging.info(_(('Number of vertices : ')+str(len(self.myvertices))))
+            return
+
+        for item, val in zip(self.myvertices.values(), values):
+            item[id] = val
+
+        self._header = True
+
+    @property
+    def xyz(self) -> np.ndarray:
+        """
+        Alias for get_xyz method
+        """
+
+        return self.get_xyz(key='vertex')
+
+    @property
+    def nbvertices(self) -> int:
+        """
+        Number of vertices in the cloud
+        """
+
+        return len(self.myvertices)
+
     def interp_on_array(self, myarray, key:str='vertex', method:Literal['linear', 'nearest', 'cubic'] = 'linear'):
         """
         Interpolation of the cloud on a 2D array

wolfhece/PyVertexvectors.py

@@ -53,6 +53,9 @@ from .matplotlib_fig import Matplotlib_Figure as MplFig
 from .PyPalette import wolfpalette
 
 class Triangulation(Element_To_Draw):
+    """ Triangulation based on a listof vertices
+    and triangles enumerated by their vertex indices """
+
     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)
 
@@ -74,20 +77,24 @@ class Triangulation(Element_To_Draw):
             self.filename=fn
             self.read(fn)
         else:
-            self.valid_format()
+            self.validate_format()
         pass
 
-    def valid_format(self):
+    def validate_format(self):
+        """ Force the format of the data """
+
         if isinstance(self.pts,list):
             self.pts = np.asarray(self.pts)
         if isinstance(self.tri,list):
             self.tri = np.asarray(self.tri)
 
     def as_polydata(self) -> pv.PolyData:
+        """ Convert the triangulation to a PyVista PolyData object """
 
         return pv.PolyData(np.asarray(self.pts),np.column_stack([[3]*self.nb_tri,self.tri]), self.nb_tri)
 
-    def from_polydata(self,poly:pv.PolyData):
+    def from_polydata(self, poly:pv.PolyData):
+        """ Convert a PyVista PolyData object to the triangulation format """
 
         self.pts = np.asarray(poly.points.copy())
         self.tri = np.asarray(poly.faces.reshape([int(len(poly.faces)/4),4])[:,1:4])
@@ -95,7 +102,8 @@ class Triangulation(Element_To_Draw):
         self.nb_pts = len(self.pts)
         self.nb_tri = len(self.tri)
 
-    def clip_surface(self,other,invert=True,subdivide=0):
+    def clip_surface(self, other:"Triangulation", invert=True, subdivide=0):
+        """ Clip the triangulation with another one """
 
         if subdivide==0:
             mypoly = self.as_polydata()
@@ -104,14 +112,12 @@ class Triangulation(Element_To_Draw):
             mypoly = self.as_polydata().subdivide(subdivide)
             mycrop = other.as_polydata().subdivide(subdivide)
 
-        res = mypoly.clip_surface(mycrop,invert=invert)
+        res = mypoly.clip_surface(mycrop, invert=invert)
 
         if len(res.faces)>0:
             self.from_polydata(res)
-        else:
-            return None
 
-    def get_mask(self,eps=1e-10):
+    def get_mask(self, eps:float= 1e-10):
         """
         Teste si la surface de tous les triangles est positive
 
@@ -122,7 +128,7 @@ class Triangulation(Element_To_Draw):
             v1 = [self.pts[curtri[1]][:2] - self.pts[curtri[0]][:2] for curtri in self.tri]
             v2 = [self.pts[curtri[2]][:2] - self.pts[curtri[0]][:2] for curtri in self.tri]
             self.areas = np.cross(v2,v1,)/2
-            return self.areas<=eps
+            return self.areas <= eps
 
             # invalid_tri = np.sort(np.where(self.areas<=eps)[0])
             # for curinv in invalid_tri[::-1]:
@@ -131,8 +137,11 @@ class Triangulation(Element_To_Draw):
             # self.nb_tri = len(self.tri)
 
     def import_from_gltf(self, fn=''):
+        """ Import a GLTF file and convert it to the triangulation format """
 
-        if fn =='':
+        wx_exists = wx.GetApp() is not None
+
+        if fn =='' and wx_exists:
             dlg=wx.FileDialog(None,_('Choose filename'),wildcard='binary gltf2 (*.glb)|*.glb|gltf2 (*.gltf)|*.gltf|All (*.*)|*.*',style=wx.FD_OPEN)
             ret=dlg.ShowModal()
             if ret==wx.ID_CANCEL:
@@ -141,6 +150,8 @@ class Triangulation(Element_To_Draw):
 
             fn=dlg.GetPath()
             dlg.Destroy()
+        else:
+            fn = str(fn)
 
         gltf = pygltflib.GLTF2().load(fn)
 
@@ -216,6 +227,7 @@ class Triangulation(Element_To_Draw):
         self.nb_tri = len(self.tri)
 
     def export_to_gltf(self,fn=''):
+        """ Export the triangulation to a GLTF file """
 
         #on force les types de variables
         triangles = np.asarray(self.tri).astype(np.uint32)
@@ -302,7 +314,7 @@ class Triangulation(Element_To_Draw):
             return
 
         if fn!='':
-            self.filename=fn
+            self.filename = fn
 
         triangles = np.asarray(self.tri).astype(np.uint32)
         points = np.asarray(self.pts) #.astype(np.float64)
@@ -343,11 +355,13 @@ class Triangulation(Element_To_Draw):
                 buf = np.frombuffer(f.read(4 * self.nb_tri * 3), dtype=np.uint32)
                 self.tri = np.array(buf.copy(), dtype=np.uint32).reshape([self.nb_tri,3]).astype(np.int32)
 
-        self.valid_format()
+        self.validate_format()
         self.find_minmax(True)
         self.reset_plot()
 
     def reset_plot(self):
+        """ Reset the OpenGL plot """
+
         try:
             if self.id_list!=-99999:
                 glDeleteLists(self.id_list)
@@ -357,6 +371,7 @@ class Triangulation(Element_To_Draw):
         self.id_list = -99999
 
     def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None ):
+        """ Plot the triangulation in OpenGL """
 
         if self.id_list == -99999:
             try:
@@ -387,7 +402,25 @@ class Triangulation(Element_To_Draw):
         else:
             glCallList(self.id_list)
 
+    def plot_matplotlib(self, ax:Axes, color='black', alpha=1., lw=1.5, **kwargs):
+        """ Plot the triangulation in Matplotlib
+        """
+
+        if self.nb_tri>0:
+            for curtri in self.tri:
+                x = [self.pts[curtri[0]][0], self.pts[curtri[1]][0], self.pts[curtri[2]][0], self.pts[curtri[0]][0]]
+                y = [self.pts[curtri[0]][1], self.pts[curtri[1]][1], self.pts[curtri[2]][1], self.pts[curtri[0]][1]]
+                ax.plot(x, y, color=color, alpha=alpha, lw=lw, **kwargs)
+        else:
+            logging.warning('No triangles to plot')
+
+
     def find_minmax(self,force):
+        """ Find the min and max of the triangulation
+
+        :param force: force the min and max to be calculated
+        """
+
         if force:
             if self.nb_pts>0:
                 self.xmin=np.min(self.pts[:,0])
@@ -396,6 +429,8 @@ class Triangulation(Element_To_Draw):
                 self.ymax=np.max(self.pts[:,1])
 
     def import_dxf(self,fn):
+        """ Import a DXF file and convert it to the triangulation format """
+
         import ezdxf
 
         if not path.exists(fn):
@@ -431,7 +466,7 @@ class Triangulation(Element_To_Draw):
         self.pts = xyz_u
         self.nb_pts = len(self.pts)
         self.nb_tri = len(self.tri)
-        self.valid_format()
+        self.validate_format()
 
     def set_cache(self):
         """ Set the cache for the vertices """
@@ -4038,7 +4073,7 @@ class zone:
         self.add_vector(mypl,0)
         self.add_vector(mypr,2)
 
-    def createmultibin(self, nb=None, nb2=0) -> Triangulation:
+    def create_multibin(self, nb:int = None, nb2:int = 0) -> Triangulation:
         """
         Création d'une triangulation sur base des vecteurs
         Tient compte de l'ordre
@@ -4075,7 +4110,11 @@ class zone:
             nb=int(dlg.GetValue())
             dlg.Destroy()
         else:
-            logging.warning( _('Bad parameter nb'))
+            try:
+                nb=int(nb)
+            except:
+                logging.warning( _('Bad parameter nb'))
+                return None
 
         # redécoupage des polylines
         s = np.linspace(0.,1.,num=nb,endpoint=True)
@@ -4095,10 +4134,16 @@ class zone:
             ret=dlg.ShowModal()
             if ret==wx.ID_CANCEL:
                 dlg.Destroy()
-                return
+                return None
 
             nb2=int(dlg.GetValue())
             dlg.Destroy()
+        else:
+            try:
+                nb2=int(nb2)
+            except:
+                logging.warning( _('Bad parameter nb2'))
+                return None
 
         if nb2>0:
             finalls = []
@@ -4187,9 +4232,12 @@ class zone:
 
         return interp
 
-    def create_constrainedDelaunay(self, nb=None) -> Triangulation:
+    def create_constrainedDelaunay(self, nb:int = None) -> Triangulation:
         """
-        Création d'une triangulation Delaunay contrainte sur base des vecteurs
+        Création d'une triangulation Delaunay contrainte sur base des vecteurs de la zone.
+
+        Il est nécessaire de définir au moins un polygone définissant la zone de triangulation.
+        Les autres vecteurs seront utilisés comme contraintes de triangulation.
 
         Utilisation de la librairie "triangle" (https://www.cs.cmu.edu/~quake/triangle.delaunay.html)
 
@@ -4223,14 +4271,18 @@ class zone:
             nb=int(dlg.GetValue())
             dlg.Destroy()
         else:
-            logging.warning( _('Bad parameter nb'))
+            try:
+                nb=int(nb)
+            except:
+                logging.warning( _('Bad parameter nb'))
+                return None
 
         if nb==0:
             # no decimation
             newls = myls
         else:
             # redécoupage des polylines
-            s = np.linspace(0.,1.,num=nb,endpoint=True)
+            s = np.linspace(0., 1., num=nb, endpoint=True)
 
             newls = [LineString([curls.interpolate(curs,True) for curs in s]) for curls in myls if curls.length>0.]
 
@@ -7690,7 +7742,7 @@ class Zones(wx.Frame, Element_To_Draw):
                 dlg.Destroy()
                 return
 
-            mytri = myzone.createmultibin()
+            mytri = myzone.create_multibin()
 
             self.mapviewer.add_object('triangulation',newobj=mytri)
             self.mapviewer.Refresh()

wolfhece/apps/version.py

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