wolfhece 2.2.42__py3-none-any.whl → 2.2.44__py3-none-any.whl

wolfhece/pywalous.py

@@ -22,6 +22,8 @@ import wx.grid
 
 from .PyTranslate import _
 from .PyPalette import wolfpalette
+from .wolf_array import WolfArray, header_wolf
+
 
 """
 Hydrology classification for Land Use in Wallonia:
@@ -339,8 +341,8 @@ class Walous_data():
 
         """
 
-        self._dir = dir_data    # directory of the data
-        self._fn  = fn          # filename without extension
+        self._dir = str(dir_data)    # directory of the data
+        self._fn  = str(fn)          # filename without extension
         self._extension = extension # extension of the file
         self._gdf = None        # geopandas dataframe
 
@@ -402,6 +404,8 @@ class Walous_data():
 
             chdir(detsdir)
 
+            fnout = str((Path(fnout)).with_suffix(self._extension))
+
             self._gdf.to_file(basename(fnout))
 
             chdir(curdir)
@@ -753,3 +757,143 @@ class Walous_OCS_Legend(wx.Dialog):
 
     def close(self):
         self.Destroy()
+
+
+def get_array_WALOUS_OCS(fname:Path, spatial_res:float, bounds:Union[list[float, float, float, float],list[list[float, float], list[float, float]]]) -> Union[WolfArray, None]:
+    """ Get WALOUS OCS as WolfArray
+
+    :param fname: path to the WALOUS OCS file
+    :param spatial_res: desired spatial resolution (in m)
+    :param bounds: [xmin, ymin, xmax, ymax] or [[xmin, xmax], [ymin, ymax]]
+    :return: WolfArray or None if error
+    """
+
+    if not fname.exists():
+        logging.error(_('WALOUS OCS file not found: {}').format(fname))
+        return None
+
+    # Convert bounds to [[xmin, xmax], [ymin, ymax]] if needed
+    if len(bounds)==4:
+        bounds = [[bounds[0], bounds[2]], [bounds[1], bounds[3]]]
+
+    # Convert bvounds to list to be able to modify it
+    bounds = [list(bounds[0]), list(bounds[1])]
+
+    bounds_copy = [list(bounds[0]), list(bounds[1])]
+
+    header_OCS = header_wolf.read_header(fname)
+    if header_OCS.dx != spatial_res:
+        # Adapt bounds to ensure that the rebin will be correct.
+        # If spatial_res is a multiple of header_OCS.dx, no need to change bounds.
+        # If not, change the bounds to ensure that the crop will include data in all footprints.
+
+        if (bounds[0][0] - header_OCS.origx) % header_OCS.dx != 0:
+            bounds[0][0] = header_OCS.origx + ((bounds[0][0] - header_OCS.origx) // header_OCS.dx) * header_OCS.dx
+        if (bounds[0][1] - bounds[0][0]) % header_OCS.dx != 0:
+            bounds[0][1] = bounds[0][0] + ((bounds[0][1] - bounds[0][0]) // header_OCS.dx + 1) * header_OCS.dx
+        if (bounds[1][0] - header_OCS.origy) % header_OCS.dy != 0:
+            bounds[1][0] = header_OCS.origy + ((bounds[1][0] - header_OCS.origy) // header_OCS.dy) * header_OCS.dy
+        if (bounds[1][1] - bounds[1][0]) % header_OCS.dy != 0:
+            bounds[1][1] = bounds[1][0] + ((bounds[1][1] - bounds[1][0]) // header_OCS.dy + 1) * header_OCS.dy
+
+    locwalous = WolfArray(fname=fname, crop = [bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]])
+
+    if locwalous.dx != spatial_res:
+        locwalous.rebin(spatial_res / locwalous.dx, operation='min')
+        logging.info(_('Rebin to {} m because original data are {} m').format(spatial_res, locwalous.dx))
+        locwalous = WolfArray(mold=locwalous, crop = bounds_copy)
+
+    return locwalous
+
+def get_array_WALOUS_OCS_2023_10m(spatial_res:float, bounds:Union[list[float, float, float, float],list[list[float, float], list[float, float]]]) -> Union[WolfArray, None]:
+    """ Get WALOUS OCS 2023 as WolfArray
+
+    :param spatial_res: desired spatial resolution (in m)
+    :param bounds: [xmin, ymin, xmax, ymax] or [[xmin, xmax], [ymin, ymax]]
+    :return: WolfArray or None if error
+    """
+
+    from wolfhece.pydownloader import toys_dataset
+
+    fname = toys_dataset(dir='Walous_OCS', file='WALOUS_2023_lbt72_10m.tif')
+
+    return get_array_WALOUS_OCS(fname, spatial_res, bounds)
+
+def get_array_WALOUS_OCS_2023_4m(spatial_res:float, bounds:Union[list[float, float, float, float],list[list[float, float], list[float, float]]]) -> Union[WolfArray, None]:
+    """ Get WALOUS OCS 2023 as WolfArray
+
+    :param spatial_res: desired spatial resolution (in m)
+    :param bounds: [xmin, ymin, xmax, ymax] or [[xmin, xmax], [ymin, ymax]]
+    :return: WolfArray or None if error
+    """
+
+    from wolfhece.pydownloader import toys_dataset
+
+    fname = toys_dataset(dir='Walous_OCS', file='WALOUS_2023_lbt72_4m.tif')
+
+    return get_array_WALOUS_OCS(fname, spatial_res, bounds)
+
+def get_array_WALOUS_OCS_2020_10m(spatial_res:float, bounds:Union[list[float, float, float, float],list[list[float, float], list[float, float]]]) -> Union[WolfArray, None]:
+    """ Get WALOUS OCS 2020 as WolfArray
+
+    :param spatial_res: desired spatial resolution (in m)
+    :param bounds: [xmin, ymin, xmax, ymax] or [[xmin, xmax], [ymin, ymax]]
+    :return: WolfArray or None if error
+    """
+
+    from wolfhece.pydownloader import toys_dataset
+
+    fname = toys_dataset(dir='Walous_OCS', file='WALOUS_2020_lbt72_10m.tif')
+
+    return get_array_WALOUS_OCS(fname, spatial_res, bounds)
+
+def get_array_WALOUS_OCS_2020_4m(spatial_res:float, bounds:Union[list[float, float, float, float],list[list[float, float], list[float, float]]]) -> Union[WolfArray, None]:
+    """ Get WALOUS OCS 2020 as WolfArray
+
+    :param spatial_res: desired spatial resolution (in m)
+    :param bounds: [xmin, ymin, xmax, ymax] or [[xmin, xmax], [ymin, ymax]]
+    :return: WolfArray or None if error
+    """
+
+    from wolfhece.pydownloader import toys_dataset
+
+    fname = toys_dataset(dir='Walous_OCS', file='WALOUS_2020_lbt72_4m.tif')
+
+    return get_array_WALOUS_OCS(fname, spatial_res, bounds)
+
+def get_array_WALOUS_UTS(fname:Path, fnout:Path, spatial_res:float, bounds:Union[list[float, float, float, float],list[list[float, float], list[float, float]]], which:Literal['UTS_MAJ_NIV1', 'UTS_MAJ_NIV2'] = 'UTS_MAJ_NIV1') -> Union[WolfArray, None]:
+    """ Get WALOUS UTS as WolfArray
+
+    :param fname: path to the WALOUS UTS file
+    :param spatial_res: desired spatial resolution (in m)
+    :param bounds: [xmin, ymin, xmax, ymax] or [[xmin, xmax], [ymin, ymax]]
+    :param which: which level to use ('UTS_MAJ_NIV1' or 'UTS_MAJ_NIV2')
+    :return: WolfArray or None if error
+    """
+
+    fname = Path(fname)
+    fnout = Path(fnout)
+
+    if not fname.exists():
+        logging.error(_('WALOUS UTS file not found: {}').format(fname))
+        return None
+
+    # Convert bounds to [[xmin, xmax], [ymin, ymax]] if needed
+    if len(bounds)==4:
+        bounds = [[bounds[0], bounds[2]], [bounds[1], bounds[3]]]
+
+    # Convert bvounds to list to be able to modify it
+    bounds = [list(bounds[0]), list(bounds[1])]
+
+    bounds_copy = [list(bounds[0]), list(bounds[1])]
+
+    locwalous = Walous_data(fname.parent, fname.name, extension=fname.suffix, bounds=bounds)
+    ret = locwalous.rasterize(bounds=bounds, layer= which, fn_out=fnout.with_suffix('.tif'), pixel_size=spatial_res)
+
+    ret = Path(ret)
+
+    if ret.exists():
+        locwalous_array = WolfArray(fname=ret)
+        return locwalous_array
+    else:
+        return None

wolfhece/wolf_array.py

@@ -515,6 +515,15 @@ class header_wolf():
             return ([self.origx, self.origx + float(self.nbx) * self.dx],
                     [self.origy, self.origy + float(self.nby) * self.dy])
 
+    def get_scale_yoverx(self):
+        """
+        Return the scale of the array (height over width)
+        """
+        if self.dx == 0 or self.dy == 0 or self.nbx == 0 or self.nby == 0:
+            return 1.
+
+        return float((self.nby * self.dy) / (self.nbx * self.dx))
+
     def get_bounds_ij(self, abs=False):
         """
         Return bounds in indices
@@ -596,6 +605,9 @@ class header_wolf():
         else:
             locij = np.zeros(locxy.shape, dtype=np.int32)
 
+        if locxy.size == 0:
+            return locij
+
         locxy[:,0] -= self.origx
         locxy[:,1] -= self.origy
 
@@ -7693,6 +7705,10 @@ class WolfArray(Element_To_Draw, header_wolf):
         depuis les vertices 3D du polygone
         """
 
+        if vector.area == 0.:
+            logging.error(_('The polygon has no area'))
+            return
+
         if keep not in ['all', 'below', 'above']:
             logging.error(_('keep must be "all", "below" or "above"'))
             raise ValueError
@@ -7702,7 +7718,7 @@ class WolfArray(Element_To_Draw, header_wolf):
             raise ValueError
 
         if self.mngselection is None:
-            destxy = self.get_xy_inside_polygon(working_vector)
+            destxy = self.get_xy_inside_polygon(working_vector, method = 'shapely_strict')
             if len(destxy)==0:
                 logging.debug(_('No points to interpolate'))
                 return
@@ -7720,16 +7736,16 @@ class WolfArray(Element_To_Draw, header_wolf):
             destxy = self.ij2xy_np(destij)
         else:
             if self.SelectionData.nb == 0:
-                destxy = self.get_xy_inside_polygon(working_vector)
+                destxy = self.get_xy_inside_polygon(working_vector, method= 'shapely_strict')
+                if destxy.shape[0] == 0:
+                    logging.debug(_('No points to interpolate'))
+                    return
             else:
                 destxy = self.SelectionData.myselection
 
-                # if isinstance(destxy, list):
-                #     destxy = np.asarray(destxy)
-
-            if len(destxy)==0:
-                logging.debug(_('No points to interpolate'))
-                return
+                if len(destxy)==0:
+                    logging.debug(_('No points to interpolate'))
+                    return
 
             destij = self.xy2ij_np(destxy)
 
@@ -7813,6 +7829,56 @@ class WolfArray(Element_To_Draw, header_wolf):
         for curvec in working_zone.myvectors:
             self.interpolate_on_polygon(curvec, method, keep)
 
+    def interpolate_strictly_on_polyline(self, working_vector:vector, usemask=True, keep:Literal['all', 'below', 'above'] = 'all'):
+        """
+        Interpolation des mailles strictement sous une polyligne.
+
+        On utilise ensuite "interpolate" de shapely pour interpoler les altitudes des mailles
+        depuis les vertices 3D de la polyligne
+        """
+
+        vecls = working_vector.linestring
+        xy = self.get_xy_strictly_on_borders(working_vector, usemask=usemask)
+        if xy.shape[0] == 0:
+            logging.debug(_('No points to interpolate'))
+            return
+        ij = np.asarray([self.get_ij_from_xy(x, y) for x, y in xy])
+        newz = np.asarray([vecls.interpolate(vecls.project(Point(x, y))).z for x, y in xy])
+
+        if keep == 'all':
+            self.array.data[ij[:, 0], ij[:, 1]] = newz
+        elif keep == 'below':
+            locmask = np.where((newz != -99999.) & (newz < self.array.data[ij[:, 0], ij[:, 1]]))
+            self.array.data[ij[locmask][:, 0], ij[locmask][:, 1]] = newz[locmask]
+        elif keep == 'above':
+            locmask = np.where((newz != -99999.) & (newz > self.array.data[ij[:, 0], ij[:, 1]]))
+            self.array.data[ij[locmask][:, 0], ij[locmask][:, 1]] = newz[locmask]
+
+    def interpolate_strictly_on_vertices(self, working_vector:vector, usemask=True, keep:Literal['all', 'below', 'above'] = 'all'):
+        """
+        Interpolation des mailles strictement sous une polyligne.
+
+        On utilise ensuite "interpolate" de shapely pour interpoler les altitudes des mailles
+        depuis les vertices 3D de la polyligne
+        """
+
+        vecls = working_vector.linestring
+        xy = self.get_xy_strictly_on_vertices(working_vector, usemask=usemask)
+        if xy.shape[0] == 0:
+            logging.debug(_('No points to interpolate'))
+            return
+        ij = np.asarray([self.get_ij_from_xy(x, y) for x, y in xy])
+        newz = np.asarray([vecls.interpolate(vecls.project(Point(x, y))).z for x, y in xy])
+
+        if keep == 'all':
+            self.array.data[ij[:, 0], ij[:, 1]] = newz
+        elif keep == 'below':
+            locmask = np.where((newz != -99999.) & (newz < self.array.data[ij[:, 0], ij[:, 1]]))
+            self.array.data[ij[locmask][:, 0], ij[locmask][:, 1]] = newz[locmask]
+        elif keep == 'above':
+            locmask = np.where((newz != -99999.) & (newz > self.array.data[ij[:, 0], ij[:, 1]]))
+            self.array.data[ij[locmask][:, 0], ij[locmask][:, 1]] = newz[locmask]
+
     def interpolate_on_polyline(self, working_vector:vector, usemask=True):
         """
         Interpolation sous une polyligne
@@ -7889,8 +7955,9 @@ class WolfArray(Element_To_Draw, header_wolf):
     def interpolate_on_triangulation(self, coords, triangles,
                                      grid_x=None, grid_y = None,
                                      mask_tri=None,
-                                     interp_method:Literal['matplotlib','scipy'] = 'matplotlib',
-                                     keep:Literal['all', 'below', 'above'] = 'all'):
+                                     interp_method:Literal['matplotlib','scipy'] = 'scipy',
+                                     keep:Literal['all', 'below', 'above'] = 'all',
+                                     points_along_edges:bool = True):
         """
         Interpolation sur une triangulation.
 
@@ -7898,7 +7965,7 @@ class WolfArray(Element_To_Draw, header_wolf):
           - uniquement dans les mailles sélectionnées si elles existent
           - dans les mailles contenues dans la triangulation sinon
 
-        Matplotlib is used by default, but Scipy(griddata) can be used as well. If Matplotlib crashes, try with Scipy.
+        Scipy(griddata) is used by default (more robust), but Matplotlib can be used as well (more strict). If Matplotlib crashes, try with Scipy.
 
         **Matplotlib is more strict on the quality of the triangulation.**
 
@@ -8205,6 +8272,7 @@ class WolfArray(Element_To_Draw, header_wolf):
                 #on force les valeurs masquées à nullvalue afin que l'interpolation n'applique pas ses effets dans cette zone
                 self.array.data[self.array.mask]= self.nullvalue
             except:
+                logging.error(_('Bad triangulation - We will try with Scipy'))
                 use_scipy=True
 
         if interp_method != 'matplotlib' or use_scipy:
@@ -8216,8 +8284,15 @@ class WolfArray(Element_To_Draw, header_wolf):
                     curvec.add_vertex(wolfvertex(coords[curpt,0], coords[curpt,1], coords[curpt,2]))
                 curvec.close_force()
 
+                # if bool(np.isnan(curvec.x).any() or np.isnan(curvec.y).any()):
+                #     continue
                 self.interpolate_on_polygon(curvec, "linear", keep)
 
+                if points_along_edges:
+                    # Test points along edges
+                    self.interpolate_strictly_on_polyline(curvec, usemask=True, keep=keep)
+                    # self.interpolate_strictly_on_vertices(curvec, usemask=True, keep=keep)
+
         self.reset_plot()
         return
 
@@ -9003,7 +9078,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.mask_reset()
 
     def interpolation2D(self, key:str='1'):
-        """ Interpolation 2D basde on selected points in key 1 """
+        """ Interpolation 2D based on selected points in key 1 """
 
         #FIXME : auhtorize interpolation on other keys
 
@@ -9576,6 +9651,113 @@ class WolfArray(Element_To_Draw, header_wolf):
         elif method == 'rasterio':
             return self.get_xy_inside_polygon_rasterio(myvect, usemask)
 
+    def get_xy_strictly_on_borders(self, myvect: vector | Polygon | LineString, usemask:bool=True,
+                                  method:Literal['shapely']='shapely'):
+        """
+        Return the coordinates strictly on the borders of a polygon.
+
+        ATTENTION : Tests are performed numerically, so the results may not be exact
+        in the sense of pure geometry.
+
+        Do not confuse with "get_xy_under_polyline" which
+        "rasterize" the polyline to find useful coordinates.
+
+        :param myvect: target vector
+        :param usemask: limit potential nodes to unmaksed nodes
+        :param method: method to use ('shapely' for now)
+        """
+
+        # As we will use Shapely(contains) to test if points are on the border,
+        # we need to use a Linestring or a Polygon.boundary.
+        if isinstance(myvect, vector):
+            myvect.find_minmax()
+            boundary = myvect.linestring
+        elif isinstance(myvect, Polygon):
+            boundary = myvect.boundary
+        elif isinstance(myvect, LineString):
+            boundary = myvect
+
+        if not is_prepared(boundary):
+            prepare(boundary) # Prepare the polygon for **faster** contains check -- VERY IMPORTANT
+            to_destroy = True
+        else:
+            to_destroy = False
+        mypointsxy, mypointsij = self.get_xy_infootprint_vect(myvect)
+
+        points= np.array([Point(x,y) for x,y in mypointsxy])
+        on_border = list(map(lambda point: boundary.contains(point), points))
+
+        if to_destroy:
+            destroy_prepared(boundary) # Destroy the prepared polygon
+
+        to_keep = np.where(on_border)
+        mypointsxy = mypointsxy[to_keep]
+
+        if mypointsxy.shape[0] == 0:
+            return mypointsxy
+
+        if usemask:
+            mypointsij = mypointsij[to_keep]
+            mymask = np.logical_not(self.array.mask[mypointsij[:, 0], mypointsij[:, 1]])
+            mypointsxy = mypointsxy[np.where(mymask)]
+
+        return mypointsxy
+
+    def get_xy_strictly_on_vertices(self, myvect: vector | Polygon | LineString, usemask:bool=True,
+                                  method:Literal['shapely']='shapely', eps:float = 1.e-4):
+        """
+        Return the coordinates strictly on the vertices of a polygon, Linestring or vector.
+
+        ATTENTION : Tests are performed numerically, so the results may not be exact
+        in the sense of pure geometry.
+
+        :param myvect: target vector
+        :param usemask: limit potential nodes to unmaksed nodes
+        :param method: method to use ('shapely' for now)
+        """
+
+        # As we will use Shapely(contains) to test if points are on the border,
+        # we need to use a Linestring or a Polygon.boundary.
+        if isinstance(myvect, vector):
+            myvect.find_minmax()
+            boundary = myvect.linestring
+        elif isinstance(myvect, Polygon):
+            boundary = myvect.boundary
+        elif isinstance(myvect, LineString):
+            boundary = myvect
+
+        if not is_prepared(boundary):
+            prepare(boundary) # Prepare the polygon for **faster** contains check -- VERY IMPORTANT
+            to_destroy = True
+        else:
+            to_destroy = False
+
+        mypointsxy, mypointsij = self.get_xy_infootprint_vect(myvect)
+
+        # Calculate distances to the vertices
+        # We use the vertices of the polygon or linestring to check if points are on the
+        # vertices.
+
+        points      = np.array([Point(x,y) for x,y in mypointsxy])
+        vertices    = [Point(pt[0], pt[1], pt[2]) for pt in boundary.coords]
+        on_vertices = list(map(lambda point: any(vert.distance(point) < eps for vert in vertices), points))
+
+        if to_destroy:
+            destroy_prepared(boundary) # Destroy the prepared polygon
+
+        to_keep = np.where(on_vertices)
+        mypointsxy = mypointsxy[to_keep]
+
+        if mypointsxy.shape[0] == 0:
+            return mypointsxy
+
+        if usemask:
+            mypointsij = mypointsij[to_keep]
+            mymask = np.logical_not(self.array.mask[mypointsij[:, 0], mypointsij[:, 1]])
+            mypointsxy = mypointsxy[np.where(mymask)]
+
+        return mypointsxy
+
     def get_xy_inside_polygon_mpl(self, myvect: vector | Polygon, usemask:bool=True):
         """
         Return the coordinates inside a polygon
@@ -9641,10 +9823,14 @@ class WolfArray(Element_To_Draw, header_wolf):
         if to_destroy:
             destroy_prepared(polygon) # Destroy the prepared polygon
 
-        mypointsxy = mypointsxy[np.where(inside)]
+        to_keep = np.where(inside)
+        mypointsxy = mypointsxy[to_keep]
+
+        if mypointsxy.shape[0] == 0:
+            return mypointsxy
 
         if usemask:
-            mypointsij = mypointsij[np.where(inside)]
+            mypointsij = mypointsij[to_keep]
             mymask = np.logical_not(self.array.mask[mypointsij[:, 0], mypointsij[:, 1]])
             mypointsxy = mypointsxy[np.where(mymask)]
 
@@ -9710,6 +9896,33 @@ class WolfArray(Element_To_Draw, header_wolf):
         elif method == 'rasterio':
             return self._get_ij_inside_polygon_rasterio(myvect, usemask, eps)
 
+
+    def get_ij_inside_listofpolygons(self, myvects: list[vector | Polygon],
+                                        usemask:bool=True, eps:float = 0.,
+                                        method:Literal['mpl', 'shapely_strict', 'shapely_wboundary', 'rasterio']='shapely_strict'):
+        """
+        Return the indices inside a list of polygons
+        :param myvects: target vector
+        :param usemask: limit potential nodes to unmaksed nodes
+        :param eps: epsilon for the intersection
+        """
+        if isinstance(myvects, zone):
+            myvects = myvects.myvectors
+
+        alls = list(map(lambda vec: self.get_ij_inside_polygon(vec, usemask, method=method), myvects))
+        #remove empty arrays
+        alls = [cur for cur in alls if cur.shape[0] > 0]
+        if len(alls) == 0:
+            return np.empty((0, 2), dtype=int)
+        # Concatenate all arrays
+        mypointsij = np.concatenate(alls, axis=0)
+        # Remove duplicates
+        mypointsij = np.unique(mypointsij, axis=0)
+        if mypointsij.shape[0] == 0:
+            return np.empty((0, 2), dtype=int)
+        return mypointsij
+
+
     def get_ij_inside_polygon_mpl(self, myvect: vector | Polygon, usemask:bool=True, eps:float = 0.):
         """
         Return the indices inside a polygon
@@ -11683,16 +11896,16 @@ class WolfArray(Element_To_Draw, header_wolf):
                 try:
                     bounds = self.get_bounds()
 
-                    scale_xovery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
+                    scale_covery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
 
-                    if scale_xovery > 1.:
+                    if scale_covery > 1.:
                         # x is larger than y
                         w = 2000
-                        h = int(2000 / scale_xovery)
+                        h = int(2000 / scale_covery)
                     else:
                         # y is larger than x
                         h = 2000
-                        w = int(2000 * scale_xovery)
+                        w = int(2000 * scale_covery)
 
                     IO_image = getWalonmap(cat, bounds[0][0], bounds[1][0],
                                         bounds[0][1], bounds[1][1],
@@ -11716,15 +11929,15 @@ class WolfArray(Element_To_Draw, header_wolf):
             else:
                 try:
                     bounds = self.get_bounds()
-                    scale_xovery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
-                    if scale_xovery > 1.:
+                    scale_covery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
+                    if scale_covery > 1.:
                         # x is larger than y
                         w = 2000
-                        h = int(2000 / scale_xovery)
+                        h = int(2000 / scale_covery)
                     else:
                         # y is larger than x
                         h = 2000
-                        w = int(2000 * scale_xovery)
+                        w = int(2000 * scale_covery)
                     IO_image = getNGI(cat, bounds[0][0], bounds[1][0],
                                     bounds[0][1], bounds[1][1],
                                         w=w, h=h, tofile=False) # w=self.nbx, h=self.nby
@@ -11744,15 +11957,15 @@ class WolfArray(Element_To_Draw, header_wolf):
             else:
                 try:
                     bounds = self.get_bounds()
-                    scale_xovery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
-                    if scale_xovery > 1.:
+                    scale_covery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
+                    if scale_covery > 1.:
                         # x is larger than y
                         w = 2000
-                        h = int(2000 / scale_xovery)
+                        h = int(2000 / scale_covery)
                     else:
                         # y is larger than x
                         h = 2000
-                        w = int(2000 * scale_xovery)
+                        w = int(2000 * scale_covery)
                     IO_image = getCartoweb(cat, bounds[0][0], bounds[1][0],
                                             bounds[0][1], bounds[1][1],
                                             w=w, h=h, tofile=False) # w=self.nbx, h=self.nby
@@ -11779,8 +11992,8 @@ class WolfArray(Element_To_Draw, header_wolf):
                                    self.origx + self.dx * self.nbx,
                                    self.origy,
                                    self.origy + self.dy * self.nby),
-                            alpha=np.select([self.array.mask.T, ~self.array.mask.T],
-                                            [np.zeros(self.shape).T, np.ones(self.shape).T]))
+                           alpha=np.select([self.array.mask.T, ~self.array.mask.T],
+                                            [np.zeros(self.shape).T, np.ones(self.shape).T * self.alpha]))
 
             if with_legend:
                 # add a legend in a new axis
@@ -11809,7 +12022,7 @@ class WolfArray(Element_To_Draw, header_wolf):
                                    self.origy + self.dy * self.nby),
                            vmin=vmin, vmax=vmax,
                            alpha=np.select([self.array.mask.T, ~self.array.mask.T],
-                                           [np.zeros(self.shape).T, np.ones(self.shape).T])                           )
+                                           [np.zeros(self.shape).T, np.ones(self.shape).T * self.alpha]))
 
 
             if with_legend:

{wolfhece-2.2.42.dist-info → wolfhece-2.2.44.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wolfhece
-Version: 2.2.42
+Version: 2.2.44
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 Project-URL: Homepage, https://uee.uliege.be/hece
 Project-URL: Issues, https://uee.uliege.be/hece
@@ -73,7 +73,7 @@ Requires-Dist: tabulate
 Requires-Dist: ipympl
 Requires-Dist: contextily
 Requires-Dist: pefile
-Requires-Dist: wolfpydike
+Requires-Dist: wolfpydike==0.1.3
 Requires-Dist: PyMuPDF
 Requires-Dist: eccodes
 Requires-Dist: dataframe_image