Index: trunk/psModules/src/imcombine/pmSubtractionMatch.c
===================================================================
--- trunk/psModules/src/imcombine/pmSubtractionMatch.c	(revision 18962)
+++ trunk/psModules/src/imcombine/pmSubtractionMatch.c	(revision 19164)
@@ -121,8 +121,8 @@
                         int inner, int ringsOrder, int binning, float penalty,
                         bool optimum, const psVector *optFWHMs, int optOrder, float optThreshold,
-                        int iter, float rej, psMaskType maskBad, psMaskType maskBlank,
-                        float badFrac, pmSubtractionMode mode)
+                        int iter, float rej, psMaskType maskVal, psMaskType maskBad, psMaskType maskPoor,
+                        float poorFrac, float badFrac, pmSubtractionMode subMode)
 {
-    if (mode != PM_SUBTRACTION_MODE_2) {
+    if (subMode != PM_SUBTRACTION_MODE_2) {
         PM_ASSERT_READOUT_NON_NULL(conv1, false);
         if (conv1->image) {
@@ -139,5 +139,5 @@
         }
     }
-    if (mode != PM_SUBTRACTION_MODE_1) {
+    if (subMode != PM_SUBTRACTION_MODE_1) {
         PM_ASSERT_READOUT_NON_NULL(conv2, false);
         if (conv2->image) {
@@ -190,6 +190,9 @@
     PS_ASSERT_INT_POSITIVE(iter, false);
     PS_ASSERT_FLOAT_LARGER_THAN(rej, 0.0, false);
+    // Don't care about maskVal
     // Don't care about maskBad
-    // Don't care about maskBlank
+    // Don't care about maskPoor
+    PS_ASSERT_FLOAT_LARGER_THAN(poorFrac, 0.0, NULL);
+    PS_ASSERT_FLOAT_LESS_THAN_OR_EQUAL(poorFrac, 1.0, NULL);
     if (isfinite(badFrac)) {
         PS_ASSERT_FLOAT_LARGER_THAN(badFrac, 0.0, NULL);
@@ -230,5 +233,5 @@
     memCheck("start");
 
-    subMask = pmSubtractionMask(ro1->mask, ro2 ? ro2->mask : NULL, maskBad, size, footprint,
+    subMask = pmSubtractionMask(ro1->mask, ro2 ? ro2->mask : NULL, maskVal, size, footprint,
                                 badFrac, useFFT);
     if (!subMask) {
@@ -267,8 +270,8 @@
             if (sources) {
                 stamps = pmSubtractionStampsSetFromSources(sources, subMask, region, footprint,
-                                                           stampSpacing, mode);
+                                                           stampSpacing, subMode);
             } else if (stampsName && strlen(stampsName) > 0) {
                 stamps = pmSubtractionStampsSetFromFile(stampsName, ro1->image, subMask, region, footprint,
-                                                        stampSpacing, mode);
+                                                        stampSpacing, subMode);
             }
 
@@ -276,14 +279,14 @@
             // doesn't matter.
             if (!getStamps(&stamps, ro1, ro2, subMask, weight, NULL, threshold, stampSpacing,
-                           size, footprint, mode)) {
+                           size, footprint, subMode)) {
                 goto MATCH_ERROR;
             }
 
-            if (mode == PM_SUBTRACTION_MODE_UNSURE) {
+            if (subMode == PM_SUBTRACTION_MODE_UNSURE) {
                 // Get backgrounds
                 psStats *bgStats = psStatsAlloc(BG_STAT); // Statistics for background
                 psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); // Random number generator
                 psVector *buffer = NULL;// Buffer for stats
-                if (!psImageBackground(bgStats, &buffer, ro1->image, ro1->mask, maskBad, rng)) {
+                if (!psImageBackground(bgStats, &buffer, ro1->image, ro1->mask, maskVal, rng)) {
                     psError(PS_ERR_UNKNOWN, false, "Unable to measure background of image 1.");
                     psFree(bgStats);
@@ -293,5 +296,5 @@
                 }
                 float bg1 = psStatsGetValue(bgStats, BG_STAT); // Background for image 1
-                if (!psImageBackground(bgStats, &buffer, ro2->image, ro2->mask, maskBad, rng)) {
+                if (!psImageBackground(bgStats, &buffer, ro2->image, ro2->mask, maskVal, rng)) {
                     psError(PS_ERR_UNKNOWN, false, "Unable to measure background of image 2.");
                     psFree(bgStats);
@@ -317,5 +320,5 @@
                     goto MATCH_ERROR;
                 }
-                mode = newMode;
+                subMode = newMode;
             }
 
@@ -323,5 +326,5 @@
             if (optimum && (type == PM_SUBTRACTION_KERNEL_ISIS || type == PM_SUBTRACTION_KERNEL_GUNK)) {
                 kernels = pmSubtractionKernelsOptimumISIS(type, size, inner, spatialOrder, optFWHMs, optOrder,
-                                                          stamps, footprint, optThreshold, penalty, mode);
+                                                          stamps, footprint, optThreshold, penalty, subMode);
                 if (!kernels) {
                     psErrorClear();
@@ -332,5 +335,5 @@
                 // Not an ISIS/GUNK kernel, or the optimum kernel search failed
                 kernels = pmSubtractionKernelsGenerate(type, size, spatialOrder, isisWidths, isisOrders,
-                                                       inner, binning, ringsOrder, penalty, mode);
+                                                       inner, binning, ringsOrder, penalty, subMode);
             }
 
@@ -344,18 +347,18 @@
                 }
 
-                if (mode == PM_SUBTRACTION_MODE_1 || mode == PM_SUBTRACTION_MODE_DUAL) {
+                if (subMode == PM_SUBTRACTION_MODE_1 || subMode == PM_SUBTRACTION_MODE_DUAL) {
                     psMetadataAddPtr(conv1->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_KERNEL,
                                      PS_DATA_UNKNOWN | PS_META_DUPLICATE_OK, "Subtraction kernels", kernels);
                     psMetadataAddS32(conv1->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_MODE,
-                                     PS_META_DUPLICATE_OK, "Subtraction kernels", mode);
+                                     PS_META_DUPLICATE_OK, "Subtraction kernels", subMode);
                     psMetadataAddPtr(conv1->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_REGION,
                                      PS_DATA_REGION | PS_META_DUPLICATE_OK,
                                      "Region over which subtraction was performed", subRegion);
                 }
-                if (mode == PM_SUBTRACTION_MODE_2 || mode == PM_SUBTRACTION_MODE_DUAL) {
+                if (subMode == PM_SUBTRACTION_MODE_2 || subMode == PM_SUBTRACTION_MODE_DUAL) {
                     psMetadataAddPtr(conv2->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_KERNEL,
                                      PS_DATA_UNKNOWN | PS_META_DUPLICATE_OK, "Subtraction kernels", kernels);
                     psMetadataAddS32(conv2->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_MODE,
-                                     PS_META_DUPLICATE_OK, "Subtraction kernels", mode);
+                                     PS_META_DUPLICATE_OK, "Subtraction kernels", subMode);
                     psMetadataAddPtr(conv2->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_REGION,
                                      PS_DATA_REGION | PS_META_DUPLICATE_OK,
@@ -374,5 +377,5 @@
 
                 if (!getStamps(&stamps, ro1, ro2, subMask, weight, region, threshold, stampSpacing,
-                               size, footprint, mode)) {
+                               size, footprint, subMode)) {
                     goto MATCH_ERROR;
                 }
@@ -434,5 +437,5 @@
             stamps = NULL;
 
-            if (mode == PM_SUBTRACTION_MODE_1 || mode == PM_SUBTRACTION_MODE_DUAL) {
+            if (subMode == PM_SUBTRACTION_MODE_1 || subMode == PM_SUBTRACTION_MODE_DUAL) {
                 psMetadataAddS32(conv1->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_STAMPS_NUM,
                                  PS_META_DUPLICATE_OK, "Number of good stamps", numStamps);
@@ -440,5 +443,5 @@
                                  PS_META_DUPLICATE_OK, "RMS deviation of stamps", rmsStamps);
             }
-            if (mode == PM_SUBTRACTION_MODE_2 || mode == PM_SUBTRACTION_MODE_DUAL) {
+            if (subMode == PM_SUBTRACTION_MODE_2 || subMode == PM_SUBTRACTION_MODE_DUAL) {
                 psMetadataAddS32(conv2->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_STAMPS_NUM,
                                  PS_META_DUPLICATE_OK, "Number of good stamps", numStamps);
@@ -454,7 +457,7 @@
                 int fullSize = 2 * size + 1 + 1;    // Full size of kernel
                 int imageSize = (2 * KERNEL_MOSAIC + 1) * fullSize;
-                psImage *convKernels = psImageAlloc((mode == PM_SUBTRACTION_MODE_DUAL ? 2 : 1) *
+                psImage *convKernels = psImageAlloc((subMode == PM_SUBTRACTION_MODE_DUAL ? 2 : 1) *
                                                     imageSize - 1 +
-                                                    (mode == PM_SUBTRACTION_MODE_DUAL ? 4 : 0),
+                                                    (subMode == PM_SUBTRACTION_MODE_DUAL ? 4 : 0),
                                                     imageSize - 1, PS_TYPE_F32);
                 psImageInit(convKernels, NAN);
@@ -479,5 +482,5 @@
                         psFree(kernel);
 
-                        if (mode == PM_SUBTRACTION_MODE_DUAL) {
+                        if (subMode == PM_SUBTRACTION_MODE_DUAL) {
                             kernel = pmSubtractionKernelImage(kernels, (float)i / (float)KERNEL_MOSAIC,
                                                               (float)j / (float)KERNEL_MOSAIC,
@@ -534,6 +537,6 @@
 
             psTrace("psModules.imcombine", 2, "Convolving...\n");
-            if (!pmSubtractionConvolve(conv1, conv2, ro1, ro2, subMask, maskBlank, region, kernels,
-                                       true, useFFT)) {
+            if (!pmSubtractionConvolve(conv1, conv2, ro1, ro2, subMask, maskBad, maskPoor, poorFrac,
+                                       region, kernels, true, useFFT)) {
                 psError(PS_ERR_UNKNOWN, false, "Unable to convolve image.");
                 goto MATCH_ERROR;
@@ -541,5 +544,5 @@
 
             // Set the variance factors
-            switch (mode) {
+            switch (subMode) {
               case PM_SUBTRACTION_MODE_1: {
                   recordVarianceFactor(conv1, pmSubtractionVarianceFactor(kernels, 0.5, 0.5, false),
@@ -565,5 +568,5 @@
 
             // There is data in the readout now
-            if (mode == PM_SUBTRACTION_MODE_1 || mode == PM_SUBTRACTION_MODE_DUAL) {
+            if (subMode == PM_SUBTRACTION_MODE_1 || subMode == PM_SUBTRACTION_MODE_DUAL) {
                 conv1->data_exists = true;
                 if (conv1->parent) {
@@ -572,5 +575,5 @@
                 }
             }
-            if (mode == PM_SUBTRACTION_MODE_2 || mode == PM_SUBTRACTION_MODE_DUAL) {
+            if (subMode == PM_SUBTRACTION_MODE_2 || subMode == PM_SUBTRACTION_MODE_DUAL) {
                 conv2->data_exists = true;
                 if (conv2->parent) {
@@ -590,5 +593,5 @@
     weight = NULL;
 
-    if (!pmSubtractionBorder(conv1->image, conv1->weight, conv1->mask, size, maskBlank)) {
+    if (!pmSubtractionBorder(conv1->image, conv1->weight, conv1->mask, size, maskBad)) {
         psError(PS_ERR_UNKNOWN, false, "Unable to set border of convolved image.");
         goto MATCH_ERROR;
@@ -600,5 +603,5 @@
 #ifdef TESTING
     {
-        if (mode == PM_SUBTRACTION_MODE_1 || mode == PM_SUBTRACTION_MODE_DUAL) {
+        if (subMode == PM_SUBTRACTION_MODE_1 || subMode == PM_SUBTRACTION_MODE_DUAL) {
             psFits *fits = psFitsOpen("convolved1.fits", "w");
             psFitsWriteImage(fits, NULL, conv1->image, 0, NULL);
@@ -606,5 +609,5 @@
         }
 
-        if (mode == PM_SUBTRACTION_MODE_2 || mode == PM_SUBTRACTION_MODE_DUAL) {
+        if (subMode == PM_SUBTRACTION_MODE_2 || subMode == PM_SUBTRACTION_MODE_DUAL) {
             psFits *fits = psFitsOpen("convolved2.fits", "w");
             psFitsWriteImage(fits, NULL, conv2->image, 0, NULL);