yirgacheffe 1.6.1__tar.gz → 1.7.1__tar.gz

{yirgacheffe-1.6.1/yirgacheffe.egg-info → yirgacheffe-1.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yirgacheffe
-Version: 1.6.1
+Version: 1.7.1
 Summary: Abstraction of gdal datasets for doing basic math operations
 Author-email: Michael Dales <mwd24@cam.ac.uk>
 License-Expression: ISC
@@ -14,6 +14,8 @@ Requires-Dist: gdal[numpy]
 Requires-Dist: scikit-image
 Requires-Dist: torch
 Requires-Dist: dill
+Requires-Dist: deprecation
+Requires-Dist: tomli
 Provides-Extra: dev
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: pylint; extra == "dev"
@@ -57,7 +59,7 @@ import yirgaceffe as yg
 
 habitat_map = yg.read_raster("habitats.tif")
 elevation_map = yg.read_raster('elevation.tif')
-range_polygon = yg.read_shape_like('species123.geojson', like=habitat_map)
+range_polygon = yg.read_shape('species123.geojson')
 area_per_pixel_map = yg.read_raster('area_per_pixel.tif')
 
 refined_habitat = habitat_map.isin([...species habitat codes...])
@@ -177,22 +179,22 @@ with VectorLayer.layer_from_file('range.gpkg', PixelScale(0.001, -0.001), WGS_84
     ...
 ```
 
-The new 2.0 way of doing this is:
+The new 2.0 way of doing this is, if you plan to use the vector layer in calculation with other raster layers that will have projection information:
 
 ```python
 import yirgacheffe as yg
 
-with yg.read_shape('range.gpkg', (0.001, -0.001), WGS_84_PROJECTION) as layer:
+with yg.read_shape('range.gpkg') as layer:
     ...
 ```
 
-It is more common that when a shape file is loaded that its pixel size and projection will want to be made to match that of an existing raster (as per the opening area of habitat example). For that there is the following convenience method:
-
+Of if you plan to use the layer on its own and want to specify a rasterisation projection you can do:
 
 ```python
-with yg.read_raster("test.tif") as raster_layer:
-    with yg.read_shape_like('range.gpkg', raster_layer) as shape_layer:
-        ...
+import yirgacheffe as yg
+
+with yg.read_shape('range.gpkg', (yg.WGS_84_PROJECTION, (0.001, -0.001))) as layer:
+    ...
 ```
 
 ### GroupLayer

{yirgacheffe-1.6.1 → yirgacheffe-1.7.1}/README.md

@@ -32,7 +32,7 @@ import yirgaceffe as yg
 
 habitat_map = yg.read_raster("habitats.tif")
 elevation_map = yg.read_raster('elevation.tif')
-range_polygon = yg.read_shape_like('species123.geojson', like=habitat_map)
+range_polygon = yg.read_shape('species123.geojson')
 area_per_pixel_map = yg.read_raster('area_per_pixel.tif')
 
 refined_habitat = habitat_map.isin([...species habitat codes...])
@@ -152,22 +152,22 @@ with VectorLayer.layer_from_file('range.gpkg', PixelScale(0.001, -0.001), WGS_84
     ...
 ```
 
-The new 2.0 way of doing this is:
+The new 2.0 way of doing this is, if you plan to use the vector layer in calculation with other raster layers that will have projection information:
 
 ```python
 import yirgacheffe as yg
 
-with yg.read_shape('range.gpkg', (0.001, -0.001), WGS_84_PROJECTION) as layer:
+with yg.read_shape('range.gpkg') as layer:
     ...
 ```
 
-It is more common that when a shape file is loaded that its pixel size and projection will want to be made to match that of an existing raster (as per the opening area of habitat example). For that there is the following convenience method:
-
+Of if you plan to use the layer on its own and want to specify a rasterisation projection you can do:
 
 ```python
-with yg.read_raster("test.tif") as raster_layer:
-    with yg.read_shape_like('range.gpkg', raster_layer) as shape_layer:
-        ...
+import yirgacheffe as yg
+
+with yg.read_shape('range.gpkg', (yg.WGS_84_PROJECTION, (0.001, -0.001))) as layer:
+    ...
 ```
 
 ### GroupLayer

{yirgacheffe-1.6.1 → yirgacheffe-1.7.1}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "yirgacheffe"
-version = "1.6.1"
+version = "1.7.1"
 description = "Abstraction of gdal datasets for doing basic math operations"
 readme = "README.md"
 authors = [{ name = "Michael Dales", email = "mwd24@cam.ac.uk" }]
@@ -18,6 +18,8 @@ dependencies = [
     "scikit-image",
     "torch",
     "dill",
+    "deprecation",
+    "tomli"
 ]
 requires-python = ">=3.10"
 
@@ -37,3 +39,7 @@ ignore_missing_imports = true
 [[tool.mypy.overrides]]
 module = "h3.*"
 ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "deprecation.*"
+ignore_missing_imports = true

{yirgacheffe-1.6.1 → yirgacheffe-1.7.1}/tests/test_base.py

@@ -5,13 +5,12 @@ import pytest
 
 from yirgacheffe import WGS_84_PROJECTION
 from yirgacheffe.layers import YirgacheffeLayer
-from yirgacheffe.window import Area, PixelScale
+from yirgacheffe.window import Area, MapProjection
 
 def test_pixel_to_latlng_unsupported_projection() -> None:
     layer = YirgacheffeLayer(
         Area(-10, 10, 10, -10),
-        PixelScale(0.02, -0.02),
-        "OTHER PROJECTION"
+        MapProjection("OTHER PROJECTION", 0.02, -0.02),
     )
     with pytest.raises(NotImplementedError):
         _ = layer.latlng_for_pixel(10, 10)
@@ -19,8 +18,7 @@ def test_pixel_to_latlng_unsupported_projection() -> None:
 def test_pixel_from_latlng_unsupported_projection() -> None:
     layer = YirgacheffeLayer(
         Area(-10, 10, 10, -10),
-        PixelScale(0.02, -0.02),
-        "OTHER PROJECTION"
+        MapProjection("OTHER PROJECTION", 0.02, -0.02),
     )
     with pytest.raises(NotImplementedError):
         _ = layer.pixel_for_latlng(10.0, 10.0)
@@ -63,8 +61,7 @@ def test_pixel_from_latlng_unsupported_projection() -> None:
 def test_latlng_for_pixel(area: Area, pixel: Tuple[int,int], expected: Tuple[float,float]) -> None:
     layer = YirgacheffeLayer(
         area,
-        PixelScale(0.2, -0.2),
-        WGS_84_PROJECTION
+        MapProjection(WGS_84_PROJECTION, 0.2, -0.2),
     )
     result = layer.latlng_for_pixel(*pixel)
     assert math.isclose(result[0], expected[0])
@@ -93,8 +90,7 @@ def test_latlng_for_pixel(area: Area, pixel: Tuple[int,int], expected: Tuple[flo
 def test_pixel_for_latlng(area: Area, coord: Tuple[float,float], expected: Tuple[int,int]) -> None:
     layer = YirgacheffeLayer(
         area,
-        PixelScale(0.2, -0.2),
-        WGS_84_PROJECTION
+        MapProjection(WGS_84_PROJECTION, 0.2, -0.2),
     )
     result = layer.pixel_for_latlng(*coord)
     assert result == expected
@@ -149,8 +145,7 @@ def test_latlng_for_pixel_with_intersection(
 ) -> None:
     layer = YirgacheffeLayer(
         area,
-        PixelScale(0.2, -0.2),
-        WGS_84_PROJECTION
+        MapProjection(WGS_84_PROJECTION, 0.2, -0.2),
     )
     layer.set_window_for_intersection(window)
     result = layer.latlng_for_pixel(*pixel)
@@ -188,8 +183,7 @@ def test_pixel_for_latlng_with_intersection(
 ) -> None:
     layer = YirgacheffeLayer(
         area,
-        PixelScale(0.2, -0.2),
-        WGS_84_PROJECTION
+        MapProjection(WGS_84_PROJECTION, 0.2, -0.2),
     )
     layer.set_window_for_intersection(window)
     result = layer.pixel_for_latlng(*coord)

{yirgacheffe-1.6.1 → yirgacheffe-1.7.1}/tests/test_h3layer.py

@@ -5,7 +5,7 @@ from osgeo import gdal
 
 from yirgacheffe import WGS_84_PROJECTION
 from yirgacheffe.layers import RasterLayer, H3CellLayer
-from yirgacheffe.window import Area, PixelScale
+from yirgacheffe.window import Area, MapProjection
 from yirgacheffe._backends import backend
 
 # work around of pylint
@@ -21,7 +21,7 @@ demote_array = backend.demote_array
 )
 def test_h3_layer(cell_id: str, is_valid: bool, expected_zoom: int) -> None:
     if is_valid:
-        with H3CellLayer(cell_id, PixelScale(0.001, -0.001), WGS_84_PROJECTION) as layer:
+        with H3CellLayer(cell_id, MapProjection(WGS_84_PROJECTION, 0.001, -0.001)) as layer:
             assert layer.zoom == expected_zoom
             assert layer.projection == WGS_84_PROJECTION
 
@@ -35,7 +35,7 @@ def test_h3_layer(cell_id: str, is_valid: bool, expected_zoom: int) -> None:
             assert one_count != 0
     else:
         with pytest.raises(ValueError):
-            with H3CellLayer(cell_id, PixelScale(0.001, -0.001), WGS_84_PROJECTION) as _layer:
+            with H3CellLayer(cell_id, MapProjection(WGS_84_PROJECTION, 0.001, -0.001)) as _layer:
                 pass
 
 @pytest.mark.parametrize(
@@ -53,8 +53,10 @@ def test_h3_layer(cell_id: str, is_valid: bool, expected_zoom: int) -> None:
 def test_h3_layer_magnifications(lat: float, lng: float) -> None:
     for zoom in range(6, 10):
         cell_id = h3.latlng_to_cell(lat, lng, zoom)
-        h3_layer = H3CellLayer(cell_id, PixelScale(0.000898315284120,-0.000898315284120), WGS_84_PROJECTION)
-
+        h3_layer = H3CellLayer(
+            cell_id,
+            MapProjection(WGS_84_PROJECTION, 0.000898315284120,-0.000898315284120)
+        )
         on_cell_count = h3_layer.sum()
         total_count = h3_layer.window.xsize * h3_layer.window.ysize
         assert 0 < on_cell_count < total_count
@@ -74,14 +76,18 @@ def test_h3_layer_magnifications(lat: float, lng: float) -> None:
 def test_h3_layer_not_clipped(lat: float, lng: float) -> None:
     for zoom in range(6, 10):
         cell_id = h3.latlng_to_cell(lat, lng, zoom)
-        scale = PixelScale(0.000898315284120,-0.000898315284120)
-        h3_layer = H3CellLayer(cell_id, scale, WGS_84_PROJECTION)
+        projection = MapProjection(
+            WGS_84_PROJECTION,
+            0.000898315284120,
+            -0.000898315284120
+        )
+        h3_layer = H3CellLayer(cell_id, projection)
 
         on_cell_count = h3_layer.sum()
         assert on_cell_count > 0.0
 
         before_window = h3_layer.window
-        abs_xstep, abs_ystep = abs(scale.xstep), abs(scale.ystep)
+        abs_xstep, abs_ystep = abs(projection.xstep), abs(projection.ystep)
         expanded_area = Area(
             left=h3_layer.area.left - (12 * abs_xstep),
             top=h3_layer.area.top + (12 * abs_ystep),
@@ -115,14 +121,18 @@ def test_h3_layer_not_clipped(lat: float, lng: float) -> None:
 def test_h3_layer_clipped(lat: float, lng: float) -> None:
     for zoom in range(6, 8):
         cell_id = h3.latlng_to_cell(lat, lng, zoom)
-        scale = PixelScale(0.000898315284120,-0.000898315284120)
-        h3_layer = H3CellLayer(cell_id, scale, WGS_84_PROJECTION)
+        projection = MapProjection(
+            WGS_84_PROJECTION,
+            0.000898315284120,
+            -0.000898315284120
+        )
+        h3_layer = H3CellLayer(cell_id, projection)
 
         on_cell_count = h3_layer.sum()
         assert on_cell_count > 0.0
 
         before_window = h3_layer.window
-        abs_xstep, abs_ystep = abs(scale.xstep), abs(scale.ystep)
+        abs_xstep, abs_ystep = abs(projection.xstep), abs(projection.ystep)
         expanded_area = Area(
             left=h3_layer.area.left + (2 * abs_xstep),
             top=h3_layer.area.top - (2 * abs_ystep),
@@ -151,8 +161,8 @@ def test_h3_layer_clipped(lat: float, lng: float) -> None:
 )
 def test_h3_layer_wrapped_on_projection(lat: float, lng: float) -> None:
     cell_id = h3.latlng_to_cell(lat, lng, 3)
-    scale = PixelScale(0.01, -0.01)
-    h3_layer = H3CellLayer(cell_id, scale, WGS_84_PROJECTION)
+    projection = MapProjection(WGS_84_PROJECTION, 0.01, -0.01)
+    h3_layer = H3CellLayer(cell_id, projection)
 
     # Just sanity check this test has caught a cell that wraps the entire planet and is testing
     # what we think it is testing:
@@ -165,14 +175,14 @@ def test_h3_layer_wrapped_on_projection(lat: float, lng: float) -> None:
     # check they are all of a similarish size - we had a bug early on where we'd
     # mistakenly invert the area for the band, counting all the cells across the planet
     for cell_id in h3.grid_ring(cell_id, 1):
-        neighbour = H3CellLayer(cell_id, scale, WGS_84_PROJECTION)
+        neighbour = H3CellLayer(cell_id, projection)
         neighbour_area = neighbour.sum()
         # We're happy if they're within 10% for now
         assert abs((neighbour_area - area) / area) < 0.1
 
 
     before_window = h3_layer.window
-    _, abs_ystep = abs(scale.xstep), abs(scale.ystep)
+    _, abs_ystep = abs(projection.xstep), abs(projection.ystep)
     expanded_area = Area(
         left=h3_layer.area.left,
         top=h3_layer.area.top + (22 * abs_ystep),
@@ -198,7 +208,11 @@ def test_h3_layer_overlapped():
     # This is based on a regression, where somehow I made tiles not tesselate properly
     left, top = (121.26706, 19.45338)
     right, bottom = (121.62494, 19.18478)
-    scale = PixelScale(0.000898315284120,-0.000898315284120)
+    projection = MapProjection(
+        WGS_84_PROJECTION,
+        0.000898315284120,
+        -0.000898315284120
+    )
 
     cells = h3.geo_to_cells(h3.LatLngPoly([
         (top, left),
@@ -208,13 +222,13 @@ def test_h3_layer_overlapped():
     ],), 7)
 
     tiles = [
-        H3CellLayer(cell_id, scale, WGS_84_PROJECTION)
+        H3CellLayer(cell_id, projection)
     for cell_id in cells]
 
     union = RasterLayer.find_union(tiles)
     union = union.grow(0.02)
 
-    scratch = RasterLayer.empty_raster_layer(union, scale, gdal.GDT_Float64)
+    scratch = RasterLayer.empty_raster_layer(union, projection.scale, gdal.GDT_Float64)
 
     # In scratch we should only have 0 or 1 values, but if there are any overlaps we should get 2s...
 

{yirgacheffe-1.6.1 → yirgacheffe-1.7.1}/tests/test_intersection.py

@@ -2,7 +2,7 @@ import pytest
 from osgeo import gdal
 
 from tests.helpers import gdal_dataset_of_region, gdal_empty_dataset_of_region
-from yirgacheffe.window import Area, PixelScale, Window
+from yirgacheffe.window import Area, MapProjection, Window
 from yirgacheffe.layers import RasterLayer, ConstantLayer, H3CellLayer
 from yirgacheffe import WGS_84_PROJECTION
 
@@ -149,10 +149,10 @@ def test_intersection_stability():
     # a rounding error that causes set_window_for_* methods to wobble depending on how far
     # away from the top left thing where. adding round_down_pixels fixed this.
     cells = ["874b93aaeffffff", "874b93a85ffffff", "874b93aa3ffffff", "874b93a84ffffff", "874b93a80ffffff"]
-    scale = PixelScale(0.000898315284120,-0.000898315284120)
+    projection = MapProjection(WGS_84_PROJECTION, 0.000898315284120,-0.000898315284120)
 
     tiles = [
-        H3CellLayer(cell_id, scale, WGS_84_PROJECTION)
+        H3CellLayer(cell_id, projection)
     for cell_id in cells]
 
     # composing the same tiles within different areas should not cause them to
@@ -160,8 +160,8 @@ def test_intersection_stability():
     union = RasterLayer.find_union(tiles)
     superunion = union.grow(0.02)
 
-    scratch1 = RasterLayer.empty_raster_layer(union, scale, gdal.GDT_Float64, name='s1')
-    scratch2 = RasterLayer.empty_raster_layer(superunion, scale, gdal.GDT_Float64, name='s2')
+    scratch1 = RasterLayer.empty_raster_layer(union, projection.scale, gdal.GDT_Float64, name='s1')
+    scratch2 = RasterLayer.empty_raster_layer(superunion, projection.scale, gdal.GDT_Float64, name='s2')
 
     relative_offsets = {}
 

{yirgacheffe-1.6.1 → yirgacheffe-1.7.1}/tests/test_multiband.py

@@ -16,7 +16,7 @@ def test_simple_two_band_image() -> None:
         bands = 4
         target = RasterLayer.empty_raster_layer(
             Area(-1, 1, 1, -1),
-            PixelScale(1.0, 1.0),
+            PixelScale(1.0, -1.0),
             gdal.GDT_Byte,
             filename=target_path,
             bands=bands

{yirgacheffe-1.6.1 → yirgacheffe-1.7.1}/tests/test_openers.py

@@ -8,7 +8,7 @@ import pytest
 import yirgacheffe as yg
 from yirgacheffe import WGS_84_PROJECTION
 from yirgacheffe.layers import InvalidRasterBand
-from yirgacheffe.window import Area, PixelScale, Window
+from yirgacheffe.window import Area, MapProjection, Window
 from tests.helpers import gdal_dataset_of_region, gdal_multiband_dataset_with_data, \
     make_vectors_with_id, make_vectors_with_mutlile_ids
 
@@ -75,7 +75,7 @@ def test_open_multiband_raster() -> None:
 
 def test_shape_from_nonexistent_file() -> None:
     with pytest.raises(FileNotFoundError):
-        _ = yg.read_shape("this_file_does_not_exist.gpkg", (1.0, -1.0), WGS_84_PROJECTION)
+        _ = yg.read_shape("this_file_does_not_exist.gpkg", (WGS_84_PROJECTION, (1.0, -1.0)))
 
 def test_open_gpkg() -> None:
     with tempfile.TemporaryDirectory() as tempdir:
@@ -83,19 +83,47 @@ def test_open_gpkg() -> None:
         area = Area(-10.0, 10.0, 10.0, 0.0)
         make_vectors_with_id(42, {area}, path)
 
-        with yg.read_shape(path, PixelScale(1.0, -1.0), WGS_84_PROJECTION) as layer:
+        with yg.read_shape(path, (WGS_84_PROJECTION, (1.0, -1.0))) as layer:
             assert layer.area == area
             assert layer.geo_transform == (area.left, 1.0, 0.0, area.top, 0.0, -1.0)
             assert layer.window == Window(0, 0, 20, 10)
+            assert layer.map_projection == MapProjection(WGS_84_PROJECTION, 1.0, -1.0)
             assert layer.projection == WGS_84_PROJECTION
 
+def test_open_gpkg_with_mapprojection() -> None:
+    with tempfile.TemporaryDirectory() as tempdir:
+        path = os.path.join(tempdir, "test.gpkg")
+        area = Area(-10.0, 10.0, 10.0, 0.0)
+        make_vectors_with_id(42, {area}, path)
+
+        with yg.read_shape(path, MapProjection(WGS_84_PROJECTION, 1.0, -1.0)) as layer:
+            assert layer.area == area
+            assert layer.geo_transform == (area.left, 1.0, 0.0, area.top, 0.0, -1.0)
+            assert layer.window == Window(0, 0, 20, 10)
+            assert layer.map_projection == MapProjection(WGS_84_PROJECTION, 1.0, -1.0)
+            assert layer.projection == WGS_84_PROJECTION
+
+def test_open_gpkg_with_no_projection() -> None:
+    with tempfile.TemporaryDirectory() as tempdir:
+        path = os.path.join(tempdir, "test.gpkg")
+        area = Area(-10.0, 10.0, 10.0, 0.0)
+        make_vectors_with_id(42, {area}, path)
+
+        with yg.read_shape(path) as layer:
+            assert layer.area == area
+            assert layer.projection is None
+            with pytest.raises(AttributeError):
+                _ = layer.geo_transform
+            with pytest.raises(AttributeError):
+                _ = layer.window
+
 def test_open_gpkg_direct_scale() -> None:
     with tempfile.TemporaryDirectory() as tempdir:
         path = Path(tempdir) / "test.gpkg"
         area = Area(-10.0, 10.0, 10.0, 0.0)
         make_vectors_with_id(42, {area}, path)
 
-        with yg.read_shape(path, (1.0, -1.0), WGS_84_PROJECTION) as layer:
+        with yg.read_shape(path, (WGS_84_PROJECTION, (1.0, -1.0))) as layer:
             assert layer.area == area
             assert layer.geo_transform == (area.left, 1.0, 0.0, area.top, 0.0, -1.0)
             assert layer.window == Window(0, 0, 20, 10)
@@ -110,7 +138,7 @@ def test_open_gpkg_with_filter() -> None:
         }
         make_vectors_with_mutlile_ids(areas, path)
 
-        with yg.read_shape(path, (1.0, -1.0), WGS_84_PROJECTION, "id_no=42") as layer:
+        with yg.read_shape(path, (WGS_84_PROJECTION, (1.0, -1.0)), "id_no=42") as layer:
             assert layer.area == Area(-10.0, 10.0, 0.0, 0.0)
             assert layer.geo_transform == (-10.0, 1.0, 0.0, 10.0, 0.0, -1.0)
             assert layer.window == Window(0, 0, 10, 10)
@@ -163,3 +191,25 @@ def test_open_two_raster_areas_side_by_side(tiled):
             with yg.read_raster(path1) as raster1:
                 with yg.read_raster(path2) as raster2:
                     assert group.sum() == raster1.sum() + raster2.sum()
+
+@pytest.mark.parametrize("tiled", [False, True])
+def test_open_two_raster_by_glob(tiled):
+    with tempfile.TemporaryDirectory() as tempdir:
+        temppath = Path(tempdir)
+        path1 = temppath / "test1.tif"
+        area1 = Area(-10, 10, 10, -10)
+        dataset1 = gdal_dataset_of_region(area1, 0.2, filename=path1)
+        dataset1.Close()
+
+        path2 = temppath / "test2.tif"
+        area2 = Area(10, 10, 30, -10)
+        dataset2 = gdal_dataset_of_region(area2, 0.2, filename=path2)
+        dataset2.Close()
+
+        with yg.read_rasters(temppath.glob("*.tif"), tiled=tiled) as group:
+            assert group.area == Area(-10, 10, 30, -10)
+            assert group.window == Window(0, 0, 200, 100)
+
+            with yg.read_raster(path1) as raster1:
+                with yg.read_raster(path2) as raster2:
+                    assert group.sum() == raster1.sum() + raster2.sum()

{yirgacheffe-1.6.1 → yirgacheffe-1.7.1}/tests/test_operators.py

@@ -1,16 +1,18 @@
 import os
 import random
 import tempfile
+from pathlib import Path
 
 import numpy as np
 import pytest
 import torch
 
 import yirgacheffe
-from yirgacheffe.layers import RasterLayer, ConstantLayer
+from yirgacheffe.window import Area, PixelScale
+from yirgacheffe.layers import ConstantLayer, RasterLayer, VectorLayer
 from yirgacheffe.operators import LayerOperation, DataType
 from yirgacheffe._backends import backend
-from tests.helpers import gdal_dataset_with_data
+from tests.helpers import gdal_dataset_with_data, gdal_dataset_of_region, make_vectors_with_id
 
 def test_add_byte_layers() -> None:
     data1 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]]).astype(np.uint8)
@@ -51,6 +53,15 @@ def test_error_of_pixel_scale_wrong_three_param() -> None:
     with pytest.raises(ValueError):
         _ = LayerOperation.where(layer1, layer2, layer3)
 
+def test_incompatible_source_and_destination_projections() -> None:
+    data1 = np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]])
+
+    layer1 = RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1))
+
+    with RasterLayer.empty_raster_layer(layer1.area, PixelScale(1.0, -1.0), layer1.datatype) as result:
+        with pytest.raises(ValueError):
+            layer1.save(result)
+
 @pytest.mark.parametrize("skip,expected_steps", [
     (1, [0.0, 0.5, 1.0]),
     (2, [0.0, 1.0]),
@@ -1497,3 +1508,50 @@ def test_to_geotiff_parallel_thread_and_sum(monkeypatch) -> None:
             expected = data1 * 2
             actual = result.read_array(0, 0, 4, 2)
             assert (expected == actual).all()
+
+def test_raster_and_vector() -> None:
+    with tempfile.TemporaryDirectory() as tempdir:
+        raster = RasterLayer(gdal_dataset_of_region(Area(-10, 10, 10, -10), 1.0))
+        assert raster.sum() > 0.0
+
+        path = Path(tempdir) / "test.gpkg"
+        area = Area(-5.0, 5.0, 5.0, -5.0)
+        make_vectors_with_id(42, {area}, path)
+        assert path.exists
+
+        vector = VectorLayer.layer_from_file(path, None, PixelScale(1.0, -1.0), yirgacheffe.WGS_84_PROJECTION)
+
+        calc = raster * vector
+        assert calc.sum() > 0.0
+        assert calc.sum() < raster.sum()
+
+def test_raster_and_vector_mixed_projection() -> None:
+    with tempfile.TemporaryDirectory() as tempdir:
+        raster = RasterLayer(gdal_dataset_of_region(Area(-10, 10, 10, -10), 1.1))
+        assert raster.sum() > 0.0
+
+        path = Path(tempdir) / "test.gpkg"
+        area = Area(-5.0, 5.0, 5.0, -5.0)
+        make_vectors_with_id(42, {area}, path)
+        assert path.exists
+
+        vector = VectorLayer.layer_from_file(path, None, PixelScale(1.0, -1.0), yirgacheffe.WGS_84_PROJECTION)
+
+        with pytest.raises(ValueError):
+            _ = raster * vector
+
+def test_raster_and_vector_no_scale_on_vector() -> None:
+    with tempfile.TemporaryDirectory() as tempdir:
+        raster = RasterLayer(gdal_dataset_of_region(Area(-10, 10, 10, -10), 1.0))
+        assert raster.sum() > 0.0
+
+        path = Path(tempdir) / "test.gpkg"
+        area = Area(-5.0, 5.0, 5.0, -5.0)
+        make_vectors_with_id(42, {area}, path)
+        assert path.exists
+
+        vector = VectorLayer.layer_from_file(path, None, None, None)
+
+        calc = raster * vector
+        assert calc.sum() > 0.0
+        assert calc.sum() < raster.sum()

{yirgacheffe-1.6.1 → yirgacheffe-1.7.1}/tests/test_optimisation.py

@@ -4,8 +4,8 @@ import numpy as np
 import pytest
 
 from yirgacheffe import WGS_84_PROJECTION
-from yirgacheffe.layers import PixelScale, RasterLayer, H3CellLayer
-from yirgacheffe.window import Area
+from yirgacheffe.layers import RasterLayer, H3CellLayer
+from yirgacheffe.window import Area, MapProjection
 import yirgacheffe.operators as yo
 
 class NaiveH3CellLayer(H3CellLayer):
@@ -14,13 +14,14 @@ class NaiveH3CellLayer(H3CellLayer):
     version that checks for every cell."""
 
     def read_array(self, xoffset, yoffset, xsize, ysize): # pylint: disable=W0237
+        assert self._projection is not None
         res = np.zeros((ysize, xsize), dtype=float)
-        start_x = self._active_area.left + (xoffset * self._pixel_scale.xstep)
-        start_y = self._active_area.top + (yoffset * self._pixel_scale.ystep)
+        start_x = self.area.left + (xoffset * self._projection.xstep)
+        start_y = self.area.top + (yoffset * self._projection.ystep)
         for ypixel in range(ysize):
-            lat = start_y + (ypixel * self._pixel_scale.ystep)
+            lat = start_y + (ypixel * self._projection.ystep)
             for xpixel in range(xsize):
-                lng = start_x + (xpixel * self._pixel_scale.xstep)
+                lng = start_x + (xpixel * self._projection.xstep)
                 this_cell = h3.latlng_to_cell(lat, lng, self.zoom)
                 if this_cell == self.cell_id:
                     res[ypixel][xpixel] = 1.0
@@ -41,8 +42,9 @@ class NaiveH3CellLayer(H3CellLayer):
 def test_h3_vs_naive(lat: float, lng: float) -> None:
     for zoom in range(5, 9):
         cell_id = h3.latlng_to_cell(lat, lng, zoom)
-        optimised_layer = H3CellLayer(cell_id, PixelScale(0.000898315284120,-0.000898315284120), "NOTUSED")
-        naive_layer = NaiveH3CellLayer(cell_id, PixelScale(0.000898315284120,-0.000898315284120), "NOTUSED")
+        projection = MapProjection(WGS_84_PROJECTION, 0.000898315284120,-0.000898315284120)
+        optimised_layer = H3CellLayer(cell_id, projection)
+        naive_layer = NaiveH3CellLayer(cell_id, projection)
 
         optimised_cell_count = optimised_layer.sum()
         naive_cell_count = naive_layer.sum()
@@ -65,17 +67,17 @@ def test_h3_vs_naive(lat: float, lng: float) -> None:
 def test_h3_vs_naive_for_union(lat: float, lng: float) -> None:
     for zoom in range(7, 9):
         cell_id = h3.latlng_to_cell(lat, lng, zoom)
-        scale = PixelScale(0.000898315284120,-0.000898315284120)
-        optimised_layer = H3CellLayer(cell_id, scale, "NOTUSED")
-        naive_layer = NaiveH3CellLayer(cell_id, scale, "NOTUSED")
+        projection = MapProjection(WGS_84_PROJECTION, 0.000898315284120,-0.000898315284120)
+        optimised_layer = H3CellLayer(cell_id, projection)
+        naive_layer = NaiveH3CellLayer(cell_id, projection)
 
         before_cell_count = optimised_layer.sum()
 
         superset_area = Area(
-            left=optimised_layer.area.left - (5 * scale.xstep),
-            right=optimised_layer.area.right + (5 * scale.xstep),
-            top=optimised_layer.area.top - (5 * scale.ystep),
-            bottom=optimised_layer.area.bottom + (5 * scale.ystep),
+            left=optimised_layer.area.left - (5 * projection.xstep),
+            right=optimised_layer.area.right + (5 * projection.xstep),
+            top=optimised_layer.area.top - (5 * projection.ystep),
+            bottom=optimised_layer.area.bottom + (5 * projection.ystep),
         )
         optimised_layer.set_window_for_union(superset_area)
         naive_layer.set_window_for_union(superset_area)
@@ -101,17 +103,17 @@ def test_h3_vs_naive_for_union(lat: float, lng: float) -> None:
 def test_h3_vs_naive_for_intersection(lat: float, lng: float) -> None:
     for zoom in range(7, 9):
         cell_id = h3.latlng_to_cell(lat, lng, zoom)
-        scale = PixelScale(0.000898315284120,-0.000898315284120)
-        optimised_layer = H3CellLayer(cell_id, scale, "NOTUSED")
-        naive_layer = NaiveH3CellLayer(cell_id, scale, "NOTUSED")
+        projection = MapProjection(WGS_84_PROJECTION, 0.000898315284120,-0.000898315284120)
+        optimised_layer = H3CellLayer(cell_id, projection)
+        naive_layer = NaiveH3CellLayer(cell_id, projection)
 
         before_cell_count = optimised_layer.sum()
 
         subset_area = Area(
-            left=optimised_layer.area.left + (2 * scale.xstep),
-            right=optimised_layer.area.right - (2 * scale.xstep),
-            top=optimised_layer.area.top + (2 * scale.ystep),
-            bottom=optimised_layer.area.bottom - (2 * scale.ystep),
+            left=optimised_layer.area.left + (2 * projection.xstep),
+            right=optimised_layer.area.right - (2 * projection.xstep),
+            top=optimised_layer.area.top + (2 * projection.ystep),
+            bottom=optimised_layer.area.bottom - (2 * projection.ystep),
         )
         optimised_layer.set_window_for_intersection(subset_area)
         naive_layer.set_window_for_intersection(subset_area)
@@ -143,8 +145,8 @@ def test_h3_vs_naive_for_intersection(lat: float, lng: float) -> None:
 def test_cells_dont_overlap(cell_id):
 
     cluster = h3.grid_disk(cell_id, 1)
-    scale = PixelScale(0.000898315284120,-0.000898315284120)
-    layers = [H3CellLayer(x, scale, WGS_84_PROJECTION) for x in cluster]
+    projection = MapProjection(WGS_84_PROJECTION, 0.000898315284120,-0.000898315284120)
+    layers = [H3CellLayer(x, projection) for x in cluster]
 
     union = RasterLayer.find_union(layers)
     for layer in layers: