Changeset 7168 for trunk/psModules/src/camera/pmFPARead.c

Timestamp:

May 22, 2006, 2:23:08 PM (20 years ago)

Author:

Paul Price

Message:

Adding pmHDUGenerate to make an HDU (image) from the cells contained below. Altered pmFPACopy to use pmHDUGenerate functions. The motivation for pmHDUGenerate is that when we go through an FPA bit by bit, creating an output FPA, we don't know the size of the resultant output images until we're done with the whole lot. So we simply create the cells, and call pmHDUGenerateFromFPA (etc) to generate the HDU image which is then written out. It takes care of the TRIMSEC, BIASSEC, etc.

File:

• trunk/psModules/src/camera/pmFPARead.c (modified) (7 diffs)

trunk/psModules/src/camera/pmFPARead.c

@@ -5 +5 @@
 
 #include "pmFPA.h"
-#include "pmFPARead.h"
 #include "pmHDU.h"
 #include "pmHDUUtils.h"
@@ -11 +10 @@
 #include "psRegionIsBad.h"
 #include "pmFPAHeader.h"
+
+#include "pmFPARead.h"
 
 #define MAX(x,y) ((x) > (y) ? (x) : (y))
@@ -74 +75 @@
 }
 
+// Read a component of a readout
+psImage *readoutReadComponent(psFits *fits, // FITS file from which to read
+                              const psRegion *region, // Region to read
+                              int readdir, // Read direction (1=rows, 2=cols)
+                              int min,  // Minimum row/col number to read
+                              int max,   // Maximum row/col number to read
+                              int z,     // Image plane to read
+                              float bad // Bad value
+                             )
+{
+    bool resize = false;                // Do we need to resize the image once read?
+    psRegion toRead = psRegionSet(region->x0, region->x1, region->y0, region->y1); // Region to read
+    psRegion fullSize = toRead;         // Full sized region
+    if (readdir == 1) {
+        if (toRead.y0 <= min) {
+            toRead.y0 = min;
+        } else {
+            fullSize.y0 = min;
+            resize = true;
+        }
+        if (toRead.y1 >= max) {
+            toRead.y1 = max;
+        } else {
+            fullSize.y1 = max;
+            resize = false;
+        }
+    } else if (readdir == 2) {
+        if (toRead.x0 <= min) {
+            toRead.x0 = min;
+        } else {
+            fullSize.x0 = min;
+            resize = true;
+        }
+        if (toRead.x1 >= max) {
+            toRead.x1 = max;
+        } else {
+            fullSize.x1 = max;
+            resize = false;
+        }
+    } else {
+        psAbort(__func__, "Read direction can only be 1 (rows) or 2 (cols).\n");
+    }
+
+    psImage *image = psFitsReadImage(fits, toRead, z); // Desired pixels
+
+    if (resize) {
+        // For some reason, the region of interest is smaller than the number of pixels we want.
+        psImage *temp = psImageAlloc(fullSize.x1 - fullSize.x0, fullSize.y1 - fullSize.y0, image->type.type);
+        psImageInit(temp, bad);
+        psImageOverlaySection(temp, image, toRead.x0, toRead.y0, "=");
+        psFree(image);
+        image = temp;
+    }
+
+    return image;
+}
+
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Public functions
@@ -79 +137 @@
 
 // Read the next readout; return true if we read pixels in.
+//
+// Note that this doesn't put pixels in the HDU.  It is therefore NOT COMPATIBLE with pmCellWrite,
+// pmChipWrite, and pmFPAWrite.  Use pmReadoutWriteNext to write the data that's read by this function.
 bool pmReadoutReadNext(pmReadout *readout, // Readout into which to read
                        psFits *fits,    // FITS file from which to read
@@ -98 +159 @@
 
     // Make sure we have the information we need
-    pmConceptsReadCell(cell, PM_CONCEPT_SOURCE_HEADER, false, NULL);
+    pmConceptsReadCell(cell, PM_CONCEPT_SOURCE_HEADER | PM_CONCEPT_SOURCE_CAMERA | PM_CONCEPT_SOURCE_DEFAULTS,
+                       false, NULL);
 
     // Get the trim and bias sections
@@ -113 +175 @@
     }
     int readdir = psMetadataLookupS32(&mdok, cell->concepts, "CELL.READDIR"); // Read direction
-    if (!mdok || readdir == 0 || (readdir != -1 && readdir != 1)) {
+    if (!mdok || readdir == 0 || (readdir != 1 && readdir != 2)) {
         psError(PS_ERR_IO, true, "CELL.READDIR is not set to -1 or +1.\n");
         return false;
+    }
+    float bad = psMetadataLookupF32(&mdok, cell->concepts, "CELL.BAD"); // Bad level
+    if (!mdok) {
+        psLogMsg(__func__, PS_LOG_WARN, "CELL.BAD is not set --- assuming zero.\n");
+        bad = 0.0;
     }
 
@@ -159 +226 @@
 
     // Read the FITS image
-    int offset = readout->row0;         // The row number to read
+    int offset = 0;                     // The offset from the start of the image to where we are now
     if (readout->image) {
-        if (readdir > 0) {
+        if (readdir == 1) {
             // Reading rows
-            offset += readout->image->numRows;
+            readout->row0 += readout->image->numRows;
+            offset = readout->row0;
         } else {
             // Reading columns
-            offset += readout->image->numCols;
-        }
-    }
-    if ((readdir > 0 && offset >= naxis2) || (readdir < 0 && offset > naxis1)) {
+            readout->col0 += readout->image->numCols;
+            offset = readout->col0;
+        }
+    }
+    if ((readdir == 1 && offset >= naxis2) || (readdir == 2 && offset > naxis1)) {
         // We've read everything there is
         return false;
     }
     int upper = offset + numScans;      // The upper limit for the pixel read
-    if (readdir > 0 && upper > naxis2) {
+    if (readdir == 1 && upper > naxis2) {
         upper = naxis2;
-    } else if (readdir < 0 && upper > naxis1) {
+    } else if (readdir == 2 && upper > naxis1) {
         upper = naxis1;
     }
-    psRegion region = {0, 0, 0, 0};     // Region to be read
-    if (readdir > 0) {
-        region = psRegionSet(0, naxis1, offset, upper); // Read rows
-    } else {
-        region = psRegionSet(offset, upper, 0, naxis2); // Read columns
-    }
-    psImage *image = psFitsReadImage(fits, region, z); // The image
-
-    // Stick the image into the HDU and the readout
-    if (!hdu->images) {
-        hdu->images = psArrayAlloc(naxis3);
-        hdu->images->n = naxis3;
-    }
-    if (hdu->images->nalloc != naxis3) {
-        hdu->images = psArrayRealloc(hdu->images, naxis3);
-        hdu->images->n = naxis3;
-    }
-    if (hdu->images->data[z]) {
-        psFree(hdu->images->data[z]);
-    }
-    hdu->images->data[z] = image;
-    readout->row0 = region.y0;
-    readout->col0 = region.x0;
-    readoutCarve(readout, image, trimsec, biassecs);
+
+    // Blow away existing data
+    psFree(readout->image);
+    while (readout->bias->n > 0) {
+        psListRemove(readout->bias, PS_LIST_HEAD);
+    }
+
+    // Get the new the trim section
+    readout->image = readoutReadComponent(fits, trimsec, readdir, offset, upper, z, bad); // The image
+
+    // Get the new bias sections
+    psListIterator *biassecsIter = psListIteratorAlloc(biassecs, PS_LIST_HEAD, false); // Iterator for BIASSEC
+    psRegion *biassec = NULL;           // Bias section from iteration
+    while ((biassec = psListGetAndIncrement(biassecsIter))) {
+        psImage *bias = readoutReadComponent(fits, biassec, readdir, offset, upper, z, bad); // The bias
+        psListAdd(readout->bias, PS_LIST_TAIL, bias);
+    }
+    psFree(biassecsIter);
 
     return true;