Changeset 16141 for branches/pap_branch_080117/psLib/src/fits/psFitsScale.c

Timestamp:

Jan 18, 2008, 3:04:13 PM (19 years ago)

Author:

Paul Price

Message:

Moving all options on FITS I/O into an additional structure, psFitsOptions. The idea is that this can be carried around independently of the FITS structure, which is only created when opening a file.

File:

• branches/pap_branch_080117/psLib/src/fits/psFitsScale.c (modified) (18 diffs)

branches/pap_branch_080117/psLib/src/fits/psFitsScale.c

@@ -5 +5 @@
 #include <stdio.h>
 #include <assert.h>
+#include <string.h>
 
 #include "psAbort.h"
@@ -21 +22 @@
 
 // Remember:
-// TRUE(MEMORY) = BZERO + BSCALE * FITS(DISK)
+// TRUE(i.e., value in memory) = BZERO + BSCALE * FITS(i.e., value on disk)
 
 
@@ -36 +37 @@
                        double *bzero, // Zero point, to return
                        const psImage *image, // Image to scale
-                       const psFits *fits // FITS options
+                       const psFitsOptions *options // FITS options
     )
 {
@@ -42 +43 @@
     assert(bzero);
     assert(image);
-    assert(fits);
-
-    double range = pow(2.0, fits->bitpix); // Range of values for target BITPIX
+    assert(options);
+
+    double range = pow(2.0, options->bitpix); // Range of values for target BITPIX
     double min = INFINITY, max = -INFINITY; // Minimum and maximum values
     int numCols = image->numCols, numRows = image->numRows; // Size of image
@@ -96 +97 @@
                        double *bzero, // Zero point, to return
                        const psImage *image, // Image to scale
-                       const psFits *fits // FITS options
+                       const psFitsOptions *options // FITS options
     )
 {
@@ -102 +103 @@
     assert(bzero);
     assert(image);
-    assert(fits);
-
-    double mean = fits->mean, stdev = fits->stdev; // Mean and standard deviation
+    assert(options);
+
+    double mean = options->mean, stdev = options->stdev; // Mean and standard deviation
     if (!isfinite(mean) || !isfinite(stdev)) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
@@ -112 +113 @@
     }
 
-    long range = 1 << fits->stdevBits;  // Range of values to carry standard deviation
+    long range = 1 << options->stdevBits;  // Range of values to carry standard deviation
     *bscale = stdev / (double) range;
 
-    int bitpix = fits->bitpix;          // Bits per pixel
     double imageVal;                    // Value on image
     long diskVal;                       // Corresponding value on disk
-    switch (fits->scaling) {
+    switch (options->scaling) {
       case PS_FITS_SCALE_STDEV_POSITIVE:
         // Put (mean - N sigma) at the lowest possible value: predominantly positive images
-        imageVal = mean - fits->stdevNum * stdev;
-        diskVal = - (1 << (bitpix - 1));
+        imageVal = mean - options->stdevNum * stdev;
+        diskVal = - (1 << (options->bitpix - 1));
         break;
       case PS_FITS_SCALE_STDEV_NEGATIVE:
         // Put (mean + N sigma) at the highest possible value: predominantly negative images
-        imageVal = mean + fits->stdevNum * stdev;
-        diskVal = (1 << (bitpix - 1)) - 1;
+        imageVal = mean + options->stdevNum * stdev;
+        diskVal = (1 << (options->bitpix - 1)) - 1;
         break;
       case PS_FITS_SCALE_STDEV_BOTH:
@@ -165 +165 @@
     // If we don't have a RNG, we will allocate one
 
-    if (fits->scaling != PS_FITS_SCALE_STDEV_POSITIVE &&
-        fits->scaling != PS_FITS_SCALE_STDEV_NEGATIVE &&
-        fits->scaling != PS_FITS_SCALE_STDEV_BOTH) {
+    psFitsOptions *options = fits->options; // FITS options
+    if (!options) {
+        // No scaling desired
+        return true;
+    }
+
+    if (options->scaling != PS_FITS_SCALE_STDEV_POSITIVE &&
+        options->scaling != PS_FITS_SCALE_STDEV_NEGATIVE &&
+        options->scaling != PS_FITS_SCALE_STDEV_BOTH) {
         // No need to do anything
         return true;
@@ -186 +192 @@
     psFree(rng);
 
-    fits->mean = psStatsGetValue(stats, MEAN_STAT); // Mean
-    fits->stdev = psStatsGetValue(stats, STDEV_STAT); // Standard deviation
+    options->mean = psStatsGetValue(stats, MEAN_STAT); // Mean
+    options->stdev = psStatsGetValue(stats, STDEV_STAT); // Standard deviation
     psFree(stats);
 
@@ -208 +214 @@
     *bzero = 0.0;
 
-    if (!PS_IS_PSELEMTYPE_REAL(image->type.type)) {
+    psFitsOptions *options = fits->options; // FITS options
+    if (!PS_IS_PSELEMTYPE_REAL(image->type.type) || !options) {
         return true;
     }
 
-    switch (fits->bitpix) {
+    switch (options->bitpix) {
       case 0:
         // No scaling applied
@@ -224 +231 @@
       default:
         psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Target bitpix (%d) is not one of 0,8,16,32,64",
-                fits->bitpix);
+                options->bitpix);
         return false;
     }
 
-    switch (fits->scaling) {
+    switch (options->scaling) {
       case PS_FITS_SCALE_NONE:
         // No scaling applied
         break;
       case PS_FITS_SCALE_RANGE:
-        if (!scaleRange(bscale, bzero, image, fits)) {
+        if (!scaleRange(bscale, bzero, image, options)) {
             psError(PS_ERR_UNKNOWN, false, "Unable to set BSCALE and BZERO from range");
             return false;
@@ -241 +248 @@
       case PS_FITS_SCALE_STDEV_NEGATIVE:
       case PS_FITS_SCALE_STDEV_BOTH:
-        if (!scaleStdev(bscale, bzero, image, fits)) {
+        if (!scaleStdev(bscale, bzero, image, options)) {
             psError(PS_ERR_UNKNOWN, false, "Unable to set BSCALE and BZERO from stdev");
             return false;
@@ -247 +254 @@
         break;
       case PS_FITS_SCALE_MANUAL:
-        *bscale = fits->bscale;
-        *bzero = fits->bzero;
-        break;
-      default:
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Unrecognised FITS scaling option: %x", fits->scaling);
+        *bscale = options->bscale;
+        *bzero = options->bzero;
+        break;
+      default:
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Unrecognised FITS scaling method: %x",
+                options->scaling);
         return false;
     }
@@ -260 +268 @@
 
 
-psImage *psFitsScaleForDisk(const psImage *image, int bitpix, double bscale, double bzero, bool fuzz,
+psImage *psFitsScaleForDisk(const psImage *image, const psFits *fits, double bscale, double bzero,
                             psRandom *rng)
 {
     PS_ASSERT_IMAGE_NON_NULL(image, NULL);
-
-    if (!PS_IS_PSELEMTYPE_REAL(image->type.type) || bitpix == 0) {
+    PS_ASSERT_FITS_NON_NULL(fits, NULL);
+
+    psFitsOptions *options = fits->options; // FITS options
+    if (!PS_IS_PSELEMTYPE_REAL(image->type.type) || !options || options->bitpix == 0) {
+        // No scaling desired
         return psMemIncrRefCounter((psImage*)image); // Casting away "const"
     }
 
+    int bitpix = options->bitpix;       // Bits per pixel
     psElemType outType;                 // Type for output image
     // Choosing to use signed types because those don't require BSCALE,BZERO to represent them in the FITS
@@ -290 +302 @@
     }
 
-    if (bscale == 1.0 && bzero == 0.0) {
+    if (bscale == 1.0 && bzero == 0.0 && !options->fuzz) {
         return psImageCopy(NULL, image, outType);
     }
@@ -297 +309 @@
     psImage *out = psImageAlloc(numCols, numRows, outType); // Output image
 
-    if (!psMemIncrRefCounter(rng) && fuzz) {
+    if (!psMemIncrRefCounter(rng) && options->fuzz) {
         // Don't blab about which seed we're going to get --- it's not necessary for this purpose
         psU64 seed = p_psRandomGetSystemSeed(false);
@@ -307 +319 @@
         ps##INTYPE scale = 1.0 / bscale; \
         ps##INTYPE zero = bzero; \
-        if (fuzz) { \
+        if (options->fuzz) { \
             /* Add random factor [0,1): adds a variance of 1/12, but preserves the expectation value */ \
             for (int y = 0; y < numRows; y++) { \
@@ -435 +447 @@
 }
 #endif
+
+
+
+psFitsScaling psFitsScalingFromString(const char *string)
+{
+    PS_ASSERT_STRING_NON_EMPTY(string, PS_FITS_SCALE_NONE);
+
+    if (strcasecmp(string, "RANGE") == 0)          return PS_FITS_SCALE_RANGE;
+    if (strcasecmp(string, "STDEV_POSITIVE") == 0) return PS_FITS_SCALE_STDEV_POSITIVE;
+    if (strcasecmp(string, "STDEV_NEGATIVE") == 0) return PS_FITS_SCALE_STDEV_NEGATIVE;
+    if (strcasecmp(string, "STDEV_BOTH") == 0)     return PS_FITS_SCALE_STDEV_BOTH;
+    if (strcasecmp(string, "MANUAL") == 0)         return PS_FITS_SCALE_MANUAL;
+
+    psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Unable to interpret FITS scaling: %s", string);
+    return PS_FITS_SCALE_NONE;
+}
+
+