Changeset 24557 for branches/eam_branches/20090522/psModules/src/camera

Timestamp:

Jun 25, 2009, 2:00:56 PM (17 years ago)

Author:

eugene

Message:

merging changes from head

Location:

branches/eam_branches/20090522

Files:

• . (modified) (1 prop)
• psModules (modified) (1 prop)
• psModules/src/camera/pmFPABin.c (modified) (1 diff)
• psModules/src/camera/pmFPACopy.c (modified) (3 diffs)
• psModules/src/camera/pmFPAMaskWeight.c (modified) (7 diffs)
• psModules/src/camera/pmFPAMaskWeight.h (modified) (4 diffs)
• psModules/src/camera/pmHDU.c (modified) (1 diff)

branches/eam_branches/20090522/psModules/src/camera/pmFPABin.c

@@ -65 +65 @@
             }
 
-            float imageValue, maskValue;// Values to set
+            // Values to set
+            float imageValue;
+            psImageMaskType maskValue;
             if (numPix > 0) {
                 imageValue = sum / numPix;

branches/eam_branches/20090522/psModules/src/camera/pmFPACopy.c

@@ -70 +70 @@
     psImageBinningSetRuffSize(binning, PS_IMAGE_BINNING_CENTER);
     *target = psImageAlloc(binning->nXruff, binning->nYruff, source->type.type);
+    psImageInit (*target, 0.0);
     return;
 }
@@ -221 +222 @@
     psTrace("psModules.camera", 3, "xFlip: %d; yFlip: %d\n", xFlip, yFlip);
 
+    // Blow away extant readouts
+    for (int i = 0; i < target->readouts->n; i++) {
+        psFree(target->readouts->data[i]);
+        target->readouts->data[i] = NULL;
+    }
+    target->readouts->n = 0;
+
     // Perform deep copy of the images.  I would prefer *not* to do a deep copy, in the interests of speed (we
     // still need to do another deep copy into the HDU for when we write out), but this is the only way I can
@@ -242 +250 @@
         readoutCopyComponent(&targetReadout->variance, sourceReadout->variance, binning, xFlip, yFlip,
                              pixels);
+        // Copy covariance matrix: doesn't care about flips, etc.
+        if (sourceReadout->covariance) {
+            if (targetReadout->covariance) {
+                psFree(targetReadout->covariance);
+            }
+            targetReadout->covariance = psKernelCopy(sourceReadout->covariance);
+#if 0
+            if (binning) {
+                // XXX This isn't strictly correct, but we don't have a function that bins covariance matrices
+                // with unequal binning factors.
+                psKernel *covar = psImageCovarianceBin(PS_MAX(binning->nXbin, binning->nYbin),
+                                                       targetReadout->covariance);
+                psFree(targetReadout->covariance);
+                targetReadout->covariance = covar;
+            }
+#endif
+        }
 
         // Copy bias

branches/eam_branches/20090522/psModules/src/camera/pmFPAMaskWeight.c

@@ -199 +199 @@
 }
 
-bool pmReadoutSetVariance(pmReadout *readout, bool poisson)
+bool pmReadoutSetVariance(pmReadout *readout, const psImage *noiseMap, bool poisson)
 {
     PS_ASSERT_PTR_NON_NULL(readout, false);
+    // check that the noiseMap (if it exists) matches the readout variance size)
 
     pmCell *cell = readout->parent;     // The parent cell
@@ -228 +229 @@
 
         // a negative variance is non-sensical. if the image value drops below 1, the variance must be 1.
+        // XXX this calculation is wrong: limit is 1 e-, but this is in DN
         readout->variance = (psImage*)psUnaryOp(readout->variance, readout->variance, "abs");
         readout->variance = (psImage*)psBinaryOp(readout->variance, readout->variance, "max",
@@ -239 +241 @@
     }
 
-    readout->variance = (psImage*)psBinaryOp(readout->variance, readout->variance, "+",
-                                           psScalarAlloc(readnoise*readnoise/gain/gain, PS_TYPE_F32));
+    // apply a supplied readnoise map (NOTE: in DN, not electrons):
+    if (noiseMap) {
+        psImage *rdVar = (psImage*)psBinaryOp(NULL, (const psPtr) noiseMap, "*", (const psPtr) noiseMap);
+        readout->variance = (psImage*)psBinaryOp(readout->variance, readout->variance, "+", rdVar);
+        psFree (rdVar);
+    } else {
+        readout->variance = (psImage*)psBinaryOp(readout->variance, readout->variance, "+", psScalarAlloc(readnoise*readnoise/gain/gain, PS_TYPE_F32));
+    }
 
     return true;
@@ -247 +255 @@
 // this function creates the variance pixels, or uses the existing variance pixels.  it will set
 // the noise pixel values only if the variance image is not supplied
-bool pmReadoutGenerateVariance(pmReadout *readout, bool poisson)
+bool pmReadoutGenerateVariance(pmReadout *readout, const psImage *noiseMap, bool poisson)
 {
     PS_ASSERT_PTR_NON_NULL(readout, false);
@@ -291 +299 @@
     readout->variance = variance;
 
-    return pmReadoutSetVariance(readout, poisson);
-}
-
-bool pmReadoutGenerateMaskVariance(pmReadout *readout, psImageMaskType satMask, psImageMaskType badMask, bool poisson)
+    return pmReadoutSetVariance(readout, noiseMap, poisson);
+}
+
+bool pmReadoutGenerateMaskVariance(pmReadout *readout, psImageMaskType satMask, psImageMaskType badMask, const psImage *noiseMap, bool poisson)
 {
     PS_ASSERT_PTR_NON_NULL(readout, false);
@@ -301 +309 @@
 
     success &= pmReadoutGenerateMask(readout, satMask, badMask);
-    success &= pmReadoutGenerateVariance(readout, poisson);
+    success &= pmReadoutGenerateVariance(readout, noiseMap, poisson);
 
     return success;
 }
 
-bool pmCellGenerateMaskVariance(pmCell *cell, psImageMaskType satMask, psImageMaskType badMask, bool poisson)
+bool pmCellGenerateMaskVariance(pmCell *cell, psImageMaskType satMask, psImageMaskType badMask, const psImage *noiseMap, bool poisson)
 {
     PS_ASSERT_PTR_NON_NULL(cell, false);
@@ -314 +322 @@
     for (int i = 0; i < readouts->n; i++) {
         pmReadout *readout = readouts->data[i]; // The readout
-        success &= pmReadoutGenerateMaskVariance(readout, poisson, satMask, badMask);
+        success &= pmReadoutGenerateMaskVariance(readout, satMask, badMask, noiseMap, poisson);
     }
 

branches/eam_branches/20090522/psModules/src/camera/pmFPAMaskWeight.h

@@ -54 +54 @@
 /// can't be generated.
 bool pmReadoutSetVariance(pmReadout *readout, ///< Readout for which to set variance
+                          const psImage *noiseMap, ///< 2D image of the read noise in DN
                           bool poisson    ///< Include poisson variance (in addition to read noise)?
     );
@@ -72 +73 @@
 /// with HDU entry).  This is intended for most operations.
 bool pmReadoutGenerateVariance(pmReadout *readout, ///< Readout for which to generate variance
+                          const psImage *noiseMap, ///< 2D image of the read noise in DN
                                bool poisson    ///< Include poisson variance (in addition to read noise)?
     );
@@ -81 +83 @@
                                    psImageMaskType sat, ///< Mask value to give saturated pixels
                                    psImageMaskType bad, ///< Mask value to give bad (low) pixels
+                                   const psImage *noiseMap, ///< 2D image of the read noise in DN
                                    bool poisson ///< Include poisson variance (in addition to read noise)?
     );
@@ -90 +93 @@
                                 psImageMaskType sat, ///< Mask value to give saturated pixels
                                 psImageMaskType bad, ///< Mask value to give bad (low) pixels
+                                const psImage *noiseMap, ///< 2D image of the read noise in DN
                                 bool poisson ///< Include poisson variance (in addition to read noise)?
     );

branches/eam_branches/20090522/psModules/src/camera/pmHDU.c

@@ -93 +93 @@
     }
 
+    psTrace("psModules.camera", 5, "Reading the header...\n");
+
+    // The header may already exist (e.g., from doing concept writing at the PHU level) so we need to be
+    // careful.  We read into a separate container and copy that over the top of anything that's already read.
+    psMetadata *header = psFitsReadHeader(NULL, fits);
+    if (!header) {
+        psError(PS_ERR_IO, false, "Unable to read header for extension %s\n", hdu->extname);
+        return false;
+    }
+
     if (!hdu->header) {
-        psTrace("psModules.camera", 5, "Reading the header...\n");
-        hdu->header = psFitsReadHeader(hdu->header, fits);
-        if (! hdu->header) {
-            psError(PS_ERR_IO, false, "Unable to read header for extension %s\n", hdu->extname);
-            return false;
-        }
-    }
+        hdu->header = header;
+        return true;
+    }
+
+    psMetadataIterator *iter = psMetadataIteratorAlloc(header, PS_LIST_HEAD, NULL); // Iterator
+    psMetadataItem *item;           // Item from iteration
+    while ((item = psMetadataGetAndIncrement(iter))) {
+        const char *name = item->name; // Name of item
+        if (psMetadataLookup(hdu->header, name)) {
+            // It exists; clobber
+            psMetadataRemoveKey(hdu->header, name);
+        }
+        psMetadataAddItem(hdu->header, item, PS_LIST_TAIL, 0);
+    }
+    psFree(iter);
+    psFree(header);
 
     return true;