IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Feb 4, 2010, 6:38:31 PM (16 years ago)
Author:
eugene
Message:

updates from the main eam_branch/20091201

Location:
branches/eam_branches/psModules.stack.20100120
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/psModules.stack.20100120

  • branches/eam_branches/psModules.stack.20100120/src/camera/pmFPAMaskWeight.c

    r26747 r26771  
    454454    // Check valid range of correction factor
    455455    if ((isfinite(minValid) && correction < minValid) || (isfinite(maxValid) && correction > maxValid)) {
    456         psWarning("Variance renormalisation is outside valid range: %f vs %f:%f --- no correction made",
    457                   correction, minValid, maxValid);
    458         return true;
     456        psError(PS_ERR_UNKNOWN, true, "Variance renormalisation is outside valid range: %f vs %f:%f --- no correction made", correction, minValid, maxValid);
     457        psMetadataAddF32(readout->analysis, PS_LIST_TAIL, PM_READOUT_ANALYSIS_RENORM, 0, "Renormalisation of variance", PS_SQR(correction));
     458        return false;
    459459    }
    460460

  • branches/eam_branches/psModules.stack.20100120/src/imcombine/pmStackReject.c

    r26747 r26771  
    3535{
    3636    int size = kernels->size;           // Half-size of convolution kernel
    37     psImage *polyValues = p_pmSubtractionPolynomialFromCoords(NULL, kernels, xMin + size + 1,
    38                                                               yMin + size + 1); // Polynomial
     37    int x = PS_MIN(xMin + size + 1, kernels->xMax); // x coordinate of interest
     38    int y = PS_MIN(yMin + size + 1, kernels->yMax); // y coordinate of interest
     39
     40    psImage *polyValues = p_pmSubtractionPolynomialFromCoords(NULL, kernels, x, y); // Polynomial
    3941    int box = p_pmSubtractionBadRadius(NULL, kernels, polyValues, false, poorFrac); // Radius of bad box
    4042    psTrace("psModules.imcombine", 10, "Growing by %d", box);
    … …  
    154156        psRegion *region = subRegions->data[i]; // Region of interest
    155157        pmSubtractionKernels *kernels = subKernels->data[i]; // Kernel of interest
    156         if (!pmSubtractionConvolve(NULL, convRO, NULL, inRO, NULL, stride, 0, 0, 1.0, 0.0,
     158        if (!pmSubtractionConvolve(NULL, convRO, NULL, inRO, NULL, stride, 0, 0, 1.0, 0.0, 0.0,
    157159                                   region, kernels, false, true)) {
    158160            psError(PS_ERR_UNKNOWN, false, "Unable to convolve mask image in region %d.", i);
    … …  
    166168
    167169        // Image of the kernel at the centre of the region
    168         float xNorm, yNorm;             // Normalised coordinates
    169         p_pmSubtractionPolynomialNormCoords(&xNorm, &yNorm, 0.5 * (region->x1 - region->x0),
    170                                             0.5 * (region->y1 - region->y0),
    171                                             kernels->xMin, kernels->xMax, kernels->yMin, kernels->yMax);
    172         psImage *kernel = pmSubtractionKernelImage(kernels, xNorm, yNorm, false);
     170        psImage *kernel = pmSubtractionKernelImage(kernels, 0.5, 0.5, false);
    173171        if (!kernel) {
    174172            psError(PS_ERR_UNKNOWN, false, "Unable to generate kernel image.");

  • branches/eam_branches/psModules.stack.20100120/src/imcombine/pmSubtraction.c

    r26747 r26771  
    423423                    *target |= maskBad;
    424424                } else if (*source & subConvPoor) {
     425                    *target &= ~maskBad;
    425426                    *target |= maskPoor;
    426427                } else {
    … …  
    11521153bool pmSubtractionConvolve(pmReadout *out1, pmReadout *out2, const pmReadout *ro1, const pmReadout *ro2,
    11531154                           psImage *subMask, int stride, psImageMaskType maskBad, psImageMaskType maskPoor,
    1154                            float poorFrac, float kernelError, const psRegion *region,
     1155                           float poorFrac, float kernelError, float covarFrac, const psRegion *region,
    11551156                           const pmSubtractionKernels *kernels, bool doBG, bool useFFT)
    11561157{
    … …  
    11941195    PS_ASSERT_FLOAT_LARGER_THAN_OR_EQUAL(kernelError, 0.0, false);
    11951196    PS_ASSERT_FLOAT_LESS_THAN_OR_EQUAL(kernelError, 1.0, false);
     1197    PS_ASSERT_FLOAT_LARGER_THAN_OR_EQUAL(covarFrac, 0.0, false);
     1198    PS_ASSERT_FLOAT_LESS_THAN(covarFrac, 1.0, false);
    11961199    if (region && psRegionIsNaN(*region)) {
    11971200        psString string = psRegionToString(*region);
    … …  
    13261329    if (kernels->mode == PM_SUBTRACTION_MODE_1 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
    13271330        psKernel *kernel = pmSubtractionKernel(kernels, 0.0, 0.0, false); // Convolution kernel
     1331        psKernelTruncate(kernel, covarFrac);
    13281332        out1->covariance = psImageCovarianceCalculate(kernel, ro1->covariance);
    13291333        psFree(kernel);
    … …  
    13321336        psKernel *kernel = pmSubtractionKernel(kernels, 0.0, 0.0,
    13331337                                               kernels->mode == PM_SUBTRACTION_MODE_DUAL); // Conv. kernel
     1338        psKernelTruncate(kernel, covarFrac);
    13341339        out2->covariance = psImageCovarianceCalculate(kernel, ro2->covariance);
    13351340        psFree(kernel);

  • branches/eam_branches/psModules.stack.20100120/src/imcombine/pmSubtraction.h

    r26747 r26771  
    113113                           psImageMaskType maskPoor, ///< Mask value to give poor pixels
    114114                           float poorFrac, ///< Fraction for "poor"
    115                            float sysError, ///< Relative systematic error
     115                           float kernelError, ///< Relative systematic error in kernel
     116                           float covarFrac,  ///< Truncation fraction for kernel before covariance calculation
    116117                           const psRegion *region, ///< Region to convolve (or NULL)
    117118                           const pmSubtractionKernels *kernels, ///< Kernel parameters

  • branches/eam_branches/psModules.stack.20100120/src/imcombine/pmSubtractionMatch.c

    r26747 r26771  
    121121                                  float skyError,           // Systematic error in images
    122122                                  float kernelError, // Systematic error in kernel
     123                                  float covarFrac,   // Fraction for kernel truncation before covariance
    123124                                  psImageMaskType maskVal, // Value to mask for input
    124125                                  psImageMaskType maskBad, // Mask for output bad pixels
    … …  
    181182        PS_ASSERT_FLOAT_LESS_THAN(kernelError, 1.0, false);
    182183    }
     184    PS_ASSERT_FLOAT_LARGER_THAN_OR_EQUAL(covarFrac, 0.0, false);
     185    PS_ASSERT_FLOAT_LESS_THAN(covarFrac, 1.0, false);
    183186    // Don't care about maskVal
    184187    // Don't care about maskBad
    … …  
    246249
    247250bool pmSubtractionMatchPrecalc(pmReadout *conv1, pmReadout *conv2, const pmReadout *ro1, const pmReadout *ro2,
    248                                psMetadata *analysis, int stride, float kernelError,
     251                               psMetadata *analysis, int stride, float kernelError, float covarFrac,
    249252                               psImageMaskType maskVal, psImageMaskType maskBad, psImageMaskType maskPoor,
    250253                               float poorFrac, float badFrac)
    … …  
    316319    }
    317320
    318     if (!subtractionMatchCheck(conv1, conv2, ro1, ro2, stride, NAN, NAN, NAN, kernelError,
     321    if (!subtractionMatchCheck(conv1, conv2, ro1, ro2, stride, NAN, NAN, NAN, kernelError, covarFrac,
    319322                               maskVal, maskBad, maskPoor, poorFrac, badFrac, mode)) {
    320323        psFree(kernels);
    … …  
    357360
    358361        if (!pmSubtractionConvolve(conv1, conv2, ro1, ro2, subMask, stride, maskBad, maskPoor, poorFrac,
    359                                    kernelError, region, kernel, true, useFFT)) {
     362                                   kernelError, covarFrac, region, kernel, true, useFFT)) {
    360363            psError(PS_ERR_UNKNOWN, false, "Unable to convolve image.");
    361364            psFree(outAnalysis);
    … …  
    388391                        bool optimum, const psVector *optFWHMs, int optOrder, float optThreshold,
    389392                        int iter, float rej, float normFrac, float sysError, float skyError,
    390                         float kernelError, psImageMaskType maskVal, psImageMaskType maskBad,
     393                        float kernelError, float covarFrac, psImageMaskType maskVal, psImageMaskType maskBad,
    391394                        psImageMaskType maskPoor, float poorFrac, float badFrac, pmSubtractionMode subMode)
    392395{
    393396    if (!subtractionMatchCheck(conv1, conv2, ro1, ro2, stride, normFrac, sysError, skyError, kernelError,
    394                                maskVal, maskBad, maskPoor, poorFrac, badFrac, subMode)) {
     397                               covarFrac, maskVal, maskBad, maskPoor, poorFrac, badFrac, subMode)) {
    395398        return false;
    396399    }
    … …  
    779782            psTrace("psModules.imcombine", 2, "Convolving...\n");
    780783            if (!pmSubtractionConvolve(conv1, conv2, ro1, ro2, subMask, stride, maskBad, maskPoor, poorFrac,
    781                                        kernelError, region, kernels, true, useFFT)) {
     784                                       kernelError, covarFrac, region, kernels, true, useFFT)) {
    782785                psError(PS_ERR_UNKNOWN, false, "Unable to convolve image.");
    783786                goto MATCH_ERROR;

  • branches/eam_branches/psModules.stack.20100120/src/imcombine/pmSubtractionMatch.h

    r26747 r26771  
    4343                        float skyError, ///< Relative systematic error in images
    4444                        float kernelError, ///< Relative systematic error in kernel
     45                        float covarFrac,   ///< Fraction for kernel truncation before covariance calculation
    4546                        psImageMaskType maskVal, ///< Value to mask for input
    4647                        psImageMaskType maskBad, ///< Mask for output bad pixels
    … …  
    5960                               int stride, ///< Size for convolution patches
    6061                               float kernelError, ///< Relative systematic error in kernel
     62                               float covarFrac,   ///< Fraction for kernel truncation before covariance calc.
    6163                               psImageMaskType maskVal, ///< Value to mask for input
    6264                               psImageMaskType maskBad, ///< Mask for output bad pixels
Note: See TracChangeset for help on using the changeset viewer.