rastr 0.3.0__tar.gz → 0.4.0__tar.gz

{rastr-0.3.0 → rastr-0.4.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: rastr
-Version: 0.3.0
+Version: 0.4.0
 Summary: Geospatial Raster datatype library for Python.
 Project-URL: Source Code, https://github.com/tonkintaylor/rastr
 Project-URL: Bug Tracker, https://github.com/tonkintaylor/rastr/issues
 Project-URL: Releases, https://github.com/tonkintaylor/rastr/releases
-Project-URL: Source Archive, https://github.com/tonkintaylor/rastr/archive/46f802e7abd275eff61c73c5edc147d92966c886.zip
+Project-URL: Source Archive, https://github.com/tonkintaylor/rastr/archive/336916af169603534dd0728c10401667f263d98a.zip
 Author-email: Tonkin & Taylor Limited <Sub-DisciplineData+AnalyticsStaff@tonkintaylor.co.nz>, Nathan McDougall <nmcdougall@tonkintaylor.co.nz>, Ben Karl <bkarl@tonkintaylor.co.nz>
 License-Expression: MIT
 License-File: LICENSE

{rastr-0.3.0 → rastr-0.4.0}/src/rastr/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.0'
-__version_tuple__ = version_tuple = (0, 3, 0)
+__version__ = version = '0.4.0'
+__version_tuple__ = version_tuple = (0, 4, 0)
 
 __commit_id__ = commit_id = None

{rastr-0.3.0 → rastr-0.4.0}/src/rastr/raster.py

@@ -6,7 +6,7 @@ import importlib.util
 import warnings
 from contextlib import contextmanager
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal
+from typing import TYPE_CHECKING, Any, Literal, overload
 
 import numpy as np
 import numpy.ma
@@ -65,6 +65,21 @@ class RasterModel(BaseModel):
     def meta(self, value: RasterMeta) -> None:
         self.raster_meta = value
 
+    @property
+    def shape(self) -> tuple[int, ...]:
+        """Shape of the raster array."""
+        return self.arr.shape
+
+    @property
+    def crs(self) -> CRS:
+        """Convenience property to access the CRS via meta."""
+        return self.meta.crs
+
+    @crs.setter
+    def crs(self, value: CRS) -> None:
+        """Set the CRS via meta."""
+        self.meta.crs = value
+
     def __init__(
         self,
         *,
@@ -193,12 +208,12 @@ class RasterModel(BaseModel):
     @property
     def cell_x_coords(self) -> NDArray[np.float64]:
         """Get the x coordinates of the cell centres in the raster."""
-        return self.raster_meta.get_cell_x_coords(self.arr.shape[0])
+        return self.raster_meta.get_cell_x_coords(self.arr.shape[1])
 
     @property
     def cell_y_coords(self) -> NDArray[np.float64]:
         """Get the y coordinates of the cell centres in the raster."""
-        return self.raster_meta.get_cell_y_coords(self.arr.shape[1])
+        return self.raster_meta.get_cell_y_coords(self.arr.shape[0])
 
     @contextmanager
     def to_rasterio_dataset(
@@ -573,6 +588,43 @@ class RasterModel(BaseModel):
         raster_meta = RasterMeta.example()
         return cls(arr=arr, raster_meta=raster_meta)
 
+    @overload
+    def apply(
+        self,
+        func: Callable[[np.ndarray], np.ndarray],
+        *,
+        raw: Literal[True],
+    ) -> Self: ...
+    @overload
+    def apply(
+        self,
+        func: Callable[[float], float] | Callable[[np.ndarray], np.ndarray],
+        *,
+        raw: Literal[False] = False,
+    ) -> Self: ...
+    def apply(self, func, *, raw=False) -> Self:
+        """Apply a function element-wise to the raster array.
+
+        Creates a new raster instance with the same metadata (CRS, transform, etc.)
+        but with the data array transformed by the provided function. The original
+        raster is not modified.
+
+        Args:
+            func: The function to apply to the raster array. If `raw` is True, this
+                  function should accept and return a NumPy array. If `raw` is False,
+                  this function should accept and return a single float value.
+            raw: If True, the function is applied directly to the entire array at
+                 once. If False, the function is applied element-wise to each cell
+                 in the array using `np.vectorize()`. Default is False.
+        """
+        new_raster = self.model_copy()
+        if raw:
+            new_arr = func(self.arr)
+        else:
+            new_arr = np.vectorize(func)(self.arr)
+        new_raster.arr = np.asarray(new_arr)
+        return new_raster
+
     def fillna(self, value: float) -> Self:
         """Fill NaN values in the raster with a specified value.
 
@@ -599,12 +651,14 @@ class RasterModel(BaseModel):
         return coords[:, :, 0], coords[:, :, 1]
 
     def contour(
-        self, *, levels: list[float] | NDArray, smoothing: bool = True
+        self, levels: list[float] | NDArray, *, smoothing: bool = True
     ) -> gpd.GeoDataFrame:
         """Create contour lines from the raster data, optionally with smoothing.
 
-        The contour lines are returned as a GeoDataFrame with the contours as linestring
-        geometries and the contour levels as attributes in a column named 'level'.
+        The contour lines are returned as a GeoDataFrame with the contours dissolved
+        by level, resulting in one row per contour level. Each row contains a
+        (Multi)LineString geometry representing all contour lines for that level,
+        and the contour level value in a column named 'level'.
 
         Consider calling `blur()` before this method to smooth the raster data before
         contouring, to denoise the contours.
@@ -627,7 +681,7 @@ class RasterModel(BaseModel):
                 level=level,
             )
 
-            # Constructg shapely LineString objects
+            # Construct shapely LineString objects
             # Convert to CRS from array index coordinates to raster CRS
             geoms = [
                 LineString(
@@ -656,7 +710,8 @@ class RasterModel(BaseModel):
             crs=self.raster_meta.crs,
         )
 
-        return contour_gdf
+        # Dissolve contours by level to merge all contour lines of the same level
+        return contour_gdf.dissolve(by="level", as_index=False)
 
     def blur(self, sigma: float) -> Self:
         """Apply a Gaussian blur to the raster data.
@@ -701,7 +756,7 @@ class RasterModel(BaseModel):
         bounds: tuple[float, float, float, float],
         strategy: Literal["underflow", "overflow"] = "underflow",
     ) -> Self:
-        """Crop the raster to the specified bounds.
+        """Crop the raster to the specified bounds as (minx, miny, maxx, maxy).
 
         Args:
             bounds: A tuple of (minx, miny, maxx, maxy) defining the bounds to crop to.
@@ -746,7 +801,7 @@ class RasterModel(BaseModel):
             raise NotImplementedError(msg)
 
         # Crop the array
-        cropped_arr = arr[np.ix_(x_idx, y_idx)]
+        cropped_arr = arr[np.ix_(y_idx, x_idx)]
 
         # Check the shape of the cropped array
         if cropped_arr.size == 0:

{rastr-0.3.0 → rastr-0.4.0}/tests/rastr/test_raster.py

@@ -12,7 +12,7 @@ from affine import Affine
 from branca.colormap import LinearColormap
 from pydantic import ValidationError
 from pyproj.crs.crs import CRS
-from shapely.geometry import Point, Polygon
+from shapely.geometry import LineString, MultiLineString, Point, Polygon
 
 from rastr.meta import RasterMeta
 from rastr.raster import RasterModel
@@ -116,6 +116,43 @@ class TestRasterModel:
             assert example_raster.meta is new_meta
             assert example_raster.raster_meta != original_meta
 
+    class TestShape:
+        def test_shape_property(self, example_raster: RasterModel):
+            # Act
+            shape = example_raster.shape
+
+            # Assert
+            assert shape == (2, 2)
+            assert shape == example_raster.arr.shape
+
+    class TestCRS:
+        def test_crs_getter(self, example_raster: RasterModel):
+            # Act
+            crs_via_property = example_raster.crs
+            crs_via_meta = example_raster.meta.crs
+            crs_via_raster_meta = example_raster.raster_meta.crs
+
+            # Assert
+            assert crs_via_property is crs_via_meta
+            assert crs_via_property is crs_via_raster_meta
+            assert crs_via_property == crs_via_meta
+            assert crs_via_property == crs_via_raster_meta
+            assert isinstance(crs_via_property, CRS)
+
+        def test_crs_setter(self, example_raster: RasterModel):
+            # Arrange
+            new_crs = CRS.from_epsg(4326)
+            original_crs = example_raster.crs
+
+            # Act
+            example_raster.crs = new_crs
+
+            # Assert
+            assert example_raster.crs is new_crs
+            assert example_raster.meta.crs is new_crs
+            assert example_raster.raster_meta.crs is new_crs
+            assert example_raster.crs != original_crs
+
     class TestSample:
         def test_sample_nan_raise(self, example_raster: RasterModel):
             with pytest.raises(
@@ -600,6 +637,14 @@ class TestRasterModel:
             # Assert
             np.testing.assert_array_equal(result.arr, np.array([[0, -1], [-2, -3]]))
 
+    class TestApply:
+        def test_sine(self, example_raster: RasterModel):
+            # Act
+            result = example_raster.apply(np.sin)
+
+            # Assert
+            np.testing.assert_array_equal(result.arr, np.sin(example_raster.arr))
+
     class TestToFile:
         def test_saving_gtiff(self, tmp_path: Path, example_raster: RasterModel):
             # Arrange
@@ -818,6 +863,61 @@ class TestRasterModel:
             assert len(contour_gdf_list) == len(contour_gdf_array)
             assert list(contour_gdf_list["level"]) == list(contour_gdf_array["level"])
 
+        def test_contour_positional_levels(self):
+            # Arrange
+            raster = RasterModel.example()
+            levels = [0.0, 0.5]
+
+            # Act - should pass without error when using positional levels arg
+            contour_gdf = raster.contour(levels)  # noqa: F841
+
+        def test_contour_returns_gdf_with_correct_columns(self):
+            raster = RasterModel.example()
+            gdf = raster.contour(levels=[0.0, 0.5])
+
+            assert isinstance(gdf, gpd.GeoDataFrame)
+            assert list(gdf.columns) == ["level", "geometry"]
+            assert "level" in gdf.columns
+            assert "geometry" in gdf.columns
+
+        def test_contour_levels_in_result(self):
+            raster = RasterModel.example()
+            levels = [0.0, 0.5]
+            gdf = raster.contour(levels=levels)
+
+            result_levels = set(gdf["level"].unique())
+            expected_levels = set(levels)
+            assert result_levels == expected_levels
+
+        def test_contour_dissolve_behavior_one_row_per_level(self):
+            raster = RasterModel.example()
+            levels = [0.0, 0.5]
+            gdf = raster.contour(levels=levels)
+
+            # After dissolving, should have exactly one row per level
+            assert len(gdf) == len(levels)
+            assert set(gdf["level"]) == set(levels)
+
+            # Geometries should be MultiLineString (dissolved from multiple LineStrings)
+            for geom in gdf.geometry:
+                assert isinstance(
+                    geom, (MultiLineString, LineString)
+                )  # Can be either depending on dissolve result
+
+        def test_contour_with_smoothing(self):
+            raster = RasterModel.example()
+            gdf = raster.contour(levels=[0.0], smoothing=True)
+
+            assert len(gdf) > 0
+            assert all(gdf["level"] == 0.0)
+
+        def test_contour_without_smoothing(self):
+            raster = RasterModel.example()
+            gdf = raster.contour(levels=[0.0], smoothing=False)
+
+            assert len(gdf) > 0
+            assert all(gdf["level"] == 0.0)
+
 
 @pytest.fixture
 def base_raster():
@@ -868,13 +968,13 @@ class TestCrop:
         minx, miny, maxx, maxy = base_raster.bounds
         cell_size = base_raster.raster_meta.cell_size
         bounds = (minx, miny + cell_size, maxx, maxy - cell_size)
-        expected_transform = Affine(20.0, 0.0, 0.0, 0.0, -5.0, 100.0 - cell_size)
+        expected_transform = Affine(10.0, 0.0, 0.0, 0.0, -10.0, 100.0 - cell_size)
 
         # Act
         cropped = base_raster.crop(bounds)
 
         # Assert
-        assert cropped.arr.shape == (4, 2)
+        assert cropped.arr.shape == (2, 4)  # Y-crop reduces rows, keeps columns
         assert cropped.bounds == bounds
         assert cropped.raster_meta.cell_size == base_raster.raster_meta.cell_size
         assert cropped.raster_meta.crs == base_raster.raster_meta.crs
@@ -885,13 +985,13 @@ class TestCrop:
         minx, miny, maxx, maxy = base_raster.bounds
         cell_size = base_raster.raster_meta.cell_size
         bounds = (minx + cell_size, miny, maxx - cell_size, maxy)
-        expected_transform = Affine(5.0, 0.0, minx + cell_size, 0.0, -20.0, 100.0)
+        expected_transform = Affine(10.0, 0.0, minx + cell_size, 0.0, -10.0, 100.0)
 
         # Act
         cropped = base_raster.crop(bounds)
 
         # Assert
-        assert cropped.arr.shape == (2, 4)
+        assert cropped.arr.shape == (4, 2)  # X-crop reduces columns, keeps rows
         assert cropped.bounds == bounds
         assert cropped.raster_meta.cell_size == base_raster.raster_meta.cell_size
         assert cropped.raster_meta.crs == base_raster.raster_meta.crs
@@ -980,6 +1080,46 @@ class TestCrop:
         ):
             base_raster.crop(bounds)
 
+    def test_crop_non_square_raster_indexing(self):
+        """Test that crop method correctly indexes non-square rasters.
+
+        This tests the fix for issue #140 where array indexing was backwards,
+        causing spatial misalignment in cropped rasters.
+        """
+        # Arrange: Create a non-square raster with distinctive values
+        meta = RasterMeta(
+            cell_size=1.0,
+            crs=CRS.from_epsg(2193),
+            transform=Affine(1.0, 0.0, 0.0, 0.0, -1.0, 3.0),
+        )
+        arr = np.array(
+            [
+                [1, 2, 3, 4, 5],  # row 0
+                [6, 7, 8, 9, 10],  # row 1
+                [11, 12, 13, 14, 15],  # row 2
+            ],
+            dtype=float,
+        )
+        raster = RasterModel(arr=arr, raster_meta=meta)
+
+        # Act: Crop to select middle 3 columns (keeping all rows)
+        bounds = (1.0, 0.0, 4.0, 3.0)  # Should select columns at x=1.5, 2.5, 3.5
+        cropped = raster.crop(bounds)
+
+        # Assert: Result should have all 3 rows but only 3 columns
+        expected_shape = (3, 3)
+        expected_array = np.array(
+            [
+                [2, 3, 4],  # row 0, columns 1,2,3 (0-indexed)
+                [7, 8, 9],  # row 1, columns 1,2,3
+                [12, 13, 14],  # row 2, columns 1,2,3
+            ],
+            dtype=float,
+        )
+
+        assert cropped.arr.shape == expected_shape
+        np.testing.assert_array_equal(cropped.arr, expected_array)
+
     def test_unsupported_crop_strategy(self, base_raster: RasterModel):
         # Arrange
         bounds = base_raster.bounds