Changeset 27840 for branches/simtest_nebulous_branches/psLib/src/fits/psFits.c

Timestamp:

May 3, 2010, 8:50:52 AM (16 years ago)

Author:

eugene

Message:

updates from trunk

Location:

branches/simtest_nebulous_branches

Files:

• . (modified) (1 prop)
• psLib/src/fits/psFits.c (modified) (9 diffs)

branches/simtest_nebulous_branches/psLib/src/fits/psFits.c

@@ -149 +149 @@
             int thisErrno = errno;      // Error number
             char errorBuf[MAX_STRING_LENGTH], *errorMsg;
-#if ((_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) && ! _GNU_SOURCE)
+#if (((_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) && ! _GNU_SOURCE) ||  __APPLE__)
             strerror_r(thisErrno, errorBuf, MAX_STRING_LENGTH);
             errorMsg = errorBuf;
@@ -208 +208 @@
                 int thisErrno = errno;
                 char errorBuf[64], *errorMsg;
-# if ((_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) && ! _GNU_SOURCE)
+#if (((_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) && ! _GNU_SOURCE) ||  __APPLE__)
                 strerror_r (errno, errorBuf, 64);
                 errorMsg = errorBuf;
@@ -344 +344 @@
 // Therefore, we implement our own version of moving to an extension specified by name.  The pure cfitsio
 // version is used if "conventions.compression" handling is turned off in the psFits structure.
-bool psFitsMoveExtName(const psFits* fits,
-                       const char* extname)
+static bool fitsMoveExtName(const psFits* fits, // FITS file
+                            const char* extname, // Extension name
+                            bool errors // Generate errors?
+    )
 {
     PS_ASSERT_FITS_NON_NULL(fits, false);
@@ -356 +358 @@
         // User wants to use cfitsio.  Good luck to them!
         if (fits_movnam_hdu(fits->fd, ANY_HDU, (char*)extname, 0, &status) != 0) {
-            psFitsError(status, true, _("Could not find HDU '%s'"), extname);
+            if (errors) {
+                psFitsError(status, true, _("Could not find HDU '%s'"), extname);
+            }
             return false;
         }
@@ -378 +382 @@
         if (fits_movabs_hdu(fits->fd, i, &hdutype, &status)) {
             // We've run off the end
-            psFitsError(status, true, _("Could not find HDU with %s = '%s'"), extword, extname);
+            if (errors) {
+                psFitsError(status, true, _("Could not find HDU with %s = '%s'"), extword, extname);
+            }
             return false;
         }
@@ -406 +412 @@
     }
     psAbort("Should never reach here.");
+}
+
+
+bool psFitsMoveExtName(const psFits* fits, const char* extname)
+{
+    return fitsMoveExtName(fits, extname, true);
+}
+
+bool psFitsMoveExtNameClean(const psFits* fits, const char* extname)
+{
+    return fitsMoveExtName(fits, extname, false);
 }
 
@@ -878 +895 @@
         break;
 
+    case PS_TYPE_U64:
+        bitpix = LONGLONG_IMG;
+        bzero = -1.0 * INT64_MIN;
+        datatype = TLONGLONG;
+        break;
+
+    case PS_TYPE_S64:
+        bitpix = LONGLONG_IMG;
+        datatype = TLONGLONG;
+        break;
+
     case PS_TYPE_F32:
         bitpix = FLOAT_IMG;
@@ -904 +932 @@
                     _("Specified type, %s, is not supported."),
                     typeStr);
+            if (bitPix) {
+                *bitPix = 0;
+            }
+            if (dataType) {
+                *dataType = 0;
+            }
+            if (bZero) {
+                *bZero = 0;
+            }
             return false;
         }
@@ -943 +980 @@
     return PS_FITS_COMPRESS_NONE;
 }
+
+
+
+#if 0
+/// Options for FITS I/O
+typedef struct {
+    char *extword;                      ///< user-specified word to name extensions (NULL implies EXTNAME)
+    struct {
+        bool compression;               ///< Compression convention: handling of compressed images
+        bool psBitpix;                  ///< Custom floating-point image
+    } conventions;                      ///< Conventions to honour
+    // The following options are particular to writing images; they needn't be set for anything else.
+    psFitsFloat floatType;              ///< Desired custom floating-point for output images
+    int bitpix;                         ///< Desired BITPIX for output images; 0 to use as provided
+    psFitsScaling scaling;              ///< Scaling scheme to use when quantising floating-point values
+    bool fuzz;                          ///< Fuzz the values when quantising floating-point values?
+    double bscale, bzero;               ///< Manually specified BSCALE and BZERO (for SCALE_MANUAL)
+    double mean, stdev;                 ///< Mean and standard deviation of image
+    int stdevBits;                      ///< Number of bits to sample a standard deviation (for SCALE_STDEV_*)
+    float stdevNum;                     ///< Number of standard deviations to pad off the edge
+} psFitsOptions;
+
+bool psFitsCopyCompression(psFits *target, psFits *source)
+{
+    PS_ASSERT_FITS_NON_NULL(target, false);
+    PS_ASSERT_FITS_NON_NULL(source, false);
+
+    psMetadata *header = psMetadataReadHeader(NULL, source); // Header of source file
+
+    bool mdok;                          // Status of MD lookup
+    psString compTypeStr = psMetadataLookupStr(&mdok, header, "ZCMPTYPE"); // Compression type
+    psFitsCompressionType compType = psFitsCompressionTypeFromString(compTypeStr); // Compression type
+
+    if (!target->options) {
+        target->options = psFitsOptionsAlloc();
+    }
+
+    target->options->floatType = psFitsFloatImageCheck(source); // Custom floating-point type
+
+
+
+
+
+    target->options = psFitsOptionsAlloc();
+    target->options->scaling = PS_FITS_SCALE_MANUAL;
+    target->options->fuzz = false;
+    target->options->bitpix = bitpix;
+    target->options->bscale = bscale;
+    target->options->bzero = bzero;
+
+    psFitsSetCompression(sfile->fits, compType, tiles, 8, 0, 0);
+
+
+
+
+    // Get current BITPIX, BSCALE, BZERO, EXTNAME
+    // Probably not necessary to look the numerical values up in this
+    // way, but guards against changes to psLib and cfitsio FITS
+    // handling.
+    psMetadataItem *bitpixItem = psMetadataLookup(in->header, "BITPIX");
+    psAssert(bitpixItem, "Every FITS image should have BITPIX");
+    int bitpix = psMetadataItemParseS32(bitpixItem);
+    psMetadataItem *bscaleItem = psMetadataLookup(in->header, "BSCALE");
+
+    float bscale;
+    if (!bscaleItem) {
+        psWarning("BSCALE isn't set; defaulting to unity");
+        bscale = 1.0;
+    } else {
+        bscale = psMetadataItemParseF32(bscaleItem);
+    }
+    psMetadataItem *bzeroItem = psMetadataLookup(in->header, "BZERO");
+    float bzero;
+    if (!bzeroItem) {
+        psWarning("BZERO isn't set; defaulting to zero");
+        bzero = 0.0;
+    } else {
+        bzero = psMetadataItemParseF32(bzeroItem);
+    }
+#endif