yirgacheffe 1.8.1__tar.gz → 1.9.1__tar.gz

{yirgacheffe-1.8.1/yirgacheffe.egg-info → yirgacheffe-1.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yirgacheffe
-Version: 1.8.1
+Version: 1.9.1
 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.1 → yirgacheffe-1.9.1}/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.1 → yirgacheffe-1.9.1}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "yirgacheffe"
-version = "1.8.1"
+version = "1.9.1"
 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.1 → yirgacheffe-1.9.1}/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.1 → yirgacheffe-1.9.1}/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.1 → yirgacheffe-1.9.1}/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.1 → yirgacheffe-1.9.1}/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.8.1/tests/test_base.py → yirgacheffe-1.9.1/tests/test_pixel_coord.py

@@ -1,136 +1,196 @@
 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])
 
+def test_latlng_for_pixel_on_operator() -> None:
+    layer1 = YirgacheffeLayer(
+        Area(-10, 10, 10, -10),
+        MapProjection("epsg:4326", 0.2, -0.2),
+    )
+    layer2 = YirgacheffeLayer(
+        Area(-10, 10, 10, -10),
+        MapProjection("epsg:4326", 0.2, -0.2),
+    )
+    calc = layer1 + layer2
+    result = calc.latlng_for_pixel(0, 0)
+    expected = (10.0, -10.0)
+    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
 
+def test_pixel_for_latlng_on_operator() -> None:
+    layer1 = YirgacheffeLayer(
+        Area(-10, 10, 10, -10),
+        MapProjection("epsg:4326", 0.2, -0.2),
+    )
+    layer2 = YirgacheffeLayer(
+        Area(-10, 10, 10, -10),
+        MapProjection("epsg:4326", 0.2, -0.2),
+    )
+    calc = layer1 + layer2
+    result = calc.pixel_for_latlng(10, -10)
+    expected = (0, 0)
+    assert math.isclose(result[0], expected[0])
+    assert math.isclose(result[1], expected[1])
 
 @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 +199,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 +213,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 +241,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.9.1/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.1 → yirgacheffe-1.9.1}/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.1 → yirgacheffe-1.9.1}/yirgacheffe/_operators.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import builtins
 import logging
 import math
 import multiprocessing
@@ -21,6 +22,7 @@ import numpy as np
 import numpy.typing as npt
 from osgeo import gdal
 from dill import dumps, loads # type: ignore
+from pyproj import Transformer
 
 from . import constants, __version__
 from .rounding import round_up_pixels, round_down_pixels
@@ -290,6 +292,53 @@ class LayerMathMixin:
             datatype=datatype
         )
 
+    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 # type: ignore[attr-defined]
+        area = self.area # type: ignore[attr-defined]
+        if projection is None:
+            raise ValueError("Map has not projection space")
+        pixel_scale = projection.scale
+        coord_in_raster_space = (
+            (y * pixel_scale.ystep) + area.top,
+            (x * pixel_scale.xstep) + 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.
+
+        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 # type: ignore[attr-defined]
+        area = self.area # type: ignore[attr-defined]
+        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((x - area.left) / pixel_scale.xstep, builtins.abs(pixel_scale.xstep)),
+            round_down_pixels((y - area.top) / pixel_scale.ystep, builtins.abs(pixel_scale.ystep)),
+        )
+
 
 class LayerOperation(LayerMathMixin):
 
@@ -654,8 +703,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 +984,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.1/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.1 → yirgacheffe-1.9.1}/yirgacheffe/layers/base.py

@@ -331,22 +331,3 @@ 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 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")
-        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)),
-        )

{yirgacheffe-1.8.1 → yirgacheffe-1.9.1}/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)

{yirgacheffe-1.8.1 → yirgacheffe-1.9.1/yirgacheffe.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yirgacheffe
-Version: 1.8.1
+Version: 1.9.1
 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.1 → yirgacheffe-1.9.1}/yirgacheffe.egg-info/SOURCES.txt

@@ -4,7 +4,6 @@ README.md
 pyproject.toml
 tests/test_area.py
 tests/test_auto_windowing.py
-tests/test_base.py
 tests/test_constants.py
 tests/test_datatypes.py
 tests/test_group.py
@@ -17,6 +16,7 @@ tests/test_operators.py
 tests/test_optimisation.py
 tests/test_parallel_operators.py
 tests/test_pickle.py
+tests/test_pixel_coord.py
 tests/test_projection.py
 tests/test_raster.py
 tests/test_rescaling.py

{yirgacheffe-1.8.1 → yirgacheffe-1.9.1}/yirgacheffe.egg-info/requires.txt

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

yirgacheffe-1.8.1/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.1/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"]]'