Changeset 34041 for branches/meh_branches/ppstack_test/ppImage/src

Timestamp:

Jun 19, 2012, 5:24:19 PM (14 years ago)

Author:

mhuber

Message:

merging latest r34040 trunk changes to branch

Location:

branches/meh_branches/ppstack_test

Files:

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

branches/meh_branches/ppstack_test/ppImage/src/Makefile.am

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

branches/meh_branches/ppstack_test/ppImage/src/ppImage.h

@@ -48 +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
 
@@ -56 +57 @@
     bool addNoise;                      // Add noise to degrade MD image to 3pi
 
+  bool hasVideo;                      // Determine if this OTA has a video cell
+  bool useVideoDark;                  // Should we use a video dark if we can?
+  bool useVideoMask;                  // Should we use a video mask if we can?
+  
     // output files requested
     bool BaseFITS;
@@ -172 +177 @@
 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/meh_branches/ppstack_test/ppImage/src/ppImageDetrendReadout.c

@@ -35 +35 @@
       }
     }
-
+    // Check to see if we're in a chip that contains video
+    bool hasVideo = false;
+    {
+      if (psMetadataLookupStr(NULL,input->parent->parent->hdu->header,"CELLMODE")) {
+        psWarning("VIDEO: %d %d %d\n",(int) options->hasVideo,(int) options->useVideoDark, (int) options->useVideoMask);
+        char *Vptr = strchr(psMetadataLookupStr(NULL,input->parent->parent->hdu->header,"CELLMODE"),'V');
+        if (Vptr) {
+          hasVideo = true;
+          psWarning("VIDEO: %d %d %d\n",(int) options->hasVideo,(int) options->useVideoDark, (int) options->useVideoMask);
+        }
+      }
+    }
+
+    
     // Masking on the basis of pixel value needs to be done before anything else, so the values are pristine.
     if (options->doMaskBuild) {
@@ -44 +57 @@
     // apply the externally supplied mask to the input->mask pixels
     if (options->doMask) {
-        pmReadout *mask = pmFPAfileThisReadout(config->files, detview, "PPIMAGE.MASK");
-        pmMaskBadPixels(input, mask, options->maskValue);
+      pmReadout *mask;
+      if ((options->useVideoMask)&&(hasVideo)) {
+        mask = pmFPAfileThisReadout(config->files, detview, "PPIMAGE.VIDEOMASK");
+      }
+      else {
+        mask = pmFPAfileThisReadout(config->files, detview, "PPIMAGE.MASK");
+      }
+      pmMaskBadPixels(input, mask, options->maskValue);
     }
     if (options->doMaskBurntool) {
@@ -80 +99 @@
         psMetadata *recipe = psMetadataLookupPtr (&mdok, config->recipes, RECIPE_NAME);
         assert(mdok && recipe);
-        if (psMetadataLookupBool(&mdok, recipe, "OLDDARK")) {
+
+        if ((options->useVideoDark)&&(hasVideo)) {
+          if (psMetadataLookupBool(&mdok, recipe, "OLDDARK")) {
+            oldDark = pmFPAfileThisReadout(config->files, detview, "PPIMAGE.VIDEODARK");
+          } else {
+            dark = pmFPAfileThisCell(config->files, detview, "PPIMAGE.VIDEODARK");
+          }
+        }
+        else {
+          if (psMetadataLookupBool(&mdok, recipe, "OLDDARK")) {
             oldDark = pmFPAfileThisReadout(config->files, detview, "PPIMAGE.DARK");
-        } else {
+          } else {
             dark = pmFPAfileThisCell(config->files, detview, "PPIMAGE.DARK");
-        }
+          }
+        }
     }
 
@@ -110 +139 @@
             // 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 +150 @@
             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/meh_branches/ppstack_test/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)){

branches/meh_branches/ppstack_test/ppImage/src/ppImageOptions.c

@@ -41 +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
     options->addNoise        = false;  //Degrade an MD image to a 3pi image
-
+    options->hasVideo        = false;   // Determine if this OTA has a video cell
+    options->useVideoDark    = false;   // Use video dark if we can?
+    options->useVideoMask    = false;   // Use video mask if we can?
     // output files requested
     options->BaseFITS        = false;   // create output image
@@ -319 +322 @@
 
     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'
@@ -360 +364 @@
     options->fringeKeep = psMetadataLookupF32(NULL, recipe, "FRINGE.KEEP");
 
+    // Video cell options
+    if (psMetadataLookup(recipe, "USE.VIDEO.DARK")) {
+      options->useVideoDark = psMetadataLookupBool(NULL,recipe,"USE.VIDEO.DARK");
+    }
+    if (psMetadataLookup(recipe, "USE.VIDEO.MASK")) {
+      options->useVideoMask = psMetadataLookupBool(NULL,recipe,"USE.VIDEO.MASK");
+    }
+
     // Pattern correction
     if (psMetadataLookup(format, "PATTERN.ROW.ORDER")) {
@@ -416 +428 @@
       options->patternContinuityEdgeWidth = psMetadataLookupS32(NULL, recipe, "PATTERN.CONTINUITY.WIDTH");
     }
-    
+
 
     // Remnance options

branches/meh_branches/ppstack_test/ppImage/src/ppImageParseCamera.c

@@ -22 +22 @@
     ppImageOptions *options = ppImageOptionsParse(config);
 
+    // parse the header to extract out whether this OTA has video cells.
+    // CZW: 2012-05-01 I'm somewhat ashamed of what needs to be done to get to the header. There has to be a simpler way, right?
+/*     pmFPAview *view = pmFPAviewAlloc(0);// View for level of interest */
+/*     pmChip *chip;                       // Chip from FPA */
+/*     while ((chip = pmFPAviewNextChip(view, input->fpa, 1)) != NULL) { */
+/*       if (!chip->process || !chip->file_exists) { */
+/*      continue; */
+/*       } */
+/* /\*       if (!pmFPAfileIOChecks(config, view, PM_FPA_BEFORE)) { *\/ */
+/* /\*  continue; *\/ */
+/* /\*       } *\/ */
+/*       psWarning("VIDEO: %d %d %d\n",(int) options->hasVideo,(int) options->useVideoDark, (int) options->useVideoMask); */
+/*       if (psMetadataLookupStr(NULL,chip->hdu->header,"CELLMODE")) { */
+/*      psWarning("VIDEO: %d %d %d\n",(int) options->hasVideo,(int) options->useVideoDark, (int) options->useVideoMask); */
+/*      char *Vptr = strchr(psMetadataLookupStr(NULL,chip->hdu->header,"CELLMODE"),'V'); */
+/*      if (Vptr) { */
+/*        options->hasVideo = true; */
+/*        psWarning("VIDEO: %d %d %d\n",(int) options->hasVideo,(int) options->useVideoDark, (int) options->useVideoMask); */
+/*      } */
+/*       } */
+/*     } */
+/*     pmFPAviewReset(view); */
+/*     psFree(view); */
+    
     // the following are defined from the argument list, if given,
     // otherwise they revert to the config information
@@ -42 +66 @@
     }
     if (options->doDark) {
-        if (!ppImageDefineFile(config, input->fpa, "PPIMAGE.DARK", "DARK",
-                               PM_FPA_FILE_DARK, PM_DETREND_TYPE_DARK)) {
+      // Always load the regular Dark
+      if (!ppImageDefineFile(config, input->fpa, "PPIMAGE.DARK", "DARK",
+                             PM_FPA_FILE_DARK, PM_DETREND_TYPE_DARK)) {
+        psError(PS_ERR_IO, false, "Can't find a dark image source");
+        psFree(options);
+        return NULL;
+      }
+      // Sometimes load the video dark if we need it.
+      if (options->useVideoDark) {
+        if (!ppImageDefineFile(config, input->fpa, "PPIMAGE.VIDEODARK", "DARK",
+                               PM_FPA_FILE_DARK, PM_DETREND_TYPE_VIDEODARK)) {
             psError(PS_ERR_IO, false, "Can't find a dark image source");
             psFree(options);
             return NULL;
         }
+      }
     }
     if (options->doMask) {
-        if (!ppImageDefineFile(config, input->fpa, "PPIMAGE.MASK", "MASK",
-                               PM_FPA_FILE_MASK, PM_DETREND_TYPE_MASK)) {
+      // Always load the regular mask
+      if (!ppImageDefineFile(config, input->fpa, "PPIMAGE.MASK", "MASK",
+                             PM_FPA_FILE_MASK, PM_DETREND_TYPE_MASK)) {
+        psError(PS_ERR_IO, false, "Can't find a mask image source");
+        psFree(options);
+        return NULL;
+      }
+
+      if (options->useVideoMask) {
+        if (!ppImageDefineFile(config, input->fpa, "PPIMAGE.VIDEOMASK", "MASK",
+                               PM_FPA_FILE_MASK, PM_DETREND_TYPE_VIDEOMASK)) {
             psError(PS_ERR_IO, false, "Can't find a mask image source");
             psFree(options);
             return NULL;
         }
+      }
     }
     if (options->doShutter) {