Changeset 33638 for branches/eam_branches/ipp-20111122/ppImage/src

Timestamp:

Mar 30, 2012, 2:49:37 PM (14 years ago)

Author:

eugene

Message:

merge changes from trunk

Location:

branches/eam_branches/ipp-20111122/ppImage/src

Files:

• . (modified) (1 prop)
• Makefile.am (modified) (1 diff)
• ppImage.h (modified) (4 diffs)
• ppImageCheckNoise.c (copied) (copied from trunk/ppImage/src/ppImageCheckNoise.c )
• ppImageDetrendPattern.c (modified) (4 diffs)
• ppImageDetrendReadout.c (modified) (2 diffs)
• ppImageLoop.c (modified) (2 diffs)
• ppImageOptions.c (modified) (5 diffs)

branches/eam_branches/ipp-20111122/ppImage/src/Makefile.am

@@ -59 +59 @@
         ppImageParityFlip.c \
         ppImageCheckCTE.c \
+        ppImageCheckNoise.c \
         ppImageFileCheck.c \
         ppImageVersion.c \

branches/eam_branches/ipp-20111122/ppImage/src/ppImage.h

@@ -40 +40 @@
     bool doPatternRow;                  // Row pattern correction
     bool doPatternCell;                 // Cell pattern correction
+    bool doPatternContinuity;           // Cell continuity correction
     bool doFringe;                      // Fringe subtraction
     bool doPhotom;                      // Source identification and photometry
@@ -47 +48 @@
     bool doStats;                       // call ppStats on the image
     bool checkCTE;                      // measure pixel-based variance
+    bool checkNoise;                    // measure cell-level variance
     bool applyParity;                   // Apply Cell parities
 
@@ -109 +111 @@
     psStatsOptions patternCellMean;        // Statistic for mean
 
+  int patternContinuityEdgeWidth;        // Size of box to use for edge matching.
+  
     int remnanceSize;                   // Size for remnance detection
     float remnanceThresh;               // Threshold for remnance detection
@@ -169 +173 @@
 bool ppImageCheckCTE(pmConfig *config, ppImageOptions *options, pmFPAview *view);
 
+bool ppImageCheckNoise(pmConfig *config, ppImageOptions *options, pmFPAview *view);
+
 bool ppImageBurntoolMask(pmConfig *config, ppImageOptions *options, pmFPAview *view, pmReadout *mask);
 

branches/eam_branches/ipp-20111122/ppImage/src/ppImageDetrendPattern.c

@@ -18 +18 @@
     pmCell *cell = NULL;
 
-    assert(options->doPatternRow || options->doPatternCell); // do not call if not needed
+    assert(options->doPatternRow || options->doPatternCell || options->doPatternContinuity); // do not call if not needed
     assert(inputView->chip != -1);
     assert(inputView->cell == -1);
@@ -40 +40 @@
         if (psMetadataLookupBool(NULL,hdu->header,"PTRN_ROW")) {
           psLogMsg("ppImage", PS_LOG_INFO, "Not performing row pattern correction as it has already been done.");
-          goto pattern_cell;
+          goto pattern_continuity;
         }
 
@@ -98 +98 @@
     }
 
+ pattern_continuity:
+
+    // see the comment for PATTERN.ROW; the same rules apply for PATTERN.CELL
+
+    if (options->doPatternContinuity) {
+        int numCells = chip->cells->n;       // Number of cells
+        psVector *tweak = psVectorAlloc(numCells, PS_TYPE_U8); // Tweak cell?
+        pmFPAview *view = pmFPAviewAlloc(0); // View for local processing
+        *view = *inputView;
+
+        pmHDU *hdu = pmHDUFromChip(chip);
+        if (psMetadataLookupBool(NULL,hdu->header,"PTRN_CON")) {
+          psLogMsg("ppImage", PS_LOG_INFO, "Not performing cell continuity correction as it has already been done.");
+          goto pattern_cell;
+        }
+
+        for (int i = 0; i < chip->cells->n; i++) {
+            view->cell = i;
+
+            pmCell *cell = chip->cells->data[i]; // Cell of interest
+
+            if (cell->readouts->n > 1) {
+                psLogMsg("ppImage", PS_LOG_INFO, "Not performing cell continuity correction on video cell.");
+                continue;
+            }
+
+            bool doPattern = false;
+            if (!doPatternForView(&doPattern, config, chip, view, RECIPE_NAME, "PATTERN.CONTINUITY.SUBSET")) {
+                ESCAPE(false, "Unable to determine whether row pattern matching should be applied.");
+            }
+            if (doPattern) {
+                tweak->data.U8[i] = 0xFF;
+            }
+        }
+
+        // Tweak the cells
+        if (!pmPatternContinuity(chip, tweak, options->patternCellBG, options->patternCellMean,
+                                 options->maskValue, options->darkMask,options->patternContinuityEdgeWidth)) {
+            psFree(tweak);
+            psFree(view);
+            return false;
+        }
+        psFree(tweak);
+        psFree(view);
+
+        psMetadataAddBool(hdu->header, PS_LIST_TAIL, "PTRN_CON",PS_META_REPLACE,"PATTERN.CONTINUITY correction applied",true);
+    }
+
  pattern_cell:
-
-    // see the comment for PATTERN.ROW; the same rules apply for PATTERN.CELL
-
+    
     if (options->doPatternCell) {
         int numCells = chip->cells->n;       // Number of cells
@@ -131 +177 @@
                 tweak->data.U8[i] = 0xFF;
             }
-
         }
 

branches/eam_branches/ipp-20111122/ppImage/src/ppImageDetrendReadout.c

@@ -110 +110 @@
             // offset information, we are not really getting exactly the right mapping from the
             // original file.
+            // CZW 2012-03-21: I do not believe this is true anymore.  In any case, this seems to be what
+            //                 ppImageReplaceBackground does to do sky subtraction.
             psImageBinning *binning = psImageBinningAlloc();
             binning->nXruff = noiseMap->image->numCols;
@@ -119 +121 @@
             psImageUnbin (noiseImage, noiseMap->image, binning);
             psFree (binning);
+            // Stolen from pmSkySubtract.c
+            // CZW: Unneeded, as psImageUnbin does the bilinear interpolation?  It still looks blocky. 
+/*          psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, RECIPE_NAME); // Recipe */
+/*          psAssert(recipe, "Should be there!"); */
+
+/*          psS32 xBinFactor = psMetadataLookupS32(NULL,recipe,"NOISE.XBIN"); */
+/*          psS32 yBinFactor = psMetadataLookupS32(NULL,recipe,"NOISE.YBIN"); */
+/*          psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(PS_INTERPOLATE_BILINEAR, */
+/*                                                                             noiseMap->image, */
+/*                                                                             NULL, NULL, */
+/*                                                                             0, 0.0, 0.0, 0, 0, 0.0); */
+/*          for (psS32 row = 0; row < input->image->numRows; row++) { */
+/*            for (psS32 col = 0; col < input->image->numCols; col++) { */
+/*              // We calculate the F32 value of the pixel coordinates in the */
+/*              // binned image and then use a pixel interpolation routine to */
+/*              // determine the value of the pixel at that location. */
+/*              psF32 binRowF64 = ((psF32) row) / ((psF32) yBinFactor); */
+/*              psF32 binColF64 = ((psF32) col) / ((psF32) xBinFactor); */
+/*              // We add 0.5 to the pixel locations since the pixel */
+/*              // interpolation routine defines the location of pixel */
+/*              // (i, j) as (i+0.5, j+0.5). */
+/*              binRowF64+= 0.5; */
+/*              binColF64+= 0.5; */
+
+/*              double binPixel; */
+/*              if (!psImagePixelInterpolate(&binPixel, NULL, NULL, binColF64, binRowF64, interp)) { */
+/*                psError(PS_ERR_UNKNOWN, false, "Unable to interpolate image."); */
+/*                psFree(interp); */
+/*                psFree(noiseImage); */
+/*                return NULL; */
+/*              } */
+/*              noiseImage->data.F32[row][col] = binPixel; */
+/*            } */
+/*          } */
+/*          psFree(interp); */
         }
 

branches/eam_branches/ipp-20111122/ppImage/src/ppImageLoop.c

@@ -126 +126 @@
                 }
 
+                if (!ppImageCheckNoise (config, options, view)) {
+                    ESCAPE("Unable to generate noisemap");
+                }
+                
                 // optionally degrade a MD image to 3pi exposure times
                 if (!ppImageAddNoise(config, options, view, input->fpa)){
@@ -170 +174 @@
 
         // Apply the pattern correction
-        if (options->doPatternRow || options->doPatternCell) {
+        if (options->doPatternRow || options->doPatternCell || options->doPatternContinuity) {
           if (!ppImageDetrendPatternApply(config,chip,view,options)) {
             ESCAPE("Unable to apply pattern corrections");

branches/eam_branches/ipp-20111122/ppImage/src/ppImageOptions.c

@@ -34 +34 @@
     options->doPatternRow    = false;   // Row pattern correction
     options->doPatternCell   = false;   // Cell pattern correction
+    options->doPatternContinuity = false; // Cell continuity correction
     options->doFringe        = false;   // Fringe subtraction
     options->doPhotom        = false;   // Source identification and photometry
@@ -40 +41 @@
     options->doStats         = false;   // Measure and save image statistics
     options->checkCTE        = false;   // Measure pixel-based variance
+    options->checkNoise      = false;   // Measure cell-level variances.
     options->applyParity     = false;   // Apply Cell parities
     options->doMaskStats     = false;   // Calculate mask fractions
@@ -253 +255 @@
     options->doPatternRow = psMetadataLookupBool(NULL, recipe, "PATTERN.ROW");
     options->doPatternCell = psMetadataLookupBool(NULL, recipe, "PATTERN.CELL");
+    options->doPatternContinuity = psMetadataLookupBool(NULL, recipe, "PATTERN.CONTINUITY");
 
     options->doMaskStats = psMetadataLookupBool(NULL, recipe, "MASK.STATS");
@@ -317 +320 @@
 
     options->checkCTE       = psMetadataLookupBool(NULL, recipe, "CHECK.CTE");
+    options->checkNoise     = psMetadataLookupBool(NULL, recipe, "CHECK.NOISE");
 
     /* doMaskBuild : there are some cases where we require a mask, so we force doMaskBuild to be set even if the user specified 'FALSE'
@@ -408 +412 @@
     }
 
+    if (psMetadataLookup(format, "PATTERN.CONTINUITY.WIDTH")) {
+      options->patternContinuityEdgeWidth = psMetadataLookupS32(NULL, format, "PATTERN.CONTINUITY.WIDTH");
+    }
+    else {
+      options->patternContinuityEdgeWidth = psMetadataLookupS32(NULL, recipe, "PATTERN.CONTINUITY.WIDTH");
+    }
+    
 
     // Remnance options