Changeset 10081

Timestamp:

Nov 18, 2006, 1:43:28 PM (20 years ago)

Author:

Paul Price

Message:

Extensive changes to FPA reading/writing functions to support mask and weight map reading/writing. Actually, not so much changes as generalisations to the reading/writing functions. Moved the reading/writing functionality into file-static functions, which the higher level functions for reading/writing particular elements (image, mask, weight) call. Added additional pmFPAfile types for mask and weight, with supporting functionality to call the reading/writing functions.

Location:

trunk/psModules/src/camera

Files:

• pmFPARead.c (modified) (11 diffs)
• pmFPAWrite.c (modified) (4 diffs)
• pmFPAWrite.h (modified) (2 diffs)
• pmFPAfile.c (modified) (1 diff)
• pmFPAfile.h (modified) (2 diffs)
• pmFPAfileFitsIO.c (modified) (10 diffs)
• pmFPAfileFitsIO.h (modified) (2 diffs)
• pmFPAfileIO.c (modified) (7 diffs)
• pmHDU.c (modified) (5 diffs)
• pmHDU.h (modified) (3 diffs)

trunk/psModules/src/camera/pmFPARead.c

@@ -16 +16 @@
 
 #include "pmFPARead.h"
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Definitions
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// Specify what to read
+typedef enum {
+    FPA_READ_TYPE_IMAGE,                // Read image
+    FPA_READ_TYPE_MASK,                 // Read mask
+    FPA_READ_TYPE_WEIGHT                // Read weight map
+} fpaReadType;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -155 +166 @@
 }
 
+
+// Read into an cell; this is the engine for pmCellRead, pmCellReadMask, pmCellReadWeight
+// Does most of the work for the reading --- reads the HDU, and portions the HDU into readouts.
+static bool cellRead(pmCell *cell,      // Cell into which to read
+                     psFits *fits,      // FITS file from which to read
+                     psDB *db,          // Database handle, for concepts ingest
+                     fpaReadType type   // Type to read
+                    )
+{
+    assert(cell);
+    assert(fits);
+
+    pmHDU *hdu = pmHDUFromCell(cell);   // The HDU
+    if (!hdu) {
+        return true;                    // We read everything we could
+    }
+
+    bool (*hduReadFunc)(pmHDU*, psFits*); // Function to use to read the HDU
+    psArray **imageArray;               // Array of images in the HDU
+    psElemType imageType;               // Expected type for image
+    switch (type) {
+    case FPA_READ_TYPE_IMAGE:
+        hduReadFunc = pmHDURead;
+        imageArray = &hdu->images;
+        imageType = PS_TYPE_F32;
+        break;
+    case FPA_READ_TYPE_MASK:
+        hduReadFunc = pmHDUReadMask;
+        imageArray = &hdu->masks;
+        imageType = PS_TYPE_MASK;
+        break;
+    case FPA_READ_TYPE_WEIGHT:
+        hduReadFunc = pmHDUReadWeight;
+        imageArray = &hdu->weights;
+        imageType = PS_TYPE_F32;
+        break;
+    default:
+        psAbort(__func__, "Unknown read type: %x\n", type);
+    }
+
+    if (!(*imageArray) && !hduReadFunc(hdu, fits)) {
+        psError(PS_ERR_UNKNOWN, false, "Unable to read HDU for cell.\n");
+        return false;
+    }
+
+    if (!pmConceptsReadCell(cell, PM_CONCEPT_SOURCE_HEADER, true, NULL)) {
+        //psError(PS_ERR_UNKNOWN, false, "Failed to read concepts for cell");
+        //return false;
+        psWarning("Difficulty reading concepts for cell; attempting to proceed.");
+    }
+
+    // Having read the cell, we now have to cut it up
+    psRegion *trimsec = psMetadataLookupPtr(NULL, cell->concepts, "CELL.TRIMSEC");
+    psList *biassecs = psMetadataLookupPtr(NULL, cell->concepts, "CELL.BIASSEC");
+    if (psRegionIsNaN(*trimsec)) {
+        psError(PS_ERR_IO, false, "CELL.TRIMSEC is not set --- can't read cell.\n");
+        return false;
+    }
+
+    // Iterate over each of the image planes, converting type if necessary, and extracting the bits that
+    // matter (CELL.TRIMSEC, CELL.BIASSEC) into readouts with readoutCarve.
+    for (int i = 0; i < (*imageArray)->n; i++) {
+        psImage *source = (*imageArray)->data[i]; // Source image, from the i-th plane
+
+        // Type conversion here to support the modules, which don't have multiple type support yet
+        if (source->type.type != imageType) {
+            psImage *temp = psImageCopy(NULL, source, imageType); // Temporary image
+            psFree((*imageArray)->data[i]);
+            (*imageArray)->data[i] = temp;
+            source = temp;
+        }
+
+        pmReadout *readout;             // Readout into which to read
+        if (cell->readouts->n > i && cell->readouts->data[i]) {
+            readout = psMemIncrRefCounter(cell->readouts->data[i]);
+        } else {
+            readout = pmReadoutAlloc(cell);
+        }
+
+        psImage **target;               // Place in readout to put carved image
+        switch (type) {
+        case FPA_READ_TYPE_IMAGE:
+            target = &readout->image;
+            break;
+        case FPA_READ_TYPE_MASK:
+            target = &readout->mask;
+            break;
+        case FPA_READ_TYPE_WEIGHT:
+            target = &readout->weight;
+            break;
+        default:
+            psAbort(__func__, "Unknown read type: %x\n", type);
+        }
+
+        if (!readoutCarve(readout, target, source, trimsec, biassecs)) {
+            psError(PS_ERR_UNEXPECTED_NULL, false,
+                    "Unable to carve readout into image and bias sections for %d the plane.", i);
+            return NULL;
+        }
+        psFree(readout);                // Drop reference
+    }
+
+    pmCellSetDataStatus(cell, true);
+    return true;
+}
+
+
+// Read into an chip; this is the engine for pmChipRead, pmChipReadMask, pmChipReadWeight
+// Iterates over component cells, reading each
+static bool chipRead(pmChip *chip,      // Chip into which to read
+                     psFits *fits,      // FITS file from which to read
+                     psDB *db,          // Database handle, for concepts ingest
+                     fpaReadType type   // Type to read
+                    )
+{
+    assert(chip);
+    assert(fits);
+
+    bool success = false;               // Were we able to read at least one HDU?
+    psArray *cells = chip->cells;       // Array of cells
+    for (int i = 0; i < cells->n; i++) {
+        pmCell *cell = cells->data[i];  // The cell of interest
+        success |= cellRead(cell, fits, db, type);
+    }
+    if (success) {
+        if (!pmConceptsReadChip(chip, PM_CONCEPT_SOURCE_HEADER, true, true, NULL)) {
+            psError(PS_ERR_IO, false, "Failed to read concepts for FPA.\n");
+            return false;
+        }
+        // XXX probably could just use chip->data_exists
+        pmChipSetDataStatus(chip, true);
+    }
+
+    return success;
+}
+
+
+// Read into an FPA; this is the engine for pmFPARead, pmFPAReadMask, pmFPAReadWeight
+// Iterates over component chips, reading each
+static bool fpaRead(pmFPA *fpa,         // FPA into which to read
+                    psFits *fits,       // FITS file from which to read
+                    psDB *db,           // Database handle, for concepts ingest
+                    fpaReadType type    // Type to read
+                   )
+{
+    assert(fpa);
+    assert(fits);
+
+    bool success = false;               // Were we able to read at least one HDU?
+    psArray *chips = fpa->chips;        // Array of chips
+    for (int i = 0; i < chips->n; i++) {
+        pmChip *chip = chips->data[i];  // The cell of interest
+        success |= chipRead(chip, fits, db, type);
+    }
+    if (success) {
+        if (!pmConceptsReadFPA(fpa, PM_CONCEPT_SOURCE_HEADER, true, NULL)) {
+            psError(PS_ERR_IO, false, "Failed to read concepts for FPA.\n");
+            return false;
+        }
+    } else {
+        psError(PS_ERR_UNKNOWN, false, "Unable to read any chips in FPA");
+    }
+
+    return success;
+}
+
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Public functions
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Reading images
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -325 +507 @@
     PS_ASSERT_PTR_NON_NULL(fits, false);
 
-    pmHDU *hdu = pmHDUFromCell(cell);   // The HDU
-    if (!hdu) {
-        return true;                    // We read everything we could
-    }
-    if (!hdu->images && !pmHDURead(hdu, fits)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to read HDU for cell.\n");
-        return false;
-    }
-
-    if (!pmConceptsReadCell(cell, PM_CONCEPT_SOURCE_HEADER, true, NULL)) {
-        //psError(PS_ERR_UNKNOWN, false, "Failed to read concepts for cell");
-        //return false;
-        psWarning("Difficulty reading concepts for cell; attempting to proceed.");
-    }
-
-    // Having read the cell, we now have to cut it up
-    psRegion *trimsec = psMetadataLookupPtr(NULL, cell->concepts, "CELL.TRIMSEC");
-    psList *biassecs = psMetadataLookupPtr(NULL, cell->concepts, "CELL.BIASSEC");
-    if (psRegionIsNaN(*trimsec)) {
-        psError(PS_ERR_IO, false, "CELL.TRIMSEC is not set --- can't read cell.\n");
-        return false;
-    }
-
-    // Iterate over each of the image planes
-    for (int i = 0; i < hdu->images->n; i++) {
-        psImage *image = hdu->images->data[i]; // The i-th plane
-
-        // XXX: Type conversion here to support the modules, which don't have multiple type support yet
-        if (image->type.type != PS_TYPE_F32) {
-            psImage *temp = psImageCopy(NULL, image, PS_TYPE_F32); // Temporary image
-            psFree(hdu->images->data[i]);
-            hdu->images->data[i] = temp;
-            image = temp;
-        }
-
-        pmReadout *readout;             // Readout into which to read
-        if (cell->readouts->n > i && cell->readouts->data[i]) {
-            readout = psMemIncrRefCounter(cell->readouts->data[i]);
-        } else {
-            readout = pmReadoutAlloc(cell);
-        }
-        if (!readoutCarve(readout, &readout->image, image, trimsec, biassecs)) {
-            psError(PS_ERR_UNEXPECTED_NULL, false,
-                    "Unable to carve readout into image and bias sections for %d the plane.", i);
-            return NULL;
-        }
-        psFree(readout);                // Drop reference
-    }
-
-    pmCellSetDataStatus(cell, true);
-    return true;
+    return cellRead(cell, fits, db, FPA_READ_TYPE_IMAGE);
 }
 
@@ -383 +515 @@
     PS_ASSERT_PTR_NON_NULL(fits, false);
 
-    bool success = false;               // Were we able to read at least one HDU?
-    psArray *cells = chip->cells;       // Array of cells
-    for (int i = 0; i < cells->n; i++) {
-        pmCell *cell = cells->data[i];  // The cell of interest
-        success |= pmCellRead(cell, fits, db);
-    }
-    if (success) {
-        if (!pmConceptsReadChip(chip, PM_CONCEPT_SOURCE_HEADER, true, true, NULL)) {
-            psError(PS_ERR_IO, false, "Failed to read concepts for FPA.\n");
-            return false;
-        }
-        // XXX probably could just use chip->data_exists
-        pmChipSetDataStatus(chip, true);
-    }
-
-    return success;
+    return chipRead(chip, fits, db, FPA_READ_TYPE_IMAGE);
 }
 
@@ -406 +523 @@
     PS_ASSERT_PTR_NON_NULL(fits, false);
 
-    bool success = false;               // Were we able to read at least one HDU?
-    psArray *chips = fpa->chips;        // Array of chips
-    for (int i = 0; i < chips->n; i++) {
-        pmChip *chip = chips->data[i];  // The cell of interest
-        success |= pmChipRead(chip, fits, db);
-    }
-    if (success) {
-        if (!pmConceptsReadFPA(fpa, PM_CONCEPT_SOURCE_HEADER, true, NULL)) {
-            psError(PS_ERR_IO, false, "Failed to read concepts for FPA.\n");
-            return false;
-        }
-    } else {
-        psError(PS_ERR_UNKNOWN, false, "Unable to read any chips in FPA");
-    }
-
-    return success;
+    return fpaRead(fpa, fits, db, FPA_READ_TYPE_IMAGE);
 }
 
@@ -434 +536 @@
     PS_ASSERT_PTR_NON_NULL(fits, false);
 
-    pmHDU *hdu = pmHDUFromCell(cell);   // The HDU
-    if (!hdu) {
-        return false;                    // Nothing to see here; move along
-    }
-    if (!hdu->images && !pmHDURead(hdu, fits)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to read HDU for cell.\n");
-        return false;
-    }
-
-    if (!pmConceptsReadCell(cell, PM_CONCEPT_SOURCE_HEADER, true, NULL)) {
-        psError(PS_ERR_UNKNOWN, false, "Failed to read concepts for cell");
-        return false;
-    }
-
-    // Having read the cell, we now have to cut it up
-    psRegion *trimsec = psMetadataLookupPtr(NULL, cell->concepts, "CELL.TRIMSEC");
-
-    // Iterate over each of the image planes
-    for (int i = 0; i < hdu->images->n; i++) {
-        psImage *image = hdu->images->data[i]; // The i-th plane
-
-        if (image->type.type != PS_TYPE_U8) {
-            psImage *temp = psImageCopy(NULL, image, PS_TYPE_U8); // Temporary image
-            psFree(hdu->images->data[i]);
-            hdu->images->data[i] = temp;
-            image = temp;
-        }
-
-        pmReadout *readout;             // Readout into which to read
-        if (cell->readouts->n > i && cell->readouts->data[i]) {
-            readout = psMemIncrRefCounter(cell->readouts->data[i]);
-        } else {
-            readout = pmReadoutAlloc(cell);
-        }
-        if (!readoutCarve(readout, &readout->mask, image, trimsec, NULL)) {
-            psError(PS_ERR_UNEXPECTED_NULL, false,
-                    "Unable to carve readout into image and bias sections for %d the plane.", i);
-            return NULL;
-        }
-        psFree(readout);                // Drop reference
-    }
-
-    pmCellSetDataStatus(cell, true);
-    return true;
+    return cellRead(cell, fits, db, FPA_READ_TYPE_MASK);
 }
 
@@ -485 +544 @@
     PS_ASSERT_PTR_NON_NULL(fits, false);
 
-    bool success = false;               // Were we able to read at least one HDU?
-    psArray *cells = chip->cells;       // Array of cells
-    for (int i = 0; i < cells->n; i++) {
-        pmCell *cell = cells->data[i];  // The cell of interest
-        success |= pmCellReadMask(cell, fits, db);
-    }
-    if (success) {
-        if (!pmConceptsReadChip(chip, PM_CONCEPT_SOURCE_HEADER, true, true, NULL)) {
-            psError(PS_ERR_IO, false, "Failed to read concepts for FPA.\n");
-            return false;
-        }
-        // XXX probably could just use chip->data_exists
-        pmChipSetDataStatus(chip, true);
-    }
-
-    return success;
+    return chipRead(chip, fits, db, FPA_READ_TYPE_MASK);
 }
 
@@ -508 +552 @@
     PS_ASSERT_PTR_NON_NULL(fits, false);
 
-    bool success = false;               // Were we able to read at least one HDU?
-    psArray *chips = fpa->chips;        // Array of chips
-    for (int i = 0; i < chips->n; i++) {
-        pmChip *chip = chips->data[i];  // The cell of interest
-        success |= pmChipReadMask(chip, fits, db);
-    }
-    if (success) {
-        if (!pmConceptsReadFPA(fpa, PM_CONCEPT_SOURCE_HEADER, true, NULL)) {
-            psError(PS_ERR_IO, false, "Failed to read concepts for FPA.\n");
-            return false;
-        }
-    } else {
-        psError(PS_ERR_UNKNOWN, false, "Unable to read any chips in FPA");
-    }
-
-    return success;
+    return fpaRead(fpa, fits, db, FPA_READ_TYPE_MASK);
 }
 
@@ -535 +564 @@
     PS_ASSERT_PTR_NON_NULL(fits, false);
 
-    pmHDU *hdu = pmHDUFromCell(cell);   // The HDU
-    if (!hdu) {
-        return false;                    // Nothing to see here; move along
-    }
-    if (!hdu->images && !pmHDURead(hdu, fits)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to read HDU for cell.\n");
-        return false;
-    }
-
-    if (!pmConceptsReadCell(cell, PM_CONCEPT_SOURCE_HEADER, true, NULL)) {
-        psError(PS_ERR_UNKNOWN, false, "Failed to read concepts for cell");
-        return false;
-    }
-
-    // Having read the cell, we now have to cut it up
-    psRegion *trimsec = psMetadataLookupPtr(NULL, cell->concepts, "CELL.TRIMSEC");
-
-    // Iterate over each of the image planes
-    for (int i = 0; i < hdu->images->n; i++) {
-        psImage *image = hdu->images->data[i]; // The i-th plane
-
-        if (image->type.type != PS_TYPE_F32) {
-            psImage *temp = psImageCopy(NULL, image, PS_TYPE_F32); // Temporary image
-            psFree(hdu->images->data[i]);
-            hdu->images->data[i] = temp;
-            image = temp;
-        }
-
-        pmReadout *readout;             // Readout into which to read
-        if (cell->readouts->n > i && cell->readouts->data[i]) {
-            readout = psMemIncrRefCounter(cell->readouts->data[i]);
-        } else {
-            readout = pmReadoutAlloc(cell);
-        }
-        if (!readoutCarve(readout, &readout->weight, image, trimsec, NULL)) {
-            psError(PS_ERR_UNEXPECTED_NULL, false,
-                    "Unable to carve readout into image and bias sections for %d the plane.", i);
-            return NULL;
-        }
-        psFree(readout);                // Drop reference
-    }
-
-    pmCellSetDataStatus(cell, true);
-    return true;
+    return cellRead(cell, fits, db, FPA_READ_TYPE_WEIGHT);
 }
 
@@ -586 +572 @@
     PS_ASSERT_PTR_NON_NULL(fits, false);
 
-    bool success = false;               // Were we able to read at least one HDU?
-    psArray *cells = chip->cells;       // Array of cells
-    for (int i = 0; i < cells->n; i++) {
-        pmCell *cell = cells->data[i];  // The cell of interest
-        success |= pmCellReadWeight(cell, fits, db);
-    }
-    if (success) {
-        if (!pmConceptsReadChip(chip, PM_CONCEPT_SOURCE_HEADER, true, true, NULL)) {
-            psError(PS_ERR_IO, false, "Failed to read concepts for FPA.\n");
-            return false;
-        }
-        // XXX probably could just use chip->data_exists
-        pmChipSetDataStatus(chip, true);
-    }
-
-    return success;
+    return chipRead(chip, fits, db, FPA_READ_TYPE_WEIGHT);
 }
 
@@ -609 +580 @@
     PS_ASSERT_PTR_NON_NULL(fits, false);
 
-    bool success = false;               // Were we able to read at least one HDU?
-    psArray *chips = fpa->chips;        // Array of chips
-    for (int i = 0; i < chips->n; i++) {
-        pmChip *chip = chips->data[i];  // The cell of interest
-        success |= pmChipReadWeight(chip, fits, db);
-    }
-    if (success) {
-        if (!pmConceptsReadFPA(fpa, PM_CONCEPT_SOURCE_HEADER, true, NULL)) {
-            psError(PS_ERR_IO, false, "Failed to read concepts for FPA.\n");
-            return false;
-        }
-    } else {
-        psError(PS_ERR_UNKNOWN, false, "Unable to read any chips in FPA");
-    }
-
-    return success;
-}
-
+    return fpaRead(fpa, fits, db, FPA_READ_TYPE_WEIGHT);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Reading FITS tables
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 int pmCellReadTable(pmCell *cell, psFits *fits, const char *name)

trunk/psModules/src/camera/pmFPAWrite.c

@@ -14 +14 @@
 
 #include "pmFPAWrite.h"
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Definitions
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// Specify what to read
+typedef enum {
+    FPA_WRITE_TYPE_IMAGE,               // Write image
+    FPA_WRITE_TYPE_MASK,                // Write mask
+    FPA_WRITE_TYPE_WEIGHT               // Write weight map
+} fpaWriteType;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// File-static (private) functions
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// Return the appropriate image array for the given type
+static psArray **appropriateImageArray(pmHDU *hdu, // HDU containing the image arrays
+                                       fpaWriteType type // Type to write
+                                      )
+{
+    switch (type) {
+    case FPA_WRITE_TYPE_IMAGE:
+        return &hdu->images;
+    case FPA_WRITE_TYPE_MASK:
+        return &hdu->masks;
+    case FPA_WRITE_TYPE_WEIGHT:
+        return &hdu->weights;
+    default:
+        psAbort(__func__, "Unknown write type: %x\n", type);
+    }
+    return NULL;
+}
+
+// Run the appropriate HDU write function
+static bool appropriateWriteFunc(pmHDU *hdu, // HDU to write
+                                 psFits *fits, // FITS file to which to write
+                                 fpaWriteType type // Type to write
+                                )
+{
+    switch (type) {
+    case FPA_WRITE_TYPE_IMAGE:
+        return pmHDUWrite(hdu, fits);
+    case FPA_WRITE_TYPE_MASK:
+        return pmHDUWriteMask(hdu, fits);
+    case FPA_WRITE_TYPE_WEIGHT:
+        return pmHDUWriteWeight(hdu, fits);
+    default:
+        psAbort(__func__, "Unknown write type: %x\n", type);
+    }
+    return false;
+}
+
+// Write a cell image/mask/weight
+static bool cellWrite(pmCell *cell,     // Cell to write
+                      psFits *fits,     // FITS file to which to write
+                      psDB *db,         // Database handle for "concepts" update
+                      bool blank,       // Write a blank PHU?
+                      fpaWriteType type // Type to write
+                     )
+{
+    assert(cell);
+    assert(fits);
+
+    psTrace ("pmFPAWrite", 5, "writing to Cell (%d)\n", blank);
+
+    pmHDU *hdu = cell->hdu;             // The HDU
+    if (!hdu) {
+        return true;                    // We wrote every HDU that exists
+    }
+
+    psArray **imageArray = appropriateImageArray(hdu, type); // Array of images in the HDU
+
+    // 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 (!hdu->blankPHU && !*imageArray && (!pmHDUGenerateForCell(cell) || !*imageArray)) {
+        psError(PS_ERR_UNKNOWN, false, "Unable to generate HDU for cell --- likely programming error.\n");
+        return false;
+    }
+
+    // We only write out a blank PHU if it's specifically requested.
+    bool writeBlank = blank && hdu->blankPHU && !*imageArray; // Write a blank PHU?
+    bool writeImage = !blank && !hdu->blankPHU && *imageArray; // Write an image?
+
+    if (writeBlank || writeImage) {
+        pmConceptSource source = PM_CONCEPT_SOURCE_HEADER | PM_CONCEPT_SOURCE_CELLS |
+                                 PM_CONCEPT_SOURCE_DEFAULTS;
+        if (!pmConceptsWriteCell(cell, source, false, NULL)) {
+            psError(PS_ERR_IO, false, "Unable to write concepts for cell.\n");
+            return false;
+        }
+        if (!appropriateWriteFunc(hdu, fits, type)) {
+            psError(PS_ERR_IO, false, "Unable to write HDU for cell.\n");
+            return false;
+        }
+    }
+    // No lower levels to which to recurse
+
+    return true;
+}
+
+// Write a chip image/mask/weight
+static bool chipWrite(pmChip *chip,     // Chip to write
+                      psFits *fits,     // FITS file to which to write
+                      psDB *db,         // Database handle for "concepts" update
+                      bool blank,       // Write a blank PHU?
+                      bool recurse,     // Recurse to lower levels?
+                      fpaWriteType type // Type to write
+                     )
+{
+    assert(chip);
+    assert(fits);
+
+    pmHDU *hdu = chip->hdu;             // The HDU
+
+    psTrace ("pmFPAWrite", 5, "writing to Chip (%d, %d)\n", blank, recurse);
+
+    // If we have data at this level, try to write it out
+    if (hdu) {
+        psArray **imageArray = appropriateImageArray(hdu, type); // Array of images in HDU
+
+        // 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 && (!pmHDUGenerateForChip(chip) || !*imageArray)) {
+            psError(PS_ERR_UNKNOWN, false, "Unable to generate HDU for chip --- likely programming error.\n");
+            return false;
+        }
+
+        // We only write out a blank PHU if it's specifically requested.
+        bool writeBlank = blank && hdu->blankPHU && !*imageArray; // Write a blank HDU?
+        bool writeImage = !blank && !hdu->blankPHU && *imageArray; // Write an image?
+
+        if (writeBlank || writeImage) {
+            pmConceptSource source = PM_CONCEPT_SOURCE_HEADER | PM_CONCEPT_SOURCE_CELLS |
+                                     PM_CONCEPT_SOURCE_DEFAULTS;
+            if (!pmConceptsWriteChip(chip, source, false, true, NULL)) {
+                psError(PS_ERR_IO, false, "Unable to write concepts for chip.\n");
+                return false;
+            }
+            if (!appropriateWriteFunc(hdu, fits, type)) {
+                psError(PS_ERR_IO, false, "Unable to write HDU for chip.\n");
+                return false;
+            }
+        }
+    }
+
+    // Recurse to lower level if specifically requested.
+    // XXX recursion implies blank == false (must be called on correct level?)
+    if (recurse) {
+        psArray *cells = chip->cells;       // Array of cells
+        for (int i = 0; i < cells->n; i++) {
+            pmCell *cell = cells->data[i];  // The cell of interest
+            if (!cellWrite(cell, fits, db, false, type)) {
+                psError(PS_ERR_IO, false, "Unable to write Chip.\n");
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+// Write an FPA image/mask/weight
+static bool fpaWrite(pmFPA *fpa,        // FPA to write
+                     psFits *fits,      // FITS file to which to write
+                     psDB *db,          // Database handle for "concepts" update
+                     bool blank,        // Write a blank PHU?
+                     bool recurse,      // Recurse to lower levels?
+                     fpaWriteType type  // Type to write
+                    )
+{
+    assert(fpa);
+    assert(fits);
+
+    pmHDU *hdu = fpa->hdu;              // The HDU
+
+    psTrace ("pmFPAWrite", 5, "writing to FPA (%d, %d)\n", blank, recurse);
+
+    // If we have data at this level, try to write it out
+    if (hdu) {
+        psArray **imageArray = appropriateImageArray(hdu, type); // Array of images in HDU
+
+        // 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 && (!pmHDUGenerateForFPA(fpa) || !*imageArray)) {
+            psError(PS_ERR_UNKNOWN, false, "Unable to generate HDU for FPA --- likely programming error.\n");
+            return false;
+        }
+
+        // We only write out a blank PHU if it's specifically requested.
+        bool writeBlank = blank && hdu->blankPHU && !*imageArray; // Write a blank PHU?
+        bool writeImage = !blank && !hdu->blankPHU && *imageArray; // Write an image?
+
+        if (writeBlank || writeImage) {
+            pmConceptSource source = PM_CONCEPT_SOURCE_HEADER | PM_CONCEPT_SOURCE_CELLS |
+                                     PM_CONCEPT_SOURCE_DEFAULTS;
+            if (!pmConceptsWriteFPA(fpa, source, true, NULL)) {
+                psError(PS_ERR_IO, false, "Unable to write concepts for FPA.\n");
+                return false;
+            }
+            if (!appropriateWriteFunc(hdu, fits, type))  {
+                psError(PS_ERR_IO, false, "Unable to write HDU for FPA.\n");
+                return false;
+            }
+        }
+    }
+
+    // Recurse to lower levels if requested
+    if (recurse) {
+        psArray *chips = fpa->chips;        // Array of chips
+        for (int i = 0; i < chips->n; i++) {
+            pmChip *chip = chips->data[i];  // The chip of interest
+            if (!chipWrite(chip, fits, db, false, true, type)) {
+                psError(PS_ERR_IO, false, "Unable to write FPA.\n");
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Public functions
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 bool pmReadoutWriteNext(pmReadout *readout, psFits *fits, int z)
@@ -82 +307 @@
 
 
-
-
-bool pmCellWrite(pmCell *cell,          // Cell to write
-                 psFits *fits,          // FITS file to which to write
-                 psDB *db,              // Database handle for "concepts" update
-                 bool blank             // Write a blank PHU?
-                )
+bool pmCellWrite(pmCell *cell, psFits *fits, psDB *db, bool blank)
 {
     PS_ASSERT_PTR_NON_NULL(cell, false);
     PS_ASSERT_PTR_NON_NULL(fits, false);
-
-    psTrace ("pmFPAWrite", 5, "writing to Cell (%d)\n", blank);
-
-    pmHDU *hdu = cell->hdu;             // The HDU
-    if (!hdu) {
-        return true;                    // We wrote every HDU that exists
-    }
-
-    // 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 (!hdu->blankPHU && !hdu->images) {
-        if (!pmHDUGenerateForCell(cell) || !hdu->images) {
-            psAbort(__func__, "Unable to generate HDU for cell --- likely programming error.\n");
-        }
-    }
-
-    // We only write out a blank PHU if it's specifically requested.
-    bool writeBlank = blank && hdu->blankPHU && !hdu->images; // Write a blank PHU?
-    bool writeImage = !blank && !hdu->blankPHU && hdu->images; // Write an image?
-
-    if (writeBlank || writeImage) {
-        pmConceptSource source = PM_CONCEPT_SOURCE_HEADER | PM_CONCEPT_SOURCE_CELLS |
-                                 PM_CONCEPT_SOURCE_DEFAULTS;
-        if (!pmConceptsWriteCell(cell, source, false, NULL)) {
-            psError(PS_ERR_IO, false, "Unable to write concepts for cell.\n");
-            return false;
-        }
-        if (!pmHDUWrite(hdu, fits)) {
-            psError(PS_ERR_IO, false, "Unable to write HDU for cell.\n");
-            return false;
-        }
-    }
-    // No lower levels to which to recurse
-
-    return true;
-}
-
+    return cellWrite(cell, fits, db, blank, FPA_WRITE_TYPE_IMAGE);
+}
 
 bool pmChipWrite(pmChip *chip, psFits *fits, psDB *db, bool blank, bool recurse)
@@ -134 +318 @@
     PS_ASSERT_PTR_NON_NULL(chip, false);
     PS_ASSERT_PTR_NON_NULL(fits, false);
-
-    pmHDU *hdu = chip->hdu;             // The HDU
-
-    psTrace ("pmFPAWrite", 5, "writing to Chip (%d, %d)\n", blank, recurse);
-
-    // If we have data at this level, try to write it out
-    if (hdu) {
-        // 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 && !hdu->images) {
-            if (!pmHDUGenerateForChip(chip) || !hdu->images) {
-                psAbort (__func__, "Unable to generate HDU for chip --- likely programming error.\n");
-            }
-        }
-
-        // We only write out a blank PHU if it's specifically requested.
-        bool writeBlank = blank && hdu->blankPHU && !hdu->images; // Write a blank HDU?
-        bool writeImage = !blank && !hdu->blankPHU && hdu->images; // Write an image?
-
-        if (writeBlank || writeImage) {
-            pmConceptSource source = PM_CONCEPT_SOURCE_HEADER | PM_CONCEPT_SOURCE_CELLS |
-                                     PM_CONCEPT_SOURCE_DEFAULTS;
-            if (!pmConceptsWriteChip(chip, source, false, true, NULL)) {
-                psError(PS_ERR_IO, false, "Unable to write concepts for chip.\n");
-                return false;
-            }
-            if (!pmHDUWrite(hdu, fits)) {
-                psError(PS_ERR_IO, false, "Unable to write HDU for chip.\n");
-                return false;
-            }
-        }
-    }
-
-    // Recurse to lower level if specifically requested.
-    // XXX recursion implies blank == false (must be called on correct level?)
-    if (recurse) {
-        psArray *cells = chip->cells;       // Array of cells
-        for (int i = 0; i < cells->n; i++) {
-            pmCell *cell = cells->data[i];  // The cell of interest
-            if (!pmCellWrite(cell, fits, db, false)) {
-                psError(PS_ERR_IO, false, "Unable to write Chip.\n");
-                return false;
-            }
-        }
-    }
-
-    return true;
-}
-
-
+    return chipWrite(chip, fits, db, blank, recurse, FPA_WRITE_TYPE_IMAGE);
+}
 
 bool pmFPAWrite(pmFPA *fpa, psFits *fits, psDB *db, bool blank, bool recurse)
@@ -189 +325 @@
     PS_ASSERT_PTR_NON_NULL(fpa, false);
     PS_ASSERT_PTR_NON_NULL(fits, false);
-
-    pmHDU *hdu = fpa->hdu;              // The HDU
-
-    psTrace ("pmFPAWrite", 5, "writing to FPA (%d, %d)\n", blank, recurse);
-
-    // If we have data at this level, try to write it out
-    if (hdu) {
-        // 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 && !hdu->images) {
-            if (!pmHDUGenerateForFPA(fpa)) {
-                psAbort("pmFPAWrite", "error generating HDU");
-            }
-            if (!hdu->images) {
-                psAbort("pmFPAWrite", "programming error: failure generating HDU");
-            }
-        }
-
-        // We only write out a blank PHU if it's specifically requested.
-        bool writeBlank = blank && hdu->blankPHU && !hdu->images; // Write a blank PHU?
-        bool writeImage = !blank && !hdu->blankPHU && hdu->images; // Write an image?
-
-        if (writeBlank || writeImage) {
-            pmConceptSource source = PM_CONCEPT_SOURCE_HEADER | PM_CONCEPT_SOURCE_CELLS |
-                                     PM_CONCEPT_SOURCE_DEFAULTS;
-            if (!pmConceptsWriteFPA(fpa, source, true, NULL)) {
-                psError(PS_ERR_IO, false, "Unable to write concepts for FPA.\n");
-                return false;
-            }
-            if (!pmHDUWrite(hdu, fits))  {
-                psError(PS_ERR_IO, false, "Unable to write HDU for FPA.\n");
-                return false;
-            }
-        }
-    }
-
-    // Recurse to lower levels if requested
-    if (recurse) {
-        psArray *chips = fpa->chips;        // Array of chips
-        for (int i = 0; i < chips->n; i++) {
-            pmChip *chip = chips->data[i];  // The chip of interest
-            if (!pmChipWrite(chip, fits, db, false, true)) {
-                psError(PS_ERR_IO, false, "Unable to write FPA.\n");
-                return false;
-            }
-        }
-    }
-
-    return true;
-}
-
-
-
-bool pmCellWriteMask(pmCell *cell,          // Cell to write
-                     psFits *fits,          // FITS file to which to write
-                     psDB *db           // Database handle for "concepts" update
-                    )
+    return fpaWrite(fpa, fits, db, blank, recurse, FPA_WRITE_TYPE_IMAGE);
+}
+
+
+bool pmCellWriteMask(pmCell *cell, psFits *fits, psDB *db, bool blank)
 {
     PS_ASSERT_PTR_NON_NULL(cell, false);
     PS_ASSERT_PTR_NON_NULL(fits, false);
-
-    pmHDU *hdu = cell->hdu;             // The HDU
-    if (!hdu) {
-        return true;                    // We wrote every HDU that exists
-    }
-
-    psTrace ("pmFPAWrite", 5, "writing mask to Cell\n");
-
-    // 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 (!hdu->blankPHU && !hdu->masks) {
-        if (!pmHDUGenerateForCell(cell) || !hdu->masks) {
-            psError(PS_ERR_UNKNOWN, false, "Unable to generate HDU for cell --- likely programming error.\n");
-            return false;
-        }
-    }
-
-    pmConceptSource source = PM_CONCEPT_SOURCE_HEADER | PM_CONCEPT_SOURCE_CELLS | PM_CONCEPT_SOURCE_DEFAULTS;
-    if (!pmConceptsWriteCell(cell, source, false, NULL)) {
-        psError(PS_ERR_IO, false, "Unable to write concepts for cell.\n");
-        return false;
-    }
-    if (!pmHDUWriteMask(hdu, fits)) {
-        psError(PS_ERR_IO, false, "Unable to write HDU for cell.\n");
-        return false;
-    }
-
-    return true;
-}
-
-
-bool pmChipWriteMask(pmChip *chip, psFits *fits, psDB *db)
+    return cellWrite(cell, fits, db, blank, FPA_WRITE_TYPE_IMAGE);
+}
+
+bool pmChipWriteMask(pmChip *chip, psFits *fits, psDB *db, bool blank, bool recurse)
 {
     PS_ASSERT_PTR_NON_NULL(chip, false);
     PS_ASSERT_PTR_NON_NULL(fits, false);
-
-    pmHDU *hdu = chip->hdu;             // The HDU
-    if (!hdu) {
-        return true;                    // We wrote every HDU that exists
-    }
-
-    psTrace ("pmFPAWrite", 5, "writing mask to Chip\n");
-
-    // 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 (!hdu->blankPHU && !hdu->masks) {
-        if (!pmHDUGenerateForChip(chip) || !hdu->masks) {
-            psError(PS_ERR_UNKNOWN, false, "Unable to generate HDU for chip --- likely programming error.\n");
-            return false;
-        }
-    }
-
-    pmConceptSource source = PM_CONCEPT_SOURCE_HEADER | PM_CONCEPT_SOURCE_CELLS | PM_CONCEPT_SOURCE_DEFAULTS;
-    if (!pmConceptsWriteChip(chip, source, false, true, NULL)) {
-        psError(PS_ERR_IO, false, "Unable to write concepts for chip.\n");
-        return false;
-    }
-    if (!pmHDUWriteMask(hdu, fits)) {
-        psError(PS_ERR_IO, false, "Unable to write HDU for chip.\n");
-        return false;
-    }
-
-    return true;
-}
-
-
-
-bool pmFPAWriteMask(pmFPA *fpa, psFits *fits, psDB *db)
+    return chipWrite(chip, fits, db, blank, recurse, FPA_WRITE_TYPE_MASK);
+}
+
+bool pmFPAWriteMask(pmFPA *fpa, psFits *fits, psDB *db, bool blank, bool recurse)
 {
     PS_ASSERT_PTR_NON_NULL(fpa, false);
     PS_ASSERT_PTR_NON_NULL(fits, false);
-
-    pmHDU *hdu = fpa->hdu;              // The HDU
-    if (!hdu) {
-        return true;                    // We wrote every HDU that exists
-    }
-
-    psTrace ("pmFPAWrite", 5, "writing mask to FPA\n");
-
-    // 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 (!hdu->blankPHU && !hdu->masks) {
-        if (!pmHDUGenerateForFPA(fpa) || !hdu->masks) {
-            psError(PS_ERR_UNKNOWN, false, "Unable to generate HDU for chip --- likely programming error.\n");
-            return false;
-        }
-    }
-
-    pmConceptSource source = PM_CONCEPT_SOURCE_HEADER | PM_CONCEPT_SOURCE_CELLS | PM_CONCEPT_SOURCE_DEFAULTS;
-    if (!pmConceptsWriteFPA(fpa, source, true, NULL)) {
-        psError(PS_ERR_IO, false, "Unable to write concepts for FPA.\n");
-        return false;
-    }
-    if (!pmHDUWriteMask(hdu, fits))  {
-        psError(PS_ERR_IO, false, "Unable to write HDU for FPA.\n");
-        return false;
-    }
-
-    return true;
-}
-
+    return fpaWrite(fpa, fits, db, blank, recurse, FPA_WRITE_TYPE_MASK);
+}
+
+
+bool pmCellWriteWeight(pmCell *cell, psFits *fits, psDB *db, bool blank)
+{
+    PS_ASSERT_PTR_NON_NULL(cell, false);
+    PS_ASSERT_PTR_NON_NULL(fits, false);
+    return cellWrite(cell, fits, db, blank, FPA_WRITE_TYPE_WEIGHT);
+}
+
+bool pmChipWriteWeight(pmChip *chip, psFits *fits, psDB *db, bool blank, bool recurse)
+{
+    PS_ASSERT_PTR_NON_NULL(chip, false);
+    PS_ASSERT_PTR_NON_NULL(fits, false);
+    return chipWrite(chip, fits, db, blank, recurse, FPA_WRITE_TYPE_WEIGHT);
+}
+
+bool pmFPAWriteWeight(pmFPA *fpa, psFits *fits, psDB *db, bool blank, bool recurse)
+{
+    PS_ASSERT_PTR_NON_NULL(fpa, false);
+    PS_ASSERT_PTR_NON_NULL(fits, false);
+    return fpaWrite(fpa, fits, db, blank, recurse, FPA_WRITE_TYPE_WEIGHT);
+}
 
 

trunk/psModules/src/camera/pmFPAWrite.h

@@ -7 +7 @@
 /// @author Paul Price, IfA
 ///
-/// @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
-/// @date $Date: 2006-11-15 00:40:02 $
+/// @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
+/// @date $Date: 2006-11-18 23:43:28 $
 ///
 /// Copyright 2005-2006 Institute for Astronomy, University of Hawaii
@@ -69 +69 @@
 /// Write a cell mask to a FITS file
 ///
-/// Generates CELL.TRIMSEC, CELL.BIASSEC and the HDU pixels if required.  Writes the concepts to the various
-/// locations, and then the HDU mask to the FITS file.
+/// Generates CELL.TRIMSEC, CELL.BIASSEC and the HDU mask pixels if required.  A blank (i.e., image-less
+/// header) is written only if specifically requested.  Writes the concepts to the various locations, and then
+/// the HDU mask to the FITS file.  This function should be called at the beginning of the output cell loop
+/// with blank=true in order to produce the correct file structure.
 bool pmCellWriteMask(pmCell *cell,      ///<  Cell to write
                      psFits *fits,      ///<  FITS file to which to write
-                     psDB *db           ///<  Database handle for "concepts" update
+                     psDB *db,          ///<  Database handle for "concepts" update
+                     bool blank         ///<  Write a blank PHU?
                     );
 
 /// Write a chip mask to a FITS file
 ///
-/// Generates CELL.TRIMSEC, CELL.BIASSEC and the HDU pixels if required.  Writes the concepts to the various
-/// locations, and then the HDU mask to the FITS file.
+/// Generates CELL.TRIMSEC, CELL.BIASSEC and the HDU mask pixels if required.  A blank (i.e., image-less
+/// header) is written only if specifically requested.  Writes the concepts to the various locations, and then
+/// the HDU mask to the FITS file, optionally recursing to lower levels.  This function should be called at
+/// the beginning of the output chip loop with blank=true and recurse=false in order to produce the correct
+/// file structure.
 bool pmChipWriteMask(pmChip *chip,      ///<  Chip to write
                      psFits *fits,      ///<  FITS file to which to write
-                     psDB *db           ///<  Database handle for "concepts" update
+                     psDB *db,          ///<  Database handle for "concepts" update
+                     bool blank,        ///<  Write a blank PHU?
+                     bool recurse       ///<  Recurse to lower levels?
                     );
 
 /// Write an FPA mask to a FITS file
 ///
-/// Generates CELL.TRIMSEC, CELL.BIASSEC and the HDU pixels if required.  Writes the concepts to the various
-/// locations, and then the HDU mask to the FITS file.
+/// Generates CELL.TRIMSEC, CELL.BIASSEC and the HDU mask pixels if required.  A blank (i.e., image-less
+/// header) is written only if specifically requested.  Writes the concepts to the various locations, and then
+/// the HDU mask to the FITS file, optionally recursing to lower levels.  This function should be called at
+/// the beginning of the output FPA loop with blank=true and recurse=false in order to produce the correct
+/// file structure.
 bool pmFPAWriteMask(pmFPA *fpa,         ///<  FPA to write
                     psFits *fits,       ///<  FITS file to which to write
-                    psDB *db            ///<  Database handle for "concepts" update
+                    psDB *db,           ///<  Database handle for "concepts" update
+                    bool blank,         ///<  Write a blank PHU?
+                    bool recurse        ///<  Recurse to lower levels?
                    );
+
+/// Write a cell weight to a FITS file
+///
+/// Generates CELL.TRIMSEC, CELL.BIASSEC and the HDU weight pixels if required.  A blank (i.e., image-less
+/// header) is written only if specifically requested.  Writes the concepts to the various locations, and then
+/// the HDU weight to the FITS file.  This function should be called at the beginning of the output cell loop
+/// with blank=true in order to produce the correct file structure.
+bool pmCellWriteWeight(pmCell *cell,    ///<  Cell to write
+                       psFits *fits,    ///<  FITS file to which to write
+                       psDB *db,        ///<  Database handle for "concepts" update
+                       bool blank       ///<  Write a blank PHU?
+                      );
+
+/// Write a chip weight to a FITS file
+///
+/// Generates CELL.TRIMSEC, CELL.BIASSEC and the HDU weight pixels if required.  A blank (i.e., image-less
+/// header) is written only if specifically requested.  Writes the concepts to the various locations, and then
+/// the HDU weight to the FITS file, optionally recursing to lower levels.  This function should be called at
+/// the beginning of the output chip loop with blank=true and recurse=false in order to produce the correct
+/// file structure.
+bool pmChipWriteWeight(pmChip *chip,    ///<  Chip to write
+                       psFits *fits,    ///<  FITS file to which to write
+                       psDB *db,        ///<  Database handle for "concepts" update
+                       bool blank,      ///<  Write a blank PHU?
+                       bool recurse     ///<  Recurse to lower levels?
+                      );
+
+/// Write an FPA weight to a FITS file
+///
+/// Generates CELL.TRIMSEC, CELL.BIASSEC and the HDU weight pixels if required.  A blank (i.e., image-less
+/// header) is written only if specifically requested.  Writes the concepts to the various locations, and then
+/// the HDU weight to the FITS file, optionally recursing to lower levels.  This function should be called at
+/// the beginning of the output FPA loop with blank=true and recurse=false in order to produce the correct
+/// file structure.
+bool pmFPAWriteWeight(pmFPA *fpa,       ///<  FPA to write
+                      psFits *fits,     ///<  FITS file to which to write
+                      psDB *db,         ///<  Database handle for "concepts" update
+                      bool blank,       ///<  Write a blank PHU?
+                      bool recurse      ///<  Recurse to lower levels?
+                     );
+
 
 /// Write a FITS table from the cell's analysis metadata.

trunk/psModules/src/camera/pmFPAfile.c

@@ -374 +374 @@
         return PM_FPA_FILE_JPEG;
     }
+    if (!strcasecmp (type, "MASK"))     {
+        return PM_FPA_FILE_MASK;
+    }
+    if (!strcasecmp (type, "WEIGHT"))     {
+        return PM_FPA_FILE_WEIGHT;
+    }
     if (!strcasecmp (type, "FRINGE")) {
         return PM_FPA_FILE_FRINGE;

trunk/psModules/src/camera/pmFPAfile.h

@@ -7 +7 @@
 *  @author EAM, IfA
 *
-*  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2006-11-13 22:15:55 $
+*  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-11-18 23:43:28 $
 *
 *  Copyright 2004-2005 Institute for Astronomy, University of Hawaii
@@ -37 +37 @@
     PM_FPA_FILE_JPEG,
     PM_FPA_FILE_MANAPLOT,
+    PM_FPA_FILE_MASK,
+    PM_FPA_FILE_WEIGHT,
     PM_FPA_FILE_FRINGE,
 } pmFPAfileType;

trunk/psModules/src/camera/pmFPAfileFitsIO.c

@@ -61 +61 @@
 }
 
-// given an already-opened fits file, read the components corresponding
-// to the specified view
-bool pmFPAviewReadFitsImage (const pmFPAview *view, pmFPAfile *file)
-{
-    PS_ASSERT_PTR_NON_NULL(view, false);
-    PS_ASSERT_PTR_NON_NULL(file, false);
-
-    bool status;
-    pmFPA *fpa = file->fpa;
-    psFits *fits = file->fits;
-
-    if (view->chip == -1) {
-        status = pmFPARead (fpa, fits, NULL);
-        return status;
+
+// given an already-opened fits file, read the components corresponding to the specified view
+static bool fpaViewReadFitsImage(const pmFPAview *view, // FPA view, specifying the level of interest
+                                 pmFPAfile *file, // FPA file of interest
+                                 bool (*fpaReadFunc)(pmFPA*, psFits*, psDB*), // Function to read FPA
+                                 bool (*chipReadFunc)(pmChip*, psFits*, psDB*), // Function to read chip
+                                 bool (*cellReadFunc)(pmCell*, psFits*, psDB*) // Function to read cell
+                                )
+{
+    assert(view);
+    assert(file);
+
+    pmFPA *fpa = file->fpa;             // FPA of interest
+    psFits *fits = file->fits;          // FITS file from which to read
+
+    if (view->chip == -1) {
+        return fpaReadFunc(fpa, fits, NULL);
     }
 
@@ -81 +84 @@
         return false;
     }
-    pmChip *chip = fpa->chips->data[view->chip];
-
-    if (view->cell == -1) {
-        status = pmChipRead (chip, fits, NULL);
-        return status;
+    pmChip *chip = fpa->chips->data[view->chip]; // Chip of interest
+
+    if (view->cell == -1) {
+        return chipReadFunc(chip, fits, NULL);
     }
 
@@ -92 +94 @@
         return false;
     }
-    pmCell *cell = chip->cells->data[view->cell];
+    pmCell *cell = chip->cells->data[view->cell]; // Cell of interest
 
     if (view->readout == -1) {
-        status = pmCellRead (cell, fits, NULL);
-        return status;
-    }
-    psError(PS_ERR_UNKNOWN, true, "Returning false");
+        return cellReadFunc(cell, fits, NULL);
+    }
+    psError(PS_ERR_UNKNOWN, true, "Bad view: %d,%d", view->chip, view->cell);
     return false;
 
@@ -118 +119 @@
     return true;
     #endif
+}
+
+
+bool pmFPAviewReadFitsImage(const pmFPAview *view, pmFPAfile *file)
+{
+    PS_ASSERT_PTR_NON_NULL(view, false);
+    PS_ASSERT_PTR_NON_NULL(file, false);
+    return fpaViewReadFitsImage(view, file, pmFPARead, pmChipRead, pmCellRead);
+}
+
+bool pmFPAviewReadFitsMask(const pmFPAview *view, pmFPAfile *file)
+{
+    PS_ASSERT_PTR_NON_NULL(view, false);
+    PS_ASSERT_PTR_NON_NULL(file, false);
+    return fpaViewReadFitsImage(view, file, pmFPAReadMask, pmChipReadMask, pmCellReadMask);
+}
+
+bool pmFPAviewReadFitsWeight(const pmFPAview *view, pmFPAfile *file)
+{
+    PS_ASSERT_PTR_NON_NULL(view, false);
+    PS_ASSERT_PTR_NON_NULL(file, false);
+    return fpaViewReadFitsImage(view, file, pmFPAReadWeight, pmChipReadWeight, pmCellReadWeight);
 }
 
@@ -126 +149 @@
 // out data in an inconsistent fashion
 // the calls below should recurse down the element to write out all components.
-bool pmFPAviewWriteFitsImage (const pmFPAview *view, pmFPAfile *file)
-{
-    PS_ASSERT_PTR_NON_NULL(view, false);
-    PS_ASSERT_PTR_NON_NULL(file, false);
-
-    pmFPA *fpa = file->fpa;
-    psFits *fits = file->fits;
+static bool fpaViewWriteFitsImage(const pmFPAview *view, // FPA view, specifying the level of interest
+                                  pmFPAfile *file, // FPA file of interest
+                                  bool (*fpaWriteFunc)(pmFPA*, psFits*, psDB*, bool, bool), // Func for FPA
+                                  bool (*chipWriteFunc)(pmChip*, psFits*, psDB*, bool, bool), // Func for chip
+                                  bool (*cellWriteFunc)(pmCell*, psFits*, psDB*, bool) // Func for cell
+                                 )
+{
+    assert(view);
+    assert(file);
+
+    pmFPA *fpa = file->fpa;             // FPA of interest
+    psFits *fits = file->fits;          // FITS file
 
     // pmFPAWrite takes care of all PHUs as needed
     if (view->chip == -1) {
-        pmFPAWrite(fpa, fits, NULL, false, true);
-        return true;
+        return fpaWriteFunc(fpa, fits, NULL, false, true);
     }
 
@@ -144 +171 @@
         return false;
     }
-    pmChip *chip = fpa->chips->data[view->chip];
-
-    if (view->cell == -1) {
-        pmChipWrite (chip, fits, NULL, false, true);
-        return true;
+    pmChip *chip = fpa->chips->data[view->chip]; // Chip of interest
+
+    if (view->cell == -1) {
+        return chipWriteFunc(chip, fits, NULL, false, true);
     }
 
@@ -155 +181 @@
         return false;
     }
-    pmCell *cell = chip->cells->data[view->cell];
+    pmCell *cell = chip->cells->data[view->cell]; // Cell of interest
 
     if (view->readout == -1) {
-        return pmCellWrite (cell, fits, NULL, false);
-    }
-    psError(PS_ERR_UNKNOWN, true, "Returning false");
+        return cellWriteFunc(cell, fits, NULL, false);
+    }
+    psError(PS_ERR_UNKNOWN, true, "Bad view: %d,%d", view->chip, view->cell);
     return false;
 
@@ -182 +208 @@
 }
 
-// this old code was used to write the blank by hand.
-// pmFPAWrite now takes care of this choice.
-# if 0
-// do we need to write out a PHU for this entry?
-if (file->phu == NULL)
-    {
-        pmHDU *hdu = pmFPAviewThisHDU (view, file->fpa);
-        pmHDU *phu = pmFPAviewThisPHU (view, file->fpa);
-        // if this hdu is the phu, the write function below will create the phu
-        if (hdu != phu) {
-            // we assume that the PHU is just a header
-            // header may not be defined for constructed images; make a dummy one
-            psMetadata *outhead = NULL;
-            if (phu->header) {
-                outhead = psMetadataCopy (NULL, phu->header);
-            } else {
-                outhead = psMetadataAlloc ();
-            }
-            psMetadataAdd (outhead, PS_LIST_TAIL, "EXTEND", PS_DATA_BOOL | PS_META_REPLACE, "this file has extensions", true);
-            psFitsWriteBlank (file->fits, outhead, "");
-            file->phu = phu->header;
-            psTrace ("pmFPAfile", 5, "wrote phu %s (type: %d)\n", file->filename, file->type);
-            psFree (outhead);
-        }
-    }
-# endif
+bool pmFPAviewWriteFitsImage(const pmFPAview *view, pmFPAfile *file)
+{
+    PS_ASSERT_PTR_NON_NULL(view, false);
+    PS_ASSERT_PTR_NON_NULL(file, false);
+    return fpaViewWriteFitsImage(view, file, pmFPAWrite, pmChipWrite, pmCellWrite);
+}
+
+bool pmFPAviewWriteFitsMask(const pmFPAview *view, pmFPAfile *file)
+{
+    PS_ASSERT_PTR_NON_NULL(view, false);
+    PS_ASSERT_PTR_NON_NULL(file, false);
+    return fpaViewWriteFitsImage(view, file, pmFPAWriteMask, pmChipWriteMask, pmCellWriteMask);
+}
+
+bool pmFPAviewWriteFitsWeight(const pmFPAview *view, pmFPAfile *file)
+{
+    PS_ASSERT_PTR_NON_NULL(view, false);
+    PS_ASSERT_PTR_NON_NULL(file, false);
+    return fpaViewWriteFitsImage(view, file, pmFPAWriteWeight, pmChipWriteWeight, pmCellWriteWeight);
+}
 
 // given an already-opened fits file, read the components corresponding
 // to the specified view
-bool pmFPAviewFreeFitsImage (const pmFPAview *view, pmFPAfile *file)
+bool pmFPAviewFreeData(const pmFPAview *view, pmFPAfile *file)
 {
     PS_ASSERT_PTR_NON_NULL(view, false);
@@ -270 +290 @@
 }
 
+#if 0
+// Shouldn't need this --- when we want to free fringe data, we want to free the whole level, not just the
+// table.
 
 // Free the table within a cell
@@ -329 +352 @@
 }
 
+#endif

trunk/psModules/src/camera/pmFPAfileFitsIO.h

@@ -6 +6 @@
 *
 *  @author EAM, IfA
+*  @author PAP, IfA
 *
-*  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2006-11-13 22:15:55 $
+*  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-11-18 23:43:28 $
 *
 *  Copyright 2004-2005 Institute for Astronomy, University of Hawaii
@@ -16 +17 @@
 #define PM_FPA_FILE_FITS_IO_H
 
-// read an image into the current view
-bool pmFPAviewReadFitsImage (const pmFPAview *view, pmFPAfile *file);
+/// Read an image into the current view
+bool pmFPAviewReadFitsImage(const pmFPAview *view, ///< View specifying level of interest
+                            pmFPAfile *file ///< FPA file into which to read
+                           );
 
-// write the components for the specified view
-bool pmFPAviewWriteFitsImage (const pmFPAview *view, pmFPAfile *file);
+/// Read a mask into the current view
+bool pmFPAviewReadFitsMask(const pmFPAview *view, ///< View specifying level of interest
+                           pmFPAfile *file ///< FPA file into which to read
+                          );
+/// Read a weight map into the current view
+bool pmFPAviewReadFitsWeight(const pmFPAview *view,  ///< View specifying level of interest
+                             pmFPAfile *file ///< FPA file into which to read
+                            );
 
-// free the appropriate image containers
-bool pmFPAviewFreeFitsImage (const pmFPAview *view, pmFPAfile *file);
+/// Write the image for the specified view
+bool pmFPAviewWriteFitsImage(const pmFPAview *view, ///< View specifying level of interest
+                             pmFPAfile *file ///< FPA file to write
+                            );
 
+/// Write the mask for the specified view
+bool pmFPAviewWriteFitsMask(const pmFPAview *view, ///< View specifying level of interest
+                            pmFPAfile *file ///< FPA file to write
+                           );
 
-// read a table into the current view
-bool pmFPAviewReadFitsTable(const pmFPAview *view, pmFPAfile *file, const char *name);
+/// Write the weight map for the specified view
+bool pmFPAviewWriteFitsWeight(const pmFPAview *view, ///< View specifying level of interest
+                              pmFPAfile *file ///< FPA file to write
+                             );
 
-// write the table for the specified view
-bool pmFPAviewWriteFitsTable(const pmFPAview *view, pmFPAfile *file, const char *name);
+/// Free the data for the specified view
+bool pmFPAviewFreeData(const pmFPAview *view, ///< View specifying level of interest
+                       pmFPAfile *file  ///< FPA file to free data
+                      );
 
-// free the appropriate table containers
-bool pmFPAviewFreeFitsTable(const pmFPAview *view, pmFPAfile *file, const char *name);
+/// Read a table into the current view
+bool pmFPAviewReadFitsTable(const pmFPAview *view, ///<  View specifying level of interest
+                            pmFPAfile *file, ///< FPA file into which to read
+                            const char *name ///< Name of table
+                           );
+
+/// Write the table for the specified view
+bool pmFPAviewWriteFitsTable(const pmFPAview *view, ///<  View specifying level of interest
+                             pmFPAfile *file, ///< FPA file to write
+                             const char *name ///< Name of table
+                            );
 
 # endif

trunk/psModules/src/camera/pmFPAfileIO.c

@@ -225 +225 @@
         // open the FITS types:
     case PM_FPA_FILE_IMAGE:
+    case PM_FPA_FILE_MASK:
+    case PM_FPA_FILE_WEIGHT:
     case PM_FPA_FILE_FRINGE:
         psTrace ("pmFPAfile", 5, "opening %s (type: %d)\n", file->filename, file->type);
@@ -311 +313 @@
     switch (file->type) {
     case PM_FPA_FILE_IMAGE:
-        if (!pmFPAviewReadFitsImage (view, file)) {
+        if (!pmFPAviewReadFitsImage(view, file)) {
+            psError(PS_ERR_UNKNOWN, false, "skipping %s (type: %d)\n", file->filename, file->type);
+            return false;
+        }
+        psTrace ("pmFPAfile", 5, "reading %s (type: %d)\n", file->filename, file->type);
+        break;
+    case PM_FPA_FILE_MASK:
+        if (!pmFPAviewReadFitsMask(view, file)) {
+            psError(PS_ERR_UNKNOWN, false, "skipping %s (type: %d)\n", file->filename, file->type);
+            return false;
+        }
+        psTrace ("pmFPAfile", 5, "reading %s (type: %d)\n", file->filename, file->type);
+        break;
+    case PM_FPA_FILE_WEIGHT:
+        if (!pmFPAviewReadFitsWeight(view, file)) {
             psError(PS_ERR_UNKNOWN, false, "skipping %s (type: %d)\n", file->filename, file->type);
             return false;
@@ -384 +400 @@
     switch (file->type) {
     case PM_FPA_FILE_IMAGE:
-        if (pmFPAviewFreeFitsImage (view, file)) {
+    case PM_FPA_FILE_MASK:
+    case PM_FPA_FILE_WEIGHT:
+    case PM_FPA_FILE_FRINGE:
+        if (pmFPAviewFreeData(view, file)) {
             psTrace ("pmFPAfile", 5, "freed %s for %s (type: %d)\n", file->filename, file->name, file->type);
             if (file->filename == NULL) {
@@ -394 +413 @@
         }
         break;
-    case PM_FPA_FILE_FRINGE:
-        if (!pmFPAviewFreeFitsTable(view, file, "FRINGE")) {
-            psError(PS_ERR_UNKNOWN, false, "Unable to free fringe data.\n");
-            return false;
-        }
-        break;
-
     case PM_FPA_FILE_SX:
     case PM_FPA_FILE_RAW:
@@ -469 +481 @@
     switch (file->type) {
     case PM_FPA_FILE_IMAGE:
+        pmFPAviewWriteFitsImage(view, file);
+        psTrace ("pmFPAfile", 5, "wrote image %s (fpa: %p)\n", file->filename, file->fpa);
+        break;
+    case PM_FPA_FILE_MASK:
+        pmFPAviewWriteFitsMask(view, file);
+        psTrace ("pmFPAfile", 5, "wrote mask %s (fpa: %p)\n", file->filename, file->fpa);
+        break;
+    case PM_FPA_FILE_WEIGHT:
+        pmFPAviewWriteFitsWeight(view, file);
+        psTrace ("pmFPAfile", 5, "wrote weight %s (fpa: %p)\n", file->filename, file->fpa);
+        break;
+    case PM_FPA_FILE_FRINGE:
         pmFPAviewWriteFitsImage (view, file);
         psTrace ("pmFPAfile", 5, "wrote image %s (fpa: %p)\n", file->filename, file->fpa);
-        break;
-    case PM_FPA_FILE_FRINGE:
-        pmFPAviewWriteFitsImage (view, file);
-        psTrace ("pmFPAfile", 5, "wrote table %s (fpa: %p)\n", file->filename, file->fpa);
         pmFPAviewWriteFitsTable(view, file, "FRINGE");
         psTrace ("pmFPAfile", 5, "wrote fringe table %s (fpa: %p)\n", file->filename, file->fpa);
@@ -554 +574 @@
     switch (file->type) {
     case PM_FPA_FILE_IMAGE:
+    case PM_FPA_FILE_MASK:
+    case PM_FPA_FILE_WEIGHT:
     case PM_FPA_FILE_FRINGE:
         // create FPA structure component based on view
@@ -608 +630 @@
         // check the FITS types
     case PM_FPA_FILE_IMAGE:
+    case PM_FPA_FILE_MASK:
+    case PM_FPA_FILE_WEIGHT:
     case PM_FPA_FILE_FRINGE:
     case PM_FPA_FILE_CMF:

trunk/psModules/src/camera/pmHDU.c

@@ -85 +85 @@
     if (!hdu->header) {
         psTrace("psModules.camera", 5, "Reading the header...\n");
-        hdu->header = psFitsReadHeader(NULL, fits);
+        hdu->header = psFitsReadHeader(hdu->header, fits);
         if (! hdu->header) {
             psError(PS_ERR_IO, false, "Unable to read header for extension %s\n", hdu->extname);
@@ -95 +95 @@
 }
 
+// Read an HDU from a FITS file
 // XXX: Add a region specifier?
-bool pmHDURead(pmHDU *hdu, psFits *fits)
-{
-    PS_ASSERT_PTR_NON_NULL(hdu, false);
-    PS_ASSERT_PTR_NON_NULL(fits, false);
+bool hduRead(pmHDU *hdu,                // HDU to write
+             psArray **images,          // Images into which to read
+             psFits *fits               // FITS file to read
+            )
+{
+    assert(hdu);
+    assert(images);
+    assert(fits);
 
     // Read the header; includes the move
@@ -111 +116 @@
     }
 
-    if (hdu->images) {
+    if (*images) {
         psLogMsg(__func__, PS_LOG_WARN, "HDU %s has already been read --- overwriting.\n", hdu->extname);
-        psFree(hdu->images);        // Blow away anything existing
+        psFree(*images);                // Blow away anything existing
     }
     psTrace("psModules.camera", 5, "Reading the pixels...\n");
-    hdu->images = psFitsReadImageCube(fits, psRegionSet(0,0,0,0));
-    if (! hdu->images) {
+    *images = psFitsReadImageCube(fits, psRegionSet(0,0,0,0));
+    if (!*images) {
         psError(PS_ERR_IO, false, "Unable to read pixels for extension %s\n", hdu->extname);
         return false;
@@ -124 +129 @@
 }
 
+bool pmHDURead(pmHDU *hdu, psFits *fits)
+{
+    PS_ASSERT_PTR_NON_NULL(hdu, false);
+    PS_ASSERT_PTR_NON_NULL(fits, false);
+
+    return hduRead(hdu, &hdu->images, fits);
+}
+
+bool pmHDUReadMask(pmHDU *hdu, psFits *fits)
+{
+    PS_ASSERT_PTR_NON_NULL(hdu, false);
+    PS_ASSERT_PTR_NON_NULL(fits, false);
+
+    return hduRead(hdu, &hdu->masks, fits);
+}
+
+bool pmHDUReadWeight(pmHDU *hdu, psFits *fits)
+{
+    PS_ASSERT_PTR_NON_NULL(hdu, false);
+    PS_ASSERT_PTR_NON_NULL(fits, false);
+
+    return hduRead(hdu, &hdu->weights, fits);
+}
+
 // Write an HDU to a FITS file
-bool hduWrite(pmHDU *hdu,               // HDU to write
-              psArray *images,          // Images to write
-              psFits *fits              // FITS file to which to write
-             )
+static bool hduWrite(pmHDU *hdu,        // HDU to write
+                     psArray *images,   // Images to write
+                     psFits *fits       // FITS file to which to write
+                    )
 {
     assert(hdu);
@@ -182 +211 @@
 }
 
+bool pmHDUWriteWeight(pmHDU *hdu, psFits *fits)
+{
+    PS_ASSERT_PTR_NON_NULL(hdu, false);
+    PS_ASSERT_PTR_NON_NULL(fits, false);
+
+    return hduWrite(hdu, hdu->weights, fits);
+}

trunk/psModules/src/camera/pmHDU.h

@@ -7 +7 @@
 /// @author Paul Price, IfA
 ///
-/// @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
-/// @date $Date: 2006-11-15 00:40:02 $
+/// @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
+/// @date $Date: 2006-11-18 23:43:28 $
 ///
 /// Copyright 2005-2006 Institute for Astronomy, University of Hawaii
@@ -51 +51 @@
               );
 
+/// Read the HDU header and mask
+///
+/// Moves to the appropriate extension
+bool pmHDUReadMask(pmHDU *hdu,          ///< HDU to read
+                   psFits *fits         ///< FITS file to read from
+                  );
+
+/// Read the HDU header and weight map
+///
+/// Moves to the appropriate extension
+bool pmHDUReadWeight(pmHDU *hdu,        ///< HDU to read
+                     psFits *fits       ///< FITS file to read from
+                    );
+
 /// Write the HDU header and pixels
 bool pmHDUWrite(pmHDU *hdu,             ///< HDU to write
@@ -57 +71 @@
 
 /// Write the HDU header and mask
-bool pmHDUWriteMask(pmHDU *hdu,         ///< HDU to write mask
+bool pmHDUWriteMask(pmHDU *hdu,         ///< HDU to write
                     psFits *fits        ///< FITS file to write to
                    );
 
+/// Write the HDU header and weight map
+bool pmHDUWriteWeight(pmHDU *hdu,       ///< HDU to write
+                      psFits *fits      ///< FITS file to write to
+                     );
+
 #endif