wolfhece 2.2.27__py3-none-any.whl → 2.2.29__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
@@ -4111,7 +4231,7 @@ class zone:
         else:
             mypl = vector(name=self.active_vector.myname+"_duplicate")
             mypl.myvertices = [wolfvertex(cur.x,cur.y,cur.z) for cur in self.active_vector.myvertices]
-            # mypl.nbvertices = self.active_vector.nbvertices # No longer needed
+
 
         if mypl is None:
             return
@@ -4567,7 +4687,6 @@ class zone:
                     vr = sublsr.myvertices.copy()
                     vr.reverse()
                     curvec.myvertices = sublsl.myvertices.copy() + vr
-                    # curvec.nbvertices = len(curvec.myvertices) FIXME Not needed anymore
                     for curv in curvec.myvertices:
                         curv.z = smean
                 else:
@@ -4631,8 +4750,6 @@ class zone:
                         curv.z = smean
                     for curv in curvecright.myvertices:
                         curv.z = smean
-                    curvecleft.nbvertices = len(curvecleft.myvertices)
-                    curvecright.nbvertices = len(curvecright.myvertices)
                 else:
                     #left poly
                     if sublsl.geom_type=='Point':
@@ -6932,7 +7049,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)
@@ -7556,6 +7677,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

wolfhece/PyWMS.py

@@ -293,9 +293,12 @@ def getNGI(cat:Literal['orthoimage_coverage',
                 tofile=True,
                 format:Literal['image/png', 'image/GeoTIFF']='image/png') -> BytesIO:
 
-    wms=WebMapService(f'https://wms.ngi.be/inspire/ortho/service?',
-                        version='1.3.0', timeout=10)
-
+    try:
+        wms=WebMapService(f'https://wms.ngi.be/inspire/ortho/service?',
+                            version='1.3.0', timeout=10)
+    except:
+        logging.warning(_('Impossible to get data from web services'))
+        return None
     ppkm = 300
     if w is None and h is None:
         real_w = (xr-xl)/1000

wolfhece/__init__.py

@@ -11,10 +11,37 @@ except ImportError as e:
     # print(e)
     raise Exception(_('Error importing GDAL library\nPlease ensure GDAL is installed and the Python bindings are available\n\ngdal wheels can be found at https://github.com/cgohlke/geospatial-wheels'))
 
+try:
+    import pyproj
+except ImportError as e:
+    raise ImportError(_('pyproj is not installed. Please install it to use this function.')) from e
+
 from .apps.version import WolfVersion
 from packaging.version import Version
+from pathlib import Path
+
+
+def ensure_ntv2grid_exists():
+    """
+    Check if the NTV2 grid file exists in the expected location.
+    """
+
+    from shutil import copyfile
+
+    # print('Version de pyproj :', pyproj.__version__)
+    files = ['be_ign_bd72lb72_etrs89lb08.tif', 'be_ign_hBG18.tif', 'be_ign_README.txt']
+
+    pyproj_datadir = Path(pyproj.datadir.get_data_dir())
+
+    for file in files:
+        if not (pyproj_datadir / file).exists():
+            # copy the NTV2 grid file to the pyproj data directory
+            ntv2_grid_path = Path(__file__).parent / 'lb7208_ntv2' / file
+            copyfile(ntv2_grid_path, pyproj_datadir / file)
+            print(f"Copied {file} to {pyproj_datadir}")
 
 __version__ = WolfVersion().get_version()
+ensure_ntv2grid_exists()
 
 def is_enough(version: str) -> bool:
     """

wolfhece/acceptability/acceptability.py

@@ -8,7 +8,7 @@ This script and its content are protected by copyright law. Unauthorized
 copying or distribution of this file, via any medium, is strictly prohibited.
 """
 
-from .Parallels import parallel_gpd_clip, parallel_v2r, parallel_datamod 
+from .Parallels import parallel_gpd_clip, parallel_v2r, parallel_datamod
 from .func import data_modification, compute_vulnerability, compute_vulnerability4scenario
 from .func import match_vulnerability2sim, compute_acceptability, shp_to_raster, clip_layer
 from .func import Accept_Manager, cleaning_directory, EXTENT, Vulnerability_csv, compute_code
@@ -316,13 +316,13 @@ def Vulnerability(main_dir:str = 'Data',
 
     """
 
-    #Call of the Manager Class --> allows structure 
+    #Call of the Manager Class --> allows structure
     manager = Accept_Manager(main_dir,
                              Study_area,
                              scenario=scenario,
                              Vuln_csv=Vuln_csv,
                              Intermediate_csv=Intermediate_csv)
- 
+
     if not manager.check_before_vulnerability():
         logging.error("The necessary files are missing - Verify logs for more information")
         return
@@ -340,7 +340,7 @@ def Vulnerability(main_dir:str = 'Data',
         cleaning_directory(manager.TMP_SCEN_DIR)
 
         if 10 in steps or steps_vulnerability.CREATE_RASTERS_VULN in steps:
-            compute_vulnerability(manager) 
+            compute_vulnerability(manager)
             done.append(steps_vulnerability.CREATE_RASTERS_VULN)
 
         if 11 in steps or steps_vulnerability.CREATE_RASTERS_CODE in steps:
@@ -382,12 +382,12 @@ def Vulnerability(main_dir:str = 'Data',
         if TMAX is None:
             logging.error("The file for the maximum return period is missing")
             return
-        
+
         match_vulnerability2sim(manager.SA_MASKED_RIVER,    manager.OUT_MASKED_RIVER,   TMAX)
         match_vulnerability2sim(manager.SA_VULN,            manager.OUT_VULN,           TMAX)
         match_vulnerability2sim(manager.SA_CODE,            manager.OUT_CODE,           TMAX)
         done.append(steps_vulnerability.MATCH_SIMUL)
-           
+
     if 4 in steps or steps_vulnerability.APPLY_SCENARIOSVULN in steps:
         if os.path.exists(manager.OUT_VULN):
             existence=False
@@ -398,7 +398,7 @@ def Vulnerability(main_dir:str = 'Data',
         else :
             logging.error(f"The baseline vulnerability does not exist ({manager.OUT_VULN}). Please, compute first the vulnerability without scenarios vuln_.")
         done.append(steps_vulnerability.APPLY_SCENARIOSVULN)
-    #Delete _scenario folder is no scenario  
+    #Delete _scenario folder is no scenario
     if os.path.isdir(manager.OUT_WITHVULN) and not os.listdir(manager.OUT_WITHVULN):
             os.rmdir(manager.OUT_WITHVULN)
     return done
@@ -409,7 +409,7 @@ def Acceptability(main_dir:str = 'Vesdre',
                   coeff_auto:bool = True,
                   Ponderation_csv:str = 'Ponderation.csv',
                   resample_size:int = 100,
-                  steps:list[int] | list[steps_acceptability] = [1,2,3,4,5,6]): 
+                  steps:list[int] | list[steps_acceptability] = [1,2,3,4,5,6]):
     """ Compute acceptability for the scenario """
 
     done = []
@@ -418,30 +418,35 @@ def Acceptability(main_dir:str = 'Vesdre',
                              Study_area,
                              scenario=scenario,
                              Ponderation_csv=Ponderation_csv)
-    
-    # Load the vulnerability raster **for the scenario**, and check if an assembly exists and is asked by the user 
-    # Initialization of lists to read/ write according to the needed steps   
+
+    # Load the vulnerability raster **for the scenario**, and check if an assembly exists and is asked by the user
+    # Initialization of lists to read/ write according to the needed steps
     VulneToCompute, PathsToSaveA, PathsToSaveA100 = [], [], []
-    if 4 in steps or steps_acceptability.COMPUTE_BASELINE_WITHOUT_SCENARIOS in steps: 
+    if 4 in steps or steps_acceptability.COMPUTE_BASELINE_WITHOUT_SCENARIOS in steps:
         VulneToCompute.append(manager.OUT_VULN)
         PathsToSaveA.append(manager.OUT_ACCEPT)
         PathsToSaveA100.append(manager.OUT_ACCEPT_RESAMP)
         river_trace = manager.OUT_MASKED_RIVER
 
-    if 5 in steps or steps_acceptability.COMPUTE_WITH_SCENARIOS in steps: 
-        river_trace = manager.wich_river_trace()        
+    if 5 in steps or steps_acceptability.COMPUTE_WITH_SCENARIOS in steps:
+        river_trace = manager.wich_river_trace()
         change_vuln_files = [Path(a) for a in glob.glob(str(manager.IN_CH_SA_SC / "vuln_*.tif")) + glob.glob(str(manager.IN_CH_SA_SC / "vuln_*.tiff"))]
         if len(change_vuln_files) != 0:
             VulneToCompute.append(manager.OUT_VULN_Stif)
             PathsToSaveA.append(manager.OUT_ACCEPT_Stif)
             PathsToSaveA100.append(manager.OUT_ACCEPT_RESAMP_Stif)
-        else : 
+        else :
             logging.info("No vulnerability rasters in CHANGE_VULNE. The code goes on without them.")
+
+    if len(VulneToCompute) == 0:
+        logging.error("No vulnerability rasters to compute acceptability. Please, compute the vulnerability first.")
+        return done
+
     for i in range(len(VulneToCompute)) :
         vulne = gdal.Open(str(VulneToCompute[i]))
         saveA = PathsToSaveA[i]
         saveA100 = PathsToSaveA100[i]
-        # Load the river mask     
+        # Load the river mask
         riv = gdal.Open(str(river_trace))
 
         # Get the geotransform and projection for the output tiff
@@ -566,7 +571,7 @@ def Acceptability(main_dir:str = 'Vesdre',
 
                 comb += part_accept[curT] * float(pond["Ponderation"][curT])
 
-            y_pixels, x_pixels = comb.shape 
+            y_pixels, x_pixels = comb.shape
 
             driver = gdal.GetDriverByName('GTiff')
 
@@ -583,14 +588,14 @@ def Acceptability(main_dir:str = 'Vesdre',
             dataset.SetGeoTransform(geotrans)
             dataset.SetProjection(proj)
             band = dataset.GetRasterBand(1)
-            band.WriteArray(comb)  
-            band.FlushCache()  
+            band.WriteArray(comb)
+            band.FlushCache()
             dataset.SetGeoTransform(geotrans)
             dataset.SetProjection(proj)
             dataset = None
 
             done.append(steps_acceptability.COMPUTE_MEAN_ACCEPT)
-        
+
         if 6 in steps or steps_acceptability.RESAMPLING in steps:
             if os.path.exists(manager.OUT_ACCEPT):
                 Agg = gdal.Warp(str(saveA100),