yirgacheffe 1.6.1__py3-none-any.whl → 1.7.1__py3-none-any.whl

yirgacheffe/__init__.py

@@ -1,9 +1,16 @@
+from pathlib import Path
+
 from osgeo import gdal
+import tomli as tomllib
+
 try:
     from importlib import metadata
-    __version__ = metadata.version(__name__)
+    __version__: str = metadata.version(__name__)
 except ModuleNotFoundError:
-    __version__ = "unknown"
+    pyproject_path = Path(__file__).parent.parent / "pyproject.toml"
+    with open(pyproject_path, "rb") as f:
+        pyproject_data = tomllib.load(f)
+    __version__ = pyproject_data["project"]["version"]
 
 from ._core import read_raster, read_rasters, read_shape, read_shape_like
 from .constants import WGS_84_PROJECTION

yirgacheffe/_core.py

@@ -1,11 +1,11 @@
 from pathlib import Path
-from typing import List, Optional, Tuple, Union
+from typing import Optional, Sequence, Tuple, Union
 
 from .layers.base import YirgacheffeLayer
 from .layers.group import GroupLayer, TiledGroupLayer
 from .layers.rasters import RasterLayer
 from .layers.vectors import VectorLayer
-from .window import PixelScale
+from .window import MapProjection
 from .operators import DataType
 
 def read_raster(
@@ -32,7 +32,7 @@ def read_raster(
     return RasterLayer.layer_from_file(filename, band, ignore_nodata)
 
 def read_rasters(
-    filenames : Union[List[Path],List[str]],
+    filenames : Sequence[Union[Path,str]],
     tiled: bool=False
 ) -> GroupLayer:
     """Open a set of raster files (e.g., GeoTIFFs) as a single layer.
@@ -58,8 +58,7 @@ def read_rasters(
 
 def read_shape(
     filename: Union[Path,str],
-    scale: Union[PixelScale, Tuple[float,float]],
-    projection: str,
+    projection: Union[Optional[MapProjection],Optional[Tuple[str,Tuple[float,float]]]]=None,
     where_filter: Optional[str] = None,
     datatype: Optional[DataType] = None,
     burn_value: Union[int,float,str] = 1,
@@ -70,10 +69,8 @@ def read_shape(
     ----------
     filename : Path
         Path of raster file to open.
-    scale: PixelScale or tuple of float
-        The dimensions of each pixel.
-    projection: str
-        The map projection to use
+    projection: MapProjection or tuple, optional
+        The map projection to use,
     where_filter : str, optional
         For use with files with many entries (e.g., GPKG), applies this filter to the data.
     datatype: DataType, default=DataType.Byte
@@ -87,16 +84,17 @@ def read_shape(
         Returns an layer representing the vector data.
     """
 
-    if not isinstance(scale, PixelScale):
-        scale = PixelScale(scale[0], scale[1])
+    if projection is not None:
+        if not isinstance(projection, MapProjection):
+            projection_name, scale_tuple = projection
+            projection = MapProjection(projection_name, scale_tuple[0], scale_tuple[1])
 
-    return VectorLayer.layer_from_file(
+    return VectorLayer._future_layer_from_file(
         filename,
         where_filter,
-        scale,
         projection,
         datatype,
-        burn_value
+        burn_value,
     )
 
 def read_shape_like(

yirgacheffe/layers/area.py

@@ -65,13 +65,13 @@ class UniformAreaLayer(RasterLayer):
 
         transform = dataset.GetGeoTransform()
 
-        pixel_scale = self.pixel_scale
-        assert pixel_scale # from raster we should always have one
+        projection = self.map_projection
+        assert projection is not None # from raster we should always have one
 
         self._underlying_area = Area(
-            floor(-180 / pixel_scale.xstep) * pixel_scale.xstep,
+            floor(-180 / projection.xstep) * projection.xstep,
             self.area.top,
-            ceil(180 / pixel_scale.xstep) * pixel_scale.xstep,
+            ceil(180 / projection.xstep) * projection.xstep,
             self.area.bottom
         )
         self._active_area = self._underlying_area

yirgacheffe/layers/base.py

@@ -1,9 +1,13 @@
 from __future__ import annotations
 from typing import Any, Optional, Sequence, Tuple
 
+import deprecation
+
+from .. import __version__
 from ..operators import DataType, LayerMathMixin
-from ..rounding import almost_equal, are_pixel_scales_equal_enough, round_up_pixels, round_down_pixels
-from ..window import Area, PixelScale, Window
+from ..rounding import almost_equal, round_up_pixels, round_down_pixels
+from ..window import Area, MapProjection, PixelScale, Window
+from .._backends import backend
 
 class YirgacheffeLayer(LayerMathMixin):
     """The common base class for the different layer types. Most still inherit from RasterLayer as deep down
@@ -12,13 +16,15 @@ class YirgacheffeLayer(LayerMathMixin):
 
     def __init__(self,
         area: Area,
-        pixel_scale: Optional[PixelScale],
-        projection: str,
+        projection: Optional[MapProjection],
         name: Optional[str] = None
     ):
-        self._pixel_scale = pixel_scale
+        # This is just to catch code that uses the old private API
+        if projection is not None and not isinstance(projection, MapProjection):
+            raise TypeError("projection value of wrong type")
+
         self._underlying_area = area
-        self._active_area = area
+        self._active_area: Optional[Area] = None
         self._projection = projection
         self._window: Optional[Window] = None
         self.name = name
@@ -49,16 +55,46 @@ class YirgacheffeLayer(LayerMathMixin):
         raise NotImplementedError("Must be overridden by subclass")
 
     @property
-    def projection(self) -> str:
-        return self._projection
+    @deprecation.deprecated(
+        deprecated_in="1.7",
+        removed_in="2.0",
+        current_version=__version__,
+        details="Use `map_projection` instead."
+    )
+    def projection(self) -> Optional[str]:
+        if self._projection:
+            return self._projection.name
+        else:
+            return None
 
     @property
+    @deprecation.deprecated(
+        deprecated_in="1.7",
+        removed_in="2.0",
+        current_version=__version__,
+        details="Use `map_projection` instead."
+    )
     def pixel_scale(self) -> Optional[PixelScale]:
-        return self._pixel_scale
+        if self._projection:
+            return PixelScale(self._projection.xstep, self._projection.ystep)
+        else:
+            return None
+
+    @property
+    def map_projection(self) -> Optional[MapProjection]:
+        return self._projection
 
     @property
     def area(self) -> Area:
-        return self._active_area
+        if self._active_area is not None:
+            return self._active_area
+        else:
+            return self._underlying_area
+
+    def _get_operation_area(self, projection: Optional[MapProjection]) -> 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")
+        return self.area
 
     @property
     def window(self) -> Window:
@@ -77,8 +113,11 @@ class YirgacheffeLayer(LayerMathMixin):
 
         # This only makes sense (currently) if all layers
         # have the same pixel pitch (modulo desired accuracy)
-        if not are_pixel_scales_equal_enough([x.pixel_scale for x in layers]):
-            raise ValueError("Not all layers are at the same pixel scale")
+        projections = [x.map_projection for x in layers if x.map_projection is not None]
+        if not projections:
+            raise ValueError("No layers have a projection")
+        if not all(projections[0] == x for x in projections[1:]):
+            raise ValueError("Not all layers are at the same projectin or pixel scale")
 
         intersection = Area(
             left=max(x._underlying_area.left for x in layers),
@@ -97,8 +136,11 @@ class YirgacheffeLayer(LayerMathMixin):
 
         # This only makes sense (currently) if all layers
         # have the same pixel pitch (modulo desired accuracy)
-        if not are_pixel_scales_equal_enough([x.pixel_scale for x in layers]):
-            raise ValueError("Not all layers are at the same pixel scale")
+        projections = [x.map_projection for x in layers if x.map_projection is not None]
+        if not projections:
+            raise ValueError("No layers have a projection")
+        if not all(projections[0] == x for x in projections[1:]):
+            raise ValueError("Not all layers are at the same projectin or pixel scale")
 
         return Area(
             left=min(x._underlying_area.left for x in layers),
@@ -109,11 +151,11 @@ class YirgacheffeLayer(LayerMathMixin):
 
     @property
     def geo_transform(self) -> Tuple[float, float, float, float, float, float]:
-        if self._pixel_scale is None:
-            raise ValueError("No geo transform for layers without explicit pixel scale")
+        if self._projection is None:
+            raise AttributeError("No geo transform for layers without explicit pixel scale")
         return (
-            self._active_area.left, self._pixel_scale.xstep, 0.0,
-            self._active_area.top, 0.0, self._pixel_scale.ystep
+            self.area.left, self._projection.xstep, 0.0,
+            self.area.top, 0.0, self._projection.ystep
         )
 
     def check_pixel_scale(self, scale: PixelScale) -> bool:
@@ -124,21 +166,21 @@ class YirgacheffeLayer(LayerMathMixin):
             almost_equal(our_scale.ystep, scale.ystep)
 
     def set_window_for_intersection(self, new_area: Area) -> None:
-        if self._pixel_scale is None:
+        if self._projection is None:
             raise ValueError("Can not set Window without explicit pixel scale")
 
         new_window = Window(
-            xoff=round_down_pixels((new_area.left - self._underlying_area.left) / self._pixel_scale.xstep,
-                self._pixel_scale.xstep),
-            yoff=round_down_pixels((self._underlying_area.top - new_area.top) / (self._pixel_scale.ystep * -1.0),
-                self._pixel_scale.ystep * -1.0),
+            xoff=round_down_pixels((new_area.left - self._underlying_area.left) / self._projection.xstep,
+                self._projection.xstep),
+            yoff=round_down_pixels((self._underlying_area.top - new_area.top) / (self._projection.ystep * -1.0),
+                self._projection.ystep * -1.0),
             xsize=round_up_pixels(
-                (new_area.right - new_area.left) / self._pixel_scale.xstep,
-                self._pixel_scale.xstep
+                (new_area.right - new_area.left) / self._projection.xstep,
+                self._projection.xstep
             ),
             ysize=round_up_pixels(
-                (new_area.top - new_area.bottom) / (self._pixel_scale.ystep * -1.0),
-                (self._pixel_scale.ystep * -1.0)
+                (new_area.top - new_area.bottom) / (self._projection.ystep * -1.0),
+                (self._projection.ystep * -1.0)
             ),
         )
         if (new_window.xoff < 0) or (new_window.yoff < 0):
@@ -156,21 +198,21 @@ class YirgacheffeLayer(LayerMathMixin):
         self._active_area = new_area
 
     def set_window_for_union(self, new_area: Area) -> None:
-        if self._pixel_scale is None:
+        if self._projection is None:
             raise ValueError("Can not set Window without explicit pixel scale")
 
         new_window = Window(
-            xoff=round_down_pixels((new_area.left - self._underlying_area.left) / self._pixel_scale.xstep,
-                self._pixel_scale.xstep),
-            yoff=round_down_pixels((self._underlying_area.top - new_area.top) / (self._pixel_scale.ystep * -1.0),
-                self._pixel_scale.ystep * -1.0),
+            xoff=round_down_pixels((new_area.left - self._underlying_area.left) / self._projection.xstep,
+                self._projection.xstep),
+            yoff=round_down_pixels((self._underlying_area.top - new_area.top) / (self._projection.ystep * -1.0),
+                self._projection.ystep * -1.0),
             xsize=round_up_pixels(
-                (new_area.right - new_area.left) / self._pixel_scale.xstep,
-                self._pixel_scale.xstep
+                (new_area.right - new_area.left) / self._projection.xstep,
+                self._projection.xstep
             ),
             ysize=round_up_pixels(
-                (new_area.top - new_area.bottom) / (self._pixel_scale.ystep * -1.0),
-                (self._pixel_scale.ystep * -1.0)
+                (new_area.top - new_area.bottom) / (self._projection.ystep * -1.0),
+                (self._projection.ystep * -1.0)
             ),
         )
         if (new_window.xoff > 0) or (new_window.yoff > 0):
@@ -188,14 +230,14 @@ class YirgacheffeLayer(LayerMathMixin):
         self._active_area = new_area
 
     def reset_window(self) -> None:
-        self._active_area = self._underlying_area
-        if self._pixel_scale:
-            abs_xstep, abs_ystep = abs(self._pixel_scale.xstep), abs(self._pixel_scale.ystep)
+        self._active_area = None
+        if self._projection:
+            abs_xstep, abs_ystep = abs(self._projection.xstep), abs(self._projection.ystep)
             self._window = Window(
                 xoff=0,
                 yoff=0,
-                xsize=round_up_pixels((self.area.right - self.area.left) / self._pixel_scale.xstep, abs_xstep),
-                ysize=round_up_pixels((self.area.bottom - self.area.top) / self._pixel_scale.ystep, abs_ystep),
+                xsize=round_up_pixels((self.area.right - self.area.left) / self._projection.xstep, abs_xstep),
+                ysize=round_up_pixels((self.area.bottom - self.area.top) / self._projection.ystep, abs_ystep),
             )
 
     def offset_window_by_pixels(self, offset: int) -> None:
@@ -244,29 +286,34 @@ class YirgacheffeLayer(LayerMathMixin):
     def _read_array_for_area(
         self,
         target_area: Area,
+        target_projection: MapProjection,
         x: int,
         y: int,
         width: int,
         height: int,
     ) -> Any:
-        assert self._pixel_scale is not None
+        assert self._projection is not None
+        assert self._projection == target_projection
 
         target_window = Window(
-            xoff=round_down_pixels((target_area.left - self._underlying_area.left) / self._pixel_scale.xstep,
-                self._pixel_scale.xstep),
-            yoff=round_down_pixels((self._underlying_area.top - target_area.top) / (self._pixel_scale.ystep * -1.0),
-                self._pixel_scale.ystep * -1.0),
+            xoff=round_down_pixels((target_area.left - self._underlying_area.left) / self._projection.xstep,
+                self._projection.xstep),
+            yoff=round_down_pixels((self._underlying_area.top - target_area.top) / (self._projection.ystep * -1.0),
+                self._projection.ystep * -1.0),
             xsize=round_up_pixels(
-                (target_area.right - target_area.left) / self._pixel_scale.xstep,
-                self._pixel_scale.xstep
+                (target_area.right - target_area.left) / self._projection.xstep,
+                self._projection.xstep
             ),
             ysize=round_up_pixels(
-                (target_area.top - target_area.bottom) / (self._pixel_scale.ystep * -1.0),
-                (self._pixel_scale.ystep * -1.0)
+                (target_area.top - target_area.bottom) / (self._projection.ystep * -1.0),
+                (self._projection.ystep * -1.0)
             ),
         )
         return self._read_array_with_window(x, y, width, height, target_window)
 
+    def _read_array(self, x: int, y: int, width: int, height: int) -> Any:
+        return self._read_array_with_window(x, y, width, height, self.window)
+
     def read_array(self, x: int, y: int, width: int, height: int) -> Any:
         """Reads data from the layer based on the current reference window.
 
@@ -286,29 +333,24 @@ class YirgacheffeLayer(LayerMathMixin):
         Any
             An array of values from the layer.
         """
-        return self._read_array_with_window(x, y, width, height, self.window)
+        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 "WGS 84" not in self.projection:
+        if self._projection is None or "WGS 84" not in self._projection.name:
             raise NotImplementedError("Not yet supported for other projections")
-        pixel_scale = self.pixel_scale
-        if pixel_scale is None:
-            raise ValueError("Layer has no pixel scale")
         return (
-            (y_coord * pixel_scale.ystep) + self.area.top,
-            (x_coord * pixel_scale.xstep) + self.area.left
+            (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 "WGS 84" not in self.projection:
+        if self._projection is None or "WGS 84" not in self._projection.name:
             raise NotImplementedError("Not yet supported for other projections")
-        pixel_scale = self.pixel_scale
-        if pixel_scale is None:
-            raise ValueError("Layer has no pixel scale")
         return (
-            round_down_pixels((lng - self.area.left) / pixel_scale.xstep, abs(pixel_scale.xstep)),
-            round_down_pixels((lat - self.area.top) / pixel_scale.ystep, abs(pixel_scale.ystep)),
+            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/layers/constant.py

@@ -1,10 +1,9 @@
 from typing import Any, Union
 
 from ..operators import DataType
-from ..window import Area, PixelScale, Window
+from ..window import Area, MapProjection, PixelScale, Window
 from .base import YirgacheffeLayer
 from .._backends import backend
-from ..constants import WGS_84_PROJECTION
 
 
 class ConstantLayer(YirgacheffeLayer):
@@ -12,7 +11,7 @@ class ConstantLayer(YirgacheffeLayer):
     missing (e.g., area) without having the calculation full of branches."""
     def __init__(self, value: Union[int,float]): # pylint: disable=W0231
         area = Area.world()
-        super().__init__(area, None, WGS_84_PROJECTION)
+        super().__init__(area, None)
         self.value = float(value)
 
     @property
@@ -41,6 +40,7 @@ class ConstantLayer(YirgacheffeLayer):
     def _read_array_for_area(
         self,
         _target_area: Area,
+        _target_projection: MapProjection,
         x: int,
         y: int,
         width: int,

yirgacheffe/layers/group.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 import copy
 from pathlib import Path
-from typing import Any, List, Optional, Union
+from typing import Any, List, Optional, Sequence, Union
 
 import numpy as np
 from numpy import ma
 
 from ..operators import DataType
-from ..rounding import are_pixel_scales_equal_enough, round_down_pixels
+from ..rounding import round_down_pixels
 from ..window import Area, Window
 from .base import YirgacheffeLayer
 from .rasters import RasterLayer
@@ -39,14 +39,14 @@ class GroupLayer(YirgacheffeLayer):
     @classmethod
     def layer_from_files(
         cls,
-        filenames: Union[List[Path],List[str]],
+        filenames: Sequence[Union[Path,str]],
         name: Optional[str] = None
     ) -> GroupLayer:
         if filenames is None:
             raise ValueError("filenames argument is None")
-        if len(filenames) < 1:
-            raise GroupLayerEmpty("No files found")
         rasters: List[YirgacheffeLayer] = [RasterLayer.layer_from_file(x) for x in filenames]
+        if len(rasters) < 1:
+            raise GroupLayerEmpty("No files found")
         return cls(rasters, name)
 
     def __init__(
@@ -56,17 +56,15 @@ class GroupLayer(YirgacheffeLayer):
     ) -> None:
         if not layers:
             raise GroupLayerEmpty("Expected one or more layers")
-        if not are_pixel_scales_equal_enough([x.pixel_scale for x in layers]):
-            raise ValueError("Not all layers are at the same pixel scale")
-        if not all(x.projection == layers[0].projection for x in layers):
-            raise ValueError("Not all layers are the same projection")
+        if not all(x.map_projection == layers[0].map_projection for x in layers):
+            raise ValueError("Not all layers are the same projection/scale")
         for layer in layers:
-            if layer._active_area != layer._underlying_area:
+            if layer._active_area is not None:
                 raise ValueError("Layers can not currently be constrained")
 
         # area/window are superset of all tiles
         union = YirgacheffeLayer.find_union(layers)
-        super().__init__(union, layers[0].pixel_scale, layers[0].projection, name=name)
+        super().__init__(union, layers[0].map_projection, name=name)
 
         # We store them in reverse order so that from the user's perspective
         # the first layer in the list will be the most important in terms
@@ -146,7 +144,7 @@ class GroupLayer(YirgacheffeLayer):
         if len(contributing_layers) == 1:
             layer, adjusted_layer_window, intersection = contributing_layers[0]
             if target_window == intersection:
-                data = layer.read_array(
+                data = layer._read_array(
                     intersection.xoff - adjusted_layer_window.xoff,
                     intersection.yoff - adjusted_layer_window.yoff,
                     intersection.xsize,
@@ -158,11 +156,11 @@ class GroupLayer(YirgacheffeLayer):
 
         result = np.zeros((ysize, xsize), dtype=float)
         for layer, adjusted_layer_window, intersection in contributing_layers:
-            data = layer.read_array(
+            data = layer._read_array(
                 intersection.xoff - adjusted_layer_window.xoff,
                 intersection.yoff - adjusted_layer_window.yoff,
                 intersection.xsize,
-                intersection.ysize,
+                intersection.ysize
             )
             result_x_offset = (intersection.xoff - xoffset) - window.xoff
             result_y_offset = (intersection.yoff - yoffset) - window.yoff
@@ -271,7 +269,7 @@ class TiledGroupLayer(GroupLayer):
             intersection = Window.find_intersection_no_throw([target_window, adjusted_layer_window])
             if intersection is None:
                 continue
-            data = layer.read_array(
+            data = layer._read_array(
                 intersection.xoff - adjusted_layer_window.xoff,
                 intersection.yoff - adjusted_layer_window.yoff,
                 intersection.xsize,

yirgacheffe/layers/h3layer.py

@@ -6,13 +6,13 @@ import numpy as np
 from yirgacheffe.operators import DataType
 
 from ..rounding import round_up_pixels
-from ..window import Area, PixelScale, Window
+from ..window import Area, MapProjection, Window
 from .base import YirgacheffeLayer
 from .._backends import backend
 
 class H3CellLayer(YirgacheffeLayer):
 
-    def __init__(self, cell_id: str, scale: PixelScale, projection: str):
+    def __init__(self, cell_id: str, projection: MapProjection):
         if not h3.is_valid_cell(cell_id):
             raise ValueError(f"{cell_id} is not a valid H3 cell identifier")
         self.cell_id = cell_id
@@ -20,7 +20,7 @@ class H3CellLayer(YirgacheffeLayer):
 
         self.cell_boundary = h3.cell_to_boundary(cell_id)
 
-        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[1] for x in self.cell_boundary) / abs_xstep) * abs_xstep),
             top=(ceil(max(x[0] for x in self.cell_boundary) / abs_ystep) * abs_ystep),
@@ -56,12 +56,12 @@ class H3CellLayer(YirgacheffeLayer):
                 bottom=area.bottom,
             )
 
-        super().__init__(area, scale, projection)
+        super().__init__(area, projection)
         self._window = Window(
             xoff=0,
             yoff=0,
-            xsize=round_up_pixels((area.right - area.left) / scale.xstep, abs_xstep),
-            ysize=round_up_pixels((area.bottom - area.top) / scale.ystep, abs_ystep),
+            xsize=round_up_pixels((area.right - area.left) / projection.xstep, abs_xstep),
+            ysize=round_up_pixels((area.bottom - area.top) / projection.ystep, abs_ystep),
         )
         self._raster_xsize = self.window.xsize
         self._raster_ysize = self.window.ysize
@@ -90,7 +90,7 @@ class H3CellLayer(YirgacheffeLayer):
         ysize: int,
         window: Window,
     ) -> Any:
-        assert self._pixel_scale is not None
+        assert self._projection is not None
 
         if (xsize <= 0) or (ysize <= 0):
             raise ValueError("Request dimensions must be positive and non-zero")
@@ -119,8 +119,8 @@ class H3CellLayer(YirgacheffeLayer):
 
             subset = np.zeros((intersection.ysize, intersection.xsize))
 
-            start_x = self._active_area.left + ((intersection.xoff - self.window.xoff) * self._pixel_scale.xstep)
-            start_y = self._active_area.top + ((intersection.yoff - self.window.yoff) * self._pixel_scale.ystep)
+            start_x = self.area.left + ((intersection.xoff - self.window.xoff) * self._projection.xstep)
+            start_y = self.area.top + ((intersection.yoff - self.window.yoff) * self._projection.ystep)
 
             for ypixel in range(intersection.ysize):
                 # The latlng_to_cell is quite expensive, so ideally we want to avoid
@@ -144,7 +144,7 @@ class H3CellLayer(YirgacheffeLayer):
                 # only a tiny number of cells that have convex edges, so in future it'd be
                 # interesting to see if we can infer when that is.
 
-                lat = start_y + (ypixel * self._pixel_scale.ystep)
+                lat = start_y + (ypixel * self._projection.ystep)
 
                 if self._raster_safe_bounds[0] < lat < self._raster_safe_bounds[1]:
                     # In "safe" zone, try to be clever
@@ -152,14 +152,14 @@ class H3CellLayer(YirgacheffeLayer):
                     right_most = -1
 
                     for xpixel in range(intersection.xsize):
-                        lng = start_x + (xpixel * self._pixel_scale.xstep)
+                        lng = start_x + (xpixel * self._projection.xstep)
                         this_cell = h3.latlng_to_cell(lat, lng, self.zoom)
                         if this_cell == self.cell_id:
                             left_most = xpixel
                             break
 
                     for xpixel in range(intersection.xsize - 1, left_most - 1, -1):
-                        lng = start_x + (xpixel * self._pixel_scale.xstep)
+                        lng = start_x + (xpixel * self._projection.xstep)
                         this_cell = h3.latlng_to_cell(lat, lng, self.zoom)
                         if this_cell == self.cell_id:
                             right_most = xpixel
@@ -170,7 +170,7 @@ class H3CellLayer(YirgacheffeLayer):
                 else:
                     # Not in safe zone, be diligent.
                     for xpixel in range(intersection.xsize):
-                        lng = start_x + (xpixel * self._pixel_scale.xstep)
+                        lng = start_x + (xpixel * self._projection.xstep)
                         this_cell = h3.latlng_to_cell(lat, lng, self.zoom)
                         if this_cell == self.cell_id:
                             subset[ypixel][xpixel] = 1.0
@@ -196,19 +196,19 @@ class H3CellLayer(YirgacheffeLayer):
             left = min(x[1] for x in self.cell_boundary if x[1] > 0.0)
             right = max(x[1] for x in self.cell_boundary if x[1] < 0.0) + 360.0
             max_width_projection = right - left
-            max_width = ceil(max_width_projection / self._pixel_scale.xstep)
+            max_width = ceil(max_width_projection / self._projection.xstep)
 
             for ypixel in range(yoffset, yoffset + ysize):
-                lat = self._active_area.top + (ypixel * self._pixel_scale.ystep)
+                lat = self.area.top + (ypixel * self._projection.ystep)
 
                 for xpixel in range(xoffset, min(xoffset + xsize, max_width)):
-                    lng = self._active_area.left + (xpixel * self._pixel_scale.xstep)
+                    lng = self.area.left + (xpixel * self._projection.xstep)
                     this_cell = h3.latlng_to_cell(lat, lng, self.zoom)
                     if this_cell == self.cell_id:
                         res[ypixel - yoffset][xpixel - xoffset] = 1.0
 
                 for xpixel in range(xoffset + xsize - 1, xoffset + xsize - max_width, -1):
-                    lng = self._active_area.left + (xpixel * self._pixel_scale.xstep)
+                    lng = self.area.left + (xpixel * self._projection.xstep)
                     this_cell = h3.latlng_to_cell(lat, lng, self.zoom)
                     if this_cell == self.cell_id:
                         res[ypixel - yoffset][xpixel - xoffset] = 1.0