Warper: add a NODATA_VALUES_PCT_THRESHOLD warping option

This is similar to the EXCLUDED_VALUES_PCT_THRESHOLD option introduced
in #9631, but here this controls the
minimum amount of transparent/invalid/nodata source pixels to cause the
target pixels to not be set.
Only used currently for average resampling.

alg/gdalwarper.cpp

@@ -1265,7 +1265,17 @@ CPLErr GDALWarpDstAlphaMasker(void *pMaskFuncArg, int nBandCount,
  * <li>EXCLUDED_VALUES_PCT_THRESHOLD=[0-100]: (GDAL >= 3.9) Minimum percentage
  * of source pixels that must be set at one of the EXCLUDED_VALUES to cause
  * the excluded value, that is in majority among source pixels, to be used as the
- * target pixel value. Default value is 50 (%)</li>
+ * target pixel value. Default value is 50 (%).
+ * Only taken into account by Average currently.</li>
+ *
+ * <li>NODATA_VALUES_PCT_THRESHOLD=[0-100]: (GDAL >= 3.9) Minimum percentage
+ * of source pixels that must be at nodata (or alpha=0 or any other way to express
+ * transparent pixel) to cause the target pixel value to not be set. Default
+ * value is 100 (%), which means that a target pixel is not set only if all
+ * contributing source pixels are not set.
+ * Note that NODATA_VALUES_PCT_THRESHOLD is taken into account before
+ * EXCLUDED_VALUES_PCT_THRESHOLD.
+ * Only taken into account by Average currently.</li>
  *
  * </ul>
  */

alg/gdalwarpkernel.cpp

@@ -6584,6 +6584,10 @@ static void GWKAverageOrModeThread(void *pData)
         CPLAtof(CSLFetchNameValueDef(poWK->papszWarpOptions,
                                      "EXCLUDED_VALUES_PCT_THRESHOLD", "50")) /
         100.0;
+    const double dfNodataValuesThreshold =
+        CPLAtof(CSLFetchNameValueDef(poWK->papszWarpOptions,
+                                     "NODATA_VALUES_PCT_THRESHOLD", "100")) /
+        100.0;
 
     const int nXMargin =
         2 * std::max(1, static_cast<int>(std::ceil(1. / poWK->dfXScale)));
@@ -6743,7 +6747,8 @@ static void GWKAverageOrModeThread(void *pData)
             // Special Average mode where we process all bands together,
             // to avoid averaging tuples that match an entry of m_aadfExcludedValues
             if (nAlgo == GWKAOM_Average &&
-                !poWK->m_aadfExcludedValues.empty() &&
+                (!poWK->m_aadfExcludedValues.empty() ||
+                 dfNodataValuesThreshold < 1 - EPS) &&
                 !poWK->bApplyVerticalShift && !bIsComplex)
             {
                 double dfTotalWeightInvalid = 0.0;
@@ -6767,17 +6772,18 @@ static void GWKAverageOrModeThread(void *pData)
                                 (iSrcX % nSrcXSize) +
                                 static_cast<GPtrDiff_t>(iSrcY) * nSrcXSize;
 
+                        const double dfWeight =
+                            COMPUTE_WEIGHT(iSrcX, dfWeightY);
+                        if (dfWeight <= 0)
+                            continue;
+
                         if (poWK->panUnifiedSrcValid != nullptr &&
                             !CPLMaskGet(poWK->panUnifiedSrcValid, iSrcOffset))
                         {
+                            dfTotalWeightInvalid += dfWeight;
                             continue;
                         }
 
-                        const double dfWeight =
-                            COMPUTE_WEIGHT(iSrcX, dfWeightY);
-                        if (dfWeight <= 0)
-                            continue;
-
                         bool bAllValid = true;
                         for (int iBand = 0; iBand < poWK->nBands; iBand++)
                         {
@@ -6830,9 +6836,15 @@ static void GWKAverageOrModeThread(void *pData)
                 const double dfTotalWeight = dfTotalWeightInvalid +
                                              dfTotalWeightExcluded +
                                              dfTotalWeightRegular;
-                if (dfTotalWeightExcluded > 0 &&
-                    dfTotalWeightExcluded >=
-                        dfExcludedValuesThreshold * dfTotalWeight)
+                if (dfTotalWeightInvalid > 0 &&
+                    dfTotalWeightInvalid >=
+                        dfNodataValuesThreshold * dfTotalWeight)
+                {
+                    // Do nothing. Let bHasFoundDensity to false.
+                }
+                else if (dfTotalWeightExcluded > 0 &&
+                         dfTotalWeightExcluded >=
+                             dfExcludedValuesThreshold * dfTotalWeight)
                 {
                     // Find the most represented excluded value tuple
                     size_t iExcludedValue = 0;

autotest/alg/warp.py

@@ -1815,3 +1815,41 @@ def test_warp_average_excluded_values():
         (11 + 21 + 31 + 41) // 4,
         (12 + 22 + 32 + 42) // 4,
     )
+
+
+###############################################################################
+# Test NODATA_VALUES_PCT_THRESHOLD warping option with average resampling
+
+
+def test_warp_average_NODATA_VALUES_PCT_THRESHOLD():
+
+    src_ds = gdal.GetDriverByName("MEM").Create("", 2, 2, 1, gdal.GDT_Byte)
+    src_ds.GetRasterBand(1).WriteRaster(
+        0, 0, 2, 2, struct.pack("B" * 4, 10, 20, 30, 40)
+    )
+    src_ds.SetGeoTransform([1, 1, 0, 1, 0, 1])
+    src_ds.GetRasterBand(1).SetNoDataValue(20)
+
+    out_ds = gdal.Warp("", src_ds, options="-of MEM -ts 1 1 -r average")
+    assert struct.unpack("B", out_ds.ReadRaster())[0] == round((10 + 30 + 40) / 3)
+
+    out_ds = gdal.Warp(
+        "",
+        src_ds,
+        options="-of MEM -ts 1 1 -r average -wo NODATA_VALUES_PCT_THRESHOLD=80",
+    )
+    assert struct.unpack("B", out_ds.ReadRaster())[0] == round((10 + 30 + 40) / 3)
+
+    out_ds = gdal.Warp(
+        "",
+        src_ds,
+        options="-of MEM -ts 1 1 -r average -wo NODATA_VALUES_PCT_THRESHOLD=30",
+    )
+    assert struct.unpack("B", out_ds.ReadRaster())[0] == round((10 + 30 + 40) / 3)
+
+    out_ds = gdal.Warp(
+        "",
+        src_ds,
+        options="-of MEM -ts 1 1 -r average -wo NODATA_VALUES_PCT_THRESHOLD=25",
+    )
+    assert struct.unpack("B", out_ds.ReadRaster())[0] == 20