wolfhece 2.2.28__py3-none-any.whl → 2.2.30__py3-none-any.whl

wolfhece/PyVertexvectors.py

@@ -637,6 +637,8 @@ class vectorproperties:
 
             self.used=True
 
+            self.plot_indices = False
+
         self._values = {}
 
         # FIXME : to be changed
@@ -699,6 +701,8 @@ class vectorproperties:
         self.imagevisible = False
         self.textureimage:genericImagetexture = None
 
+        self.plot_indices = False
+
     def get_extra(self) -> list[float,float,int,float,str,bool]:
         """ Return extra properties """
         return [self.legendlength,
@@ -706,7 +710,8 @@ class vectorproperties:
                 self.legendpriority,
                 self.legendorientation,
                 str(self.attachedimage),
-                self.imagevisible]
+                self.imagevisible,
+                self.plot_indices]
 
     def set_extra(self, linesextra:list[float,float,int,float,str,bool] = None):
         """ Set extra properties """
@@ -725,6 +730,9 @@ class vectorproperties:
             self.attachedimage = Path(linesextra[4])
             self.imagevisible = linesextra[5].lower() == 'true'
 
+        if len(linesextra)>6:
+            self.plot_indices = linesextra[6].lower() == 'true'
+
     def load_extra(self, lines:list[str]) -> int:
         """ Load extra properties from lines """
 
@@ -817,7 +825,7 @@ class vectorproperties:
 
         self.color = getIfromRGB(props[('Draw','Color')])
         self.width = props[('Draw','Width')]
-        self.style = props[('Draw','Style')]
+        # self.style = props[('Draw','Style')]
 
         old_closed = self.closed
         self.closed = props[('Draw','Closed')]
@@ -828,7 +836,8 @@ class vectorproperties:
         self.filled = props[('Draw','Filled')]
         self.transparent = props[('Draw','Transparent')]
         self.alpha = props[('Draw','Alpha')]
-        self.flash = props[('Draw','Flash')]
+        # self.flash = props[('Draw','Flash')]
+        self.plot_indices = props[('Draw','Plot indices if active')]
 
         self.legendunderlined = props[('Legend','Underlined')]
         self.legendbold = props[('Legend','Bold')]
@@ -928,14 +937,18 @@ class vectorproperties:
 
             self.myprops.hide_selected_buttons() # only 'Apply' button
 
+        self.myprops.addparam('Geometry','Length 2D',99999.,Type_Param.Float,'',whichdict='Default')
+        self.myprops.addparam('Geometry','Length 3D',99999.,Type_Param.Float,'',whichdict='Default')
+        self.myprops.addparam('Geometry','Surface',99999.,Type_Param.Float,'',whichdict='Default')
+
         self.myprops.addparam('Draw','Color',(0,0,0),'Color','Drawing color',whichdict='Default')
         self.myprops.addparam('Draw','Width',1,'Integer','Drawing width',whichdict='Default')
-        self.myprops.addparam('Draw','Style',1,'Integer','Drawing style',whichdict='Default')
+        # self.myprops.addparam('Draw','Style',1,'Integer','Drawing style',whichdict='Default')
         self.myprops.addparam('Draw','Closed',False,'Logical','',whichdict='Default')
         self.myprops.addparam('Draw','Filled',False,'Logical','',whichdict='Default')
         self.myprops.addparam('Draw','Transparent',False,'Logical','',whichdict='Default')
         self.myprops.addparam('Draw','Alpha',0,'Integer','Transparency intensity (255 is opaque)',whichdict='Default')
-        self.myprops.addparam('Draw','Flash',False,'Logical','',whichdict='Default')
+        # self.myprops.addparam('Draw','Flash',False,'Logical','',whichdict='Default')
 
         self.myprops.addparam('Legend','Visible',False,'Logical','',whichdict='Default')
 
@@ -991,10 +1004,6 @@ if :\n \
         self.myprops.addparam('Image','Attached image','',Type_Param.File, '', whichdict='Default')
         self.myprops.addparam('Image','To show',False,Type_Param.Logical,'',whichdict='Default')
 
-        self.myprops.addparam('Geometry','Length 2D',99999.,Type_Param.Float,'',whichdict='Default')
-        self.myprops.addparam('Geometry','Length 3D',99999.,Type_Param.Float,'',whichdict='Default')
-        self.myprops.addparam('Geometry','Surface',99999.,Type_Param.Float,'',whichdict='Default')
-
     def destroyprop(self):
         """
         Nullify the properties UI
@@ -1063,14 +1072,20 @@ if :\n \
         """ Update the properties """
 
         if self.myprops is not None:
+            self.parent.update_lengths()
+            self.myprops[( 'Geometry','Length 2D')] = self.parent.length2D if self.parent.length2D is not None else 0.
+            self.myprops[( 'Geometry','Length 3D')] = self.parent.length3D if self.parent.length3D is not None else 0.
+            self.myprops[( 'Geometry','Surface')] = self.parent.area if self.parent.area is not None else 0.
+
             self.myprops[('Draw','Color')]      = getRGBfromI(self.color)
             self.myprops[('Draw','Width')]      = self.width
-            self.myprops[('Draw','Style')]      = self.style
+            # self.myprops[('Draw','Style')]      = self.style
             self.myprops[('Draw','Closed')]     = self.closed
             self.myprops[('Draw','Filled')]     = self.filled
             self.myprops[('Draw','Transparent')]= self.transparent
             self.myprops[('Draw','Alpha')]          = self.alpha
-            self.myprops[('Draw','Flash')]      = self.flash
+            # self.myprops[('Draw','Flash')]      = self.flash
+            self.myprops[('Draw','Plot indices if active')]       = self.plot_indices
 
             self.myprops[('Legend','Visible')]  = self.legendvisible
             self.myprops[('Legend','Text')]     = self.legendtext
@@ -1123,11 +1138,6 @@ if :\n \
             self.myprops[('Move','Delta X')] = 0.
             self.myprops[('Move','Delta Y')] = 0.
 
-            self.parent.update_lengths()
-            self.myprops[( 'Geometry','Length 2D')] = self.parent.length2D if self.parent.length2D is not None else 0.
-            self.myprops[( 'Geometry','Length 3D')] = self.parent.length3D if self.parent.length3D is not None else 0.
-            self.myprops[( 'Geometry','Surface')] = self.parent.area if self.parent.area is not None else 0.
-
             self.myprops.Populate()
 class vector:
     """
@@ -2124,6 +2134,99 @@ class vector:
                 else:
                     return [self.myvertices]
 
+    def _plot_square_at_vertices(self, size=5):
+        """
+        Plot small squares at each vertex, in OpenGL
+        """
+
+        if self.nbvertices == 0:
+            return
+
+        curvert: wolfvertex
+        ongoing = True
+
+        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
+        # if filled:
+        #     glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
+
+        glPointSize(size)
+        rgb = getRGBfromI(self.myprop.color)
+        glBegin(GL_POINTS)
+        for curvert in self.myvertices:
+            glColor3ub(int(rgb[0]), int(rgb[1]), int(rgb[2]))
+            glVertex2f(curvert.x, curvert.y)
+        glEnd()
+
+        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
+
+        ongoing = False
+
+    def _plot_index_vertex(self, idx:int = None, xy:tuple[float,float] = None,
+                           sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None):
+        """
+        Plot OpenGL
+
+        :param idx: index of the vertex to plot
+        :param xy: coordinates (x,y) of the vertex to plot
+        :param sx: scale x
+        :param sy: scale y
+        :param xmin: minimum x
+        :param ymin: minimum y
+        :param xmax: maximum x
+        :param ymax: maximum y
+        :param size: size of the text
+        """
+        if self.get_mapviewer() is None:
+            logging.warning(_('No mapviewer available for legend plot'))
+            return
+
+        if xy is not None:
+            x, y = xy
+            curvert = self.find_nearest_vert(x, y)
+            idx = self.myvertices.index(curvert)
+        elif idx is not None:
+            if idx < 0 or idx >= self.nbvertices:
+                logging.warning(_('Index {} out of range for vector {}').format(idx, self.myname))
+                return
+            curvert = self.myvertices[idx]
+        else:
+            logging.warning(_('No index or coordinates provided for plotting index vertex'))
+            return
+
+        if not (xmin is None or ymin is None or xmax is None or ymax is None):
+            if curvert.x < xmin or curvert.x > xmax or curvert.y < ymin or curvert.y > ymax:
+                logging.debug(_('Vertex {} at ({},{}) is out of bounds ({},{},{},{}))'.format(idx, curvert.x, curvert.y, xmin, ymin, xmax, ymax)))
+                return
+
+        self._textimage = Text_Image_Texture(str(idx+1),
+                                            self.get_mapviewer(), # mapviewer de l'instance Zones qui contient le vecteur
+                                            self._get_textfont_idx(),
+                                            self,
+                                            curvert.x,
+                                            curvert.y)
+        self._textimage.paint()
+
+    def _plot_all_indices(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None):
+        """
+        Plot all indices of the vertices in OpenGL
+        :param sx: scale x
+        :param sy: scale y
+        :param xmin: minimum x
+        :param ymin: minimum y
+        :param xmax: maximum x
+        :param ymax: maximum y
+        :param size: size of the text
+        """
+        if self.get_mapviewer() is None:
+            logging.warning(_('No mapviewer available for legend plot'))
+            return
+        if self.nbvertices == 0:
+            logging.warning(_('No vertices to plot indices for vector {}').format(self.myname))
+            return
+        if self.myprop.used:
+            for idx in range(self.nbvertices):
+                self._plot_index_vertex(idx=idx, sx=sx, sy=sy, xmin=xmin, ymin=ymin, xmax=xmax, ymax=ymax, size=size)
+
     def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None):
         """
         Plot OpenGL
@@ -2279,10 +2382,12 @@ class vector:
                     ax.fill([curvert.x for curvert in self.myvertices], [curvert.y for curvert in self.myvertices], color=(rgb[0]/255.,rgb[1]/255.,rgb[2]/255.))
             else:
                 rgb=getRGBfromI(self.myprop.color)
-                if self.myprop.transparent:
-                    ax.plot([curvert.x for curvert in self.myvertices], [curvert.y for curvert in self.myvertices], color=(rgb[0]/255.,rgb[1]/255.,rgb[2]/255.,self.myprop.alpha), linewidth=self.myprop.width)
-                else:
-                    ax.plot([curvert.x for curvert in self.myvertices], [curvert.y for curvert in self.myvertices], color=(rgb[0]/255.,rgb[1]/255.,rgb[2]/255.), linewidth=self.myprop.width)
+                subpoly = self.get_subpolygons()
+                for curpoly in subpoly:
+                    if self.myprop.transparent:
+                        ax.plot([curvert.x for curvert in curpoly], [curvert.y for curvert in curpoly], color=(rgb[0]/255.,rgb[1]/255.,rgb[2]/255.,self.myprop.alpha), linewidth=self.myprop.width)
+                    else:
+                        ax.plot([curvert.x for curvert in curpoly], [curvert.y for curvert in curpoly], color=(rgb[0]/255.,rgb[1]/255.,rgb[2]/255.), linewidth=self.myprop.width)
 
             self.plot_legend_mpl(ax)
 
@@ -2302,6 +2407,21 @@ class vector:
 
         return tinfos
 
+    def _get_textfont_idx(self):
+        """ Retunr a 'Text_Infos' instance for the legend """
+
+        r,g,b = getRGBfromI(self.myprop.color)
+        tinfos =  Text_Infos(3,
+                             (1., 0.),
+                             self.myprop.legendfontname,
+                             12,
+                             colour=(r,g,b,255),
+                             dimsreal=(self.myprop.legendlength,
+                                       self.myprop.legendheight),
+                             relative_position=7)
+
+        return tinfos
+
     def add2tree(self, tree:TreeListCtrl, root):
         """
         Ajout de l'objte à un TreeListCtrl wx
@@ -2474,6 +2594,13 @@ class vector:
         """
         Retrouve le segment associé aux paramètres passés
         """
+
+        if self.length2D is None or self.length3D is None:
+            self.update_lengths()
+        else:
+            if len(self._lengthparts2D) != self.nbvertices-1 or len(self._lengthparts3D) != self.nbvertices-1:
+                self.update_lengths()
+
         if is3D:
             length = self.length3D
             lengthparts = self._lengthparts3D
@@ -2481,15 +2608,6 @@ class vector:
             length = self.length2D
             lengthparts = self._lengthparts2D
 
-        if length is None:
-            self.update_lengths()
-            if is3D:
-                length = self.length3D
-                lengthparts = self._lengthparts3D
-            else:
-                length = self.length2D
-                lengthparts = self._lengthparts2D
-
         cums = np.cumsum(lengthparts)
 
         if adim:
@@ -2508,7 +2626,7 @@ class vector:
 
         if frombegin:
             k=0
-            while s>cums[k]:
+            while s>cums[k] and k < self.nbvertices-2:
                 k+=1
         else:
             k=self.nbvertices-2
@@ -4748,19 +4866,23 @@ class zone:
         veccenter = self.myvectors[0]
         veccenter.update_lengths()
 
+        logging.info(_('Length of the center vector: {}').format(veccenter.length2D))
+
         # Returned zone
         myparallels = zone()
 
         if interval_parallel is None :
+            logging.warning(_('Interval between parallels is not defined --> set to farthest_parallel'))
             interval_parallel : farthest_parallel
 
         if interval_parallel > farthest_parallel:
-            logging.warning(_('dspar is greater than dpar --> dspar is set to dpar'))
+            logging.warning(_('Interval between parallels is greater than farthest_parallel --> set to farthest_parallel'))
             interval_parallel = farthest_parallel
 
         # All parallel distances
         all_par = np.arange(0, farthest_parallel, interval_parallel)[1:]
         all_par = np.concatenate((all_par,[farthest_parallel]))
+        logging.info(_('All parallel distances: {}').format(all_par))
 
         for curpar in tqdm(all_par):
             # add current parallel to the dicts
@@ -4775,22 +4897,28 @@ class zone:
                 #
                 # gestion de vecteurs d'intersection
                 for curint in intersect.myvectors:
+                    if not curint.used:
+                        continue
+
                     # bouclage sur les vecteurs
-                    curint2 = curint.parallel_offset(eps_offset, side='right')
+                    curint1 = curint.parallel_offset(-eps_offset/2., side='left')
+                    curint2 = curint.parallel_offset( eps_offset/2., side='right')
 
                     # recherche si une intersection existe
-                    pt, dist = vecleft[curpar].intersection(curint, eval_dist=True, force_single=True)
+                    pt, dist = vecleft[curpar].intersection(curint1, eval_dist=True, force_single=True)
                     if pt is not None:
+                        logging.debug(_('Intersection found on left parallel at distance {}').format(dist))
                         #Une intersection existe --> on ajoute la portion de vecteur
 
                         # Projection du point d'intersection sur le vecteur à suivre
-                        curls = curint.asshapely_ls()
-                        dist2 = curls.project(pt)
+                        dist2 = curint1.linestring.project(pt)
+
                         # recherche de la portion de vecteur
                         # subs = extrêmité -> intersection
                         # subs_inv = intersection -> extrêmité
-                        subs  = curint.substring(0. , dist2, is3D=False, adim=False)
+                        subs  = curint1.substring(0. , dist2, is3D=False, adim=False)
                         subs.reverse()
+
                         subs2 = curint2.substring(0., dist2, is3D=False, adim=False)
 
                         vec1 = vecleft[curpar].substring(0., dist, is3D=False, adim=False)
@@ -4805,13 +4933,19 @@ class zone:
                         # mise à jour des caractéristiques
                         vecleft[curpar].find_minmax()
                         vecleft[curpar].update_lengths()
+                        vecleft[curpar].reset_linestring()
+                        curint1.reset_linestring()
+                        curint2.reset_linestring()
 
-                    pt, dist = vecright[curpar].intersection(curint, eval_dist=True, force_single=True)
+                    pt, dist = vecright[curpar].intersection(curint1, eval_dist=True, force_single=True)
                     if pt is not None:
-                        curls = curint.asshapely_ls()
-                        dist2 = curls.project(pt)
+                        logging.debug(_('Intersection found on right parallel at distance {}').format(dist))
+
+                        dist2 = curint1.linestring.project(pt)
+
                         #Une intersection existe --> on ajoute la portion de vecteur
-                        subs = curint.substring(0., dist2, is3D=False, adim=False)
+                        subs  = curint1.substring(0., dist2, is3D=False, adim=False)
+
                         subs2 = curint2.substring(0., dist2, is3D=False, adim=False)
                         subs2.reverse()
 
@@ -4820,8 +4954,11 @@ class zone:
 
                         vecright[curpar].myvertices = vec1.myvertices.copy() + subs2.myvertices.copy() + subs.myvertices.copy() + vec2.myvertices.copy()
 
-                        vecright[curpar].update_lengths()
                         vecright[curpar].find_minmax()
+                        vecright[curpar].update_lengths()
+                        vecright[curpar].reset_linestring()
+                        curint1.reset_linestring()
+                        curint2.reset_linestring()
 
         #Shapely LineString
         lsl:dict[str,LineString] = {key:vec.asshapely_ls() for key,vec in vecleft.items()}
@@ -4840,7 +4977,7 @@ class zone:
         ptsc  = [veccenter.interpolate(curs, is3D=False, adim=False) for curs in sloc]
         ptsc2 = [veccenter.interpolate(curs, is3D=False, adim=False) for curs in sloc2]
 
-        sc = [lsc.project(Point(curs.x, curs.y)) for curs in ptsc]
+        sc  = [lsc.project(Point(curs.x, curs.y)) for curs in ptsc]
         sc2 = [lsc.project(Point(curs.x, curs.y)) for curs in ptsc2]
 
         #Real distances along left, right and center vector
@@ -4881,9 +5018,9 @@ class zone:
 
         if howmanypoly==1:
             #un seul polygone sur base des // gauche et droite
-            zonepoly = zone(name='polygons_'+self.myname,parent=self.parent)
+            zonepoly = zone(name='polygons_'+self.myname, parent=self.parent)
 
-            self.parent.add_zone(zonepoly)
+            self.parent.add_zone(zonepoly, forceparent=True)
 
             for i in range(nb):
                 ptc1 = sc[i]
@@ -4917,16 +5054,16 @@ class zone:
                 #force to close the polygon
                 curvec.close_force()
                 #add vector to zone
-                zonepoly.add_vector(curvec)
+                zonepoly.add_vector(curvec, forceparent=True)
 
             #force to update minmax in the zone --> mandatory to plot
             zonepoly.find_minmax(True)
         else:
             #deux polygones sur base des // gauche et droite
-            zonepolyleft = zone(name='polygons_left_'+self.myname,parent=self.parent)
-            zonepolyright = zone(name='polygons_right_'+self.myname,parent=self.parent)
-            self.parent.add_zone(zonepolyleft)
-            self.parent.add_zone(zonepolyright)
+            zonepolyleft = zone(name='polygons_left_'+self.myname, parent=self.parent)
+            zonepolyright = zone(name='polygons_right_'+self.myname, parent=self.parent)
+            self.parent.add_zone(zonepolyleft, forceparent=True)
+            self.parent.add_zone(zonepolyright, forceparent=True)
 
             for i in range(nb):
                 ptc1 = sc[i]
@@ -4938,8 +5075,8 @@ class zone:
 
                 #mean distance along center will be stored as Z value of each vertex
                 smean =(ptc1+ptc2)/2.
-                curvecleft=vector(name='poly'+str(i+1),parentzone=zonepolyleft)
-                curvecright=vector(name='poly'+str(i+1),parentzone=zonepolyright)
+                curvecleft=vector(name='poly'+str(i+1), parentzone=zonepolyleft)
+                curvecright=vector(name='poly'+str(i+1), parentzone=zonepolyright)
 
                 #Substring for Left and Right
                 sublsl=vecleft[farthest_parallel].substring(pt1[-1], pt2[-1], is3D=False, adim=False)
@@ -4957,8 +5094,8 @@ class zone:
                 downl.reverse()
                 downr = [wolfvertex(pt[i].x, pt[i].y) for pt in ptr2.values()]
 
-                curvecleft.myvertices  = sublsl.myvertices.copy() + downl[1:-1].copy() + [sublscr.myvertices.copy()] + upl[1:-1].copy()
-                curvecright.myvertices = sublsc.myvertices.copy() + downr[1:-1].copy() + [sublsr.myvertices.copy()] + upr[1:-1].copy()
+                curvecleft.myvertices  = sublsl.myvertices.copy() + downl[1:-1].copy() + sublscr.myvertices.copy() + upl[1:-1].copy()
+                curvecright.myvertices = sublsc.myvertices.copy() + downr[1:-1].copy() + sublsr.myvertices.copy() + upr[1:-1].copy()
 
                 for curvert in curvecleft.myvertices:
                     curvert.z = smean
@@ -4976,6 +5113,9 @@ class zone:
 
         self._fill_structure()
 
+        if self.get_mapviewer() is not None:
+            self.get_mapviewer().Paint()
+
         return myparallels
 
     def get_values_linked_polygons(self, linked_arrays, stats=True) -> dict:
@@ -6929,7 +7069,11 @@ class Zones(wx.Frame, Element_To_Draw):
             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)
+            box_interp_indices = wx.BoxSizer(wx.HORIZONTAL)
+            box_interp_indices.Add(self.interpxyz,1,wx.EXPAND)
+
+            boxright.Add(box_interp_indices,0,wx.EXPAND)
+
 
             _sizer_ascbuffer = wx.BoxSizer(wx.HORIZONTAL)
             _sizer_ascbuffer.Add(self.sascending,1,wx.EXPAND)
@@ -7553,6 +7697,16 @@ class Zones(wx.Frame, Element_To_Draw):
             self.mapviewer.mimicme()
             self.active_zone.reset_listogl()
 
+    def OnPlotIndices(self, event:wx.MouseEvent):
+        """
+        Plot the indices of the active vector in the mapviewer
+        """
+
+        if self.wx_exists:
+            if self.verify_activevec():
+                return
+            self.mapviewer._force_to_plot_indices = True
+
     def Onzoom(self, event:wx.MouseEvent):
         """
         Zoom sur le vecteur actif dans le mapviewer
@@ -7670,6 +7824,7 @@ class Zones(wx.Frame, Element_To_Draw):
         """
 
         if self.active_zone is None:
+            logging.warning(_('No active zone - Nothing to do !'))
             return
 
         if self.wx_exists:
@@ -7679,25 +7834,81 @@ class Zones(wx.Frame, Element_To_Draw):
                 logging.warning(_('The active zone must contain 3 vectors and only 3'))
                 return
 
-            dlg=wx.NumberEntryDialog(None,_('What is the desired longitudinal size [cm] ?'),'ds','ds size',500,1,10000)
-            ret=dlg.ShowModal()
-            if ret==wx.ID_CANCEL:
-                dlg.Destroy()
-                return
+            self.active_zone.myvectors[1].update_lengths()
 
-            ds=float(dlg.GetValue())/100.
-            dlg.Destroy()
+            poly_dlg = wx.Dialog(None, title=_('Polygons from parallels options'), size=(400, 350))
+            poly_dlg.SetBackgroundColour(wx.Colour(240, 240, 240))
+            poly_sizer = wx.BoxSizer(wx.VERTICAL)
+            poly_sizer.Add(wx.StaticText(poly_dlg, label=_('Polygons from parallels options')), 0, wx.ALL | wx.CENTER, 5)
+            poly_sizer.Add(wx.StaticText(poly_dlg, label=_('This will create polygons from the parallels in the active zone')), 0, wx.ALL | wx.CENTER, 5)
+            poly_sizer.Add(wx.StaticText(poly_dlg, label=_('Please enter the parameters below:')), 0, wx.ALL | wx.CENTER, 5)
+            poly_sizer.Add(wx.StaticText(poly_dlg, label=_('Longitudinal size [cm]:')), 0, wx.ALL | wx.LEFT, 5)
+            ds_text = wx.TextCtrl(poly_dlg, value='5000')  # Default
+            poly_sizer.Add(ds_text, 0, wx.ALL | wx.EXPAND, 5)
+            poly_sizer.Add(wx.StaticText(poly_dlg, label=_('How many polygons? \n\n 1 = one large polygon from left to right\n 2 = two polygons - one left and one right')), 0, wx.ALL | wx.LEFT, 5)
+            nb_text = wx.TextCtrl(poly_dlg, value='1')  # Default
+            poly_sizer.Add(nb_text, 0, wx.ALL | wx.EXPAND, 5)
+            ok_button = wx.Button(poly_dlg, label=_('OK'))
+            ok_button.Bind(wx.EVT_BUTTON, lambda evt: self._OnCreatePolygons(evt, ds_text, nb_text, poly_dlg))
+            poly_sizer.Add(ok_button, 0, wx.ALL | wx.CENTER, 5)
+            poly_dlg.SetSizer(poly_sizer)
+            poly_dlg.Layout()
+            poly_dlg.CentreOnParent()
+            poly_dlg.ShowModal()
 
-            dlg=wx.NumberEntryDialog(None,_('How many polygons ? \n\n 1 = one large polygon from left to right\n 2 = two polygons - one left and one right'),'Number','Polygons',1,1,2)
-            ret=dlg.ShowModal()
-            if ret==wx.ID_CANCEL:
-                dlg.Destroy()
+            # dlg=wx.NumberEntryDialog(None,_('What is the desired longitudinal size [cm] ?'),'ds','ds size',500,1,10000)
+            # ret=dlg.ShowModal()
+            # if ret==wx.ID_CANCEL:
+            #     dlg.Destroy()
+            #     return
+
+            # ds=float(dlg.GetValue())/100.
+            # dlg.Destroy()
+
+            # dlg=wx.NumberEntryDialog(None,_('How many polygons ? \n\n 1 = one large polygon from left to right\n 2 = two polygons - one left and one right'),'Number','Polygons',1,1,2)
+            # ret=dlg.ShowModal()
+            # if ret==wx.ID_CANCEL:
+            #     dlg.Destroy()
+            #     return
+
+            # nb=int(dlg.GetValue())
+            # dlg.Destroy()
+
+
+    def _OnCreatePolygons(self, event:wx.MouseEvent, ds_text:wx.TextCtrl, nb_text:wx.TextCtrl, option_dialog:wx.Dialog):
+        """
+        Handle the creation of polygons based on user input from the dialog.
+        """
+
+        try:
+            ds = float(ds_text.GetValue()) / 100.0  # Convert cm to
+            nb = int(nb_text.GetValue())  # Number of polygons
+
+            if ds <= 0:
+                wx.MessageBox(_('Please enter a valid distance greater than 0.'), _('Input Error'), wx.OK | wx.ICON_ERROR)
                 return
 
-            nb=int(dlg.GetValue())
-            dlg.Destroy()
+            if ds > self.active_zone.myvectors[1].length2D:
+                wx.MessageBox(_('The distance must be less than the length of the center vector in the active zone.'), _('Input Error'), wx.OK | wx.ICON_ERROR)
+                return
 
+            if nb < 1 or nb > 2:
+                wx.MessageBox(_('Please enter a valid number of polygons (1 or 2).'), _('Input Error'), wx.OK | wx.ICON_ERROR)
+                return
+        except ValueError:
+            wx.MessageBox(_('Please enter valid numeric values for all fields.'), _('Input Error'), wx.OK | wx.ICON_ERROR)
+            return
+
+        try:
             self.active_zone.create_polygon_from_parallel(ds,nb)
+        except Exception as e:
+            logging.error(_('Error during polygon creation: {}').format(str(e)))
+
+        if self.get_mapviewer() is not None:
+            self.get_mapviewer().Paint()
+
+        option_dialog.Destroy()
+
 
     def Oncreateslidingpoly(self, event:wx.MouseEvent):
         """
@@ -7715,71 +7926,145 @@ class Zones(wx.Frame, Element_To_Draw):
             dlg.Destroy()
             return
 
-        #dialog box for length, sliding length, farthest parallel and parallel interval
-        dlg=wx.NumberEntryDialog(None,_('What is the desired longitudinal size [cm] ?'),'ds','ds size',5000,1,100000)
-        ret=dlg.ShowModal()
-        if ret==wx.ID_CANCEL:
-            dlg.Destroy()
-            return
+        option_dialog = wx.Dialog(None, title=_('Sliding polygons options'), size=(450, 520))
+        option_dialog.SetBackgroundColour(wx.Colour(240, 240, 240))
+        option_sizer = wx.BoxSizer(wx.VERTICAL)
+        option_sizer.Add(wx.StaticText(option_dialog, label=_('Sliding polygons options')), 0, wx.ALL | wx.CENTER, 5)
+        option_sizer.Add(wx.StaticText(option_dialog, label=_('This will create sliding polygons from the active vector in the active zone')), 0, wx.ALL | wx.CENTER, 5)
+        option_sizer.Add(wx.StaticText(option_dialog, label=_('Please enter the parameters below:')), 0, wx.ALL | wx.CENTER, 5)
+        option_sizer.Add(wx.StaticText(option_dialog, label=_('Longitudinal size [cm]:')), 0, wx.ALL | wx.LEFT, 5)
+        ds_text = wx.TextCtrl(option_dialog, value='5000')  # Default value in cm
+        option_sizer.Add(ds_text, 0, wx.ALL | wx.EXPAND, 5)
+        option_sizer.Add(wx.StaticText(option_dialog, label=_('Sliding length [cm]:')), 0, wx.ALL | wx.LEFT, 5)
+        sliding_text = wx.TextCtrl(option_dialog, value='5000')  # Default value
+        option_sizer.Add(sliding_text, 0, wx.ALL | wx.EXPAND, 5)
+        option_sizer.Add(wx.StaticText(option_dialog, label=_('Farthest parallel [cm]:')), 0, wx.ALL | wx.LEFT, 5)
+        farthest_text = wx.TextCtrl(option_dialog, value='10000')  # Default
+        option_sizer.Add(farthest_text, 0, wx.ALL | wx.EXPAND, 5)
+        option_sizer.Add(wx.StaticText(option_dialog, label=_('Parallel interval [cm]:')), 0, wx.ALL | wx.LEFT, 5)
+        interval_text = wx.TextCtrl(option_dialog, value='1000')  # Default
+        option_sizer.Add(interval_text, 0, wx.ALL | wx.EXPAND, 5)
+
+        intersect_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        inter_checkbox = wx.CheckBox(option_dialog, label=_('Use intersect zone if available'))
+        inter_checkbox.SetValue(True)  # Default to True
+        offset_text = wx.TextCtrl(option_dialog, value='10')  # Default offset value
+        intersect_sizer.Add(inter_checkbox, 0, wx.ALL | wx.LEFT, 5)
+        intersect_sizer.Add(wx.StaticText(option_dialog, label=_('Offset [cm]:')), 0, wx.ALL | wx.LEFT, 5)
+        intersect_sizer.Add(offset_text, 0, wx.ALL | wx.EXPAND, 5)
+        option_sizer.Add(wx.StaticText(option_dialog, label=_('If you have a zone named "intersect", you can use it to constrain the polygons.\nWhen constraint vectors are present, they cannot intersect the central vector.\nLikewise, they must be drawn moving away from the central vector.')), 0, wx.ALL | wx.CENTER, 5)
+
+        option_sizer.Add(intersect_sizer, 0, wx.ALL | wx.LEFT, 5)
+        separate_checkbox = wx.CheckBox(option_dialog, label=_('Separate left and right polygons'))
+        separate_checkbox.SetValue(False)  # Default to False
+        option_sizer.Add(separate_checkbox, 0, wx.ALL | wx.LEFT, 5)
+        ok_button = wx.Button(option_dialog, label=_('OK'))
+        ok_button.Bind(wx.EVT_BUTTON, lambda evt: self._OnCreateSlidingPolygon(evt, ds_text, sliding_text, farthest_text, interval_text, inter_checkbox, offset_text, separate_checkbox, option_dialog))
+        option_sizer.Add(ok_button, 0, wx.ALL | wx.CENTER, 5)
+        option_dialog.SetSizer(option_sizer)
+        option_dialog.Layout()
+        option_dialog.Centre()
 
-        ds=float(dlg.GetValue())/100.
+        try:
+            option_dialog.ShowModal()
+        except:
+            logging.error(_('Error during sliding polygons calculation.'))
 
-        dlg.Destroy()
+        option_dialog.Destroy()
 
-        dlg=wx.NumberEntryDialog(None,_('What is the desired sliding length [cm] ?'),'sliding','sliding size',5000,1,100000)
-        ret=dlg.ShowModal()
-        if ret==wx.ID_CANCEL:
-            dlg.Destroy()
+    def _OnCreateSlidingPolygon(self, event, ds_text, sliding_text, farthest_text, interval_text, inter_checkbox, offset_text, separate_checkbox, option_dialog:wx.Dialog):
+        """
+        Handle the creation of sliding polygons based on user input from the dialog.
+        """
+
+        try:
+            ds = float(ds_text.GetValue()) / 100.0  # Convert cm to m
+            sliding = float(sliding_text.GetValue()) / 100.0  # Convert cm
+            farthest = float(farthest_text.GetValue()) / 100.0  # Convert cm to m
+            interval = float(interval_text.GetValue()) / 100.0  # Convert cm to
+            intersect = inter_checkbox.GetValue()  # Boolean value
+            separate = separate_checkbox.GetValue()  # Boolean value
+            offset = float(offset_text.GetValue())/100.0  # Offset value in m
+        except ValueError:
+            wx.MessageBox(_('Please enter valid numeric values for all fields.'), _('Input Error'), wx.OK | wx.ICON_ERROR)
             return
 
-        sliding=float(dlg.GetValue())/100.
+        if separate:
+            howmany = 2  # Separate left and right polygons
+        else:
+            howmany = 1  # Single polygon
 
-        dlg.Destroy()
+        # #dialog box for length, sliding length, farthest parallel and parallel interval
+        # dlg=wx.NumberEntryDialog(None,_('What is the desired longitudinal size [cm] ?'),'ds','ds size',5000,1,100000)
+        # ret=dlg.ShowModal()
+        # if ret==wx.ID_CANCEL:
+        #     dlg.Destroy()
+        #     return
 
-        dlg=wx.NumberEntryDialog(None,_('What is the desired farthest parallel [cm] ?'),'farthest','farthest size',10000,1,100000)
-        ret=dlg.ShowModal()
-        if ret==wx.ID_CANCEL:
-            dlg.Destroy()
-            return
+        # ds=float(dlg.GetValue())/100.
 
-        farthest=float(dlg.GetValue())/100.
+        # dlg.Destroy()
 
-        dlg.Destroy()
+        # dlg=wx.NumberEntryDialog(None,_('What is the desired sliding length [cm] ?'),'sliding','sliding size',5000,1,100000)
+        # ret=dlg.ShowModal()
+        # if ret==wx.ID_CANCEL:
+        #     dlg.Destroy()
+        #     return
 
-        dlg=wx.NumberEntryDialog(None,_('What is the desired parallel interval [cm] ?'),'interval','interval size',int(farthest*10.),1,int(farthest*100.))
-        ret=dlg.ShowModal()
-        if ret==wx.ID_CANCEL:
-            dlg.Destroy()
-            return
+        # sliding=float(dlg.GetValue())/100.
 
-        interval=float(dlg.GetValue())/100.
+        # dlg.Destroy()
 
-        dlg.Destroy()
+        # dlg=wx.NumberEntryDialog(None,_('What is the desired farthest parallel [cm] ?'),'farthest','farthest size',10000,1,100000)
+        # ret=dlg.ShowModal()
+        # if ret==wx.ID_CANCEL:
+        #     dlg.Destroy()
+        #     return
 
-        zones_names=[curz.myname for curz in self.myzones]
-        if "intersect" in zones_names:
-            dlg = wx.MessageDialog(None,_('Do you want to use the intersect zone ?'),style=wx.YES_NO)
-            ret=dlg.ShowModal()
-            if ret==wx.ID_YES:
-                inter = True
-            else:
-                inter = False
-            dlg.Destroy()
-        else:
-            inter = False
+        # farthest=float(dlg.GetValue())/100.
+
+        # dlg.Destroy()
+
+        # dlg=wx.NumberEntryDialog(None,_('What is the desired parallel interval [cm] ?'),'interval','interval size',int(farthest*10.),1,int(farthest*100.))
+        # ret=dlg.ShowModal()
+        # if ret==wx.ID_CANCEL:
+        #     dlg.Destroy()
+        #     return
+
+        # interval=float(dlg.GetValue())/100.
+
+        # dlg.Destroy()
+
+        zones_names=[curz.myname.lower() for curz in self.myzones]
+        # if "intersect" in zones_names:
+        #     dlg = wx.MessageDialog(None,_('Do you want to use the intersect zone ?'),style=wx.YES_NO)
+        #     ret=dlg.ShowModal()
+        #     if ret==wx.ID_YES:
+        #         inter = True
+        #     else:
+        #         inter = False
+        #     dlg.Destroy()
+        # else:
+        #     inter = False
 
         inter_zone = None
-        if inter:
-            inter_zone = self.myzones[zones_names.index("intersect")]
+        if intersect:
+            if "intersect" in zones_names:
+                inter_zone = self.myzones[zones_names.index("intersect")]
+
+        # dlg = wx.MessageDialog(None,_('Do you want to separate left and right polygons ?'),style=wx.YES_NO)
+        # ret=dlg.ShowModal()
+        # if ret==wx.ID_YES:
+        #     howmany = 2
+        # else:
+        #     howmany = 1
 
-        dlg = wx.MessageDialog(None,_('Do you want to separate left and right polygons ?'),style=wx.YES_NO)
-        ret=dlg.ShowModal()
-        if ret==wx.ID_YES:
-            howmany = 2
-        else:
-            howmany = 1
+        try:
+            self.active_zone.create_sliding_polygon_from_parallel(ds, sliding, farthest, interval, inter_zone, howmany, eps_offset=offset)
+        except:
+            logging.error(_('Error during sliding polygons calculation.'))
 
-        self.active_zone.create_sliding_polygon_from_parallel(ds, sliding, farthest, interval, inter_zone, howmany)
+        option_dialog.Close()
 
 
     def Oncreatebin(self,event:wx.MouseEvent):
@@ -8471,9 +8756,15 @@ class Zones(wx.Frame, Element_To_Draw):
 
             self.active_zone.reset_listogl()
             self.myzones.pop(int(self.myzones.index(self.active_zone)))
+            self.Activate_vector(None)
+            self.Activate_zone(None)
+
             self.fill_structure()
             self.find_minmax(True)
 
+            if self.get_mapviewer() is not None:
+                self.get_mapviewer().Paint()
+
     def OnClickfindactivate_vector(self, event:wx.MouseEvent):
         """
         Recherche et activation d'un vecteur dans toutes les zones
@@ -8580,11 +8871,7 @@ class Zones(wx.Frame, Element_To_Draw):
                 return
 
             curname=self.active_vector.myname
-            r = wx.MessageDialog(
-                None,
-                _('The vector {n} will be deleted. Continue?').format(n=curname),
-                style=wx.YES_NO | wx.ICON_QUESTION
-            ).ShowModal()
+            r = wx.MessageDialog(None, _('The vector {n} will be deleted. Continue?').format(n=curname), style=wx.YES_NO | wx.ICON_QUESTION).ShowModal()
 
             if r != wx.ID_YES:
                 return
@@ -8596,14 +8883,23 @@ class Zones(wx.Frame, Element_To_Draw):
 
             idx = int(actzone.myvectors.index(self.active_vector))
             if idx >= 0 and idx < actzone.nbvectors:
+                actzone.reset_listogl()
                 actzone.myvectors.pop(idx)
 
-                if actzone.nbvectors==0:
+                if actzone.nbvectors == 0:
                     self.Activate_vector(None)
+                elif idx < actzone.nbvectors:
+                    self.Activate_vector(actzone.myvectors[idx])
+                else:
+                    self.Activate_vector(actzone.myvectors[-1])
 
                 self.fill_structure()
                 self.find_minmax(True)
 
+            if self.get_mapviewer() is not None:
+                self.get_mapviewer().Paint()
+
+
     def OnClickup_vector(self, event:wx.MouseEvent):
         """Remonte le vecteur actif dans la liste de la zone"""
         if self.verify_activevec():