add nodata, scales and offsets attributes to ImageData and PointData classes (#818)

Author: vincentsarago

CHANGES.md

@@ -53,11 +53,17 @@ with Reader("tests/fixtures/cog_tags.tif") as src:
 ```
 
 * only cast data to `uint8` if colormap values are of type `uint8`
+
 * add `alpha_mask` attribute to `ImageData` class
+
 * allow partial alpha values from alpha band
+
 * better handle non-uint8 alpha band
+
 * remove deprecated `force_binary_mask` option in `reader.read` function  **breaking change**
 
+* add `nodata`, `scales` and `offsets` attributes to `ImageData` and `PointData` classes
+
 # 7.8.1 (2025-06-16)
 
 * apply scale/offset to dataset statistics in ImageData object (used for automatic rescaling)

rio_tiler/io/xarray.py

@@ -312,6 +312,7 @@ def tile(
             crs=dst_crs,
             dataset_statistics=stats,
             band_names=band_names,
+            nodata=da.rio.nodata,
         )
 
     def part(
@@ -405,6 +406,7 @@ def part(
             crs=da.rio.crs,
             dataset_statistics=stats,
             band_names=band_names,
+            nodata=da.rio.nodata,
         )
 
         output_height = height or img.height
@@ -498,6 +500,7 @@ def preview(
             crs=da.rio.crs,
             dataset_statistics=stats,
             band_names=band_names,
+            nodata=da.rio.nodata,
         )
 
         output_height = height or img.height
@@ -566,6 +569,7 @@ def point(
             crs=coord_crs,
             band_names=band_names,
             pixel_location=(x, y),
+            nodata=da.rio.nodata,
         )
 
     def feature(

rio_tiler/models.py

@@ -33,6 +33,7 @@
     ColorMapType,
     GDALColorMapType,
     IntervalTuple,
+    NoData,
     NumType,
     RIOResampling,
     WarpResampling,
@@ -159,6 +160,9 @@ class PointData:
     crs: Optional[CRS] = attr.ib(default=None, kw_only=True)
     assets: Optional[List] = attr.ib(default=None, kw_only=True)
     metadata: Optional[Dict] = attr.ib(factory=dict, kw_only=True)
+    nodata: Optional[NoData] = attr.ib(default=None, kw_only=True)
+    scales: Optional[List[NumType]] = attr.ib(kw_only=True)
+    offsets: Optional[List[NumType]] = attr.ib(kw_only=True)
     pixel_location: Optional[Tuple[NumType, NumType]] = attr.ib(
         default=None, kw_only=True
     )
@@ -179,6 +183,14 @@ def _validate_coordinates(self, attribute, value):
     def _default_names(self):
         return [f"b{ix + 1}" for ix in range(self.count)]
 
+    @scales.default
+    def _default_scales(self):
+        return [1.0] * self.count
+
+    @offsets.default
+    def _default_offsets(self):
+        return [0.0] * self.count
+
     @property
     def data(self) -> numpy.ndarray:
         """Return data part of the masked array."""
@@ -236,6 +248,10 @@ def create_from_list(cls, data: Sequence["PointData"]) -> Self:
             itertools.chain.from_iterable([pt.band_names for pt in data if pt.band_names])
         )
 
+        scales = list(itertools.chain.from_iterable([pt.scales for pt in data]))
+
+        offsets = list(itertools.chain.from_iterable([pt.offsets for pt in data]))
+
         metadata = dict(
             itertools.chain.from_iterable(
                 [pt.metadata.items() for pt in data if pt.metadata]
@@ -246,6 +262,8 @@ def create_from_list(cls, data: Sequence["PointData"]) -> Self:
             arr,
             assets=assets,
             band_names=band_names,
+            offsets=offsets,
+            scales=scales,
             coordinates=data[0].coordinates,
             crs=data[0].crs,
             metadata=metadata,
@@ -311,6 +329,9 @@ class ImageData:
     )
     crs: Optional[CRS] = attr.ib(default=None, kw_only=True)
     metadata: Optional[Dict] = attr.ib(factory=dict, kw_only=True)
+    nodata: Optional[NoData] = attr.ib(default=None, kw_only=True)
+    scales: Optional[List[NumType]] = attr.ib(kw_only=True)
+    offsets: Optional[List[NumType]] = attr.ib(kw_only=True)
     band_names: Optional[List[str]] = attr.ib(kw_only=True)
     dataset_statistics: Optional[Sequence[Tuple[float, float]]] = attr.ib(
         default=None, kw_only=True
@@ -322,6 +343,14 @@ class ImageData:
     def _default_names(self):
         return [f"b{ix + 1}" for ix in range(self.count)]
 
+    @scales.default
+    def _default_scales(self):
+        return [1.0] * self.count
+
+    @offsets.default
+    def _default_offsets(self):
+        return [0.0] * self.count
+
     @alpha_mask.validator
     def _check_alpha_mask(self, attribute, value):
         """Make sure alpha mask has valid shame and datatype."""
@@ -411,7 +440,14 @@ def from_bytes(cls, data: bytes) -> Self:
                         array,
                         crs=dataset.crs,
                         bounds=dataset.bounds,
+                        band_names=[
+                            dataset.descriptions[ix - 1] or f"b{idx}" for idx in indexes
+                        ],
                         dataset_statistics=dataset_statistics,
+                        nodata=dataset.nodata,
+                        scales=list(dataset.scales),
+                        offsets=list(dataset.offsets),
+                        metadata=dataset.tags(),
                     )
 
     @classmethod
@@ -464,6 +500,10 @@ def create_from_list(cls, data: Sequence["ImageData"]) -> Self:
             )
         )
 
+        scales = list(itertools.chain.from_iterable([img.scales for img in data]))
+
+        offsets = list(itertools.chain.from_iterable([img.offsets for img in data]))
+
         stats = list(
             itertools.chain.from_iterable(
                 [img.dataset_statistics for img in data if img.dataset_statistics]
@@ -486,6 +526,8 @@ def create_from_list(cls, data: Sequence["ImageData"]) -> Self:
             dataset_statistics=dataset_statistics,
             cutline_mask=cutline_mask,
             metadata=metadata,
+            scales=scales,
+            offsets=offsets,
         )
 
     def data_as_image(self) -> numpy.ndarray:
@@ -540,6 +582,10 @@ def rescale(
                 out_range=dtype_ranges[out_dtype],
             ).astype(out_dtype)
 
+        # reset scales/offsets
+        self.scales = [1.0] * self.count
+        self.offsets = [0.0] * self.count
+
         return self
 
     def apply_color_formula(self, color_formula: Optional[str]) -> Self:
@@ -560,6 +606,10 @@ def apply_color_formula(self, color_formula: Optional[str]) -> Self:
                 self.alpha_mask, in_range=dtype_ranges[str(self.alpha_mask.dtype)]
             ).astype("uint8")
 
+        # reset scales/offsets
+        self.scales = [1.0] * self.count
+        self.offsets = [0.0] * self.count
+
         return self
 
     def apply_colormap(self, colormap: ColorMapType) -> "ImageData":
@@ -643,6 +693,9 @@ def resize(
             crs=self.crs,
             bounds=self.bounds,
             band_names=self.band_names,
+            nodata=self.nodata,
+            scales=self.scales,
+            offsets=self.offsets,
             metadata=self.metadata,
             dataset_statistics=self.dataset_statistics,
             alpha_mask=alpha_mask,
@@ -660,6 +713,9 @@ def clip(self, bbox: BBox) -> "ImageData":
             crs=self.crs,
             bounds=bbox,
             band_names=self.band_names,
+            nodata=self.nodata,
+            scales=self.scales,
+            offsets=self.offsets,
             metadata=self.metadata,
             dataset_statistics=self.dataset_statistics,
             alpha_mask=self.alpha_mask[row_slice, col_slice].copy()
@@ -777,14 +833,15 @@ def to_raster(self, dst_path: str, *, driver: str = "GTIFF", **kwargs: Any) -> N
             if "crs" not in kwargs and self.crs:
                 kwargs.update({"crs": self.crs})
 
-        write_nodata = "nodata" in kwargs
+        write_nodata = self.nodata is not None
         count, height, width = self.array.shape
 
         output_profile = {
             "dtype": self.array.dtype,
             "count": count if write_nodata else count + 1,
             "height": height,
             "width": width,
+            "nodata": self.nodata,
         }
         output_profile.update(kwargs)
 
@@ -930,6 +987,9 @@ def reproject(
             crs=dst_crs,
             bounds=bounds,
             band_names=self.band_names,
+            nodata=self.nodata,
+            scales=self.scales,
+            offsets=self.offsets,
             metadata=self.metadata,
             dataset_statistics=self.dataset_statistics,
             alpha_mask=alpha_mask,

rio_tiler/reader.py

@@ -276,33 +276,33 @@ def read(
         # We only add dataset statistics if we have them for all the indexes
         dataset_statistics = stats if len(stats) == len(indexes) else None
 
+        scales = numpy.array(dataset.scales)[numpy.array(indexes) - 1]
+        offsets = numpy.array(dataset.offsets)[numpy.array(indexes) - 1]
         if unscale:
             data = data.astype("float32", casting="unsafe")
-
-            # reshaped to match data
-            scales = numpy.array(dataset.scales)[numpy.array(indexes) - 1].reshape(
-                (-1, 1, 1)
-            )
-            offsets = numpy.array(dataset.offsets)[numpy.array(indexes) - 1].reshape(
-                (-1, 1, 1)
-            )
-
-            numpy.multiply(data, scales, out=data, casting="unsafe")
-            numpy.add(data, offsets, out=data, casting="unsafe")
+            numpy.multiply(data, scales.reshape((-1, 1, 1)), out=data, casting="unsafe")
+            numpy.add(data, offsets.reshape((-1, 1, 1)), out=data, casting="unsafe")
 
             # apply scale/offsets to stats
             if dataset_statistics:
-                scales = numpy.array(dataset.scales)[numpy.array(indexes) - 1].reshape(
-                    (-1, 1)
+                stats_array = numpy.array(dataset_statistics)
+                numpy.multiply(
+                    stats_array,
+                    scales.reshape((-1, 1)),
+                    out=stats_array,
+                    casting="unsafe",
                 )
-                offsets = numpy.array(dataset.offsets)[numpy.array(indexes) - 1].reshape(
-                    (-1, 1)
+                numpy.add(
+                    stats_array,
+                    offsets.reshape((-1, 1)),
+                    out=stats_array,
+                    casting="unsafe",
                 )
-                stats_array = numpy.array(dataset_statistics)
-                numpy.multiply(stats_array, scales, out=stats_array, casting="unsafe")
-                numpy.add(stats_array, offsets, out=stats_array, casting="unsafe")
                 dataset_statistics = [tuple(s) for s in stats_array.tolist()]
 
+            scales = numpy.zeros(len(indexes)) + 1.0
+            offsets = numpy.zeros(len(indexes))
+
         if post_process:
             data = post_process(data)
 
@@ -317,6 +317,9 @@ def read(
             band_names=[dataset.descriptions[ix - 1] or f"b{idx}" for idx in indexes],
             dataset_statistics=dataset_statistics,
             metadata=dataset.tags(),
+            nodata=nodata,
+            scales=scales.tolist(),
+            offsets=offsets.tolist(),
         )
 
 
@@ -522,6 +525,9 @@ def part(
             bounds=bounds,
             crs=img.crs,
             band_names=img.band_names,
+            nodata=img.nodata,
+            scales=img.scales,
+            offsets=img.offsets,
             dataset_statistics=img.dataset_statistics,
             metadata=img.metadata,
         )
@@ -660,6 +666,9 @@ def point(
             band_names=img.band_names,
             coordinates=coordinates,
             crs=coord_crs,
-            metadata=dataset.tags(),
             pixel_location=(col, row),
+            nodata=img.nodata,
+            scales=img.scales,
+            offsets=img.offsets,
+            metadata=img.metadata,
         )

tests/test_io_rasterio.py

@@ -1177,13 +1177,17 @@ def test_unscale_stats():
     """check if scale/offset were applied on stats."""
     with Reader(COG_SCALE_STATS) as src:
         img = src.read(unscale=True)
+        assert img.scales == [1.0, 1.0]
+        assert img.offsets == [0.0, 0.0]
         stats = img.statistics()
         minb1, maxb1 = stats["b1"].min, stats["b1"].max
 
         assert pytest.approx(img.dataset_statistics[0][0]) == pytest.approx(minb1)
         assert pytest.approx(img.dataset_statistics[0][1]) == pytest.approx(maxb1)
 
         img = src.read()
+        assert img.scales == [0.0001, 0.001]
+        assert img.offsets == [1000.0, 2000.0]
         stats = img.statistics()
         minb1, maxb1 = stats["b1"].min, stats["b1"].max