wolfhece 2.1.85__py3-none-any.whl → 2.1.87__py3-none-any.whl

wolfhece/PyVertexvectors.py

@@ -1749,7 +1749,7 @@ class vector:
         if self.mytree is not None:
             self.mytree.UncheckItem(self.myitem)
 
-        self.parentzone.reset_listogl()
+        self._reset_listogl()
 
     def use(self):
         """
@@ -1760,7 +1760,7 @@ class vector:
             self.mytree.CheckItem(self.myitem)
 
 
-        self.parentzone.reset_listogl()
+        self._reset_listogl()
 
     def fillgrid(self, gridto:CpGrid):
         """
@@ -1820,7 +1820,7 @@ class vector:
         if self.linestring is not None:
             self.prepare_shapely()
 
-        self.parentzone.reset_listogl()
+        self._reset_listogl()
 
     def get_s2d(self):
         """
@@ -1842,11 +1842,14 @@ class vector:
 
         return s3d
 
-    def get_sz(self,cumul=True):
+    def get_sz(self, cumul=True):
         """
-        Calcule et retourne la distance horizontale cumulée ou non de chaque point vis-à-vis du premier point
+        Calcule et retourne la distance horizontale cumulée ou non
+        de chaque point vis-à-vis du premier point
 
         Utile pour le tracé de sections en travers ou des vérifications de position
+
+        :param cumul: si True, retourne la distance cumulée 2D. si False, retourne la distance 2D entre chaque point et le premier.
         """
         z = np.asarray([self.myvertices[i].z for i in range(self.nbvertices)])
 
@@ -1977,6 +1980,9 @@ class vector:
         """
         Création d'un nouveau vecteur sur base du découpage d'un autre et d'un pas spatial à respecter
         Le nouveau vecteur contient tous les points de l'ancien et des nouveaux sur base d'un découpage 3D
+
+        :param ds: pas spatial
+        :param new: si True, le vecteur est ajouté à la zone parente
         """
         newvec = vector(name=self.myname+'_split',parentzone=self.parentzone)
 
@@ -1995,10 +2001,7 @@ class vector:
             curzone=self.parentzone
             if curzone is not None:
                 curzone.add_vector(newvec)
-                try:
-                    curzone.parent.fill_structure()
-                except:
-                    pass
+                curzone._fill_structure()
         else:
             self.myvertices = newvec.myvertices
             self.update_lengths()
@@ -2303,7 +2306,7 @@ class vector:
 
         return fig,ax
 
-    def deepcopy_vector(self, name: str = None, parentzone : str = None):
+    def deepcopy_vector(self, name: str = None, parentzone = None) -> 'vector':
         """
         Return a deep copy of the vector.
         """
@@ -2311,7 +2314,7 @@ class vector:
         if name is None:
             name = self.myname + "_copy"
 
-        if parentzone:
+        if parentzone is not None:
             copied_vector = vector(name=name,parentzone=parentzone)
         else:
             copied_vector = vector(name=name)
@@ -2320,6 +2323,13 @@ class vector:
 
         return copied_vector
 
+    def deepcopy(self, name: str = None, parentzone = None) -> 'vector':
+        """
+        Return a deep copy of the vector.
+        """
+
+        return self.deepcopy_vector(name, parentzone)
+
     def set_legend_to_centroid(self, text:str='', visible:bool=True):
         """
         Positionne la légende au centre du vecteur
@@ -2333,6 +2343,312 @@ class vector:
         self.myprop.legendy = centroid.y
         self.myprop.legendtext = text if text else self.myname
 
+    def set_z(self, new_z:np.ndarray):
+        """ Set the z values of the vertices """
+        self.z = new_z
+
+    @property
+    def z(self):
+        z = np.asarray([curvert.z for curvert in self.myvertices])
+        if self.add_zdatum:
+            z+=self.zdatum
+        return z
+
+    @property
+    def x(self):
+        return np.asarray([curvert.x for curvert in self.myvertices])
+
+    @property
+    def y(self):
+        return np.asarray([curvert.y for curvert in self.myvertices])
+
+    @property
+    def xy(self):
+        return np.asarray([[curvert.x, curvert.y] for curvert in self.myvertices])
+
+    @property
+    def xz(self):
+        return np.asarray([[curvert.x, curvert.z] for curvert in self.myvertices])
+
+    @property
+    def xyz(self):
+        return self.asnparray3d()
+
+    @property
+    def i(self):
+        return np.asarray([curvert.in_use for curvert in self.myvertices])
+
+    @property
+    def xyzi(self):
+        x = self.x
+        y = self.y
+        z = self.z
+        i = self.i
+        return np.column_stack((x,y,z,i))
+
+    @property
+    def xyi(self):
+        return np.asarray([[curvert.x, curvert.y, curvert.in_use] for curvert in self.myvertices])
+
+    @property
+    def sz(self):
+        return self.get_sz()
+
+    @property
+    def s(self):
+        sz = self.get_sz()
+        return sz[0]
+
+    @x.setter
+    def x(self, new_x:np.ndarray | list):
+        """ Set the x values of the vertices """
+
+        if isinstance(new_x, list):
+            new_x = np.array(new_x)
+
+        if len(new_x) != self.nbvertices:
+            logging.warning(_('New x values have not the same length as the number of vertices'))
+            return
+
+        for curvert, newx in zip(self.myvertices, new_x):
+            curvert.x = newx
+
+        self._reset_listogl()
+
+    @y.setter
+    def y(self, new_y:np.ndarray | list):
+        """ Set the y values of the vertices """
+
+        if isinstance(new_y, list):
+            new_y = np.array(new_y)
+
+        if len(new_y) != self.nbvertices:
+            logging.warning(_('New y values have not the same length as the number of vertices'))
+            return
+
+        for curvert, newy in zip(self.myvertices, new_y):
+            curvert.y = newy
+
+        self._reset_listogl()
+
+    @z.setter
+    def z(self, new_z:np.ndarray | float | list):
+        """ Set the z values of the vertices """
+
+        if isinstance(new_z, (int, float)):
+            new_z = np.full(self.nbvertices, new_z, dtype=float)
+
+        if isinstance(new_z, list):
+            new_z = np.array(new_z)
+
+        if len(new_z) != self.nbvertices:
+            logging.warning(_('New z values have not the same length as the number of vertices'))
+            return
+
+        if self.add_zdatum:
+            for curvert, newz in zip(self.myvertices, new_z):
+                curvert.z = newz - self.zdatum
+        else:
+            for curvert, newz in zip(self.myvertices, new_z):
+                curvert.z = newz
+
+        self._reset_listogl()
+
+    @xyz.setter
+    def xyz(self, new_xyz:np.ndarray | list):
+        """ Set the x, y, z values of the vertices """
+
+        if isinstance(new_xyz, list):
+            new_xyz = np.array(new_xyz)
+
+        if len(new_xyz) != self.nbvertices:
+            logging.warning(_('New xyz values have not the same length as the number of vertices'))
+            return
+
+        if self.add_zdatum:
+            for curvert, newxyz in zip(self.myvertices, new_xyz):
+                curvert.x = newxyz[0]
+                curvert.y = newxyz[1]
+                curvert.z = newxyz[2] - self.zdatum
+        else:
+            for curvert, newxyz in zip(self.myvertices, new_xyz):
+                curvert.x = newxyz[0]
+                curvert.y = newxyz[1]
+                curvert.z = newxyz[2]
+
+        self._reset_listogl()
+
+    @xy.setter
+    def xy(self, new_xy:np.ndarray | list):
+        """ Set the x, y values of the vertices """
+
+        if isinstance(new_xy, list):
+            new_xy = np.array(new_xy)
+
+        if len(new_xy) != self.nbvertices:
+            logging.warning(_('New xy values have not the same length as the number of vertices'))
+            return
+
+        for curvert, newxy in zip(self.myvertices, new_xy):
+            curvert.x = newxy[0]
+            curvert.y = newxy[1]
+
+        self._reset_listogl()
+
+    @xz.setter
+    def xz(self, new_xz:np.ndarray | list):
+        """ Set the x, z values of the vertices """
+
+        if isinstance(new_xz, list):
+            new_xz = np.array(new_xz)
+
+        if len(new_xz) != self.nbvertices:
+            logging.warning(_('New xz values have not the same length as the number of vertices'))
+            return
+
+        if self.add_zdatum:
+            for curvert, newxz in zip(self.myvertices, new_xz):
+                curvert.x = newxz[0]
+                curvert.z = newxz[1] - self.zdatum
+        else:
+            for curvert, newxz in zip(self.myvertices, new_xz):
+                curvert.x = newxz[0]
+                curvert.z = newxz[1]
+
+        self._reset_listogl()
+
+    @xyzi.setter
+    def xyzi(self, new_xyzi:np.ndarray | list):
+        """ Set the x, y, z, in_use values of the vertices """
+
+        if isinstance(new_xyzi, list):
+            new_xyzi = np.array(new_xyzi)
+
+        if len(new_xyzi) != self.nbvertices:
+            logging.warning(_('New xyzi values have not the same length as the number of vertices'))
+            return
+
+        for curvert, newxyzi in zip(self.myvertices, new_xyzi):
+            curvert.x = newxyzi[0]
+            curvert.y = newxyzi[1]
+            curvert.z = newxyzi[2] - self.zdatum if self.add_zdatum else newxyzi[2]
+            curvert.in_use = newxyzi[3]
+
+        self._reset_listogl()
+
+    @xyi.setter
+    def xyi(self, new_xyi:np.ndarray | list):
+        """ Set the x, y, in_use values of the vertices """
+
+        if isinstance(new_xyi, list):
+            new_xyi = np.array(new_xyi)
+
+        if len(new_xyi) != self.nbvertices:
+            logging.warning(_('New xyi values have not the same length as the number of vertices'))
+            return
+
+        for curvert, newxyi in zip(self.myvertices, new_xyi):
+            curvert.x = newxyi[0]
+            curvert.y = newxyi[1]
+            curvert.in_use = newxyi[2]
+
+        self._reset_listogl()
+
+    @i.setter
+    def i(self, new_i:np.ndarray | list):
+        """ Set the in_use values of the vertices """
+
+        if isinstance(new_i, list):
+            new_i = np.array(new_i)
+
+        if len(new_i) != self.nbvertices:
+            logging.warning(_('New i values have not the same length as the number of vertices'))
+            return
+
+        for curvert, newi in zip(self.myvertices, new_i):
+            curvert.in_use = newi
+
+        self._reset_listogl()
+
+    def __str__(self):
+        return self.myname
+
+    def __len__(self):
+        return self.nbvertices
+
+    def __iter__(self) -> wolfvertex:
+        return iter(self.myvertices)
+
+    def __getitem__(self, ndx:int) -> wolfvertex:
+        """ Permet de retrouver un vertex sur base de son index """
+        if ndx>=0 and ndx < self.nbvertices:
+            return self.myvertices[ndx]
+        else:
+            logging.warning(_('Index out of range'))
+
+    def __setitem__(self, ndx:int, value:wolfvertex):
+        """ Permet de modifier un vertex sur base de son index """
+        if ndx>=0 and ndx < self.nbvertices:
+            self.myvertices[ndx] = value
+            self._reset_listogl()
+        else:
+            logging.warning(_('Index out of range'))
+
+    def __delitem__(self, ndx:int):
+        """ Permet de supprimer un vertex sur base de son index """
+        if ndx>=0 and ndx < self.nbvertices:
+            self.myvertices.pop(ndx)
+            self._reset_listogl()
+        else:
+            logging.warning(_('Index out of range'))
+
+    def append(self, other:"vector", merge_type:Literal['link', 'copy']='link'):
+        """
+        Append a vector to the current one
+        """
+
+        if merge_type == 'link':
+            self.myvertices.extend(other.myvertices)
+        elif merge_type == 'copy':
+            self.myvertices.extend(other.myvertices.copy())
+        else:
+            logging.warning(_('Merge type not supported'))
+
+        self.update_lengths()
+        self._reset_listogl()
+
+    def cut(self, s:float, is3D:bool=True, adim:bool=True, frombegin:bool=True):
+        """
+        cut a vector at a given curvilinear abscissa
+        """
+
+        newvec = vector(name=self.myname+'_cut', parentzone=self.parentzone)
+        self.parentzone.add_vector(newvec, update_struct=True)
+
+        k,cums,lengthparts=self.get_segment(s,is3D,adim,frombegin)
+
+        if frombegin:
+            newvec.myvertices = self.myvertices[:k+1]
+            self.myvertices = self.myvertices[k:]
+        else:
+            newvec.myvertices = self.myvertices[k:]
+            self.myvertices = self.myvertices[:k+1]
+
+        self.update_lengths()
+        newvec.update_lengths()
+
+        self._reset_listogl()
+
+        return newvec
+
+    def _reset_listogl(self):
+        """
+        Reset the list of OpenGL display
+        """
+        if self.parentzone is not None:
+            self.parentzone.reset_listogl()
+
+
 class zone:
     """
     Objet de gestion d'informations vectorielles
@@ -2547,7 +2863,7 @@ class zone:
 
         return i
 
-    def add_vector(self, addedvect:vector, index=-99999, forceparent=False):
+    def add_vector(self, addedvect:vector, index=-99999, forceparent=False, update_struct=False):
         """
         Ajout d'une instance 'vector'
 
@@ -2574,6 +2890,9 @@ class zone:
             # NOTHING because the active vector is normally choosen by the UI or during special operations
             # Here, we select the first added vector
 
+        if update_struct:
+            self._fill_structure()
+
     def count(self):
         """
         Compte le nombre de vecteurs
@@ -2936,7 +3255,7 @@ class zone:
 
     def createmultibin_proj(self, nb=None, nb2=0) -> Triangulation:
         """
-        Création d'une triangulation sur base des vecteurs par projection au plus proche du veteur central
+        Création d'une triangulation sur base des vecteurs par projection au plus proche du vecteur central
         Tient compte de l'ordre
 
         :param nb : nombre de points de découpe des vecteurs
@@ -3220,7 +3539,14 @@ class zone:
             zonepolyleft.find_minmax(True)
             zonepolyright.find_minmax(True)
 
-        self.parent.fill_structure()
+        self._fill_structure()
+
+    def _fill_structure(self):
+        """
+        Mise à jour des structures
+        """
+        if self.parent is not None:
+            self.parent.fill_structure()
 
     def create_sliding_polygon_from_parallel(self,
                                              poly_length:float,
@@ -3503,7 +3829,7 @@ class zone:
             zonepolyleft.find_minmax(True)
             zonepolyright.find_minmax(True)
 
-        self.parent.fill_structure()
+        self._fill_structure()
 
         return myparallels
 
@@ -3844,22 +4170,28 @@ class zone:
             glDeleteLists(self.idgllist,1)
             self.idgllist=-99999
 
-    def deepcopy_zone(self, name: str =None, parent: str= None):
+    def deepcopy_zone(self, name: str =None, parent: str= None) -> "zone":
         """ Return a deep copy of the zone"""
 
         if name is None:
             name =  self.myname + '_copy'
-            if parent:
-                copied_zone = zone(name=name, parent=parent)
-            else:
-                copied_zone = zone(name=name)
-            copied_zone.myvectors = []
-            for vec in self.myvectors:
-                copied_vec = vec.deepcopy_vector(parentzone = copied_zone)
-                copied_zone.add_vector(copied_vec)
-            #     copied_zone.myvectors.append(copied_vec)
-            # copied_zone.nbvectors = len(copied_zone.myvectors) FIXME not needed anymore
-            return copied_zone
+
+        if parent is not None:
+            copied_zone = zone(name=name, parent=parent)
+        else:
+            copied_zone = zone(name=name)
+
+        copied_zone.myvectors = []
+        for vec in self.myvectors:
+            copied_vec = vec.deepcopy_vector(parentzone = copied_zone)
+            copied_zone.add_vector(copied_vec, forceparent=True)
+
+        return copied_zone
+
+    def deepcopy(self, name: str =None, parent: str= None) -> "zone":
+        """ Return a deep copy of the zone"""
+
+        return self.deepcopy_zone(name, parent)
 
     def show_properties(self):
         """ Show properties of the zone --> will be applied to all vectors int he zone """
@@ -4507,6 +4839,16 @@ class Zones(wx.Frame, Element_To_Draw):
         """
         self.plotted = False
 
+    def save(self):
+        """
+        Sauvegarde sur disque, sans remise en cause du nom de fichier
+        """
+        if self.filename =='':
+            logging.warning(_('No filename defined'))
+            return
+
+        self.saveas()
+
     def saveas(self, filename:str=''):
         """
         Sauvegarde sur disque
@@ -4742,12 +5084,12 @@ class Zones(wx.Frame, Element_To_Draw):
             self.binfrom3.SetToolTip(_("Create a bin/rectangular channel based on 3 vectors in the currently active zone \n Some parameters will be prompted to the user (lateral height, ...) and if a triangular mesh must be created --> Blender"))
             self.binfrom3.Bind(wx.EVT_BUTTON,self.Oncreatebin)
 
-            self.trifromall = wx.Button(self,label=_('Create tri from all vectors'))
-            self.trifromall.SetToolTip(_("Create a triangular mesh based on all vectors in the currently active zone and add the result to the GUI \n Useful in some interpolation method"))
+            self.trifromall = wx.Button(self,label=_('Create triangulation'))
+            self.trifromall.SetToolTip(_("Create a triangular mesh based on all vectors within the currently active zone.\nUse the vertices as they are after subdividing the vectors into a specified number of points.\nAdd the resulting mesh to the GUI.\nThis can be useful in certain interpolation methods."))
             self.trifromall.Bind(wx.EVT_BUTTON,self.Oncreatemultibin)
 
-            self.trifromall_proj = wx.Button(self,label=_('Create tri from all vectors (projection)'))
-            self.trifromall_proj.SetToolTip(_("Create a triangular mesh based on all vectors in the currently active zone and add the result to the GUI \n Useful in some interpolation method"))
+            self.trifromall_proj = wx.Button(self,label=_('Create triangulation (projection)'))
+            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.polyfrompar = wx.Button(self,label=_('Create polygons from parallels'))
@@ -5217,7 +5559,7 @@ class Zones(wx.Frame, Element_To_Draw):
             self.mapviewer.start_action('capture vertices', _('Capture vertices'))
             firstvert=wolfvertex(0.,0.)
             self.active_vector.add_vertex(firstvert)
-            self.active_vector.parentzone.reset_listogl()
+            self.active_vector._reset_listogl()
             self.mapviewer.mimicme()
 
     def OnReverse(self, event:wx.MouseEvent):
@@ -5233,6 +5575,7 @@ class Zones(wx.Frame, Element_To_Draw):
 
             self.active_vector.reverse()
             self.fill_structure()
+            self.active_vector._reset_listogl()
 
     def OnAddPar(self, event:wx.MouseEvent):
         """
@@ -5257,6 +5600,7 @@ class Zones(wx.Frame, Element_To_Draw):
             self.fill_structure()
             self.find_minmax(True)
             self.expand_tree(self.active_zone)
+            self.active_zone.reset_listogl()
 
     def OncaptureandDynapar(self, event:wx.MouseEvent):
         """
@@ -6024,6 +6368,8 @@ class Zones(wx.Frame, Element_To_Draw):
                 msg+=_('\n')
                 msg+=_('Retry !\n')
                 wx.MessageBox(msg)
+            else:
+                logging.warning(_('Active vector is None - Retry !'))
             return True
         return False
 
@@ -6340,18 +6686,25 @@ class Zones(wx.Frame, Element_To_Draw):
                             dlg.Destroy()
                             return
 
-    def deepcopy_zones(self, name:str = None):
+    def deepcopy_zones(self, name:str = None) -> "Zones":
         """
         Return the deep copy of the current
         Zones (a new object).
         """
-        copied_Zones = Zones()
+        copied_Zones = Zones(idx=name)
         for zne in self.myzones:
             new_zne = zne.deepcopy_zone(parent= copied_Zones)
             copied_Zones.add_zone(new_zne,forceparent=True)
         copied_Zones.find_minmax(True)
         return copied_Zones
 
+    def deepcopy(self, name:str = None) -> "Zones":
+        """
+        Return the deep copy of the current
+        Zones (a new object).
+        """
+        return self.deepcopy_zones(name=name)
+
 class Grid(Zones):
     """
     Grid to draw on the mapviewer.

wolfhece/apps/check_version.py

@@ -0,0 +1,49 @@
+import pkg_resources
+
+from .version import WolfVersion
+
+def validate_version(expected_version:str):
+
+    # Test de la version afin de s'assurer que les dernières fonctionnalités sont présentes
+    major, minor, patch = str(WolfVersion()).split('.')
+    major = int(major)
+    minor = int(minor)
+    patch = int(patch)
+
+    major_expected, minor_expected, patch_expected = expected_version.split('.')
+    major_expected = int(major_expected)
+    minor_expected = int(minor_expected)
+    patch_expected = int(patch_expected)
+
+    test = major == major_expected and minor == minor_expected and patch >= patch_expected
+
+    if test:
+        return 'Version correcte'
+    else:
+        return 'Version incorrecte'
+
+def validate_package_version(expected_version:str):
+    # Test de la version afin de s'assurer que les dernières fonctionnalités sont présentes
+    # Obtenir la version du paquet 'wolfhece' dans l'espace de
+    # stockage des paquets de l'environnement Python actif.
+    # Potentiellement différente de la version accessible via le PATH
+    # en fonction de la amchine utilisée.
+    pkg_wolfhece = pkg_resources.get_distribution('wolfhece')
+    locversion_pkg = pkg_wolfhece.version
+    major, minor, patch = str(locversion_pkg).split('.')
+    major = int(major)
+    minor = int(minor)
+    patch = int(patch)
+
+    major_expected, minor_expected, patch_expected = expected_version.split('.')
+    major_expected = int(major_expected)
+    minor_expected = int(minor_expected)
+    patch_expected = int(patch_expected)
+
+    test = major == major_expected and minor == minor_expected and patch >= patch_expected
+
+    if test:
+        return 'Version correcte'
+    else:
+        return 'Version incorrecte'
+

wolfhece/apps/version.py

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