wolfhece 2.1.108__py3-none-any.whl → 2.1.110__py3-none-any.whl

wolfhece/PyVertexvectors.py

@@ -59,6 +59,12 @@ class Triangulation(Element_To_Draw):
         self.nb_tri = len(tri)
         self.nb_pts = len(pts)
 
+        self._start_move = None
+        self._move_step = None  # step for a move
+        self._rotation_center = None
+        self._rotation_step = None
+        self._cache = None
+
         if fn !='':
             self.filename=fn
             self.read(fn)
@@ -370,6 +376,7 @@ class Triangulation(Element_To_Draw):
                 glPolygonMode(GL_FRONT_AND_BACK,GL_LINE)
 
                 glEndList()
+                glCallList(self.id_list)
             except:
                 logging.warning('Problem with OpenGL plot - Triangulation.plot')
         else:
@@ -420,6 +427,67 @@ class Triangulation(Element_To_Draw):
         self.nb_pts = len(self.pts)
         self.nb_tri = len(self.tri)
         self.valid_format()
+
+    def set_cache(self):
+        """ Set the cache for the vertices """
+
+        self._cache = self.pts.copy()
+
+    def clear_cache(self):
+        """ Clear the cache for the vertices """
+
+        self._cache = None
+
+    def move(self, delta_x:float, delta_y:float, use_cache:bool = True):
+        """ Move the vertices by a delta_x and delta_y
+
+        :param delta_x: delta x [m]
+        :param delta_y: delta y [m]
+        """
+
+        if use_cache and self._cache is None:
+            self.set_cache()
+
+        if use_cache:
+            self.pts[:,0] = self._cache[:,0] + delta_x
+            self.pts[:,1] = self._cache[:,1] + delta_y
+        else:
+            self.pts[:,0] += delta_x
+            self.pts[:,1] += delta_y
+
+    def rotate(self, angle:float, center:tuple, use_cache:bool = True):
+        """ Rotate the vertices around a center
+
+        :param angle: angle in degrees -- positive for clockwise rotation
+        :param center: center of rotation
+        """
+        angle = np.radians(angle)
+        c,s = np.cos(angle), np.sin(angle)
+        R = np.array([[c,-s],[s,c]])
+
+        if use_cache and self._cache is None:
+            self.set_cache()
+
+        if use_cache:
+            locxy = self._cache[:,:2] - np.array(center)
+            self.pts[:,:2] = np.dot(R,locxy.T).T + np.array(center)
+        else:
+            locxy = self.pts[:,:2] - np.array(center)
+            self.pts[:,:2] = np.dot(R,locxy.T).T + np.array(center)
+
+    def rotate_xy(self, x:float, y:float, use_cache:bool = True):
+        """ Rotate the vector around the rotation center and a xy point """
+
+        if self._rotation_center is None:
+            logging.error('No rotation center defined -- set it before rotating by this routine')
+            return self
+
+        angle = np.degrees(np.arctan2(-(y-self._rotation_center[1]), x-self._rotation_center[0]))
+
+        if self._rotation_step is not None:
+            angle = np.round(angle/self._rotation_step)*self._rotation_step
+
+        return self.rotate(-angle, center=self._rotation_center, use_cache=use_cache)
 class vectorproperties:
     """ Vector properties """
     used:bool
@@ -743,6 +811,48 @@ class vectorproperties:
         self.attachedimage = Path(props[('Image','Attached image')])
         self.imagevisible = props[('Image','To show')]
 
+        posx = props[('Move','Start X')]
+        posy = props[('Move','Start Y')]
+        move_step = props[('Move','Step [m]')]
+
+        if posx != 99999. and posy != 99999.:
+            self.parent._start_move = (posx,posy)
+        else:
+            self.parent._start_move = None
+
+        if move_step != 99999.:
+            self.parent._move_step = move_step
+        else:
+            self.parent._move_step = None
+
+        posx = props[('Rotation','Center X')]
+        posy = props[('Rotation','Center Y')]
+        rot_step = props[('Rotation','Step [degree]')]
+
+        if posx != 99999. and posy != 99999.:
+            self.parent._rotation_center = (posx,posy)
+        else:
+            self.parent._rotation_center = None
+
+        if rot_step != 99999.:
+            self.parent._rotation_step = rot_step
+        else:
+            self.parent._rotation_step = None
+
+        angle = props[('Rotation','Angle [degree]')]
+        dx = props[('Move','Delta X')]
+        dy = props[('Move','Delta Y')]
+
+        if angle != 0. and (dx != 0. or dy != 0.):
+            logging.error('Both rotation and move are selected')
+        elif angle != 0.:
+            if self.parent._rotation_center is not None:
+                self.parent.rotate(angle, self.parent._rotation_center)
+                self.parent.clear_cache()
+        elif dx != 0. or dy != 0.:
+            self.parent.move(dx,dy)
+            self.parent.clear_cache()
+
         self.load_unload_image()
 
         try:
@@ -881,6 +991,35 @@ if :\n \
         self.myprops[('Image','Attached image')] = str(self.attachedimage)
         self.myprops[('Image','To show')] = self.imagevisible
 
+        if self.parent._rotation_center is not None:
+            self.myprops[('Rotation','center X')] = self.parent._rotation_center[0]
+            self.myprops[('Rotation','Center Y')] = self.parent._rotation_center[1]
+        else:
+            self.myprops[('Rotation','Center X')] = 99999.
+            self.myprops[('Rotation','Center Y')] = 99999.
+
+        if self.parent._rotation_step is not None:
+            self.myprops[('Rotation','Step [degree]')] = self.parent._rotation_step
+        else:
+            self.myprops[('Rotation','Step [degree]')] = 99999.
+
+        self.myprops[('Rotation', 'Angle [degree]')] = 0.
+
+        if self.parent._start_move is not None:
+            self.myprops[('Move','Start X')] = self.parent._start_move[0]
+            self.myprops[('Move','Start Y')] = self.parent._start_move[1]
+        else:
+            self.myprops[('Move','Start X')] = 99999.
+            self.myprops[('Move','Start Y')] = 99999.
+
+        if self.parent._move_step is not None:
+            self.myprops[('Move','Step [m]')] = self.parent._move_step
+        else:
+            self.myprops[('Move','Step [m]')] = 99999.
+
+        self.myprops[('Move','Delta X')] = 0.
+        self.myprops[('Move','Delta Y')] = 0.
+
         self.myprops.Populate()
         self.myprops.Layout()
         self.myprops.SetSizeHints(500,800)
@@ -1014,6 +1153,13 @@ class vector:
             self.myvertices=[]
             self.myprop=vectorproperties(parent=self)
 
+        self._cache_vertices = None
+        self._start_move = None
+        self._move_step = None
+
+        self._rotation_center = None
+        self._rotation_step = None
+
         self.linestring = None
         self.polygon = None
 
@@ -1026,6 +1172,94 @@ class vector:
         if fromshapely is not None:
             self.import_shapelyobj(fromshapely)
 
+    def set_cache(self):
+        """ Set the cache for the vertices """
+
+        self._cache_vertices = self.asnparray3d()
+
+    def clear_cache(self):
+        """ Clear the cache for the vertices """
+
+        self._cache_vertices = None
+
+    def move(self, deltax:float, deltay:float, use_cache:bool = True, inplace:bool = True):
+        """
+        Move the vector
+
+        :param deltax: delta x
+        :param deltay: delta y
+        :param use_cache: use the cache if available
+        :param inplace: move the vector inplace or return a new vector
+        """
+
+        if self._move_step is not None:
+            deltax = np.round(deltax/self._move_step)*self._move_step
+            deltay = np.round(deltay/self._move_step)*self._move_step
+
+        if inplace:
+            if use_cache and self._cache_vertices is None:
+                self.set_cache()
+
+            if use_cache:
+                self.xy = self._cache_vertices[:,:2] + np.array([deltax, deltay])
+            else:
+                for curvert in self.myvertices:
+                    curvert.x += deltax
+                    curvert.y += deltay
+
+            return self
+        else:
+            new_vector = self.deepcopy_vector(self.myname + '_moved')
+            new_vector.move(deltax, deltay, inplace=True)
+
+            return new_vector
+
+    def rotate(self, angle:float, center:tuple[float,float]=(0.,0.), use_cache:bool = True, inplace:bool = True):
+        """
+        Rotate the vector
+
+        :param angle: angle in degrees
+        :param center: center of the rotation
+        :param use_cache: use the cache if available
+        :param inplace: rotate the vector inplace or return a new vector
+        """
+
+        if inplace:
+            if use_cache and self._cache_vertices is None:
+                self.set_cache()
+
+            if use_cache:
+                locxy = self._cache_vertices[:,:2] - np.array(center)
+
+                rotation_matrix = np.array([[np.cos(np.radians(angle)), -np.sin(np.radians(angle))],
+                                            [np.sin(np.radians(angle)), np.cos(np.radians(angle))]])
+
+                self.xy = np.dot(locxy, rotation_matrix) + np.array(center)
+            else:
+                for curvert in self.myvertices:
+                    curvert.rotate(angle, center)
+
+            return self
+        else:
+            new_vector = self.deepcopy_vector(self.myname + '_rotated')
+            new_vector.rotate(angle, center, inplace=True)
+
+            return new_vector
+
+    def rotate_xy(self, x:float, y:float, use_cache:bool = True, inplace:bool = True):
+        """ Rotate the vector around the rotation center and a xy point """
+
+        if self._rotation_center is None:
+            logging.error('No rotation center defined -- set it before rotating by this routine')
+            return self
+
+        angle = np.degrees(np.arctan2(-(y-self._rotation_center[1]), x-self._rotation_center[0]))
+
+        if self._rotation_step is not None:
+            angle = np.round(angle/self._rotation_step)*self._rotation_step
+
+        return self.rotate(angle, center=self._rotation_center, use_cache=use_cache, inplace=inplace)
+
     def get_mapviewer(self):
         """
         Retourne l'instance de la mapviewer
@@ -1352,7 +1586,7 @@ class vector:
 
             for x,y in mypar.coords:
                 xy = Point(x,y)
-                curs = mypar.project(xy,True)
+                curs = mypar.project(xy, True)
                 curz = myls.interpolate(curs,True).z
 
                 newvert = wolfvertex(x,y,curz)
@@ -1924,6 +2158,10 @@ class vector:
 
         Retient également les longueurs de chaque segment
         """
+        if self.nbvertices < 2:
+            logging.warning(_('No enough vertices in vector to compute lenghts'))
+            return
+
         self._lengthparts2D=np.zeros(self.nbvertices-1)
         self._lengthparts3D=np.zeros(self.nbvertices-1)
 
@@ -2048,7 +2286,7 @@ class vector:
             self.myvertices = newvec.myvertices
             self.update_lengths()
 
-    def interpolate(self,s,is3D=True,adim=True,frombegin=True):
+    def interpolate(self,s,is3D=True,adim=True,frombegin=True) -> wolfvertex:
         """
         Interpolation linéaire à une abscisse curviligne 's' donnée
 
@@ -2790,6 +3028,11 @@ class zone:
         self.has_legend = False # indicate if at least one vector in the zone has a legend
         self.has_image  = False # indicate if at least one vector in the zone has an image
 
+        self._start_move = None # starting point for a move
+        self._move_step = None  # step for a move
+        self._rotation_center = None # center of rotation
+        self._rotation_step = None   # step for rotation
+
         if len(lines)>0:
             # Decoding from lines -- lines is a list of strings provided by the parent during reading
             # The order of the lines is important to ensure compatibility with the WOLF2D format
@@ -2823,6 +3066,80 @@ class zone:
             # Object can be created from a shapely object
             self.import_shapelyobj(fromshapely)
 
+    def set_cache(self):
+        """
+        Set the cache for the zone and all its vectors
+        """
+        for curvect in self.myvectors:
+            curvect.set_cache()
+
+    def clear_cache(self):
+        """
+        Clear the cache for the zone and all its vectors
+        """
+        for curvect in self.myvectors:
+            curvect.clear_cache()
+
+        self._start_move = None
+        self._move_step = None
+        self._rotation_center = None
+        self._rotation_step = None
+
+        self.find_minmax(update=True)
+
+    def move(self, dx:float, dy:float, use_cache:bool=True, inplace:bool=True):
+        """
+        Move the zone and all its vectors
+        """
+
+        if self._move_step is not None:
+            dx = np.round(dx/self._move_step)*self._move_step
+            dy = np.round(dy/self._move_step)*self._move_step
+
+        if inplace:
+            for curvect in self.myvectors:
+                curvect.move(dx, dy, use_cache)
+            return self
+        else:
+            newzone = self.deepcopy()
+            newzone.move(dx, dy, use_cache= False)
+            return newzone
+
+    def rotate(self, angle:float, center:tuple[float,float], use_cache:bool=True, inplace:bool=True):
+        """
+        Rotate the zone and all its vectors
+
+        :param angle: angle in degrees (clockwise)
+        :param center: center of rotation
+        :param use_cache: use the cache for the vertices
+        :param inplace: modify the zone in place or return a new one
+        """
+
+        if inplace:
+            for curvect in self.myvectors:
+                curvect.rotate(angle, center, use_cache)
+            return self
+        else:
+            newzone = self.deepcopy()
+            newzone.rotate(angle, center, use_cache= False)
+            return newzone
+
+    def rotate_xy(self, x:float, y:float, use_cache:bool=True, inplace:bool=True):
+        """
+        Rotate the zone and all its vectors in the xy plane
+        """
+
+        if self._rotation_center is None:
+            logging.error(_('No rotation center defined - Set it before rotating by this routine'))
+            return self
+
+        angle = np.degree(np.arctan2(y-self._rotation_center[1], x-self._rotation_center[0]))
+
+        if self._rotation_step is not None:
+            angle = np.round(angle/self._rotation_step)*self._rotation_step
+
+        return self.rotate(angle, self._rotation_center, use_cache, inplace)
+
     @property
     def nbvectors(self):
         return len(self.myvectors)
@@ -4406,6 +4723,36 @@ class zone:
         self.myprops[('Legend','X')] = 99999.
         self.myprops[('Legend','Y')] = 99999.
         self.myprops[('Legend','Text')] = _('Not used')
+
+        if self._rotation_center is None:
+            self.myprops[('Rotation','Center X')] = 99999.
+            self.myprops[('Rotation','Center Y')] = 99999.
+        else:
+            self.myprops[('Rotation','Center X')] = self._rotation_center.x
+            self.myprops[('Rotation','Center Y')] = self._rotation_center.y
+
+        if self._rotation_step is None:
+            self.myprops[('Rotation','Step [degree]')] = 99999.
+        else:
+            self.myprops[('Rotation','Step [degree]')] = self._rotation_step
+
+        self.myprops[('Rotation', 'Angle [degree]')] = 0.
+
+        if self._move_start is None:
+            self.myprops[('Move','Start X')] = 99999.
+            self.myprops[('Move','Start Y')] = 99999.
+        else:
+            self.myprops[('Move','Start X')] = self._move_start.x
+            self.myprops[('Move','Start Y')] = self._move_start.y
+
+        if self._move_step is None:
+            self.myprops[('Move','Step [m]')] = 99999.
+        else:
+            self.myprops[('Move','Step [m]')] = self._move_step
+
+        self.myprops[('Move', 'Delta X')] = 0.
+        self.myprops[('Move', 'Delta Y')] = 0.
+
         self.myprops.Populate()
         self.myprops.set_callbacks(self._callback_prop, self._callback_destroy_props)
 
@@ -4442,6 +4789,24 @@ class zone:
         for curvec in self.myvectors:
             curvec.myprop.fill_property(self.myprops, updateOGL = False)
 
+        angle = self.myprops[('Rotation', 'Angle [degree]')]
+        dx = self.myprops[('Move', 'Delta X')]
+        dy = self.myprops[('Move', 'Delta Y')]
+
+        if angle!=0. and (dx!=0. or dy!=0.):
+            logging.warning(_('Rotation and translation are not compatible'))
+            return
+        elif angle!=0.:
+            if self._rotation_center is None:
+                logging.warning(_('No rotation center defined'))
+                return
+            else:
+                self.rotate(angle, self._rotation_center)
+                self.clear_cache()
+        elif dx!=0. or dy!=0.:
+            self.move(dx, dy)
+            self.clear_cache()
+
         if self.parent.mapviewer is not None:
             self.prep_listogl()
             self.parent.mapviewer.Refresh()
@@ -4559,6 +4924,11 @@ class Zones(wx.Frame, Element_To_Draw):
         self.ty=ty
         self.myzones=[]
 
+        self._start_move = None
+        self._move_step = None
+        self._rotation_center = None
+        self._rotation_step = None
+
         if self.filename!='':
             # lecture du fichier
 
@@ -4630,6 +5000,70 @@ class Zones(wx.Frame, Element_To_Draw):
         if plotted and self.has_OGLContext and not self.shared:
             self.prep_listogl()
 
+    def set_cache(self):
+        """ Set cache for all zones """
+
+        for curzone in self.myzones:
+            curzone.set_cache()
+
+    def clear_cache(self):
+        """ Clear cache for all zones """
+
+        for curzone in self.myzones:
+            curzone.clear_cache()
+
+    def move(self, dx:float, dy:float, use_cache:bool = True, inplace:bool = True):
+        """ Move all zones """
+
+        if self._move_step is not None:
+            dx = np.round(dx/self._move_step)*self._move_step
+            dy = np.round(dy/self._move_step)*self._move_step
+
+        if inplace:
+            for curzone in self.myzones:
+                curzone.move(dx, dy, use_cache=use_cache, inplace=inplace)
+
+            return self
+
+        else:
+            newzones = self.deepcopy_zones()
+            newzones.move(dx, dy, use_cache=False, inplace=True)
+            newzones.find_minmax(True)
+            return newzones
+
+    def rotate(self, angle:float, center:Point = None, use_cache:bool = True, inplace:bool = True):
+        """ Rotate all zones """
+
+        if self._rotation_step is not None:
+            angle = np.round(angle/self._rotation_step)*self._rotation_step
+
+        if inplace:
+            for curzone in self.myzones:
+                curzone.rotate(angle, center, use_cache=use_cache, inplace=inplace)
+
+            return self
+
+        else:
+            newzones = self.deepcopy_zones()
+            newzones.rotate(angle, center, use_cache=False, inplace=True)
+            newzones.find_minmax(True)
+            return newzones
+
+    def rotate_xy(self, angle:float, center:Point = None, use_cache:bool = True, inplace:bool = True):
+        """ Rotate all zones """
+
+        if inplace:
+            for curzone in self.myzones:
+                curzone.rotate_xy(angle, center, use_cache=use_cache, inplace=inplace)
+
+            return self
+
+        else:
+            newzones = self.deepcopy_zones()
+            newzones.rotate_xy(angle, center, use_cache=False, inplace=True)
+            newzones.find_minmax(True)
+            return newzones
+
     def force_unique_zone_name(self):
         """
         Check if all zones have a unique id
@@ -5297,6 +5731,10 @@ class Zones(wx.Frame, Element_To_Draw):
             self.evaluates.SetToolTip(_("Calculate the curvilinear 's' distance using a '2D' or '3D' approach and store the result in the 5th column of the grid, X being the first one"))
             self.evaluates.Bind(wx.EVT_BUTTON,self.Onevaluates)
 
+            self.update_from_s = wx.Button(self,label=_('Update from sz (support)'))
+            self.update_from_s.SetToolTip(_("Update the coordinates of the vertices based on the 's' distance \n The interpolation uses the 's' value contained in the 5th column of the grid, X being the first one.\nThe support vector is in XY. It will be replaced."))
+            self.update_from_s.Bind(wx.EVT_BUTTON,self.Onupdate_from_sz_support)
+
             #  Modified
             self.zoomonactive = wx.Button(self,label=_('Zoom on active vector'))
             self.zoomonactive.SetToolTip(_("Zoom on the active vector and a default view size of 500 m x 500 m"))
@@ -5338,8 +5776,8 @@ class Zones(wx.Frame, Element_To_Draw):
             self.slidingpoly.Bind(wx.EVT_BUTTON,self.Oncreateslidingpoly)
 
             # Added
-            self.getxyfromsz = wx.Button(self, label = _('Get xy from sz'))
-            self.getxyfromsz.SetToolTip(_("Populate the X an Y columns based on: \n - Given sz coordinates, \n - The X and Y coordinates of the initial point (s = 0) and,  \n - The X and Y coordinates of a second point (any other point with an S coordinate)"))
+            self.getxyfromsz = wx.Button(self, label = _('Update from sz (2 points)'))
+            self.getxyfromsz.SetToolTip(_("Populate the X an Y columns based on: \n - Given sz coordinates, \n - 2 Points \n - The X and Y coordinates of the initial point (s = 0) and,  \n - The X and Y coordinates of a second point (for the direction)"))
             self.getxyfromsz.Bind(wx.EVT_BUTTON, self.get_xy_from_sz)
 
             boxright.Add(self.xls,1,wx.EXPAND)
@@ -5363,10 +5801,16 @@ class Zones(wx.Frame, Element_To_Draw):
 
             # boxright.Add(self.zoomonactive,0,wx.EXPAND)
             boxright.Add(boxzoom,0,wx.EXPAND)
-            boxright.Add(self.evaluates,0,wx.EXPAND)
+
+            box_s = wx.BoxSizer(wx.HORIZONTAL)
+            boxright.Add(box_s,0,wx.EXPAND)
+
+            box_s.Add(self.evaluates,1,wx.EXPAND)
+            box_s.Add(self.update_from_s,1,wx.EXPAND)
+            box_s.Add(self.getxyfromsz,1,wx.EXPAND) # Added
+
             boxright.Add(self.interpxyz,0,wx.EXPAND)
             boxright.Add(self.sascending,0,wx.EXPAND)
-            boxright.Add(self.getxyfromsz,0,wx.EXPAND) # Added
 
             self.butgetval = wx.Button(self,label=_('Get values (self or active array)'))
             self.butgetval.SetToolTip(_("Get values of the attached/active array (not working with 2D results) on each vertex of the active vector and update the editor"))
@@ -5381,8 +5825,22 @@ class Zones(wx.Frame, Element_To_Draw):
             self.butgetrefvallinked.SetToolTip(_("Get values of all the visible arrays and 2D results on each vertex of the active vector \n and more is the step size of the array is more precise \n\n Create a new zone containing the results"))
             self.butgetrefvallinked.Bind(wx.EVT_BUTTON,self.Ongetvalueslinkedandref)
 
+            self._move_rotate_sizer = wx.BoxSizer(wx.HORIZONTAL)
+
+            self.butmove = wx.Button(self,label=_('Move'))
+            self.butmove.SetToolTip(_("Move the active vector - If not defined in properties, the first right click is the origin of the move"))
+            self.butmove.Bind(wx.EVT_BUTTON,self.OnMove)
+
+            self.butrotate = wx.Button(self,label=_('Rotate'))
+            self.butrotate.SetToolTip(_("Rotate the active vector - If not defined in properties, the first right click is the origin of the rotation"))
+            self.butrotate.Bind(wx.EVT_BUTTON,self.OnRotate)
+
+            self._move_rotate_sizer.Add(self.butmove, 1, wx.EXPAND)
+            self._move_rotate_sizer.Add(self.butrotate, 1, wx.EXPAND)
+
             boxright.Add(self.butgetvallinked,0,wx.EXPAND)
             boxright.Add(self.butgetrefvallinked,0,wx.EXPAND)
+            boxright.Add(self._move_rotate_sizer, 0, wx.EXPAND)
 
             self.treelist = TreeListCtrl(self,style=TL_CHECKBOX|wx.TR_FULL_ROW_HIGHLIGHT|wx.TR_EDIT_LABELS)
             self.treelist.AppendColumn('Zones')
@@ -5401,6 +5859,10 @@ class Zones(wx.Frame, Element_To_Draw):
 
             self.addzone = wx.Button(self,label=_('Add zone'))
             self.addvector = wx.Button(self,label=_('Add vector'))
+
+            self.duplicatezone = wx.Button(self,label=_('Duplicate zone'))
+            self.duplicatevector = wx.Button(self,label=_('Duplicate vector'))
+
             self.deletezone = wx.Button(self,label=_('Delete zone'))
             self.findactivevector = wx.Button(self,label=_('Find in all'))
             self.findactivevector.SetToolTip(_("Search and activate the nearest vector by mouse click (Searching window : all zones)"))
@@ -5414,8 +5876,24 @@ class Zones(wx.Frame, Element_To_Draw):
             self.downzone = wx.Button(self,label=_('Down zone'))
             # self.interpolate = wx.Button(self,label=_('Interpolate vector'))
 
+            self._move_rotate_zone_sizer = wx.BoxSizer(wx.HORIZONTAL)
+            self.butmove_zone = wx.Button(self,label=_('Move zone'))
+            self.butmove_zone.SetToolTip(_("Move the active zone - If not defined in properties, the first right click is the origin of the move"))
+            self.butmove_zone.Bind(wx.EVT_BUTTON,self.OnMoveZone)
+
+            self.butrotate_zone = wx.Button(self,label=_('Rotate zone'))
+            self.butrotate_zone.SetToolTip(_("Rotate the active zone - If not defined in properties, the first right click is the origin of the rotation"))
+            self.butrotate_zone.Bind(wx.EVT_BUTTON,self.OnRotateZone)
+
+            self._move_rotate_zone_sizer.Add(self.butmove_zone, 1, wx.EXPAND)
+            self._move_rotate_zone_sizer.Add(self.butrotate_zone, 1, wx.EXPAND)
+
             self.addzone.Bind(wx.EVT_BUTTON,self.OnClickadd_zone)
             self.addvector.Bind(wx.EVT_BUTTON,self.OnClickadd_vector)
+
+            self.duplicatezone.Bind(wx.EVT_BUTTON,self.OnClickduplicate_zone)
+            self.duplicatevector.Bind(wx.EVT_BUTTON,self.OnClickduplicate_vector)
+
             self.deletezone.Bind(wx.EVT_BUTTON,self.OnClickdelete_zone)
             self.deletevector.Bind(wx.EVT_BUTTON,self.OnClickdelete_vector)
             self.upvector.Bind(wx.EVT_BUTTON,self.OnClickup_vector)
@@ -5433,6 +5911,11 @@ class Zones(wx.Frame, Element_To_Draw):
             boxadd.Add(self.addzone,1,wx.EXPAND)
             boxadd.Add(self.addvector,1,wx.EXPAND)
 
+            boxduplicate = wx.BoxSizer(wx.HORIZONTAL)
+            boxduplicate.Add(self.duplicatezone,1,wx.EXPAND)
+            boxduplicate.Add(self.duplicatevector,1,wx.EXPAND)
+            boxadd.Add(boxduplicate,1,wx.EXPAND)
+
             subboxadd = wx.BoxSizer(wx.HORIZONTAL)
             subboxadd.Add(self.findactivevector,1,wx.EXPAND)
             subboxadd.Add(self.findactivevectorcurz,1,wx.EXPAND)
@@ -5467,6 +5950,7 @@ class Zones(wx.Frame, Element_To_Draw):
             boxleft.Add(boxdelete,0,wx.EXPAND)
             boxleft.Add(boxupdown,0,wx.EXPAND)
             boxleft.Add(boxtri,0,wx.EXPAND)
+            boxleft.Add(self._move_rotate_zone_sizer, 0, wx.EXPAND)
 
             box.Add(boxleft,1,wx.EXPAND)
             box.Add(boxright,1,wx.EXPAND)
@@ -5494,7 +5978,6 @@ class Zones(wx.Frame, Element_To_Draw):
 
             self.init_struct=False
 
-
     def get_xy_from_sz(self, event: wx.Event):
         """
         Add vertices and their respectives xy coordinates from s and Z entries in the xls grid:
@@ -5503,98 +5986,7 @@ class Zones(wx.Frame, Element_To_Draw):
         if self.wx_exists:
             if self.verify_activevec():
                 return
-        curv  = self.active_vector
-        n_rows = self.xls.GetNumberRows()
-
-        # Getting the 2 first XY coordinates
-        X =[]
-        Y = []
 
-        z_row = 1 #Starting from the second row because the first one is the initial point
-
-        # First row coordinates
-        x1 = self.xls.GetCellValue(0,0)
-        y1 = self.xls.GetCellValue(0,1)
-
-
-        if x1 != '' and y1 != '':
-            X.append(float(x1))
-            Y.append(float(y1))
-
-        else:
-            raise Exception('Encode the coordinates of the initial point (S = 0 -->  first point)')
-
-        # Coordinates of the second points
-        while z_row < n_rows:
-            if len(X) < 2 and len(Y) < 2:
-                x2 = self.xls.GetCellValue(z_row,0)
-                y2 = self.xls.GetCellValue(z_row,1)
-
-                if x2 != '' and y2 != '':
-                    X.append(float(x2))
-                    Y.append(float(y2))
-
-                z_row += 1
-
-            else:
-                break
-
-        xy1 = np.array([X[0], Y[0]])
-        xy2 = np.array([X[1], Y[1]])
-
-        # Collection of sz coordinates
-        row = 0
-
-        SZ = []
-
-        while row < n_rows:
-            s = self.xls.GetCellValue(row,4)
-            z = self.xls.GetCellValue(row,2)
-
-            if z=='':
-                z=0.
-
-            if s != '':
-                SZ.append((s,z))
-                row += 1
-
-            elif s=='':         #FIXME logging msg to notify the user a point is missing
-                break
-
-            else:
-                raise Exception (_("Recheck your data inputs"))
-                break
-
-        sz = np.asarray(SZ,dtype='float64') # FIXME The type is required otherwise type == <U
-
-        # Creation of vertices
-        if sz.shape[1]==2 and xy1.shape==(2,) and xy2.shape==(2,):
-            if not np.array_equal(xy1,xy2):
-                curv.myvertices=[]
-                curv.nbvertices = 0
-
-                dx, dy = xy2[0]-xy1[0], xy2[1]-xy1[1]
-                norm = np.linalg.norm([dx,dy])
-                dx, dy = dx/norm, dy/norm
-
-                for cur in sz:
-                    x, y = xy1[0] + dx*cur[0], xy1[1] + dy*cur[0]
-                    curv.add_vertex(wolfvertex(x, y, float(cur[1])))
-
-        # update of the xls grid
-        for k in range(curv.nbvertices ):
-            self.xls.SetCellValue(k,0,str(curv.myvertices[k].x))
-            self.xls.SetCellValue(k,1,str(curv.myvertices[k].y))
-
-
-    def get_xy_from_sz(self, event: wx.Event):
-        """
-        Add vertices and their respectives xy coordinates from s and Z entries in the xls grid:
-            - NB: The coordinates of the initial point s= 0 and one other points should be explicitly given in the xls grid.
-        """
-        if self.wx_exists:
-            if self.verify_activevec():
-                return
         curv  = self.active_vector
         n_rows = self.xls.GetNumberRows()
 
@@ -5663,19 +6055,7 @@ class Zones(wx.Frame, Element_To_Draw):
 
         sz = np.asarray(SZ,dtype='float64') # FIXME The type is required otherwise type == <U
 
-        # Creation of vertices
-        if sz.shape[1]==2 and xy1.shape==(2,) and xy2.shape==(2,):
-            if not np.array_equal(xy1,xy2):
-                curv.myvertices=[]
-                curv.nbvertices = 0
-
-                dx, dy = xy2[0]-xy1[0], xy2[1]-xy1[1]
-                norm = np.linalg.norm([dx,dy])
-                dx, dy = dx/norm, dy/norm
-
-                for cur in sz:
-                    x, y = xy1[0] + dx*cur[0], xy1[1] + dy*cur[0]
-                    curv.add_vertex(wolfvertex(x, y, float(cur[1])))
+        self.update_from_sz_direction(xy1, xy2, sz)
 
         # update of the xls grid
         for k in range(curv.nbvertices ):
@@ -5840,6 +6220,56 @@ class Zones(wx.Frame, Element_To_Draw):
             self.expand_tree(self.active_zone)
             self.active_zone.reset_listogl()
 
+    def OnMove(self, event:wx.MouseEvent):
+        """
+        Déplacement du vecteur actif
+        """
+        if self.wx_exists:
+            if self.verify_activevec():
+                return
+
+            self.mapviewer.start_action('move vector', _('Move vector'))
+            self.active_vector.set_cache()
+            self.mapviewer.mimicme()
+
+    def OnMoveZone(self, event:wx.MouseEvent):
+        """
+        Déplacement de la zone active
+        """
+        if self.wx_exists:
+            if self.verify_activezone():
+                return
+
+            self.mapviewer.start_action('move zone', _('Move zone'))
+            self.active_zone.set_cache()
+            self.mapviewer.mimicme()
+
+    def OnRotate(self, event:wx.MouseEvent):
+        """
+        Rotation du vecteur actif
+        """
+
+        if self.wx_exists:
+            if self.verify_activevec():
+                return
+
+            self.mapviewer.start_action('rotate vector', _('Rotate vector'))
+            self.active_vector.set_cache()
+            self.mapviewer.mimicme()
+
+    def OnRotateZone(self, event:wx.MouseEvent):
+        """
+        Rotation de la zone active
+        """
+
+        if self.wx_exists:
+            if self.verify_activezone():
+                return
+
+            self.mapviewer.start_action('rotate zone', _('Rotate zone'))
+            self.active_zone.set_cache()
+            self.mapviewer.mimicme()
+
     def OncaptureandDynapar(self, event:wx.MouseEvent):
         """
         Ajoute des vertices au vecteur courant et crée des parallèles gauche-droite
@@ -6399,6 +6829,98 @@ class Zones(wx.Frame, Element_To_Draw):
                 s+=curv._lengthparts3D[k]
                 self.xls.SetCellValue(k+1,4,str(s))
 
+    def Onupdate_from_sz_support(self, event:wx.MouseEvent):
+        """ Update the active vector from the sz values in the xls grid """
+
+        if self.active_vector is None:
+            logging.info(_('No active vector -- Nothing to do'))
+            return
+
+        sz = []
+
+        i = 0
+        while self.xls.GetCellValue(i,4) != '':
+            sz.append((float(self.xls.GetCellValue(i,4)), float(self.xls.GetCellValue(i,2))))
+            i += 1
+
+        logging.info(f'Number of points: {len(sz)}')
+
+        vec_sz = np.array(sz)
+
+        self.update_from_sz_support(vec=self.active_vector, sz=vec_sz)
+
+        # update of the xls grid
+        for k in range(self.active_vector.nbvertices ):
+            self.xls.SetCellValue(k,0,str(self.active_vector.myvertices[k].x))
+            self.xls.SetCellValue(k,1,str(self.active_vector.myvertices[k].y))
+
+
+    def update_from_sz_direction(self, xy1:np.ndarray, xy2:np.ndarray, sz:np.ndarray):
+        """ Update the active vector from the sz values in the xls grid """
+
+        if self.active_vector is None:
+            logging.info(_('No active vector -- Nothing to do'))
+            return
+
+        curv = self.active_vector
+
+        # Creation of vertices
+        if sz.shape[1]==2 and xy1.shape==(2,) and xy2.shape==(2,):
+            if not np.array_equal(xy1,xy2):
+                curv.myvertices=[]
+
+                dx, dy = xy2[0]-xy1[0], xy2[1]-xy1[1]
+                norm = np.linalg.norm([dx,dy])
+                dx, dy = dx/norm, dy/norm
+
+                for cur in sz:
+                    x, y = xy1[0] + dx*cur[0], xy1[1] + dy*cur[0]
+                    curv.add_vertex(wolfvertex(x, y, float(cur[1])))
+
+        self.find_minmax(True)
+
+    def update_from_sz_support(self, vec: vector, sz:np.ndarray, dialog_box = True):
+
+        if sz.shape[0] ==0:
+            logging.warning(_('No data to update'))
+            return
+
+        support_vec = vec.deepcopy_vector()
+        support_vec.update_lengths()
+
+        if support_vec.length2D is None or support_vec.length3D is None:
+            logging.warning(_('The support vector must be updated before updating the active vector'))
+            return
+
+        if dialog_box:
+            dlg = wx.SingleChoiceDialog(None, "Which mode?", "How to evaluate lengths?", ['2D','3D'])
+            ret=dlg.ShowModal()
+            if ret==wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+
+            method=dlg.GetStringSelection()
+            dlg.Destroy()
+        else:
+            method = '2D'
+
+        if method == '2D':
+            if sz[-1,0] > support_vec.length2D:
+                logging.warning(_('The last point is beyond the vector length. You must add more points !'))
+                return
+        else:
+            if sz[-1,0] > support_vec.length3D:
+                logging.warning(_('The last point is beyond the vector length. You must add more points !'))
+                return
+
+        vec.myvertices = []
+        for s,z in sz:
+            new_vertex = support_vec.interpolate(s, method == '3D', adim= False)
+            new_vertex.z = z
+            vec.add_vertex(new_vertex)
+
+        self.find_minmax(True)
+
     def evaluate_s (self, vec: vector =None, dialog_box = True):
         """
         Calcule la position curviligne du vecteur encodé
@@ -6527,6 +7049,32 @@ class Zones(wx.Frame, Element_To_Draw):
                 else:
                     return
 
+    def OnClickduplicate_zone(self, event:wx.MouseEvent):
+        """ Duplication de la zone active """
+        if self.wx_exists:
+            if self.verify_activezone():
+                return
+
+            newzone = self.active_zone.deepcopy_zone()
+            newzone.myname = self.active_zone.myname + '_copy'
+            self.add_zone(newzone, forceparent=True)
+            self.fill_structure()
+            self.Activate_zone(newzone)
+
+    def OnClickduplicate_vector(self, event:wx.MouseEvent):
+        """
+        Duplication du vecteur actif
+        """
+        if self.wx_exists:
+            if self.verify_activevec():
+                return
+
+            newvec = self.active_vector.deepcopy_vector()
+            newvec.myname = self.active_vector.myname + '_copy'
+            self.active_zone.add_vector(newvec, forceparent=True)
+            self.fill_structure()
+            self.Activate_vector(newvec)
+
     def OnClickdelete_zone(self, event:wx.MouseEvent):
         """
         Suppression de la zone courante
@@ -6781,6 +7329,48 @@ class Zones(wx.Frame, Element_To_Draw):
             for curvec in curzone.myvectors:
                 curvec.myprop.fill_property(self._myprops, updateOGL = False)
 
+        posx = self._myprops[('Move','Start X')]
+        posy = self._myprops[('Move','Start Y')]
+        if posx != 99999. and posy != 99999.:
+            self._start_move = (posx,posy)
+        else:
+            self._start_move = None
+
+        step = self._myprops[('Move','Step [m]')]
+        if step != 99999.:
+            self._move_step = step
+        else:
+            self._move_step = None
+
+        posx = self._myprops[('Rotation','Center X')]
+        posy = self._myprops[('Rotation','Center Y')]
+        if posx != 99999. and posy != 99999.:
+            self._rotation_center = (posx,posy)
+        else:
+            self._rotation_center = None
+
+        step = self._myprops[('Rotation','Step [degree]')]
+        if step != 99999.:
+            self._rotation_step = step
+        else:
+            self._rotation_step = None
+
+        angle = self._myprops[('Rotation','Angle [degree]')]
+        dx = self._myprops[('Move','Delta X')]
+        dy = self._myprops[('Move','Delta Y')]
+
+        if angle != 0. and (dx!= 0. or dy!=0.):
+            logging.error(_('Rotation and move are not compatible - Choose one and only one'))
+        elif angle!= 0.:
+            if self._rotation_center is None:
+                logging.error(_('No rotation center defined - Choose one'))
+            else:
+                self.rotate(angle, self._rotation_center)
+                self.clear_cache()
+        elif dx!= 0. or dy!=0.:
+            self.move(dx,dy)
+            self.clear_cache()
+
         if self.mapviewer is not None:
             self.prep_listogl()
             self.mapviewer.Refresh()
@@ -6798,10 +7388,40 @@ class Zones(wx.Frame, Element_To_Draw):
         self._myprops[('Legend','X')] = 99999.
         self._myprops[('Legend','Y')] = 99999.
         self._myprops[('Legend','Text')] = _('Not used')
+
+        if self._rotation_center is not None:
+            self._myprops[('Rotation', 'Center X')] = self._rotation_center[0]
+            self._myprops[('Rotation', 'Center Y')] = self._rotation_center[1]
+        else:
+            self._myprops[('Rotation', 'Center X')] = 99999.
+            self._myprops[('Rotation', 'Center Y')] = 99999.
+
+        if self._rotation_step is not None:
+            self._myprops[('Rotation', 'Step [degree]')] = self._rotation_step
+        else:
+            self._myprops[('Rotation', 'Step [degree]')] = 99999.
+
+        self._myprops['Rotation', 'Angle [degree]'] = 0.
+
+        if self._start_move is not None:
+            self._myprops[('Move', 'Start X')] = self._start_move[0]
+            self._myprops[('Move', 'Start Y')] = self._start_move[1]
+        else:
+            self._myprops[('Move', 'Start X')] = 99999.
+            self._myprops[('Move', 'Start Y')] = 99999.
+
+        self._myprops[('Move', 'Delta X')] = 0.
+        self._myprops[('Move', 'Delta Y')] = 0.
+
+        if self._move_step is not None:
+            self._myprops[('Move', 'Step [m]')] = self._move_step
+        else:
+            self._myprops[('Move', 'Step [m]')] = 99999.
+
         self._myprops.Populate()
         self._myprops.set_callbacks(self._callback_prop, self._callback_destroy_props)
 
-        self._myprops.SetTitle(_('Properties for all vectors in {}'.format(self.myname)))
+        self._myprops.SetTitle(_('Properties for all vectors in {}'.format(self.filename)))
         self._myprops.Center()
         self._myprops.Raise()