Changeset 27839 for branches/simmosaic_branches/psLib/src/fits/psFitsHeader.c

Timestamp:

May 3, 2010, 8:45:22 AM (16 years ago)

Author:

eugene

Message:

updates from trunk

Location:

branches/simmosaic_branches

Files:

• . (modified) (1 prop)
• psLib/src/fits/psFitsHeader.c (modified) (17 diffs)

branches/simmosaic_branches/psLib/src/fits/psFitsHeader.c

@@ -50 +50 @@
 
 // List of the start of FITS header keys not to write (handled by cfitsio); NULL-terminated
-static const char *noWriteFitsKeyStarts[] = { "NAXIS", "TTYPE", "TFORM", NULL };
+static const char *noWriteFitsKeyStarts[] = { "NAXIS", "TTYPE", "TFORM", "TZERO", "TSCAL", NULL };
 
 // List of compressed FITS header keys not to write (handled by cfitsio); NULL-terminated
@@ -148 +148 @@
 }
 
-
 bool psFitsCheckCompressedImagePHU(const psFits *fits, psMetadata *header)
 {
@@ -306 +305 @@
                 keyType = 'C';
             }
+            psTrace("psLib.fits", 3, "Reading keyword %s, type %c\n", keyName, keyType);
             if (status != 0) {
                 break;
@@ -328 +328 @@
                                                -INFINITY);
                 } else {
-                    success = psMetadataAddS32(header, PS_LIST_TAIL, keyNameTrans, dupFlag, keyComment,
-                                               atoi(keyValue));
+                    long long value = atoll(keyValue); // Value
+                    if (value > PS_MIN_S32 && value < PS_MAX_S32) {
+                        success = psMetadataAddS32(header, PS_LIST_TAIL, keyNameTrans, dupFlag, keyComment,
+                                                   value);
+                    } else {
+                        success = psMetadataAddS64(header, PS_LIST_TAIL, keyNameTrans, dupFlag, keyComment,
+                                                   value);
+                    }
                 }
                 break;
@@ -497 +503 @@
 static bool fitsWriteHeader(psFits *fits, // The FITS file handle
                             const psMetadata *output, // Metadata that is to be output into the FITS file
-                            bool keyStarts // Write out the key starts?
+                            bool keyStarts, // Write out the key starts?
+                            bool phuImage   // Are we writing a PHU image?
                            )
 {
     int status = 0;                     // Status of cfitsio calls
+    int extnum = psFitsGetExtNum(fits); // Number of extension
     bool simple = true;                 // If SIMPLE is T, then the file should conform to the FITS standard
     psFitsCompressionType compress = psFitsCompressionGetType(fits); // Compression type
-    if (psFitsGetExtNum(fits) == 0) {
+    if (extnum == 0) {
+
         // We allow the user to write SIMPLE, but it must be boolean
         psMetadataItem *simpleItem = psMetadataLookup(output, "SIMPLE"); // SIMPLE in the header
         if (simpleItem) {
-            if (simpleItem->type != PS_DATA_BOOL) {
-                psError(PS_ERR_BAD_PARAMETER_TYPE, true, "SIMPLE in a FITS header must be of boolean type: "
-                        "not %x --- assuming FALSE.\n", simpleItem->type);
+            if (simpleItem->type != PS_DATA_BOOL || !simpleItem->data.B) {
                 int value = false;          // Temporary holder for boolean
+                psWarning("Writing SIMPLE=F to FITS header by request");
                 fits_update_key(fits->fd, TLOGICAL, "SIMPLE", &value,
                                 "File does not conform to FITS standard", &status);
                 simple = false;
-            } else if (!simpleItem->data.B) {
-                simple = false;
-                int value = false;      // Temporary holder for boolean
-                fits_update_key(fits->fd, TLOGICAL, "SIMPLE", &value,
-                                "File does not conform to FITS standard", &status);
             }
             // Uncompressed SIMPLE = T is taken care of by cfitsio.
@@ -526 +529 @@
     bool compressing = ((!fits->options || fits->options->conventions.compression) &&
                         compress != PS_FITS_COMPRESS_NONE) ? true : false; // Are we compressing?
-
     if (compressing) {
         psMetadataItem *simpleItem = psMetadataLookup(output, "SIMPLE"); // SIMPLE in the header
@@ -538 +540 @@
             }
         }
-        //        int value = simple;             // Temporary holder for boolean
-        //        fits_update_key(fits->fd, TLOGICAL, "ZSIMPLE", &value,
-        //                        "Uncompressed file's conformance to FITS standard", &status);
+        if (simple && phuImage && extnum == 1) {
+            // ZSIMPLE is required for decompression with funpack, etc.  For funpack to work, ZSIMPLE needs to
+            // go early in the FITS header (otherwise we get "Extension doesn't start with SIMPLE or XTENSION
+            // keyword.").  We put it after ZIMAGE by reading ZIMAGE (which sets the insertion pointer) and
+            // then inserting ZSIMPLE.
+            char comment[FLEN_CARD];    // Comment for ZIMAGE; unused
+            int value;                  // Value for ZIMAGE; unused
+            psTrace("psLib.fits", 3, "Writing header ZSIMPLE to preserve PHU");
+            fits_read_key(fits->fd, TLOGICAL, "ZIMAGE", &value, comment, &status);
+            fits_insert_key_log(fits->fd, "ZSIMPLE", simple, "Uncompressed file's conforms to FITS", &status);
+        }
     }
 
@@ -560 +570 @@
             // to preserve NAXISn etc for reference, so we don't do this.
 
+            if (keywordInList(name, noWriteFitsKeys) ||
+                (keyStarts && keywordStartsWith(name, noWriteFitsKeyStarts))) {
+                psTrace("psLib.fits", 3, "Not writing FITS keyword %s", name);
+                continue;
+            }
+
             // Options for compression
             if (compressing) {
@@ -567 +583 @@
                 if (keywordInList(name, noWriteCompressedKeys) ||
                     (keyStarts && keywordStartsWith(name, noWriteCompressedKeyStarts))) {
+                    psTrace("psLib.fits", 3, "Not writing FITS keyword %s", name);
                     continue;
                 }
             } else if (keywordInList(name, noWriteCompressedKeys) ||
                        (keyStarts && keywordStartsWith(name, noWriteCompressedKeyStarts))) {
-                continue;
-            }
-
-            if (keywordInList(name, noWriteFitsKeys) ||
-                (keyStarts && keywordStartsWith(name, noWriteFitsKeyStarts))) {
+                psTrace("psLib.fits", 3, "Not writing FITS keyword %s", name);
                 continue;
             }
@@ -584 +597 @@
                 psWarning("COMMENT header is not of type STRING (%x) --- ignored.", item->type);
             } else {
+                psTrace("psLib.fits", 5, "Writing header COMMENT: %s", item->data.str);
                 fits_write_comment(fits->fd, item->data.str, &status);
             }
@@ -590 +604 @@
                 psWarning("COMMENT header is not of type STRING (%x) --- ignored.", item->type);
             } else {
+                psTrace("psLib.fits", 5, "Writing header HISTORY: %s", item->data.str);
                 fits_write_history(fits->fd, item->data.str, &status);
             }
@@ -597 +612 @@
               case PS_DATA_BOOL: {
                   int value = item->data.B;
+                  psTrace("psLib.fits", 5, "Writing BOOL header %s: %d", name, value);
                   fits_update_key(fits->fd, TLOGICAL, name, &value, item->comment, &status);
                   break;
               }
               case PS_DATA_S8:
+                psTrace("psLib.fits", 5, "Writing S8 header %s: %d", name, (int)item->data.S8);
                 fits_update_key(fits->fd, TBYTE, name, &item->data.S8, item->comment, &status);
                 break;
               case PS_DATA_S16:
+                psTrace("psLib.fits", 5, "Writing S16 header %s: %d", name, (int)item->data.S16);
                 fits_update_key(fits->fd, TSHORT, name, &item->data.S16, item->comment, &status);
                 break;
               case PS_DATA_S32:
+                psTrace("psLib.fits", 5, "Writing S32 header %s: %d", name, (int)item->data.S32);
                 fits_update_key(fits->fd, TINT, name, &item->data.S32, item->comment, &status);
                 break;
               case PS_DATA_S64:
+                psTrace("psLib.fits", 5, "Writing S64 header %s: %" PRId64, name, item->data.S64);
                 fits_update_key(fits->fd, TLONGLONG, name, &item->data.S64, item->comment, &status);
                 break;
               case PS_DATA_U8: {
                   unsigned short int temp = item->data.U8;
+                psTrace("psLib.fits", 5, "Writing U8 header %s: %d", name, (int)item->data.U8);
                   fits_update_key(fits->fd, TUSHORT, name, &temp, item->comment, &status);
                   break;
               }
               case PS_DATA_U16:
+                psTrace("psLib.fits", 5, "Writing U16 header %s: %d", name, (int)item->data.U16);
                 fits_update_key(fits->fd, TUSHORT, name, &item->data.U16, item->comment, &status);
                 break;
               case PS_DATA_U32:
+                psTrace("psLib.fits", 5, "Writing U32 header %s: %d", name, (unsigned int)item->data.U32);
                 fits_update_key(fits->fd, TUINT, name, &item->data.U32, item->comment, &status);
                 break;
@@ -631 +654 @@
                 }
                 psS64 temp = item->data.U64; // Signed version
+                psTrace("psLib.fits", 5, "Writing U64 header %s: %" PRIu64, name, item->data.U64);
                 fits_update_key(fits->fd, TLONGLONG, name, &temp, item->comment, &status);
                 break;
               case PS_DATA_F32: {
                   int infCheck = 0;         // Result of isinf()
+                  psTrace("psLib.fits", 5, "Writing F32 header %s: %f", name, item->data.F32);
                   if (isnan(item->data.F32)) {
                       fits_update_key(fits->fd, TSTRING, name, "NaN", item->comment, &status);
@@ -651 +676 @@
               case PS_DATA_F64: {
                   int infCheck = 0;         // Result of isinf()
+                  psTrace("psLib.fits", 5, "Writing F32 header %s: %lf", name, item->data.F64);
                   if (isnan(item->data.F64)) {
                       fits_update_key(fits->fd, TSTRING, name, "NaN", item->comment, &status);
@@ -666 +692 @@
               }
               case PS_DATA_STRING:
+                psTrace("psLib.fits", 5, "Writing STR header %s: %s", name, item->data.str);
                 fits_update_key(fits->fd, TSTRING, name, item->data.V, item->comment, &status);
                 break;
@@ -699 +726 @@
     PS_ASSERT_METADATA_NON_NULL(output, false);
 
-    return fitsWriteHeader(fits, output, true);
+    return fitsWriteHeader(fits, output, true, false);
+}
+
+bool psFitsWriteHeaderImage(psFits *fits,
+                            const psMetadata *output,
+                            bool phuImage
+                            )
+{
+    PS_ASSERT_FITS_NON_NULL(fits, false);
+    PS_ASSERT_FITS_WRITABLE(fits, false);
+    PS_ASSERT_METADATA_NON_NULL(output, false);
+
+    return fitsWriteHeader(fits, output, true, phuImage);
 }
 
@@ -733 +772 @@
     }
 
-    if (output && !fitsWriteHeader(fits, output, false)) {
+    if (output && !fitsWriteHeader(fits, output, false, false)) {
         psError(PS_ERR_IO, false, "Unable to write FITS header.\n");
         return false;