Preserve arbitrary TIFF tags through read/write round-trip

Any IFD tag that the writer doesn't explicitly manage (Software,
DateTime, ImageDescription, Copyright, custom private tags, etc.)
is now collected on read, stored in attrs['extra_tags'], and
re-emitted on write.

Read: extract_geo_info collects (tag_id, type_id, count, value)
tuples for all tags not in the _MANAGED_TAGS set (structural tags
that the writer builds from scratch: dimensions, compression,
offsets, geo tags, etc.). Stored in attrs['extra_tags'].

Write: extra_tags are appended to the IFD, skipping any tag_id
that was already written to avoid duplicates. The tag values are
serialized using the same type-aware encoder as built-in tags.

Tested with a hand-crafted TIFF containing Software (305) and
DateTime (306) tags. Both survive read -> write -> read intact.

3 new tests: read detection, round-trip preservation, and
no-extra-tags baseline.

Author: brendancol

xrspatial/geotiff/__init__.py

@@ -182,6 +182,10 @@ def read_geotiff(source: str, *, window=None,
     if geo_info.gdal_metadata_xml is not None:
         attrs['gdal_metadata_xml'] = geo_info.gdal_metadata_xml
 
+    # Extra (non-managed) TIFF tags for pass-through
+    if geo_info.extra_tags is not None:
+        attrs['extra_tags'] = geo_info.extra_tags
+
     # Resolution / DPI metadata
     if geo_info.x_resolution is not None:
         attrs['x_resolution'] = geo_info.x_resolution
@@ -282,6 +286,7 @@ def write_geotiff(data: xr.DataArray | np.ndarray, path: str, *,
     y_res = None
     res_unit = None
     gdal_meta_xml = None
+    extra_tags_list = None
 
     # Resolve crs argument: can be int (EPSG) or str (WKT/PROJ)
     if isinstance(crs, int):
@@ -311,6 +316,8 @@ def write_geotiff(data: xr.DataArray | np.ndarray, path: str, *,
             if isinstance(gdal_meta_dict, dict):
                 from ._geotags import _build_gdal_metadata_xml
                 gdal_meta_xml = _build_gdal_metadata_xml(gdal_meta_dict)
+        # Extra tags for pass-through
+        extra_tags_list = data.attrs.get('extra_tags')
         # Resolution / DPI from attrs
         x_res = data.attrs.get('x_resolution')
         y_res = data.attrs.get('y_resolution')
@@ -341,6 +348,7 @@ def write_geotiff(data: xr.DataArray | np.ndarray, path: str, *,
         y_resolution=y_res,
         resolution_unit=res_unit,
         gdal_metadata_xml=gdal_meta_xml,
+        extra_tags=extra_tags_list,
     )
 
 

xrspatial/geotiff/_geotags.py

@@ -6,15 +6,38 @@
 
 from ._header import (
     IFD,
-    TAG_MODEL_PIXEL_SCALE,
-    TAG_MODEL_TIEPOINT,
+    TAG_IMAGE_WIDTH, TAG_IMAGE_LENGTH, TAG_BITS_PER_SAMPLE,
+    TAG_COMPRESSION, TAG_PHOTOMETRIC,
+    TAG_STRIP_OFFSETS, TAG_SAMPLES_PER_PIXEL,
+    TAG_ROWS_PER_STRIP, TAG_STRIP_BYTE_COUNTS,
+    TAG_X_RESOLUTION, TAG_Y_RESOLUTION,
+    TAG_PLANAR_CONFIG, TAG_RESOLUTION_UNIT,
+    TAG_PREDICTOR, TAG_COLORMAP,
+    TAG_TILE_WIDTH, TAG_TILE_LENGTH,
+    TAG_TILE_OFFSETS, TAG_TILE_BYTE_COUNTS,
+    TAG_SAMPLE_FORMAT, TAG_GDAL_METADATA, TAG_GDAL_NODATA,
+    TAG_MODEL_PIXEL_SCALE, TAG_MODEL_TIEPOINT,
     TAG_MODEL_TRANSFORMATION,
-    TAG_GEO_KEY_DIRECTORY,
-    TAG_GEO_DOUBLE_PARAMS,
-    TAG_GEO_ASCII_PARAMS,
-    TAG_GDAL_NODATA,
+    TAG_GEO_KEY_DIRECTORY, TAG_GEO_DOUBLE_PARAMS, TAG_GEO_ASCII_PARAMS,
 )
 
+# Tags that the writer manages -- everything else can be passed through
+_MANAGED_TAGS = frozenset({
+    TAG_IMAGE_WIDTH, TAG_IMAGE_LENGTH, TAG_BITS_PER_SAMPLE,
+    TAG_COMPRESSION, TAG_PHOTOMETRIC,
+    TAG_STRIP_OFFSETS, TAG_SAMPLES_PER_PIXEL,
+    TAG_ROWS_PER_STRIP, TAG_STRIP_BYTE_COUNTS,
+    TAG_X_RESOLUTION, TAG_Y_RESOLUTION,
+    TAG_PLANAR_CONFIG, TAG_RESOLUTION_UNIT,
+    TAG_PREDICTOR, TAG_COLORMAP,
+    TAG_TILE_WIDTH, TAG_TILE_LENGTH,
+    TAG_TILE_OFFSETS, TAG_TILE_BYTE_COUNTS,
+    TAG_SAMPLE_FORMAT, TAG_GDAL_METADATA, TAG_GDAL_NODATA,
+    TAG_MODEL_PIXEL_SCALE, TAG_MODEL_TIEPOINT,
+    TAG_MODEL_TRANSFORMATION,
+    TAG_GEO_KEY_DIRECTORY, TAG_GEO_DOUBLE_PARAMS, TAG_GEO_ASCII_PARAMS,
+})
+
 # GeoKey IDs
 GEOKEY_MODEL_TYPE = 1024
 GEOKEY_RASTER_TYPE = 1025
@@ -113,6 +136,9 @@ class GeoInfo:
     # and {(name, band): value} for per-band items.  Raw XML also kept.
     gdal_metadata: dict | None = None
     gdal_metadata_xml: str | None = None
+    # Extra TIFF tags not managed by the writer (pass-through on round-trip)
+    # List of (tag_id, type_id, count, raw_value) tuples.
+    extra_tags: list | None = None
     # Raw geokeys dict for anything else
     geokeys: dict[int, int | float | str] = field(default_factory=dict)
 
@@ -450,6 +476,14 @@ def extract_geo_info(ifd: IFD, data: bytes | memoryview,
                     b = raw_cmap[2 * n_colors + i] / 65535.0
                     colormap.append((r, g, b, 1.0))
 
+    # Collect extra (non-managed) tags for pass-through
+    extra_tags = []
+    for tag_id, entry in ifd.entries.items():
+        if tag_id not in _MANAGED_TAGS:
+            extra_tags.append((tag_id, entry.type_id, entry.count, entry.value))
+    if not extra_tags:
+        extra_tags = None
+
     # Resolve EPSG -> WKT via pyproj if available
     crs_wkt = None
     if epsg is not None:
@@ -483,6 +517,7 @@ def extract_geo_info(ifd: IFD, data: bytes | memoryview,
         crs_wkt=crs_wkt,
         gdal_metadata=gdal_metadata,
         gdal_metadata_xml=gdal_metadata_xml,
+        extra_tags=extra_tags,
         geokeys=geokeys,
     )
 

xrspatial/geotiff/_writer.py

@@ -414,6 +414,7 @@ def _assemble_tiff(width: int, height: int, dtype: np.dtype,
                    is_cog: bool = False,
                    raster_type: int = 1,
                    gdal_metadata_xml: str | None = None,
+                   extra_tags: list | None = None,
                    x_resolution: float | None = None,
                    y_resolution: float | None = None,
                    resolution_unit: int | None = None) -> bytes:
@@ -523,6 +524,14 @@ def _assemble_tiff(width: int, height: int, dtype: np.dtype,
                 tags.append((TAG_GDAL_METADATA, ASCII,
                              len(gdal_metadata_xml) + 1, gdal_metadata_xml))
 
+            # Extra tags (pass-through from source file)
+            if extra_tags is not None:
+                for etag_id, etype_id, ecount, evalue in extra_tags:
+                    # Skip any tag we already wrote to avoid duplicates
+                    existing_ids = {t[0] for t in tags}
+                    if etag_id not in existing_ids:
+                        tags.append((etag_id, etype_id, ecount, evalue))
+
         ifd_specs.append(tags)
 
     # --- Determine if BigTIFF is needed ---
@@ -711,7 +720,8 @@ def write(data: np.ndarray, path: str, *,
           x_resolution: float | None = None,
           y_resolution: float | None = None,
           resolution_unit: int | None = None,
-          gdal_metadata_xml: str | None = None) -> None:
+          gdal_metadata_xml: str | None = None,
+          extra_tags: list | None = None) -> None:
     """Write a numpy array as a GeoTIFF or COG.
 
     Parameters
@@ -781,6 +791,7 @@ def write(data: np.ndarray, path: str, *,
         parts, geo_transform, crs_epsg, nodata, is_cog=cog,
         raster_type=raster_type,
         gdal_metadata_xml=gdal_metadata_xml,
+        extra_tags=extra_tags,
         x_resolution=x_resolution, y_resolution=y_resolution,
         resolution_unit=resolution_unit,
     )

xrspatial/geotiff/tests/test_features.py

@@ -417,6 +417,144 @@ def test_no_crs_no_wkt(self, tmp_path):
 # GDAL metadata (tag 42112)
 # -----------------------------------------------------------------------
 
+# -----------------------------------------------------------------------
+# Arbitrary tag preservation
+# -----------------------------------------------------------------------
+
+class TestExtraTags:
+
+    def _make_tiff_with_extra_tags(self, tmp_path):
+        """Build a TIFF with Software (305) and DateTime (306) tags."""
+        import struct
+        bo = '<'
+        width, height = 4, 4
+        pixels = np.arange(16, dtype=np.float32).reshape(4, 4)
+        pixel_bytes = pixels.tobytes()
+
+        tag_list = []
+        def add_short(tag, val):
+            tag_list.append((tag, 3, 1, struct.pack(f'{bo}H', val)))
+        def add_long(tag, val):
+            tag_list.append((tag, 4, 1, struct.pack(f'{bo}I', val)))
+        def add_ascii(tag, text):
+            raw = text.encode('ascii') + b'\x00'
+            tag_list.append((tag, 2, len(raw), raw))
+
+        add_short(256, width)
+        add_short(257, height)
+        add_short(258, 32)
+        add_short(259, 1)
+        add_short(262, 1)
+        add_short(277, 1)
+        add_short(278, height)
+        add_long(273, 0)  # placeholder
+        add_long(279, len(pixel_bytes))
+        add_short(339, 3)  # float
+        add_ascii(305, 'TestSoftware v1.0')
+        add_ascii(306, '2025:01:15 12:00:00')
+
+        tag_list.sort(key=lambda t: t[0])
+        num_entries = len(tag_list)
+        ifd_start = 8
+        ifd_size = 2 + 12 * num_entries + 4
+        overflow_start = ifd_start + ifd_size
+
+        overflow_buf = bytearray()
+        tag_offsets = {}
+        for tag, typ, count, raw in tag_list:
+            if len(raw) > 4:
+                tag_offsets[tag] = len(overflow_buf)
+                overflow_buf.extend(raw)
+                if len(overflow_buf) % 2:
+                    overflow_buf.append(0)
+            else:
+                tag_offsets[tag] = None
+
+        pixel_data_start = overflow_start + len(overflow_buf)
+
+        patched = []
+        for tag, typ, count, raw in tag_list:
+            if tag == 273:
+                patched.append((tag, typ, count, struct.pack(f'{bo}I', pixel_data_start)))
+            else:
+                patched.append((tag, typ, count, raw))
+        tag_list = patched
+
+        overflow_buf = bytearray()
+        tag_offsets = {}
+        for tag, typ, count, raw in tag_list:
+            if len(raw) > 4:
+                tag_offsets[tag] = len(overflow_buf)
+                overflow_buf.extend(raw)
+                if len(overflow_buf) % 2:
+                    overflow_buf.append(0)
+            else:
+                tag_offsets[tag] = None
+
+        out = bytearray()
+        out.extend(b'II')
+        out.extend(struct.pack(f'{bo}H', 42))
+        out.extend(struct.pack(f'{bo}I', ifd_start))
+        out.extend(struct.pack(f'{bo}H', num_entries))
+        for tag, typ, count, raw in tag_list:
+            out.extend(struct.pack(f'{bo}HHI', tag, typ, count))
+            if len(raw) <= 4:
+                out.extend(raw.ljust(4, b'\x00'))
+            else:
+                ptr = overflow_start + tag_offsets[tag]
+                out.extend(struct.pack(f'{bo}I', ptr))
+        out.extend(struct.pack(f'{bo}I', 0))
+        out.extend(overflow_buf)
+        out.extend(pixel_bytes)
+
+        path = str(tmp_path / 'extra_tags.tif')
+        with open(path, 'wb') as f:
+            f.write(bytes(out))
+        return path, pixels
+
+    def test_extra_tags_read(self, tmp_path):
+        """Extra tags are collected in attrs['extra_tags']."""
+        path, _ = self._make_tiff_with_extra_tags(tmp_path)
+        da = read_geotiff(path)
+
+        extra = da.attrs.get('extra_tags')
+        assert extra is not None
+        tag_ids = {t[0] for t in extra}
+        assert 305 in tag_ids  # Software
+        assert 306 in tag_ids  # DateTime
+
+    def test_extra_tags_round_trip(self, tmp_path):
+        """Extra tags survive read -> write -> read."""
+        path, pixels = self._make_tiff_with_extra_tags(tmp_path)
+        da = read_geotiff(path)
+
+        out_path = str(tmp_path / 'roundtrip.tif')
+        write_geotiff(da, out_path, compression='none')
+
+        da2 = read_geotiff(out_path)
+
+        # Pixels should match
+        np.testing.assert_array_equal(da2.values, pixels)
+
+        # Extra tags should survive
+        extra2 = da2.attrs.get('extra_tags')
+        assert extra2 is not None
+        tag_map = {t[0]: t[3] for t in extra2}
+        assert 305 in tag_map
+        assert 'TestSoftware v1.0' in str(tag_map[305])
+        assert 306 in tag_map
+        assert '2025:01:15' in str(tag_map[306])
+
+    def test_no_extra_tags(self, tmp_path):
+        """Files with only managed tags have no extra_tags attr."""
+        arr = np.ones((4, 4), dtype=np.float32)
+        path = str(tmp_path / 'no_extra.tif')
+        write(arr, path, compression='none', tiled=False)
+
+        da = read_geotiff(path)
+        assert 'extra_tags' not in da.attrs
+
+
 class TestGDALMetadata:
 
     def test_parse_gdal_metadata_xml(self):