yirgacheffe 1.6.0__py3-none-any.whl → 1.7.0__py3-none-any.whl

yirgacheffe/layers/rescaled.py

@@ -6,7 +6,7 @@ from typing import Any, Optional, Union
 from skimage import transform
 from yirgacheffe.operators import DataType
 
-from ..window import PixelScale, Window
+from ..window import MapProjection, PixelScale, Window
 from .rasters import RasterLayer, YirgacheffeLayer
 from .._backends import backend
 
@@ -24,30 +24,33 @@ class RescaledRasterLayer(YirgacheffeLayer):
         nearest_neighbour: bool = True,
     ) -> RescaledRasterLayer:
         src = RasterLayer.layer_from_file(filename, band=band)
-        return RescaledRasterLayer(src, pixel_scale, nearest_neighbour, src.name)
+        source_projection = src.map_projection
+        if source_projection is None:
+            raise ValueError("Source raster must have projection and scale")
+        target_projection = MapProjection(source_projection.name, pixel_scale.xstep, pixel_scale.ystep)
+        return RescaledRasterLayer(src, target_projection, nearest_neighbour, src.name)
 
     def __init__(
         self,
         src: RasterLayer,
-        pixel_scale: PixelScale,
+        target_projection: MapProjection,
         nearest_neighbour: bool = True,
         name: Optional[str] = None,
     ):
         super().__init__(
             src.area,
-            pixel_scale=pixel_scale,
-            projection=src.projection,
+            target_projection,
             name=name
         )
 
         self._src = src
         self._nearest_neighbour = nearest_neighbour
 
-        src_pixel_scale = src.pixel_scale
-        assert src_pixel_scale # from raster we should always have one
+        src_projection = src.map_projection
+        assert src_projection # from raster we should always have one
 
-        self._x_scale = src_pixel_scale.xstep / pixel_scale.xstep
-        self._y_scale = src_pixel_scale.ystep / pixel_scale.ystep
+        self._x_scale = src_projection.xstep / target_projection.xstep
+        self._y_scale = src_projection.ystep / target_projection.ystep
 
     def close(self):
         self._src.close()

yirgacheffe/layers/vectors.py

@@ -7,7 +7,7 @@ from typing_extensions import NotRequired
 from osgeo import gdal, ogr
 
 from ..operators import DataType
-from ..window import Area, PixelScale
+from ..window import Area, MapProjection, PixelScale
 from .base import YirgacheffeLayer
 from .rasters import RasterLayer
 from .._backends import backend
@@ -84,10 +84,11 @@ class RasteredVectorLayer(RasterLayer):
         else:
             datatype_arg = datatype
 
+        map_projection = MapProjection(projection, scale.xstep, scale.ystep)
+
         vector_layer = RasteredVectorLayer(
             layer,
-            scale,
-            projection,
+            map_projection,
             datatype=datatype_arg,
             burn_value=burn_value
         )
@@ -101,8 +102,7 @@ class RasteredVectorLayer(RasterLayer):
     def __init__(
         self,
         layer: ogr.Layer,
-        scale: PixelScale,
-        projection: str,
+        projection: MapProjection,
         datatype: Union[int, DataType] = DataType.Byte,
         burn_value: Union[int,float,str] = 1,
     ):
@@ -132,7 +132,7 @@ class RasteredVectorLayer(RasterLayer):
         # 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(scale.xstep), abs(scale.ystep)
+        abs_xstep, abs_ystep = abs(projection.xstep), abs(projection.ystep)
         area = Area(
             left=floor(min(x[0] for x in envelopes) / abs_xstep) * abs_xstep,
             top=ceil(max(x[3] for x in envelopes) / abs_ystep) * abs_ystep,
@@ -152,8 +152,8 @@ class RasteredVectorLayer(RasterLayer):
         if not dataset:
             raise MemoryError('Failed to create memory mask')
 
-        dataset.SetProjection(projection)
-        dataset.SetGeoTransform([area.left, scale.xstep, 0.0, area.top, 0.0, scale.ystep])
+        dataset.SetProjection(projection.name)
+        dataset.SetGeoTransform([area.left, projection.xstep, 0.0, area.top, 0.0, projection.ystep])
         if isinstance(burn_value, (int, float)):
             gdal.RasterizeLayer(dataset, [1], self.layer, burn_values=[burn_value], options=["ALL_TOUCHED=TRUE"])
         elif isinstance(burn_value, str):
@@ -180,8 +180,9 @@ class VectorLayer(YirgacheffeLayer):
     ) -> VectorLayer:
         if other_layer is None:
             raise ValueError("like layer can not be None")
-        if other_layer.pixel_scale is None:
-            raise ValueError("Reference layer must have pixel scale")
+        map_projection = other_layer.map_projection
+        if map_projection is None:
+            raise ValueError("Reference layer must have projectione")
 
         vectors = ogr.Open(filename)
         if vectors is None:
@@ -196,8 +197,7 @@ class VectorLayer(YirgacheffeLayer):
 
         vector_layer = VectorLayer(
             layer,
-            other_layer.pixel_scale,
-            other_layer.projection,
+            map_projection,
             name=str(filename),
             datatype=datatype if datatype is not None else other_layer.datatype,
             burn_value=burn_value,
@@ -217,8 +217,34 @@ class VectorLayer(YirgacheffeLayer):
         cls,
         filename: Union[Path,str],
         where_filter: Optional[str],
-        scale: PixelScale,
-        projection: str,
+        scale: Optional[PixelScale],
+        projection: Optional[str],
+        datatype: Optional[Union[int, DataType]] = None,
+        burn_value: Union[int,float,str] = 1,
+        anchor: Tuple[float,float] = (0.0, 0.0)
+    ) -> VectorLayer:
+        # In 2.0 we need to remove this and migrate to the MapProjection version
+        if (projection is None) ^ (scale is None):
+            raise ValueError("Either both projection and scale must be provide, or neither")
+        if projection is not None and scale is not None:
+            map_projection = MapProjection(projection, scale.xstep, scale.ystep)
+        else:
+            map_projection = None
+        return cls._future_layer_from_file(
+            filename,
+            where_filter,
+            map_projection,
+            datatype,
+            burn_value,
+            anchor
+        )
+
+    @classmethod
+    def _future_layer_from_file(
+        cls,
+        filename: Union[Path,str],
+        where_filter: Optional[str],
+        projection: Optional[MapProjection],
         datatype: Optional[Union[int, DataType]] = None,
         burn_value: Union[int,float,str] = 1,
         anchor: Tuple[float,float] = (0.0, 0.0)
@@ -243,7 +269,6 @@ class VectorLayer(YirgacheffeLayer):
 
         vector_layer = VectorLayer(
             layer,
-            scale,
             projection,
             name=str(filename),
             datatype=datatype_arg,
@@ -262,8 +287,7 @@ class VectorLayer(YirgacheffeLayer):
     def __init__(
         self,
         layer: ogr.Layer,
-        scale: PixelScale,
-        projection: str,
+        projection: Optional[MapProjection],
         name: Optional[str] = None,
         datatype: Union[int,DataType] = DataType.Byte,
         burn_value: Union[int,float,str] = 1,
@@ -286,6 +310,7 @@ class VectorLayer(YirgacheffeLayer):
         self._original = None
         self._dataset_path: Optional[Path] = None
         self._filter: Optional[str] = None
+        self._anchor: Tuple[float,float] = (0.0, 0.0)
 
         # work out region for mask
         envelopes = []
@@ -298,30 +323,84 @@ class VectorLayer(YirgacheffeLayer):
             feature = layer.GetNextFeature()
         if len(envelopes) == 0:
             raise ValueError('No geometry found')
-
-        # 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(scale.xstep), abs(scale.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
-
+        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 we don't have  a projection just go with the idealised area
         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,
+            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, scale, projection)
+        super().__init__(area, projection)
+
+
+    def _get_operation_area(self, projection: Optional[MapProjection]=None) -> Area:
+        if self._projection is not None and projection is not None and self._projection != projection:
+            raise ValueError("Calculation projection does not match layer projection")
+
+        target_projection = projection if projection is not None else self._projection
+
+        if target_projection is None:
+            if self._active_area is not None:
+                return self._active_area
+            else:
+                return self._underlying_area
+        else:
+            # 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(target_projection.xstep), abs(target_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 = self._anchor[0]
+            y_anchor = self._anchor[1]
+            left_shift = x_anchor - abs_xstep
+            right_shift = x_anchor
+            top_shift = y_anchor
+            bottom_shift = y_anchor - abs_ystep
+
+            envelopes = self._envelopes
+            return 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,
+            )
+
+    @property
+    def area(self) -> Area:
+        if self._active_area is not None:
+            return self._active_area
+        else:
+            return self._get_operation_area()
 
     def __getstate__(self) -> object:
         # Only support pickling on file backed layers (ideally read only ones...)
@@ -362,12 +441,14 @@ class VectorLayer(YirgacheffeLayer):
     def _read_array_for_area(
         self,
         target_area: Area,
+        target_projection: Optional[MapProjection],
         x: int,
         y: int,
         width: int,
         height: int,
     ) -> Any:
-        assert self._pixel_scale is not None
+        projection = target_projection if target_projection is not None else self._projection
+        assert projection is not None
 
         if self._original is None:
             self._unpark()
@@ -387,14 +468,14 @@ class VectorLayer(YirgacheffeLayer):
         if not dataset:
             raise MemoryError('Failed to create memory mask')
 
-        dataset.SetProjection(self._projection)
+        dataset.SetProjection(projection.name)
         dataset.SetGeoTransform([
-            target_area.left + (x * self._pixel_scale.xstep),
-            self._pixel_scale.xstep,
+            target_area.left + (x * projection.xstep),
+            projection.xstep,
             0.0,
-            target_area.top + (y * self._pixel_scale.ystep),
+            target_area.top + (y * projection.ystep),
             0.0,
-            self._pixel_scale.ystep
+            projection.ystep
         ])
         if isinstance(self.burn_value, (int, float)):
             gdal.RasterizeLayer(dataset, [1], self.layer, burn_values=[self.burn_value], options=["ALL_TOUCHED=TRUE"])
@@ -410,4 +491,4 @@ class VectorLayer(YirgacheffeLayer):
         assert NotRequired
 
     def read_array(self, x: int, y: int, width: int, height: int) -> Any:
-        return self._read_array_for_area(self._active_area, x, y, width, height)
+        return self._read_array_for_area(self.area, None, x, y, width, height)