IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 19532


Ignore:
Timestamp:
Sep 11, 2008, 6:12:42 PM (18 years ago)
Author:
Paul Price
Message:

Correcting stack variances for the imperfect convolution. Changed (again) the way the deviations are calculated; they're now straight chi2, which allows us to estimate how the variance factor needs to be changed in order to correct for it. Moving additional values into pmSubtractionKernels so that this can be calculated from a kernel that has been read in (very useful for debugging, also nice to have a record of the quality of the fit).

Location:
trunk
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/ppStack/src/ppStack.h

    r19346 r19532  
    8989                               const psArray *readouts, // Input readouts
    9090                               const psArray *regions, // Array with array of regions used in each PSF match
    91                                const psArray *kernels // Array with array of kernels used in each PSF match
     91                               const psArray *kernels, // Array with array of kernels used in each PSF match
     92                               const psVector *addVariance // Additional variance for rejection
    9293    );
    9394
    … …  
    128129
    129130/// Convolve image to match specified seeing
    130 bool ppStackMatch(pmReadout *readout, // Readout to be convolved; replaced with output
    131                   psArray **regions, // Array of regions used in each PSF matching, returned
    132                   psArray **kernels, // Array of kernels used in each PSF matching, returned
     131bool ppStackMatch(pmReadout *readout,   // Readout to be convolved; replaced with output
     132                  psArray **regions,    // Array of regions used in each PSF matching, returned
     133                  psArray **kernels,    // Array of kernels used in each PSF matching, returned
     134                  float *chi2,          // Chi^2 from the stamps
    133135                  const psArray *sources, // Array of sources
    134136                  const pmPSF *psf,     // Target PSF

  • trunk/ppStack/src/ppStackLoop.c

    r19505 r19532  
    390390    psVector *inputMask = psVectorAlloc(num, PS_TYPE_U8); // Mask for inputs
    391391    psVectorInit(inputMask, 0);
     392    psVector *matchChi2 = psVectorAlloc(num, PS_TYPE_F32); // chi^2 for stamps when matching
     393    psVectorInit(matchChi2, NAN);
    392394    for (int i = 0; i < num; i++) {
    393395        psTrace("ppStack", 2, "Convolving input %d of %d to target PSF....\n", i, num);
    … …  
    402404            psFree(rng);
    403405            psFree(inputMask);
     406            psFree(matchChi2);
    404407            return false;
    405408        }
    … …  
    419422            psFree(rng);
    420423            psFree(inputMask);
     424            psFree(matchChi2);
    421425            return false;
    422426        }
    … …  
    425429        psArray *regions = NULL, *kernels = NULL; // Regions and kernels used in subtraction
    426430        psArray *sources = haveSources ? globalSources : indSources->data[i]; // Sources for matching
    427         if (!ppStackMatch(readout, &regions, &kernels, sources, targetPSF, rng, config)) {
     431        if (!ppStackMatch(readout, &regions, &kernels, &matchChi2->data.F32[i],
     432                          sources, targetPSF, rng, config)) {
    428433            psErrorStackPrint(stderr, "Unable to match image %d --- ignoring.", i);
    429434            inputMask->data.U8[i] = PPSTACK_MASK_MATCH;
    … …  
    459464        psFree(cells);
    460465        psFree(inputMask);
     466        psFree(inputMask);
     467        psFree(matchChi2);
    461468        return false;
    462469    }
    … …  
    473480    memDump("preinitial");
    474481
    475     // Stack the convolvd files
     482    // Stack the convolved files
    476483    psTrace("ppStack", 1, "Initial stack of convolved images....\n");
    477484    pmReadout *outRO = NULL;            // Output readout
    … …  
    489496            psFree(stack);
    490497            psFree(inputMask);
     498            psFree(matchChi2);
    491499            psFree(exptimes);
    492500            psFree(cells);
    … …  
    502510            psFree(stack);
    503511            psFree(inputMask);
     512            psFree(matchChi2);
    504513            psFree(exptimes);
    505514            psFree(cells);
    … …  
    518527            psFree(stack);
    519528            psFree(inputMask);
     529            psFree(matchChi2);
    520530            psFree(view);
    521531            psFree(outRO);
    … …  
    546556        psFree(cellList);
    547557
    548     psFree(cells);
     558        psFree(cells);
    549559
    550560        bool status;                    // Status of read
    … …  
    559569                psFree(stack);
    560570                psFree(inputMask);
     571                psFree(matchChi2);
    561572                psFree(view);
    562573                psFree(outRO);
    … …  
    576587            psArrayAdd(job->args, 1, subRegions);
    577588            psArrayAdd(job->args, 1, subKernels);
     589            psArrayAdd(job->args, 1, matchChi2);
    578590            if (!psThreadJobAddPending(job)) {
    579591                psFree(job);
    … …  
    582594                psFree(stack);
    583595                psFree(inputMask);
     596                psFree(matchChi2);
    584597                psFree(view);
    585598                psFree(outRO);
    … …  
    596609            psFree(stack);
    597610            psFree(inputMask);
     611            psFree(matchChi2);
    598612            psFree(view);
    599613            psFree(outRO);
    … …  
    601615            return false;
    602616        }
     617        psFree(matchChi2);
    603618
    604619        // Harvest the jobs, gathering the inspection lists

  • trunk/ppStack/src/ppStackMatch.c

    r19486 r19532  
    1515                     PM_SOURCE_MODE_CR_LIMIT) // Mask to apply to input sources
    1616
    17 //#define TESTING                         // Enable debugging output
     17#define TESTING                         // Enable debugging output
    1818
    1919
    … …  
    4848#endif
    4949
    50 bool ppStackMatch(pmReadout *readout, psArray **regions, psArray **kernels,
     50bool ppStackMatch(pmReadout *readout, psArray **regions, psArray **kernels, float *chi2,
    5151                  const psArray *sources, const pmPSF *psf, psRandom *rng, const pmConfig *config)
    5252{
    … …  
    111111                                                                PM_SUBTRACTION_ANALYSIS_KERNEL); // Kernels
    112112            float vf = pmSubtractionVarianceFactor(kernels, 0.0, 0.0, false); // Variance factor
    113             psMetadataItem *vfItem = psMetadataLookup(output->parent->concepts, "CELL.VARFACTOR");
     113            psMetadataItem *vfItem = psMetadataLookup(readout->parent->concepts, "CELL.VARFACTOR");
    114114            if (!isfinite(vf)) {
    115115                vf = 1.0;
    … …  
    341341    assert((*regions)->n == (*kernels)->n);
    342342
     343    // Correct the variance for the chi^2
     344    {
     345        *chi2 = 0.0;
     346        int num = 0;                    // Number of measurements of chi^2
     347        psString regex = NULL;          // Regular expression
     348        psStringAppend(&regex, "^%s$", PM_SUBTRACTION_ANALYSIS_KERNEL);
     349        psMetadataIterator *iter = psMetadataIteratorAlloc(output->analysis, PS_LIST_HEAD, regex); // Iterator
     350        psFree(regex);
     351        psMetadataItem *item = NULL;// Item from iteration
     352        while ((item = psMetadataGetAndIncrement(iter))) {
     353            assert(item->type == PS_DATA_UNKNOWN);
     354            pmSubtractionKernels *kernels = item->data.V; // Convolution kernels
     355            *chi2 += kernels->mean;
     356            num++;
     357        }
     358        psFree(iter);
     359
     360        float vf = psMetadataLookupF32(NULL, readout->parent->concepts, "CELL.VARFACTOR"); // Variance factor
     361        *chi2 /= vf * num;
     362    }
     363
    343364    // Renormalise the variances if desired
    344365    if (renorm) {

  • trunk/ppStack/src/ppStackReadout.c

    r19475 r19532  
    2222    psArray *subRegions = args->data[3]; // Regions for PSF-matching
    2323    psArray *subKernels = args->data[4]; // Kernels for PSF-matching
    24 
    25     psArray *inspect = ppStackReadoutInitial(config, outRO, thread->readouts, subRegions, subKernels);
     24    psVector *addVariance = args->data[5]; // Additional variance when rejecting
     25
     26    psArray *inspect = ppStackReadoutInitial(config, outRO, thread->readouts,
     27                                             subRegions, subKernels, addVariance);
    2628
    2729    job->results = inspect;
    … …  
    7577
    7678psArray *ppStackReadoutInitial(const pmConfig *config, pmReadout *outRO, const psArray *readouts,
    77                                const psArray *regions, const psArray *kernels)
     79                               const psArray *regions, const psArray *kernels, const psVector *addVariance)
    7880{
    7981    assert(config);
    … …  
    8486    assert(readouts->n == regions->n);
    8587    assert(regions->n == kernels->n);
     88    assert(addVariance && addVariance->n == readouts->n && addVariance->type.type == PS_TYPE_F32);
    8689    static int sectionNum = 0;          // Section number; for debugging outputs
    8790
    … …  
    127130        }
    128131
    129         stack->data[i] = pmStackDataAlloc(ro, weighting);
     132        stack->data[i] = pmStackDataAlloc(ro, weighting, addVariance->data.F32[i]);
    130133    }
    131134
    … …  
    221224        }
    222225
    223         pmStackData *data = pmStackDataAlloc(ro, weighting);
     226        pmStackData *data = pmStackDataAlloc(ro, weighting, NAN);
    224227        data->reject = psMemIncrRefCounter(rejected->data[i]);
    225228        stack->data[i] = data;

  • trunk/ppStack/src/ppStackThread.c

    r19346 r19532  
    235235
    236236    {
    237         psThreadTask *task = psThreadTaskAlloc("PPSTACK_INITIAL_COMBINE", 5);
     237        psThreadTask *task = psThreadTaskAlloc("PPSTACK_INITIAL_COMBINE", 6);
    238238        task->function = &ppStackReadoutInitialThread;
    239239        psThreadTaskAdd(task);

  • trunk/psModules/src/imcombine/pmStack.c

    r19487 r19532  
    88 *  @author GLG, MHPCC
    99 *
    10  *  @version $Revision: 1.40 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2008-09-11 20:52:16 $
     10 *  @version $Revision: 1.41 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2008-09-12 04:12:42 $
    1212 *  Copyright 2004-2007 Institute for Astronomy, University of Hawaii
    1313 *
    … …  
    3030#define PIXEL_LIST_BUFFER 100           // Number of entries to add to pixel list at a time
    3131#define PIXEL_MAP_BUFFER 2              // Number of entries to add to pixel map at a time
    32 //#define VARIANCE_FACTORS                // Use variance factors when calculating the variances?
     32#define VARIANCE_FACTORS                // Use variance factors when calculating the variances?
    3333#define NUM_DIRECT_STDEV 5              // For less than this number of values, measure stdev directly
    3434
    … …  
    312312              // Use variance to check that the two are consistent
    313313              float diff = pixelData->data.F32[0] - pixelData->data.F32[1];
    314 #if VARIANCE_FACTORS
     314#ifdef VARIANCE_FACTORS
    315315              float sigma2 = pixelVariances->data.F32[0] * varFactors->data.F32[pixelSources->data.U16[0]] +
    316316                  pixelVariances->data.F32[1] * varFactors->data.F32[pixelSources->data.U16[1]];
    … …  
    346346                  float rej2 = PS_SQR(rej); // Rejection level squared
    347347                  for (int i = 0; i < num; i++) {
    348 #if VARIANCE_FACTORS
     348#ifdef VARIANCE_FACTORS
    349349                      pixelVariances->data.F32[i] *= rej2 * varFactors->data.F32[pixelSources->data.U16[i]];
    350350#else
    … …  
    538538
    539539/// Constructor
    540 pmStackData *pmStackDataAlloc(pmReadout *readout, float weight)
     540pmStackData *pmStackDataAlloc(pmReadout *readout, float weight, float addVariance)
    541541{
    542542    pmStackData *data = psAlloc(sizeof(pmStackData)); // Stack data, to return
    … …  
    547547    data->inspect = NULL;
    548548    data->weight = weight;
     549    data->addVariance = addVariance;
    549550
    550551    return data;
    … …  
    602603        }
    603604        varFactors->data.F32[i] = vf;
     605        if (isfinite(data->addVariance)) {
     606            varFactors->data.F32[i] *= data->addVariance;
     607        }
    604608        if (!haveRejects && !data->inspect) {
    605609            data->inspect = psPixelsAllocEmpty(PIXEL_LIST_BUFFER);

  • trunk/psModules/src/imcombine/pmStack.h

    r17005 r19532  
    88 * @author GLG, MHPCC
    99 *
    10  * @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
    11  * @date $Date: 2008-03-17 21:38:43 $
     10 * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
     11 * @date $Date: 2008-09-12 04:12:42 $
    1212 *
    1313 * Copyright 2004-2007 Institute for Astronomy, University of Hawaii
    … …  
    3131    psPixels *inspect;                  ///< Pixels to inspect
    3232    float weight;                       ///< Relative weighting for image
     33    float addVariance;                  ///< Additional variance when rejecting
    3334} pmStackData;
    3435
    3536/// Constructor
    3637pmStackData *pmStackDataAlloc(pmReadout *readout, ///< Warped readout (sky cell)
    37                               float weight ///< Weight to apply
     38                              float weight, ///< Weight to apply
     39                              float addVariance ///< Additional variance when rejecting
    3840    );
    3941

  • trunk/psModules/src/imcombine/pmSubtraction.c

    r19482 r19532  
    665665
    666666
    667 int pmSubtractionRejectStamps(float *rmsPtr, int *numPtr, pmSubtractionStampList *stamps,
    668                               const psVector *deviations, psImage *subMask, float sigmaRej,
    669                               int footprint)
    670 {
     667int pmSubtractionRejectStamps(pmSubtractionKernels *kernels, pmSubtractionStampList *stamps,
     668                              const psVector *deviations, psImage *subMask, float sigmaRej, int footprint)
     669{
     670    PM_ASSERT_SUBTRACTION_KERNELS_NON_NULL(kernels, false);
    671671    PM_ASSERT_SUBTRACTION_STAMP_LIST_NON_NULL(stamps, -1);
    672672    PS_ASSERT_VECTOR_NON_NULL(deviations, -1);
    … …  
    678678    // the distribution is actually something like a chi^2 or Student's t, both of which become Gaussian-like
    679679    // with large N.  Therefore, let's just treat this as a Gaussian distribution.
     680
     681    kernels->mean = NAN;
     682    kernels->rms = NAN;
     683    kernels->numStamps = -1;
    680684
    681685    int numStamps = 0;                  // Number of used stamps
    … …  
    721725    psTrace("psModules.imcombine", 1, "RMS deviation: %f\n", rms);
    722726
    723     if (rmsPtr) {
    724         *rmsPtr = rms;
    725     }
    726     if (numPtr) {
    727         *numPtr = numStamps;
    728     }
    729 
    730     psLogMsg("psModules.imcombine", PS_LOG_INFO, "RMS deviation from %d stamps: %lf", numStamps, rms);
     727    kernels->mean = mean;
     728    kernels->rms = rms;
     729    kernels->numStamps = numStamps;
     730
     731    psLogMsg("psModules.imcombine", PS_LOG_INFO, "Mean deviation from %d stamps: %lf +/- %lf",
     732             numStamps, mean, rms);
    731733
    732734    if (!isfinite(sigmaRej) || sigmaRej <= 0.0) {
    733         // User just wanted to calculate and record the RMS for posterity
     735        // User just wanted to calculate and record the deviation for posterity
    734736        return 0;
    735737    }

  • trunk/psModules/src/imcombine/pmSubtraction.h

    r19299 r19532  
    66 * @author GLG, MHPCC
    77 *
    8  * @version $Revision: 1.31 $ $Name: not supported by cvs2svn $
    9  * @date $Date: 2008-08-30 02:28:07 $
     8 * @version $Revision: 1.32 $ $Name: not supported by cvs2svn $
     9 * @date $Date: 2008-09-12 04:12:42 $
    1010 * Copyright 2004-207 Institute for Astronomy, University of Hawaii
    1111 */
    … …  
    6464
    6565/// Reject stamps
    66 int pmSubtractionRejectStamps(float *rms, ///< RMS deviation, to return
    67                               int *num, ///< Number of good stamps, to return
     66int pmSubtractionRejectStamps(pmSubtractionKernels *kernels, ///< Kernel parameters to update
    6867                              pmSubtractionStampList *stamps, ///< Stamps
    6968                              const psVector *deviations, ///< Deviations for each stamp

  • trunk/psModules/src/imcombine/pmSubtractionEquation.c

    r19299 r19532  
    10851085            }
    10861086        }
    1087         deviations->data.F32[i] = sqrtf(devNorm * deviation);
     1087        deviations->data.F32[i] = devNorm * deviation;
    10881088        psTrace("psModules.imcombine", 5, "Deviation for stamp %d (%d,%d): %f\n",
    10891089                i, (int)(stamp->x + 0.5), (int)(stamp->y + 0.5), deviations->data.F32[i]);

  • trunk/psModules/src/imcombine/pmSubtractionIO.c

    r19230 r19532  
    3232#define NAME_SOL1 "SOLUTION_1"          // Solution for convolving image 1
    3333#define NAME_SOL2 "SOLUTION_2"          // Solution for convolving image 2
     34#define NAME_MEAN "MEAN"                // Mean of chi^2 from stamps
     35#define NAME_RMS  "RMS"                 // RMS of chi^2 from stamps
     36#define NAME_NUMSTAMPS "NUMSTAMPS"      // Number of good stamps
    3437
    3538#define FALLBACK_EXTNAME "SUBTRACTION_KERNEL" // Fallback extension name
    … …  
    159162            psMetadataAddVector(row, PS_LIST_TAIL, NAME_SOL2, 0, "Solution vector 2", kernel->solution2);
    160163        }
     164        psMetadataAddF32(row, PS_LIST_TAIL, NAME_MEAN,  0, "Mean of chi^2 from stamps", kernel->mean);
     165        psMetadataAddF32(row, PS_LIST_TAIL, NAME_RMS,  0, "RMS of chi^2 from stamps", kernel->rms);
     166        psMetadataAddF32(row, PS_LIST_TAIL, NAME_NUMSTAMPS,  0, "Number of good stamps", kernel->numStamps);
    161167    }
    162168    psFree(regions);
    … …  
    167173    // CVS tags, used to identify the version of this file (in case incompatibilities are introduced)
    168174    psString cvsFile = psStringCopy("$RCSfile: pmSubtractionIO.c,v $");
    169     psString cvsRev  = psStringCopy("$Revision: 1.3 $");
    170     psString cvsDate = psStringCopy("$Date: 2008-08-27 02:54:44 $");
     175    psString cvsRev  = psStringCopy("$Revision: 1.4 $");
     176    psString cvsDate = psStringCopy("$Date: 2008-09-12 04:12:42 $");
    171177    psStringSubstitute(&cvsFile, NULL, "RCSfile: ");
    172178    psStringSubstitute(&cvsRev,  NULL, "Revision: ");
    … …  
    338344        TABLE_LOOKUP(int, S32, numRows, NAME_ROWS);
    339345
     346        TABLE_LOOKUP(float, F32, mean,      NAME_MEAN);
     347        TABLE_LOOKUP(float, F32, rms,       NAME_RMS);
     348        TABLE_LOOKUP(int,   S32, numStamps, NAME_NUMSTAMPS);
     349
    340350        pmSubtractionKernels *kernels = pmSubtractionKernelsFromDescription(description, bg, mode);
    341351        kernels->numCols = numCols;
    342352        kernels->numRows = numRows;
     353        kernels->mean = mean;
     354        kernels->rms = rms;
     355        kernels->numStamps = numStamps;
    343356
    344357        bool mdok;                      // Status of MD lookup

  • trunk/psModules/src/imcombine/pmSubtractionKernels.h

    r18287 r19532  
    4242    int numCols, numRows;               ///< Size of image (for normalisation), or zero to use image provided
    4343    psVector *solution1, *solution2;    ///< Solution for the PSF matching
     44    // Quality information
     45    float mean, rms;                    ///< Mean and RMS of chi^2 from stamps
     46    int numStamps;                      ///< Number of good stamps
    4447} pmSubtractionKernels;
    4548

  • trunk/psModules/src/imcombine/pmSubtractionMatch.c

    r19482 r19532  
    370370            memCheck("kernels");
    371371
    372             float rmsStamps = NAN;      // RMS for stamps
    373             int numStamps = 0;          // Number of good stamps
    374372            int numRejected = -1;       // Number of rejected stamps in each iteration
    375373            for (int k = 0; k < iter && numRejected != 0; k++) {
    … …  
    407405
    408406                psTrace("psModules.imcombine", 3, "Rejecting stamps...\n");
    409                 numRejected = pmSubtractionRejectStamps(&rmsStamps, &numStamps, stamps, deviations,
    410                                                         subMask, rej, footprint);
     407                numRejected = pmSubtractionRejectStamps(kernels, stamps, deviations, subMask, rej, footprint);
    411408                if (numRejected < 0) {
    412409                    psError(PS_ERR_UNKNOWN, false, "Unable to reject stamps.");
    … …  
    430427                    goto MATCH_ERROR;
    431428                }
    432                 pmSubtractionRejectStamps(&rmsStamps, &numStamps, stamps, deviations,
    433                                           subMask, NAN, footprint);
     429                pmSubtractionRejectStamps(kernels, stamps, deviations, subMask, NAN, footprint);
    434430                psFree(deviations);
    435431            }
    436432            psFree(stamps);
    437433            stamps = NULL;
    438 
    439             if (subMode == PM_SUBTRACTION_MODE_1 || subMode == PM_SUBTRACTION_MODE_DUAL) {
    440                 psMetadataAddS32(conv1->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_STAMPS_NUM,
    441                                  PS_META_DUPLICATE_OK, "Number of good stamps", numStamps);
    442                 psMetadataAddF32(conv1->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_STAMPS_RMS,
    443                                  PS_META_DUPLICATE_OK, "RMS deviation of stamps", rmsStamps);
    444             }
    445             if (subMode == PM_SUBTRACTION_MODE_2 || subMode == PM_SUBTRACTION_MODE_DUAL) {
    446                 psMetadataAddS32(conv2->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_STAMPS_NUM,
    447                                  PS_META_DUPLICATE_OK, "Number of good stamps", numStamps);
    448                 psMetadataAddF32(conv2->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_STAMPS_RMS,
    449                                  PS_META_DUPLICATE_OK, "RMS deviation of stamps", rmsStamps);
    450             }
    451434
    452435            memCheck("solution");

  • trunk/psModules/src/imcombine/pmSubtractionMatch.h

    r19299 r19532  
    99#include <pmSubtractionStamps.h>
    1010
    11 #define PM_SUBTRACTION_ANALYSIS_KERNEL "SUBTRACTION.KERNEL" // Name of kernel in the analysis metadata
    12 #define PM_SUBTRACTION_ANALYSIS_MODE "SUBTRACTION.MODE" // Name of subtraction mode in the analysis metadata
    13 #define PM_SUBTRACTION_ANALYSIS_REGION "SUBTRACTION.REGION" // Name of subtraction region in the analysis MD
    14 #define PM_SUBTRACTION_ANALYSIS_STAMPS_RMS "SUBTRACTION.RMS" // Name of stamp rms in the analysis metadata
    15 #define PM_SUBTRACTION_ANALYSIS_STAMPS_NUM "SUBTRACTION.NUM"// Name of the number of stamps in the analysis MD
    16 #define PM_SUBTRACTION_ANALYSIS_VARFACTOR "SUBTRACTION.VARFACTOR"// Name of variance factor in the analysis MD
     11// Names for things put on the readout analysis metadata
     12#define PM_SUBTRACTION_ANALYSIS_KERNEL "SUBTRACTION.KERNEL" // Kernel used for convolving
     13#define PM_SUBTRACTION_ANALYSIS_MODE "SUBTRACTION.MODE" // Subtraction mode
     14#define PM_SUBTRACTION_ANALYSIS_REGION "SUBTRACTION.REGION" // Subtraction region
     15#define PM_SUBTRACTION_ANALYSIS_STAMPS_MEAN "SUBTRACTION.MEAN" // Stamp mean deviation
     16#define PM_SUBTRACTION_ANALYSIS_STAMPS_RMS "SUBTRACTION.RMS" // Stamp RMS deviation
     17#define PM_SUBTRACTION_ANALYSIS_STAMPS_NUM "SUBTRACTION.NUM" // Number of stamps
     18#define PM_SUBTRACTION_ANALYSIS_VARFACTOR "SUBTRACTION.VARFACTOR"// Variance factor
    1719
    1820
Note: See TracChangeset for help on using the changeset viewer.