xarray-spatial 0.9.3__tar.gz → 0.9.4__tar.gz

{xarray_spatial-0.9.3 → xarray_spatial-0.9.4}/CHANGELOG.md

@@ -2,6 +2,27 @@
 -----------
 
 
+### Version 0.9.4 - 2026-03-30
+
+#### New features
+- Streaming TIFF write for dask inputs (#1084) (#1108)
+- Add dtype, compression_level, and VRT output to geotiff I/O (#1083) (#1085)
+
+#### Bug fixes and improvements
+- Use float64 in Jenks natural breaks internals (#1100) (#1101)
+- Fix multi-metric output mislabeling in glcm_texture (#1106) (#1107)
+- Fix inverted decay and off-by-one in bump spread (#1102) (#1103)
+- Propagate NaN from curve_number in curve_number_runoff (#1104) (#1105)
+- Fix target_elev contaminating horizon in dask viewshed distance sweep (#1098) (#1099)
+- Preserve float64 precision in convolve_2d (#1096) (#1097)
+- Fix SAVI formula: (1+L) was in denominator instead of numerator (#1094) (#1095)
+- Fix NaN handling in focal_stats CUDA kernels (#1092) (#1093)
+- Fix three accuracy bugs in zonal stats dask backend (#1090) (#1091)
+- Add longitude normalization to CUDA inverse projection kernels (#1089)
+- Fix three accuracy bugs in reproject resampling kernels (#1087)
+- Fix three accuracy bugs in open_geotiff/to_geotiff (#1081) (#1082)
+
+
 ### Version 0.9.3 - 2026-03-27
 
 #### New features

{xarray_spatial-0.9.3 → xarray_spatial-0.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xarray-spatial
-Version: 0.9.3
+Version: 0.9.4
 Summary: xarray-based spatial analysis tools
 Home-page: https://github.com/xarray-contrib/xarray-spatial
 Author: Xarray-Spatial Developers
@@ -231,6 +231,13 @@ to_geotiff(data, 'out.tif', gpu=True)                # force GPU compress
 to_geotiff(data, 'ortho.tif', compression='jpeg')    # JPEG for orthophotos
 write_vrt('mosaic.vrt', ['tile1.tif', 'tile2.tif'])  # generate VRT
 
+open_geotiff('dem.tif', dtype='float32')             # half memory
+open_geotiff('dem.tif', dtype='float32', chunks=512) # Dask + half memory
+to_geotiff(data, 'out.tif', compression_level=1)     # fast scratch write
+to_geotiff(data, 'out.tif', compression_level=22)    # max compression
+to_geotiff(dask_da, 'out.tif')                       # stream Dask to single TIFF
+to_geotiff(dask_da, 'mosaic.vrt')                    # stream Dask to VRT
+
 # Accessor methods
 da.xrs.to_geotiff('out.tif', compression='lzw')     # write from DataArray
 ds.xrs.open_geotiff('large_dem.tif')                 # read windowed to Dataset extent

{xarray_spatial-0.9.3 → xarray_spatial-0.9.4}/README.md

@@ -165,6 +165,13 @@ to_geotiff(data, 'out.tif', gpu=True)                # force GPU compress
 to_geotiff(data, 'ortho.tif', compression='jpeg')    # JPEG for orthophotos
 write_vrt('mosaic.vrt', ['tile1.tif', 'tile2.tif'])  # generate VRT
 
+open_geotiff('dem.tif', dtype='float32')             # half memory
+open_geotiff('dem.tif', dtype='float32', chunks=512) # Dask + half memory
+to_geotiff(data, 'out.tif', compression_level=1)     # fast scratch write
+to_geotiff(data, 'out.tif', compression_level=22)    # max compression
+to_geotiff(dask_da, 'out.tif')                       # stream Dask to single TIFF
+to_geotiff(dask_da, 'mosaic.vrt')                    # stream Dask to VRT
+
 # Accessor methods
 da.xrs.to_geotiff('out.tif', compression='lzw')     # write from DataArray
 ds.xrs.open_geotiff('large_dem.tif')                 # read windowed to Dataset extent

{xarray_spatial-0.9.3 → xarray_spatial-0.9.4}/xarray_spatial.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xarray-spatial
-Version: 0.9.3
+Version: 0.9.4
 Summary: xarray-based spatial analysis tools
 Home-page: https://github.com/xarray-contrib/xarray-spatial
 Author: Xarray-Spatial Developers
@@ -231,6 +231,13 @@ to_geotiff(data, 'out.tif', gpu=True)                # force GPU compress
 to_geotiff(data, 'ortho.tif', compression='jpeg')    # JPEG for orthophotos
 write_vrt('mosaic.vrt', ['tile1.tif', 'tile2.tif'])  # generate VRT
 
+open_geotiff('dem.tif', dtype='float32')             # half memory
+open_geotiff('dem.tif', dtype='float32', chunks=512) # Dask + half memory
+to_geotiff(data, 'out.tif', compression_level=1)     # fast scratch write
+to_geotiff(data, 'out.tif', compression_level=22)    # max compression
+to_geotiff(dask_da, 'out.tif')                       # stream Dask to single TIFF
+to_geotiff(dask_da, 'mosaic.vrt')                    # stream Dask to VRT
+
 # Accessor methods
 da.xrs.to_geotiff('out.tif', compression='lzw')     # write from DataArray
 ds.xrs.open_geotiff('large_dem.tif')                 # read windowed to Dataset extent

{xarray_spatial-0.9.3 → xarray_spatial-0.9.4}/xarray_spatial.egg-info/SOURCES.txt

@@ -109,8 +109,11 @@ xrspatial/geotiff/tests/__init__.py
 xrspatial/geotiff/tests/bench_vs_rioxarray.py
 xrspatial/geotiff/tests/conftest.py
 xrspatial/geotiff/tests/test_accessor_io.py
+xrspatial/geotiff/tests/test_accuracy_1081.py
 xrspatial/geotiff/tests/test_cog.py
 xrspatial/geotiff/tests/test_compression.py
+xrspatial/geotiff/tests/test_compression_level.py
+xrspatial/geotiff/tests/test_dtype_read.py
 xrspatial/geotiff/tests/test_edge_cases.py
 xrspatial/geotiff/tests/test_features.py
 xrspatial/geotiff/tests/test_geotags.py
@@ -120,6 +123,8 @@ xrspatial/geotiff/tests/test_jpeg2000.py
 xrspatial/geotiff/tests/test_lerc.py
 xrspatial/geotiff/tests/test_lz4.py
 xrspatial/geotiff/tests/test_reader.py
+xrspatial/geotiff/tests/test_streaming_write.py
+xrspatial/geotiff/tests/test_vrt_write.py
 xrspatial/geotiff/tests/test_writer.py
 xrspatial/gpu_rtx/__init__.py
 xrspatial/gpu_rtx/cuda_utils.py
@@ -257,6 +262,7 @@ xrspatial/tests/test_fused_overlap.py
 xrspatial/tests/test_geodesic_aspect.py
 xrspatial/tests/test_geodesic_slope.py
 xrspatial/tests/test_glcm.py
+xrspatial/tests/test_glcm_metric_order.py
 xrspatial/tests/test_hillshade.py
 xrspatial/tests/test_interpolation.py
 xrspatial/tests/test_lite_crs.py

{xarray_spatial-0.9.3 → xarray_spatial-0.9.4}/xrspatial/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.9.3'
-__version_tuple__ = version_tuple = (0, 9, 3)
+__version__ = version = '0.9.4'
+__version_tuple__ = version_tuple = (0, 9, 4)
 
-__commit_id__ = commit_id = 'gb6a15e5b6'
+__commit_id__ = commit_id = 'g0ad1feb6e'

{xarray_spatial-0.9.3 → xarray_spatial-0.9.4}/xrspatial/bump.py

@@ -29,11 +29,11 @@ def _finish_bump(width, height, locs, heights, spread):
         z = heights[i]
         out[y, x] = out[y, x] + z
         if s > 0:
-            for nx in range(max(x - spread, 0), min(x + spread, width)):
-                for ny in range(max(y - spread, 0), min(y + spread, height)):
+            for nx in range(max(x - spread, 0), min(x + spread + 1, width)):
+                for ny in range(max(y - spread, 0), min(y + spread + 1, height)):
                     d2 = (nx - x) * (nx - x) + (ny - y) * (ny - y)
                     if d2 <= s:
-                        out[ny, nx] = out[ny, nx] + (out[y, x] * (d2 / s))
+                        out[ny, nx] = out[ny, nx] + (out[y, x] * ((s - d2) / s))
     return out
 
 

{xarray_spatial-0.9.3 → xarray_spatial-0.9.4}/xrspatial/classify.py

@@ -547,12 +547,12 @@ def quantile(agg: xr.DataArray,
 def _run_numpy_jenks_matrices(data, n_classes):
     n_data = data.shape[0]
     lower_class_limits = np.zeros(
-        (n_data + 1, n_classes + 1), dtype=np.float32
+        (n_data + 1, n_classes + 1), dtype=np.float64
     )
     lower_class_limits[1, 1:n_classes + 1] = 1.0
 
     var_combinations = np.zeros(
-        (n_data + 1, n_classes + 1), dtype=np.float32
+        (n_data + 1, n_classes + 1), dtype=np.float64
     )
     var_combinations[2:n_data + 1, 1:n_classes + 1] = np.inf
 
@@ -568,7 +568,7 @@ def _run_numpy_jenks_matrices(data, n_classes):
             lower_class_limit = l - m
             i4 = lower_class_limit - 1
 
-            val = np.float32(data[i4])
+            val = data[i4]
 
             # here we're estimating variance for each potential classing
             # of the data, for each potential number of classes. `w`
@@ -610,7 +610,7 @@ def _run_jenks(data, n_classes):
     lower_class_limits, _ = _run_numpy_jenks_matrices(data, n_classes)
 
     k = data.shape[0]
-    kclass = np.zeros(n_classes + 1, dtype=np.float32)
+    kclass = np.zeros(n_classes + 1, dtype=np.float64)
     kclass[0] = data[0]
     kclass[-1] = data[-1]
     count_num = n_classes

{xarray_spatial-0.9.3 → xarray_spatial-0.9.4}/xrspatial/convolution.py

@@ -17,6 +17,13 @@ except ImportError:
         ndarray = False
 
 
+def _promote_float(dtype):
+    """Return at least float32; preserve float64."""
+    if np.issubdtype(dtype, np.floating):
+        return dtype
+    return np.float32
+
+
 DEFAULT_UNIT = 'meter'
 METER = 1
 FOOT = 0.3048
@@ -286,8 +293,7 @@ def custom_kernel(kernel):
 @jit(nopython=True, nogil=True)
 def _convolve_2d_numpy(data, kernel):
     # apply kernel to data image.
-    # TODO: handle nan
-    data = data.astype(np.float32)
+    # Caller must ensure data is a float type (float32 or float64).
     nx = data.shape[0]
     ny = data.shape[1]
     nkx = kernel.shape[0]
@@ -295,7 +301,7 @@ def _convolve_2d_numpy(data, kernel):
     wkx = nkx // 2
     wky = nky // 2
 
-    out = np.zeros(data.shape, dtype=np.float32)
+    out = np.empty_like(data)
     out[:] = np.nan
     for i in prange(wkx, nx-wkx):
         iimin = max(i - wkx, 0)
@@ -315,6 +321,7 @@ def _convolve_2d_numpy(data, kernel):
 
 
 def _convolve_2d_numpy_boundary(data, kernel, boundary='nan'):
+    data = data.astype(_promote_float(data.dtype))
     if boundary == 'nan':
         return _convolve_2d_numpy(data, kernel)
     pad_h = kernel.shape[0] // 2
@@ -329,7 +336,7 @@ def _convolve_2d_numpy_boundary(data, kernel, boundary='nan'):
 
 
 def _convolve_2d_dask_numpy(data, kernel, boundary='nan'):
-    data = data.astype(np.float32)
+    data = data.astype(_promote_float(data.dtype))
     pad_h = kernel.shape[0] // 2
     pad_w = kernel.shape[1] // 2
     _func = partial(_convolve_2d_numpy, kernel=kernel)
@@ -393,8 +400,9 @@ def _convolve_2d_cupy(data, kernel, boundary='nan'):
         c1 = -pad_w if pad_w else None
         return result[r0:r1, c0:c1]
 
-    data = data.astype(cupy.float32)
-    out = cupy.empty(data.shape, dtype='f4')
+    fdtype = _promote_float(data.dtype)
+    data = data.astype(fdtype)
+    out = cupy.empty(data.shape, dtype=fdtype)
     out[:, :] = cupy.nan
     griddim, blockdim = cuda_args(data.shape)
     _convolve_2d_cuda[griddim, blockdim](data, kernel, cupy.asarray(out))
@@ -402,7 +410,7 @@ def _convolve_2d_cupy(data, kernel, boundary='nan'):
 
 
 def _convolve_2d_dask_cupy(data, kernel, boundary='nan'):
-    data = data.astype(cupy.float32)
+    data = data.astype(_promote_float(data.dtype))
     pad_h = kernel.shape[0] // 2
     pad_w = kernel.shape[1] // 2
     _func = partial(_convolve_2d_cupy, kernel=kernel)

{xarray_spatial-0.9.3 → xarray_spatial-0.9.4}/xrspatial/flood.py

@@ -328,8 +328,8 @@ def _cn_runoff_numpy(p, cn):
     s = (25400.0 / cn) - 254.0
     ia = 0.2 * s
     q = np.where(p > ia, (p - ia) ** 2 / (p + 0.8 * s), 0.0)
-    # propagate NaN from rainfall
-    q = np.where(np.isnan(p), np.nan, q)
+    # propagate NaN from rainfall or curve number
+    q = np.where(np.isnan(p) | np.isnan(cn), np.nan, q)
     return q
 
 
@@ -340,7 +340,7 @@ def _cn_runoff_cupy(p, cn):
     s = (25400.0 / cn) - 254.0
     ia = 0.2 * s
     q = cp.where(p > ia, (p - ia) ** 2 / (p + 0.8 * s), 0.0)
-    q = cp.where(cp.isnan(p), cp.nan, q)
+    q = cp.where(cp.isnan(p) | cp.isnan(cn), cp.nan, q)
     return q
 
 
@@ -349,7 +349,7 @@ def _cn_runoff_dask(p, cn):
     s = (25400.0 / cn) - 254.0
     ia = 0.2 * s
     q = _da.where(p > ia, (p - ia) ** 2 / (p + 0.8 * s), 0.0)
-    q = _da.where(_da.isnan(p), np.nan, q)
+    q = _da.where(_da.isnan(p) | _da.isnan(cn), np.nan, q)
     return q
 
 

{xarray_spatial-0.9.3 → xarray_spatial-0.9.4}/xrspatial/focal.py

@@ -608,13 +608,13 @@ def _focal_min_cuda(data, kernel, out):
 
             if 0 <= ii < rows and 0 <= jj < cols:
                 v = data[ii, jj]
+                if v != v:  # NaN check
+                    continue
                 if (not found) or (v < m):
                     m = v
                     found = True
 
-    # With your mask containing the center, found should be True.
-    # But keep a safe fallback anyway.
-    out[i, j] = m if found else data[i, j]
+    out[i, j] = m if found else math.nan
 
 
 @cuda.jit
@@ -636,20 +636,20 @@ def _focal_max_cuda(data, kernel, out):
         for h in range(kernel.shape[1]):
             w = kernel[k, h]
             if w == 0:
-                continue  # mask says "ignore this neighbor"
+                continue
 
             ii = i + k - dr
             jj = j + h - dc
 
             if 0 <= ii < rows and 0 <= jj < cols:
                 v = data[ii, jj]
+                if v != v:  # NaN check
+                    continue
                 if (not found) or (v > m):
                     m = v
                     found = True
 
-    # With your mask containing the center (1), found should always be True.
-    # But keep this for safety.
-    out[i, j] = m if found else data[i, j]
+    out[i, j] = m if found else math.nan
 
 
 def _focal_range_cupy(data, kernel):
@@ -684,6 +684,8 @@ def _focal_range_cuda(data, kernel, out):
 
             if 0 <= ii < rows and 0 <= jj < cols:
                 v = data[ii, jj]
+                if v != v:  # NaN check
+                    continue
                 if not found:
                     mx = v
                     mn = v
@@ -694,7 +696,7 @@ def _focal_range_cuda(data, kernel, out):
                     if v < mn:
                         mn = v
 
-    out[i, j] = (mx - mn) if found else 0.0
+    out[i, j] = (mx - mn) if found else math.nan
 
 
 @cuda.jit
@@ -716,29 +718,29 @@ def _focal_std_cuda(data, kernel, out):
         for h in range(kernel.shape[1]):
             w = kernel[k, h]
             if w == 0:
-                continue  # mask says ignore
+                continue
 
             ii = i + k - dr
             jj = j + h - dc
 
             if 0 <= ii < rows and 0 <= jj < cols:
                 x = data[ii, jj]
+                if x != x:  # NaN check
+                    continue
                 w_sum += w
                 sum_wx += w * x
                 sum_wx2 += w * x * x
 
-    # With your mask including the center, w_sum should be > 0. Guard anyway.
     if w_sum > 0.0:
         mean = sum_wx / w_sum
         var = (sum_wx2 / w_sum) - (mean * mean)
 
-        # Numerical safety (tiny negative due to floating point)
         if var < 0.0:
             var = 0.0
 
         out[i, j] = math.sqrt(var)
     else:
-        out[i, j] = 0.0
+        out[i, j] = math.nan
 
 
 @cuda.jit
@@ -760,13 +762,15 @@ def _focal_var_cuda(data, kernel, out):
         for h in range(kernel.shape[1]):
             w = kernel[k, h]
             if w == 0:
-                continue  # mask says ignore
+                continue
 
             ii = i + k - dr
             jj = j + h - dc
 
             if 0 <= ii < rows and 0 <= jj < cols:
                 x = data[ii, jj]
+                if x != x:  # NaN check
+                    continue
                 w_sum += w
                 sum_wx += w * x
                 sum_wx2 += w * x * x
@@ -775,13 +779,12 @@ def _focal_var_cuda(data, kernel, out):
         mean = sum_wx / w_sum
         var = (sum_wx2 / w_sum) - (mean * mean)
 
-        # numerical guard for tiny negative due to float rounding
         if var < 0.0:
             var = 0.0
 
         out[i, j] = var
     else:
-        out[i, j] = 0.0
+        out[i, j] = math.nan
 
 
 @cuda.jit
@@ -856,15 +859,18 @@ def _focal_sum_cuda(data, kernel, out):
         for h in range(kernel.shape[1]):
             w = kernel[k, h]
             if w == 0:
-                continue  # mask says ignore
+                continue
 
             ii = i + k - dr
             jj = j + h - dc
 
             if 0 <= ii < rows and 0 <= jj < cols:
-                s += w * data[ii, jj]
+                v = data[ii, jj]
+                if v != v:  # NaN check
+                    continue
+                s += w * v
 
-    out[i, j] = s
+    out[i, j] = s  # nansum: 0 when all NaN (matches numpy)
 
 
 def _focal_stats_func_cupy(data, kernel, func=_focal_max_cuda):
@@ -894,21 +900,22 @@ def _focal_mean_cuda(data, kernel, out):
         for h in range(kernel.shape[1]):
             w = kernel[k, h]
             if w == 0:
-                continue  # mask says ignore
+                continue
 
             ii = i + k - dr
             jj = j + h - dc
 
             if 0 <= ii < rows and 0 <= jj < cols:
-                s += w * data[ii, jj]
+                v = data[ii, jj]
+                if v != v:  # NaN check
+                    continue
+                s += w * v
                 w_sum += w
 
-    # With your mask including the center, w_sum should be > 0.
-    # Guard anyway to avoid divide-by-zero.
     if w_sum > 0.0:
         out[i, j] = s / w_sum
     else:
-        out[i, j] = data[i, j]
+        out[i, j] = math.nan
 
 
 def _focal_stats_cupy(agg, kernel, stats_funcs):