Changeset 15179

Timestamp:

Oct 3, 2007, 11:27:21 AM (19 years ago)

Author:

Paul Price

Message:

Merging branch with FITS compression development.

Location:

trunk/psLib/src/fits

Files:

• psFits.c (modified) (28 diffs)
• psFits.h (modified) (10 diffs)
• psFitsHeader.c (modified) (15 diffs)
• psFitsHeader.h (modified) (2 diffs)
• psFitsImage.c (modified) (15 diffs)
• psFitsTable.c (modified) (11 diffs)

trunk/psLib/src/fits/psFits.c

@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.71 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-09-18 03:01:17 $
+ *  @version $Revision: 1.72 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-10-03 21:27:21 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -20 +20 @@
 
 #include "psFits.h"
+#include "psFitsHeader.h"
 #include "string.h"
 #include "psError.h"
@@ -65 +66 @@
             return false;
         }
-        fits->fd = NULL;
+        fits->fd = NULL;
     }
     return true;
@@ -74 +75 @@
     if (!fits) return;
     if (fits->fd) {
-        fitsClose(fits);
+        fitsClose(fits);
     }
     psFree (fits->extword);
@@ -81 +82 @@
 bool psFitsClose(psFits* fits)
 {
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return false;
-    }
+    PS_ASSERT_FITS_NON_NULL(fits, false);
 
     bool status = fitsClose(fits);
@@ -95 +92 @@
 psFits* psFitsOpen(const char* name, const char* mode)
 {
+    PS_ASSERT_STRING_NON_EMPTY(name, NULL);
+
     int status = 0;
     fitsfile *fptr = NULL;      /* Pointer to the FITS file */
-
-    if (name == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("Specified filename can not be NULL."));
-        return NULL;
-    }
 
     /* check the mode to determine how to open/create file */
@@ -131 +124 @@
         if (access(name, F_OK) == 0) {
             // file exists, delete old one first
-            remove
-                (name);
+            remove(name);
         }
 
@@ -140 +132 @@
         (void)fits_create_file
         #endif
-        (&fptr,
-         name,
-         &status);
+        (&fptr, name, &status);
         if (fptr == NULL || status != 0) {
-            char fitsErr[MAX_STRING_LENGTH]
-            ;
+            char fitsErr[MAX_STRING_LENGTH];
             fits_get_errstatus(status, fitsErr);
             psError(PS_ERR_IO, true,
@@ -158 +147 @@
         (void)fits_open_file
         #endif
-        (&fptr,
-         name,
-         iomode,
-         &status);
+        (&fptr, name, iomode, &status);
         if (fptr == NULL || status != 0) {
-            char fitsErr[MAX_STRING_LENGTH]
-            ;
+            char fitsErr[MAX_STRING_LENGTH];
             fits_get_errstatus(status, fitsErr);
             psError(PS_ERR_IO, true,
@@ -177 +162 @@
     fits->writable = (iomode == READWRITE);
     fits->extword = NULL;
+    fits->conventions.compression = true;
     psMemSetDeallocator(fits,(psFreeFunc)fitsFree);
 
@@ -182 +168 @@
 }
 
-static void psFitsOptionsFree(psFitsOptions *opt)
-{
-    psFree(opt->tilesize);
-}
-
-psFitsOptions* psFitsOptionsAlloc(
+psErrorCode p_psFitsError(const char* filename, unsigned int lineno, const char* func, int status,
+                          bool new, const char *errorMsg, ...)
+{
+    if (status == 0) {
+        return PS_ERR_NONE;
+    }
+
+    va_list ap;                         // Variable arguments
+    va_start(ap, errorMsg);
+    psString msg = NULL;                // Message to pass to psError
+    psStringAppendV(&msg, errorMsg, ap);
+    va_end(ap);
+
+    char cfitsioMsg[MAX_STRING_LENGTH];   // Error message from cfitsio
+    (void)fits_get_errstatus(status, cfitsioMsg);
+
+    psStringAppend(&msg, "[CFITSIO error: %s]", cfitsioMsg);
+
+    psErrorCode code = p_psError(filename, lineno, func, PS_ERR_IO, new, msg); // Error code
+    psFree(msg);
+    return code;
+}
+
+static void psFitsCompressionFree(psFitsCompression *comp)
+{
+    PS_ASSERT_PTR_NON_NULL(comp,);
+    psFree(comp->tilesize);
+}
+
+psFitsCompression* psFitsCompressionAlloc(
     psFitsCompressionType type,         ///< type of compression
     psVector *tilesize,                 ///< vector defining compression tile size
@@ -195 +205 @@
 )
 {
-    psFitsOptions *opt = psAlloc(sizeof(psFitsOptions));
-
-    opt->type = type;
-    opt->tilesize = psVectorCopy(NULL, tilesize, PS_DATA_S64);
-    opt->noisebits = noisebits;
-    opt->scale = scale;
-    opt->smooth = smooth;
-
-    psMemSetDeallocator(opt, (psFreeFunc) psFitsOptionsFree);
-
-    return opt;
+    psFitsCompression *comp = psAlloc(sizeof(psFitsCompression));
+    psMemSetDeallocator(comp, (psFreeFunc) psFitsCompressionFree);
+
+    comp->type = type;
+    comp->tilesize = psVectorCopy(NULL, tilesize, PS_DATA_S64);
+    comp->noisebits = noisebits;
+    comp->scale = scale;
+    comp->smooth = smooth;
+
+    return comp;
 }
 
@@ -224 +233 @@
 }
 
-// move to the first HDU where extword == extname.  this is equivalent to fits_movnam_hdu() for
-// a user-defined word in place of EXTNAME
-bool p_psFitsMoveExtName_UserKey(const psFits *fits,
-                                 const char *extname,
-                                 const char *extword)
-{
-    PS_ASSERT_PTR_NON_NULL(fits,    false);
-    PS_ASSERT_PTR_NON_NULL(extname, false);
-    PS_ASSERT_PTR_NON_NULL(extword, false);
-
-    int hdutype = 0;
-    char name[MAX_STRING_LENGTH];
-    char extstring[MAX_STRING_LENGTH];
-
-    sprintf (extstring, "'%s'", extname);
-
-    // NOTE: fits_* return 0 for success
-    for (int i = 1; true; i++) {
-        // are we able to read the next HDU?
-
-        int status = 0;
-        if (fits_movabs_hdu(fits->fd, i, &hdutype, &status)) {
-            char fitsErr[MAX_STRING_LENGTH];
-            fits_get_errstatus(status, fitsErr);
-            psError(PS_ERR_LOCATION_INVALID, true,
-                    _("Could not find HDU with %s = '%s'. CFITSIO Error: %s"),
-                    extword, extname, fitsErr);
-            return false;
-        }
-        // is there a keyword called 'extword'? (read as string regardless of type)
-        status = 0;
-        if (fits_read_keyword(fits->fd, (char *)extword, name, NULL, &status)) {
-            continue;
-        }
-        // if this was read as a string, we will have leading and trailing single-quotes
-        // try both for comparison
-        
-        // do we have the right hdu (names match)?
-        if (!strcmp (name, extname) || !strcmp (name, extstring)) {
-            return true;
-        }
-    }
-    psAbort("we should not reach here");
-}
-
-// XXX I will need to define a low-level function p_psFitsMoveExtName_UserKey () which
-// uses fits_movabs_hdu() to replicate the functionality of fits_movnam_hdu using an
-// alternate name for EXTNAME
+// Files compressed with cfitsio's "imcopy" program may have multiple EXTNAME keywords, with the first set to
+// COMPRESSED_IMAGE.  However, fits_movnam_hdu won't find the second (proper) value of EXTNAME, and so can
+// fail to find a perfectly legitimate extension, simply because imcopy does something silly.  However, we
+// really want to be able to read these files (MegaCam data are shipped as imcopy-compressed images).
+// 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)
 {
-    int status = 0;
-
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return false;
-    }
-
-    if (extname == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("Specified extension name can not be NULL."));
-        return false;
-    }
-
-    if (fits->extword != NULL) {
-        bool result = p_psFitsMoveExtName_UserKey(fits, extname, fits->extword);
-        return (result);
-    }
-
-    if (fits_movnam_hdu(fits->fd, ANY_HDU, (char*)extname, 0, &status) != 0) {
-        char fitsErr[MAX_STRING_LENGTH];
-        fits_get_errstatus(status, fitsErr);
-        psError(PS_ERR_LOCATION_INVALID, true,
-                _("Could not find HDU '%s'. CFITSIO Error: %s"),
-                extname, fitsErr);
-        return false;
-    }
-
-    return true;
+    PS_ASSERT_FITS_NON_NULL(fits, false);
+    PS_ASSERT_STRING_NON_EMPTY(extname, false);
+
+    int status = 0;
+
+    if (!fits->conventions.compression && !fits->extword) {
+        // 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);
+            return false;
+        }
+        return true;
+    }
+
+    bool ignoreCI = (fits->conventions.compression &&
+                     (strcmp(extname, "COMPRESSED_IMAGE") != 0)); // Ignore COMPRESSED_IMAGE extension name?
+    char *extword = (fits->extword ? fits->extword : "EXTNAME"); // Word to use as extension name
+
+#if 0
+    // XXX Future optimisation: loop through from the current HDU to the end, then from the start to the
+    // current position.  This will save seeking through the file multiple times.
+    int currentExt = psFitsGetExtNum(fits); // Current extension number
+    int numExt = psFitsGetSize(fits);   // Total number of extensions
+#endif
+
+    for (int i = 1; true; i++) {
+        int hdutype = 0;
+        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);
+            return false;
+        }
+        // Is there a keyword called 'extword'? (read as string regardless of type)
+        char name[MAX_STRING_LENGTH];  // Name of extension
+        if (fits_read_keyword(fits->fd, extword, name, NULL, &status)) {
+            // It doesn't exist in the header.
+            // This isn't the extension you're looking for.  Move along.
+            status = 0;
+            continue;
+        }
+        char *fixed = p_psFitsHeaderParseString(name); // Parsed version (removing quotes and spaces)
+
+        if (ignoreCI && strcmp(fixed, "COMPRESSED_IMAGE") == 0) {
+            // Read it again, Sam
+            if (fits_read_keyword(fits->fd, extword, name, NULL, &status)) {
+                status = 0;
+                continue;
+            }
+            fixed = p_psFitsHeaderParseString(name);
+        }
+
+        if (strcmp(fixed, extname) == 0) {
+            // We've arrived
+            return true;
+        }
+    }
+    psAbort("Should never reach here.");
 }
 
@@ -310 +305 @@
                       bool relative)
 {
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return false;
-    }
+    PS_ASSERT_FITS_NON_NULL(fits, false);
 
     int status = 0;
@@ -346 +337 @@
 bool psFitsMoveLast(psFits* fits)
 {
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return false;
-    }
+    PS_ASSERT_FITS_NON_NULL(fits, false);
+
     int size = psFitsGetSize(fits);
     if (size == 0) { // empty file -- no action needed
@@ -361 +349 @@
 int psFitsGetExtNum(const psFits* fits)
 {
+    PS_ASSERT_FITS_NON_NULL(fits, false);
     int hdunum;
-
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return PS_FITS_TYPE_NONE;
-    }
-
-
     return fits_get_hdu_num(fits->fd,&hdunum) - 1;
 }
@@ -375 +356 @@
 psString psFitsGetExtName(const psFits* fits)
 {
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return NULL;
-    }
+    PS_ASSERT_FITS_NON_NULL(fits, NULL);
 
     int status = 0;
@@ -389 +366 @@
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
                 _("Header keyword %s is not found"), extword);
-        return NULL;
+        return NULL;
     }
     return psStringCopy(name);
@@ -396 +373 @@
 bool psFitsSetExtName(psFits* fits, const char* name)
 {
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return false;
-    }
-
-    if (name == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("Specified extension name can not be NULL."));
-        return false;
-    }
+    PS_ASSERT_FITS_NON_NULL(fits, false);
+    PS_ASSERT_STRING_NON_EMPTY(name, false);
 
     int status = 0;
@@ -428 +396 @@
                         bool relative)
 {
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return false;
-    }
+    PS_ASSERT_FITS_NON_NULL(fits, false);
 
     if (! fits->writable) {
@@ -466 +430 @@
                          const char* extname)
 {
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return false;
-    }
+    PS_ASSERT_FITS_NON_NULL(fits, false);
+    PS_ASSERT_STRING_NON_EMPTY(extname, false);
 
     if (! fits->writable) {
@@ -504 +465 @@
 int psFitsGetSize(const psFits* fits)
 {
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return 0;
-    }
+    PS_ASSERT_FITS_NON_NULL(fits, 0);
 
     int num = 0;
@@ -527 +484 @@
 psFitsType psFitsGetExtType(const psFits* fits)
 {
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return PS_FITS_TYPE_NONE;
-    }
+    PS_ASSERT_FITS_NON_NULL(fits, PS_FITS_TYPE_NONE);
 
     int status = 0;
@@ -556 +509 @@
 bool psFitsTruncate(psFits* fits)
 {
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return PS_FITS_TYPE_NONE;
-    }
+    PS_ASSERT_FITS_NON_NULL(fits, NULL);
 
     if (! fits->writable) {
@@ -597 +546 @@
 )
 {
+    PS_ASSERT_FITS_NON_NULL(fits, false);
+
     // convert psFitsCompressionType to cfitsio compression types
     int comptype;
@@ -640 +591 @@
         psAbort("can't map (long) type to a psLib type");
     }
+    psFree(dim);
     // status check belongs to fits_set_tile_dim() call
     if (status) {
@@ -681 +633 @@
 }
 
-
-bool psFitsSetOptions(
+psFitsCompression *psFitsCompressionGet(psFits* fits)
+{
+    PS_ASSERT_FITS_NON_NULL(fits, NULL);
+
+    int status = 0;                     // cfitsio status
+
+    psFitsCompressionType type = psFitsCompressionGetType(fits);
+    if (type < 0) {
+        psError(PS_ERR_UNKNOWN, false, "Unable to get compression type.");
+        return NULL;
+    }
+
+    psElemType tileType;                // Type corresponding to "long"
+    if (sizeof(long) == sizeof(psS64)) {
+        tileType = PS_TYPE_S64;
+    } else if (sizeof(long) == sizeof(psS32)) {
+        tileType = PS_TYPE_S32;
+    } else {
+        psAbort("can't map (long) type to a psLib type");
+    }
+
+    psVector *tiles = psVectorAlloc(3, tileType); // Tile sizes
+    if (fits_get_tile_dim(fits->fd, 3, (long*)tiles->data.U8, &status)) {
+        psFitsError(status, true, "Unable to get compression tile sizes.");
+        psFree(tiles);
+        return NULL;
+    }
+
+    int noisebits;                      // Noise bits for compression
+    if (fits_get_noise_bits(fits->fd, &noisebits, &status)) {
+        psFitsError(status, true, "Unable to get compression noise bits.");
+        psFree(tiles);
+        return NULL;
+    }
+
+    int hscale = 0, hsmooth = 0;        // Scaling and smoothing for HCOMPRESS
+
+#if FITS_HCOMP
+    if (fits_get_hcomp_scale(fits->fd, &hscale, &status)) {
+        psFitsError(status, true, "Unable to get HCOMPRESS scaling.");
+        psFree(tiles);
+        return NULL;
+    }
+    if (fits_get_hcomp_smooth(fits->fd, &hsmooth, &status)) {
+        psFitsError(status, true, "Unable to get HCOMPRESS smoothing.");
+        psFree(tiles);
+        return NULL;
+    }
+#endif // FITS_HCOMP
+
+    psFitsCompression *compress = psFitsCompressionAlloc(type, tiles, noisebits, hscale, hsmooth);
+    psFree(tiles);                      // Drop reference
+
+    return compress;
+}
+
+psFitsCompressionType psFitsCompressionGetType(psFits* fits)
+{
+    PS_ASSERT_FITS_NON_NULL(fits, -1);
+
+    int status = 0;                     // cfitsio status
+    int comptype = 0;                   // cfitsio compression type
+    if (fits_get_compression_type(fits->fd, &comptype, &status)) {
+        psFitsError(status, true, "Unable to get compression type.");
+        return -1;
+    }
+
+    psFitsCompressionType type;
+    switch (comptype) {
+      case 0:
+        type = PS_FITS_COMPRESS_NONE;
+        break;
+      case GZIP_1:
+        type = PS_FITS_COMPRESS_GZIP;
+        break;
+      case RICE_1:
+        type = PS_FITS_COMPRESS_RICE;
+        break;
+      case HCOMPRESS_1:
+        type = PS_FITS_COMPRESS_HCOMPRESS;
+        break;
+      case PLIO_1:
+        type = PS_FITS_COMPRESS_PLIO;
+        break;
+      default:
+        psError(PS_ERR_UNKNOWN, true, "cfitsio reports unknown compression type.");
+        return -1;
+    }
+
+    return type;
+}
+
+
+bool psFitsCompressionApply(
     psFits* fits,                       ///< psFits object to close
-    psFitsOptions *opt                  ///< options object
+    psFitsCompression *comp             ///< options object
 )
 {
-    return psFitsSetCompression(
-            fits,
-            opt->type,
-            opt->tilesize,
-            opt->noisebits,
-            opt->scale,
-            opt->smooth);
+    return psFitsSetCompression(fits, comp->type, comp->tilesize, comp->noisebits, comp->scale, comp->smooth);
 }
 
@@ -826 +864 @@
 
 
+psFitsCompressionType psFitsCompressionTypeFromString(const char *string)
+{
+    if (!string || strlen(string) == 0) {
+        psWarning("Unable to identify compression type --- none set.");
+        return PS_FITS_COMPRESS_NONE;
+    }
+
+    if (strcmp(string, "GZIP") == 0) return PS_FITS_COMPRESS_GZIP;
+    if (strcmp(string, "RICE") == 0) return PS_FITS_COMPRESS_RICE;
+    if (strcmp(string, "HCOMPRESS") == 0) return PS_FITS_COMPRESS_HCOMPRESS;
+    if (strcmp(string, "PLIO") == 0) return PS_FITS_COMPRESS_PLIO;
+
+    psWarning("Unable to identify compression type (%s) --- none set.", string);
+    return PS_FITS_COMPRESS_NONE;
+}

trunk/psLib/src/fits/psFits.h

@@ -4 +4 @@
  * @author Robert DeSonia, MHPCC
  *
- * @version $Revision: 1.31 $ $Name: not supported by cvs2svn $
- * @date $Date: 2007-09-18 02:56:36 $
+ * @version $Revision: 1.32 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2007-10-03 21:27:21 $
  * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
  */
@@ -21 +21 @@
 #include "psMetadata.h"
 #include "psImage.h"
+
+#include "psErrorCodes.h"
 
 /** FITS HDU type.
@@ -49 +51 @@
  *
  */
-typedef struct
-{
-    fitsfile* fd;                       ///< the CFITSIO fits files handle.
-    bool writable;                      ///< Is the file writable?
-    char *extword;                      ///< user-specified word to name extensions (NULL implies EXTNAME)
-}
-psFits;
-
-/** FITS options object. */
-typedef struct
-{
+typedef struct {
+    fitsfile* fd;                       ///< the CFITSIO fits files handle.
+    bool writable;                      ///< Is the file writable?
+    char *extword;                      ///< user-specified word to name extensions (NULL implies EXTNAME)
+    struct {
+        bool compression;               ///< Honour compression convention, handling compressed images
+    } conventions;                      ///< Conventions to honour
+} psFits;
+
+/** FITS compression settings. */
+typedef struct {
     psFitsCompressionType type;         ///< type of compression
     psVector *tilesize;                 ///< vector defining compression tile size
@@ -65 +67 @@
     int scale;                          ///< hcompress scale
     int smooth;                         ///< hcompress smothing
-}
-psFitsOptions;
+} psFitsCompression;
 
 /** Opens a FITS file and allocates the associated psFits object.
@@ -84 +85 @@
 );
 
-/** Creates a new FITS options struct 
+
+/// Generate an error including the cfitsio error string
+#ifdef DOXYGEN
+psErrorCode psFitsError(
+    int status,                         ///< cfitsio status value
+    bool new,                           ///< new error?
+    const char *errorMsg,               ///< printf-style format of header line
+    ...                                 ///< any parameters required in format
+    );
+#else // ifdef DOXYGEN
+psErrorCode p_psFitsError(
+    const char* filename,               ///< file name
+    unsigned int lineno,                ///< line number in file
+    const char* func,                   ///< function name
+    int status,                         ///< cfitsio status value
+    bool new,                           ///< new error?
+    const char *errorMsg,               ///< printf-style format of header line
+    ...                                 ///< any parameters required in format
+    ) PS_ATTR_FORMAT(printf, 6, 7);
+#ifndef SWIG
+#define psFitsError(status,new,...) \
+      p_psFitsError(__FILE__,__LINE__,__func__,status,new,__VA_ARGS__)
+#endif // ifndef SWIG
+#endif // ifdef DOXYGEN
+
+
+/** Creates a new FITS options struct
  *
  *  @return psFitsOptions or NULL on failure
  */
-psFitsOptions* psFitsOptionsAlloc(
+psFitsCompression* psFitsCompressionAlloc(
     psFitsCompressionType type,         ///< type of compression
     psVector *tilesize,                 ///< vector defining compression tile size
@@ -96 +123 @@
 );
 
+/// Return the FITS compression type specified by a string
+psFitsCompressionType psFitsCompressionTypeFromString(
+    const char *string                  ///< String with compression type
+    );
+
 /** Closes a FITS file.
  *
@@ -111 +143 @@
  */
 bool psFitsSetCompression(
-    psFits* fits,                       ///< psFits object to close
+    psFits* fits,                       ///< psFits object for which to set compression
     psFitsCompressionType type,         ///< type of compression
     psVector *tilesize,                 ///< vector defining compression tile size
@@ -119 +151 @@
 );
 
+/// Get the compression options for a file handle
+psFitsCompression *psFitsCompressionGet(
+    psFits* fits                        ///< psFits object for which to get compression
+);
+
+/// Get the compression type for a file handle
+psFitsCompressionType psFitsCompressionGetType(
+    psFits* fits                        ///< psFits object for which to get compression type
+    );
+
 /** Sets FITS write options
  *
  *  @return bool      TRUE if successfully configured, otherwise FALSE
  */
-bool psFitsSetOptions(
-    psFits* fits,                       ///< psFits object to close
-    psFitsOptions *opt                  ///< options object
+bool psFitsCompressionApply(
+    psFits* fits,                       ///< psFits object for which to set compression
+    psFitsCompression *compress         ///< options object
 );
 
@@ -146 +188 @@
 // a user-defined word in place of EXTNAME
 bool p_psFitsMoveExtName_UserKey(const psFits *fits,
-                                 const char *extname,
-                                 const char *extword);
+                                 const char *extname,
+                                 const char *extword);
 
 /** Moves the FITS HDU to the specified extension name.
@@ -261 +303 @@
                           );
 
+#define PS_ASSERT_FITS_NON_NULL(NAME, RVAL) \
+if (!(NAME) || !(NAME)->fd) { \
+    psError(PS_ERR_UNEXPECTED_NULL, true, "Error: FITS file pointer %s is NULL", #NAME); \
+    return RVAL; \
+}
+
 /// @}
 #endif // #ifndef PS_FITS_H

trunk/psLib/src/fits/psFitsHeader.c

@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.34 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-08-10 02:23:42 $
+ *  @version $Revision: 1.35 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-10-03 21:27:21 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -19 +19 @@
 #include <unistd.h>
 
+#include "psAssert.h"
 #include "psFits.h"
 #include "string.h"
@@ -32 +33 @@
 
 #define MAX_STRING_LENGTH 256  // maximum length string for FITS routines
+#define NUM_EMPTY_KEYS 8                // Number of keywords before header is considered practically empty
 
 // list of FITS header keys to ignore; NULL-terminated
-static char* ignoreFitsKeys[] = {"", NULL};
+static const char* ignoreFitsKeys[] = { "", NULL};
 
 // List of FITS header keys that may be duplicated; NULL-terminated
-static char *duplicateFitsKeys[] = {"COMMENT", "HIERARCH", "HISTORY", NULL};
+static const char *duplicateFitsKeys[] = { "COMMENT", "HIERARCH", "HISTORY", NULL};
 
 // List of FITS header keys not to write (handled by cfitsio); NULL-terminated
-static char *noWriteFitsKeys[] = {"SIMPLE", "XTENSION", "BITPIX", "NAXIS", "EXTNAME", "BSCALE", "BZERO",
-                                  "TFIELDS", NULL};
+static const char *noWriteFitsKeys[] = { "SIMPLE", "XTENSION", "BITPIX", "NAXIS", "EXTNAME", "BSCALE",
+                                         "BZERO", "TFIELDS", "PCOUNT", "GCOUNT", "ZIMAGE", "ZBITPIX",
+                                         "ZCMPTYPE", NULL};
+
 // List of the start of FITS header keys not to write (handled by cfitsio); NULL-terminated
-static char *noWriteFitsKeyStarts[] = {"NAXIS", "TTYPE", "TFORM", NULL};
-
-// List of FITS header keys to be written with fits_write_comment
-
-psMetadata* psFitsReadHeader(psMetadata* out,
-                             const psFits* fits)
-{
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return NULL;
-    }
-
-    if (out == NULL) {
-        out = psMetadataAlloc();
-    }
+static const char *noWriteFitsKeyStarts[] = { "NAXIS", "TTYPE", "TFORM", "ZNAXIS", "ZTILE", "ZNAME", "ZVAL",
+                                              NULL};
+
+// List of FITS header keys that may be present if the header is considered "empty"; NULL-terminated
+static const char *emptyKeys[] = { "SIMPLE", "BITPIX", "NAXIS", "EXTEND", "COMMENT", "CHECKSUM", "DATASUM",
+                                   NULL };
+
+// Compare a keyword with a list of keywords; return true if it's in the list
+static bool keywordInList(const char *keyword, // Keyword to check
+                          const char **list // List of keywords
+    )
+{
+    for (const char **check = list; *check; ++check) {
+        if (strcmp(keyword, *check) == 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
+
+bool psFitsCheckSingleCompressedImagePHU(const psFits *fits, psMetadata *header)
+{
+    PS_ASSERT_FITS_NON_NULL(fits, false);
+
+    if (!fits->conventions.compression) {
+        // User has turned off compression conventions; doesn't want any nasty surprises
+        return false;
+    }
+
+    if (psFitsGetExtNum(fits) != 0) {
+        // It's not the PHU, so it can't be the PHU for a single compressed image!
+        return false;
+    }
+
+    if (psFitsGetSize(fits) != 2) {
+        // No second extension, or multiple extensions
+        return false;
+    }
+
+    int numKeys;                        // Number of keywords in the header
+    int status = 0;                     // CFITSIO status
+    fits_get_hdrspace(fits->fd, &numKeys, 0, &status);
+    if (numKeys > NUM_EMPTY_KEYS) {
+        return false;
+    }
+
+    int bitpix, naxis;                  // Bits per pixel and number of axes
+    long naxes[MAX_COMPRESS_DIM];       // Dimensions
+    fits_get_img_param(fits->fd, MAX_COMPRESS_DIM, &bitpix, &naxis, naxes, &status);
+    if (naxis != 0) {
+        return false;
+    }
+
+    if (!header) {
+        for (int i = 1; i <= numKeys; i++) {
+            // Just want to read the keyword names, without parsing the values and stuffing into a metadata
+            char keyName[MAX_STRING_LENGTH];// Keyword name
+            char keyValue[MAX_STRING_LENGTH]; // Corresponding value
+            char keyComment[MAX_STRING_LENGTH]; // Corresponding comment
+            fits_read_keyn(fits->fd, i, keyName, keyValue, keyComment, &status);
+            if (!keywordInList(keyName, emptyKeys)) {
+                return false;
+            }
+        }
+    } else {
+        psMetadataIterator *iter = psMetadataIteratorAlloc(header, PS_LIST_HEAD, NULL); // Iterator
+        psMetadataItem *item;           // Item from iteration
+        while ((item = psMetadataGetAndIncrement(iter))) {
+            if (!keywordInList(item->name, emptyKeys)) {
+                psFree(iter);
+                return false;
+            }
+        }
+        psFree(iter);
+    }
+
+    if (!psFitsMoveExtNum(fits, 1, false)) {
+        psWarning("Unable to examine first extension as suspect compressed image.");
+        return false;
+    }
+
+    if (fits_is_compressed_image(fits->fd, &status)) {
+        return true;
+    }
+
+    // It's not a single compressed image PHU --- move back to the PHU for the user
+    if (!psFitsMoveExtNum(fits, 0, false)) {
+        psWarning("Unable to examine first extension as suspect compressed image.");
+        return false;
+    }
+
+    return false;
+}
+
+char *p_psFitsHeaderParseString(char *string)
+{
+    if (!string || strlen(string) == 0) {
+        return string;
+    }
+
+    char *fixed = string;       // Fixed version of the string
+    // remove the single-quotes at front/end
+    if (fixed[0] == '\'' && fixed[strlen(string)-1] == '\'') {
+        string[strlen(string)-1] = '\0'; // Remove the trailing quote
+        fixed += 1; // Advance past the leading quote
+    }
+    // Remove trailing spaces, which are not significant, according to the FITS standard
+    // http://archive.stsci.edu/fits/fits_standard/node31.html
+    char *lastSpace = NULL; // The last space in the string
+    while (strlen(fixed) > 1 && (lastSpace = strrchr(fixed, ' ')) && lastSpace[1] == '\0') {
+        // This is a trailing space, not a leading space.
+        lastSpace[0] = '\0'; // Truncate the string here
+    }
+
+    return fixed;
+}
+
+// Read the header
+static psMetadata *readHeader(const psFits *fits // FITS file from which to read header
+                              )
+{
+    assert(fits);
+
+    psMetadata *header = psMetadataAlloc(); // Header, to return
 
     // Get number of key names
@@ -74 +187 @@
 
         // Check to see if the keyword should be ignored
-        bool ignoreKey = false;         // Ignore this keyword?
-        for (int i = 0; ignoreFitsKeys[i] && !ignoreKey; i++) {
-            if (strcmp(keyName, ignoreFitsKeys[i]) == 0) {
-                ignoreKey = true;
-            }
-        }
-        if (ignoreKey) {
+        if (keywordInList(keyName, ignoreFitsKeys)) {
             // We're done here; skip to the next key
             continue;
         }
 
-#if 0
-        // This doesn't seem to be necessary
-        if (strncmp(keyName, "HIERARCH ", 9) == 0) {
-            char temp[MAX_STRING_LENGTH];
-            strcpy(temp, &keyName[9]);
-            strcpy(keyName, temp);
-        }
-#endif
-
         // Check to see if the keyword should be duplicated
         int dupFlag = 0;                // Duplicate flag
-        for (int i = 0; duplicateFitsKeys[i] && !dupFlag; i++) {
-            if (strcmp(keyName, duplicateFitsKeys[i]) == 0) {
-                dupFlag = PS_META_DUPLICATE_OK;
-            }
+        if (keywordInList(keyName, duplicateFitsKeys)) {
+            dupFlag = PS_META_DUPLICATE_OK;
         }
 
@@ -116 +212 @@
         case 'X': // bit
         case 'B': // byte
-            success = psMetadataAddS8(out, PS_LIST_TAIL, keyName, dupFlag, keyComment, atoi(keyValue));
+            success = psMetadataAddS8(header, PS_LIST_TAIL, keyName, dupFlag, keyComment, atoi(keyValue));
             break;
         case 'I': // short int.
@@ -122 +218 @@
             // Trap NAN, INF and -INF, which cfitsio doesn't handle.
             if (strncasecmp(keyValue, "NAN", 3) == 0) {
-                success = psMetadataAddF32(out, PS_LIST_TAIL, keyName, dupFlag, keyComment, NAN);
+                success = psMetadataAddF32(header, PS_LIST_TAIL, keyName, dupFlag, keyComment, NAN);
             } else if (strncasecmp(keyValue, "INF", 3) == 0) {
-                success = psMetadataAddF32(out, PS_LIST_TAIL, keyName, dupFlag, keyComment, INFINITY);
+                success = psMetadataAddF32(header, PS_LIST_TAIL, keyName, dupFlag, keyComment, INFINITY);
             } else if (strncasecmp(keyValue, "-INF", 4) == 0) {
-                success = psMetadataAddF32(out, PS_LIST_TAIL, keyName, dupFlag, keyComment, -INFINITY);
+                success = psMetadataAddF32(header, PS_LIST_TAIL, keyName, dupFlag, keyComment, -INFINITY);
             } else {
-                success = psMetadataAddS32(out, PS_LIST_TAIL, keyName, dupFlag, keyComment, atoi(keyValue));
+                success = psMetadataAddS32(header, PS_LIST_TAIL, keyName, dupFlag, keyComment,
+                                           atoi(keyValue));
             }
             break;
         case 'J': // int.
-            success = psMetadataAddS32(out, PS_LIST_TAIL, keyName, dupFlag, keyComment, atoi(keyValue));
+            success = psMetadataAddS32(header, PS_LIST_TAIL, keyName, dupFlag, keyComment, atoi(keyValue));
             break;
         case 'U': // unsigned int.
-            success = psMetadataAddU32(out, PS_LIST_TAIL, keyName, dupFlag, keyComment, atol(keyValue));
+            success = psMetadataAddU32(header, PS_LIST_TAIL, keyName, dupFlag, keyComment, atol(keyValue));
             break;
 
         case 'K': // long int. can't all fit in a psS32, put in psF64
         case 'F':
-            success = psMetadataAddF64(out, PS_LIST_TAIL, keyName, dupFlag, keyComment, atof(keyValue));
+            success = psMetadataAddF64(header, PS_LIST_TAIL, keyName, dupFlag, keyComment, atof(keyValue));
             break;
         case 'C': {
-                char *keyValueFixed = keyValue; // Fixed version of the string
-                // remove the single-quotes at front/end
-                if (keyValueFixed[0] == '\'' && keyValueFixed[strlen(keyValue)-1] == '\'') {
-                    keyValue[strlen(keyValue)-1] = '\0'; // Remove the trailing quote
-                    keyValueFixed += 1; // Advance past the leading quote
-                }
-                // Remove trailing spaces, which are not significant, according to the FITS standard
-                // http://archive.stsci.edu/fits/fits_standard/node31.html
-                char *lastSpace = NULL; // The last space in the string
-                while (strlen(keyValueFixed) > 1 && (lastSpace = strrchr(keyValueFixed, ' ')) &&
-                        lastSpace[1] == '\0') {
-                    // This is a trailing space, not a leading space.
-                    lastSpace[0] = '\0'; // Truncate the string here
-                }
-
-                // Need to trap NAN, INF and -INF written by psFitsWriteHeader.
-                // cfitsio won't write these, so we write them as strings, and then have to trap them on read.
-                if (strcasecmp(keyValueFixed, "NAN") == 0) {
-                    success = psMetadataAddF32(out, PS_LIST_TAIL, keyName, dupFlag, keyComment, NAN);
-                } else if (strcasecmp(keyValueFixed, "INF") == 0) {
-                    success = psMetadataAddF32(out, PS_LIST_TAIL, keyName, dupFlag, keyComment, INFINITY);
-                } else if (strcasecmp(keyValueFixed, "-INF") == 0) {
-                    success = psMetadataAddF32(out, PS_LIST_TAIL, keyName, dupFlag, keyComment, -INFINITY);
-                } else {
-                    success = psMetadataAddStr(out, PS_LIST_TAIL, keyName, dupFlag, keyComment,
-                                               keyValueFixed);
-                }
-                break;
+            char *keyValueFixed = p_psFitsHeaderParseString(keyValue); // Fixed version of the string
+
+            // Need to trap NAN, INF and -INF written by psFitsWriteHeader.
+            // cfitsio won't write these, so we write them as strings, and then have to trap them on read.
+            if (strcasecmp(keyValueFixed, "NAN") == 0) {
+                success = psMetadataAddF32(header, PS_LIST_TAIL, keyName, dupFlag, keyComment, NAN);
+            } else if (strcasecmp(keyValueFixed, "INF") == 0) {
+                success = psMetadataAddF32(header, PS_LIST_TAIL, keyName, dupFlag, keyComment, INFINITY);
+            } else if (strcasecmp(keyValueFixed, "-INF") == 0) {
+                success = psMetadataAddF32(header, PS_LIST_TAIL, keyName, dupFlag, keyComment, -INFINITY);
+            } else if (!fits->conventions.compression ||
+                       (strcmp(keyName, "EXTNAME") != 0 || strcmp(keyValueFixed, "COMPRESSED_IMAGE") != 0)) {
+                // Ignore EXTNAME=COMPRESSED_IMAGE if compression convention is to be respected
+                success = psMetadataAddStr(header, PS_LIST_TAIL, keyName, dupFlag, keyComment,
+                                           keyValueFixed);
             }
+            break;
+        }
         case 'L': {
-                bool temp = (keyValue[0] == 'T') ? 1 : 0;
-                success = psMetadataAddBool(out, PS_LIST_TAIL, keyName, dupFlag, keyComment, temp);
-                break;
-            }
+            bool temp = (keyValue[0] == 'T') ? 1 : 0;
+            success = psMetadataAddBool(header, PS_LIST_TAIL, keyName, dupFlag, keyComment, temp);
+            break;
+        }
         default:
             psError(PS_ERR_IO, true, _("Specified FITS metadata type, %c, is not supported."), keyType);
-            return out;
+            psFree(header);
+            return NULL;
         }
 
         if (!success) {
             psError(PS_ERR_UNKNOWN, false, _("Failed to add metadata item, %s."), keyName);
-            return out;
+            psFree(header);
+            return NULL;
         }
 
@@ -193 +281 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true, _("Failed to add metadata item, %s."), fitsErr);
-        return false;
-    }
-
+        psFree(header);
+        return false;
+    }
+
+    return header;
+}
+
+
+psMetadata* psFitsReadHeader(psMetadata* out,
+                             const psFits* fits)
+{
+    PS_ASSERT_FITS_NON_NULL(fits, NULL);
+
+    psMetadata *header = readHeader(fits); // Header
+    if (!header) {
+        return NULL;
+    }
+
+    // Explore the potential case that this is an empty PHU, and the first extension contains the sole image,
+    // which is compressed.
+    if (psFitsCheckSingleCompressedImagePHU(fits, header)) {
+        // This is really what we want, not the empty PHU
+        psTrace("psLib.fits", 1,
+                "This PHU should really be a compressed image --- getting that header instead.");
+        psFree(header);
+        header = readHeader(fits);
+        if (!header) {
+            return NULL;
+        }
+    }
+
+    if (!out) {
+        return header;
+    }
+
+    // Need to move header onto the nominated metadata
+    psMetadataIterator *iter = psMetadataIteratorAlloc(header, PS_LIST_HEAD, NULL); // Iterator
+    psMetadataItem *item;           // Item from iteration
+    while ((item = psMetadataGetAndIncrement(iter))) {
+        // Need to look for MULTI, which won't be picked up using the iterator.
+        psMetadataItem *multiCheckItem = psMetadataLookup(header, item->name);
+        assert(multiCheckItem);
+        unsigned int flag = 0;      // Flag to indicate MULTI; otherwise default action
+        if (multiCheckItem->type == PS_DATA_METADATA_MULTI) {
+            flag = PS_META_DUPLICATE_OK;
+        }
+        if (!psMetadataAddItem(out, item, PS_LIST_TAIL, flag)) {
+            psError(PS_ERR_UNKNOWN, false, "Unable to add header item %s to extant metadata.",
+                    item->name);
+            psFree(iter);
+            psFree(header);
+            return NULL;
+        }
+    }
+    psFree(iter);
+    psFree(header);
     return out;
 }
@@ -201 +342 @@
 psMetadata* psFitsReadHeaderSet(psMetadata* out, const psFits* fits)
 {
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psFits object can not NULL."));
-        psFree(out);
-        return NULL;
-    }
-
-    if (out == NULL) {
+    PS_ASSERT_FITS_NON_NULL(fits, NULL);
+
+    if (!out) {
         out = psMetadataAlloc();
     }
@@ -279 +416 @@
             // image, the NAXISn haven't been changed; or after converting to F32, the BITPIX hasn't been
             // changed) so we'll take care of that for them.
-            bool writeKey = true;           // Should we write this keyword?
-            for (int i = 0; noWriteFitsKeys[i] && writeKey; i++) {
-                if (strcmp(item->name, noWriteFitsKeys[i]) == 0) {
-                    writeKey = false;
-                }
-            }
-            if (!writeKey) {
+            if (keywordInList(item->name, noWriteFitsKeys)) {
                 // Don't write it; skip to the next key
                 continue;
@@ -294 +425 @@
                 // that go in are correct.  However, when we're writing a "blank" HDU (header only), we want
                 // to preserve NAXISn etc for reference, so we don't do this.
+                bool writeKey = true;   // Write this keyword?
                 for (int i = 0; noWriteFitsKeyStarts[i] && writeKey; i++) {
                     if (strncmp(item->name, noWriteFitsKeyStarts[i], strlen(noWriteFitsKeyStarts[i])) == 0) {
@@ -349 +481 @@
                         }
                     } else {
-                        fits_update_key(fits->fd, TFLOAT, item->name, &item->data.F32, item->comment, &status);
+                        fits_update_key(fits->fd, TFLOAT, item->name, &item->data.F32, item->comment,
+                                        &status);
                     }
                     break;
@@ -364 +497 @@
                         }
                     } else {
-                        fits_update_key(fits->fd, TDOUBLE, item->name, &item->data.F64, item->comment, &status);
+                        fits_update_key(fits->fd, TDOUBLE, item->name, &item->data.F64, item->comment,
+                                        &status);
                     }
                     break;
@@ -395 +529 @@
                       )
 {
-    if (!fits) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psFits object can not NULL."));
-        return false;
-    }
-
-    if (!output) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psMetadata was NULL.  Need a non-NULL psMetadata for operation to be performed."));
-        return false;
-    }
+    PS_ASSERT_FITS_NON_NULL(fits, false);
+    PS_ASSERT_METADATA_NON_NULL(output, false);
 
     return fitsWriteHeader(fits, output, true);
@@ -413 +540 @@
                      )
 {
-    if (!fits) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psFits object can not NULL."));
-        return false;
-    }
+    PS_ASSERT_FITS_NON_NULL(fits, false);
 
     // We allow output == NULL in order to write a minimal header.
@@ -458 +582 @@
 bool psFitsHeaderValidate(psMetadata *header)
 {
-    if (header == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psMetadata was NULL.  Need a non-NULL psMetadata for operation to be performed."));
-        return false;
-    }
+    PS_ASSERT_METADATA_NON_NULL(header, false);
 
     // Traverse the metadata list and inspect at each key

trunk/psLib/src/fits/psFitsHeader.h

@@ -4 +4 @@
  * @author Robert DeSonia, MHPCC
  *
- * @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
- * @date $Date: 2007-01-23 22:47:23 $
+ * @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
+ * @date $Date: 2007-10-03 21:27:21 $
  *
  * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -18 +18 @@
 #include "psFits.h"
 #include "psMetadata.h"
+
+
+/// Determine whether the current HDU is an empty PHU with a single compressed image following.
+///
+/// In that case, what should be treated as an image PHU is technically an empty PHU with a binary table
+/// extension.  We test the current position, number of extensions, the FITS headers and presence of a
+/// following compressed image to determine if this is the case.  If so, the FITS file pointer is left
+/// pointing at the compressed image.
+bool psFitsCheckSingleCompressedImagePHU(const psFits *fits, ///< FITS file pointer
+                                         const psMetadata *header ///< Header, or NULL
+    );
+
+/// Parse a string read from the FITS header.
+
+/// Removes the quotes, and any trailing spaces.  NOTE: the returned string is NOT on the psLib memory system
+/// --- it's simply a hacked version of the input string.  Note also that the input string is MODIFIED.
+char *p_psFitsHeaderParseString(char *string ///< String to parse
+    );
 
 /** Reads the header of the current HDU.

trunk/psLib/src/fits/psFitsImage.c

@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.17 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-01-09 22:38:52 $
+ *  @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-10-03 21:27:21 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -38 +38 @@
 
 // Information required to read a FITS file
-typedef struct
-{
+typedef struct {
     int nAxis;                          // Number of axes
     int bitPix;                         // Bits per pixel
@@ -48 +47 @@
     int fitsDatatype;                   // cfitsio data type
     int psDatatype;                     // psLib data type
-}
-p_psFitsReadInfo;
+} p_psFitsReadInfo;
 
 static p_psFitsReadInfo *p_psFitsReadInfoAlloc(const psFits *fits, // The FITS file handle
@@ -56 +54 @@
                                               )
 {
-    PS_ASSERT_PTR_NON_NULL(fits, NULL);
+    PS_ASSERT_FITS_NON_NULL(fits, NULL);
     PS_ASSERT_INT_NONNEGATIVE(z, NULL);
 
@@ -221 +219 @@
                         )
 {
+    PS_ASSERT_FITS_NON_NULL(fits, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(z, NULL);
+
+    if (psFitsCheckSingleCompressedImagePHU(fits, NULL)) {
+        // This is really what we want, not the empty PHU
+        psTrace("psLib.fits", 1,
+                "This PHU should really be a compressed image --- reading that image instead.");
+    }
+
     p_psFitsReadInfo *info = p_psFitsReadInfoAlloc(fits, region, z);
 
@@ -243 +250 @@
                               )
 {
+    PS_ASSERT_FITS_NON_NULL(fits, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(z, NULL);
+
     if (output && output->parent) {
         psError(PS_ERR_IO, true, "Unable to read into a buffer for a child image.\n");
         return NULL;
+    }
+
+    if (psFitsCheckSingleCompressedImagePHU(fits, NULL)) {
+        // This is really what we want, not the empty PHU
+        psTrace("psLib.fits", 1,
+                "This PHU should really be a compressed image --- reading that image instead.");
     }
 
@@ -270 +286 @@
                       const char* extname)
 {
+    PS_ASSERT_FITS_NON_NULL(fits, false);
+    PS_ASSERT_IMAGE_NON_NULL(input, false);
     // this is equivalent to insert after the last HDU
 
@@ -283 +301 @@
                        bool after)
 {
-
-    if (!fits) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psFits object can not NULL."));
-        return false;
-    }
-
-    if (!input) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psImage was NULL.  Need a non-NULL psImage for operation to be performed."));
-        return false;
-    }
+    PS_ASSERT_FITS_NON_NULL(fits, false);
+    PS_ASSERT_IMAGE_NON_NULL(input, false);
 
     int numCols = input->numCols;       // Number of columns for image
@@ -391 +401 @@
                        int z)
 {
+    PS_ASSERT_FITS_NON_NULL(fits, false);
+    PS_ASSERT_IMAGE_NON_NULL(input, false);
+
     int status = 0;
-
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return false;
-    }
-
-    if (input == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psImage was NULL.  Need a non-NULL psImage for operation to be performed."));
-        return false;
-    }
 
     // check to see if we are positioned on an image HDU
@@ -499 +500 @@
 psArray *psFitsReadImageCube(const psFits *fits, psRegion region)
 {
+    PS_ASSERT_FITS_NON_NULL(fits, NULL);
+
     int nAxis = 0;                      // Number of axes
     long nAxes[3];                      // Number of pixels on each axis
@@ -504 +507 @@
     char fitsErr[80] = "";              // CFITSIO error message string
 
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return NULL;
-    }
-
     // Some of this replicates what is in psFitsReadImage, so it's a little inefficient.  But it saves
     // code replication, and should be sufficient for our needs.
+
+    if (psFitsCheckSingleCompressedImagePHU(fits, NULL)) {
+        // This is really what we want, not the empty PHU
+        psTrace("psLib.fits", 1,
+                "This PHU should really be a compressed image --- reading that image instead.");
+    }
 
     if (fits_get_img_dim(fits->fd, &nAxis, &status) != 0) {
@@ -544 +547 @@
 
     // Bad dimensionality
-    psError(PS_ERR_IO, true, _("Image number of dimensions, %d, is not valid.  Only two or three dimensions supported for FITS I/O."), nAxis);
+    psError(PS_ERR_IO, true,
+            _("Image number of dimensions, %d, is not valid."
+              " Only two or three dimensions supported for FITS I/O."), nAxis);
     return NULL;
 }
@@ -550 +555 @@
 bool psFitsWriteImageCube(psFits *fits, psMetadata *header, const psArray *input, const char *extname)
 {
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return false;
-    }
-
-    if (input == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psImage was NULL.  Need a non-NULL psImage for operation to be performed."));
-        return false;
-    }
+    PS_ASSERT_FITS_NON_NULL(fits, false);
+    PS_ASSERT_ARRAY_NON_NULL(input, false);
 
     if (input->n == 0) {
@@ -592 +588 @@
     }
     bool update = psMetadataAddS32(headerCopy, PS_LIST_HEAD, "NAXIS", PS_META_REPLACE, "Dimensionality", 3) &&
-                  psMetadataAddS32(headerCopy, PS_LIST_HEAD, "NAXIS1", PS_META_REPLACE, "Number of columns", numCols) &&
-                  psMetadataAddS32(headerCopy, PS_LIST_HEAD, "NAXIS2", PS_META_REPLACE, "Number of rows", numRows) &&
-                  psMetadataAddS32(headerCopy, PS_LIST_HEAD, "NAXIS3", PS_META_REPLACE, "Number of image planes",
-                                   input->n);
+        psMetadataAddS32(headerCopy, PS_LIST_HEAD, "NAXIS1", PS_META_REPLACE, "Number of columns", numCols) &&
+        psMetadataAddS32(headerCopy, PS_LIST_HEAD, "NAXIS2", PS_META_REPLACE, "Number of rows", numRows) &&
+        psMetadataAddS32(headerCopy, PS_LIST_HEAD, "NAXIS3", PS_META_REPLACE, "Number of image planes",
+                         input->n);
     if (! update) {
         psError(PS_ERR_UNKNOWN, false, _("Failed to add metadata item, %s."),
@@ -625 +621 @@
 bool psFitsUpdateImageCube(psFits *fits, const psArray *input, int x0, int y0)
 {
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return false;
-    }
-
-    if (input == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psImage was NULL.  Need a non-NULL psImage for operation to be performed."));
-        return false;
-    }
+    PS_ASSERT_FITS_NON_NULL(fits, false);
+    PS_ASSERT_ARRAY_NON_NULL(input, false);
 
     if (input->n == 0) {

trunk/psLib/src/fits/psFitsTable.c

@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-03-22 21:40:47 $
+ *  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-10-03 21:27:21 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -38 +38 @@
                                int row)
 {
+    PS_ASSERT_FITS_NON_NULL(fits, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(row, NULL);
+
     long numRows;
     int numCols;
     int status = 0;
-
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return NULL;
-    }
 
     // check to see if we even are positioned on a table HDU
@@ -185 +182 @@
                                const char* colname)
 {
+    PS_ASSERT_FITS_NON_NULL(fits, NULL);
+    PS_ASSERT_STRING_NON_EMPTY(colname, NULL);
+
     int colnum = 0;
     int status = 0;
-
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return NULL;
-    }
 
     // check to see if we even are positioned on a table HDU
@@ -266 +260 @@
                                    const char* colname)
 {
+    PS_ASSERT_FITS_NON_NULL(fits, NULL);
+    PS_ASSERT_STRING_NON_EMPTY(colname, NULL);
+
     int status = 0;
     int colnum = 0;
-
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return NULL;
-    }
 
     // check to see if we even are positioned on a table HDU
@@ -348 +339 @@
 psArray* psFitsReadTable(const psFits* fits)
 {
+    PS_ASSERT_FITS_NON_NULL(fits, NULL);
+
     int status = 0;
-
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return NULL;
-    }
 
     // check to see if we even are positioned on a table HDU
@@ -400 +387 @@
                       const char *extname)
 {
-    psFitsMoveLast(fits);
+    PS_ASSERT_FITS_NON_NULL(fits, false);
+    if (!psFitsMoveLast(fits)) {
+        psError(PS_ERR_UNKNOWN, false, "Unable to move to last extension to write table");
+        return false;
+    }
     return psFitsInsertTable(fits, header, table, extname, true);
 }
@@ -460 +451 @@
 // Column specification
 // Included here, because there's no need for the user to have access to it
-typedef struct
-{
+typedef struct {
     psDataType type;                    // psLib type (e.g., PS_DATA_STRING or PS_TYPE_F32)
     size_t size;                        // Size (number of repeats)
     psElemType vectorType;              // psLib type of vectors
-}
-colSpec;
+} colSpec;
 
 
@@ -475 +464 @@
                        bool after)
 {
+    PS_ASSERT_FITS_NON_NULL(fits, false);
+    PS_ASSERT_ARRAY_NON_NULL(table, false);
+
     int status = 0;
-
-    PS_ASSERT_PTR_NON_NULL(fits, false);
-    PS_ASSERT_ARRAY_NON_NULL(table, false);
 
     long numRows = table->n;
@@ -614 +603 @@
         char fitsErr[MAX_STRING_LENGTH];
         fits_get_errstatus(status, fitsErr);
-        psError(PS_ERR_LOCATION_INVALID, true, "Unable to create FITS table with %ld columns and %ld rows: %s",
+        psError(PS_ERR_LOCATION_INVALID, true,
+                "Unable to create FITS table with %ld columns and %ld rows: %s",
                 numColumns, table->n, fitsErr);
         psFree(colSpecsIter);
@@ -632 +622 @@
     if (extname && strlen(extname) > 0) {
         if (!psFitsSetExtName(fits, extname)) {
-            psError(PS_ERR_IO, false, "Unable to write FITS header extension name.\n");
-            psFree(colSpecsIter);
-            psFree(colSpecs);
-            return false;
-        }
+            psError(PS_ERR_IO, false, "Unable to write FITS header extension name.\n");
+            psFree(colSpecsIter);
+            psFree(colSpecs);
+            return false;
+        }
     }
 
@@ -728 +718 @@
                        int row)
 {
+    PS_ASSERT_FITS_NON_NULL(fits, false);
+    PS_ASSERT_METADATA_NON_NULL(data, false);
+    PS_ASSERT_INT_NONNEGATIVE(row, false);
+
     int status = 0;
-
-    if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psFits object can not NULL."));
-        return false;
-    }
-
-    if (data == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                _("The input psImage was NULL.  Need a non-NULL psImage for operation to be performed."));
-        return false;
-    }
 
     // check to see if we even are positioned on a table HDU