yirgacheffe 1.8.0__tar.gz → 1.9.0__tar.gz

{yirgacheffe-1.8.0/yirgacheffe.egg-info → yirgacheffe-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yirgacheffe
-Version: 1.8.0
+Version: 1.9.0
 Summary: Abstraction of gdal datasets for doing basic math operations
 Author-email: Michael Dales <mwd24@cam.ac.uk>
 License-Expression: ISC
@@ -27,6 +27,7 @@ Requires-Dist: dill
 Requires-Dist: deprecation
 Requires-Dist: tomli
 Requires-Dist: h3
+Requires-Dist: pyproj
 Provides-Extra: mlx
 Requires-Dist: mlx; extra == "mlx"
 Provides-Extra: dev
@@ -44,6 +45,11 @@ Dynamic: license-file
 
 # Yirgacheffe: a declarative geospatial library for Python to make data-science with maps easier
 
+[![CI](https://github.com/quantifyearth/yirgacheffe/actions/workflows/pull-request.yml/badge.svg?branch=main)](https://github.com/quantifyearth/yirgacheffe/actions)
+[![Documentation](https://img.shields.io/badge/docs-yirgacheffe.org-blue)](https://yirgacheffe.org)
+[![PyPI version](https://img.shields.io/pypi/v/yirgacheffe)](https://pypi.org/project/yirgacheffe/)
+
+
 ## Overview
 
 Yirgacheffe is an attempt to wrap raster and polygon geospatial datasets such that you can do computational work on them as a whole or at the pixel level, but without having to do a lot of the grunt work of working out where you need to be in rasters, or managing how much you can load into memory safely.

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0}/README.md

@@ -1,5 +1,10 @@
 # Yirgacheffe: a declarative geospatial library for Python to make data-science with maps easier
 
+[![CI](https://github.com/quantifyearth/yirgacheffe/actions/workflows/pull-request.yml/badge.svg?branch=main)](https://github.com/quantifyearth/yirgacheffe/actions)
+[![Documentation](https://img.shields.io/badge/docs-yirgacheffe.org-blue)](https://yirgacheffe.org)
+[![PyPI version](https://img.shields.io/pypi/v/yirgacheffe)](https://pypi.org/project/yirgacheffe/)
+
+
 ## Overview
 
 Yirgacheffe is an attempt to wrap raster and polygon geospatial datasets such that you can do computational work on them as a whole or at the pixel level, but without having to do a lot of the grunt work of working out where you need to be in rasters, or managing how much you can load into memory safely.

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "yirgacheffe"
-version = "1.8.0"
+version = "1.9.0"
 description = "Abstraction of gdal datasets for doing basic math operations"
 readme = "README.md"
 authors = [{ name = "Michael Dales", email = "mwd24@cam.ac.uk" }]
@@ -30,6 +30,7 @@ dependencies = [
     "deprecation",
     "tomli",
     "h3",
+    "pyproj",
 ]
 requires-python = ">=3.10"
 

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0}/tests/test_area.py

@@ -29,3 +29,6 @@ def test_global_area() -> None:
     other_area = Area(-10.0, 10.0, 10.0, -10.0)
     assert area.overlaps(other_area)
     assert other_area.overlaps(area)
+
+def test_wrong_types_on_eq() -> None:
+    assert Area(-10, 10, 10, -10) != 42

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0}/tests/test_auto_windowing.py

@@ -4,7 +4,7 @@ import tempfile
 import numpy as np
 import pytest
 
-import yirgacheffe
+import yirgacheffe as yg
 from tests.helpers import gdal_dataset_with_data, make_vectors_with_mutlile_ids
 from yirgacheffe.layers import ConstantLayer, RasterLayer, VectorLayer
 from yirgacheffe.window import Area
@@ -315,7 +315,7 @@ def test_vector_layers_multiply() -> None:
         expected = np.array([[2, 0], [0, 8]])
         assert (expected == actual).all()
 
-@pytest.mark.skipif(yirgacheffe._backends.BACKEND != "NUMPY", reason="Only applies for numpy")
+@pytest.mark.skipif(yg._backends.BACKEND != "NUMPY", reason="Only applies for numpy")
 def test_parallel_save_windows() -> None:
     data1 = np.array([[1, 2], [3, 4]])
     data2 = np.array([[10, 20, 30, 40], [50, 60, 70, 80], [90, 100, 110, 120], [130, 140, 150, 160]])

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0}/tests/test_base.py

@@ -1,136 +1,166 @@
 import math
+import os
+import tempfile
 
 import pytest
 
-from yirgacheffe import WGS_84_PROJECTION
+import yirgacheffe as yg
 from yirgacheffe.layers import YirgacheffeLayer
 from yirgacheffe.window import Area, MapProjection
 
-def test_pixel_to_latlng_unsupported_projection() -> None:
-    layer = YirgacheffeLayer(
-        Area(-10, 10, 10, -10),
-        MapProjection("OTHER PROJECTION", 0.02, -0.02),
-    )
-    with pytest.raises(NotImplementedError):
-        _ = layer.latlng_for_pixel(10, 10)
+from tests.helpers import make_vectors_with_id
 
-def test_pixel_from_latlng_unsupported_projection() -> None:
-    layer = YirgacheffeLayer(
-        Area(-10, 10, 10, -10),
-        MapProjection("OTHER PROJECTION", 0.02, -0.02),
-    )
-    with pytest.raises(NotImplementedError):
-        _ = layer.pixel_for_latlng(10.0, 10.0)
+def test_pixel_to_latlng_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:
+            with pytest.raises(ValueError):
+                _ = layer.latlng_for_pixel(10, 10)
+
+def test_latlng_to_pixel_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:
+            with pytest.raises(ValueError):
+                _ = layer.pixel_for_latlng(10.0, 10.0)
 
 @pytest.mark.parametrize(
-    "area,pixel,expected",
+    "area,projection,pixel,expected",
     [
         (
             Area(-10, 10, 10, -10),
+            MapProjection("epsg:4326", 0.2, -0.2),
             (0, 0),
             (10.0, -10.0)
         ),
         (
             Area(-10, 10, 10, -10),
+            MapProjection("epsg:4326", 0.2, -0.2),
             (1, 1),
             (9.8, -9.8)
         ),
         (
             Area(-10, 10, 10, -10),
+            MapProjection("epsg:4326", 0.2, -0.2),
             (101, 101),
             (-10.2, 10.2)
         ),
         (
             Area(-10, 10, 10, -10),
+            MapProjection("epsg:4326", 0.2, -0.2),
             (-1, -1),
             (10.2, -10.2)
         ),
         (
             Area(10, 10, 20, -10),
+            MapProjection("epsg:4326", 0.2, -0.2),
             (1, 1),
             (9.8, 10.2)
         ),
         (
             Area(-10, -10, 10, -20),
+            MapProjection("epsg:4326", 0.2, -0.2),
             (1, 1),
             (-10.2, -9.8)
         ),
     ]
 )
-def test_latlng_for_pixel(area: Area, pixel: tuple[int, int], expected: tuple[float, float]) -> None:
+def test_latlng_for_pixel(
+    area: Area,
+    projection: MapProjection,
+    pixel: tuple[int, int],
+    expected: tuple[float, float]
+) -> None:
     layer = YirgacheffeLayer(
         area,
-        MapProjection(WGS_84_PROJECTION, 0.2, -0.2),
+        projection,
     )
     result = layer.latlng_for_pixel(*pixel)
     assert math.isclose(result[0], expected[0])
     assert math.isclose(result[1], expected[1])
 
 @pytest.mark.parametrize(
-    "area,coord,expected",
+    "area,projection,coord,expected",
     [
         (
             Area(-10, 10, 10, -10),
+            MapProjection("epsg:4326", 0.2, -0.2),
             (10.0, -10.0),
             (0, 0)
         ),
         (
             Area(-10, 10, 10, -10),
+            MapProjection("epsg:4326", 0.2, -0.2),
             (9.8, -9.8),
             (1, 1)
         ),
         (
             Area(-10, 10, 10, -10),
+            MapProjection("epsg:4326", 0.2, -0.2),
             (0.0, 0.0),
             (50, 50)
         ),
     ]
 )
-def test_pixel_for_latlng(area: Area, coord: tuple[float, float], expected: tuple[int, int]) -> None:
+def test_pixel_for_latlng(
+    area: Area,
+    projection: MapProjection,
+    coord: tuple[float, float],
+    expected: tuple[int, int]
+) -> None:
     layer = YirgacheffeLayer(
         area,
-        MapProjection(WGS_84_PROJECTION, 0.2, -0.2),
+        projection,
     )
     result = layer.pixel_for_latlng(*coord)
     assert result == expected
 
-
 @pytest.mark.parametrize(
-    "area,window,pixel,expected",
+    "area,window,projection,pixel,expected",
     [
         (
             Area(-10, 10, 10, -10),
             Area(-5, 5, 5, -5),
+            MapProjection("epsg:4326", 0.2, -0.2),
             (0, 0),
             (5.0, -5.0)
         ),
         (
             Area(-10, 10, 10, -10),
             Area(-5, 5, 5, -5),
+            MapProjection("epsg:4326", 0.2, -0.2),
             (1, 1),
             (4.8, -4.8)
         ),
         (
             Area(-10, 10, 10, -10),
             Area(-5, 5, 5, -5),
+            MapProjection("epsg:4326", 0.2, -0.2),
             (101, 101),
             (-15.2, 15.2)
         ),
         (
             Area(-10, 10, 10, -10),
             Area(-5, 5, 5, -5),
+            MapProjection("epsg:4326", 0.2, -0.2),
             (-1, -1),
             (5.2, -5.2)
         ),
         (
             Area(10, 10, 20, -10),
             Area(15, 5, 20, -5),
+            MapProjection("epsg:4326", 0.2, -0.2),
             (1, 1),
             (4.8, 15.2)
         ),
         (
             Area(-10, -10, 10, -20),
             Area(-5, -15, 5, -20),
+            MapProjection("epsg:4326", 0.2, -0.2),
             (1, 1),
             (-15.2, -4.8)
         ),
@@ -139,12 +169,13 @@ def test_pixel_for_latlng(area: Area, coord: tuple[float, float], expected: tupl
 def test_latlng_for_pixel_with_intersection(
     area: Area,
     window: Area,
+    projection: MapProjection,
     pixel: tuple[int, int],
     expected: tuple[float, float]
 ) -> None:
     layer = YirgacheffeLayer(
         area,
-        MapProjection(WGS_84_PROJECTION, 0.2, -0.2),
+        projection,
     )
     layer.set_window_for_intersection(window)
     result = layer.latlng_for_pixel(*pixel)
@@ -152,23 +183,26 @@ def test_latlng_for_pixel_with_intersection(
     assert math.isclose(result[1], expected[1])
 
 @pytest.mark.parametrize(
-    "area,window,coord,expected",
+    "area,window,projection,coord,expected",
     [
         (
             Area(-10, 10, 10, -10),
             Area(-5, 5, 5, -5),
+            MapProjection("epsg:4326", 0.2, -0.2),
             (5.0, -5.0),
             (0, 0)
         ),
         (
             Area(-10, 10, 10, -10),
             Area(-5, 5, 5, -5),
+            MapProjection("epsg:4326", 0.2, -0.2),
             (4.8, -4.8),
             (1, 1)
         ),
         (
             Area(-10, 10, 10, -10),
             Area(-5, 5, 5, -5),
+            MapProjection("epsg:4326", 0.2, -0.2),
             (0.0, 0.0),
             (25, 25)
         ),
@@ -177,12 +211,13 @@ def test_latlng_for_pixel_with_intersection(
 def test_pixel_for_latlng_with_intersection(
     area: Area,
     window: Area,
+    projection: MapProjection,
     coord: tuple[float, float],
     expected: tuple[int, int]
 ) -> None:
     layer = YirgacheffeLayer(
         area,
-        MapProjection(WGS_84_PROJECTION, 0.2, -0.2),
+        projection,
     )
     layer.set_window_for_intersection(window)
     result = layer.pixel_for_latlng(*coord)

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0}/tests/test_h3layer.py

@@ -23,7 +23,7 @@ def test_h3_layer(cell_id: str, is_valid: bool, expected_zoom: int) -> None:
     if is_valid:
         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
+            assert layer.map_projection.epsg == 4326
 
             # without getting too deep, we'd expect a mix of zeros and ones in the data
             window = layer.window

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0}/tests/test_intersection.py

@@ -59,6 +59,9 @@ def test_find_intersection_with_constant() -> None:
     intersection = RasterLayer.find_intersection(layers)
     assert intersection == layers[0].area
 
+    for layer in layers:
+        layer.set_window_for_intersection(intersection)
+
 def test_find_intersection_with_vector_unbound() -> None:
     with tempfile.TemporaryDirectory() as tempdir:
         path = Path(tempdir) / "test.gpkg"
@@ -74,6 +77,10 @@ def test_find_intersection_with_vector_unbound() -> None:
         intersection = RasterLayer.find_intersection(layers)
         assert intersection == vector.area
 
+        raster.set_window_for_intersection(intersection)
+        with pytest.raises(ValueError):
+            vector.set_window_for_intersection(intersection)
+
 def test_find_intersection_with_vector_bound() -> None:
     with tempfile.TemporaryDirectory() as tempdir:
         path = Path(tempdir) / "test.gpkg"
@@ -89,6 +96,29 @@ def test_find_intersection_with_vector_bound() -> None:
         intersection = RasterLayer.find_intersection(layers)
         assert intersection == vector.area
 
+        for layer in layers:
+            layer.set_window_for_intersection(intersection)
+
+def test_find_intersection_with_vector_awkward_rounding() -> None:
+    with tempfile.TemporaryDirectory() as tempdir:
+        path = Path(tempdir) / "test.gpkg"
+        area = Area(left=-90, top=45, right=90, bottom=-45)
+        make_vectors_with_id(42, {area}, path)
+        assert path.exists
+
+        raster = RasterLayer(gdal_dataset_of_region(Area(left=-180, top=90, right=180, bottom=-90), 18.0))
+        vector = VectorLayer.layer_from_file(path, None, raster.map_projection.scale, raster.map_projection.name)
+
+        rounded_area = Area(left=-90, top=54, right=90, bottom=-54)
+        assert vector.area == rounded_area
+
+        layers = [raster, vector]
+        intersection = RasterLayer.find_intersection(layers)
+        assert intersection == vector.area
+
+        for layer in layers:
+            layer.set_window_for_intersection(intersection)
+
 def test_find_intersection_different_pixel_pitch() -> None:
     layers = [
         RasterLayer(gdal_dataset_of_region(Area(-10, 10, 10, -10), 0.02)),

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0}/tests/test_openers.py

@@ -90,7 +90,6 @@ def test_open_gpkg() -> None:
             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:
@@ -103,7 +102,6 @@ def test_open_gpkg_with_mapprojection() -> None:
             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:
@@ -129,7 +127,7 @@ def test_open_gpkg_direct_scale() -> None:
             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.projection == WGS_84_PROJECTION
+            assert layer.map_projection == MapProjection(WGS_84_PROJECTION, 1.0, -1.0)
 
 def test_open_gpkg_with_filter() -> None:
     with tempfile.TemporaryDirectory() as tempdir:

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0}/tests/test_operators.py

@@ -1596,3 +1596,84 @@ def test_isnan() -> None:
             actual = result.read_array(0, 0, 4, 2)
             expected = data1 == 5.0
             assert (expected == actual).all()
+
+@pytest.mark.parametrize("blocksize", [1, 2, 4, 8])
+def test_add_byte_layers_read_array_all(monkeypatch, blocksize) -> None:
+    with monkeypatch.context() as m:
+        m.setattr(yirgacheffe.constants, "YSTEP", blocksize)
+        data1 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
+        data2 = np.array([[10, 20, 30, 40], [50, 60, 70, 80]])
+
+        with (
+            RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1)) as layer1,
+            RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data2)) as layer2,
+        ):
+            comp = layer1 + layer2
+            expected = data1 + data2
+            actual = comp.read_array(0, 0, 4, 2)
+            assert (expected == actual).all()
+
+@pytest.mark.parametrize("blocksize", [1, 2, 4, 8])
+def test_add_byte_layers_read_array_partial_horizontal(monkeypatch, blocksize) -> None:
+    with monkeypatch.context() as m:
+        m.setattr(yirgacheffe.constants, "YSTEP", blocksize)
+        data1 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
+        data2 = np.array([[10, 20, 30, 40], [50, 60, 70, 80]])
+
+        with (
+            RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1)) as layer1,
+            RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data2)) as layer2,
+        ):
+            comp = layer1 + layer2
+            expected = (data1 + data2)[0:3,1:3]
+            actual = comp.read_array(1, 0, 2, 2)
+            assert (expected == actual).all()
+
+@pytest.mark.parametrize("blocksize", [1, 2, 4, 8])
+def test_add_byte_layers_read_array_partial_vertical(monkeypatch, blocksize) -> None:
+    with monkeypatch.context() as m:
+        m.setattr(yirgacheffe.constants, "YSTEP", blocksize)
+        data1 = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
+        data2 = np.array([[10, 20], [30, 40], [50, 60], [70, 80]])
+
+        with (
+            RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1)) as layer1,
+            RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data2)) as layer2,
+        ):
+            comp = layer1 + layer2
+            expected = (data1 + data2)[1:3,0:3]
+            actual = comp.read_array(0, 1, 2, 2)
+            assert (expected == actual).all()
+
+@pytest.mark.parametrize("blocksize", [1, 2, 4, 8])
+def test_add_byte_layers_read_array_partial(monkeypatch, blocksize) -> None:
+    with monkeypatch.context() as m:
+        m.setattr(yirgacheffe.constants, "YSTEP", blocksize)
+        data1 = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
+        data2 = np.array([[10, 10, 10, 10], [20, 20, 20, 20], [30, 30, 30, 30], [40, 40, 40, 40]])
+
+        with (
+            RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1)) as layer1,
+            RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data2)) as layer2,
+        ):
+            comp = layer1 + layer2
+            expected = (data1 + data2)[1:3,1:3]
+            actual = comp.read_array(1, 1, 2, 2)
+            assert (expected == actual).all()
+
+@pytest.mark.parametrize("blocksize", [1, 2, 4, 8])
+def test_add_byte_layers_read_array_superset(monkeypatch, blocksize) -> None:
+    with monkeypatch.context() as m:
+        m.setattr(yirgacheffe.constants, "YSTEP", blocksize)
+        data1 = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
+        data2 = np.array([[10, 10, 10, 10], [20, 20, 20, 20], [30, 30, 30, 30], [40, 40, 40, 40]])
+
+        with (
+            RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data1)) as layer1,
+            RasterLayer(gdal_dataset_with_data((0.0, 0.0), 0.02, data2)) as layer2,
+        ):
+            comp = layer1 + layer2
+            inner_expected = data1 + data2
+            expected = np.pad(inner_expected, (1, 1))
+            actual = comp.read_array(-1, -1, 6, 6)
+            assert (expected == actual).all()

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0}/tests/test_pickle.py

@@ -48,7 +48,7 @@ def test_pickle_dyanamic_vector_layer() -> None:
         assert restore.area == area
         assert restore.geo_transform == (area.left, 1.0, 0.0, area.top, 0.0, -1.0)
         assert restore.window == Window(0, 0, 20, 10)
-        assert restore.projection == WGS_84_PROJECTION
+        assert restore.map_projection == MapProjection(WGS_84_PROJECTION, 1.0, -1.0)
 
         del layer
 

yirgacheffe-1.9.0/tests/test_projection.py

@@ -0,0 +1,45 @@
+import pyproj
+import pytest
+
+from yirgacheffe.window import MapProjection
+from yirgacheffe.rounding import MINIMAL_DEGREE_OF_INTEREST
+
+@pytest.mark.parametrize("name", [
+    "epsg:4326",
+    "esri:54009",
+    pyproj.CRS.from_string("epsg:4326").to_wkt(),
+    pyproj.CRS.from_string("esri:54009").to_wkt(),
+])
+def test_scale_from_projection(name) -> None:
+    projection = MapProjection(name, 0.1, -0.1)
+    assert projection.name == pyproj.CRS.from_string(name).to_wkt()
+    assert projection.xstep == 0.1
+    assert projection.ystep == -0.1
+    scale = projection.scale
+    assert scale.xstep == 0.1
+    assert scale.ystep == -0.1
+
+PROJ_A = "epsg:4326"
+PROJ_B = "esri:54009"
+
+@pytest.mark.parametrize(
+    "lhs,rhs,is_equal",
+    [
+        (MapProjection(PROJ_A, 0.1, -0.1), MapProjection(PROJ_A, 0.1, -0.1), True),
+        (MapProjection(PROJ_A, 0.1, -0.1), MapProjection(PROJ_B, 0.1, -0.1), False),
+        (MapProjection(PROJ_A, 0.1, -0.1), MapProjection(PROJ_A, 0.1, 0.1), False),
+        (MapProjection(PROJ_A, 0.1, -0.1), MapProjection(PROJ_A, -0.1, 0.1), False),
+        (MapProjection(PROJ_A, 0.1, -0.1), MapProjection(PROJ_A, 0.1 + (MINIMAL_DEGREE_OF_INTEREST / 2), -0.1), True),
+        (MapProjection(PROJ_A, 0.1, -0.1), MapProjection(PROJ_A, 0.1 - (MINIMAL_DEGREE_OF_INTEREST / 2), -0.1), True),
+        (MapProjection(PROJ_A, 0.1, -0.1), MapProjection(PROJ_A, 0.1, -0.1 + (MINIMAL_DEGREE_OF_INTEREST / 2)), True),
+        (MapProjection(PROJ_A, 0.1, -0.1), MapProjection(PROJ_A, 0.1, -0.1 - (MINIMAL_DEGREE_OF_INTEREST / 2)), True),
+    ]
+)
+def test_projection_equality(lhs: MapProjection, rhs : MapProjection, is_equal: bool) -> None:
+    assert MINIMAL_DEGREE_OF_INTEREST > 0.0
+    assert (lhs == rhs) == is_equal
+    assert (lhs != rhs) == (not is_equal)
+
+def test_invalid_projection_name() -> None:
+    with pytest.raises(ValueError):
+        _ = MapProjection("random name", 1.0, -1.0)

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0}/tests/test_union.py

@@ -49,6 +49,9 @@ def test_find_union_distinct() -> None:
     union = RasterLayer.find_union(layers)
     assert union == Area(-110, 10, 110, -10)
 
+    for layer in layers:
+        layer.set_window_for_union(union)
+
 def test_find_union_with_null() -> None:
     layers = [
         RasterLayer(gdal_dataset_of_region(Area(-10, 10, 10, -10), 0.02)),
@@ -80,6 +83,11 @@ def test_find_union_with_vector_unbound() -> None:
         union = RasterLayer.find_union(layers)
         assert union == vector.area
 
+        raster.set_window_for_union(union)
+        with pytest.raises(ValueError):
+            vector.set_window_for_union(union)
+
+
 def test_find_union_with_vector_bound() -> None:
     with tempfile.TemporaryDirectory() as tempdir:
         path = Path(tempdir) / "test.gpkg"
@@ -95,6 +103,9 @@ def test_find_union_with_vector_bound() -> None:
         union = RasterLayer.find_union(layers)
         assert union == vector.area
 
+        for layer in layers:
+            layer.set_window_for_union(union)
+
 @pytest.mark.parametrize("scale", [0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09])
 def test_set_union_self(scale) -> None:
     layer = RasterLayer(gdal_dataset_of_region(Area(-10, 10, 10, -10), scale))

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0}/tests/test_vectors.py

@@ -29,8 +29,7 @@ def test_basic_dynamic_vector_layer() -> None:
             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.projection == WGS_84_PROJECTION
-            assert layer.map_projection.name == WGS_84_PROJECTION
+            assert layer.map_projection.epsg == 4326
 
             # The astype here is to catch escaping MLX types...
             res = layer.read_array(0, 0, 20, 20).astype(int)
@@ -46,8 +45,7 @@ def test_rastered_vector_layer() -> None:
             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.projection == WGS_84_PROJECTION
-            assert layer.map_projection.name == WGS_84_PROJECTION
+            assert layer.map_projection.epsg == 4326
 
 def test_basic_dynamic_vector_layer_no_filter_match() -> None:
     with tempfile.TemporaryDirectory() as tempdir:

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0}/yirgacheffe/__init__.py

@@ -15,5 +15,6 @@ except ModuleNotFoundError:
 from ._core import read_raster, read_rasters, read_shape, read_shape_like, constant, read_narrow_raster
 from .constants import WGS_84_PROJECTION
 from .window import Area, MapProjection, Window
+from ._backends.enumeration import dtype as DataType
 
 gdal.UseExceptions()

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0}/yirgacheffe/_backends/enumeration.py

@@ -41,6 +41,26 @@ class operators(Enum):
     ISNAN = 36
 
 class dtype(Enum):
+    """Represents the type of data returned by a layer.
+
+    This enumeration defines the valid data types supported by Yirgacheffe, and is
+    what is returned by  calling `datatype` on a layer or expression, and can be
+    passed to `astype` to convert values between types.
+
+    Attributes:
+        Float32: 32 bit floating point value
+        Float64: 64 bit floating point value
+        Byte: Unsigned 8 bit integer value
+        Int8: Signed 8 bit integer value
+        Int16: Signed 16 bit integer value
+        Int32: Signed 32 bit integer value
+        Int64: Signed 64 bit integer value
+        UInt8: Unsigned 8 bit integer value
+        UInt16: Unsigned 16 bit integer value
+        UInt32: Unsigned 32 bit integer value
+        UInt64: Unsigned 64 bit integer value
+    """
+
     Float32 = gdal.GDT_Float32
     Float64 = gdal.GDT_Float64
     Byte = gdal.GDT_Byte

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0}/yirgacheffe/_operators.py

@@ -654,8 +654,8 @@ class LayerOperation(LayerMathMixin):
         for yoffset in range(0, computation_window.ysize, self.ystep):
             if callback:
                 callback(yoffset / computation_window.ysize)
-            step=self.ystep
-            if yoffset+step > computation_window.ysize:
+            step = self.ystep
+            if yoffset + step > computation_window.ysize:
                 step = computation_window.ysize - yoffset
             chunk = self._eval(computation_area, projection, yoffset, step, computation_window)
             if isinstance(chunk, (float, int)):
@@ -935,6 +935,48 @@ class LayerOperation(LayerMathMixin):
 
         return result
 
+    def read_array(self, x: int, y: int, width: int, height: int) -> np.ndarray:
+        """Read an area of pixles from the specified area of a calculated raster.
+
+        Args:
+            x: X axis offset for reading
+            y: Y axis offset for reading
+            width: Width of data to read
+            height: Height of data to read
+
+        Returns:
+            A numpy array containing the requested data. If the region of data read goes
+            beyond the bounds of the calculation that area will be filled with zeros.
+        """
+        projection = self.map_projection
+        if projection is None:
+            raise ValueError("No map projection specified for layers in expression")
+
+        computation_window = Window(0, 0, width, height)
+        expression_area = self.area
+        pixel_scale = projection.scale
+        left = expression_area.left + (x * pixel_scale.xstep)
+        top = expression_area.top + (y * pixel_scale.ystep)
+        computation_area = Area(
+            left=left,
+            top=top,
+            right=left + (width * pixel_scale.xstep),
+            bottom=top + (height * pixel_scale.ystep),
+        )
+
+        chunks = []
+        for yoffset in range(0, height, self.ystep):
+            step = self.ystep
+            if yoffset + step > height:
+                step = height - yoffset
+            chunk = self._eval(computation_area, projection, yoffset, step, computation_window)
+            if isinstance(chunk, (float, int)):
+                chunk = backend.full((step, computation_window.xsize), chunk)
+            chunks.append(chunk)
+        res = np.vstack(chunks)
+
+        return res
+
 class ShaderStyleOperation(LayerOperation):
 
     def _eval(self, area, projection, index, step, target_window=None):

yirgacheffe-1.9.0/yirgacheffe/constants.py

@@ -0,0 +1,8 @@
+import pyproj
+
+YSTEP = 512
+MINIMUM_CHUNKS_PER_THREAD = 1
+
+# I don't really want this here, but it's just too useful having it exposed
+# This used to be a fixed string, but now it is at least programmatically generated
+WGS_84_PROJECTION = pyproj.CRS.from_epsg(4326).to_wkt(version='WKT1_GDAL')

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0}/yirgacheffe/layers/base.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 from typing import Any, Sequence
 
 import deprecation
+from pyproj import Transformer
 
 from .. import __version__
 from .._operators import LayerMathMixin
@@ -332,21 +333,47 @@ class YirgacheffeLayer(LayerMathMixin):
         res = self._read_array(x, y, width, height)
         return backend.demote_array(res)
 
-    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."""
-        if self._projection is None or "WGS 84" not in self._projection.name:
-            raise NotImplementedError("Not yet supported for other projections")
-        return (
-            (y_coord * self._projection.ystep) + self.area.top,
-            (x_coord * self._projection.xstep) + self.area.left
+    def latlng_for_pixel(self, x: int, y: int) -> tuple[float, float]:
+        """Get geo coords for pixel. This is relative to the set view window.
+
+        Args:
+            x: X axis position within raster
+            y: Y axis position within raster
+
+        Returns:
+            A tuple containing the (latitude, longitude).
+        """
+        projection = self.map_projection
+        if projection is None:
+            raise ValueError("Map has not projection space")
+        pixel_scale = projection.scale
+        coord_in_raster_space = (
+            (y * pixel_scale.ystep) + self.area.top,
+            (x * pixel_scale.xstep) + self.area.left,
         )
+        transformer = Transformer.from_crs(projection.name, "EPSG:4326")
+        return transformer.transform(*coord_in_raster_space)
 
     def pixel_for_latlng(self, lat: float, lng: float) -> tuple[int, int]:
         """Get pixel for geo coords. This is relative to the set view window.
-        Result is rounded down to nearest pixel."""
-        if self._projection is None or "WGS 84" not in self._projection.name:
-            raise NotImplementedError("Not yet supported for other projections")
+        Result is rounded down to nearest pixel.
+
+        Args:
+            lat: Geospatial latitude in WGS84
+            lng: Geospatial longitude in WGS84
+
+        Returns:
+            A tuple containing the x, y coordinates in pixel space.
+        """
+        projection = self.map_projection
+        if projection is None:
+            raise ValueError("Map has not projection space")
+
+        transformer = Transformer.from_crs("EPSG:4326", projection.name)
+        x, y = transformer.transform(lng,lat)
+
+        pixel_scale = projection.scale
         return (
-            round_down_pixels((lng - self.area.left) / self._projection.xstep, abs(self._projection.xstep)),
-            round_down_pixels((lat - self.area.top) / self._projection.ystep, abs(self._projection.ystep)),
+            round_down_pixels((x - self.area.left) / pixel_scale.xstep, abs(pixel_scale.xstep)),
+            round_down_pixels((y - self.area.top) / pixel_scale.ystep, abs(pixel_scale.ystep)),
         )

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0}/yirgacheffe/layers/vectors.py

@@ -333,36 +333,36 @@ class VectorLayer(YirgacheffeLayer):
         self._anchor = anchor
         self._envelopes = envelopes
 
-        # if projection is not None:
-        #     # Get the area, but scale it to the pixel resolution that we're using. Note that
-        #     # the pixel scale GDAL uses can have -ve values, but those will mess up the
-        #     # ceil/floor math, so we use absolute versions when trying to round.
-        #     abs_xstep, abs_ystep = abs(projection.xstep), abs(projection.ystep)
-#
-        #     # Lacking any other reference, we will make the raster align with
-        #     # (0.0, 0.0), if sometimes we want to align with an existing raster, so if
-        #     # an anchor is specified, ensure we use that as our pixel space alignment
-        #     x_anchor = anchor[0]
-        #     y_anchor = anchor[1]
-        #     left_shift = x_anchor - abs_xstep
-        #     right_shift = x_anchor
-        #     top_shift = y_anchor
-        #     bottom_shift = y_anchor - abs_ystep
-#
-        #     area = Area(
-        #         left=(floor((min(x[0] for x in envelopes) - left_shift) / abs_xstep) * abs_xstep) + left_shift,
-        #         top=(ceil((max(x[3] for x in envelopes) - top_shift) / abs_ystep) * abs_ystep) + top_shift,
-        #         right=(ceil((max(x[1] for x in envelopes) - right_shift) / abs_xstep) * abs_xstep) + right_shift,
-        #         bottom=(floor((min(x[2] for x in envelopes) - bottom_shift) / abs_ystep) * abs_ystep) + bottom_shift,
-        #     )
-        # else:
+        if projection is not None:
+            # Get the area, but scale it to the pixel resolution that we're using. Note that
+            # the pixel scale GDAL uses can have -ve values, but those will mess up the
+            # ceil/floor math, so we use absolute versions when trying to round.
+            abs_xstep, abs_ystep = abs(projection.xstep), abs(projection.ystep)
+
+            # Lacking any other reference, we will make the raster align with
+            # (0.0, 0.0), if sometimes we want to align with an existing raster, so if
+            # an anchor is specified, ensure we use that as our pixel space alignment
+            x_anchor = anchor[0]
+            y_anchor = anchor[1]
+            left_shift = x_anchor - abs_xstep
+            right_shift = x_anchor
+            top_shift = y_anchor
+            bottom_shift = y_anchor - abs_ystep
+
+            area = Area(
+                left=(floor((min(x[0] for x in envelopes) - left_shift) / abs_xstep) * abs_xstep) + left_shift,
+                top=(ceil((max(x[3] for x in envelopes) - top_shift) / abs_ystep) * abs_ystep) + top_shift,
+                right=(ceil((max(x[1] for x in envelopes) - right_shift) / abs_xstep) * abs_xstep) + right_shift,
+                bottom=(floor((min(x[2] for x in envelopes) - bottom_shift) / abs_ystep) * abs_ystep) + bottom_shift,
+            )
+        else:
             # If we don't have  a projection just go with the idealised area
-        area = Area(
-            left=floor(min(x[0] for x in envelopes)),
-            top=ceil(max(x[3] for x in envelopes)),
-            right=ceil(max(x[1] for x in envelopes)),
-            bottom=floor(min(x[2] for x in envelopes)),
-        )
+            area = Area(
+                left=floor(min(x[0] for x in envelopes)),
+                top=ceil(max(x[3] for x in envelopes)),
+                right=ceil(max(x[1] for x in envelopes)),
+                bottom=floor(min(x[2] for x in envelopes)),
+            )
 
         super().__init__(area, projection)
 

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0}/yirgacheffe/window.py

@@ -4,37 +4,50 @@ import sys
 from collections import namedtuple
 from dataclasses import dataclass
 
+import pyproj
+
 PixelScale = namedtuple('PixelScale', ['xstep', 'ystep'])
 
-@dataclass
 class MapProjection:
     """Records the map projection and the size of the pixels in a layer.
 
     This superceeeds the old PixelScale class, which will be removed in version 2.0.
 
     Args:
-        name: The map projection used.
+        name: The map projection used in WKT format, or as "epsg:xxxx" or "esri:xxxx".
         xstep: The number of units horizontal distance a step of one pixel makes in the map projection.
         ystep: The number of units vertical distance a step of one pixel makes in the map projection.
 
     Attributes:
-        name: The map projection used.
+        name: The map projection used in WKT format.
         xstep: The number of units horizontal distance a step of one pixel makes in the map projection.
         ystep: The number of units vertical distance a step of one pixel makes in the map projection.
     """
 
-    name : str
-    xstep : float
-    ystep : float
+    def __init__(self, projection_string: str, xstep: float, ystep: float) -> None:
+        try:
+            self.crs = pyproj.CRS.from_string(projection_string)
+        except pyproj.exceptions.CRSError as exc:
+            raise ValueError(f"Invalid projection: {projection_string}") from exc
+        self.xstep = xstep
+        self.ystep = ystep
 
     def __eq__(self, other) -> bool:
         if other is None:
             return True
         # to avoid circular dependancies
         from .rounding import are_pixel_scales_equal_enough  # pylint: disable=C0415
-        return (self.name == other.name) and \
+        return (self.crs == other.crs) and \
             are_pixel_scales_equal_enough([self.scale, other.scale])
 
+    @property
+    def name(self) -> str:
+        return self.crs.to_wkt()
+
+    @property
+    def epsg(self) -> int | None:
+        return self.crs.to_epsg()
+
     @property
     def scale(self) -> PixelScale:
         return PixelScale(self.xstep, self.ystep)
@@ -72,7 +85,9 @@ class Area:
     def __hash__(self):
         return (self.left, self.top, self.right, self.bottom).__hash__()
 
-    def __eq__(self, other) -> bool:
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Area):
+            return False
         return math.isclose(self.left, other.left, abs_tol=1e-09) and \
             math.isclose(self.right, other.right, abs_tol=1e-09) and \
             math.isclose(self.top, other.top, abs_tol=1e-09) and \

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0/yirgacheffe.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yirgacheffe
-Version: 1.8.0
+Version: 1.9.0
 Summary: Abstraction of gdal datasets for doing basic math operations
 Author-email: Michael Dales <mwd24@cam.ac.uk>
 License-Expression: ISC
@@ -27,6 +27,7 @@ Requires-Dist: dill
 Requires-Dist: deprecation
 Requires-Dist: tomli
 Requires-Dist: h3
+Requires-Dist: pyproj
 Provides-Extra: mlx
 Requires-Dist: mlx; extra == "mlx"
 Provides-Extra: dev
@@ -44,6 +45,11 @@ Dynamic: license-file
 
 # Yirgacheffe: a declarative geospatial library for Python to make data-science with maps easier
 
+[![CI](https://github.com/quantifyearth/yirgacheffe/actions/workflows/pull-request.yml/badge.svg?branch=main)](https://github.com/quantifyearth/yirgacheffe/actions)
+[![Documentation](https://img.shields.io/badge/docs-yirgacheffe.org-blue)](https://yirgacheffe.org)
+[![PyPI version](https://img.shields.io/pypi/v/yirgacheffe)](https://pypi.org/project/yirgacheffe/)
+
+
 ## Overview
 
 Yirgacheffe is an attempt to wrap raster and polygon geospatial datasets such that you can do computational work on them as a whole or at the pixel level, but without having to do a lot of the grunt work of working out where you need to be in rasters, or managing how much you can load into memory safely.

{yirgacheffe-1.8.0 → yirgacheffe-1.9.0}/yirgacheffe.egg-info/requires.txt

@@ -6,6 +6,7 @@ dill
 deprecation
 tomli
 h3
+pyproj
 
 [dev]
 mypy

yirgacheffe-1.8.0/tests/test_projection.py

@@ -1,32 +0,0 @@
-import pytest
-
-from yirgacheffe.window import MapProjection
-from yirgacheffe.rounding import MINIMAL_DEGREE_OF_INTEREST
-
-def test_scale_from_projection() -> None:
-    projection = MapProjection("PROJ", 0.1, -0.1)
-    assert projection.name == "PROJ"
-    assert projection.xstep == 0.1
-    assert projection.ystep == -0.1
-
-    scale = projection.scale
-    assert scale.xstep == 0.1
-    assert scale.ystep == -0.1
-
-@pytest.mark.parametrize(
-    "lhs,rhs,is_equal",
-    [
-        (MapProjection("A", 0.1, -0.1), MapProjection("A", 0.1, -0.1), True),
-        (MapProjection("A", 0.1, -0.1), MapProjection("B", 0.1, -0.1), False),
-        (MapProjection("A", 0.1, -0.1), MapProjection("A", 0.1, 0.1), False),
-        (MapProjection("A", 0.1, -0.1), MapProjection("A", -0.1, 0.1), False),
-        (MapProjection("A", 0.1, -0.1), MapProjection("A", 0.1 + (MINIMAL_DEGREE_OF_INTEREST / 2), -0.1), True),
-        (MapProjection("A", 0.1, -0.1), MapProjection("A", 0.1 - (MINIMAL_DEGREE_OF_INTEREST / 2), -0.1), True),
-        (MapProjection("A", 0.1, -0.1), MapProjection("A", 0.1, -0.1 + (MINIMAL_DEGREE_OF_INTEREST / 2)), True),
-        (MapProjection("A", 0.1, -0.1), MapProjection("A", 0.1, -0.1 - (MINIMAL_DEGREE_OF_INTEREST / 2)), True),
-    ]
-)
-def test_projection_equality(lhs: MapProjection, rhs : MapProjection, is_equal: bool) -> None:
-    assert MINIMAL_DEGREE_OF_INTEREST > 0.0
-    assert (lhs == rhs) == is_equal
-    assert (lhs != rhs) == (not is_equal)

yirgacheffe-1.8.0/yirgacheffe/constants.py

@@ -1,8 +0,0 @@
-YSTEP = 512
-MINIMUM_CHUNKS_PER_THREAD = 1
-
-# I don't really want this here, but it's just too useful having it exposed
-WGS_84_PROJECTION = 'GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563,'\
-	'AUTHORITY["EPSG","7030"]],AUTHORITY["EPSG","6326"]],PRIMEM["Greenwich",0],'\
-	'UNIT["degree",0.0174532925199433,AUTHORITY["EPSG","9122"]],AXIS["Latitude",NORTH],'\
-	'AXIS["Longitude",EAST],AUTHORITY["EPSG","4326"]]'