Changeset 24951 for branches/czw_branch/cleanup/psModules/src/camera

Timestamp:

Jul 30, 2009, 5:20:29 PM (17 years ago)

Author:

watersc1

Message:

Finished up my edits to the detrend cleanup, and some changes to my
copy of burntool and the pslib astrometry. Detrend cleanup has not
been tested yet. That's up next.

Location:

branches/czw_branch/cleanup

Files:

• . (modified) (1 prop)
• psModules/src/camera/Makefile.am (modified) (2 diffs)
• psModules/src/camera/pmFPABin.c (modified) (1 diff)
• psModules/src/camera/pmFPAMaskWeight.c (modified) (3 diffs)
• psModules/src/camera/pmFPARead.c (modified) (18 diffs)
• psModules/src/camera/pmFPARead.h (modified) (6 diffs)
• psModules/src/camera/pmFPAWrite.c (modified) (2 diffs)
• psModules/src/camera/pmFPAfileFringeIO.c (copied) (copied from trunk/psModules/src/camera/pmFPAfileFringeIO.c )
• psModules/src/camera/pmFPAfileFringeIO.h (copied) (copied from trunk/psModules/src/camera/pmFPAfileFringeIO.h )
• psModules/src/camera/pmFPAfileIO.c (modified) (3 diffs)
• psModules/src/camera/pmHDUGenerate.c (modified) (4 diffs)
• psModules/src/camera/pmReadoutStack.c (modified) (2 diffs)

branches/czw_branch/cleanup/psModules/src/camera/Makefile.am

@@ -23 +23 @@
         pmFPAfileIO.c \
         pmFPAfileFitsIO.c \
+        pmFPAfileFringeIO.c \
         pmFPAFlags.c \
         pmFPALevel.c \
@@ -51 +52 @@
         pmFPAfileIO.h \
         pmFPAfileFitsIO.h \
+        pmFPAfileFringeIO.h \
         pmFPAFlags.h \
         pmFPALevel.h \

branches/czw_branch/cleanup/psModules/src/camera/pmFPABin.c

@@ -60 +60 @@
                         continue;
                     }
+                    if (!isfinite(inImage->data.F32[y][x])) {
+                        continue;
+                    }
                     sum += inImage->data.F32[y][x];
                     numPix++;

branches/czw_branch/cleanup/psModules/src/camera/pmFPAMaskWeight.c

@@ -109 +109 @@
     float saturation = psMetadataLookupF32(&mdok, cell->concepts, "CELL.SATURATION"); // Saturation level
     if (!mdok || isnan(saturation)) {
-        psError(PS_ERR_IO, true, "CELL.SATURATION is not set --- unable to set mask.\n");
-        return false;
+        // psError(PS_ERR_IO, true, "CELL.SATURATION is not set --- unable to set mask.\n");
+        // return false;
+        psWarning("CELL.SATURATION is not set --- completely masking cell.\n");
+        saturation = NAN;
     }
     float bad = psMetadataLookupF32(&mdok, cell->concepts, "CELL.BAD"); // Bad level
     if (!mdok || isnan(bad)) {
-        psError(PS_ERR_IO, true, "CELL.BAD is not set --- unable to set mask.\n");
-        return false;
+        // psError(PS_ERR_IO, true, "CELL.BAD is not set --- unable to set mask.\n");
+        // return false;
+        psWarning("CELL.BAD is not set --- completely masking cell.\n");
+        bad = NAN;
     }
     psTrace("psModules.camera", 5, "Saturation: %f, bad: %f\n", saturation, bad);
 
+    // if CELL.GAIN or CELL.READNOISE are not set, then the variance will be set to NAN; 
+    // in this case, we have to set the mask as well
+    float gain = psMetadataLookupF32(&mdok, cell->concepts, "CELL.GAIN"); // Cell gain
+    if (!mdok) { gain = NAN; }
+    float readnoise = psMetadataLookupF32(&mdok, cell->concepts, "CELL.READNOISE"); // Cell read noise
+    if (!mdok) { readnoise = NAN; }
 
     // Set up the mask
@@ -127 +137 @@
     }
     psImage *mask = readout->mask;      // The mask pixels
+
+    // completely mask if SATURATION or BAD are invalid
+    if (isnan(saturation) || isnan(bad) || isnan(gain) || isnan(readnoise)) {
+        psImageInit(mask, badMask);
+        return true;
+    }
+
     psImageInit(mask, 0);
 
@@ -210 +227 @@
     float gain = psMetadataLookupF32(&mdok, cell->concepts, "CELL.GAIN"); // Cell gain
     if (!mdok || isnan(gain)) {
-        psError(PS_ERR_IO, true, "CELL.GAIN is not set --- unable to set variance.\n");
-        return false;
+        // psError(PS_ERR_IO, true, "CELL.GAIN is not set --- unable to set variance.\n");
+        // return false;
+        psWarning("CELL.GAIN is not set --- setting variance to NAN\n");
+        gain = NAN;
     }
     float readnoise = psMetadataLookupF32(&mdok, cell->concepts, "CELL.READNOISE"); // Cell read noise
     if (!mdok || isnan(readnoise)) {
-        psError(PS_ERR_IO, true, "CELL.READNOISE is not set --- unable to set variance.\n");
-        return false;
-    }
-    if (psMetadataLookup(cell->concepts, "CELL.READNOISE.UPDATE")) {
+        // psError(PS_ERR_IO, true, "CELL.READNOISE is not set --- unable to set variance.\n");
+        // return false;
+        psWarning("CELL.READNOISE is not set --- setting variance to NAN\n");
+        readnoise = NAN;
+    }
+    // if we have a non-NAN readnoise, then we need to ensure it has been updated (not necessary if NAN)
+    if (!isnan(gain) && psMetadataLookup(cell->concepts, "CELL.READNOISE.UPDATE")) {
         psError(PS_ERR_IO, true, "CELL.READNOISE has not yet been updated for the gain");
         return false;
+    }
+
+    // for invalid input data, set the readout variance to NAN
+    if (isnan(gain) || isnan(readnoise)) {
+        if (!readout->variance) {
+            // generate the image if needed
+            readout->variance = psImageAlloc(readout->image->numCols, readout->image->numRows, PS_TYPE_F32);
+        }
+        // XXX need to set the mask, if defined
+        psImageInit(readout->variance, NAN);
+        return true;
     }
 

branches/czw_branch/cleanup/psModules/src/camera/pmFPARead.c

@@ -141 +141 @@
 // Determine number of readouts in the FITS file
 // In the process, reads the header and concepts
-static bool cellNumReadouts(pmCell *cell,    // Cell of interest
+static int cellNumReadouts(pmCell *cell,    // Cell of interest
                             psFits *fits,    // FITS file
                             pmConfig *config // Configuration
@@ -153 +153 @@
     if (!hdu || hdu->blankPHU) {
         psError(PS_ERR_IO, true, "Unable to find HDU");
-        return false;
+        return 0;
     }
     if (!pmCellReadHeader(cell, fits, config)) {
         psError(PS_ERR_IO, false, "Unable to read header for cell!\n");
-        return false;
+        return 0;
     }
     if (!pmConceptsReadCell(cell, PM_CONCEPT_SOURCE_HEADER | PM_CONCEPT_SOURCE_CELLS, true, NULL)) {
         psError(PS_ERR_IO, false, "Failed to read concepts for cell.\n");
-        return false;
+        return 0;
     }
 
@@ -169 +169 @@
     if (!mdok) {
         psError(PS_ERR_IO, true, "Unable to find NAXIS in header for extension %s\n", hdu->extname);
-        return false;
-    }
+        return 0;
+    }
+
     if (naxis == 0) {
         // No pixels to read
         psError(PS_ERR_IO, true, "No pixels in extension %s.", hdu->extname);
-        return false;
+        return 0;
     }
     if (naxis < 2 || naxis > 3) {
         psError(PS_ERR_IO, true, "NAXIS in header of extension %s (= %d) is not valid.\n",
                 hdu->extname, naxis);
-        return false;
+        return 0;
     }
     int naxis3;                     // Number of image planes
@@ -186 +187 @@
         if (!mdok) {
             psError(PS_ERR_IO, true, "Unable to find NAXIS3 in header for extension %s\n", hdu->extname);
-            return false;
+            return 0;
         }
     } else {
@@ -294 +295 @@
 static bool readoutMore(pmReadout *readout, // Readout of interest
                         psFits *fits,    // FITS file
-                        int z,          // Plane number
+                        int z,          // Plane number to read
+                        int *zMax,      // Max plane number in this cell
                         int numScans,   // Number of scans to read at a time
                         fpaReadType type, // Type of image
@@ -308 +310 @@
     // N readouts, but numScans set to 0.  only the first should report that it requires data,
     // even if all readouts lack the image pointer.
-    if (!image) {
+    if (numScans == 0) {
+      if (!image) {
         return true;
-    }
-
-    // If we have already read an image, this result implies we are done (no more to read)
-    if (numScans == 0) {
-        return false;
+      } else {
+        return false;
+      }
     }
 
@@ -322 +323 @@
         return false;
     }
-    int naxis3 = cellNumReadouts(cell, fits, config); // Number of planes
-    if (z >= naxis3) {
+    *zMax = cellNumReadouts(cell, fits, config); // Number of planes
+    if (z >= *zMax) {
         // No more to read
         return false;
@@ -484 +485 @@
                              psFits *fits, // FITS file
                              int z,     // Desired image plane
+                             int *zMax, // Max plane number in this cell
                              int numScans, // Number of scans (row or col depends on CELL.READDIR); 0 for all
                              int overlap, // Number of scans (row/col) to overlap between scans
@@ -509 +511 @@
 
     int naxis3 = cellNumReadouts(cell, fits, config); // Number of image planes
+    if (zMax) *zMax = naxis3;
+
     if (z >= naxis3) {
         psError(PS_ERR_IO, false, "Desired image plane (%d) exceeds available number (%d).",
@@ -1021 +1025 @@
 
 
-bool pmReadoutMore(pmReadout *readout, psFits *fits, int z, int numScans, pmConfig *config)
+bool pmReadoutMore(pmReadout *readout, psFits *fits, int z, int *zMax, int numScans, pmConfig *config)
 {
     PS_ASSERT_PTR_NON_NULL(readout, false);
     PS_ASSERT_FITS_NON_NULL(fits, false);
 
-    return readoutMore(readout, fits, z, numScans, FPA_READ_TYPE_IMAGE, config);
-}
-
-bool pmReadoutReadChunk(pmReadout *readout, psFits *fits, int z, int numScans, int overlap, pmConfig *config)
+    return readoutMore(readout, fits, z, zMax, numScans, FPA_READ_TYPE_IMAGE, config);
+}
+
+bool pmReadoutReadChunk(pmReadout *readout, psFits *fits, int z, int *zMax, int numScans, int overlap, pmConfig *config)
 {
     PS_ASSERT_PTR_NON_NULL(readout, false);
@@ -1036 +1040 @@
     PS_ASSERT_INT_NONNEGATIVE(numScans, false);
 
-    return readoutReadChunk(readout, fits, z, numScans, overlap, FPA_READ_TYPE_IMAGE, config);
+    return readoutReadChunk(readout, fits, z, zMax, numScans, overlap, FPA_READ_TYPE_IMAGE, config);
 }
 
@@ -1044 +1048 @@
     PS_ASSERT_FITS_NON_NULL(fits, false);
 
-    return readoutReadChunk(readout, fits, z, 0, 0, FPA_READ_TYPE_IMAGE, config);
+    return readoutReadChunk(readout, fits, z, NULL, 0, 0, FPA_READ_TYPE_IMAGE, config);
 }
 
@@ -1084 +1088 @@
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-bool pmReadoutMoreMask(pmReadout *readout, psFits *fits, int z, int numScans, pmConfig *config)
+bool pmReadoutMoreMask(pmReadout *readout, psFits *fits, int z, int *zMax, int numScans, pmConfig *config)
 {
     PS_ASSERT_PTR_NON_NULL(readout, false);
     PS_ASSERT_FITS_NON_NULL(fits, false);
 
-    return readoutMore(readout, fits, z, numScans, FPA_READ_TYPE_MASK, config);
-}
-
-bool pmReadoutReadChunkMask(pmReadout *readout, psFits *fits, int z, int numScans, int overlap,
+    return readoutMore(readout, fits, z, zMax, numScans, FPA_READ_TYPE_MASK, config);
+}
+
+bool pmReadoutReadChunkMask(pmReadout *readout, psFits *fits, int z, int *zMax, int numScans, int overlap,
                             pmConfig *config)
 {
@@ -1100 +1104 @@
     PS_ASSERT_INT_NONNEGATIVE(numScans, false);
 
-    return readoutReadChunk(readout, fits, z, numScans, overlap, FPA_READ_TYPE_MASK, config);
+    return readoutReadChunk(readout, fits, z, zMax, numScans, overlap, FPA_READ_TYPE_MASK, config);
 }
 
@@ -1108 +1112 @@
     PS_ASSERT_FITS_NON_NULL(fits, false);
 
-    return readoutReadChunk(readout, fits, z, 0, 0, FPA_READ_TYPE_MASK, config);
+    return readoutReadChunk(readout, fits, z, NULL, 0, 0, FPA_READ_TYPE_MASK, config);
 }
 
@@ -1139 +1143 @@
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-bool pmReadoutMoreVariance(pmReadout *readout, psFits *fits, int z, int numScans, pmConfig *config)
+bool pmReadoutMoreVariance(pmReadout *readout, psFits *fits, int z, int *zMax, int numScans, pmConfig *config)
 {
     PS_ASSERT_PTR_NON_NULL(readout, false);
     PS_ASSERT_FITS_NON_NULL(fits, false);
 
-    return readoutMore(readout, fits, z, numScans, FPA_READ_TYPE_VARIANCE, config);
-}
-
-bool pmReadoutReadChunkVariance(pmReadout *readout, psFits *fits, int z, int numScans, int overlap,
+    return readoutMore(readout, fits, z, zMax, numScans, FPA_READ_TYPE_VARIANCE, config);
+}
+
+bool pmReadoutReadChunkVariance(pmReadout *readout, psFits *fits, int z, int *zMax, int numScans, int overlap,
                               pmConfig *config)
 {
@@ -1155 +1159 @@
     PS_ASSERT_INT_NONNEGATIVE(numScans, false);
 
-    return readoutReadChunk(readout, fits, z, numScans, overlap, FPA_READ_TYPE_VARIANCE, config);
+    return readoutReadChunk(readout, fits, z, zMax, numScans, overlap, FPA_READ_TYPE_VARIANCE, config);
 }
 
@@ -1163 +1167 @@
     PS_ASSERT_FITS_NON_NULL(fits, false);
 
-    return readoutReadChunk(readout, fits, z, 0, 0, FPA_READ_TYPE_VARIANCE, config);
+    return readoutReadChunk(readout, fits, z, NULL, 0, 0, FPA_READ_TYPE_VARIANCE, config);
 }
 

branches/czw_branch/cleanup/psModules/src/camera/pmFPARead.h

@@ -21 +21 @@
                    psFits *fits,        ///< FITS file from which to read
                    int z,               ///< Readout number/plane; zero-offset indexing
+                   int *zMax,           ///< Max plane number in this cell
                    int numScans,        ///< Number of scans (rows/cols) to read
                    pmConfig *config     ///< Configuration
@@ -31 +32 @@
                         psFits *fits,   ///< FITS file from which to read
                         int z,          ///< Readout number/plane; zero-offset indexing
+                   int *zMax,           ///< Max plane number in this cell
                         int numScans,   ///< Number of scans (rows/cols) to read
                         int overlap,    ///< Overlap between consecutive reads
@@ -98 +100 @@
                        psFits *fits,    ///< FITS file from which to read
                        int z,           ///< Readout number/plane; zero-offset indexing
+                       int *zMax,       ///< Max plane number in this cell
                        int numScans,    ///< Number of scans (rows/cols) to read
                        pmConfig *config ///< Configuration
@@ -108 +111 @@
                             psFits *fits, ///< FITS file from which to read
                             int z,      ///< Readout number/plane; zero-offset indexing
+                            int *zMax,          ///< Max plane number in this cell
                             int numScans, ///< Number of scans (rows/cols) to read
                             int overlap, ///< Overlap between consecutive reads
@@ -150 +154 @@
                            psFits *fits, ///< FITS file from which to read
                            int z,       ///< Readout number/plane; zero-offset indexing
+                           int *zMax,   ///< Max plane number in this cell
                            int numScans, ///< Number of scans (rows/cols) to read
                            pmConfig *config ///< Configuration
@@ -160 +165 @@
                                 psFits *fits, ///< FITS file from which to read
                                 int z,    ///< Readout number/plane; zero-offset indexing
+                   int *zMax,           ///< Max plane number in this cell
                                 int numScans, ///< Number of scans (rows/cols) to read
                                 int overlap, ///< Overlap between consecutive reads

branches/czw_branch/cleanup/psModules/src/camera/pmFPAWrite.c

@@ -160 +160 @@
     psArray **imageArray = appropriateImageArray(hdu, type); // Array of images in the HDU
 
+    // XXX detect missing variance & mask images...
+
     // Generate the HDU if needed --- this is required after a pmFPACopy, or similar, which does not
     // generate the HDU, but only copies the structure.
-    if (!blank && !hdu->blankPHU && !*imageArray && (!pmHDUGenerateForCell(cell) || !*imageArray)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to generate HDU for cell --- likely programming error.");
-        return false;
+    if (!blank && !hdu->blankPHU && !*imageArray) {
+        if (!pmHDUGenerateForCell(cell)) {
+            psError(PS_ERR_UNKNOWN, false, "Unable to generate HDU for cell --- likely programming error.");
+            return false;
+        }
+        if (!*imageArray) {
+            if (type == FPA_WRITE_TYPE_IMAGE) {
+                psError(PS_ERR_UNKNOWN, false, "Expected to write an image, but it is missing...programming error?.");
+                return false;
+            }
+            if (type == FPA_WRITE_TYPE_MASK) {
+                psWarning("No mask image for this cell; skipping");
+            }
+            if (type == FPA_WRITE_TYPE_VARIANCE) {
+                psWarning("No variance image for this cell; skipping");
+            }
+            return true;
+        }
     }
 
@@ -724 +741 @@
     }
     if (!psFitsCompressionApply(fits, compress)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to set FITS compression to NONE");
+        psError(PS_ERR_UNKNOWN, false, "Unable to restore FITS compression");
         psFree(compress);
         return false;

branches/czw_branch/cleanup/psModules/src/camera/pmFPAfileIO.c

@@ -23 +23 @@
 #include "pmFPAWrite.h"
 #include "pmFPAfileFitsIO.h"
+#include "pmFPAfileFringeIO.h"
 #include "pmSpan.h"
 #include "pmFootprint.h"
@@ -192 +193 @@
         status = pmFPAviewReadFitsImage(view, file, config);
         if (status) {
-            if (!pmFPAviewReadFitsTable(view, file, "FRINGE")) {
+            if (!pmFPAviewReadFringes(view, file)) {
                 psError(PS_ERR_UNKNOWN, false, "Unable to read fringe data from %s.\n", file->filename);
                 return false;
@@ -451 +452 @@
         status = pmFPAviewWriteFitsImage (view, file, config);
         if (status) {
-            if (!pmFPAviewWriteFitsTable(view, file, "FRINGE", config)) {
+            if (!pmFPAviewWriteFringes(view, file, config)) {
                 psError(PS_ERR_UNKNOWN, false, "Unable to write fringe data from %s.\n", file->filename);
                 return false;

branches/czw_branch/cleanup/psModules/src/camera/pmHDUGenerate.c

@@ -390 +390 @@
     if (numReadouts == 0 || (imageType == 0 && maskType == 0 && varianceType == 0)) {
         // Nothing from which to create an HDU
-        psFree(cells);
-        psError(PS_ERR_IO, true, "Nothing from which to create an HDU\n");
-        return false;
+        // psError(PS_ERR_IO, true, "Nothing from which to create an HDU\n");
+        psWarning("Nothing from which to create an HDU, must be empty\n");
+        return true;
     }
 
@@ -504 +504 @@
         psFree(iter);
     }
-    psFree(cells);
-
     return true;
 }
@@ -615 +613 @@
                 return true;
             }
-
-            return generateHDU(hdu, cells);
+            bool status = generateHDU(hdu, cells);
+            psFree (cells);
+            return status;
         }
     case PM_FPA_LEVEL_CHIP:
@@ -664 +663 @@
             }
 
-            return generateHDU(hdu, cells);
+            bool status = generateHDU(hdu, cells);
+            psFree (cells);
+            return status;
         }
     case PM_FPA_LEVEL_FPA:

branches/czw_branch/cleanup/psModules/src/camera/pmReadoutStack.c

@@ -252 +252 @@
             continue;
         }
+        if (!readout->process) {
+            continue;
+        }
         if (!readout->image) {
             psError(PS_ERR_UNEXPECTED_NULL, true, "Input readout %ld has NULL image.\n", i);
@@ -260 +263 @@
         pmCell *cell = readout->parent; // The parent cell
         bool mdok = true;       // Status of MD lookup
-        psRegion *trimsec = psMetadataLookupPtr(&mdok, cell->concepts, "CELL.TRIMSEC"); // Trim section
+        psRegion *trimsec = cell ? psMetadataLookupPtr(&mdok, cell->concepts, "CELL.TRIMSEC") : NULL; // Trim section
         if (!mdok || !trimsec || psRegionIsNaN(*trimsec)) {
-            psWarning("CELL.TRIMSEC is not set for readout %ld --- ignored.\n", i);
+            psWarning("CELL.TRIMSEC is not set for readout %ld --- attempting to use image size.\n", i);
+            xSize = PS_MAX(xSize, readout->image->numCols);
+            ySize = PS_MAX(ySize, readout->image->numRows);
+            xMin = PS_MIN(xMin, 0);
+            xMax = PS_MAX(xMax, readout->image->numCols - 1);
+            yMin = PS_MIN(yMin, 0);
+            yMax = PS_MAX(yMax, readout->image->numRows - 1);
         } else {
             xSize = PS_MAX(xSize, trimsec->x1 - trimsec->x0);