Changeset 23352 for branches/cnb_branches/cnb_branch_20090301/ppImage

Timestamp:

Mar 17, 2009, 12:08:50 PM (17 years ago)

Author:

beaumont

Message:

merged with head

Location:

branches/cnb_branches/cnb_branch_20090301

Files:

• . (modified) (1 prop)
• ppImage (modified) (1 prop)
• ppImage/src/Makefile.am (modified) (1 diff)
• ppImage/src/ppImage.c (modified) (1 diff)
• ppImage/src/ppImage.h (modified) (2 diffs)
• ppImage/src/ppImageArguments.c (modified) (5 diffs)
• ppImage/src/ppImageDefineFile.c (modified) (1 diff)
• ppImage/src/ppImageDetrendReadout.c (modified) (6 diffs)
• ppImage/src/ppImageLoop.c (modified) (7 diffs)
• ppImage/src/ppImageLoop_Threaded.c (deleted)
• ppImage/src/ppImageOptions.c (modified) (2 diffs)
• ppImage/src/ppImageParseCamera.c (modified) (15 diffs)
• ppImage/src/ppImageReplaceBackground.c (modified) (1 diff)
• ppImage/src/ppImageVersion.c (modified) (2 diffs)

branches/cnb_branches/cnb_branch_20090301/ppImage/src/Makefile.am

@@ -4 +4 @@
         ppImage.h 
 
-ppImage_CFLAGS = $(PPIMAGE_CFLAGS) $(PPSTATS_CFLAGS) $(PSASTRO_CFLAGS) $(PSPHOT_CFLAGS) $(PSMODULE_CFLAGS) $(PSLIB_CFLAGS)
+#PPIMAGE_VERSION=`if [ -e ../../VERSION ]; then cat ../../VERSION; else svnversion; fi`
+#PPIMAGE_BRANCH=`if [ -e ../../BRANCH ]; then cat ../../BRANCH; else svn info | sed -n -e '/URL:/ h' -e '/Repository Root:/ { x; H; x; s|Repository Root: \(.*\)\nURL: \1\(.*\)|\2| ; s|^/|| ; s|/[a-zA-Z]*/src.*|| ; p }'; fi`
+#PPIMAGE_SOURCE=`if [ -e ../../SOURCE ]; then cat ../../SOURCE; else svn info | sed -n -e 's/Repository UUID: // p'; fi`
+
+# Force recompilation of ppImageVersion.c, since it gets the version information
+# ppImageVersion.c: FORCE
+#       touch ppImageVersion.c
+# FORCE: ;
+
+ppImage_CFLAGS = $(PPIMAGE_CFLAGS) $(PPSTATS_CFLAGS) $(PSASTRO_CFLAGS) $(PSPHOT_CFLAGS) $(PSMODULE_CFLAGS) $(PSLIB_CFLAGS) -DPPIMAGE_VERSION=$(SVN_VERSION) -DPPIMAGE_BRANCH=$(SVN_BRANCH) -DPPIMAGE_SOURCE=$(SVN_SOURCE)
 ppImage_LDFLAGS = $(PPIMAGE_LIBS) $(PSASTRO_LIBS) $(PPSTATS_LIBS) $(PSPHOT_LIBS) $(PSMODULE_LIBS) $(PSLIB_LIBS)
 ppImage_SOURCES = \

branches/cnb_branches/cnb_branch_20090301/ppImage/src/ppImage.c

@@ -21 +21 @@
         exit(PS_EXIT_CONFIG_ERROR);
     }
+
+    ppImageVersionPrint();
 
     // define recipe options

branches/cnb_branches/cnb_branch_20090301/ppImage/src/ppImage.h

@@ -86 +86 @@
     int remnanceSize;                   // Size for remnance detection
     float remnanceThresh;               // Threshold for remnance detection
+
+    char *normClass;                    // class to use for per-class normalization 
 } ppImageOptions;
 
@@ -208 +210 @@
 psString ppImageVersion(void);
 
+/// Return software source
+psString ppImageSource(void);
+
 /// Return long version information
 psString ppImageVersionLong(void);
 
-/// Update the metadata with version information for all dependencies
-void ppImageVersionMetadata(psMetadata *metadata ///< Metadata to update with version information
-    );
+/// Populate the header with version information for all dependencies
+bool ppImageVersionHeader(psMetadata *metadata ///< Header to populate
+    );
+
+/// Print version information
+void ppImageVersionPrint(void);
 
 

branches/cnb_branches/cnb_branch_20090301/ppImage/src/ppImageArguments.c

@@ -14 +14 @@
     fprintf(stderr, "\t-chip CHIPNUM: Only process this chip number.\n");
     fprintf(stderr, "\t-norm VALUE: Divide through by this value when done.\n");
+    fprintf(stderr, "\t-normlist file.mdc: normalizations by class_id.\n");
     fprintf(stderr, "\n");
     fprintf(stderr, "Input options (single file / file list):\n");
@@ -80 +81 @@
     if ((argnum = psArgumentGet(argc, argv, "-visual"))) {
         psArgumentRemove(argnum, &argc, argv);
-        psphotSetVisual (true);
+        pmVisualSetVisual(true);
     }
 
@@ -86 +87 @@
     if ((argnum = psArgumentGet(argc, argv, "-threads"))) {
         psArgumentRemove(argnum, &argc, argv);
-        int nThreads = atoi(argv[argnum]);
+        int nThreads = atoi(argv[argnum]);
         psMetadataAddS32(config->arguments, PS_LIST_TAIL, "NTHREADS", 0, "number of warp threads", nThreads);
         psArgumentRemove(argnum, &argc, argv);
 
-        // create the thread pool with number of desired threads, supplying our thread launcher function
-        // XXX need to determine the number of threads from the config data
-        psThreadPoolInit (nThreads);
+        // create the thread pool with number of desired threads, supplying our thread launcher function
+        // XXX need to determine the number of threads from the config data
+        psThreadPoolInit (nThreads);
     }
 
@@ -107 +108 @@
 
     // the input file is a required argument; if not found, we will exit
-    bool status = pmConfigFileSetsMD (config->arguments, &argc, argv, "INPUT", "-file", "-list");
-    if (!status) {
-        usage ();
-    }
+    pmConfigFileSetsMD (config->arguments, &argc, argv, "INPUT", "-file", "-list");
 
     // if these command-line options are supplied, load the file name lists into config->arguments
@@ -128 +126 @@
     }
 
-    // Optional normalisation factor
+    // Optional normalization factor
     if ((argnum = psArgumentGet(argc, argv, "-norm"))) {
         psArgumentRemove(argnum, &argc, argv);
         float norm = atof(argv[argnum]);
-        psMetadataAddF32(config->arguments, PS_LIST_TAIL, "NORMALISATION", 0,
+        psMetadataAddF32(config->arguments, PS_LIST_TAIL, "NORMALIZATION", 0,
                          "Normalisation to apply", norm);
+        psArgumentRemove(argnum, &argc, argv);
+    }
+
+    // Optional per-class normalization table
+    if ((argnum = psArgumentGet(argc, argv, "-normlist"))) {
+        psArgumentRemove(argnum, &argc, argv);
+
+        unsigned int nFail = 0;
+        psMetadata *normlist = psMetadataConfigRead (NULL, &nFail, argv[argnum], false);
+        // XXX allow this file to be in nebulous?
+
+        psMetadataAddMetadata(config->arguments, PS_LIST_TAIL, "NORMALIZATION.TABLE", 0, "Normalization to apply", normlist);
+        psFree (normlist);
         psArgumentRemove(argnum, &argc, argv);
     }

branches/cnb_branches/cnb_branch_20090301/ppImage/src/ppImageDefineFile.c

@@ -5 +5 @@
 # include "ppImage.h"
 
-bool ppImageDefineFile (pmConfig *config, pmFPA *input, char *filerule, char *argname, pmFPAfileType fileType, pmDetrendType detrendType) {
+bool ppImageDefineFile(pmConfig *config, pmFPA *input, char *filerule, char *argname,
+                       pmFPAfileType fileType, pmDetrendType detrendType)
+{
+    bool status;
+    pmFPAfile *file = NULL;             // File to be defined
 
-    bool status;
-    pmFPAfile *file;
-
-    // look for the file on the argument list
-    file = pmFPAfileDefineFromArgs  (&status, config, filerule, argname);
-    if (!status) {
-        psError (PS_ERR_UNKNOWN, false, "failed to load find definition");
-        return false;
+    if (!file) {
+        // look for the file on the RUN metadata
+        file = pmFPAfileDefineFromRun(&status, config, filerule);
+        if (!status) {
+            psError(PS_ERR_UNKNOWN, false, "failed to load file definition");
+            return false;
+        }
     }
-    if (file) {
-        if (file->type != fileType) {
-            psError(PS_ERR_IO, true, "%s is not of type %s", filerule, pmFPAfileStringFromType (fileType));
-            return false;
-        }
-        return true;
+    if (!file) {
+        // look for the file on the argument list
+        file = pmFPAfileDefineFromArgs(&status, config, filerule, argname);
+        if (!status) {
+            psError(PS_ERR_UNKNOWN, false, "failed to load file definition");
+            return false;
+        }
+    }
+    if (!file) {
+        // look for the file in the camera config table
+        file = pmFPAfileDefineFromConf(&status, config, filerule);
+        if (!status) {
+            psError(PS_ERR_UNKNOWN, false, "failed to load file definition");
+            return false;
+        }
+    }
+    if (!file) {
+        // look for the file to be loaded from the detrend database
+        file = pmFPAfileDefineFromDetDB(&status, config, filerule, input, detrendType);
+        if (!status) {
+            psError(PS_ERR_UNKNOWN, false, "failed to load file definition");
+            return false;
+        }
     }
 
-    // look for the file in the camera config table
-    file = pmFPAfileDefineFromConf  (&status, config, filerule);
-    if (!status) {
-        psError (PS_ERR_UNKNOWN, false, "failed to load find definition");
-        return false;
-    }
-    if (file) {
-        if (file->type != fileType) {
-            psError(PS_ERR_IO, true, "%s is not of type %s", filerule, pmFPAfileStringFromType (fileType));
-            return false;
-        }
-        return true;
+    if (!file) {
+        return false;
     }
 
-    // look for the file to be loaded from the detrend database
-    file = pmFPAfileDefineFromDetDB (&status, config, filerule, input, detrendType);
-    if (!status) {
-        psError (PS_ERR_UNKNOWN, false, "failed to load file definition");
-        return false;
+    if (file->type != fileType) {
+        psError(PS_ERR_IO, true, "%s is not of type %s", filerule, pmFPAfileStringFromType(fileType));
+        return false;
     }
-    if (file) {
-        if (file->type != fileType) {
-            psError(PS_ERR_IO, true, "%s is not of type %s", filerule, pmFPAfileStringFromType (fileType));
-            return false;
-        }
-        return true;
-    }
-    return false;
+    return true;
 }
 

branches/cnb_branches/cnb_branch_20090301/ppImage/src/ppImageDetrendReadout.c

@@ -54 +54 @@
         if (!pmBiasSubtract(input, options->overscan, bias, oldDark, view)) {
             psError(PS_ERR_UNKNOWN, false, "Unable to subtract bias.");
+            psFree(detview);
             return false;
         }
@@ -67 +68 @@
         if (!pmDarkApply(input, dark, options->maskValue)) {
             psError(PS_ERR_UNKNOWN, false, "Unable to subtract dark.");
+            psFree(detview);
             return false;
         }
@@ -75 +77 @@
                         options->remnanceSize, options->remnanceThresh)) {
             psError(PS_ERR_UNKNOWN, false, "Unable to mask remnance.");
+            psFree(detview);
             return false;
         }
@@ -83 +86 @@
         pmReadout *shutter = pmFPAfileThisReadout(config->files, detview, "PPIMAGE.SHUTTER");
         if (!pmShutterCorrectionApply(input, shutter, pmConfigMaskGet("FLAT", config))) {
+            psFree(detview);
             return false;
         }
@@ -91 +95 @@
         pmReadout *flat = pmFPAfileThisReadout(config->files, detview, "PPIMAGE.FLAT");
         if (!pmFlatField(input, flat, options->flatMask)) {
+            psFree(detview);
             return false;
         }
     }
 
-    // Normalisation by a (known) constant
+    // Normalization by a single (known) constant
     bool mdok;                          // Status of MD lookup
-    float norm = psMetadataLookupF32(&mdok, config->arguments, "NORMALISATION");
+    float norm = psMetadataLookupF32(&mdok, config->arguments, "NORMALIZATION");
     if (mdok && isfinite(norm) && norm != 1.0) {
         pmHDU *hdu = pmHDUFromReadout(input); // HDU of interest
@@ -108 +113 @@
     }
 
+# if (1)
+    // Normalization by per-class values
+    psMetadata *normlist = psMetadataLookupMetadata(&mdok, config->arguments, "NORMALIZATION.TABLE");
+    if (normlist) {
+        pmFPAfile *inputFile = psMetadataLookupPtr(&mdok, config->files, "PPIMAGE.INPUT");
+
+        // get the menu of class IDs
+        psMetadata *menu = psMetadataLookupMetadata(&mdok, inputFile->camera, "CLASSID"); 
+        if (!menu) {
+            psError(PS_ERR_IO, false, "Unable to find CLASSID metadata in camera configuration");
+            psFree(detview);
+            return false;
+        }
+        // get the rule for class_id for the desired class
+        const char *rule = psMetadataLookupStr(&mdok, menu, options->normClass); 
+        if (!rule) {
+            psError(PS_ERR_IO, false, "Unable to find NORM.CLASS value %s in CLASSID in camera configuration", options->normClass);
+            psFree(detview);
+            return false;
+        }
+        // get the class_id from the rule
+        char *classID = pmFPAfileNameFromRule(rule, inputFile, view);
+        if (!classID) {
+            psError(PS_ERR_IO, false, "error converting CLASSID rule %s to name\n", rule);
+            psFree(detview);
+            return false;
+        }
+
+        // get normalization from the class_id
+        float norm = psMetadataLookupF32 (&mdok, normlist, classID);
+
+        pmHDU *hdu = pmHDUFromReadout(input); // HDU of interest
+        psString comment = NULL;        // Comment to add
+        psStringAppend(&comment, "Normalization: %f", norm);
+        psMetadataAddStr(hdu->header, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, comment, "");
+        psFree(comment);
+
+        // apply the normalization
+        psBinaryOp(input->image, input->image, "*", psScalarAlloc(norm, PS_TYPE_F32));
+
+        psFree (classID);
+    }
+# endif
+
     if (options->doFringe) {
         pmCell *fringe = pmFPAfileThisCell(config->files, detview, "PPIMAGE.FRINGE");
         if (!ppImageDetrendFringeMeasure(input, fringe, false, options)) {
+            psFree(detview);
             return false;
         }

branches/cnb_branches/cnb_branch_20090301/ppImage/src/ppImageLoop.c

@@ -25 +25 @@
     }
 
-    psString dump_file = psMetadataLookupStr(&status, config->arguments, "DUMP_CONFIG");
-    if (dump_file) {
-        pmConfigCamerasCull(config, NULL);
-        pmConfigRecipesCull(config, "PPIMAGE,PPSTATS,PSPHOT,MASKS,PSASTRO");
-
-        pmConfigDump(config, input->fpa, dump_file);
-    }
+    pmConfigCamerasCull(config, NULL);
+    pmConfigRecipesCull(config, "PPIMAGE,PPSTATS,PSPHOT,MASKS,PSASTRO,JPEG");
 
     pmFPAview *view = pmFPAviewAlloc(0);// View for level of interest
@@ -63 +58 @@
 
             // Put version information into the header
-            pmHDU *hdu = pmHDUFromCell(cell);
+            pmHDU *hdu = pmHDUGetHighest(input->fpa, chip, cell);
             if (hdu && hdu != lastHDU) {
-                ppImageVersionMetadata(hdu->header);
+                ppImageVersionHeader(hdu->header);
                 lastHDU = hdu;
             }
@@ -96 +91 @@
                 }
 
-                // free detrend images potentially in use: MASK, BIAS, DARK, SHUTTER, FLAT
-                if (!ppImageDetrendFree (config, view)) {
-                    ESCAPE("Unable to free detrend images");
-                }
+                // free detrend images potentially in use: MASK, BIAS, DARK, SHUTTER, FLAT
+                if (!ppImageDetrendFree (config, view)) {
+                    ESCAPE("Unable to free detrend images");
+                }
             }
 
@@ -105 +100 @@
                 ppImageDetrendRecord(cell, config, options, view);
             }
-            // free detrend images potentially in use: MASK, BIAS, DARK, SHUTTER, FLAT
-            if (!ppImageDetrendFree (config, view)) {
-                ESCAPE("Unable to free detrend images");
-            }
-        }
-        // free detrend images potentially in use: MASK, BIAS, DARK, SHUTTER, FLAT
-        if (!ppImageDetrendFree (config, view)) {
-            ESCAPE("Unable to free detrend images");
-        }
+            // free detrend images potentially in use: MASK, BIAS, DARK, SHUTTER, FLAT
+            if (!ppImageDetrendFree (config, view)) {
+                ESCAPE("Unable to free detrend images");
+            }
+        }
+        // free detrend images potentially in use: MASK, BIAS, DARK, SHUTTER, FLAT
+        if (!ppImageDetrendFree (config, view)) {
+            ESCAPE("Unable to free detrend images");
+        }
 
         // Apply the fringe correction
@@ -121 +116 @@
             }
         }
-        // free detrend images potentially in use: MASK, BIAS, DARK, SHUTTER, FLAT
-        if (!ppImageFringeFree (config, view)) {
-            ESCAPE("Unable to free fringe images");
-        }
+        // free detrend images potentially in use: MASK, BIAS, DARK, SHUTTER, FLAT
+        if (!ppImageFringeFree (config, view)) {
+            ESCAPE("Unable to free fringe images");
+        }
 
         // measure various pixel-based statistics for this image
@@ -152 +147 @@
         }
 
-        // these may be used by ppImageSubtractBackground.
-        // if these are defined as internal files, drop them here
-        status = true;
-        status &= pmFPAfileDropInternal (config->files, "PSPHOT.BACKMDL");
-        status &= pmFPAfileDropInternal (config->files, "PSPHOT.BACKMDL.STDEV");
-        status &= pmFPAfileDropInternal (config->files, "PSPHOT.BACKGND");
-        if (!status) {
-            psError(PSPHOT_ERR_PROG, false, "trouble dropping internal files");
-            psFree (view);
-            return false;
-        }
+        // these may be used by ppImageSubtractBackground.
+        // if these are defined as internal files, drop them here
+        status = true;
+        status &= pmFPAfileDropInternal (config->files, "PSPHOT.BACKMDL");
+        status &= pmFPAfileDropInternal (config->files, "PSPHOT.BACKMDL.STDEV");
+        status &= pmFPAfileDropInternal (config->files, "PSPHOT.BACKGND");
+        if (!status) {
+            psError(PSPHOT_ERR_PROG, false, "trouble dropping internal files");
+            psFree (view);
+            return false;
+        }
 
         // binning (used for display) must take place after the background is replaced, if desired
@@ -219 +214 @@
     }
     psFree(view);
+
+    // Dump configuration
+    psString dump_file = psMetadataLookupStr(&status, config->arguments, "DUMP_CONFIG");
+    if (dump_file) {
+        pmConfigDump(config, input->fpa, dump_file);
+    }
 
     // Write out summary statistics

branches/cnb_branches/cnb_branch_20090301/ppImage/src/ppImageOptions.c

@@ -81 +81 @@
     options->remnanceThresh  = 25.0;    // Threshold for remnance detection
 
+    // per-class normalization source
+    options->normClass       = NULL;    // per-class normalizations refer to this class
+
     return options;
 }
@@ -278 +281 @@
     options->remnanceThresh = psMetadataLookupS32(NULL, recipe, "REMNANCE.THRESH");
 
+    // per-class normalization source (just a reference; don't free)
+    options->normClass = psMetadataLookupStr(NULL, recipe, "NORM.CLASS");
+
     return options;
 }

branches/cnb_branches/cnb_branch_20090301/ppImage/src/ppImageParseCamera.c

@@ -9 +9 @@
     bool status = false;
 
-    // the input image defines the camera, and all recipes and options the follow
-    pmFPAfile *input = pmFPAfileDefineFromArgs (&status, config, "PPIMAGE.INPUT", "INPUT");
-    if (!status || !input) {
-        psError(PS_ERR_IO, false, "Failed to build FPA from PPIMAGE.INPUT");
-        return NULL;
-    }
-    if (input->type != PM_FPA_FILE_IMAGE) {
-        psError(PS_ERR_IO, true, "PPIMAGE.INPUT is not of type IMAGE");
-        return NULL;
-    }
-
-    // if MASK or VARIANCE was supplied on command line, bind files to 'input'.
-    // the mask and variance will be mosaicked with the image
-    pmFPAfile *inputMask = pmFPAfileBindFromArgs(&status, input, config, "PPIMAGE.INPUT.MASK", "PPIMAGE.INPUT.MASK");
-    if (!status) {
-        psError (PS_ERR_UNKNOWN, false, "failed to load find definition");
-        return NULL;
-    }
-    if (inputMask) {
-      if (inputMask->type != PM_FPA_FILE_MASK) {
-        psError(PS_ERR_IO, true, "PPIMAGE.INPUT.MASK is not of type MASK");
-        return NULL;
-      }
-    }
-
-    pmFPAfile *inputVariance = pmFPAfileBindFromArgs(&status, input, config, "PPIMAGE.INPUT.VARIANCE", "PPIMAGE.INPUT.VARIANCE");
-    if (!status) {
-        psError (PS_ERR_UNKNOWN, false, "failed to load find definition");
-        return NULL;
-    }
-    if (inputVariance && inputVariance->type != PM_FPA_FILE_VARIANCE) {
-        psError(PS_ERR_IO, true, "PPIMAGE.INPUT.VARIANCE is not of type VARIANCE");
-        return NULL;
-    }
+    if (!ppImageDefineFile(config, NULL, "PPIMAGE.INPUT", "INPUT", PM_FPA_FILE_IMAGE, PM_DETREND_TYPE_NONE)) {
+        psError(PS_ERR_IO, false, "Can't find an input image source");
+        return NULL;
+    }
+    pmFPAfile *input = psMetadataLookupPtr(NULL, config->files, "PPIMAGE.INPUT"); // Input file
+    psAssert(input, "We just put it there!");
 
     // add recipe options supplied on command line
-    psMetadata *recipe  = psMetadataLookupPtr (&status, config->recipes, RECIPE_NAME);
+    psMetadata *recipe  = psMetadataLookupPtr(&status, config->recipes, RECIPE_NAME);
 
     // parse the options from the metadata format to the ppImageOptions structure
-    ppImageOptions *options = ppImageOptionsParse (config);
+    ppImageOptions *options = ppImageOptionsParse(config);
 
     // the following are defined from the argument list, if given,
@@ -54 +26 @@
     // not all input or output images are used in a given recipe
     if (options->doBias) {
-        if (!ppImageDefineFile (config, input->fpa, "PPIMAGE.BIAS", "BIAS", PM_FPA_FILE_IMAGE, PM_DETREND_TYPE_BIAS)) {
-            psError (PS_ERR_IO, false, "Can't find a bias image source");
-            psFree (options);
+        if (!ppImageDefineFile(config, input->fpa, "PPIMAGE.BIAS", "BIAS",
+                               PM_FPA_FILE_IMAGE, PM_DETREND_TYPE_BIAS)) {
+            psError(PS_ERR_IO, false, "Can't find a bias image source");
+            psFree(options);
             return NULL;
         }
     }
     if (options->doDark) {
-        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);
+        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;
         }
     }
     if (options->doMask) {
-
-        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 (!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 0
+        // I think this is now done automatically in the pmFPAfileDefine and pmFPAfileIOChecks -- PAP.
+
         // XXX have ppImageDefineFile return the pmFPAfile?
         pmFPAfile *mask = psMetadataLookupPtr(&status, config->files, "PPIMAGE.MASK");
-        psAssert (mask, "mask not defined?  not possible!");
+        psAssert(mask, "Just defined the mask!");
 
         // Need to read the names of bit masks from the mask header and set them in the
@@ -84 +62 @@
             // XXX need to load the mask bit names from one of the headers
             // this grabs the first available hdu : no guarantee that it will be valid, though
-            pmHDU *hdu = pmHDUGetFirst (mask->fpa);
+            pmHDU *hdu = pmHDUGetFirst(mask->fpa);
             if (!hdu) {
                 psError(PS_ERR_IO, true, "no valid HDU for PPIMAGE.INPUT.MASK");
@@ -90 +68 @@
             }
             // XXX is this consistent with the pmConfigMaskReadHeader call above?
-            if (!pmConfigMaskReadHeader (config, hdu->header)) {
+            if (!pmConfigMaskReadHeader(config, hdu->header)) {
                 psError(PS_ERR_IO, false, "error in mask bits");
                 return NULL;
             }
         }
+#endif
     }
     if (options->doShutter) {
-        if (!ppImageDefineFile (config, input->fpa, "PPIMAGE.SHUTTER", "SHUTTER", PM_FPA_FILE_IMAGE, PM_DETREND_TYPE_SHUTTER)) {
-            psError (PS_ERR_IO, false, "Can't find a shutter image source");
-            psFree (options);
+        if (!ppImageDefineFile(config, input->fpa, "PPIMAGE.SHUTTER", "SHUTTER",
+                               PM_FPA_FILE_IMAGE, PM_DETREND_TYPE_SHUTTER)) {
+            psError(PS_ERR_IO, false, "Can't find a shutter image source");
+            psFree(options);
             return NULL;
         }
@@ -105 +85 @@
 
     if (options->doFlat) {
-        if (!ppImageDefineFile (config, input->fpa, "PPIMAGE.FLAT", "FLAT", PM_FPA_FILE_IMAGE, PM_DETREND_TYPE_FLAT)) {
-            psError (PS_ERR_IO, false, "Can't find a flat image source");
-            psFree (options);
-            return NULL;
-        }
-    }
-
-    int nThreads = psMetadataLookupS32 (&status, config->arguments, "NTHREADS");
+        if (!ppImageDefineFile(config, input->fpa, "PPIMAGE.FLAT", "FLAT",
+                               PM_FPA_FILE_IMAGE, PM_DETREND_TYPE_FLAT)) {
+            psError(PS_ERR_IO, false, "Can't find a flat image source");
+            psFree(options);
+            return NULL;
+        }
+    }
+
+    int nThreads = psMetadataLookupS32(&status, config->arguments, "NTHREADS");
     if (nThreads > 0) {
-        int nScanRows = psMetadataLookupS32 (&status, recipe, "SCAN.ROWS");
-        pmDetrendSetThreadTasks (nScanRows);
+        int nScanRows = psMetadataLookupS32(&status, recipe, "SCAN.ROWS");
+        pmDetrendSetThreadTasks(nScanRows);
     }
 
@@ -166 +147 @@
 skip_fringe:
     if (options->doFringe) {
-        if (!ppImageDefineFile (config, input->fpa, "PPIMAGE.FRINGE", "FRINGE", PM_FPA_FILE_FRINGE, PM_DETREND_TYPE_FRINGE)) {
+        if (!ppImageDefineFile(config, input->fpa, "PPIMAGE.FRINGE", "FRINGE",
+                               PM_FPA_FILE_FRINGE, PM_DETREND_TYPE_FRINGE)) {
             psError (PS_ERR_IO, false, "Can't find a fringe image source");
             return NULL;
@@ -283 +265 @@
         // define associated psphot input/output files
         if (!psphotDefineFiles (config, psphotInput)) {
-            psError(PSPHOT_ERR_CONFIG, false, "Trouble defining the additional input/output files for psphot");
+            psError(PSPHOT_ERR_CONFIG, false,
+                    "Trouble defining the additional input/output files for psphot");
             return false;
         }
@@ -291 +274 @@
     if (options->doAstromChip || options->doAstromMosaic) {
         if (!options->doPhotom) {
-            psError (PSASTRO_ERR_CONFIG, false, "photometry mode is not selected; it is required for astrometry");
+            psError(PSASTRO_ERR_CONFIG, false,
+                    "Photometry mode is not selected; it is required for astrometry");
             return false;
         }
 
-        pmFPAfile *psphotOutput = psMetadataLookupPtr (&status, config->files, "PSPHOT.OUTPUT");
-        PS_ASSERT (psphotOutput, false);
-
-        pmFPAfile *psastroInput = pmFPAfileDefineInput (config, psphotOutput->fpa, NULL, "PSASTRO.INPUT");
-        PS_ASSERT (psastroInput, false);
+        pmFPAfile *psphotOutput = psMetadataLookupPtr(&status, config->files, "PSPHOT.OUTPUT");
+        PS_ASSERT(psphotOutput, false);
+
+        pmFPAfile *psastroInput = pmFPAfileDefineInput(config, psphotOutput->fpa, NULL, "PSASTRO.INPUT");
+        PS_ASSERT(psastroInput, false);
         psastroInput->mode = PM_FPA_MODE_REFERENCE;
 
         // define associated psphot input/output files
-        if (!psastroDefineFiles (config, psastroInput)) {
-            psError(PSPHOT_ERR_CONFIG, false, "Trouble defining the additional input/output files for psastro");
+        if (!psastroDefineFiles(config, psastroInput)) {
+            psError(PSPHOT_ERR_CONFIG, false,
+                    "Trouble defining the additional input/output files for psastro");
             return false;
         }
 
         // deactivate the psastro files, reactive when needed
-        pmFPAfileActivate (config->files, false, "PSASTRO.OUTPUT");
+        pmFPAfileActivate(config->files, false, "PSASTRO.OUTPUT");
     }
 
@@ -325 +310 @@
 
     // outImage is used as a carrier: input to chipImage -> require the data to remain at the CHIP level
-    outImage->freeLevel = PS_MIN (outImage->freeLevel, PM_FPA_LEVEL_CHIP);
+    outImage->freeLevel = PS_MIN(outImage->freeLevel, PM_FPA_LEVEL_CHIP);
     outImage->dataLevel = outImage->freeLevel;
-    outImage->fileLevel = PS_MIN (outImage->fileLevel, outImage->dataLevel);
+    outImage->fileLevel = PS_MIN(outImage->fileLevel, outImage->dataLevel);
 
     // outMask and outVariance must be freed at the same level as outImage (all freed by pmFPAFreeData)
@@ -342 +327 @@
 
     // the input data is the same as the outImage data : force the free levels to match
-    input->freeLevel = PS_MIN (outImage->freeLevel, input->freeLevel);
+    input->freeLevel = PS_MIN(outImage->freeLevel, input->freeLevel);
 
     // define the binned target files (which may just be carriers for some camera configurations)
-    pmFPAfile *bin1 = pmFPAfileDefineFromFPA (config, chipImage->fpa, options->xBin1, options->yBin1, "PPIMAGE.BIN1");
+    pmFPAfile *bin1 = pmFPAfileDefineFromFPA(config, chipImage->fpa, options->xBin1, options->yBin1,
+                                             "PPIMAGE.BIN1");
     if (!bin1) {
         psError(PS_ERR_IO, false, _("Unable to generate new file from PPIMAGE.BIN1"));
@@ -357 +343 @@
     }
 
-    pmFPAfile *bin2 = pmFPAfileDefineFromFPA (config, chipImage->fpa, options->xBin2, options->yBin2, "PPIMAGE.BIN2");
+    pmFPAfile *bin2 = pmFPAfileDefineFromFPA(config, chipImage->fpa, options->xBin2, options->yBin2,
+                                             "PPIMAGE.BIN2");
     if (!bin2) {
         psError(PS_ERR_IO, false, _("Unable to generate new file from PPIMAGE.BIN2"));
@@ -373 +360 @@
     bin2->freeLevel = PM_FPA_LEVEL_FPA;
 
-    pmFPAfile *jpg1 = pmFPAfileDefineOutput (config, byFPA1->fpa, "PPIMAGE.JPEG1");
+    pmFPAfile *jpg1 = pmFPAfileDefineOutput(config, byFPA1->fpa, "PPIMAGE.JPEG1");
     if (!jpg1) {
         psError(PS_ERR_IO, false, _("Unable to generate new file from PPIMAGE.JPEG1"));
@@ -384 +371 @@
         return NULL;
     }
-    pmFPAfile *jpg2 = pmFPAfileDefineOutput (config, byFPA2->fpa, "PPIMAGE.JPEG2");
+    pmFPAfile *jpg2 = pmFPAfileDefineOutput(config, byFPA2->fpa, "PPIMAGE.JPEG2");
     if (!jpg2) {
         psError(PS_ERR_IO, false, _("Unable to generate new file from PPIMAGE.JPEG2"));
@@ -404 +391 @@
     // Chip selection: turn on only the chips specified (pass status to suppress missing-key log msg)
     char *chipLine = psMetadataLookupStr(&status, config->arguments, "CHIP_SELECTIONS");
-    psArray *chips = psStringSplitArray (chipLine, ",", false);
+    psArray *chips = psStringSplitArray(chipLine, ",", false);
     if (chips->n > 0) {
         pmFPASelectChip (input->fpa, -1, true); // deselect all chips
@@ -454 +441 @@
     if (psTraceGetLevel("ppImage.config") > 0) {
         // Get a look inside all the files.
-        psMetadataIterator *filesIter = psMetadataIteratorAlloc(config->files, PS_LIST_HEAD, NULL); // Iterator
+        psMetadataIterator *filesIter = psMetadataIteratorAlloc(config->files, PS_LIST_HEAD, NULL);
         psMetadataItem *item;               // Item from iteration
         fprintf(stderr, "Files:\n");

branches/cnb_branches/cnb_branch_20090301/ppImage/src/ppImageReplaceBackground.c

@@ -101 +101 @@
         }
     }
-    psImageBinning *binning = psMetadataLookupPtr(&status, psphotRecipe, "PSPHOT.BACKGROUND.BINNING"); // Binning for model
+    psImageBinning *binning = psMetadataLookupPtr(&status, modelRO->analysis,
+                                                  "PSPHOT.BACKGROUND.BINNING"); // Binning for model
     if (!binning) {
         psError(PS_ERR_UNEXPECTED_NULL, true, "Unable to find background binning");

branches/cnb_branches/cnb_branch_20090301/ppImage/src/ppImageVersion.c

@@ -5 +5 @@
 #include "ppImage.h"
 
-static const char *cvsTag = "$Name: not supported by cvs2svn $";// CVS tag name
+#ifndef PPIMAGE_VERSION
+#error "PPIMAGE_VERSION is not set"
+#endif
+#ifndef PPIMAGE_BRANCH
+#error "PPIMAGE_BRANCH is not set"
+#endif
+#ifndef PPIMAGE_SOURCE
+#error "PPIMAGE_SOURCE is not set"
+#endif
+
+#define xstr(s) str(s)
+#define str(s) #s
 
 psString ppImageVersion(void)
 {
-    psString version = NULL;            // Version, to return
-    psStringAppend(&version, "%s-%s",PACKAGE_NAME,PACKAGE_VERSION);
-    return version;
+    char *value = NULL;
+    psStringAppend(&value, "%s@%s", xstr(PPIMAGE_BRANCH), xstr(PPIMAGE_VERSION));
+    return value;
+}
+
+psString ppImageSource(void)
+{
+    return psStringCopy (xstr(PPIMAGE_SOURCE));
 }
 
 psString ppImageVersionLong(void)
 {
-    psString version = ppImageVersion(); // Version, to return
-    psString tag = psStringStripCVS(cvsTag, "Name"); // CVS tag
-    psStringAppend(&version, " (cvs tag %s) %s, %s", tag, __DATE__, __TIME__);
-    psFree(tag);
+    psString version = ppImageVersion();  // Version, to return
+    psString source = ppImageSource(); // Source
+
+    psStringPrepend(&version, "ppImage ");
+    psStringAppend(&version, " from %s, built %s, %s", source, __DATE__, __TIME__);
+    psFree(source);
+
+#ifdef __OPTIMIZE__
+    psStringAppend(&version, " optimised");
+#else
+    psStringAppend(&version, " unoptimised");
+#endif
+
     return version;
+};
+
+bool ppImageVersionHeader(psMetadata *header)
+{
+    PS_ASSERT_METADATA_NON_NULL(header, false);
+
+    psTime *time = psTimeGetNow(PS_TIME_TAI); // The time now
+    psString timeString = psTimeToISO(time); // The time in an ISO string
+    psFree(time);
+    psString history = NULL;               // History string
+    psStringAppend(&history, "ppImage at %s", timeString);
+    psFree(timeString);
+    psMetadataAddStr(header, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, NULL, history);
+    psFree(history);
+
+    psLibVersionHeader(header);
+    psModulesVersionHeader(header);
+    psphotVersionHeader(header);
+    psastroVersionHeader(header);
+    ppStatsVersionHeader(header);
+
+    psString version = ppImageVersion(); // ppImage software version
+    psString source  = ppImageSource();  // ppImage software source
+
+    psStringPrepend(&version, "ppImage version: ");
+    psStringPrepend(&source, "ppImage source: ");
+
+    psMetadataAddStr(header, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, NULL, version);
+    psMetadataAddStr(header, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, NULL, source);
+
+    psFree(version);
+    psFree(source);
+
+    return true;
 }
 
 
-void ppImageVersionMetadata(psMetadata *metadata)
+void ppImageVersionPrint(void)
 {
-    PS_ASSERT_METADATA_NON_NULL(metadata,);
+    psTime *time = psTimeGetNow(PS_TIME_TAI); // The time now
+    psString timeString = psTimeToISO(time); // The time in an ISO string
+    psFree(time);
+    psLogMsg("ppImage", PS_LOG_INFO, "ppImage at %s", timeString);
+    psFree(timeString);
 
     psString pslib = psLibVersionLong();// psLib version
@@ -35 +98 @@
     psString ppImage = ppImageVersionLong(); // ppImage version
 
-    psTime *time = psTimeGetNow(PS_TIME_TAI); // The time now
-    psString timeString = psTimeToISO(time); // The time in an ISO string
-    psFree(time);
-    psString head = NULL;               // Head string
-    psStringAppend(&head, "ppImage processing at %s. Component information:", timeString);
-    psFree(timeString);
+    psLogMsg("ppImage", PS_LOG_INFO, "%s", pslib);
+    psLogMsg("ppImage", PS_LOG_INFO, "%s", psmodules);
+    psLogMsg("ppImage", PS_LOG_INFO, "%s", psphot);
+    psLogMsg("ppImage", PS_LOG_INFO, "%s", psastro);
+    psLogMsg("ppImage", PS_LOG_INFO, "%s", ppStats);
+    psLogMsg("ppImage", PS_LOG_INFO, "%s", ppImage);
 
-    psMetadataAddStr(metadata, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, head, "");
-    psMetadataAddStr(metadata, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, pslib, "");
-    psMetadataAddStr(metadata, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, psmodules, "");
-    psMetadataAddStr(metadata, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, psphot, "");
-    psMetadataAddStr(metadata, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, psastro, "");
-    psMetadataAddStr(metadata, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, ppStats, "");
-    psMetadataAddStr(metadata, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, ppImage, "");
-
-    psFree(head);
     psFree(pslib);
     psFree(psmodules);