Fix BigTIFF auto-detection and add bigtiff= parameter

The auto-detection now estimates total file size (header + IFDs +
overflow + pixel data) instead of only checking compressed pixel
data size, and compares against UINT32_MAX (4,294,967,295) instead
of a hardcoded 3.9 GB threshold.

Also adds a bigtiff= parameter to write() and write_geotiff():
- bigtiff=None (default): auto-detect based on estimated file size
- bigtiff=True: force BigTIFF even for small files
- bigtiff=False: force classic TIFF (user's responsibility if >4GB)

3 new tests: force BigTIFF via public API, small file stays classic,
force classic via bigtiff=False.

Author: brendancol

xrspatial/geotiff/__init__.py

@@ -248,7 +248,8 @@ def write_geotiff(data: xr.DataArray | np.ndarray, path: str, *,
                   predictor: bool = False,
                   cog: bool = False,
                   overview_levels: list[int] | None = None,
-                  overview_resampling: str = 'mean') -> None:
+                  overview_resampling: str = 'mean',
+                  bigtiff: bool | None = None) -> None:
     """Write data as a GeoTIFF or Cloud Optimized GeoTIFF.
 
     Parameters
@@ -349,6 +350,7 @@ def write_geotiff(data: xr.DataArray | np.ndarray, path: str, *,
         resolution_unit=res_unit,
         gdal_metadata_xml=gdal_meta_xml,
         extra_tags=extra_tags_list,
+        bigtiff=bigtiff,
     )
 
 

xrspatial/geotiff/_writer.py

@@ -417,7 +417,8 @@ def _assemble_tiff(width: int, height: int, dtype: np.dtype,
                    extra_tags: list | None = None,
                    x_resolution: float | None = None,
                    y_resolution: float | None = None,
-                   resolution_unit: int | None = None) -> bytes:
+                   resolution_unit: int | None = None,
+                   force_bigtiff: bool | None = None) -> bytes:
     """Assemble a complete TIFF file.
 
     Parameters
@@ -535,9 +536,22 @@ def _assemble_tiff(width: int, height: int, dtype: np.dtype,
         ifd_specs.append(tags)
 
     # --- Determine if BigTIFF is needed ---
-    total_data = sum(sum(len(c) for c in chunks)
-                     for _, _, _, _, _, chunks in pixel_data_parts)
-    bigtiff = total_data > 3_900_000_000  # ~4GB threshold with margin
+    # Classic TIFF uses 32-bit offsets (max ~4.29 GB). Estimate total file
+    # size including headers, IFDs, overflow data, and all pixel data.
+    # Switch to BigTIFF if any offset could exceed 2^32.
+    total_pixel_data = sum(sum(len(c) for c in chunks)
+                           for _, _, _, _, _, chunks in pixel_data_parts)
+    # Conservative overhead estimate: header + IFDs + overflow + geo tags
+    num_levels = len(ifd_specs)
+    max_tags_per_ifd = max(len(tags) for tags in ifd_specs) if ifd_specs else 20
+    ifd_overhead = num_levels * (2 + 12 * max_tags_per_ifd + 4 + 1024)  # ~1KB overflow per IFD
+    estimated_file_size = 8 + ifd_overhead + total_pixel_data
+
+    UINT32_MAX = 0xFFFFFFFF  # 4,294,967,295
+    if force_bigtiff is not None:
+        bigtiff = force_bigtiff
+    else:
+        bigtiff = estimated_file_size > UINT32_MAX
 
     header_size = 16 if bigtiff else 8
 
@@ -721,7 +735,8 @@ def write(data: np.ndarray, path: str, *,
           y_resolution: float | None = None,
           resolution_unit: int | None = None,
           gdal_metadata_xml: str | None = None,
-          extra_tags: list | None = None) -> None:
+          extra_tags: list | None = None,
+          bigtiff: bool | None = None) -> None:
     """Write a numpy array as a GeoTIFF or COG.
 
     Parameters
@@ -794,6 +809,7 @@ def write(data: np.ndarray, path: str, *,
         extra_tags=extra_tags,
         x_resolution=x_resolution, y_resolution=y_resolution,
         resolution_unit=resolution_unit,
+        force_bigtiff=bigtiff,
     )
 
     # Write to a temp file then atomically rename, so concurrent writes to

xrspatial/geotiff/tests/test_features.py

@@ -957,6 +957,39 @@ def test_bigtiff_read_write_round_trip(self, tmp_path):
         result, _ = read_to_array(path)
         np.testing.assert_array_equal(result, arr)
 
+    def test_force_bigtiff_via_public_api(self, tmp_path):
+        """bigtiff=True on write_geotiff forces BigTIFF even for small files."""
+        arr = np.arange(16, dtype=np.float32).reshape(4, 4)
+        path = str(tmp_path / 'forced_bigtiff.tif')
+        write_geotiff(arr, path, compression='none', bigtiff=True)
+
+        with open(path, 'rb') as f:
+            header = parse_header(f.read(16))
+        assert header.is_bigtiff
+
+        result = read_geotiff(path)
+        np.testing.assert_array_equal(result.values, arr)
+
+    def test_small_file_stays_classic(self, tmp_path):
+        """Small files default to classic TIFF (bigtiff=None auto-detects)."""
+        arr = np.arange(16, dtype=np.float32).reshape(4, 4)
+        path = str(tmp_path / 'classic.tif')
+        write_geotiff(arr, path, compression='none')
+
+        with open(path, 'rb') as f:
+            header = parse_header(f.read(16))
+        assert not header.is_bigtiff
+
+    def test_force_bigtiff_false_stays_classic(self, tmp_path):
+        """bigtiff=False forces classic TIFF."""
+        arr = np.arange(16, dtype=np.float32).reshape(4, 4)
+        path = str(tmp_path / 'forced_classic.tif')
+        write_geotiff(arr, path, compression='none', bigtiff=False)
+
+        with open(path, 'rb') as f:
+            header = parse_header(f.read(16))
+        assert not header.is_bigtiff
+
 
 # -----------------------------------------------------------------------
 # Sub-byte bit depths (1-bit, 4-bit, 12-bit)