wolfhece 2.2.33__py3-none-any.whl → 2.2.34__py3-none-any.whl

wolfhece/PyVertexvectors.py

@@ -705,10 +705,17 @@ class vectorproperties:
         self.attachedimage = None
         self.imagevisible = False
         self.textureimage:genericImagetexture = None
+        self.image_scale = 1.0
+        self.image_relative_posx = 0.0
+        self.image_relative_posy = 0.0
+        self.image_attached_pointx = -99999.
+        self.image_attached_pointy = -99999.
 
         self.plot_indices = False
 
-    def get_extra(self) -> list[float,float,int,float,str,bool]:
+        self._cached_offset = None
+
+    def get_extra(self) -> list[float,float,int,float,str,bool, float, float, float, float, float]:
         """ Return extra properties """
         return [self.legendlength,
                 self.legendheight,
@@ -716,9 +723,15 @@ class vectorproperties:
                 self.legendorientation,
                 str(self.attachedimage),
                 self.imagevisible,
-                self.plot_indices]
-
-    def set_extra(self, linesextra:list[float,float,int,float,str,bool] = None):
+                self.plot_indices,
+                self.image_scale,
+                self.image_relative_posx,
+                self.image_relative_posy,
+                self.image_attached_pointx,
+                self.image_attached_pointy
+                ]
+
+    def set_extra(self, linesextra:list[float,float,int,float,str,bool, float, float, float, float, float] = None):
         """ Set extra properties """
 
         if linesextra is None:
@@ -728,7 +741,7 @@ class vectorproperties:
 
         self.legendlength = float(linesextra[0])
         self.legendheight = float(linesextra[1])
-        self.legendpriority = float(linesextra[2])
+        self.legendpriority = int(linesextra[2])
         self.legendorientation = float(linesextra[3])
 
         if len(linesextra)>4:
@@ -738,6 +751,13 @@ class vectorproperties:
         if len(linesextra)>6:
             self.plot_indices = linesextra[6].lower() == 'true'
 
+        if len(linesextra)>7:
+            self.image_scale = float(linesextra[7])
+            self.image_relative_posx = float(linesextra[8])
+            self.image_relative_posy = float(linesextra[9])
+            self.image_attached_pointx = float(linesextra[10])
+            self.image_attached_pointy = float(linesextra[11])
+
     def load_extra(self, lines:list[str]) -> int:
         """ Load extra properties from lines """
 
@@ -802,6 +822,18 @@ class vectorproperties:
 
                     (xmin,xmax),(ymin,ymax) = self.parent.get_bounds_xx_yy()
 
+                    if self.textureimage is not None:
+                        if self.textureimage.imageFile == self.attachedimage:
+                            self.textureimage.drawing_scale = self.image_scale
+                            self.textureimage.offset = (self.image_relative_posx, self.image_relative_posy)
+                            self.textureimage.xmin = xmin
+                            self.textureimage.xmax = xmax
+                            self.textureimage.ymin = ymin
+                            self.textureimage.ymax = ymax
+                            return
+                        else:
+                            self.textureimage.unload()
+
                     self.textureimage = genericImagetexture(which = 'attachedfile',
                                                             label=self.parent.myname,
                                                             mapviewer= self.parent.get_mapviewer(),
@@ -809,8 +841,9 @@ class vectorproperties:
                                                             xmin=xmin,
                                                             xmax=xmax,
                                                             ymin=ymin,
-                                                            ymax=ymax)
-                    # self.textureimage.load(str(self.textureimage))
+                                                            ymax=ymax,
+                                                            drawing_scale= self.image_scale,
+                                                            offset = (self.image_relative_posx, self.image_relative_posy))
                 else:
                     logging.warning('Image not found : {}'.format(self.attachedimage))
         else:
@@ -865,6 +898,11 @@ class vectorproperties:
 
         self.attachedimage = Path(props[('Image','Attached image')])
         self.imagevisible = props[('Image','To show')]
+        self.image_scale = props[('Image','Scale')]
+        self.image_relative_posx = props[('Image','Relative position X')]
+        self.image_relative_posy = props[('Image','Relative position Y')]
+        self.image_attached_pointx = props[('Image','Attached point X')]
+        self.image_attached_pointy = props[('Image','Attached point Y')]
 
         posx = props[('Move','Start X')]
         posy = props[('Move','Start Y')]
@@ -1008,6 +1046,11 @@ 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('Image','Scale',1.0,Type_Param.Float,'',whichdict='Default')
+        self.myprops.addparam('Image','Relative position X',0.0,Type_Param.Float,'',whichdict='Default')
+        self.myprops.addparam('Image','Relative position Y',0.0,Type_Param.Float,'',whichdict='Default')
+        self.myprops.addparam('Image','Attached point X',-99999.,Type_Param.Float,'',whichdict='Default')
+        self.myprops.addparam('Image','Attached point Y',-99999.,Type_Param.Float,'',whichdict='Default')
 
     def destroyprop(self):
         """
@@ -1113,6 +1156,11 @@ if :\n \
 
             self.myprops[('Image','Attached image')] = str(self.attachedimage)
             self.myprops[('Image','To show')] = self.imagevisible
+            self.myprops[('Image','Scale')] = self.image_scale
+            self.myprops[('Image','Relative position X')] = self.image_relative_posx
+            self.myprops[('Image','Relative position Y')] = self.image_relative_posy
+            self.myprops[('Image','Attached point X')] = self.image_attached_pointx
+            self.myprops[('Image','Attached point Y')] = self.image_attached_pointy
 
             if self.parent._rotation_center is not None:
                 self.myprops[('Rotation','center X')] = self.parent._rotation_center[0]
@@ -1144,6 +1192,31 @@ if :\n \
             self.myprops[('Move','Delta Y')] = 0.
 
             self.myprops.Populate()
+
+    def update_image_texture(self):
+        """ Update the image texture if it exists """
+        if self.textureimage is not None:
+            (xmin, xmax), (ymin, ymax) = self.parent.get_bounds_xx_yy()
+            self.textureimage.xmin = xmin
+            self.textureimage.xmax = xmax
+            self.textureimage.ymin = ymin
+            self.textureimage.ymax = ymax
+            self.textureimage.drawing_scale = self.image_scale
+            self.textureimage.offset = (self.image_relative_posx, self.image_relative_posy)
+
+    def _offset_image_texture(self, delta_x:float, delta_y:float):
+        """ Offset the image texture by a delta in x and y direction """
+
+        if self._cached_offset is None:
+            self._cached_offset = (self.image_relative_posx, self.image_relative_posy)
+
+        self.image_relative_posx = self._cached_offset[0] + delta_x
+        self.image_relative_posy = self._cached_offset[1] + delta_y
+
+    def _reset_cached_offset(self):
+        """ Reset the cached offset for the image texture """
+        self._cached_offset = None
+
 class vector:
     """
     Objet de gestion d'informations vectorielles
@@ -1419,11 +1492,13 @@ class vector:
         """ Set the cache for the vertices """
 
         self._cache_vertices = self.asnparray3d()
+        self._cache_bounds = np.array([[self.xmin, self.xmax], [self.ymin, self.ymax]])
 
     def clear_cache(self):
         """ Clear the cache for the vertices """
 
         self._cache_vertices = None
+        self._cache_bounds = None
 
     def move(self, deltax:float, deltay:float, use_cache:bool = True, inplace:bool = True):
         """
@@ -1445,10 +1520,26 @@ class vector:
 
             if use_cache:
                 self.xy = self._cache_vertices[:,:2] + np.array([deltax, deltay])
+                self.xmin = self._cache_bounds[0,0] + deltax
+                self.xmax = self._cache_bounds[0,1] + deltax
+                self.ymin = self._cache_bounds[1,0] + deltay
+                self.ymax = self._cache_bounds[1,1] + deltay
             else:
                 for curvert in self.myvertices:
                     curvert.x += deltax
                     curvert.y += deltay
+                # update the bounds
+                self.xmin += deltax
+                self.xmax += deltax
+                self.ymin += deltay
+                self.ymax += deltay
+
+            # update the texture image position if it exists
+            if self.myprop.textureimage is not None:
+                self.myprop.textureimage.xmin = self.xmin
+                self.myprop.textureimage.xmax = self.xmax
+                self.myprop.textureimage.ymin = self.ymin
+                self.myprop.textureimage.ymax = self.ymax
 
             return self
         else:
@@ -1482,6 +1573,14 @@ class vector:
                 for curvert in self.myvertices:
                     curvert.rotate(angle, center)
 
+            self.find_minmax()
+
+            if self.myprop.textureimage is not None:
+                self.myprop.textureimage.xmin = self.xmin
+                self.myprop.textureimage.xmax = self.xmax
+                self.myprop.textureimage.ymin = self.ymin
+                self.myprop.textureimage.ymax = self.ymax
+
             return self
         else:
             new_vector = self.deepcopy_vector(self.myname + '_rotated')
@@ -2071,6 +2170,13 @@ class vector:
 
         return self.myvertices[indexmp]
 
+    def update_image_texture(self):
+        """
+        Met à jour la texture de l'image si elle existe
+        """
+
+        self.myprop.update_image_texture()
+
     def find_minmax(self, only_firstlast:bool=False):
         """
         Recherche l'extension spatiale du vecteur
@@ -2090,6 +2196,8 @@ class vector:
                 self.ymin=min(vert.y for vert in self.myvertices)
                 self.xmax=max(vert.x for vert in self.myvertices)
                 self.ymax=max(vert.y for vert in self.myvertices)
+
+            self.update_image_texture()
         else:
             self.xmin=-99999.
             self.ymin=-99999.
@@ -4135,14 +4243,14 @@ class zone:
                     self.has_legend |= curvect.myprop.legendvisible
                     self.has_image  |= curvect.myprop.imagevisible
 
-        if self.has_legend:
-            for curvect in self.myvectors:
-                curvect.plot_legend(sx, sy, xmin, ymin, xmax, ymax, size)
-
         if self.has_image:
             for curvect in self.myvectors:
                 curvect.plot_image(sx, sy, xmin, ymin, xmax, ymax, size)
 
+        if self.has_legend:
+            for curvect in self.myvectors:
+                curvect.plot_legend(sx, sy, xmin, ymin, xmax, ymax, size)
+
     def plot_matplotlib(self, ax:plt.Axes):
         """
         Plot the zone using matplotlib
@@ -6725,6 +6833,14 @@ class Zones(wx.Frame, Element_To_Draw):
 
         return minvec
 
+    def find_vector_containing_point(self, x:float, y:float) -> vector:
+        """ Trouve le prmier vecteur contenant le point (x,y) """
+        xy = Point(x, y)
+        for curzone in self.myzones:
+            for curvect in curzone.myvectors:
+                if curvect.polygon.contains(xy):
+                    return curvect
+
     def reset_listogl(self):
         """
         Reset des listes OpenGL pour toutes les zones

wolfhece/apps/version.py

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

wolfhece/textpillow.py

@@ -194,7 +194,7 @@ class Text_Infos():
         elif self.priority == Font_Priority.HEIGHT:
             self.fontsize = int(self.fontsize/scaley)
 
-        self.fontsize=min(self.fontsize,200)
+        self.fontsize=max(min(self.fontsize,200),2)
 
         self.findsize(text)
 

wolfhece/wolf_texture.py

@@ -48,12 +48,32 @@ class genericImagetexture(Element_To_Draw):
                  which: str,
                  label: str,
                  mapviewer,
-                 xmin, xmax, ymin, ymax,
-                 imageFile="",
-                 imageObj=None,
+                 xmin:float, xmax:float, ymin:float, ymax:float,
+                 imageFile:str = "",
+                 imageObj = None,
                  transparent_color = None,
                  tolerance:int = 3,
-                 replace_color = None) -> None:
+                 replace_color = None,
+                 drawing_scale:float = 1.0,
+                 offset:list[float, float] = [0.,0.]) -> None:
+
+        """ Initialize the image texture
+
+        :param which: Type of image (e.g., 'satellite', 'map', etc.)
+        :param label: Label for the texture
+        :param mapviewer: The map viewer object to which this texture belongs
+        :param xmin: Minimum X coordinate for the texture
+        :param xmax: Maximum X coordinate for the texture
+        :param ymin: Minimum Y coordinate for the texture
+        :param ymax: Maximum Y coordinate for the texture
+        :param imageFile: Optional file path to load the image from
+        :param imageObj: Optional PIL Image object to use instead of loading from file
+        :param transparent_color: Color to treat as transparent in the image
+        :param tolerance: Tolerance for color matching when replacing transparent color
+        :param replace_color: Color to replace the transparent color with
+        :param drawing_scale: Scale factor for the image
+        :param offset: Offset to apply to the texture position
+        """
 
         super().__init__(label, True, mapviewer, False)
 
@@ -61,6 +81,7 @@ class genericImagetexture(Element_To_Draw):
             self.mapviewer.canvas.SetCurrent(mapviewer.context)
         except:
             logging.error(_('Opengl setcurrent -- Do you have a active canvas ?'))
+            return
 
         self.time = None
         self.xmin = xmin
@@ -82,6 +103,9 @@ class genericImagetexture(Element_To_Draw):
         self.imageFile = imageFile
         self.myImage = imageObj
 
+        self.drawing_scale = drawing_scale
+        self.offset = offset
+
         if imageFile != "":
             if exists(imageFile):
                 try:
@@ -142,6 +166,11 @@ class genericImagetexture(Element_To_Draw):
             del self.myImage
 
     def load(self, imageFile=""):
+        """ Load the image texture into OpenGL
+
+        :param imageFile: Optional file path to load the image from
+        """
+
         if self.width == -99999 or self.height == -99999:
             return
 
@@ -167,6 +196,7 @@ class genericImagetexture(Element_To_Draw):
                 'Opengl setcurrent -- maybe a conflict with an existing opengl32.dll file - please rename the opengl32.dll in the libs directory and retry')
 
     def update_minmax(self):
+        """ Update the spatial extent of the texture based on its size """
 
         if self.myImage is None:
             return
@@ -181,7 +211,7 @@ class genericImagetexture(Element_To_Draw):
 
             self.ymax = self.ymin + dx *scale
 
-    def reload(self,xmin=-99999,xmax=-99999,ymin=-99999,ymax=-99999):
+    def reload(self, xmin=-99999, xmax=-99999, ymin=-99999, ymax=-99999):
 
         if xmin !=-99999:
             self.xmin = xmin
@@ -210,7 +240,28 @@ class genericImagetexture(Element_To_Draw):
         # Nothing to do, set during initialization phase
         pass
 
+    def uv(self, x: float, y: float) -> tuple[float, float]:
+        """ Convert coordinates to texture coordinates taking into account the texture's spatial extent,
+        the scaleing factor, and the offset.
+
+        :param x: X coordinate in pixels
+        :param y: Y coordinate in pixels
+        :return: Tuple of (u, v) texture coordinates
+        """
+        if self.width == -99999 or self.height == -99999:
+            return 0.0, 0.0
+
+        u = (x - self.offset[0] - self.xmin) / ((self.xmax - self.xmin) * self.drawing_scale)
+        v = 1.0 - (y - self.offset[1] - self.ymin) / ((self.ymax - self.ymin) * self.drawing_scale)
+
+        # Ensure u and v are within the range [0, 1]
+        u = max(0.0, min(1.0, u))
+        v = max(0.0, min(1.0, v))
+
+        return u, v
+
     def paint(self):
+        """ Paint the image texture on the OpenGL canvas """
 
         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
 
@@ -222,14 +273,31 @@ class genericImagetexture(Element_To_Draw):
         glBindTexture(GL_TEXTURE_2D, self.idtexture[0])
 
         glBegin(GL_QUADS)
-        glTexCoord2f(0.0, 0.0)
-        glVertex2f(self.xmin, self.ymax)
-        glTexCoord2f(1.0, 0.0)
-        glVertex2f(self.xmax, self.ymax)
-        glTexCoord2f(1.0, 1.0)
-        glVertex2f(self.xmax, self.ymin)
-        glTexCoord2f(0.0, 1.0)
-        glVertex2f(self.xmin, self.ymin)
+
+        # Draw a quad with texture coordinates
+        xy = [[self.xmin, self.ymax],
+              [self.xmax, self.ymax],
+              [self.xmax, self.ymin],
+              [self.xmin, self.ymin]]
+        uv = [self.uv(x,y) for x,y in xy]
+
+        glTexCoord2f(uv[0][0], uv[0][1])
+        glVertex2f(xy[0][0], xy[0][1])
+        glTexCoord2f(uv[1][0], uv[1][1])
+        glVertex2f(xy[1][0], xy[1][1])
+        glTexCoord2f(uv[2][0], uv[2][1])
+        glVertex2f(xy[2][0], xy[2][1])
+        glTexCoord2f(uv[3][0], uv[3][1])
+        glVertex2f(xy[3][0], xy[3][1])
+
+        # glTexCoord2f(0.0, 0.0)
+        # glVertex2f(self.xmin, self.ymax)
+        # glTexCoord2f(1.0, 0.0)
+        # glVertex2f(self.xmax, self.ymax)
+        # glTexCoord2f(1.0, 1.0)
+        # glVertex2f(self.xmax, self.ymin)
+        # glTexCoord2f(0.0, 1.0)
+        # glVertex2f(self.xmin, self.ymin)
         glEnd()
         glDisable(GL_TEXTURE_2D)
         glDisable(GL_BLEND)