yirgacheffe 1.5.0__tar.gz → 1.6.0__tar.gz

{yirgacheffe-1.5.0/yirgacheffe.egg-info → yirgacheffe-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yirgacheffe
-Version: 1.5.0
+Version: 1.6.0
 Summary: Abstraction of gdal datasets for doing basic math operations
 Author-email: Michael Dales <mwd24@cam.ac.uk>
 License-Expression: ISC
@@ -107,7 +107,7 @@ If you have set either the intersection window or union window on a layer and yo
 
 ### Direct access to data
 
-If doing per-layer operations isn't applicable for your application, you can read the pixel values for all layers (including VectorLayers) by calling `read_array` similarly to how you would for gdal. The data you access will be relative to the specified window - that is, if you've called either `set_window_for_intersection` or `set_window_for_union` then `read_array` will be relative to that and Yirgacheffe will clip or expand the data with zero values as necessary.
+If doing per-layer operations isn't applicable for your application, you can read the pixel values for all layers (including VectorLayers) by calling `read_array` similarly to how you would for GDAL. The data you access will be relative to the specified window - that is, if you've called either `set_window_for_intersection` or `set_window_for_union` then `read_array` will be relative to that and Yirgacheffe will clip or expand the data with zero values as necessary.
 
 
 ## Layer types
@@ -160,6 +160,7 @@ with RasterLayer.layer_from_file('test1.tif') as source:
     scaled = RasterLayer.scaled_raster_from_raster(source, PixelScale(0.0001, -0.0001), 'scaled.tif')
 ```
 
+If the data is from a GeoTIFF that has a nodata value specified, then pixel values with that specified nodata value in them will be converted to NaN. You can override that by providing `ignore_nodata=True` as an optional argument to `layer_from_file` (or with the new 2.0 API, `read_raster`). You can find out if a layer has a nodata value by accessing the `nodata` property - it is None if there is no such value.
 
 ### VectorLayer
 
@@ -229,6 +230,9 @@ with yg.read_rasters(['tile_N10_E10.tif', 'tile_N20_E10.tif']) as all_tiles:
     ...
 ```
 
+If any of the layers have a `nodata` value specified, then any pixel with that value will be masked out to allow data from other layers to be visible.
+
+
 ### TiledGroupLayer
 
 This is a specialisation of GroupLayer, which you can use if your layers are all the same size and form a grid, as is often the case with map tiles. In this case the rendering code can be optimised and this class is significantly faster that GroupLayer.

{yirgacheffe-1.5.0 → yirgacheffe-1.6.0}/README.md

@@ -82,7 +82,7 @@ If you have set either the intersection window or union window on a layer and yo
 
 ### Direct access to data
 
-If doing per-layer operations isn't applicable for your application, you can read the pixel values for all layers (including VectorLayers) by calling `read_array` similarly to how you would for gdal. The data you access will be relative to the specified window - that is, if you've called either `set_window_for_intersection` or `set_window_for_union` then `read_array` will be relative to that and Yirgacheffe will clip or expand the data with zero values as necessary.
+If doing per-layer operations isn't applicable for your application, you can read the pixel values for all layers (including VectorLayers) by calling `read_array` similarly to how you would for GDAL. The data you access will be relative to the specified window - that is, if you've called either `set_window_for_intersection` or `set_window_for_union` then `read_array` will be relative to that and Yirgacheffe will clip or expand the data with zero values as necessary.
 
 
 ## Layer types
@@ -135,6 +135,7 @@ with RasterLayer.layer_from_file('test1.tif') as source:
     scaled = RasterLayer.scaled_raster_from_raster(source, PixelScale(0.0001, -0.0001), 'scaled.tif')
 ```
 
+If the data is from a GeoTIFF that has a nodata value specified, then pixel values with that specified nodata value in them will be converted to NaN. You can override that by providing `ignore_nodata=True` as an optional argument to `layer_from_file` (or with the new 2.0 API, `read_raster`). You can find out if a layer has a nodata value by accessing the `nodata` property - it is None if there is no such value.
 
 ### VectorLayer
 
@@ -204,6 +205,9 @@ with yg.read_rasters(['tile_N10_E10.tif', 'tile_N20_E10.tif']) as all_tiles:
     ...
 ```
 
+If any of the layers have a `nodata` value specified, then any pixel with that value will be masked out to allow data from other layers to be visible.
+
+
 ### TiledGroupLayer
 
 This is a specialisation of GroupLayer, which you can use if your layers are all the same size and form a grid, as is often the case with map tiles. In this case the rendering code can be optimised and this class is significantly faster that GroupLayer.

{yirgacheffe-1.5.0 → yirgacheffe-1.6.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "yirgacheffe"
-version = "1.5.0"
+version = "1.6.0"
 description = "Abstraction of gdal datasets for doing basic math operations"
 readme = "README.md"
 authors = [{ name = "Michael Dales", email = "mwd24@cam.ac.uk" }]

{yirgacheffe-1.5.0 → yirgacheffe-1.6.0}/tests/test_datatypes.py

@@ -44,7 +44,6 @@ def test_round_trip_from_gdal(ytype) -> None:
 def test_round_trip_float64() -> None:
     backend_type = backend.dtype_to_backed(DataType.Float64)
     ytype = backend.backend_to_dtype(backend_type)
-    print(BACKEND, "sad")
     match BACKEND:
         case "NUMPY":
             assert ytype == DataType.Float64

yirgacheffe-1.6.0/tests/test_nodata.py

@@ -0,0 +1,64 @@
+import numpy as np
+
+from yirgacheffe.layers.rasters import RasterLayer
+from yirgacheffe.layers.group import GroupLayer
+
+from tests.helpers import gdal_dataset_with_data
+
+def test_raster_without_nodata_value() -> None:
+    data1 = np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 5.0, 8.0]])
+    dataset = gdal_dataset_with_data((0.0, 0.0), 0.02, data1)
+    with RasterLayer(dataset) as layer:
+        assert layer.nodata is None
+        actual = layer.read_array(0, 0, 4, 2)
+        assert np.array_equal(data1, actual, equal_nan=True)
+
+def test_raster_with_nodata_value() -> None:
+    data1 = np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 5.0, 8.0]])
+    dataset = gdal_dataset_with_data((0.0, 0.0), 0.02, data1)
+    dataset.GetRasterBand(1).SetNoDataValue(5.0)
+    with RasterLayer(dataset) as layer:
+        assert layer.nodata == 5.0
+        data1[data1 == 5.0] = np.nan
+        actual = layer.read_array(0, 0, 4, 2)
+        assert np.array_equal(data1, actual, equal_nan=True)
+
+def test_raster_with_nodata_value_ignored() -> None:
+    data1 = np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 5.0, 8.0]])
+    dataset = gdal_dataset_with_data((0.0, 0.0), 0.02, data1)
+    dataset.GetRasterBand(1).SetNoDataValue(5.0)
+    with RasterLayer(dataset, ignore_nodata=True) as layer:
+        assert layer.nodata == 5.0
+        actual = layer.read_array(0, 0, 4, 2)
+        assert np.array_equal(data1, actual, equal_nan=True)
+
+def test_group_layer_with_nodata_values() -> None:
+    data1 = np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 5.0, 5.0, 5.0]])
+    dataset1 = gdal_dataset_with_data((0.0, 0.0), 0.02, data1)
+    dataset1.GetRasterBand(1).SetNoDataValue(5.0)
+
+    data2 = np.array([[1.0, 1.0, 1.0, 1.0], [5.0, 6.0, 7.0, 8.0]])
+    dataset2 = gdal_dataset_with_data((0.0, 0.0), 0.02, data2)
+    dataset2.GetRasterBand(1).SetNoDataValue(1.0)
+
+    with RasterLayer(dataset1) as layer1:
+        with RasterLayer(dataset2) as layer2:
+            with GroupLayer([layer1, layer2]) as group:
+                actual = group.read_array(0, 0, 4, 2)
+                expected = np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]])
+                assert np.array_equal(expected, actual, equal_nan=True)
+
+def test_group_layer_with_nodata_values_ignore_nodata() -> None:
+    data1 = np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 5.0, 5.0, 5.0]])
+    dataset1 = gdal_dataset_with_data((0.0, 0.0), 0.02, data1)
+    dataset1.GetRasterBand(1).SetNoDataValue(5.0)
+
+    data2 = np.array([[1.0, 1.0, 1.0, 1.0], [5.0, 6.0, 7.0, 8.0]])
+    dataset2 = gdal_dataset_with_data((0.0, 0.0), 0.02, data2)
+    dataset2.GetRasterBand(1).SetNoDataValue(1.0)
+
+    with RasterLayer(dataset1, ignore_nodata=True) as layer1:
+        with RasterLayer(dataset2, ignore_nodata=True) as layer2:
+            with GroupLayer([layer1, layer2]) as group:
+                actual = group.read_array(0, 0, 4, 2)
+                assert np.array_equal(data1, actual, equal_nan=True)

{yirgacheffe-1.5.0 → yirgacheffe-1.6.0}/tests/test_raster.py

@@ -56,12 +56,12 @@ def test_open_file() -> None:
         dataset = gdal_dataset_of_region(area, 0.02, filename=path)
         dataset.Close()
         assert os.path.exists(path)
-        layer = RasterLayer.layer_from_file(path)
-        assert layer.area == area
-        assert layer.pixel_scale == (0.02, -0.02)
-        assert layer.geo_transform == (-10, 0.02, 0.0, 10, 0.0, -0.02)
-        assert layer.window == Window(0, 0, 1000, 1000)
-        del layer
+        with RasterLayer.layer_from_file(path) as layer:
+            assert layer.area == area
+            assert layer.pixel_scale == (0.02, -0.02)
+            assert layer.geo_transform == (-10, 0.02, 0.0, 10, 0.0, -0.02)
+            assert layer.window == Window(0, 0, 1000, 1000)
+            del layer
 
 @pytest.mark.parametrize("initial_area",
     [

{yirgacheffe-1.5.0 → yirgacheffe-1.6.0}/yirgacheffe/_core.py

@@ -10,7 +10,8 @@ from .operators import DataType
 
 def read_raster(
     filename: Union[Path,str],
-    band: int = 1
+    band: int = 1,
+    ignore_nodata: bool = False,
 ) -> RasterLayer:
     """Open a raster file (e.g., GeoTIFF).
 
@@ -19,14 +20,16 @@ def read_raster(
     filename : Path
         Path of raster file to open.
     band : int, default=1
-        For multi-band rasters, which band to use (defaults to first if not specified).
+        For multi-band rasters, which band to use (defaults to first if not specified)
+    ignore_nodata : bool, default=False
+        If the GeoTIFF has a NODATA value, don't subsitute that value for NaN
 
     Returns
     -------
     RasterLayer
         Returns an layer representing the raster data.
     """
-    return RasterLayer.layer_from_file(filename, band)
+    return RasterLayer.layer_from_file(filename, band, ignore_nodata)
 
 def read_rasters(
     filenames : Union[List[Path],List[str]],

{yirgacheffe-1.5.0 → yirgacheffe-1.6.0}/yirgacheffe/layers/area.py

@@ -56,12 +56,12 @@ class UniformAreaLayer(RasterLayer):
                 return False
         return True
 
-    def __init__(self, dataset, name: Optional[str] = None, band: int = 1):
+    def __init__(self, dataset, name: Optional[str] = None, band: int = 1, ignore_nodata: bool = False):
         if dataset.RasterXSize > 1:
             raise ValueError("Expected a shrunk dataset")
         self.databand = dataset.GetRasterBand(1).ReadAsArray(0, 0, 1, dataset.RasterYSize)
 
-        super().__init__(dataset, name, band)
+        super().__init__(dataset, name, band, ignore_nodata)
 
         transform = dataset.GetGeoTransform()
 
@@ -84,7 +84,14 @@ class UniformAreaLayer(RasterLayer):
         )
         self._raster_xsize = self.window.xsize
 
-    def read_array_with_window(self, xoffset: int, yoffset: int, xsize: int, ysize: int, window: Window) -> Any:
+    def _read_array_with_window(
+        self,
+        xoffset: int,
+        yoffset: int,
+        xsize: int,
+        ysize: int,
+        window: Window,
+    ) -> Any:
         if ysize <= 0:
             raise ValueError("Request dimensions must be positive and non-zero")
         offset = window.yoff + yoffset

{yirgacheffe-1.5.0 → yirgacheffe-1.6.0}/yirgacheffe/layers/base.py

@@ -66,6 +66,10 @@ class YirgacheffeLayer(LayerMathMixin):
             raise AttributeError("Layer has no window")
         return self._window
 
+    @property
+    def nodata(self) -> None:
+        return None
+
     @staticmethod
     def find_intersection(layers: Sequence[YirgacheffeLayer]) -> Area:
         if not layers:
@@ -227,10 +231,24 @@ class YirgacheffeLayer(LayerMathMixin):
         self._window = new_window
         self._active_area = new_area
 
-    def read_array_with_window(self, _x: int, _y: int, _xsize: int, _ysize: int, window: Window) -> Any:
+    def _read_array_with_window(
+        self,
+        _x: int,
+        _y: int,
+        _xsize: int,
+        _ysize: int,
+        _window: Window,
+    ) -> Any:
         raise NotImplementedError("Must be overridden by subclass")
 
-    def read_array_for_area(self, target_area: Area, x: int, y: int, width: int, height: int) -> Any:
+    def _read_array_for_area(
+        self,
+        target_area: Area,
+        x: int,
+        y: int,
+        width: int,
+        height: int,
+    ) -> Any:
         assert self._pixel_scale is not None
 
         target_window = Window(
@@ -247,10 +265,28 @@ class YirgacheffeLayer(LayerMathMixin):
                 (self._pixel_scale.ystep * -1.0)
             ),
         )
-        return self.read_array_with_window(x, y, width, height, target_window)
+        return self._read_array_with_window(x, y, width, height, target_window)
 
     def read_array(self, x: int, y: int, width: int, height: int) -> Any:
-        return self.read_array_with_window(x, y, width, height, self.window)
+        """Reads data from the layer based on the current reference window.
+
+        Arguments
+        ---------
+        x : int
+            X axis offset for reading
+        y : int
+            Y axis offset for reading
+        width : int
+            Width of data to read
+        height : int
+            Height of data to read
+
+        Results
+        -------
+        Any
+            An array of values from the layer.
+        """
+        return self._read_array_with_window(x, y, width, height, self.window)
 
     def latlng_for_pixel(self, x_coord: int, y_coord: int) -> Tuple[float,float]:
         """Get geo coords for pixel. This is relative to the set view window."""

{yirgacheffe-1.5.0 → yirgacheffe-1.6.0}/yirgacheffe/layers/constant.py

@@ -28,8 +28,22 @@ class ConstantLayer(YirgacheffeLayer):
     def read_array(self, _x: int, _y: int, width: int, height: int) -> Any:
         return backend.full((height, width), self.value)
 
-    def read_array_with_window(self, _x: int, _y: int, width: int, height: int, _window: Window) -> Any:
+    def _read_array_with_window(
+        self,
+        _x: int,
+        _y: int,
+        width: int,
+        height: int,
+        _window: Window,
+    ) -> Any:
         return backend.full((height, width), self.value)
 
-    def read_array_for_area(self, _target_area: Area, x: int, y: int, width: int, height: int) -> Any:
+    def _read_array_for_area(
+        self,
+        _target_area: Area,
+        x: int,
+        y: int,
+        width: int,
+        height: int,
+    ) -> Any:
         return self.read_array(x, y, width, height)

{yirgacheffe-1.5.0 → yirgacheffe-1.6.0}/yirgacheffe/layers/group.py

@@ -4,8 +4,9 @@ from pathlib import Path
 from typing import Any, List, Optional, Union
 
 import numpy as np
-from yirgacheffe.operators import DataType
+from numpy import ma
 
+from ..operators import DataType
 from ..rounding import are_pixel_scales_equal_enough, round_down_pixels
 from ..window import Area, Window
 from .base import YirgacheffeLayer
@@ -104,8 +105,14 @@ class GroupLayer(YirgacheffeLayer):
         except AttributeError:
             pass # called from Base constructor before we've added the extra field
 
-    def read_array_with_window(self, xoffset: int, yoffset: int, xsize: int, ysize: int, window: Window) -> Any:
-
+    def _read_array_with_window(
+        self,
+        xoffset: int,
+        yoffset: int,
+        xsize: int,
+        ysize: int,
+        window: Window,
+    ) -> Any:
         if (xsize <= 0) or (ysize <= 0):
             raise ValueError("Request dimensions must be positive and non-zero")
 
@@ -139,12 +146,15 @@ class GroupLayer(YirgacheffeLayer):
         if len(contributing_layers) == 1:
             layer, adjusted_layer_window, intersection = contributing_layers[0]
             if target_window == intersection:
-                return layer.read_array(
+                data = layer.read_array(
                     intersection.xoff - adjusted_layer_window.xoff,
                     intersection.yoff - adjusted_layer_window.yoff,
                     intersection.xsize,
                     intersection.ysize
                 )
+                if layer.nodata is not None:
+                    data[data.isnan()] = 0.0
+                return data
 
         result = np.zeros((ysize, xsize), dtype=float)
         for layer, adjusted_layer_window, intersection in contributing_layers:
@@ -152,14 +162,26 @@ class GroupLayer(YirgacheffeLayer):
                 intersection.xoff - adjusted_layer_window.xoff,
                 intersection.yoff - adjusted_layer_window.yoff,
                 intersection.xsize,
-                intersection.ysize
+                intersection.ysize,
             )
             result_x_offset = (intersection.xoff - xoffset) - window.xoff
             result_y_offset = (intersection.yoff - yoffset) - window.yoff
-            result[
-                result_y_offset:result_y_offset + intersection.ysize,
-                result_x_offset:result_x_offset + intersection.xsize
-            ] = data
+            if layer.nodata is None:
+                result[
+                    result_y_offset:result_y_offset + intersection.ysize,
+                    result_x_offset:result_x_offset + intersection.xsize
+                ] = data
+            else:
+                masked = ma.masked_invalid(data)
+                before = result[
+                    result_y_offset:result_y_offset + intersection.ysize,
+                    result_x_offset:result_x_offset + intersection.xsize
+                ]
+                merged = ma.where(masked.mask, before, masked)
+                result[
+                    result_y_offset:result_y_offset + intersection.ysize,
+                    result_x_offset:result_x_offset + intersection.xsize
+                ] = merged
 
         return backend.promote(result)
 
@@ -214,7 +236,14 @@ class TiledGroupLayer(GroupLayer):
     * You can have missing tiles, and it'll fill in zeros.
     * The tiles can overlap - e.g., JRC Annual Change tiles all overlap by a few pixels on all edges.
     """
-    def read_array_with_window(self, xoffset: int, yoffset: int, xsize: int, ysize: int, window: Window) -> Any:
+    def _read_array_with_window(
+        self,
+        xoffset: int,
+        yoffset: int,
+        xsize: int,
+        ysize: int,
+        window: Window,
+    ) -> Any:
         if (xsize <= 0) or (ysize <= 0):
             raise ValueError("Request dimensions must be positive and non-zero")
 

{yirgacheffe-1.5.0 → yirgacheffe-1.6.0}/yirgacheffe/layers/h3layer.py

@@ -82,7 +82,14 @@ class H3CellLayer(YirgacheffeLayer):
     def datatype(self) -> DataType:
         return DataType.Float64
 
-    def read_array_with_window(self, xoffset: int, yoffset: int, xsize: int, ysize: int, window: Window) -> Any:
+    def _read_array_with_window(
+        self,
+        xoffset: int,
+        yoffset: int,
+        xsize: int,
+        ysize: int,
+        window: Window,
+    ) -> Any:
         assert self._pixel_scale is not None
 
         if (xsize <= 0) or (ysize <= 0):

{yirgacheffe-1.5.0 → yirgacheffe-1.6.0}/yirgacheffe/layers/rasters.py

@@ -214,7 +214,12 @@ class RasterLayer(YirgacheffeLayer):
         return RasterLayer(dataset)
 
     @classmethod
-    def layer_from_file(cls, filename: Union[Path,str], band: int = 1) -> RasterLayer:
+    def layer_from_file(
+        cls,
+        filename: Union[Path,str],
+        band: int = 1,
+        ignore_nodata: bool = False,
+    ) -> RasterLayer:
         try:
             dataset = gdal.Open(filename, gdal.GA_ReadOnly)
         except RuntimeError as exc:
@@ -224,9 +229,15 @@ class RasterLayer(YirgacheffeLayer):
             _ = dataset.GetRasterBand(band)
         except RuntimeError as exc:
             raise InvalidRasterBand(band) from exc
-        return cls(dataset, str(filename), band)
-
-    def __init__(self, dataset: gdal.Dataset, name: Optional[str] = None, band: int = 1):
+        return cls(dataset, str(filename), band, ignore_nodata)
+
+    def __init__(
+        self,
+        dataset: gdal.Dataset,
+        name: Optional[str] = None,
+        band: int = 1,
+        ignore_nodata: bool = False,
+    ) -> None:
         if not dataset:
             raise ValueError("None is not a valid dataset")
 
@@ -256,6 +267,7 @@ class RasterLayer(YirgacheffeLayer):
         self._band = band
         self._raster_xsize = dataset.RasterXSize
         self._raster_ysize = dataset.RasterYSize
+        self._ignore_nodata = ignore_nodata
 
     @property
     def _raster_dimensions(self) -> Tuple[int,int]:
@@ -305,7 +317,21 @@ class RasterLayer(YirgacheffeLayer):
         assert self._dataset
         return DataType.of_gdal(self._dataset.GetRasterBand(1).DataType)
 
-    def read_array_with_window(self, xoffset: int, yoffset: int, xsize: int, ysize: int, window: Window) -> Any:
+    @property
+    def nodata(self) -> Optional[Any]:
+        if self._dataset is None:
+            self._unpark()
+        assert self._dataset
+        return self._dataset.GetRasterBand(self._band).GetNoDataValue()
+
+    def _read_array_with_window(
+        self,
+        xoffset: int,
+        yoffset: int,
+        xsize: int,
+        ysize: int,
+        window: Window,
+    ) -> Any:
         if self._dataset is None:
             self._unpark()
         assert self._dataset
@@ -335,7 +361,6 @@ class RasterLayer(YirgacheffeLayer):
         if target_window == intersection:
             # The target window is a subset of or equal to the source, so we can just ask for the data
             data = backend.promote(self._dataset.GetRasterBand(self._band).ReadAsArray(*intersection.as_array_args))
-            return data
         else:
             # We should read the intersection from the array, and the rest should be zeros
             subset = backend.promote(self._dataset.GetRasterBand(self._band).ReadAsArray(*intersection.as_array_args))
@@ -350,4 +375,9 @@ class RasterLayer(YirgacheffeLayer):
                 )
             )).astype(int)
             data = backend.pad(subset, region, mode='constant')
-            return data
+
+        nodata = self.nodata
+        if not self._ignore_nodata and nodata is not None:
+            data = backend.where(data == nodata, float("nan"), data)
+
+        return data

{yirgacheffe-1.5.0 → yirgacheffe-1.6.0}/yirgacheffe/layers/rescaled.py

@@ -62,7 +62,14 @@ class RescaledRasterLayer(YirgacheffeLayer):
     def datatype(self) -> DataType:
         return self._src.datatype
 
-    def read_array_with_window(self, xoffset: int, yoffset: int, xsize: int, ysize: int, window: Window) -> Any:
+    def _read_array_with_window(
+        self,
+        xoffset: int,
+        yoffset: int,
+        xsize: int,
+        ysize: int,
+        window: Window,
+    ) -> Any:
 
         # to avoid aliasing issues, we try to scale to the nearest pixel
         # and recrop when scaling bigger

{yirgacheffe-1.5.0 → yirgacheffe-1.6.0}/yirgacheffe/layers/vectors.py

@@ -359,7 +359,14 @@ class VectorLayer(YirgacheffeLayer):
     def datatype(self) -> DataType:
         return self._datatype
 
-    def read_array_for_area(self, target_area: Area, x: int, y: int, width: int, height: int) -> Any:
+    def _read_array_for_area(
+        self,
+        target_area: Area,
+        x: int,
+        y: int,
+        width: int,
+        height: int,
+    ) -> Any:
         assert self._pixel_scale is not None
 
         if self._original is None:
@@ -399,8 +406,8 @@ class VectorLayer(YirgacheffeLayer):
         res = backend.promote(dataset.ReadAsArray(0, 0, width, height))
         return res
 
-    def read_array_with_window(self, _x, _y, _width, _height, _window) -> Any:
+    def _read_array_with_window(self, _x, _y, _width, _height, _window) -> Any:
         assert NotRequired
 
     def read_array(self, x: int, y: int, width: int, height: int) -> Any:
-        return self.read_array_for_area(self._active_area, x, y, width, height)
+        return self._read_array_for_area(self._active_area, x, y, width, height)

{yirgacheffe-1.5.0 → yirgacheffe-1.6.0}/yirgacheffe/operators.py

@@ -98,9 +98,9 @@ class LayerMathMixin:
     def _eval(self, area, index, step, target_window=None):
         try:
             window = self.window if target_window is None else target_window
-            return self.read_array_for_area(area, 0, index, window.xsize, step)
+            return self._read_array_for_area(area, 0, index, window.xsize, step)
         except AttributeError:
-            return self.read_array_for_area(area, 0, index, target_window.xsize if target_window else 1, step)
+            return self._read_array_for_area(area, 0, index, target_window.xsize if target_window else 1, step)
 
     def nan_to_num(self, nan=0, posinf=None, neginf=None):
         return LayerOperation(

{yirgacheffe-1.5.0 → yirgacheffe-1.6.0/yirgacheffe.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yirgacheffe
-Version: 1.5.0
+Version: 1.6.0
 Summary: Abstraction of gdal datasets for doing basic math operations
 Author-email: Michael Dales <mwd24@cam.ac.uk>
 License-Expression: ISC
@@ -107,7 +107,7 @@ If you have set either the intersection window or union window on a layer and yo
 
 ### Direct access to data
 
-If doing per-layer operations isn't applicable for your application, you can read the pixel values for all layers (including VectorLayers) by calling `read_array` similarly to how you would for gdal. The data you access will be relative to the specified window - that is, if you've called either `set_window_for_intersection` or `set_window_for_union` then `read_array` will be relative to that and Yirgacheffe will clip or expand the data with zero values as necessary.
+If doing per-layer operations isn't applicable for your application, you can read the pixel values for all layers (including VectorLayers) by calling `read_array` similarly to how you would for GDAL. The data you access will be relative to the specified window - that is, if you've called either `set_window_for_intersection` or `set_window_for_union` then `read_array` will be relative to that and Yirgacheffe will clip or expand the data with zero values as necessary.
 
 
 ## Layer types
@@ -160,6 +160,7 @@ with RasterLayer.layer_from_file('test1.tif') as source:
     scaled = RasterLayer.scaled_raster_from_raster(source, PixelScale(0.0001, -0.0001), 'scaled.tif')
 ```
 
+If the data is from a GeoTIFF that has a nodata value specified, then pixel values with that specified nodata value in them will be converted to NaN. You can override that by providing `ignore_nodata=True` as an optional argument to `layer_from_file` (or with the new 2.0 API, `read_raster`). You can find out if a layer has a nodata value by accessing the `nodata` property - it is None if there is no such value.
 
 ### VectorLayer
 
@@ -229,6 +230,9 @@ with yg.read_rasters(['tile_N10_E10.tif', 'tile_N20_E10.tif']) as all_tiles:
     ...
 ```
 
+If any of the layers have a `nodata` value specified, then any pixel with that value will be masked out to allow data from other layers to be visible.
+
+
 ### TiledGroupLayer
 
 This is a specialisation of GroupLayer, which you can use if your layers are all the same size and form a grid, as is often the case with map tiles. In this case the rendering code can be optimised and this class is significantly faster that GroupLayer.

{yirgacheffe-1.5.0 → yirgacheffe-1.6.0}/yirgacheffe.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ tests/test_group.py
 tests/test_h3layer.py
 tests/test_intersection.py
 tests/test_multiband.py
+tests/test_nodata.py
 tests/test_openers.py
 tests/test_operators.py
 tests/test_optimisation.py