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

wolfhece/PyDraw.py

@@ -2008,6 +2008,8 @@ class WolfMapViewer(wx.Frame):
         self.treewidth = treewidth
         super(WolfMapViewer, self).__init__(wxparent, title=title, size=(w + self.treewidth, h))
 
+        self._tmp_vector_distance = None  # distance computation the vector
+
         self._wxlogging = wxlogging
         self.action = None  # Action à entreprendre
         self.update_absolute_minmax = False  # Force la MAJ de la palette
@@ -4086,7 +4088,7 @@ class WolfMapViewer(wx.Frame):
             if ret == wx.ID_NO:
                 return
 
-            with wx.lib.busy.BusyInfo(_('Updating 2D model')):
+            with wx.BusyInfo(_('Updating 2D model')):
                 wait = wx.BusyCursor()
 
                 sux,suy,cont,interior = self.active_array.suxsuy_contour(self.wolfparent.filenamegen,True)
@@ -4305,7 +4307,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()
@@ -5734,12 +5736,12 @@ class WolfMapViewer(wx.Frame):
                         fnpos = self.link_params['gltf pos']
                         break
 
-        with wx.lib.busy.BusyInfo(_('Importing gltf/glb')):
+        with wx.BusyInfo(_('Importing gltf/glb')):
             wait = wx.BusyCursor()
             sourcenew.import_from_gltf(fn, fnpos, 'scipy')
             del wait
 
-        with wx.lib.busy.BusyInfo(_('Update plots')):
+        with wx.BusyInfo(_('Update plots')):
             # Création du différentiel -- Les opérateurs mathématiques sont surchargés
             diff.array = (sourcenew - source).array
             grad.array = sourcenew.get_gradient_norm().array
@@ -8986,7 +8988,7 @@ class WolfMapViewer(wx.Frame):
             fn = dlg.GetPath()
             dlg.Destroy()
 
-            with wx.lib.busy.BusyInfo(_('Export to gltf/glb')):
+            with wx.BusyInfo(_('Export to gltf/glb')):
                 wait = wx.BusyCursor()
                 curarray.export_to_gltf(mybounds, fn)
                 del wait
@@ -9037,7 +9039,7 @@ class WolfMapViewer(wx.Frame):
             method = dlg.GetStringSelection()
             dlg.Destroy()
 
-            with wx.lib.busy.BusyInfo(_('Importing gltf/glb')):
+            with wx.BusyInfo(_('Importing gltf/glb')):
                 wait = wx.BusyCursor()
                 try:
                     curarray.import_from_gltf(fn, fnpos, method)
@@ -9199,7 +9201,7 @@ class WolfMapViewer(wx.Frame):
             dlg.Destroy()
             return
 
-        with wx.lib.busy.BusyInfo(_('Loading masks')):
+        with wx.BusyInfo(_('Loading masks')):
             wait = wx.BusyCursor()
             curarray:WolfArray
             for curarray in self.myarrays:
@@ -9830,7 +9832,7 @@ class WolfMapViewer(wx.Frame):
                     testobj.read_txt_header()
 
                     if testobj.wolftype in WOLF_ARRAY_MB:
-                        # with wx.lib.busy.BusyInfo(_('Importing array')):
+                        # with wx.BusyInfo(_('Importing array')):
                         #     wait = wx.BusyCursor()
                         #     newobj = WolfArrayMB(filename, mapviewer=self)
                         #     del wait
@@ -9839,7 +9841,7 @@ class WolfMapViewer(wx.Frame):
                         if which.lower() == 'array_crop':
                             newobj = WolfArray(filename, mapviewer=self, crop='newcrop')
                         else:
-                            # with wx.lib.busy.BusyInfo(_('Importing array')):
+                            # with wx.BusyInfo(_('Importing array')):
                             #     wait = wx.BusyCursor()
                             #     newobj = WolfArray(filename, mapviewer=self)
                             #     del wait
@@ -9945,7 +9947,7 @@ class WolfMapViewer(wx.Frame):
             curtree = self.myitemsvector
 
             if newobj is None:
-                with wx.lib.busy.BusyInfo(_('Importing files')):
+                with wx.BusyInfo(_('Importing files')):
                     wait = wx.BusyCursor()
                     newobj = Bridges(filename, mapviewer=self)
                     del wait
@@ -9961,7 +9963,7 @@ class WolfMapViewer(wx.Frame):
             curtree = self.myitemsvector
 
             if newobj is None:
-                with wx.lib.busy.BusyInfo(_('Importing files')):
+                with wx.BusyInfo(_('Importing files')):
                     wait = wx.BusyCursor()
                     newobj = Weirs(filename, mapviewer=self)
                     del wait
@@ -9996,7 +9998,7 @@ class WolfMapViewer(wx.Frame):
                         dirname_comp = file.GetPath()
                         file.Destroy()
 
-                with wx.lib.busy.BusyInfo(_('Importing files')):
+                with wx.BusyInfo(_('Importing files')):
                     wait = wx.BusyCursor()
                     newobj = Tiles(filename, parent=self, linked_data_dir=dirname, mapviewer=self)
                     del wait
@@ -10152,7 +10154,7 @@ class WolfMapViewer(wx.Frame):
             curtree = self.myitemsres2d
 
             if newobj is None:
-                with wx.lib.busy.BusyInfo(_('Importing 2D model')):
+                with wx.BusyInfo(_('Importing 2D model')):
                     wait = wx.BusyCursor()
                     newobj = Wolfresults_2D(filename, mapviewer=self)
                     del wait
@@ -10168,7 +10170,7 @@ class WolfMapViewer(wx.Frame):
             curtree = self.myitemsres2d
 
             if newobj is None:
-                with wx.lib.busy.BusyInfo(_('Importing 2D GPU model')):
+                with wx.BusyInfo(_('Importing 2D GPU model')):
                     wait = wx.BusyCursor()
                     newobj = wolfres2DGPU(filename, mapviewer=self)
                     del wait
@@ -10183,7 +10185,7 @@ class WolfMapViewer(wx.Frame):
             curdict = self.myvectors
             curtree = self.myitemsvector
             if newobj is None:
-                with wx.lib.busy.BusyInfo(_('Importing file')):
+                with wx.BusyInfo(_('Importing file')):
                     wait = wx.BusyCursor()
                     newobj = Zones(filename, parent=self)
                     del wait
@@ -10220,7 +10222,7 @@ class WolfMapViewer(wx.Frame):
                         if ret == wx.ID_OK:
                             dirlaz = dlg.GetPath()
 
-                with wx.lib.busy.BusyInfo(_('Importing cross sections')):
+                with wx.BusyInfo(_('Importing cross sections')):
                     wait = wx.BusyCursor()
                     if curfilter == 1:  # txt 2022
                         newobj = crosssections(filename, format='2022', dirlaz=dirlaz, mapviewer=self)
@@ -10346,7 +10348,7 @@ class WolfMapViewer(wx.Frame):
             curdict = self.mytri
             curtree = self.myitemstri
             if newobj is None:
-                with wx.lib.busy.BusyInfo(_('Importing triangulation')):
+                with wx.BusyInfo(_('Importing triangulation')):
                     wait = wx.BusyCursor()
                     newobj = Triangulation(filename, mapviewer=self)
                     del wait
@@ -11584,6 +11586,11 @@ class WolfMapViewer(wx.Frame):
 
             self.rightdown = (x, y)
 
+        elif self.action == 'distance along vector':
+
+            # add a vertex to the vector
+            self._tmp_vector_distance.add_vertex(wolfvertex(x, y))
+
         elif self.action == 'move triangles':
 
             if self.active_tri is None:
@@ -12342,6 +12349,39 @@ class WolfMapViewer(wx.Frame):
                                  type = Type_Param.String,
                                  comment = '')
 
+        if self._tmp_vector_distance is not None:
+            curgroup = _('Temporary vector')
+            self.mytooltip.myparams[curgroup] = {}
+            curpar = _('Length [m]')
+            self._tmp_vector_distance.update_lengths()
+            self.mytooltip.add_param(groupname = curgroup,
+                                        name = curpar,
+                                        value = '{:3f}'.format(self._tmp_vector_distance.length2D),
+                                        type = Type_Param.Float,
+                                        comment = '')
+
+            if self._tmp_vector_distance.nbvertices > 4:
+                _polygon = self._tmp_vector_distance.asshapely_pol()
+                _area = _polygon.area
+                curpar = _('Area [m2]')
+                self.mytooltip.add_param(groupname = curgroup,
+                                            name = curpar,
+                                            value = '{:3f}'.format(_area),
+                                            type = Type_Param.Float,
+                                            comment = '')
+                curpar = _('Area [ha]')
+                self.mytooltip.add_param(groupname = curgroup,
+                                            name = curpar,
+                                            value = '{:3f}'.format(_area / 10000.),
+                                            type = Type_Param.Float,
+                                            comment = '')
+                curpar = _('Area [km2]')
+                self.mytooltip.add_param(groupname = curgroup,
+                                            name = curpar,
+                                            value = '{:3f}'.format(_area / 1e6),
+                                            type = Type_Param.Float,
+                                            comment = '')
+
         for locarray in self.myres2D:
             locarray:Wolfresults_2D
             curgroup = locarray.idx
@@ -12735,10 +12775,10 @@ class WolfMapViewer(wx.Frame):
 
                     self.active_vertex.limit2bounds(self.active_vector.mylimits)
 
-            if self.action == 'dynamic parallel':
+            elif self.action == 'dynamic parallel':
                 self.active_zone.parallel_active(self.dynapar_dist)
 
-            if self.action == 'move vector':
+            elif self.action == 'move vector':
                 if self.active_vector is not None:
                     if self.active_vector._move_start is not None:
 
@@ -12753,7 +12793,7 @@ class WolfMapViewer(wx.Frame):
 
                         self.active_vector.move(delta_x, delta_y)
 
-            if self.action == 'move triangles':
+            elif self.action == 'move triangles':
                 if self.active_tri is not None:
                     if self.active_tri._move_start is not None:
 
@@ -12770,18 +12810,18 @@ class WolfMapViewer(wx.Frame):
 
                         self.active_tri.reset_plot()
 
-            if self.action == 'rotate vector':
+            elif self.action == 'rotate vector':
                 if self.active_vector is not None:
                     if self.active_vector._rotation_center is not None:
                         self.active_vector.rotate_xy(x, y)
 
-            if self.action == 'rotate triangles':
+            elif self.action == 'rotate triangles':
                 if self.active_tri is not None:
                     if self.active_tri._rotation_center is not None:
                         self.active_tri.rotate_xy(x, y)
                         self.active_tri.reset_plot()
 
-            if self.action == 'move zone':
+            elif self.action == 'move zone':
                 if self.active_zone is not None:
                     if self.active_zone._move_start is not None:
                         delta_x = x - self.active_zone._move_start[0]
@@ -12795,11 +12835,20 @@ class WolfMapViewer(wx.Frame):
 
                         self.active_zone.move(delta_x, delta_y)
 
-            if self.action == 'rotate zone':
+            elif self.action == 'rotate zone':
                 if self.active_zone is not None:
                     if self.active_zone._rotation_center is not None:
                         self.active_zone.rotate_xy(x, y)
 
+            elif self.action == 'distance along vector':
+                if self._tmp_vector_distance is not None:
+                    self._tmp_vector_distance.myvertices[-1].x = x
+                    self._tmp_vector_distance.myvertices[-1].y = y
+
+                    if self._tmp_vector_distance.nbvertices ==2:
+                        self._tmp_vector_distance.myvertices[0].x = x
+                        self._tmp_vector_distance.myvertices[0].y = y
+
             self.Paint()
 
         # Store the position of the mouse as last known position
@@ -12943,6 +12992,10 @@ class WolfMapViewer(wx.Frame):
                     # we must reset the temporary vector
                     self.active_vector.reset()
 
+            if self.action == 'distance along vector':
+
+                self._tmp_vector_distance = None
+
             elif self.action == 'pick landmap':
 
                 self.end_action(_('End of landmap picking'))
@@ -13172,6 +13225,7 @@ class WolfMapViewer(wx.Frame):
         #     r : reset de la sélection de la matrice courante\n \
         #     R : reset de toutes les sélections de la matrice courante\n \
         #     P : sélection de la section transversale par click souris\n \
+        #     D : calcule de distance le long d'un vecteur temporaire\n \
         #     \n \
         #     RETURN : end current action (cf aussi double clicks droit 'OnRDClick')\n \
         #     DELETE : remove item\n \
@@ -13220,6 +13274,7 @@ class WolfMapViewer(wx.Frame):
                      'ALT+C': _('Drawing : copy canvas to Clipboard as Matplotlib image'),
                      'ALT+SHIFT+C': _('Drawing : copy canvas to Clipboard as Matplotlib image with axes - multiviewers'),
                      'CTRL+ALT+SHIFT+C': _('Drawing : copy canvas to Clipboard as Matplotlib image with axes - all arrays one by one'),
+                     'd or D': _('Drawing : calculate distance along a temporary vector'),
 
                      'CTRL+o': _('Results : increase transparency of the current result'),
                      'CTRL+O': _('Results : decrease transparency of the current result'),
@@ -13326,6 +13381,14 @@ class WolfMapViewer(wx.Frame):
         logging.info(_('ACTION : ') + _(message) if message != '' else _('ACTION : End of action') )
         self.msg_action(1)
 
+    def distance_by_multiple_clicks(self):
+        """ Distance between multiple clicks """
+
+        self.start_action('distance along vector', _('Distance by multiple clicks -- Select the points'))
+        self._tmp_vector_distance = vector()
+        self._tmp_vector_distance.add_vertex([wolfvertex(0., 0.),
+                                              wolfvertex(0., 0.)])
+
     def OnHotKey(self, e: wx.KeyEvent):
         """
         Gestion des touches clavier -- see print_shortcuts for more details
@@ -14001,6 +14064,9 @@ class WolfMapViewer(wx.Frame):
                 if self.active_laz is not None:
                     self.active_laz.add_pose_in_memory()
 
+            elif key == ord('D'):
+                self.distance_by_multiple_clicks()
+
     def paste_values(self,fromarray:WolfArray):
         """ Paste selected values from a WolfArray to the active array """
 
@@ -14309,6 +14375,10 @@ class WolfMapViewer(wx.Frame):
             # Gestion des BC (si actif)
             if self.active_bc is not None:
                 self.active_bc.plot()
+
+            if self._tmp_vector_distance is not None:
+                self._tmp_vector_distance.plot()
+
             # try:
             #     if self.active_bc is not None:
             #         self.active_bc.plot()

wolfhece/PyGui.py

@@ -153,6 +153,7 @@ class GenMapManager(wx.Frame):
         return self._configuration
 
 class MapManager(GenMapManager):
+
     def __init__(self,*args, **kw):
         super().__init__(*args, **kw)
 

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)
+
+            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]
 
-        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]
+        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):
+    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
 
@@ -1010,6 +1039,8 @@ class cloud_vertices(Element_To_Draw):
         Plot OpenGL
 
         Legend is an image texture
+
+        FIXME : to be improved
         """
         if self.get_mapviewer() is None:
             logging.warning(_('No mapviewer available for legend plot'))
@@ -1235,7 +1266,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 +1275,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
@@ -1319,3 +1407,23 @@ class cloud_vertices(Element_To_Draw):
             return newcloud
         else:
             return all_s, all_z
+
+    def plot_matplotlib(self, ax=None, **kwargs):
+        """
+        Plot the cloud using matplotlib
+
+        :param ax: axis to plot on -- if None, a new figure is created
+        :param kwargs: additional arguments for matplotlib
+
+        """
+        import matplotlib.pyplot as plt
+
+        if ax is None:
+            fig, ax = plt.subplots()
+
+        x = [cur['vertex'].x for cur in self.myvertices.values()]
+        y = [cur['vertex'].y for cur in self.myvertices.values()]
+
+        ax.scatter(x, y, **kwargs)
+
+        return fig, ax