wolfhece 2.1.45__py3-none-any.whl → 2.1.48__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

@@ -7508,6 +7508,8 @@ class WolfMapViewer(wx.Frame):
             if self.active_array.nb_blocks > 0:
                 txt += ' ; Nb blocks : {:d}'.format(self.active_array.nb_blocks)
 
+            txt += ' ; Type : ' + self.active_array.dtype_str
+
             self.StatusBar.SetStatusText(txt)
 
 
@@ -8393,6 +8395,8 @@ class WolfMapViewer(wx.Frame):
                     if not altdown:
                         newarray.mask_outsidepoly(self.active_vector)
 
+                    newarray.nullify_border(width=1)
+
                     self.add_object('array', newobj = newarray, id = self.active_array.idx + '_crop')
 
                     self.Refresh()

wolfhece/apps/version.py

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

wolfhece/scenario/config_manager.py

@@ -746,6 +746,7 @@ class Config_Manager_2D_GPU:
                     new_zones.add_zone(new_zone)
 
                     curarray = WolfArray(curtif)
+                    curarray.nullify_border(width=1)
                     sux, sux, curvect, interior = curarray.suxsuy_contour()
                     new_zone.add_vector(curvect, forceparent=True)
                     curvect.set_legend_to_centroid(curtif.name)
@@ -1481,6 +1482,10 @@ class UI_Manager_2D_GPU():
         logging.info(_('Creating vecz ...'))
         mydata = self._treelist.GetItemData(self._selected_item)
 
+        if not 'path' in mydata:
+            logging.error(_('Please select a scenario to analyze !'))
+            return
+
         # création du fichier vrt
         new_zones = self._parent.create_vec(mydata['path'])
         logging.info(_('... done !'))

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
@@ -4396,14 +4440,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 """
@@ -4613,6 +4667,36 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return dtype
 
+    @property
+    def dtype_str(self):
+        """
+        Return the numpy dtype corresponding to the WOLF type, as a string
+
+        Pay ettention to the difference between :
+            - LOGICAL : Fortran and VB6
+            - Bool : Python
+
+        In VB6, logical is stored as int16
+        In Fortran, there are Logical*1, Logical*2, Logical*4, Logical*8
+        In Python, bool is one byte
+        In Numpy, np.bool_ is one byte
+        """
+
+        if self.wolftype in [WOLF_ARRAY_FULL_DOUBLE, WOLF_ARRAY_SYM_DOUBLE, WOLF_ARRAY_CSR_DOUBLE]:
+            dtype = _('float64 - 8 bytes poer values')
+        elif self.wolftype in [WOLF_ARRAY_FULL_SINGLE, WOLF_ARRAY_FULL_SINGLE_3D, WOLF_ARRAY_MB_SINGLE]:
+            dtype = _('float32 - 4 bytes per values')
+        elif self.wolftype in [WOLF_ARRAY_FULL_INTEGER, WOLF_ARRAY_MB_INTEGER, WOLF_ARRAY_MNAP_INTEGER]:
+            dtype = _('int32 - 4 bytes per values')
+        elif self.wolftype in [WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_FULL_INTEGER16_2]:
+            dtype = _('int16 - 2 bytes per values')
+        elif self.wolftype == WOLF_ARRAY_FULL_INTEGER8:
+            dtype = _('int8 - 1 byte per values')
+        elif self.wolftype == WOLF_ARRAY_FULL_LOGICAL:
+            dtype = _('int16 - 2 bytes per values')
+
+        return dtype
+
     def loadnap_and_apply(self):
         """
         Load a mask file (aka nap) and apply it to the array;
@@ -4772,7 +4856,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)
 
@@ -4783,11 +4867,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
@@ -4815,7 +4900,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())
 
 
@@ -5079,6 +5174,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
@@ -6652,11 +6751,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):
@@ -6666,7 +6766,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
@@ -6700,18 +6800,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
+
+        The shape is adjusted to be a multiple of the factor.
 
-        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
+        :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
@@ -6720,8 +6828,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
@@ -6735,20 +6920,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
@@ -7940,26 +8146,85 @@ class WolfArray(Element_To_Draw, header_wolf):
 
     def map_values(self, keys_vals:dict, default:float=None):
         """
-        Apply a mapping to the array
+        Mapping array values to new values defined by a dictionnary.
+
+        First, check if all values are in keys_vals. If not, set to default.
+        If default is None, set to nullvalue.
+
+        :param keys_vals: dictionary of values to map
+        :param default: default value if key not found
         """
 
         vals = self.get_unique_values()
 
-        if default is not None:
-            self.array.data[:,:] = default
-
+        def_keys = []
         for val in vals:
             if val not in keys_vals:
-                logging.warning(f"Value {val} not in keys_vals")
+                logging.warning(_(f"Value {val} not in keys_vals -- Will be set to default or NullValue"))
+                def_keys.append(val)
                 continue
 
         for key, val in keys_vals.items():
             self.array.data[self.array.data == key] = val
 
+        if default is None:
+            default = self.nullvalue
+
+        for key in def_keys:
+            self.array.data[self.array.data == key] = default
+
         self.mask_data(self.nullvalue)
 
         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.45.dist-info → wolfhece-2.1.48.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.1.45
+Version: 2.1.48
 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.45.dist-info → wolfhece-2.1.48.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=mMPowIkidxWrEqQwvsFG__HADLjIu-nVRX0ChllpAUA,390687
+wolfhece/PyDraw.py,sha256=t3U7YQwBA5OYh-Pf0tffZCv9Ha9SH3S-XAhFXVOpeBs,390808
 wolfhece/PyGui.py,sha256=aRWv9tBpRl7sKEd2gHWj8Bss0ZOKbGlUYIehWHFm8WY,105008
 wolfhece/PyGuiHydrology.py,sha256=f60E8K9eGTnRq5RDF6yvt-ahf2AYegwQ9t25zZ2Mk1A,14946
 wolfhece/PyHydrographs.py,sha256=jwtSNMMACwarxrtN1UeQYth99UNrhwPx1IGgUwcooHA,3774
@@ -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=AUSGolqu-YfyQ2SJp5WCMVD1gppvddHULJ3GrUpBjB4,357128
+wolfhece/wolf_array.py,sha256=cWkTaA4nY9I8-FLNlXBwn0xkvaN1EXw6M9NYUYnTqf8,368492
 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=ls80i8D7bLwHlLa8Q9f7hPR0HGZE2sGy0sqH0i67EBs,388
+wolfhece/apps/version.py,sha256=1j6FkD-S6lKIU8cwsITdvdCE6HZVOxDK9aVtSrdT5Vw,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
@@ -254,7 +255,7 @@ wolfhece/report/reporting.py,sha256=JUEXovx_S4jpYkJEBU0AC-1Qw2OkkWyV3VAp6iOfSHc,
 wolfhece/report/wolf_report.png,sha256=NoSV58LSwb-oxCcZScRiJno-kxDwRdm_bK-fiMsKJdA,592485
 wolfhece/scenario/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/scenario/check_scenario.py,sha256=w7_SST4n_uec-MUBK36gbJzz2KC8qT_bVJ_VNyp7cMo,4917
-wolfhece/scenario/config_manager.py,sha256=k5wPR58AQk_xSN1uzKR0DjGume26NrbBFZvAbgMIhlc,85287
+wolfhece/scenario/config_manager.py,sha256=UzInaAtxmTLqUaXAHg17iLcUZRGTrPPLsj2D9kBs6wI,85468
 wolfhece/scenario/imposebc_void.py,sha256=PqA_99hKcaqK5zsK6IRIc5Exgg3WVpgWU8xpwNL49zQ,5571
 wolfhece/scenario/update_void.py,sha256=ay8C_FxfXN627Hx46waaAO6F3ovYmOCTxseUumKAY7c,7474
 wolfhece/shaders/fragment_shader_texture.glsl,sha256=w6h8d5mJqFaGbao0LGmjRcFFdcEQ3ICIl9JpuT71K5k,177
@@ -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.45.dist-info/METADATA,sha256=y63i_CDK02w9EiVXGhd2JlyrM_GCuI0iP7BTQfkmbAw,2488
-wolfhece-2.1.45.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-wolfhece-2.1.45.dist-info/entry_points.txt,sha256=Q5JuIWV4odeIJI3qc6fV9MwRoz0ezqPVlFC1Ppm_vdQ,395
-wolfhece-2.1.45.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.1.45.dist-info/RECORD,,
+wolfhece-2.1.48.dist-info/METADATA,sha256=2S8MGX7bCP41sSY7a9scSmcsfKj2w8uiaMzIY5bIY9k,2548
+wolfhece-2.1.48.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+wolfhece-2.1.48.dist-info/entry_points.txt,sha256=Q5JuIWV4odeIJI3qc6fV9MwRoz0ezqPVlFC1Ppm_vdQ,395
+wolfhece-2.1.48.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.1.48.dist-info/RECORD,,