wolfhece 2.2.4__py3-none-any.whl → 2.2.5__py3-none-any.whl

wolfhece/PyPalette.py

@@ -96,7 +96,10 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
         self.set_over(tuple(self.colormax))
 
     def get_rgba(self, x: np.ndarray):
-        """Récupération de la couleur en fonction de la valeur x"""
+        """Récupération de la couleur en fonction de la valeur x
+
+        :param x: tableau de valeurs
+        """
 
         dval = self.values[-1]-self.values[0]
         if dval == 0.:
@@ -260,6 +263,7 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
         if self.interval_cst:
             discrete_cmap = ListedColormap(self.colorsflt[:, :3])
             colorbar = ScalarMappable(BoundaryNorm(self.values, ncolors=self.nb-1), cmap=discrete_cmap)
+            return colorbar
         else:
             return ScalarMappable(Normalize(self.values[0], self.values[-1]), cmap=self)
 
@@ -453,6 +457,26 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
         ax.set_xticks(pos)
         ax.set_xticklabels(txt, rotation=30, fontsize=6)
 
+    @property
+    def cmap(self):
+        """ Récupération de la palette de couleurs """
+        return self
+
+    @property
+    def vmin(self):
+        """ Récupération de la valeur minimale """
+        return self.values[0]
+
+    @property
+    def vmax(self):
+        """ Récupération de la valeur maximale """
+        return self.values[-1]
+
+    @property
+    def norm(self):
+        """ Récupération de la normalisation """
+        return Normalize(self.values[0], self.values[-1])
+
     def fillgrid(self, gridto: CpGrid):
         """ Remplissage d'une grille avec les valeurs de la palette """
 
@@ -692,7 +716,7 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
             normval = np.ones([len(self.values)])
 
             if dval > 0.:
-                normval = (self.values-self.values[0])/(self.values[-1]-self.values[0])
+                normval = (self.values-self.values[0])/dval
 
             normval[0] = 0.
             normval[-1] = 1.

wolfhece/PyWMS.py

@@ -202,7 +202,8 @@ def getLifeWatch(cat:Literal['None'],
                 yr:float,
                 w:int = None,
                 h:int = None,
-                tofile=True) -> BytesIO:
+                tofile=True,
+                format:Literal['image/png', 'image/png; mode=8bit']='image/png') -> BytesIO:
 
     wms=WebMapService(f'https://maps.elie.ucl.ac.be/cgi-bin/mapserv72?map=/maps_server/lifewatch/mapfiles/LW_Ecotopes/latest/{cat}.map&SERVICE=wms',
                         version='1.3.0')
@@ -226,6 +227,16 @@ def getLifeWatch(cat:Literal['None'],
         # w = int(real_w * ppkm)
         h = int(real_h * ppkm)
 
+    MAXSIZE = 2048
+    if w > MAXSIZE:
+        pond = w / MAXSIZE
+        w = MAXSIZE
+        h = int(h / pond)
+    if h > MAXSIZE:
+        pond = h / MAXSIZE
+        h = MAXSIZE
+        w = int(w / pond)
+
     if tofile:
         img=wms.getmap(layers=['lc_hr_raster'],
                     #    styles=['default'],
@@ -250,7 +261,7 @@ def getLifeWatch(cat:Literal['None'],
                            srs='EPSG:31370',
                            bbox=(xl,yl,xr,yr),
                            size=(w,h),
-                           format='image/png',
+                           format=format,
                            transparent=False)
             return BytesIO(img.read())
         except:

wolfhece/apps/version.py

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

wolfhece/lifewatch.py

@@ -1,6 +1,20 @@
 from enum import Enum
 from PIL import Image
+import numpy as np
+from typing import Literal
+import matplotlib.pyplot as plt
+from matplotlib.colors import LinearSegmentedColormap, Normalize, ListedColormap, BoundaryNorm
 
+
+from .PyTranslate import _
+from .PyWMS import getLifeWatch
+from .wolf_array import WolfArray, header_wolf, WOLF_ARRAY_FULL_INTEGER8, WOLF_ARRAY_FULL_INTEGER, wolfpalette
+
+
+YEARS = [2006, 2010, 2015, 2018, 2019, 2020, 2021, 2022]
+PIXEL_SIZE = 2 # in meters
+MAP_LW = 'LW_ecotopes_lc_hr_raster'
+MAX_PIXELS = 2048 # Maximum number of pixels in one direction (x or y)
 class LifeWatch_Legend(Enum):
     """
     https://www.mdpi.com/2306-5729/8/1/13
@@ -21,68 +35,389 @@ class LifeWatch_Legend(Enum):
     Small broadleaved trees (<3 m) and shrubs	56	LCC-2_1_2 &    LCH-3_1_2	1.75
 
     Color Table (RGB with 256 entries) from tiff file
-    10: 10,10,210,255
-    11: 254,254,254,255
-    15: 215,215,215,255
-    20: 20,20,20,255
-    21: 210,0,0,255
-    30: 230,230,130,255
-    35: 235,170,0,255
-    40: 240,40,240,255
-    45: 145,245,245,255
+    10: 10,10,210
+    15: 210,210,210
+    20: 20,20,20
+    21: 210,0,0
+    30: 230,230,130
+    35: 235,170,0
+    40: 240,40,240
+    45: 145,245,245
+    48: 148,118,0
+    50: 50,150,50
+    51: 0,151,151
+    55: 55,255,0
+    56: 156,255,156
+
     46: 246,146,246,255
-    48: 148,112,0,255
-    50: 50,150,50,255
-    51: 0,151,151,255
-    55: 55,255,0,255
-    56: 156,255,156,255
+    11: 254,254,254,255
+    """
+    NODATA_WHITE = (0, (255, 255, 255), 'Nodata', '') # Outside Belgium/Wallonia
+
+    WATER = (10, (10, 10, 210), _("Water"), 'LCC-3')
+    NATURAL_MATERIAL_SURFACES = (15, (210, 210, 210), _("Natural Material Surfaces with less than 10% vegetation"), 'LCC-1_2')
+    ARTIFICIALLY_SEALED_GROUND_SURFACE = (20, (20, 20, 20), _("Artificially sealed ground surface"), 'LCC-1_1_1_3')
+    BUILDING = (21, (210, 0, 0), _("Building, specific structures and facilities"), 'LCC-1_1_1_1 || LCC-1_1_1_2')
+    HERBACEOUS_ROTATION = (30, (230, 230, 130), _("Herbaceous in rotation during the year (e.g., crops)"), 'LCC-2_2')
+    GRASSLAND_INTENSIVE_MANAGEMENT = (35, (235, 170, 0), _("Grassland with intensive management"), 'LCC-2_2')
+    GRASSLAND_SCRUB_BIOLOGICAL_INTEREST = (40, (240, 40, 240), _("Grassland and scrub of biological interest"), 'LCC-2_2')
+    INUNDATED_GRASSLAND_SCRUB_BIOLOGICAL_INTEREST = (45, (145, 245, 245), _("Inundated grassland and scrub of biological interest"), 'LCC-2_2 & LCH-4_4_2')
+    VEGETATION_RECENTLY_DISTURBED_AREA = (48, (148, 118, 0), _("Vegetation of recently disturbed area (e.g., clear cut)"), 'LCC-2_2 & LCH-3_8')
+    CONIFEROUS_TREES = (50, (50, 150, 50), _("Coniferous trees (≥3 m)"), 'LCC-2_1_1 & LCH-3_1_1')
+    SMALL_CONIFEROUS_TREES = (51, (0, 151, 151), _("Small coniferous trees (<3 m)"), 'LCC-2_1_2 & LCH-3_1_1')
+    BROADLEAVED_TREES = (55, (55, 255, 0), _("Broadleaved trees (≥3 m)"), 'LCC-2_1_1 & LCH-3_1_2')
+    SMALL_BROADLEAVED_TREES_SHRUBS = (56, (156, 255, 156), _("Small broadleaved trees (<3 m) and shrubs"), 'LCC-2_1_2 & LCH-3_1_2')
+
+    # NODATA11 = (11, (254,254,254,255)) # Not used
+    # NODATA46 = (46, (246,146,246,255)) # Not used
+    NODATA_BLACK = (100, (0, 0, 0), 'Nodata', '') # Outside Belgium/Wallonia
+
+    @classmethod
+    def reference(cls) -> str:
+        """
+        Return the reference
+        """
+        return 'https://www.mdpi.com/2306-5729/8/1/13'
+
+    @classmethod
+    def colors(cls, rgba:bool = False) -> list[tuple[int, int, int] | tuple[int, int, int, int]]:
+        """
+        Return the color of the class as a tuple (R, G, B)
+        """
+        if rgba:
+            return [leg.value[1] + (255,) for leg in cls]
+        else:
+            return [leg.value[1] for leg in cls]
+
+    @classmethod
+    def codes(cls):
+        """
+        Return the code of the class as integer
+        """
+        return [leg.value[0] for leg in cls]
+
+    @classmethod
+    def plot_legend(cls, figax = None):
+        """
+        Return the color of the class as a tuple (R, G, B)
+        """
+
+        colors = cls.colors()
+        codes = cls.codes()
+        texts = cls.texts()
+
+        if figax is None:
+            fig, ax = plt.subplots(figsize=(1, 6))
+        else:
+            fig, ax = figax
+
+        for i, color in enumerate(colors):
+            ax.fill([0,1,1,0,0],[i,i,i+1,i+1,i], color=np.array(color)/255.0)
+            ax.text(1.05, i + 0.5, f"{codes[i]}: {texts[i]}", va='center', fontsize=12)
+            ax.axis('off')
+
+        return fig, ax
+
+    @classmethod
+    def cmap(cls) -> plt.cm:
+        """
+        Return the colormap of the class
+        """
+        colors = np.asarray(cls.colors()).astype(float)/255.
+        codes = np.asarray(cls.codes()).astype(float)
+
+        normval = codes/100.
+
+        normval[0] = 0.
+        normval[-1] = 1.
+        segmentdata = {"red": np.column_stack([normval, colors[:, 0], colors[:, 0]]),
+                    "green": np.column_stack([normval, colors[:, 1], colors[:, 1]]),
+                    "blue": np.column_stack([normval, colors[:, 2], colors[:, 2]]),
+                    "alpha": np.column_stack([normval, np.ones(len(colors)) * 255., np.ones(len(colors)) * 255.])}
+
+        return LinearSegmentedColormap('LifeWatch', segmentdata, 256)
+
+    @classmethod
+    def norm(cls) -> BoundaryNorm:
+        """
+        Return the norm of the class
+        """
+        return Normalize(0, 100)
+
+    @classmethod
+    def texts(cls):
+        """
+        Return the text of the class as a string
+        """
+        return [leg.value[2] for leg in cls]
+
+    @classmethod
+    def EAGLE_codes(cls):
+        """
+        Return the EAGLE code of the class as string
+        """
+        return [leg.value[3] for leg in cls]
+
+    @classmethod
+    def colors2codes(cls, array: np.ndarray | Image.Image,
+                     aswolf:bool = True) -> np.ndarray:
+        """
+        Convert the color of the class to the code of the class
+        :param array: numpy array or PIL image
+        """
+
+        if isinstance(array, Image.Image):
+            mode = array.mode
+            if mode == 'RGB':
+                array = np.array(array)
+            elif mode == 'RGBA':
+                array = np.array(array)[:, :, :3]
+            elif mode == 'P':
+                array = np.array(array.convert('RGB'))
+            else:
+                raise ValueError(f"Unsupported image mode: {mode}")
+
+        elif isinstance(array, np.ndarray):
+            if array.ndim == 3 and array.shape[2] == 4:
+                array = array[:, :, :3]
+            elif array.ndim == 2:
+                pass
+            else:
+                raise ValueError(f"Unsupported array shape: {array.shape}")
+
+        unique_colors = np.unique(array.reshape(-1, array.shape[2]), axis=0)
+
+        # check if the colors are in the legend
+        for color in unique_colors:
+            if not any(np.array_equal(color, leg.value[1]) for leg in cls):
+                raise ValueError(f"Color {color} not found in legend")
+
+        # convert the color to the code
+        color_to_code = {leg.value[1]: leg.value[0] for leg in cls}
+        code_array = np.zeros(array.shape[:2], dtype=np.uint8)
+        for color, code in color_to_code.items():
+            mask = np.all(array == color, axis=-1)
+            code_array[mask] = code
+
+        if aswolf:
+            return np.asfortranarray(np.fliplr(code_array.T))
+        else:
+            return code_array
+
+    @classmethod
+    def codes2colors(cls, array: np.ndarray, asimage:bool = False) -> np.ndarray | Image.Image:
+        """
+        Convert the code of the class to the color of the class
+        :param array: numpy array or PIL image
+        """
+
+        if isinstance(array, np.ndarray):
+            if  array.ndim == 2:
+                pass
+            else:
+                raise ValueError(f"Unsupported array shape: {array.shape}")
+        else:
+            raise ValueError(f"Unsupported array type: {type(array)}")
+
+        # check if the codes are in the legend
+        for code in np.unique(array):
+            if code not in cls.codes():
+                raise ValueError(f"Code {code} not found in legend")
+
+        # convert the code to the color
+        code_to_color = {leg.value[0]: leg.value[1] for leg in cls}
+        color_array = np.zeros((*array.shape, 3), dtype=np.uint8)
+        for code, color in code_to_color.items():
+            mask = (array == code)
+            color_array[mask] = color
+
+        if asimage:
+            color_array = Image.fromarray(color_array, mode='RGB')
+            color_array = color_array.convert('RGBA')
+            color_array.putalpha(255)
+            return color_array
+        else:
+            return color_array
+
+        return color_array
+
+    @classmethod
+    def getwolfpalette(cls) -> wolfpalette:
+        """
+        Get the wolf palette for the class
+        """
+        palette = wolfpalette()
+
+        palette.set_values_colors(cls.codes(), cls.colors())
+        palette.automatic = False
+        palette.interval_cst = True
+
+        return palette
+
+def get_LifeWatch_bounds(year:int,
+                         xmin:float,
+                         ymin:float,
+                         xmax:float,
+                         ymax:float,
+                         format:Literal['WolfArray',
+                                        'NUMPY',
+                                        'RGB',
+                                        'RGBA',
+                                        'Palette'] = 'WolfArray',
+                         force_size:bool= True,
+                                        ) -> WolfArray | np.ndarray | Image.Image:
+
+
+    if year not in YEARS:
+        raise ValueError(f"Year {year} not found in LifeWatch years")
+
+    dx = xmax - xmin
+    dy = ymax - ymin
+
+    if force_size:
+        w = dx / PIXEL_SIZE
+        h = dy / PIXEL_SIZE
+
+        if w > MAX_PIXELS or h > MAX_PIXELS:
+            raise ValueError(f"Map size is too large: {w}x{h} pixels (max. {MAX_PIXELS}x{MAX_PIXELS})")
+    else:
+
+        if dx > dy:
+            w = MAX_PIXELS
+            h = int(dy * w / dx)
+        else:
+            h = MAX_PIXELS
+            w = int(dx * h / dy)
+
+    # Get the map from the WMS server
+    mybytes = getLifeWatch(f'{MAP_LW}_{year}',
+                        xmin, ymin,     # Lower left corner
+                        xmax, ymax,     # Upper right corner
+                        w=MAX_PIXELS, h=None, # Width and height of the image [pixels]
+                        tofile=False,   # Must be False to get bytes --> save the image to ".\Lifewatch.png" if True
+                        format='image/png; mode=8bit')
+
+    # Check if the map is empty
+    if mybytes is None:
+        raise ValueError(f"Error getting LifeWatch map for year {year} -- Check you internet connection or the resolution of the map (max. 2048x2048 pixels or 2mx2m)")
+
+    image = Image.open(mybytes) # Convert bytes to Image
+
+    if format in ['RGB', 'RGBA', 'Palette']:
+        if format == 'RGB':
+            image = image.convert('RGB')
+        elif format == 'RGBA':
+            image = image.convert('RGBA')
+        elif format == 'Palette':
+            image = image.convert('P')
+        else:
+            raise ValueError(f"Unsupported format: {format}")
+
+        return image, (xmin, ymin, xmax, ymax)
+
+    elif format == 'NUMPY':
+        return LifeWatch_Legend.colors2codes(image, aswolf=False), (xmin, ymin, xmax, ymax)
+
+    elif format in ['WolfArray', 'WOLF']:
+        h = header_wolf()
+        h.set_origin(xmin, ymin)
+        h.shape = image.size[0], image.size[1]
+        h.set_resolution((xmax-xmin)/h.nbx, (ymax-ymin)/h.nby)
+        wolf = WolfArray(srcheader=h, whichtype=WOLF_ARRAY_FULL_INTEGER)
+        wolf.array[:,:] = LifeWatch_Legend.colors2codes(image, aswolf=True).astype(int)
+        wolf.mask_data(0)
+        wolf.mypal = LifeWatch_Legend.getwolfpalette()
+
+        return wolf, (xmin, ymin, xmax, ymax)
+    else:
+        raise ValueError(f"Unsupported format: {format}")
+
+def get_LifeWatch_Wallonia(year: int,
+                           format:Literal['WolfArray',
+                                          'NUMPY',
+                                          'RGB',
+                                          'RGBA',
+                                          'Palette'] = 'WolfArray') -> WolfArray | np.ndarray | Image.Image:
+    """
+    Get the Wallonia LifeWatch map for the given year
+    :param year: year of the map
+    :param asimage: if True, return the image as PIL image, else return numpy array
+    :return: numpy array or PIL image
     """
-    WATER = (10, (10, 210, 255))
-    NATURAL_MATERIAL_SURFACES = (15, (215, 215, 215, 255))
-    ARTIFICIALLY_SEALED_GROUND_SURFACE = (20, (20, 20, 20, 255))
-    BUILDING = (21, (210, 0, 0, 255))
-    HERBACEOUS_ROTATION = (30, (230, 230, 130, 255))
-    GRASSLAND_INTENSIVE_MANAGEMENT = (35, (235, 170, 0, 255))
-    GRASSLAND_SCRUB_BIOLOGICAL_INTEREST = (40, (240, 40, 240, 255))
-    INUNDATED_GRASSLAND_SCRUB_BIOLOGICAL_INTEREST = (45, (145, 245, 245, 255))
-    VEGETATION_RECENTLY_DISTURBED_AREA = (48, (148, 112, 0, 255))
-    CONIFEROUS_TREES = (50, (50, 150, 50, 255))
-    SMALL_CONIFEROUS_TREES = (51, (0, 151, 151, 255))
-    BROADLEAVED_TREES = (55, (55, 255, 0, 255))
-    SMALL_BROADLEAVED_TREES_SHRUBS = (56, (156, 255, 156, 255))
-
-    NODATA11 = (11, (254,254,254,255)) # Not used
-    NODATA46 = (46, (246,146,246,255)) # Not used
-    NODATA100 = (100, (0, 0, 0, 255)) # Outside Belgium/Wallonia
-
-if __name__ == "__main__":
-    import numpy as np
-    n = 4
-
-    DIR = r'E:\MODREC-Vesdre\vesdre-data\LifeWatch'
-
-    # Tif file is very large, so we need to use PIL to open it
-    Image.MAX_IMAGE_PIXELS = 15885900000
-    img = Image.open(DIR + r'\lifewatch_LC2018_vx19_2mLB08cog.tif',)
-    img = np.asarray(img)
-
-    ij11 = np.where(img == 11)
-    ij46 = np.where(img == 46)
-
-    print(ij11[0].shape) # must be 0
-    print(ij11[1].shape) # must be 0
-
-    img = img[::n,:-img.shape[1]//2:n]
-    print(np.unique(img))
-
-    img = Image.open(DIR +r'\lifewatch_LC2022_vx20_2mLB08cog.tif',)
-    img = np.asarray(img)
-
-    ij11 = np.where(img == 11) # must be 0
-    ij46 = np.where(img == 46) # must be 0
-
-    print(ij11[0].shape)
-    print(ij11[1].shape)
-
-    img = img[::n,:-img.shape[1]//2:n]
-    print(np.unique(img))
+
+    # Whole Wallonia
+    xmin = 40_000
+    xmax = 300_000
+    ymin = 10_000
+    ymax = 175_000
+
+    return get_LifeWatch_bounds(year, xmin, ymin, xmax, ymax, format, force_size=False)
+
+def get_LifeWatch_center_width_height(year: int,
+                            x: float,
+                            y: float,
+                            width: float = 2000,
+                            height: float = 2000,
+                            format:Literal['WolfArray',
+                                           'NUMPY',
+                                           'RGB',
+                                           'RGBA',
+                                           'Palette'] = 'WolfArray') -> WolfArray | np.ndarray | Image.Image:
+    """
+    Get the LifeWatch map for the given year and center
+    :param year: year of the map
+    :param x: x coordinate of the center
+    :param y: y coordinate of the center
+    :param asimage: if True, return the image as PIL image, else return numpy array
+    :return: numpy array or PIL image
+    """
+
+    # compute bounds
+    xmin = x - width / 2
+    xmax = x + width / 2
+    ymin = y - height / 2
+    ymax = y + height / 2
+
+    return get_LifeWatch_bounds(year, xmin, ymin, xmax, ymax, format)
+
+def count_pixels(array:np.ndarray | WolfArray) -> dict[int, int]:
+    """
+    Count the number of pixels for each code in the array
+    :param array: numpy array or WolfArray
+    :return: dictionary with the code as key and the number of pixels as value
+    """
+    if isinstance(array, WolfArray):
+        array = array.array[~array.array.mask]
+    elif isinstance(array, np.ndarray):
+        pass
+    else:
+        raise ValueError(f"Unsupported array type: {type(array)}")
+
+    unique_codes, counts = np.unique(array, return_counts=True)
+
+    for code in unique_codes:
+        if code not in LifeWatch_Legend.codes():
+            raise ValueError(f"Code {code} not found in legend")
+
+    return {int(code): int(count) for code, count in zip(unique_codes, counts)}
+
+def get_areas(array:np.ndarray | WolfArray) -> dict[int, float]:
+    """
+    Get the areas of each code in the array
+    :param array: numpy array or WolfArray
+    :return: dictionary with the code as key and the area in m² as value
+    """
+    if isinstance(array, WolfArray):
+        array = array.array[~array.array.mask]
+    elif isinstance(array, np.ndarray):
+        pass
+    else:
+        raise ValueError(f"Unsupported array type: {type(array)}")
+
+    unique_codes, counts = np.unique(array, return_counts=True)
+
+    for code in unique_codes:
+        if code not in LifeWatch_Legend.codes():
+            raise ValueError(f"Code {code} not found in legend")
+
+    return {int(code): float(count) * PIXEL_SIZE**2 for code, count in zip(unique_codes, counts)}

wolfhece/models/Lifewatch.pal

@@ -0,0 +1,61 @@
+15
+0.0
+255
+255
+255
+10.0
+10
+10
+210
+15.0
+210
+210
+210
+20.0
+20
+20
+20
+21.0
+210
+0
+0
+30.0
+230
+230
+130
+35.0
+235
+170
+0
+40.0
+240
+40
+240
+45.0
+145
+245
+245
+48.0
+148
+118
+0
+50.0
+50
+150
+50
+51.0
+0
+151
+151
+55.0
+55
+255
+0
+56.0
+156
+255
+156
+100.0
+0
+0
+0

wolfhece/wolf_array.py

@@ -8,6 +8,13 @@ This script and its content are protected by copyright law. Unauthorized
 copying or distribution of this file, via any medium, is strictly prohibited.
 """
 
+try:
+    from osgeo import gdal, osr
+    gdal.UseExceptions()
+except ImportError as e:
+    print(e)
+    raise Exception(_('Error importing GDAL library'))
+
 import os
 import sys
 
@@ -127,13 +134,6 @@ VERSION_RGB = 3
 
 from numba import jit
 
-try:
-    from osgeo import gdal, osr
-    gdal.UseExceptions()
-except ImportError as e:
-    print(e)
-    raise Exception(_('Error importing GDAL library'))
-
 @jit(nopython=True)
 def custom_gradient(array: np.ndarray):
     """ Calculate the gradient manually """
@@ -5495,10 +5495,10 @@ class WolfArray(Element_To_Draw, header_wolf):
         return self.alpha
 
     # def find_minmax(self, update=False):
-        
+
     #     if update:
     #         [self.xmin, self.xmax], [self.ymin, self.ymax] = self.get_bounds()
-    
+
     @property
     def memory_usage(self):
         """
@@ -8568,6 +8568,40 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return self.get_values_underpoly(myvect, usemask, getxy)
 
+    def count_unique_pixels(self) -> dict[int, int]:
+        """
+        Count the number of pixels for each unique value in the array
+        :return: dictionary with the code as key and the number of pixels as value
+        """
+        if self.wolftype not in [WOLF_ARRAY_FULL_INTEGER, WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_FULL_INTEGER8, WOLF_ARRAY_FULL_UINTEGER8]:
+            logging.error("Bad wolftype")
+            return {}
+
+        counts = np.bincount(self.array[~self.array.mask].ravel())
+        ret = {i: int(val) for i, val in enumerate(counts) if val > 0}
+
+        return ret
+
+    def get_unique_areas(self, format:Literal['m2', 'ha', 'km2'] = 'm2') -> dict[int, float]:
+        """
+        Get the areas of each code in the array
+        :param array: numpy array or WolfArray
+        :return: dictionary with the code as key and the area in m² as value
+        """
+        ret = self.count_unique_pixels()
+
+        fact = 1.0
+        if format in ['ha', 'Ha']:
+            fact = 0.0001
+        elif format in ['km2', 'km²']:
+            fact = 1e-6
+        elif format not in ['m2', 'm²']:
+            logging.error("Bad format")
+            return {}
+
+        # Convert counts to areas in m²
+        return {code: float(count) * self.dx * self.dy * fact for code, count in ret.items()}
+
     def count_insidepoly(self, myvect: vector,
                          usemask:bool=True,
                          method:Literal['mpl', 'shapely_strict', 'shapely_wboundary', 'rasterio']='shapely_strict',
@@ -9427,6 +9461,59 @@ class WolfArray(Element_To_Draw, header_wolf):
         y, x = np.meshgrid(y_discr, x_discr)
         return x, y
 
+    def convolve(self,
+                 filter,
+                 method:Literal['scipyfft',
+                                'jaxfft',
+                                'classic']='scipyfft',
+                 inplace:bool=True) -> "WolfArray":
+        """
+        Convolve the array with a filter
+
+        :param filter: filter to convolve with
+        :param method: method to use for convolution ('scipyfft', 'jaxfft', 'classic')
+        :param inplace: if True, the array is modified in place, otherwise a new array is returned
+        :return: convolved array, WolfArray instance
+
+        """
+
+        if isinstance(filter, WolfArray):
+            _filter = filter.array.data.copy()
+            _filter[filter.array.mask] = 0.0
+        elif isinstance(filter, np.ndarray):
+            _filter = filter.copy()
+            _filter[np.isnan(_filter)] = 0.0
+        else:
+            logging.error("Filter must be a WolfArray or a numpy array")
+            return None
+
+        if method == 'classic':
+            from scipy.signal import convolve2d
+            convolved = convolve2d(self.array.data, _filter, mode='same', fillvalue=0.0)
+        elif method == 'scipyfft':
+            from scipy.signal import fftconvolve
+            convolved = fftconvolve(self.array.data, _filter, mode='same')
+        elif method == 'jaxfft':
+            import jax.numpy as jnp
+            from jax.scipy.signal import fftconvolve as jax_fftconvolve
+            jax_filter = jnp.array(_filter)
+            jax_array = jnp.array(self.array.data)
+            convolved = jax_fftconvolve(jax_array, jax_filter, mode='same')
+            convolved = jnp.asarray(convolved)
+        else:
+            logging.error("Method not supported")
+            return None
+
+        if inplace:
+            self.array.data[:,:] = convolved
+            return self
+        else:
+            newWolfArray = WolfArray(mold=self)
+            newWolfArray.array.data[:,:] = convolved
+            newWolfArray.array.mask[:,:] = self.array.mask[:,:]
+            newWolfArray.count()
+            return newWolfArray
+
     def crop_masked_at_edges(self):
 
         """
@@ -9933,11 +10020,26 @@ class WolfArray(Element_To_Draw, header_wolf):
                 logging.error(e)
 
         if (vmin is None) and (vmax is None):
-            im = ax.imshow(self.array.transpose(), origin='lower', cmap=self.mypal,
-                    extent=(self.origx, self.origx + self.dx * self.nbx, self.origy, self.origy + self.dy * self.nby))
-        else:
-            im = ax.imshow(self.array.transpose(), origin='lower', cmap=self.mypal,
-                    extent=(self.origx, self.origx + self.dx * self.nbx, self.origy, self.origy + self.dy * self.nby), vmin=vmin, vmax=vmax)
+            # im = ax.imshow(self.array.transpose(), origin='lower', cmap=self.mypal,
+            #         extent=(self.origx, self.origx + self.dx * self.nbx, self.origy, self.origy + self.dy * self.nby))
+            im = ax.imshow(self.array.transpose(),
+                           origin='lower',
+                           norm = self.mypal.norm,
+                           cmap=self.mypal.cmap,
+                           interpolation='none',
+                           extent=(self.origx,
+                                   self.origx + self.dx * self.nbx,
+                                   self.origy,
+                                   self.origy + self.dy * self.nby))
+        else:
+            im = ax.imshow(self.array.transpose(),
+                           origin='lower',
+                           cmap=self.mypal,
+                           extent=(self.origx,
+                                   self.origx + self.dx * self.nbx,
+                                   self.origy,
+                                   self.origy + self.dy * self.nby),
+                           vmin=vmin, vmax=vmax)
         ax.set_aspect('equal')
 
         if getdata_im:

{wolfhece-2.2.4.dist-info → wolfhece-2.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wolfhece
-Version: 2.2.4
+Version: 2.2.5
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 Project-URL: Homepage, https://uee.uliege.be/hece
 Project-URL: Issues, https://uee.uliege.be/hece

{wolfhece-2.2.4.dist-info → wolfhece-2.2.5.dist-info}/RECORD

@@ -12,13 +12,13 @@ wolfhece/PyDraw.py,sha256=mCIcXgtTT3vvixO_bvo76HlgK9p1MKk1GljGGIuIosw,631732
 wolfhece/PyGui.py,sha256=IU97wVlmer3Q2MpWbJv4MQWH7nYbc5uN4pRzhr4jdlM,145197
 wolfhece/PyGuiHydrology.py,sha256=sKafpOopBg50L5llZCI_fZtbebVTDtxvoRI6-osUwhg,14745
 wolfhece/PyHydrographs.py,sha256=1P5XAURNqCvtSsMQXhOn1ihjTpr725sRsZdlCEhhk6M,3730
-wolfhece/PyPalette.py,sha256=SnzMfzpVblbvq1kItLp52jufk6-R1b0QX3fF6RUKKT4,34842
+wolfhece/PyPalette.py,sha256=k9b_95GYD0USQ8DS5zGXeZ577712U6772kmhEbJtlXw,35406
 wolfhece/PyParams.py,sha256=Dh9C_WYICMjo3m9roRySsu8ZgFzzYhSr6RpbaXZni0M,99423
 wolfhece/PyPictures.py,sha256=m1kY0saW6Y9Q0bDCo47lW6XxDkBrbQG-Fd8uVn8G5ic,2514
 wolfhece/PyTranslate.py,sha256=4appkmNeHHZLFmUtaA_k5_5QL-5ymxnbVN4R2OblmtE,622
 wolfhece/PyVertex.py,sha256=Ym42pHWwEVv6Fu5v-OzhlHiQB46DnvLf9MUe_c3lbR0,45610
 wolfhece/PyVertexvectors.py,sha256=0lt0YyHIz_IxgXqdqPlTDruDwjeP6L1Dw6B2Q35a8kQ,325801
-wolfhece/PyWMS.py,sha256=_HwJh3WVc0eHNCOPlQx40TVCdfXQF86Lb-_qpbzTC2M,8829
+wolfhece/PyWMS.py,sha256=LWkQk3R7miiVal-n5K5P5ClSQJA_vi5ImBxYGuxCx9A,9122
 wolfhece/RatingCurve.py,sha256=bUjIrQjvIjkD4V-z8bZmA6pe1ILtYNM0-3fT6YUY1RU,22498
 wolfhece/RatingCurveData.py,sha256=5UvnIm89BwqjnEbLCcY3CA8WoFd_xHJbooNy62fX5iY,57660
 wolfhece/RatingCurve_xml.py,sha256=cUjReVMHFKtakA2wVey5zz6lCgHlSr72y7ZfswZDvTM,33891
@@ -41,7 +41,7 @@ wolfhece/ins.py,sha256=uUeLMS1n3GPnfJhxl0Z2l-UXpmPUgthuwct282OOEzk,36184
 wolfhece/irm_qdf.py,sha256=DMdDEAYbgYxApObm6w-dZbBmA8ec6PghBLXR2lUEZLc,27457
 wolfhece/ismember.py,sha256=fkLvaH9fhx-p0QrlEzqa6ySO-ios3ysjAgXVXzLgSpY,2482
 wolfhece/lagrange_multiplier.py,sha256=0G-M7b2tGzLx9v0oNYYq4_tLAiHcs_39B4o4W3TUVWM,6567
-wolfhece/lifewatch.py,sha256=TOqmbD_fuxXLvrnx401z5OxMqOBBSn-7Yg6flndWXFE,3324
+wolfhece/lifewatch.py,sha256=AszCItQCq3Z3d-gznsjtYU9FIKJaWAcr1gafBxb-qHs,16265
 wolfhece/matplotlib_fig.py,sha256=vnFI6sghw9N9jKhR8X1Z4aWli_5fPNylZQtFuujFJDY,84075
 wolfhece/multiprojects.py,sha256=Sd6Bl6YP33jlR79A6rvSLu23vq8sqbFYL8lWuVPkEpE,21549
 wolfhece/picc.py,sha256=0X_pzhSBoVxgtTfJ37pkOQO3Vbr9yurPaD1nVeurx8k,8531
@@ -58,7 +58,7 @@ wolfhece/rain_SPWMI.py,sha256=qCfcmF7LajloOaCwnTrrSMzyME03YyilmRUOqrPrv3U,13846
 wolfhece/textpillow.py,sha256=map7HsGYML_o5NHRdFg2s_TVQed_lDnpYNDv27MM0Vw,14130
 wolfhece/tools2d_dll.py,sha256=oU0m9XYAf4CZsMoB68IuKeE6SQh-AqY7O5NVED8r9uw,13125
 wolfhece/tools_mpl.py,sha256=gQ3Jg1iuZiecmMqa5Eli2ZLSkttu68VXL8YmMDBaEYU,564
-wolfhece/wolf_array.py,sha256=t6-gLy1Op3Lx6Nmxv-Yo7cQIW62BinFDRP7x6Qpb5u8,486606
+wolfhece/wolf_array.py,sha256=YtrTYzYhJKMewxDkkaiVjFfd7XBq6DNBE3uHdIpgmJY,490755
 wolfhece/wolf_hist.py,sha256=7jeVrgSkM3ErJO6SRMH_PGzfLjIdw8vTy87kesldggk,3582
 wolfhece/wolf_texture.py,sha256=IvFtekT5iLU2sivZOOlJXpE4CevjTQYSxHaOp4cH_wI,17723
 wolfhece/wolf_tiles.py,sha256=v-HohqaWuMYdn75XLnA22dlloAG90iwnIqrgnB0ASQ4,10488
@@ -86,7 +86,7 @@ wolfhece/apps/curvedigitizer.py,sha256=lEJJwgAfulrrWQc-U6ij6sj59hWN3SZl4Yu1kQxVz
 wolfhece/apps/hydrometry.py,sha256=lhhJsFeb4zGL4bNQTs0co85OQ_6ssL1Oy0OUJCzhfYE,656
 wolfhece/apps/isocurrent.py,sha256=dagmGR8ja9QQ1gwz_8fU-N052hIw-W0mWGVkzLu6C7I,4247
 wolfhece/apps/splashscreen.py,sha256=eCPAUYscZPWDYKBHDBWum_VIcE7WXOCBe1GLHL3KUmU,3088
-wolfhece/apps/version.py,sha256=ZQEA7v7GBHHT9_GNdNPgeQvXG9KlV9xxGk8ae-2UVaU,387
+wolfhece/apps/version.py,sha256=imjv2iLmDitvnvE91s2oHHPHEwKdSfXQkxnrkAddHV4,387
 wolfhece/apps/wolf.py,sha256=j_CgvsL8rwixbVvVD5Z0s7m7cHZ86gmFLojKGuetMls,729
 wolfhece/apps/wolf2D.py,sha256=4z_OPQ3IgaLtjexjMKX9ppvqEYyjFLt1hcfFABy3-jU,703
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -249,6 +249,7 @@ wolfhece/models/6_coul.pal,sha256=z7NK2dg0tAQBUweRQV54dIwJbPM1U5y1AR2LLw19Idw,14
 wolfhece/models/7_coul.pal,sha256=XTnnUyCE8ONokScB2YzYDnSTft7E6sppmr7P-XwMsCE,205
 wolfhece/models/Froude.pal,sha256=FmrvUI01fv4k0ygqDJEYdC1M9Fn72Sr6Sn2IlZAm0KA,138
 wolfhece/models/HECE_169.pptx,sha256=OWJtsWz504A-REFaaxw8lwStHyQU2l7KEeiE7IZvtbk,3396930
+wolfhece/models/Lifewatch.pal,sha256=ZSmJtTvwU37kDlNgtc6ohh2M19EhVSbdeyiJIS4wId8,292
 wolfhece/models/Risque_TAF.pal,sha256=Tnbx-_gIyCszzwmwo0I9vvFfVVKmATjFXS89AoZwTOs,135
 wolfhece/models/blue.pal,sha256=s9-wEPzSiKMMHuKofUB2FPjmyO7HfGM2xWaUJwsKAY8,39
 wolfhece/models/blues.pal,sha256=0ZEU1p9EcKwsCvNjU0s9_9aVakqQ71LDNoddVBAluEs,509
@@ -313,8 +314,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.2.4.dist-info/METADATA,sha256=JJuO3xTYTfqTWVbcVcF-dLDr89VgsykNuEikAt6elpk,2744
-wolfhece-2.2.4.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-wolfhece-2.2.4.dist-info/entry_points.txt,sha256=ZZ-aSfbpdcmo-wo84lRFzBN7LaSnD1XRGSaAKVX-Gpc,522
-wolfhece-2.2.4.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.2.4.dist-info/RECORD,,
+wolfhece-2.2.5.dist-info/METADATA,sha256=9v84rbmTr0ngAwq3vgROTfRNq7plNxUkXPxWVWhoq-E,2744
+wolfhece-2.2.5.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+wolfhece-2.2.5.dist-info/entry_points.txt,sha256=ZZ-aSfbpdcmo-wo84lRFzBN7LaSnD1XRGSaAKVX-Gpc,522
+wolfhece-2.2.5.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.2.5.dist-info/RECORD,,