yirgacheffe 1.8.0__py3-none-any.whl → 1.9.0__py3-none-any.whl

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/_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/_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/constants.py

@@ -1,8 +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
-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"]]'
+# 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/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/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/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.dist-info → yirgacheffe-1.9.0.dist-info}/METADATA

@@ -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.dist-info → yirgacheffe-1.9.0.dist-info}/RECORD

@@ -1,27 +1,27 @@
-yirgacheffe/__init__.py,sha256=SBRDdk_GEIN6tOxxGrNySjT9ympv9FL6thEgsiycODo,615
+yirgacheffe/__init__.py,sha256=OOzfXtafPoDpAsNRC08BXjmwv0hBp-mNFCjwplGs9lY,668
 yirgacheffe/_core.py,sha256=AU6tlqovBV_l1dNZs6AlHSw59Z0U6pStUaQZvJGiLhM,5721
-yirgacheffe/_operators.py,sha256=OiR4pCVILmdXDmG37YILJuYjcxZlRussrJC7DeyoOts,36070
-yirgacheffe/constants.py,sha256=uCWJwec3-ND-zVxYbsk1sdHKANl3ToNCTPg7MZb0j2g,434
+yirgacheffe/_operators.py,sha256=cnJgnfnfIRwrPB6sX2TVU_-s4eDyhZCPyemwIBFurxU,37723
+yirgacheffe/constants.py,sha256=bKUjOGNj19zwggV79lJgK7tiv51DH2-rgNOKswl2gvQ,293
 yirgacheffe/operators.py,sha256=nw-BpnAwTjCwFtjosa8wKd2MGUuC0PJR5jACFdLhqCg,412
 yirgacheffe/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 yirgacheffe/rounding.py,sha256=ZNuAaxsWfzYETC_G9H5weY1ZOci2pihEKTVrUiIqfZw,2257
-yirgacheffe/window.py,sha256=-5eB3rnVUr7p_A2VKt_DqR-ACDeNwRt6X0_UEiVLCo8,8913
+yirgacheffe/window.py,sha256=QuyBLOwKFI0XkEQ4Bd2hdELPbJSfHL7mt5KSi7CIHcE,9505
 yirgacheffe/_backends/__init__.py,sha256=jN-2iRrHStnPI6cNL7XhwhsROtI0EaGfIrbF5c-ECV0,334
-yirgacheffe/_backends/enumeration.py,sha256=Jrce2p2n4Wlk5tHBkiWntDnpLSD_0H-bnwgsKXHjkwQ,1018
+yirgacheffe/_backends/enumeration.py,sha256=9bcCXz9Ssrh8Oh1iazodkx6Gm2kQBi9HQ9z9zehS4AE,1806
 yirgacheffe/_backends/mlx.py,sha256=U1gl1lK1mZXLEET6ylF1TNs6WJ0PBEvfSk7ppn28n8w,6203
 yirgacheffe/_backends/numpy.py,sha256=Gxx49JJH79GFEkKIpV6IyjCUcdtN5-qLlzRfylzKhS4,4142
 yirgacheffe/layers/__init__.py,sha256=mYKjw5YTcMNv_hMy7a6K4yRzIuNUbR8WuBTw4WIAmSk,435
 yirgacheffe/layers/area.py,sha256=wJcMHbLJBaXS4BeFbu5rYeKfgu3gvaE9hwQ5j6aw-y4,3976
-yirgacheffe/layers/base.py,sha256=dQQLFKP05QK4C73N1DCDYT8D8eD15HuSQKN5KrABeHg,14289
+yirgacheffe/layers/base.py,sha256=EkfR3DOQ1I_tQZfpOSczs-sWFSP6uUMXdiB7xspfd4E,14954
 yirgacheffe/layers/constant.py,sha256=gtkQ98Z01CYYDgFElswtRZY4ZG3UnS5NIAoIVue5ufk,1481
 yirgacheffe/layers/group.py,sha256=yaqf-ra_Vh59yrWcz7-OvJ1fBnTcBXZd18AfRDN5Ymo,16157
 yirgacheffe/layers/h3layer.py,sha256=Rq1bFo7CApIh5NdBcV7hSj3hm-DszY79nhYsTRAvJ_g,9916
 yirgacheffe/layers/rasters.py,sha256=zBE9uXm6LvAQF2_XdQzcOgJQOQWGmuPflY5JNDrUf3k,13527
 yirgacheffe/layers/rescaled.py,sha256=gEFbXeYxX1nVn7eQYmbGww90_yc5ENmgQrD_WxXxpQE,3352
-yirgacheffe/layers/vectors.py,sha256=AD1KcXO5acFZ9CTRENTPA_D9DMGSjAxGIF298LdeNeY,20010
-yirgacheffe-1.8.0.dist-info/licenses/LICENSE,sha256=dNSHwUCJr6axStTKDEdnJtfmDdFqlE3h1NPCveqPfnY,757
-yirgacheffe-1.8.0.dist-info/METADATA,sha256=wcJXfOQ15YfLkT-0TvivPXKZnyanK2wEQsalRY6f2Yk,23797
-yirgacheffe-1.8.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-yirgacheffe-1.8.0.dist-info/entry_points.txt,sha256=j4KgHXbVGbGyfTySc1ypBdERpfihO4WNjppvCdE9HjE,52
-yirgacheffe-1.8.0.dist-info/top_level.txt,sha256=9DBFlKO2Ld3hG6TuE3qOTd3Tt8ugTiXil4AN4Wr9_y0,12
-yirgacheffe-1.8.0.dist-info/RECORD,,
+yirgacheffe/layers/vectors.py,sha256=A27kuTr0C9BZhHG0-cplNEa7aSNcse37Pm9xTjEzv-c,19990
+yirgacheffe-1.9.0.dist-info/licenses/LICENSE,sha256=dNSHwUCJr6axStTKDEdnJtfmDdFqlE3h1NPCveqPfnY,757
+yirgacheffe-1.9.0.dist-info/METADATA,sha256=ciRPPO-k-vbyd0gbg_u-uinc739ZoPuazQna9MpluCM,24186
+yirgacheffe-1.9.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+yirgacheffe-1.9.0.dist-info/entry_points.txt,sha256=j4KgHXbVGbGyfTySc1ypBdERpfihO4WNjppvCdE9HjE,52
+yirgacheffe-1.9.0.dist-info/top_level.txt,sha256=9DBFlKO2Ld3hG6TuE3qOTd3Tt8ugTiXil4AN4Wr9_y0,12
+yirgacheffe-1.9.0.dist-info/RECORD,,