rslearn 0.0.26__py3-none-any.whl → 0.0.27__py3-none-any.whl

rslearn/train/dataset.py

@@ -8,6 +8,7 @@ import random
 import tempfile
 import time
 import uuid
+import warnings
 from datetime import datetime
 from enum import StrEnum
 from typing import Any
@@ -456,11 +457,15 @@ class SplitConfig:
         num_patches: int | None = None,
         transforms: list[torch.nn.Module] | None = None,
         sampler: SamplerFactory | None = None,
+        crop_size: int | tuple[int, int] | None = None,
+        overlap_pixels: int | None = None,
+        load_all_crops: bool | None = None,
+        skip_targets: bool | None = None,
+        output_layer_name_skip_inference_if_exists: str | None = None,
+        # Deprecated parameters (for backwards compatibility)
         patch_size: int | tuple[int, int] | None = None,
         overlap_ratio: float | None = None,
         load_all_patches: bool | None = None,
-        skip_targets: bool | None = None,
-        output_layer_name_skip_inference_if_exists: str | None = None,
     ) -> None:
         """Initialize a new SplitConfig.
 
@@ -475,19 +480,69 @@ class SplitConfig:
             num_patches: limit this split to this many patches
             transforms: transforms to apply
             sampler: SamplerFactory for this split
-            patch_size: an optional square size or (width, height) tuple. If set, read
+            crop_size: an optional square size or (width, height) tuple. If set, read
                 crops of this size rather than entire windows.
-            overlap_ratio: an optional float between 0 and 1. If set, read patches with
-                this ratio of overlap.
-            load_all_patches: with patch_size set, rather than sampling a random patch
-                for each window, read all patches as separate sequential items in the
+            overlap_pixels: the number of pixels shared between adjacent crops during
+                sliding window inference.
+            load_all_crops: with crop_size set, rather than sampling a random crop
+                for each window, read all crops as separate sequential items in the
                 dataset.
             skip_targets: whether to skip targets when loading inputs
             output_layer_name_skip_inference_if_exists: optional name of the output layer used during prediction.
                 If set, windows that already
                 have this layer completed will be skipped (useful for resuming
                 partial inference runs).
+            patch_size: deprecated, use crop_size instead
+            overlap_ratio: deprecated, use overlap_pixels instead
+            load_all_patches: deprecated, use load_all_crops instead
         """
+        # Handle deprecated load_all_patches parameter
+        if load_all_patches is not None:
+            warnings.warn(
+                "load_all_patches is deprecated, use load_all_crops instead",
+                FutureWarning,
+                stacklevel=2,
+            )
+            if load_all_crops is not None:
+                raise ValueError(
+                    "Cannot specify both load_all_patches and load_all_crops"
+                )
+            load_all_crops = load_all_patches
+        # Handle deprecated patch_size parameter
+        if patch_size is not None:
+            warnings.warn(
+                "patch_size is deprecated, use crop_size instead",
+                FutureWarning,
+                stacklevel=2,
+            )
+            if crop_size is not None:
+                raise ValueError("Cannot specify both patch_size and crop_size")
+            crop_size = patch_size
+
+        # Normalize crop_size to tuple[int, int] | None
+        self.crop_size: tuple[int, int] | None = None
+        if crop_size is not None:
+            if isinstance(crop_size, int):
+                self.crop_size = (crop_size, crop_size)
+            else:
+                self.crop_size = crop_size
+
+        # Handle deprecated overlap_ratio parameter
+        if overlap_ratio is not None:
+            warnings.warn(
+                "overlap_ratio is deprecated, use overlap_pixels instead",
+                FutureWarning,
+                stacklevel=2,
+            )
+            if overlap_pixels is not None:
+                raise ValueError("Cannot specify both overlap_ratio and overlap_pixels")
+            if self.crop_size is None:
+                raise ValueError("overlap_ratio requires crop_size to be set")
+            overlap_pixels = round(self.crop_size[0] * overlap_ratio)
+
+        if overlap_pixels is not None and overlap_pixels < 0:
+            raise ValueError("overlap_pixels must be non-negative")
+
         self.groups = groups
         self.names = names
         self.tags = tags
@@ -495,19 +550,15 @@ class SplitConfig:
         self.num_patches = num_patches
         self.transforms = transforms
         self.sampler = sampler
-        self.patch_size = patch_size
         self.skip_targets = skip_targets
         self.output_layer_name_skip_inference_if_exists = (
             output_layer_name_skip_inference_if_exists
         )
 
-        # Note that load_all_patches are handled by the RslearnDataModule rather than
-        # the ModelDataset.
-        self.load_all_patches = load_all_patches
-        self.overlap_ratio = overlap_ratio
-
-        if self.overlap_ratio is not None and not (0 < self.overlap_ratio < 1):
-            raise ValueError("overlap_ratio must be between 0 and 1 (exclusive)")
+        # Note that load_all_crops is handled by the RslearnDataModule rather than the
+        # ModelDataset.
+        self.load_all_crops = load_all_crops
+        self.overlap_pixels = overlap_pixels
 
     def update(self, other: "SplitConfig") -> "SplitConfig":
         """Override settings in this SplitConfig with those in another.
@@ -523,9 +574,9 @@ class SplitConfig:
             num_patches=self.num_patches,
             transforms=self.transforms,
             sampler=self.sampler,
-            patch_size=self.patch_size,
-            overlap_ratio=self.overlap_ratio,
-            load_all_patches=self.load_all_patches,
+            crop_size=self.crop_size,
+            overlap_pixels=self.overlap_pixels,
+            load_all_crops=self.load_all_crops,
             skip_targets=self.skip_targets,
             output_layer_name_skip_inference_if_exists=self.output_layer_name_skip_inference_if_exists,
         )
@@ -543,12 +594,12 @@ class SplitConfig:
             result.transforms = other.transforms
         if other.sampler:
             result.sampler = other.sampler
-        if other.patch_size:
-            result.patch_size = other.patch_size
-        if other.overlap_ratio is not None:
-            result.overlap_ratio = other.overlap_ratio
-        if other.load_all_patches is not None:
-            result.load_all_patches = other.load_all_patches
+        if other.crop_size:
+            result.crop_size = other.crop_size
+        if other.overlap_pixels is not None:
+            result.overlap_pixels = other.overlap_pixels
+        if other.load_all_crops is not None:
+            result.load_all_crops = other.load_all_crops
         if other.skip_targets is not None:
             result.skip_targets = other.skip_targets
         if other.output_layer_name_skip_inference_if_exists is not None:
@@ -557,21 +608,17 @@ class SplitConfig:
             )
         return result
 
-    def get_patch_size(self) -> tuple[int, int] | None:
-        """Get patch size normalized to int tuple."""
-        if self.patch_size is None:
-            return None
-        if isinstance(self.patch_size, int):
-            return (self.patch_size, self.patch_size)
-        return self.patch_size
+    def get_crop_size(self) -> tuple[int, int] | None:
+        """Get crop size as tuple."""
+        return self.crop_size
 
-    def get_overlap_ratio(self) -> float:
-        """Get the overlap ratio (default 0)."""
-        return self.overlap_ratio if self.overlap_ratio is not None else 0.0
+    def get_overlap_pixels(self) -> int:
+        """Get the overlap pixels (default 0)."""
+        return self.overlap_pixels if self.overlap_pixels is not None else 0
 
-    def get_load_all_patches(self) -> bool:
+    def get_load_all_crops(self) -> bool:
         """Returns whether loading all patches is enabled (default False)."""
-        return True if self.load_all_patches is True else False
+        return True if self.load_all_crops is True else False
 
     def get_skip_targets(self) -> bool:
         """Returns whether skip_targets is enabled (default False)."""
@@ -677,13 +724,13 @@ class ModelDataset(torch.utils.data.Dataset):
         else:
             self.transforms = rslearn.train.transforms.transform.Identity()
 
-        # Get normalized patch size from the SplitConfig.
-        # But if load all patches is enabled, this is handled by AllPatchesDataset, so
+        # Get normalized crop size from the SplitConfig.
+        # But if load all patches is enabled, this is handled by AllCropsDataset, so
         # here we instead load the entire windows.
-        if split_config.get_load_all_patches():
-            self.patch_size = None
+        if split_config.get_load_all_crops():
+            self.crop_size = None
         else:
-            self.patch_size = split_config.get_patch_size()
+            self.crop_size = split_config.get_crop_size()
 
         # If targets are not needed, remove them from the inputs.
         if split_config.get_skip_targets():
@@ -904,8 +951,8 @@ class ModelDataset(torch.utils.data.Dataset):
     def get_dataset_examples(self) -> list[Window]:
         """Get a list of examples in the dataset.
 
-        If load_all_patches is False, this is a list of Windows. Otherwise, this is a
-        list of (window, patch_bounds, (patch_idx, # patches)) tuples.
+        If load_all_crops is False, this is a list of Windows. Otherwise, this is a
+        list of (window, crop_bounds, (crop_idx, # patches)) tuples.
         """
         if self.dataset_examples is None:
             logger.debug(
@@ -941,34 +988,34 @@ class ModelDataset(torch.utils.data.Dataset):
         rng = random.Random(idx if self.fix_patch_pick else None)
 
         # Select bounds to read.
-        if self.patch_size:
+        if self.crop_size:
             window = example
 
-            def get_patch_range(n_patch: int, n_window: int) -> list[int]:
-                if n_patch > n_window:
+            def get_crop_range(n_crop: int, n_window: int) -> list[int]:
+                if n_crop > n_window:
                     # Select arbitrary range containing the entire window.
-                    # Basically arbitrarily padding the window to get to patch size.
-                    start = rng.randint(n_window - n_patch, 0)
-                    return [start, start + n_patch]
+                    # Basically arbitrarily padding the window to get to crop size.
+                    start = rng.randint(n_window - n_crop, 0)
+                    return [start, start + n_crop]
 
                 else:
-                    # Select arbitrary patch within the window.
-                    start = rng.randint(0, n_window - n_patch)
-                    return [start, start + n_patch]
+                    # Select arbitrary crop within the window.
+                    start = rng.randint(0, n_window - n_crop)
+                    return [start, start + n_crop]
 
             window_size = (
                 window.bounds[2] - window.bounds[0],
                 window.bounds[3] - window.bounds[1],
             )
-            patch_ranges = [
-                get_patch_range(self.patch_size[0], window_size[0]),
-                get_patch_range(self.patch_size[1], window_size[1]),
+            crop_ranges = [
+                get_crop_range(self.crop_size[0], window_size[0]),
+                get_crop_range(self.crop_size[1], window_size[1]),
             ]
             bounds = (
-                window.bounds[0] + patch_ranges[0][0],
-                window.bounds[1] + patch_ranges[1][0],
-                window.bounds[0] + patch_ranges[0][1],
-                window.bounds[1] + patch_ranges[1][1],
+                window.bounds[0] + crop_ranges[0][0],
+                window.bounds[1] + crop_ranges[1][0],
+                window.bounds[0] + crop_ranges[0][1],
+                window.bounds[1] + crop_ranges[1][1],
             )
 
         else:
@@ -990,9 +1037,9 @@ class ModelDataset(torch.utils.data.Dataset):
             window_group=window.group,
             window_name=window.name,
             window_bounds=window.bounds,
-            patch_bounds=bounds,
-            patch_idx=0,
-            num_patches_in_window=1,
+            crop_bounds=bounds,
+            crop_idx=0,
+            num_crops_in_window=1,
             time_range=window.time_range,
             projection=window.projection,
             dataset_source=self.name,

rslearn/train/lightning_module.py

@@ -365,7 +365,7 @@ class RslearnLightningModule(L.LightningModule):
                 for image_suffix, image in images.items():
                     out_fname = os.path.join(
                         self.visualize_dir,
-                        f"{metadata.window_name}_{metadata.patch_bounds[0]}_{metadata.patch_bounds[1]}_{image_suffix}.png",
+                        f"{metadata.window_name}_{metadata.crop_bounds[0]}_{metadata.crop_bounds[1]}_{image_suffix}.png",
                     )
                     Image.fromarray(image).save(out_fname)
 

rslearn/train/model_context.py

@@ -67,9 +67,9 @@ class SampleMetadata:
     window_group: str
     window_name: str
     window_bounds: PixelBounds
-    patch_bounds: PixelBounds
-    patch_idx: int
-    num_patches_in_window: int
+    crop_bounds: PixelBounds
+    crop_idx: int
+    num_crops_in_window: int
     time_range: tuple[datetime, datetime] | None
     projection: Projection
 

rslearn/train/prediction_writer.py

@@ -1,6 +1,7 @@
 """rslearn PredictionWriter implementation."""
 
 import json
+import warnings
 from collections.abc import Iterable, Sequence
 from dataclasses import dataclass
 from pathlib import Path
@@ -39,20 +40,20 @@ logger = get_logger(__name__)
 
 
 @dataclass
-class PendingPatchOutput:
-    """A patch output that hasn't been merged yet."""
+class PendingCropOutput:
+    """A crop output that hasn't been merged yet."""
 
     bounds: PixelBounds
     output: Any
 
 
-class PatchPredictionMerger:
-    """Base class for merging predictions from multiple patches."""
+class CropPredictionMerger:
+    """Base class for merging predictions from multiple crops."""
 
     def merge(
         self,
         window: Window,
-        outputs: Sequence[PendingPatchOutput],
+        outputs: Sequence[PendingCropOutput],
         layer_config: LayerConfig,
     ) -> Any:
         """Merge the outputs.
@@ -68,39 +69,60 @@ class PatchPredictionMerger:
         raise NotImplementedError
 
 
-class VectorMerger(PatchPredictionMerger):
+class VectorMerger(CropPredictionMerger):
     """Merger for vector data that simply concatenates the features."""
 
     def merge(
         self,
         window: Window,
-        outputs: Sequence[PendingPatchOutput],
+        outputs: Sequence[PendingCropOutput],
         layer_config: LayerConfig,
     ) -> list[Feature]:
         """Concatenate the vector features."""
         return [feat for output in outputs for feat in output.output]
 
 
-class RasterMerger(PatchPredictionMerger):
+class RasterMerger(CropPredictionMerger):
     """Merger for raster data that copies the rasters to the output."""
 
-    def __init__(self, padding: int | None = None, downsample_factor: int = 1):
+    def __init__(
+        self,
+        overlap_pixels: int | None = None,
+        downsample_factor: int = 1,
+        # Deprecated parameter (for backwards compatibility)
+        padding: int | None = None,
+    ):
         """Create a new RasterMerger.
 
         Args:
-            padding: the padding around the individual patch outputs to remove. This is
-                typically used when leveraging overlapping patches. Portions of outputs
-                at the border of the window will still be retained.
+            overlap_pixels: the number of pixels shared between adjacent crops during
+                sliding window inference. Half of this overlap is removed from each
+                crop during merging (except at window boundaries where the full crop
+                is retained).
             downsample_factor: the factor by which the rasters output by the task are
                 lower in resolution relative to the window resolution.
+            padding: deprecated, use overlap_pixels instead. The old padding value
+                equals overlap_pixels // 2.
         """
-        self.padding = padding
+        # Handle deprecated padding parameter
+        if padding is not None:
+            warnings.warn(
+                "padding is deprecated, use overlap_pixels instead. "
+                "Note: overlap_pixels = padding * 2",
+                FutureWarning,
+                stacklevel=2,
+            )
+            if overlap_pixels is not None:
+                raise ValueError("Cannot specify both padding and overlap_pixels")
+            overlap_pixels = padding * 2
+
+        self.overlap_pixels = overlap_pixels
         self.downsample_factor = downsample_factor
 
     def merge(
         self,
         window: Window,
-        outputs: Sequence[PendingPatchOutput],
+        outputs: Sequence[PendingCropOutput],
         layer_config: LayerConfig,
     ) -> npt.NDArray:
         """Merge the raster outputs."""
@@ -114,6 +136,12 @@ class RasterMerger(PatchPredictionMerger):
             dtype=layer_config.band_sets[0].dtype.get_numpy_dtype(),
         )
 
+        # Compute how many pixels to trim from each side.
+        # We remove half of the overlap from each side (not at window boundaries).
+        trim_pixels = (
+            self.overlap_pixels // 2 if self.overlap_pixels is not None else None
+        )
+
         # Ensure the outputs are sorted by height then width.
         # This way when we merge we can be sure that outputs that are lower or further
         # to the right will overwrite earlier outputs.
@@ -123,18 +151,18 @@ class RasterMerger(PatchPredictionMerger):
         for output in sorted_outputs:
             # So now we just need to compute the src_offset to copy.
             # If the output is not on the left or top boundary, then we should apply
-            # the padding (if set).
+            # the trim (if set).
             src = output.output
             src_offset = (
                 output.bounds[0] // self.downsample_factor,
                 output.bounds[1] // self.downsample_factor,
             )
-            if self.padding is not None and output.bounds[0] != window.bounds[0]:
-                src = src[:, :, self.padding :]
-                src_offset = (src_offset[0] + self.padding, src_offset[1])
-            if self.padding is not None and output.bounds[1] != window.bounds[1]:
-                src = src[:, self.padding :, :]
-                src_offset = (src_offset[0], src_offset[1] + self.padding)
+            if trim_pixels is not None and output.bounds[0] != window.bounds[0]:
+                src = src[:, :, trim_pixels:]
+                src_offset = (src_offset[0] + trim_pixels, src_offset[1])
+            if trim_pixels is not None and output.bounds[1] != window.bounds[1]:
+                src = src[:, trim_pixels:, :]
+                src_offset = (src_offset[0], src_offset[1] + trim_pixels)
 
             copy_spatial_array(
                 src=src,
@@ -162,7 +190,7 @@ class RslearnWriter(BasePredictionWriter):
         output_layer: str,
         path_options: dict[str, Any] | None = None,
         selector: list[str] | None = None,
-        merger: PatchPredictionMerger | None = None,
+        merger: CropPredictionMerger | None = None,
         output_path: str | Path | None = None,
         layer_config: LayerConfig | None = None,
         storage_config: StorageConfig | None = None,
@@ -175,7 +203,7 @@ class RslearnWriter(BasePredictionWriter):
             path_options: additional options for path to pass to fsspec
             selector: keys to access the desired output in the output dict if needed.
                 e.g ["key1", "key2"] gets output["key1"]["key2"]
-            merger: merger to use to merge outputs from overlapped patches.
+            merger: merger to use to merge outputs from overlapped crops.
             output_path: optional custom path for writing predictions. If provided,
                 predictions will be written to this path instead of deriving from dataset path.
             layer_config: optional layer configuration. If provided, this config will be
@@ -217,9 +245,9 @@ class RslearnWriter(BasePredictionWriter):
             self.merger = VectorMerger()
 
         # Map from window name to pending data to write.
-        # This is used when windows are split up into patches, so the data from all the
-        # patches of each window need to be reconstituted.
-        self.pending_outputs: dict[str, list[PendingPatchOutput]] = {}
+        # This is used when windows are split up into crops, so the data from all the
+        # crops of each window need to be reconstituted.
+        self.pending_outputs: dict[str, list[PendingCropOutput]] = {}
 
     def _get_layer_config_and_dataset_storage(
         self,
@@ -327,7 +355,7 @@ class RslearnWriter(BasePredictionWriter):
                 will be processed by the task to obtain a vector (list[Feature]) or
                 raster (npt.NDArray) output.
             metadatas: corresponding list of metadatas from the batch describing the
-                patches that were processed.
+                crops that were processed.
         """
         # Process the predictions into outputs that can be written.
         outputs: list = [
@@ -349,17 +377,17 @@ class RslearnWriter(BasePredictionWriter):
             )
             self.process_output(
                 window,
-                metadata.patch_idx,
-                metadata.num_patches_in_window,
-                metadata.patch_bounds,
+                metadata.crop_idx,
+                metadata.num_crops_in_window,
+                metadata.crop_bounds,
                 output,
             )
 
     def process_output(
         self,
         window: Window,
-        patch_idx: int,
-        num_patches: int,
+        crop_idx: int,
+        num_crops: int,
         cur_bounds: PixelBounds,
         output: npt.NDArray | list[Feature],
     ) -> None:
@@ -367,28 +395,28 @@ class RslearnWriter(BasePredictionWriter):
 
         Args:
             window: the window that the output pertains to.
-            patch_idx: the index of this patch for the window.
-            num_patches: the total number of patches to be processed for the window.
-            cur_bounds: the bounds of the current patch.
+            crop_idx: the index of this crop for the window.
+            num_crops: the total number of crops to be processed for the window.
+            cur_bounds: the bounds of the current crop.
             output: the output data.
         """
-        # Incorporate the output into our list of pending patch outputs.
+        # Incorporate the output into our list of pending crop outputs.
         if window.name not in self.pending_outputs:
             self.pending_outputs[window.name] = []
-        self.pending_outputs[window.name].append(PendingPatchOutput(cur_bounds, output))
+        self.pending_outputs[window.name].append(PendingCropOutput(cur_bounds, output))
         logger.debug(
-            f"Stored PendingPatchOutput for patch #{patch_idx}/{num_patches} at window {window.name}"
+            f"Stored PendingCropOutput for crop #{crop_idx}/{num_crops} at window {window.name}"
         )
 
-        if patch_idx < num_patches - 1:
+        if crop_idx < num_crops - 1:
             return
 
-        # This is the last patch so it's time to write it.
+        # This is the last crop so it's time to write it.
         # First get the pending output and clear it.
         pending_output = self.pending_outputs[window.name]
         del self.pending_outputs[window.name]
 
-        # Merge outputs from overlapped patches if merger is set.
+        # Merge outputs from overlapped crops if merger is set.
         logger.debug(f"Merging and writing for window {window.name}")
         merged_output = self.merger.merge(window, pending_output, self.layer_config)
 

rslearn/train/tasks/classification.py

@@ -201,7 +201,7 @@ class ClassificationTask(BasicTask):
         feature = Feature(
             STGeometry(
                 metadata.projection,
-                shapely.Point(metadata.patch_bounds[0], metadata.patch_bounds[1]),
+                shapely.Point(metadata.crop_bounds[0], metadata.crop_bounds[1]),
                 None,
             ),
             {

rslearn/train/tasks/detection.py

@@ -128,7 +128,7 @@ class DetectionTask(BasicTask):
         if not load_targets:
             return {}, {}
 
-        bounds = metadata.patch_bounds
+        bounds = metadata.crop_bounds
 
         boxes = []
         class_labels = []
@@ -244,10 +244,10 @@ class DetectionTask(BasicTask):
         features = []
         for box, class_id, score in zip(boxes, class_ids, scores):
             shp = shapely.box(
-                metadata.patch_bounds[0] + float(box[0]),
-                metadata.patch_bounds[1] + float(box[1]),
-                metadata.patch_bounds[0] + float(box[2]),
-                metadata.patch_bounds[1] + float(box[3]),
+                metadata.crop_bounds[0] + float(box[0]),
+                metadata.crop_bounds[1] + float(box[1]),
+                metadata.crop_bounds[0] + float(box[2]),
+                metadata.crop_bounds[1] + float(box[3]),
             )
             geom = STGeometry(metadata.projection, shp, None)
             properties: dict[str, Any] = {

rslearn/train/tasks/regression.py

@@ -130,7 +130,7 @@ class RegressionTask(BasicTask):
         feature = Feature(
             STGeometry(
                 metadata.projection,
-                shapely.Point(metadata.patch_bounds[0], metadata.patch_bounds[1]),
+                shapely.Point(metadata.crop_bounds[0], metadata.crop_bounds[1]),
                 None,
             ),
             {

rslearn/utils/__init__.py

@@ -7,6 +7,7 @@ from .geometry import (
     PixelBounds,
     Projection,
     STGeometry,
+    get_global_raster_bounds,
     is_same_resolution,
     shp_intersects,
 )
@@ -23,6 +24,7 @@ __all__ = (
     "Projection",
     "STGeometry",
     "daterange",
+    "get_global_raster_bounds",
     "get_utm_ups_crs",
     "is_same_resolution",
     "logger",

rslearn/utils/geometry.py

@@ -116,6 +116,27 @@ class Projection:
 WGS84_PROJECTION = Projection(CRS.from_epsg(WGS84_EPSG), 1, 1)
 
 
+def get_global_raster_bounds(projection: Projection) -> PixelBounds:
+    """Get very large pixel bounds for a global raster in the given projection.
+
+    This is useful for data sources that cover the entire world and don't want to
+    compute exact bounds in arbitrary projections (which can fail for projections
+    like UTM that only cover part of the world).
+
+    Args:
+        projection: the projection to get bounds in.
+
+    Returns:
+        Pixel bounds that will intersect with any reasonable window. We assume that the
+        absolute value of CRS coordinates is at most 2^32, and adjust it based on the
+        resolution in the Projection in case very fine-grained resolutions are used.
+    """
+    crs_bound = 2**32
+    pixel_bound_x = int(crs_bound / abs(projection.x_resolution))
+    pixel_bound_y = int(crs_bound / abs(projection.y_resolution))
+    return (-pixel_bound_x, -pixel_bound_y, pixel_bound_x, pixel_bound_y)
+
+
 class ResolutionFactor:
     """Multiplier for the resolution in a Projection.