IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 26769


Ignore:
Timestamp:
Feb 4, 2010, 3:18:46 PM (16 years ago)
Author:
Paul Price
Message:

Using psKernelTruncate to reduce size of the kernel before calculating the covariance matrix.

Location:
branches/eam_branches/20091201
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/20091201/ippconfig/recipes/ppSub.config

    r26763 r26769  
    22
    33KERNEL.TYPE     STR     ISIS            # Kernel type to use (POIS|ISIS|SPAM|FRIES|GUNK|RINGS)
    4 KERNEL.SIZE     S32     35              # Kernel half-size (pixels)
     4KERNEL.SIZE     S32     20              # Kernel half-size (pixels)
    55SPATIAL.ORDER   S32     1               # Spatial polynomial order
    66REGION.SIZE     F32     0               # Iso-kernel region size (pixels)
    77SOURCE.RADIUS   F32     3.0             # Source matching radius (pixels)
    88STAMP.SPACING   F32     300             # Typical spacing between stamps (pixels)
    9 STAMP.FOOTPRINT S32     40              # Size of stamps (pixels)
     9STAMP.FOOTPRINT S32     25              # Size of stamps (pixels)
    1010STAMP.THRESHOLD F32     5               # Flux threshold for stamps (stdev above background)
    1111STRIDE          S32     100             # Size of convolution patches (pixels)
    … …  
    1616SKY.ERR         F32     0.0             # Relative systematic error in images
    1717NORM.FRAC       F32     0.03            # Fraction of window for normalisation window
     18COVAR.FRAC      F32     0.01            # Fraction of kernel to truncate before calculating covariance
    1819
    1920MASK.VAL        STR     MASK.VALUE,CONV.BAD     # Mask value for input

  • branches/eam_branches/20091201/ppStack/src/ppStackMatch.c

    r26740 r26769  
    301301            float sysError = psMetadataLookupF32(NULL, ppsub, "SYS.ERR"); // Relative systematic error in images
    302302            float skyErr = psMetadataLookupF32(NULL, ppsub, "SKY.ERR"); // Additional error in sky
     303            float covarFrac = psMetadataLookupF32(NULL, ppsub, "COVAR.FRAC"); // Fraction for covariance calculation
    303304
    304305            const char *typeStr = psMetadataLookupStr(NULL, ppsub, "KERNEL.TYPE"); // Kernel type
    … …  
    412413            if (kernel) {
    413414                if (!pmSubtractionMatchPrecalc(NULL, conv, fake, readout, readout->analysis,
    414                                                stride, kernelError, maskVal, maskBad, maskPoor,
     415                                               stride, kernelError, covarFrac, maskVal, maskBad, maskPoor,
    415416                                               poorFrac, badFrac)) {
    416417                    psError(PS_ERR_UNKNOWN, false, "Unable to convolve images.");
    … …  
    446447                                        orders, inner, ringsOrder, binning, penalty,
    447448                                        optimum, optWidths, optOrder, optThresh, iter, rej, normFrac,
    448                                         sysError, skyErr, kernelError, maskVal, maskBad, maskPoor,
     449                                        sysError, skyErr, kernelError, covarFrac, maskVal, maskBad, maskPoor,
    449450                                        poorFrac, badFrac, PM_SUBTRACTION_MODE_2)) {
    450451                    psError(PS_ERR_UNKNOWN, false, "Unable to match images.");

  • branches/eam_branches/20091201/ppSub/src/ppSubMatchPSFs.c

    r26738 r26769  
    258258    float sysErr = psMetadataLookupF32(NULL, recipe, "SYS.ERR"); // Relative systematic error in images
    259259    float skyErr = psMetadataLookupF32(NULL, recipe, "SKY.ERR"); // Additional error in sky
     260    float covarFrac = psMetadataLookupF32(NULL, recipe, "COVAR.FRAC"); // Fraction for covariance calculation
    260261
    261262    float badFrac = psMetadataLookupF32(NULL, recipe, "BADFRAC"); // Maximum bad fraction
    … …  
    321322    if (kernelRO) {
    322323        success = pmSubtractionMatchPrecalc(inConv, refConv, inRO, refRO, kernelRO->analysis,
    323                                             stride, kernelErr, maskVal, maskBad, maskPoor, poorFrac, badFrac);
     324                                            stride, kernelErr, covarFrac, maskVal, maskBad, maskPoor,
     325                                            poorFrac, badFrac);
    324326    } else {
    325327        success = pmSubtractionMatch(inConv, refConv, inRO, refRO, footprint, stride, regionSize,
    … …  
    327329                                     widths, orders, inner, ringsOrder, binning, penalty, optimum,
    328330                                     optWidths, optOrder, optThresh, iter, rej, normFrac,
    329                                      sysErr, skyErr, kernelErr, maskVal, maskBad, maskPoor,
     331                                     sysErr, skyErr, kernelErr, covarFrac, maskVal, maskBad, maskPoor,
    330332                                     poorFrac, badFrac, subMode);
    331333    }

  • branches/eam_branches/20091201/psModules/src/imcombine/pmStackReject.c

    r26761 r26769  
    156156        psRegion *region = subRegions->data[i]; // Region of interest
    157157        pmSubtractionKernels *kernels = subKernels->data[i]; // Kernel of interest
    158         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,
    159159                                   region, kernels, false, true)) {
    160160            psError(PS_ERR_UNKNOWN, false, "Unable to convolve mask image in region %d.", i);

  • branches/eam_branches/20091201/psModules/src/imcombine/pmSubtraction.c

    r26759 r26769  
    11531153bool pmSubtractionConvolve(pmReadout *out1, pmReadout *out2, const pmReadout *ro1, const pmReadout *ro2,
    11541154                           psImage *subMask, int stride, psImageMaskType maskBad, psImageMaskType maskPoor,
    1155                            float poorFrac, float kernelError, const psRegion *region,
     1155                           float poorFrac, float kernelError, float covarFrac, const psRegion *region,
    11561156                           const pmSubtractionKernels *kernels, bool doBG, bool useFFT)
    11571157{
    … …  
    11951195    PS_ASSERT_FLOAT_LARGER_THAN_OR_EQUAL(kernelError, 0.0, false);
    11961196    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);
    11971199    if (region && psRegionIsNaN(*region)) {
    11981200        psString string = psRegionToString(*region);
    … …  
    13271329    if (kernels->mode == PM_SUBTRACTION_MODE_1 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
    13281330        psKernel *kernel = pmSubtractionKernel(kernels, 0.0, 0.0, false); // Convolution kernel
     1331        psKernelTruncate(kernel, covarFrac);
    13291332        out1->covariance = psImageCovarianceCalculate(kernel, ro1->covariance);
    13301333        psFree(kernel);
    … …  
    13331336        psKernel *kernel = pmSubtractionKernel(kernels, 0.0, 0.0,
    13341337                                               kernels->mode == PM_SUBTRACTION_MODE_DUAL); // Conv. kernel
     1338        psKernelTruncate(kernel, covarFrac);
    13351339        out2->covariance = psImageCovarianceCalculate(kernel, ro2->covariance);
    13361340        psFree(kernel);

  • branches/eam_branches/20091201/psModules/src/imcombine/pmSubtraction.h

    r26739 r26769  
    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/20091201/psModules/src/imcombine/pmSubtractionMatch.c

    r26741 r26769  
    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/20091201/psModules/src/imcombine/pmSubtractionMatch.h

    r26703 r26769  
    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.