wolfhece 2.1.46__py3-none-any.whl → 2.1.49__py3-none-any.whl

wolfhece/Coordinates_operations.py

@@ -0,0 +1,189 @@
+from pyproj import Transformer
+from concurrent.futures import ProcessPoolExecutor
+import numpy as np
+from osgeo import gdal
+import os
+import logging
+
+from .PyTranslate import _
+
+def transform_chunk_coordinates(inputEPSG:str, outputEPSG:str, chunk:np.ndarray):
+    """
+    Transforms a chunk of coordinates
+
+    :param inputEPSG: input EPSG code (e.g. "EPSG:3812")
+    :type inputEPSG: str
+    :param outputEPSG: output EPSG code (e.g. "EPSG:31370")
+    :type outputEPSG: str
+    :param chunk: list of points to be transformed
+    :type chunk: np.ndarray
+    """
+    COO_TRANSFORMER = Transformer.from_crs(inputEPSG, outputEPSG, always_xy=True)
+    return COO_TRANSFORMER.transform(chunk[:, 0], chunk[:, 1])
+
+def transform_coordinates(points:np.ndarray, inputEPSG:str="EPSG:3812", outputEPSG:str="EPSG:31370", chunk_size:int=1000):
+    """
+        Transforms coordinates in batches using multiprocessing. If more than chunk_size points are provided, the
+        function will split the points into chunks and transform them in parallel => requiring in the main script
+        to use the statement if __name__ == '__main__':.
+
+    :param points: Array of coordinates to be transformed
+    :type points: numpy.ndarray
+    :param inputEPSG: (optional) Input EPSG code. Defaults to "EPSG:3812"
+    :type inputEPSG: str
+    :param outputEPSG: (optional) Output EPSG code. Defaults to "EPSG:31370"
+    :type outputEPSG: str
+    :param chunk_size: (optional) Size of each batch for transformation. Defaults to 100000
+    :type chunk_size: int
+
+    :return numpy.ndarray: Transformed coordinates
+    """
+
+    # sanitize inputs
+    inputEPSG = str(inputEPSG)
+    outputEPSG = str(outputEPSG)
+
+    if not "EPSG" in inputEPSG or not "EPSG" in inputEPSG:
+        logging.error(_("EPSG code must be in the format 'EPSG:XXXX'"))
+        return
+
+    num_points = len(points)
+    results = []
+
+    total_steps = (num_points + chunk_size - 1) // chunk_size
+
+    if total_steps == 1:
+        result_x, result_y = transform_chunk_coordinates(inputEPSG, outputEPSG, points)
+        return np.vstack((result_x, result_y)).T
+
+    with ProcessPoolExecutor() as executor:
+        futures = []
+        for i in range(0, num_points, chunk_size):
+            chunk = points[i:i + chunk_size]
+            futures.append(executor.submit(transform_chunk_coordinates, inputEPSG, outputEPSG, chunk))
+
+        for step, future in enumerate(futures):
+            result_x, result_y = future.result()
+            results.append(np.vstack((result_x, result_y)).T)
+
+    return np.vstack(results)
+
+def reproject_and_resample_raster(input_raster_path:str, output_raster_path:str,
+                                  input_srs:str='EPSG:3812', output_srs:str='EPSG:31370',
+                                  resampling_method:str|int=gdal.GRA_Bilinear,
+                                  xRes:float=0.5, yRes:float=0.5, debug:bool=False):
+    """
+    Use gdal to open a tiff raster in a given input EPSG 'inputEPSG' and transforms the raster into another EPSG system 'outputEPSG'.
+    The resolution can be forced through xRes and yRes (the origin will be rounded to the nearest multiple of the resolution). The
+    resampling method can be chosen among the gdal GRA_* constants (gdal.GRA_Average; gdal.GRA_Bilinear; gdal.GRA_Cubic; gdal.GRA_CubicSpline;
+    gdal.GRA_Lanczos; gdal.GRA_Mode; gdal.GRA_NearestNeighbor).
+
+    :param input_raster_path: the path to the input raster file (.tif or .tiff)
+    :type input_raster_path: str
+    :param output_raster_path: the path to the output raster file (.tif or .tiff) that will be created
+    :type output_raster_path: str
+    :param input_srs: Input EPSG code. Defaults to Lambert 2008 "EPSG:3812"
+    :type input_srs: str
+    :param output_srs: Output EPSG code. Defaults to Lambert 72 "EPSG:31370"
+    :type output_srs: str
+    :param resampling_method: Resampling method. Defaults to gdal.GRA_Bilinear
+    :type resampling_method: int, str
+    :param xRes: Resolution along X. Defaults to 0.5
+    :type xRes: float
+    :param yRes: Resolution along Y. Defaults to 0.5
+    :type yRes: float
+    :param debug: If True, print debug information. Defaults to False
+    :type debug: bool
+    """
+    from osgeo import osr
+
+    # santitize inputs
+    input_raster_path = str(input_raster_path)
+    output_raster_path = str(output_raster_path)
+
+    # ATTENTION: mask values should be negative in the tiff corresponding to input_raster_path!
+    if not(input_raster_path.endswith('.tif') or input_raster_path.endswith('.tiff')):
+        logging.error(_("Input raster must be a GeoTIFF file"))
+        return
+    if not(output_raster_path.endswith('.tif') or output_raster_path.endswith('.tiff')):
+        logging.error(_("Output raster must be a GeoTIFF file"))
+        return
+
+    # check the output file
+    if os.path.exists(output_raster_path):
+        try:
+            os.remove(output_raster_path)
+        except PermissionError as e:
+            logging.error(_(f"Permission denied while trying to delete {output_raster_path}. Ensure the file is not open in another program and you have sufficient privileges."))
+            return
+        except Exception as e:
+            logging.error(_(f"An unexpected error occurred while trying to delete {output_raster_path}: {str(e)}"))
+            return
+
+    # Open the input raster
+    input_raster = gdal.Open(input_raster_path)
+    if input_raster is None:
+        logging.error(_(f"Unable to open input raster: {input_raster_path}"))
+        return
+
+    # Get the source SRS from the input raster
+    source_srs = osr.SpatialReference()
+    if debug:
+        print('Initial projection: ',input_raster.GetProjection())
+        print('set projection init: ',int(input_srs.split(':')[1]))
+    source_srs.ImportFromEPSG(int(input_srs.split(':')[1]))
+
+    # Create the target SRS
+    target_srs = osr.SpatialReference()
+    if debug:
+        print('set projection out: ',int(output_srs.split(':')[1]))
+    target_srs.ImportFromEPSG(int(output_srs.split(':')[1]))
+
+    # Define the options for the reprojection
+    # Load the initial array to obtain the origin and the limits
+    ulx, xres, xskew, uly, yskew, yres  = input_raster.GetGeoTransform()
+    Orig = np.array([[ulx,uly],
+                     [ulx+input_raster.RasterXSize*xres, uly+input_raster.RasterYSize*yres]])
+    Orig.sort(0)
+
+    # Transform the origin and the limits into the new projection 'Lambert 72'
+    Orig_out = transform_coordinates(Orig, inputEPSG=input_srs, outputEPSG=output_srs)
+
+    # Round each coordinate to the nearest multiple of the wanted resolution
+    Orig_out[:,0] = np.round(Orig_out[:,0]/xRes)*xRes
+    Orig_out[:,1] = np.round(Orig_out[:,1]/yRes)*yRes
+    if debug:
+        print(Orig_out)
+        print(tuple(Orig_out.reshape(-1)))
+
+    # Define the reprojection options
+    # outputBounds=tuple(Orig_out.reshape(-1)),
+    # xRes=xRes, yRes=yRes,
+    reproject_options = gdal.WarpOptions(
+        outputBounds=tuple(Orig_out.reshape(-1)),  # Output bounds: (minX, minY, maxX, maxY)
+        xRes=xRes, yRes=yRes,
+        srcSRS=source_srs.ExportToWkt(),
+        dstSRS=target_srs.ExportToWkt(),
+        resampleAlg=resampling_method
+    )
+
+    # Reproject and resample the input raster
+    output_raster = gdal.Warp(
+        destNameOrDestDS=output_raster_path,
+        srcDSOrSrcDSTab=input_raster,
+        options=reproject_options
+    )
+
+    if output_raster is None:
+        logging.error(_(f"Reprojection failed for input raster: {input_raster_path}"))
+        return
+
+    # Flush cache to ensure the output is written to disk
+    output_raster.FlushCache()
+
+    # Close the datasets IMPORTANT to set to None in order to close them
+    input_raster = None
+    output_raster = None
+
+    if debug:
+        print(f"Reprojection and resampling completed successfully. Output saved to: {output_raster_path}")

wolfhece/PyDraw.py

@@ -6543,6 +6543,8 @@ class WolfMapViewer(wx.Frame):
                 if myobj in curlist:
                     curlist.pop(curlist.index(myobj))
 
+            myobj.hide_properties()
+
     def upobj(self):
 
         """Up selected item into general tree"""

wolfhece/PyVertexvectors.py

@@ -885,6 +885,21 @@ if :\n \
         self.myprops.SetSizeHints(500,800)
         self.myprops.Show()
 
+        self.myprops.SetTitle(_('Vector properties - {}'.format(self.parent.myname)))
+        self.myprops.Center()
+        self.myprops.Raise()
+
+    def show_properties(self):
+        """ Show the properties -- alias of show() """
+
+        self.show()
+
+    def hide_properties(self):
+        """ Hide the properties """
+
+        if self.myprops is not None:
+            self.myprops.Hide()
+
     def _convert_fontname2int(self, fontname:str) -> int:
 
         if fontname.lower() in 'arial.ttf':
@@ -1002,6 +1017,18 @@ class vector:
         if fromshapely is not None:
             self.import_shapelyobj(fromshapely)
 
+    def show_properties(self):
+        """ Show the properties """
+
+        if self.myprop is not None:
+            self.myprop.show()
+
+    def hide_properties(self):
+        """ Hide the properties """
+
+        if self.myprop is not None:
+            self.myprop.hide_properties()
+
     def get_mapviewer(self):
         """ Return the mapviewer """
 
@@ -1652,7 +1679,7 @@ class vector:
             logging.warning(_('No mapviewer available for legend plot'))
             return
 
-        if self.myprop.legendvisible:
+        if self.myprop.legendvisible and self.myprop.used:
 
             self.textimage = Text_Image_Texture(self.myprop.legendtext,
                                                 self.get_mapviewer(), # mapviewer de l'instance Zones qui contient le vecteur
@@ -1671,7 +1698,7 @@ class vector:
             logging.warning(_('No mapviewer available for image plot'))
             return
 
-        if self.myprop.imagevisible:
+        if self.myprop.imagevisible and self.myprop.used:
 
             if self.myprop.textureimage is None:
                 self.myprop.load_unload_image()
@@ -2325,7 +2352,9 @@ class zone:
                  is2D:bool=True,
                  fromshapely:Union[LineString,Polygon,MultiLineString, MultiPolygon]=None) -> None:
 
+        self.myprop = None
         self.myprops = None
+
         self.myname = ''        # name of the zone
         self.idgllist = -99999  # id of the zone in the gllist
         self.active_vector=None # current active vector
@@ -3526,6 +3555,7 @@ class zone:
         """
         Compute statistics on values dict resulting from 'get_values_linked_polygons'
         """
+
         for curpol in vals.values():
             medianlist  =curpol['median'] = []
             meanlist = curpol['mean'] = []
@@ -3570,7 +3600,10 @@ class zone:
                         p95.append(None)
                         p5.append(None)
 
-    def plot_linked_polygons(self, fig:Figure, ax:Axes, linked_arrays:dict, linked_vec:dict[str,"Zones"]=None, linestyle:str='-', onlymedian:bool=False, withtopography:bool = True, ds:float = None):
+    def plot_linked_polygons(self, fig:Figure, ax:Axes,
+                             linked_arrays:dict, linked_vec:dict[str,"Zones"]=None,
+                             linestyle:str='-', onlymedian:bool=False,
+                             withtopography:bool = True, ds:float = None):
         """
         Création d'un graphique sur base des polygones
 
@@ -3591,6 +3624,7 @@ class zone:
         :param ds: pas spatial le long de l'axe
 
         """
+
         colors=['red','blue','green','darkviolet','fuchsia','lime']
 
         #Vérifie qu'au moins une matrice liée est fournie, sinon rien à faire
@@ -3790,16 +3824,19 @@ class zone:
 
     def reset_listogl(self):
         """
-        Reset des liste OpenGL
+        Reset OpenGL lists.
+
+        Force deletion of the OpenGL list.
+        If the object is newly plotted, the lists will be recreated.
         """
+
         if self.idgllist!=-99999:
             glDeleteLists(self.idgllist,1)
             self.idgllist=-99999
 
     def deepcopy_zone(self, name: str =None, parent: str= None):
-        """
-        Return a deep copy of the zone.
-        """
+        """ Return a deep copy of the zone"""
+
         if name is None:
             name =  self.myname + '_copy'
             if parent:
@@ -3817,9 +3854,10 @@ class zone:
     def show_properties(self):
         """ Show properties of the zone --> will be applied to all vectors int he zone """
 
-        locvec = vector()
-        locvec.myprop.show()
-        self.myprops = locvec.myprop.myprops
+        if self.myprops is None:
+            locvec = vector()
+            locvec.show_properties()
+            self.myprops = locvec.myprop.myprops
 
         self.myprops[('Legend','X')] = 99999.
         self.myprops[('Legend','Y')] = 99999.
@@ -3827,11 +3865,31 @@ class zone:
         self.myprops.Populate()
         self.myprops.set_callbacks(self._callback_prop, self._callback_destroy_props)
 
+        self.myprops.SetTitle(_('Zone properties - {}'.format(self.myname)))
+        self.myprops.Center()
+        self.myprops.Raise()
+
+    def hide_properties(self):
+        """ Hide the properties window """
+
+        if self.myprops is not None:
+            # window for general properties
+            self.myprops.Hide()
+
+        for curvect in self.myvectors:
+            curvect.hide_properties()
+
+
     def _callback_destroy_props(self):
+        """ Callback to destroy the properties window """
+
+        if self.myprops is not None:
+            self.myprops.Destroy()
 
         self.myprops = None
 
     def _callback_prop(self):
+        """ Callback to update properties """
 
         if self.myprops is None:
             logging.warning(_('No properties available'))
@@ -3848,6 +3906,7 @@ class zone:
         """
         Set the legend to the centroid of the zone
         """
+
         for curvec in self.myvectors:
             curvec.set_legend_to_centroid()
 
@@ -3914,6 +3973,8 @@ class Zones(wx.Frame, Element_To_Draw):
 
         Element_To_Draw.__init__(self, idx, plotted, mapviewer, need_for_wx)
 
+        self._myprops = None # common properties of all zones
+
         self.loaded=True
 
         self.active_vector:vector = None
@@ -4521,7 +4582,18 @@ class Zones(wx.Frame, Element_To_Draw):
           si parent est d'un autre type, il faut s'assurer que les options/actions sont consistantes
 
         """
-        self.showstructure(parent,forceupdate)
+        self.showstructure(parent, forceupdate)
+
+    def hide_properties(self):
+        """ Hide the properties window """
+
+        self.Hide()
+
+        if self._myprops is not None:
+            self._myprops.Hide()
+
+        for curzone in self.myzones:
+            curzone.hide_properties()
 
     def showstructure(self, parent=None, forceupdate=False):
         """
@@ -4547,6 +4619,8 @@ class Zones(wx.Frame, Element_To_Draw):
                 self.init_ui()
 
             self.Show()
+            self.Center()
+            self.Raise()
 
     def init_ui(self):
         """
@@ -6056,10 +6130,11 @@ class Zones(wx.Frame, Element_To_Draw):
     def _edit_all_properties(self):
         """ Show properties of the zone --> will be applied to all vectors int he zone """
 
-        locvec = vector()
-        locvec.myprop.show()
+        if self._myprops is None:
+            locvec = vector()
+            locvec.show_properties()
 
-        self._myprops = locvec.myprop.myprops
+            self._myprops = locvec.myprop.myprops
 
         self._myprops[('Legend','X')] = 99999.
         self._myprops[('Legend','Y')] = 99999.
@@ -6067,6 +6142,10 @@ class Zones(wx.Frame, Element_To_Draw):
         self._myprops.Populate()
         self._myprops.set_callbacks(self._callback_prop, self._callback_destroy_props)
 
+        self._myprops.SetTitle(_('Properties for all vectors in {}'.format(self.myname)))
+        self._myprops.Center()
+        self._myprops.Raise()
+
 
     def OnRDown(self, event:TreeListEvent):
         """
@@ -6080,7 +6159,7 @@ class Zones(wx.Frame, Element_To_Draw):
                 self._edit_all_properties()
 
             elif isinstance(self.last_active, vector):
-                self.active_vector.myprop.show()
+                self.active_vector.show_properties()
 
             elif isinstance(self.last_active, zone):
                 self.active_zone.show_properties()

wolfhece/apps/version.py

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

wolfhece/drawing_obj.py

@@ -92,6 +92,13 @@ class Element_To_Draw:
         logging.warning('No properties to show for this object !')
         pass
 
+    def hide_properties(self):
+        """
+        Generic function to hide properties of the object
+        """
+        logging.warning('No properties to hide for this object !')
+        pass
+
     def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None):
         """
         Plot data in OpenGL context
@@ -126,5 +133,5 @@ class Element_To_Draw:
         """
         if self.mapviewer is None:
             return False
-        
+
         return self.mapviewer.SetCurrentContext()

wolfhece/wolf_array.py

@@ -20,6 +20,7 @@ import numpy.ma as ma
 import math as m
 import logging
 import json
+import tempfile
 from pathlib import Path
 
 try:
@@ -45,7 +46,11 @@ from os.path import dirname,basename,join
 import logging
 from typing import Literal
 from copy import deepcopy
+from osgeo import gdal
+from enum import Enum
 
+
+from .Coordinates_operations import reproject_and_resample_raster
 from .PyTranslate import _
 from .GraphNotebook import PlotPanel
 from .CpGrid import CpGrid
@@ -90,6 +95,42 @@ WOLF_ARRAY_MB = [WOLF_ARRAY_MB_SINGLE, WOLF_ARRAY_MB_INTEGER, WOLF_ARRAY_MNAP_IN
 
 VERSION_RGB = 2
 
+class Rebin_Ops(Enum):
+    MIN = 0
+    MEAN = 1
+    MAX = 2
+    SUM = 3
+    MEDIAN = 4
+
+    @classmethod
+    def get_numpy_ops(cls):
+        """ Return a list of numpy functions corresponding to the enum values """
+
+        # CAUTION : Order is important and must match the enum values
+        return [np.ma.min, np.ma.mean, np.ma.max, np.ma.sum, np.ma.median]
+
+    @classmethod
+    def get_ops(cls, name:str):
+        """ Return the numpy function corresponding to a string """
+
+        if isinstance(name, Rebin_Ops):
+            return cls.get_numpy_ops()[name.value]
+        elif isinstance(name, str):
+            if name == 'min':
+                return np.ma.min
+            elif name == 'mean':
+                return np.ma.mean
+            elif name == 'max':
+                return np.ma.max
+            elif name == 'sum':
+                return np.ma.sum
+            elif name == 'median':
+                return np.ma.median
+            else:
+                return None
+        else:
+            return None
+
 def getkeyblock(i, addone=True) -> str:
     """
     Name/Key of a block in the dictionnary of a WolfArrayMB instance
@@ -111,6 +152,9 @@ def decodekeyblock(key, addone=True) -> int:
         return int(key[5:])
     else:
         return int(key[5:]) - 1
+
+
+
 class header_wolf():
     """
     Header of WolfArray
@@ -284,9 +328,9 @@ class header_wolf():
         """
         Set translation
 
-        :param tr_x = translation along X
-        :param tr_y = translation along Y
-        :param tr_z = translation along Z
+        :param tr_x: translation along X
+        :param tr_y: translation along Y
+        :param tr_z: translation along Z
         """
         self.translx = tr_x
         self.transly = tr_y
@@ -2277,6 +2321,15 @@ class Ops_Array(wx.Frame):
 
         self.myzones.showstructure()
 
+    def hide_properties(self):
+        """ Hide the properties panel """
+
+        try:
+            self.myzones.hide_properties()
+            self.Hide()
+        except Exception as e:
+            logging.error('Error in hide_properties : %s' % e)
+
     def OnLoadvec(self, event:wx.MouseEvent):
         """ Load vector file """
 
@@ -4396,14 +4449,24 @@ class WolfArray(Element_To_Draw, header_wolf):
 
     def __del__(self):
         """ Destructeur de la classe """
-        import gc
-        self.delete_lists()
-        del self.array
-        if VERSION_RGB==1 : del self.rgb
-        del self._array3d
-        del self.mypal
-        del self.shaded
-        gc.collect()
+        try:
+            # Perform cleanup tasks safely
+            self.delete_lists()
+            if hasattr(self, 'array'):
+                del self.array
+            if VERSION_RGB == 1 and hasattr(self, 'rgb'):
+                del self.rgb
+            if hasattr(self, '_array3d'):
+                del self._array3d
+            if hasattr(self, 'mypal'):
+                del self.mypal
+            if hasattr(self, 'shaded'):
+                del self.shaded
+            # Perform garbage collection if gc is available
+            import gc
+            gc.collect()
+        except Exception as e:
+            print(f"Exception in WolfArray destructor: {e} -- Please report this issue")
 
     def extract_selection(self):
         """ Extract the current selection """
@@ -4491,6 +4554,15 @@ class WolfArray(Element_To_Draw, header_wolf):
             self.myops.SetTitle(_('Operations on array: ') + self.idx)
             self.myops.Show()
 
+            self.myops.Center()
+            self.myops.Raise()
+
+    def hide_properties(self):
+        """ Hide the properties window """
+
+        if self.wx_exists and self.myops is not None:
+            self.myops.hide_properties()
+
     @property
     def nullvalue(self) -> float:
         """ Return the null value """
@@ -4802,7 +4874,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         if reset_plot:
             self.reset_plot()
 
-    def export_geotif(self, outdir='', extent = ''):
+    def export_geotif(self, outdir='', extent = '', EPSG:int = 31370):
         """
         Export de la matrice au format Geotiff (Lambert 72 - EPSG:31370)
 
@@ -4813,11 +4885,12 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         :param outdir: directory
         :param extent: suffix to add to the filename before the extension '.tif'
+        :param EPSG: EPSG code, by default 31370 (Lambert 72)
         """
         from osgeo import gdal, osr, gdalconst
 
         srs = osr.SpatialReference()
-        srs.ImportFromEPSG(31370)
+        srs.ImportFromEPSG(EPSG)
 
         if outdir=='' and extent=='':
             filename = self.filename
@@ -4845,7 +4918,17 @@ class WolfArray(Element_To_Draw, header_wolf):
         out_ds: gdal.Dataset
         band: gdal.Band
         driver = gdal.GetDriverByName("GTiff")
-        out_ds = driver.Create(filename, arr.shape[0], arr.shape[1], 1, arr_type, options=['COMPRESS=LZW'])
+        # bytes_per_pixel = arr.data.dtype.itemsize
+        estimated_file_size = self.memory_usage #arr.shape[0] * arr.shape[1] * bytes_per_pixel
+
+        # Check if estimated file size exceeds 4GB
+        if (estimated_file_size > 4 * 1024**3):  # 4GB in bytes
+            options = ['COMPRESS=LZW', 'BIGTIFF=YES']
+            print('BigTIFF format will be used!')
+        else:
+            options = ['COMPRESS=LZW']
+
+        out_ds = driver.Create(filename, arr.shape[0], arr.shape[1], 1, arr_type, options=options)
         out_ds.SetProjection(srs.ExportToWkt())
 
 
@@ -5109,6 +5192,10 @@ class WolfArray(Element_To_Draw, header_wolf):
         except:
             logging.warning(_('Error during importing tif file'))
 
+        # Close the raster
+        raster.FlushCache()
+        raster = None
+
     def add_ops_sel(self):
         """
         Adding selection manager and operations array
@@ -6682,11 +6769,12 @@ class WolfArray(Element_To_Draw, header_wolf):
                 if update_min_max:
                     self.mypal.distribute_values(self.array.min(), self.array.max())
 
-    def write_all(self, newpath:str = None):
+    def write_all(self, newpath:str = None, EPSG:int = 31370):
         """
         Ecriture de tous les fichiers d'un Wolf array
 
         :param newpath: new path and filename with extension -- if None, use the current filename
+        :param EPSG: EPSG code for geotiff
         """
 
         if isinstance(newpath, Path):
@@ -6696,7 +6784,7 @@ class WolfArray(Element_To_Draw, header_wolf):
             self.filename = newpath
 
         if self.filename.endswith('.tif'):
-            self.export_geotif()
+            self.export_geotif(EPSG=EPSG)
         elif self.filename.endswith('.npy'):
 
             writing_header = True
@@ -6730,18 +6818,26 @@ class WolfArray(Element_To_Draw, header_wolf):
             self.write_txt_header()
             self.write_array()
 
-    def rebin(self, factor:float, operation:Literal['mean', 'sum', 'min']='mean') -> None:
+    def get_rebin_shape_size(self, factor:float) -> tuple[tuple[int, int], tuple[float, float]]:
         """
-        Change resolution - in place
+        Return the new shape after rebinning.
 
-        :param factor: factor of resolution change -- > 1.0 : decrease resolution, < 1.0 : increase resolution
+        newdx = dx * factor
+        newdy = dy * factor
 
-        If you want to keep current data, copy the WolfArray into a new variable -> newWA = Wolfarray(mold=curWA)
+        The shape is adjusted to be a multiple of the factor.
+
+        :param factor: factor of resolution change -- > 1.0 : decrease resolution, < 1.0 : increase resolution
+        :type factor: float
+        :return: new shape
+        :rtype: Tuple[int, int]
         """
-        operation = operation.lower()
-        if not operation in ['sum', 'mean', 'min']:
-            raise ValueError("Operator not supported.")
 
+        newdx = self.dx * float(factor)
+        newdy = self.dy * float(factor)
+
+        newnbx = self.nbx
+        newnby = self.nby
         if np.mod(self.nbx,factor) != 0 or np.mod(self.nby,factor) != 0 :
             newnbx = self.nbx
             newnby = self.nby
@@ -6750,8 +6846,85 @@ class WolfArray(Element_To_Draw, header_wolf):
             if np.mod(self.nby,factor) !=0:
                 newnby = self.nby + factor - np.mod(self.nby,factor)
 
-            newarray = np.ma.zeros((newnbx,newnby))
+        newnbx = int(newnbx / factor)
+        newnby = int(newnby / factor)
+
+        return (newnbx, newnby), (newdx, newdy)
+
+    def get_rebin_header(self, factor:float) -> header_wolf:
+        """
+        Return a new header after rebinning.
+
+        :param factor: factor of resolution change -- > 1.0 : decrease resolution, < 1.0 : increase resolution
+        :type factor: float
+
+        :return: new header
+        :rtype: header_wolf
+        """
+
+        newshape, newdx_dy = self.get_rebin_shape_size(factor)
+
+        newheader = self.get_header()
+
+        newheader.nbx = newshape[0]
+        newheader.nby = newshape[1]
+        newheader.dx = newdx_dy[0]
+        newheader.dy = newdx_dy[1]
+
+        return newheader
+
+    def rebin(self,
+              factor:float,
+              operation:Literal['mean', 'sum', 'min', 'max', 'median'] ='mean',
+              operation_matrix:"WolfArray"=None) -> None:
+        """
+        Change resolution - **in place**.
+
+        If you want to keep current data, copy the WolfArray into a new variable -> newWA = Wolfarray(mold=curWA).
+
+        :param factor: factor of resolution change -- > 1.0 : decrease resolution, < 1.0 : increase resolution
+        :type factor: float
+        :param operation: operation to apply on the blocks ('mean', 'sum', 'min', 'max', 'median')
+        :type operation: str, Rebin_Ops
+        :param operation_matrix: operation matrix to apply on the blocks -- see the Enum "Rebin_Ops" for more infos. The matrix must have the same shape as the new array
+        :type operation_matrix: WolfArray
+
+        """
+
+        if operation_matrix is not None:
+            tmp_header = self.get_rebin_header(factor)
+            if not operation_matrix.is_like(tmp_header):
+                logging.error(_("The operation matrix must have the same shape as the new array"))
+                logging.info(_("You can use the get_rebin_header method to get the new header if you don't know it"))
+                return
+
+            logging.info(_("Operation matrix detected"))
+            logging.info(_("The operation matrix will be used to apply the operation on the blocks"))
+        else:
+
+            operation = Rebin_Ops.get_ops(operation)
+
+            if operation is None:
+                logging.error(_("Operator not supported -- Must be a string in ['sum', 'mean', 'min', 'max', 'median'] or a Rebin_Ops Enum"))
+                return
+
+            if not callable(operation):
+                logging.error(_("Operator not supported -- Must be a string in ['sum', 'mean', 'min', 'max', 'median'] or a Rebin_Ops Enum"))
+
+
+        if np.mod(self.nbx,factor) != 0 or np.mod(self.nby,factor) != 0 :
+            # The shape is adjusted to be a multiple of the factor.
+            # Fill the array with nullvalue
+            newnbx = self.nbx
+            newnby = self.nby
+            if np.mod(self.nbx,factor) !=0:
+                newnbx = int(self.nbx + factor - np.mod(self.nbx,factor))
+            if np.mod(self.nby,factor) !=0:
+                newnby = int(self.nby + factor - np.mod(self.nby,factor))
+
+            newarray = np.ma.ones((newnbx,newnby), dtype = self.dtype) * self.nullvalue
             newarray[:self.nbx,:self.nby] = self.array
+            newarray.mask[:self.nbx,:self.nby] = self.array.mask
             self.array = newarray
 
             self.nbx = newnbx
@@ -6765,20 +6938,41 @@ class WolfArray(Element_To_Draw, header_wolf):
         new_shape = (self.nbx, self.nby)
 
         if factor>1.:
-            compression_pairs = [(d, c // d) for d, c in zip(new_shape,
-                                                            self.array.shape)]
-            flattened = [l for p in compression_pairs for l in p]
-            self.array = self.array.reshape(flattened)
-            for i in range(len(new_shape)):
-                op = getattr(self.array, operation)
-                self.array = np.float32(op(-1 * (i + 1)))
+            if operation_matrix is not None:
+                # Reshape the input array to split it into blocks of size f x f
+                reshaped_a = self.array.reshape(new_shape[0], int(factor), new_shape[1], int(factor))
+
+                # Swap axes to make blocks as separate dimensions
+                reshaped_a = reshaped_a.swapaxes(1, 2)
+
+                # Initialize the output matrix
+                self.array = ma.masked_array(np.ones((new_shape[0], new_shape[1]), dtype= self.dtype) * self.nullvalue, dtype= self.dtype)
+
+                # Check the dtype of the newly initialized array
+                assert self.array.dtype == self.dtype, _('Bad dtype')
+
+                # Vectorized operations
+                for op_idx, operation in enumerate(Rebin_Ops.get_numpy_ops()):
+                    mask = (operation_matrix.array == op_idx)
+                    if np.any(mask):
+                        block_results = operation(reshaped_a, axis=(2, 3))
+                        self.array[mask] = block_results[mask]
+
+            else:
+                compression_pairs = [(d, c // d) for d, c in zip(new_shape,
+                                                                self.array.shape)]
+                flattened = [l for p in compression_pairs for l in p]
+                self.array = operation(self.array.reshape(flattened), axis=(1, 3)).astype(self.dtype)
+
+            self.set_nullvalue_in_mask()
         else:
             self.array = np.kron(self.array, np.ones((int(1/factor), int(1/factor)), dtype=self.array.dtype))
 
-        self.mask_reset()
-
         self.count()
 
+        # rebin must not change the type of the array
+        assert self.array.dtype == self.dtype, _('Bad dtype')
+
     def read_txt_header(self):
         """
         Read header from txt file
@@ -8001,6 +8195,54 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.reset_plot()
 
+    @classmethod
+    def from_other_epsg_coo(cls,
+                            input_raster_path:str,
+                            input_srs='EPSG:3812',
+                            output_srs='EPSG:31370',
+                            resampling_method=gdal.GRA_Bilinear,
+                            xRes:float=0.5, yRes:float=0.5):
+        """
+        Reprojects and resamples a raster file from an other EPSG coordinates and return it as a WolfArray.
+
+        :param input_raster_path: The path to the input raster file.
+        :type input_raster_path: str
+        :param input_srs: The input spatial reference system (SRS) in the format 'EPSG:XXXX'. Defaults to Lambert 2008 'EPSG:3812'.
+        :type input_srs: str
+        :param output_srs: The output spatial reference system (SRS) in the format 'EPSG:XXXX'. Defaults to Belgian Lambert 72 'EPSG:31370'.
+        :type output_srs: str
+        :param resampling_method: The resampling method to use. Defaults to gdal.GRA_Bilinear. Resampling method can be chosen among the gdal GRA_*
+        constants (gdal.GRA_Average; gdal.GRA_Bilinear; gdal.GRA_Cubic; gdal.GRA_CubicSpline;
+        gdal.GRA_Lanczos; gdal.GRA_Mode; gdal.GRA_NearestNeighbour)
+        :type resampling_method: int
+        :param xRes: The desired output resolution in the x direction. Defaults to 0.5.
+        :type xRes (float): float
+        :param yRes: The desired output resolution in the y direction. Defaults to 0.5.
+        :type yRes (float): float
+
+        :raises AssertionError: If the input or output raster file is not a GeoTIFF file.
+        :raises RuntimeError: If the input raster file cannot be opened.
+        :raises PermissionError: If there is a permission error while trying to delete the output raster file.
+        :raises Exception: If an unexpected error occurs while trying to delete the output raster file.
+        :raises RuntimeError: If the reprojection fails for the input raster file.
+
+        :return: WolfArray
+        """
+
+        #sanitize input
+        input_raster_path = str(input_raster_path)
+        input_srs = str(input_srs)
+        output_srs = str(output_srs)
+
+        assert resampling_method in [gdal.GRA_Average, gdal.GRA_Bilinear, gdal.GRA_Cubic, gdal.GRA_CubicSpline, gdal.GRA_Lanczos, gdal.GRA_Mode, gdal.GRA_NearestNeighbour], "Invalid resampling method"
+
+        # Define temporary files
+        with tempfile.TemporaryDirectory() as temp_dir:
+            output_raster_path = os.path.join(temp_dir, "Array_72.tif")
+            reproject_and_resample_raster(input_raster_path, output_raster_path, input_srs, output_srs, resampling_method, xRes, yRes)
+            Array3 = WolfArray(output_raster_path, nullvalue=-9999)
+        return Array3
+
 class WolfArrayMB(WolfArray):
     """
     Matrice multiblocks

{wolfhece-2.1.46.dist-info → wolfhece-2.1.49.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.1.46
+Version: 2.1.49
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 License: Copyright (c) 2024 University of Liege. All rights reserved.
 Project-URL: Homepage, https://uee.uliege.be/hece
@@ -13,14 +13,14 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 Requires-Python: <3.11,>=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: wxpython
-Requires-Dist: colorlog
+Requires-Dist: colorlog ==6.7.*
 Requires-Dist: intel-fortran-rt
 Requires-Dist: scikit-learn
 Requires-Dist: cryptography
-Requires-Dist: jax
+Requires-Dist: jax ==0.4.30
 Requires-Dist: triangle
-Requires-Dist: numpy
-Requires-Dist: pyopengl
+Requires-Dist: numpy ==1.23.*
+Requires-Dist: pyopengl ==3.1.*
 Requires-Dist: pandas
 Requires-Dist: geopandas
 Requires-Dist: scipy
@@ -33,7 +33,7 @@ Requires-Dist: graphviz
 Requires-Dist: beautifulsoup4
 Requires-Dist: requests
 Requires-Dist: notebook
-Requires-Dist: matplotlib
+Requires-Dist: matplotlib ==3.6.*
 Requires-Dist: mkl
 Requires-Dist: python-gettext
 Requires-Dist: shapely
@@ -49,10 +49,10 @@ Requires-Dist: python-docx
 Requires-Dist: pygltflib
 Requires-Dist: ezdxf
 Requires-Dist: pyvista
-Requires-Dist: tqdm
+Requires-Dist: tqdm ==4.64.*
 Requires-Dist: osmnx
 Requires-Dist: tifffile
-Requires-Dist: numba
+Requires-Dist: numba ==0.58.*
 Requires-Dist: xmltodict
 Requires-Dist: opencv-python
 Requires-Dist: xarray

{wolfhece-2.1.46.dist-info → wolfhece-2.1.49.dist-info}/RECORD

@@ -1,3 +1,4 @@
+wolfhece/Coordinates_operations.py,sha256=YyWlAwKManb-ReQrmP37rEXxehunUCihmkeDYX6qTAQ,8037
 wolfhece/CpGrid.py,sha256=ke4n1khTUoed2asJl1GR25PsEkI4TpiBDCo4u0aSo9M,10658
 wolfhece/GraphNotebook.py,sha256=V1_Ak4F_hoIpKm2GAakuyKOALhujjIXB5FwzFHtM5-8,28021
 wolfhece/GraphProfile.py,sha256=OCgJo0YFFBI6H1z-5egJsOOoWF_iziiza0-bbPejNMc,69656
@@ -6,7 +7,7 @@ wolfhece/ManageParams.py,sha256=EeuUI5Vvh9ixCvYf8YShMC1s1Yacc7OxOCN7q81gqiQ,517
 wolfhece/Model1D.py,sha256=uL1DJVmDI2xVSE7H6n3icn3QbsPtTHeg8E-6wkDloKw,476914
 wolfhece/PyConfig.py,sha256=FB8u0belXOXTb03Ln6RdVWvMgjzi3oGPCmw2dWa3lNg,8332
 wolfhece/PyCrosssections.py,sha256=FnmM9DWY_SAF2EDH9Gu2PojXNtSTRF4-aYQuAAJXBh4,112771
-wolfhece/PyDraw.py,sha256=t3U7YQwBA5OYh-Pf0tffZCv9Ha9SH3S-XAhFXVOpeBs,390808
+wolfhece/PyDraw.py,sha256=_Rfx59LMopR0Cx00d1RRF5Gb-WNxfA2v2RjkOfm84Yo,390847
 wolfhece/PyGui.py,sha256=aRWv9tBpRl7sKEd2gHWj8Bss0ZOKbGlUYIehWHFm8WY,105008
 wolfhece/PyGuiHydrology.py,sha256=f60E8K9eGTnRq5RDF6yvt-ahf2AYegwQ9t25zZ2Mk1A,14946
 wolfhece/PyHydrographs.py,sha256=jwtSNMMACwarxrtN1UeQYth99UNrhwPx1IGgUwcooHA,3774
@@ -15,7 +16,7 @@ wolfhece/PyParams.py,sha256=wwgmP-_7wiiPLTcyX8a5jR6FyC1D2c4oBPc1VWQqtSA,97383
 wolfhece/PyPictures.py,sha256=m1kY0saW6Y9Q0bDCo47lW6XxDkBrbQG-Fd8uVn8G5ic,2514
 wolfhece/PyTranslate.py,sha256=4appkmNeHHZLFmUtaA_k5_5QL-5ymxnbVN4R2OblmtE,622
 wolfhece/PyVertex.py,sha256=vJ-NbnhPiTuFvDfAF7wfrEzVmladx5Ts0zKsyfySV3Q,40390
-wolfhece/PyVertexvectors.py,sha256=9MT7Qa37dnItmL4ml9O0NUY4SAee2SMWLd2FfL1oMTg,233710
+wolfhece/PyVertexvectors.py,sha256=KMXJB_zFi54I73jk_fGtSTxqTQhnCwngeEjJyLdgGDo,235914
 wolfhece/PyWMS.py,sha256=fyyzm2HFwq8aRwVYHKiBatcZOeKnFi6DWhv4nfscySQ,4602
 wolfhece/RatingCurve.py,sha256=bUjIrQjvIjkD4V-z8bZmA6pe1ILtYNM0-3fT6YUY1RU,22498
 wolfhece/RatingCurveData.py,sha256=5UvnIm89BwqjnEbLCcY3CA8WoFd_xHJbooNy62fX5iY,57660
@@ -26,7 +27,7 @@ wolfhece/__init__.py,sha256=FRDE8PiJAWxX9PMXsShRMZ8YADAY4WIgKMRh52rmhiw,23
 wolfhece/_add_path.py,sha256=nudniS-lsgHwXXq5o626XRDzIeYj76GoGKYt6lcu2Nc,616
 wolfhece/cli.py,sha256=3S1Hbp2tOl51LwLcloAm1DqV9QuUWJx_Ui_vdKNtGxo,2915
 wolfhece/color_constants.py,sha256=Snc5RX11Ydi756EkBp_83C7DiAQ_Z1aHD9jFIBsosAU,37121
-wolfhece/drawing_obj.py,sha256=znIQY8dkYhnmoq3mEsVkVzd-hSKDbFY6i8TV-Tf37jM,4040
+wolfhece/drawing_obj.py,sha256=7vY04B6r08nurTTFmBXHyR5tVIF1YzAEw_uz4pqTDIw,4233
 wolfhece/flow_SPWMI.py,sha256=XDAelwAY-3rYOR0WKW3fgYJ_r8DU4IP6Y5xULW421tk,20956
 wolfhece/friction_law.py,sha256=MtZJLo-pTj3-Fw-w12z1LSgSIDrH-JGR0iD9wer_fpQ,5498
 wolfhece/gpuview.py,sha256=0Ld8glEijx5OhMEfcwqvUFEQ5ryRXLnzey3Dff_sn-k,24110
@@ -47,7 +48,7 @@ wolfhece/pywalous.py,sha256=yRaWJjKckXef1d9D5devP0yFHC9uc6kRV4G5x9PNq9k,18972
 wolfhece/rain_SPWMI.py,sha256=qCfcmF7LajloOaCwnTrrSMzyME03YyilmRUOqrPrv3U,13846
 wolfhece/textpillow.py,sha256=map7HsGYML_o5NHRdFg2s_TVQed_lDnpYNDv27MM0Vw,14130
 wolfhece/tools_mpl.py,sha256=gQ3Jg1iuZiecmMqa5Eli2ZLSkttu68VXL8YmMDBaEYU,564
-wolfhece/wolf_array.py,sha256=8UwY94icIbz2BGHtBBdjoia0ijlriJsLcvuJ0Ji-DTg,358915
+wolfhece/wolf_array.py,sha256=HnrviXNSps9LFDERXyeZmI0L2ovFYY4rBHInPBZLRGw,368994
 wolfhece/wolf_hist.py,sha256=7jeVrgSkM3ErJO6SRMH_PGzfLjIdw8vTy87kesldggk,3582
 wolfhece/wolf_texture.py,sha256=DS5eobLxrq9ljyebYfpMSQPn8shkUAZZVfqrOKN_QUU,16951
 wolfhece/wolf_tiles.py,sha256=2Ho2I20rHRY81KXxjgLOYISdF4OkJ2d6omeY4shDoGI,10386
@@ -71,7 +72,7 @@ wolfhece/apps/check_install.py,sha256=SG024u18G7VRLKynbp7DKD1jImtHwuWwN4bJWHm-YH
 wolfhece/apps/curvedigitizer.py,sha256=_hRR2PWow7PU7rTHIbc6ykZ08tCXcK9uy7RFrb4EKkE,5196
 wolfhece/apps/isocurrent.py,sha256=MuwTodHxdc6PrqNpphR2ntYf1NLL2n9klTPndGrOHDQ,4109
 wolfhece/apps/splashscreen.py,sha256=SrustmIQeXnsiD-92OzjdGhBi-S7c_j-cSvuX4T6rtg,2929
-wolfhece/apps/version.py,sha256=NcO4o6jWbzNyEQy_q5jp-nVRYwCMSE9siAWq3vRNszg,388
+wolfhece/apps/version.py,sha256=cUwL_sNDbbwu6AtD4FZAGrhp2E-myuuGl2doXoLXtBc,388
 wolfhece/apps/wolf.py,sha256=mM6Tyi4DlKQILmO49cDUCip9fYVy-hLXkY3YhZgIeUQ,591
 wolfhece/apps/wolf2D.py,sha256=yPQGee7fsegoQ8GfWKrWEjX1Az_ApL-UWlBiqPvaIyY,565
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -277,8 +278,8 @@ wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=8PlMYrb_8jI8h9F0_EagpM
 wolfhece/ui/wolf_times_selection_comparison_models.py,sha256=ORy7fz4dcp691qKzaOZHrRLZ0uXNhL-LIHxmpDGL6BI,5007
 wolfhece/wintab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/wintab/wintab.py,sha256=8A-JNONV6ujgsgG3lM5Uw-pVgglPATwKs86oBzzljoc,7179
-wolfhece-2.1.46.dist-info/METADATA,sha256=Me3fak5XA8FOqijhfnRwcDvv4O8CNe51c17L0oHxDsY,2488
-wolfhece-2.1.46.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-wolfhece-2.1.46.dist-info/entry_points.txt,sha256=Q5JuIWV4odeIJI3qc6fV9MwRoz0ezqPVlFC1Ppm_vdQ,395
-wolfhece-2.1.46.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.1.46.dist-info/RECORD,,
+wolfhece-2.1.49.dist-info/METADATA,sha256=5OMCtgg9J68-JovF2B1Yy4PdFja_n8nT7_UTT_vlgsU,2548
+wolfhece-2.1.49.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+wolfhece-2.1.49.dist-info/entry_points.txt,sha256=Q5JuIWV4odeIJI3qc6fV9MwRoz0ezqPVlFC1Ppm_vdQ,395
+wolfhece-2.1.49.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.1.49.dist-info/RECORD,,