Changeset 13483 for trunk/psLib/src/imageops/psImageInterpolate.c

Timestamp:

May 22, 2007, 4:55:01 PM (19 years ago)

Author:

Paul Price

Message:

Adding psImageInterpolateStatus, a status enum which is returned by psImageInterpolate to indicate the relative success. Relatively small API change should leave most implimentations unaffected.

File:

• trunk/psLib/src/imageops/psImageInterpolate.c (modified) (18 diffs)

trunk/psLib/src/imageops/psImageInterpolate.c

@@ -7 +7 @@
  *  @author Paul Price, IfA
  *
- *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-04-11 19:54:47 $
+ *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-05-23 02:55:01 $
  *
  *  Copyright 2004-2007 Institute for Astronomy, University of Hawaii
@@ -65 +65 @@
 
 // Interpolation engine for flat mode (nearest pixel)
-static inline bool interpolateFlat(double *imageValue, double *varianceValue, psMaskType *maskValue,
-                                   float x, float y, const psImageInterpolateOptions *options)
+static inline psImageInterpolateStatus interpolateFlat(double *imageValue, double *varianceValue,
+                                                       psMaskType *maskValue, float x, float y,
+                                                       const psImageInterpolateOptions *options)
 {
     // Parameters have been checked by psImageInterpolate()
@@ -87 +88 @@
             *maskValue = options->badMask;
         }
+
+        return PS_INTERPOLATE_STATUS_OFF;
     } else {
 
@@ -115 +118 @@
             psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Unrecognised type for image: %x",
                     options->image->type.type);
-            return false;
+            return PS_INTERPOLATE_STATUS_ERROR;
         }
 
@@ -122 +125 @@
         }
     }
-    return true;
+    return PS_INTERPOLATE_STATUS_GOOD;
 }
 
 // Interpolation engine using interpolation kernel
-static bool interpolateKernel(double *imageValue, double *varianceValue, psMaskType *maskValue,
-                               float x, float y, const psImageInterpolateOptions *options)
+static psImageInterpolateStatus interpolateKernel(double *imageValue, double *varianceValue,
+                                                  psMaskType *maskValue, float x, float y,
+                                                  const psImageInterpolateOptions *options)
 {
     // Parameters have been checked by psImageInterpolate()
@@ -171 +175 @@
             *maskValue = options->badMask;
         }
-        return true;
+        return PS_INTERPOLATE_STATUS_OFF;
     }
     double kernel[yNum][xNum];          // Interpolation kernel for straight interpolation
@@ -259 +263 @@
             psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Unrecognised type for image: %x",
                     image->type.type);
-            return false;
+            return PS_INTERPOLATE_STATUS_ERROR;
         }
     }
@@ -265 +269 @@
     // Check the mask value
     const psImage *mask = options->mask; // Image mask
+    psImageInterpolateStatus status = PS_INTERPOLATE_STATUS_GOOD; // Status of interpolation
     if (maskValue && mask) {
         *maskValue = 0;
@@ -285 +290 @@
             if (badContrib / totContrib >= options->poorFrac) {
                 *maskValue |= options->badMask;
+                status = PS_INTERPOLATE_STATUS_BAD;
             } else {
                 *maskValue |= options->poorMask;
+            status = PS_INTERPOLATE_STATUS_POOR;
             }
         }
@@ -321 +328 @@
             psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Unrecognised type for image: %x",
                     image->type.type);
-            return false;
-        }
-    }
-
-    return true;
+            return PS_INTERPOLATE_STATUS_ERROR;
+        }
+    }
+
+    return status;
 }
 
@@ -364 +371 @@
 
 // Interpolation engine for separable interpolation kernels (either for good reasons or for practical reasons)
-static bool interpolateSeparate(double *imageValue, double *varianceValue, psMaskType *maskValue,
-                               float x, float y, const psImageInterpolateOptions *options)
+static psImageInterpolateStatus interpolateSeparate(double *imageValue, double *varianceValue,
+                                               psMaskType *maskValue, float x, float y,
+                                               const psImageInterpolateOptions *options)
 {
     // Parameters have been checked by psImageInterpolate()
@@ -406 +414 @@
             *maskValue = options->badMask;
         }
-        return true;
+        return PS_INTERPOLATE_STATUS_OFF;
     }
 
@@ -477 +485 @@
             psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Unrecognised type for image: %x",
                     image->type.type);
-            return false;
+            return PS_INTERPOLATE_STATUS_ERROR;
         }
     }
@@ -483 +491 @@
     // Check the mask value
     const psImage *mask = options->mask; // Image mask
+    psImageInterpolateStatus status = PS_INTERPOLATE_STATUS_GOOD; // Status of interpolation
     if (maskValue && mask) {
         psMaskType maskVal = options->maskVal; // Mask value
@@ -509 +518 @@
             if (badContrib / totContrib >= options->poorFrac) {
                 *maskValue |= options->badMask;
+                status = PS_INTERPOLATE_STATUS_BAD;
             } else {
                 *maskValue |= options->poorMask;
+                status = PS_INTERPOLATE_STATUS_POOR;
             }
         }
@@ -547 +558 @@
             psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Unrecognised type for image: %x",
                     variance->type.type);
-            return false;
-        }
-    }
-
-    return true;
-}
-
-
-
-bool psImageInterpolate(double *imageValue, double *varianceValue, psMaskType *maskValue,
+            return PS_INTERPOLATE_STATUS_ERROR;
+        }
+    }
+
+    return status;
+}
+
+
+
+psImageInterpolateStatus psImageInterpolate(double *imageValue, double *varianceValue, psMaskType *maskValue,
                         float x, float y, const psImageInterpolateOptions *options)
 {
-    PS_ASSERT_PTR_NON_NULL(options, false);
+    PS_ASSERT_PTR_NON_NULL(options, PS_INTERPOLATE_STATUS_ERROR);
 
     const psImage *image = options->image; // Image to interpolate
@@ -565 +576 @@
     const psImage *variance = options->variance; // Variance to interpolate
 
-    PS_ASSERT_IMAGE_NON_NULL(image, false);
+    PS_ASSERT_IMAGE_NON_NULL(image, PS_INTERPOLATE_STATUS_ERROR);
     if (varianceValue && variance) {
-        PS_ASSERT_IMAGE_NON_NULL(variance, false);
-        PS_ASSERT_IMAGE_TYPE(variance, image->type.type, false);
-        PS_ASSERT_IMAGES_SIZE_EQUAL(variance, image, false);
+        PS_ASSERT_IMAGE_NON_NULL(variance, PS_INTERPOLATE_STATUS_ERROR);
+        PS_ASSERT_IMAGE_TYPE(variance, image->type.type, PS_INTERPOLATE_STATUS_ERROR);
+        PS_ASSERT_IMAGES_SIZE_EQUAL(variance, image, PS_INTERPOLATE_STATUS_ERROR);
     }
     if (maskValue && mask) {
-        PS_ASSERT_IMAGE_NON_NULL(mask, false);
-        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, false);
-        PS_ASSERT_IMAGES_SIZE_EQUAL(mask, image, false);
-    }
-
-    PS_ASSERT_FLOAT_LARGER_THAN_OR_EQUAL(options->poorFrac, 0.0, false);
+        PS_ASSERT_IMAGE_NON_NULL(mask, PS_INTERPOLATE_STATUS_ERROR);
+        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, PS_INTERPOLATE_STATUS_ERROR);
+        PS_ASSERT_IMAGES_SIZE_EQUAL(mask, image, PS_INTERPOLATE_STATUS_ERROR);
+    }
+
+    PS_ASSERT_FLOAT_LARGER_THAN_OR_EQUAL(options->poorFrac, 0.0, PS_INTERPOLATE_STATUS_ERROR);
 
     switch (options->mode) {
@@ -594 +605 @@
                 _("Specified interpolation method (%d) is not supported."),
                 options->mode);
-        return false;
+        return PS_INTERPOLATE_STATUS_ERROR;
     }
 
     psAbort("Should never reach here.");
-    return false;
+    return PS_INTERPOLATE_STATUS_ERROR;
 }