wolfhece 2.2.33__py3-none-any.whl → 2.2.35__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.
@@ -2681,7 +2789,7 @@ class vector:
 
         return pts
 
-    def split(self,ds, new=True):
+    def split(self, ds, new=True):
         """
         Création d'un nouveau vecteur sur base du découpage d'un autre et d'un pas spatial à respecter
         Le nouveau vecteur contient tous les points de l'ancien et des nouveaux sur base d'un découpage 3D
@@ -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/__init__.py

@@ -32,6 +32,7 @@ def ensure_ntv2grid_exists():
     files = ['be_ign_bd72lb72_etrs89lb08.tif', 'be_ign_hBG18.tif', 'be_ign_README.txt']
 
     pyproj_datadir = Path(pyproj.datadir.get_data_dir())
+    os.environ["PROJ_DATA"] = pyproj.datadir.get_data_dir()  # set the PROJ_DATA environment variable to pyproj data directory
 
     for file in files:
         if not (pyproj_datadir / file).exists():

wolfhece/analyze_poly.py

@@ -231,7 +231,7 @@ class Array_analysis_onepolygon():
 
         import plotly.express as px
 
-        fig = px.histogram(self.values('Values'), x='Values',
+        fig = px.histogram(self.values('Values'), x=self._polygon.myname,
                            nbins=bins, title='Values distribution',
                            histnorm='probability density')
 

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 2
-        self.patch = 33
+        self.patch = 35
 
     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)