IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Apr 2, 2008, 3:57:59 PM (18 years ago)
Author:
Paul Price
Message:

Removing MODE_TARGET mode --- this is now done by generating a fake image (with pmReadoutFakeFromSources) and matching to that with MODE_1 or MODE_2 as appropriate. Changed pmSubtractionMatch and pmSubtractionConvolve so that two output 'convolved' images are always produced. This makes it easier to determine what to subtract from what.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r16607 r17297  
    44 *  @author GLG, MHPCC
    55 *
    6  *  @version $Revision: 1.82 $ $Name: not supported by cvs2svn $
    7  *  @date $Date: 2008-02-22 19:50:56 $
     6 *  @version $Revision: 1.83 $ $Name: not supported by cvs2svn $
     7 *  @date $Date: 2008-04-03 01:57:59 $
    88 *
    99 *  Copyright 2004-2007 Institute for Astronomy, University of Hawaii
    … …  
    472472
    473473    switch (kernels->mode) {
    474       case PM_SUBTRACTION_MODE_TARGET:
    475474      case PM_SUBTRACTION_MODE_1:
    476475        stamp->convolutions1 = convolveStamp(stamp->convolutions1, stamp->image1, kernels, footprint);
    … …  
    638637                           const pmSubtractionKernels *kernels, bool doBG, bool useFFT)
    639638{
    640     PS_ASSERT_PTR_NON_NULL(out1, false);
    641     PS_ASSERT_PTR_NON_NULL(ro1, false);
    642     PS_ASSERT_IMAGE_NON_NULL(ro1->image, false);
    643     PS_ASSERT_IMAGE_TYPE(ro1->image, PS_TYPE_F32, false);
    644     if (ro1->weight) {
    645         PS_ASSERT_IMAGE_NON_NULL(ro1->weight, false);
    646         PS_ASSERT_IMAGE_TYPE(ro1->weight, PS_TYPE_F32, false);
    647         PS_ASSERT_IMAGES_SIZE_EQUAL(ro1->weight, ro1->image, false);
    648     }
     639    PM_ASSERT_READOUT_NON_NULL(out1, false);
     640    PM_ASSERT_READOUT_NON_NULL(out2, false);
     641    PM_ASSERT_READOUT_NON_NULL(ro1, false);
     642    PM_ASSERT_READOUT_NON_NULL(ro2, false);
     643    PM_ASSERT_READOUT_IMAGE(ro1, false);
     644    PM_ASSERT_READOUT_IMAGE(ro2, false);
     645    PS_ASSERT_IMAGES_SIZE_EQUAL(ro1->image, ro2->image, false);
    649646    PM_ASSERT_SUBTRACTION_KERNELS_NON_NULL(kernels, false);
    650647    PM_ASSERT_SUBTRACTION_KERNELS_SOLUTION(kernels, false);
    651     if (kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
    652         PS_ASSERT_PTR_NON_NULL(out2, false);
    653         PS_ASSERT_PTR_NON_NULL(ro2, false);
    654         PS_ASSERT_IMAGE_NON_NULL(ro2->image, false);
    655         PS_ASSERT_IMAGE_TYPE(ro2->image, PS_TYPE_F32, false);
    656         if (ro2->weight) {
    657             PS_ASSERT_IMAGE_NON_NULL(ro2->weight, false);
    658             PS_ASSERT_IMAGE_TYPE(ro2->weight, PS_TYPE_F32, false);
    659             PS_ASSERT_IMAGES_SIZE_EQUAL(ro2->weight, ro1->image, false);
    660         }
    661     }
    662648    if (subMask) {
    663649        PS_ASSERT_IMAGE_NON_NULL(subMask, false);
    664650        PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_MASK, false);
    665651        PS_ASSERT_IMAGES_SIZE_EQUAL(subMask, ro1->image, false);
    666     }
    667     if (out1->image) {
    668         PS_ASSERT_IMAGE_NON_NULL(out1->image, false);
    669         PS_ASSERT_IMAGES_SIZE_EQUAL(out1->image, ro1->image, false);
    670         PS_ASSERT_IMAGE_TYPE(out1->image, PS_TYPE_F32, false);
    671     }
    672     if (out1->mask) {
    673         PS_ASSERT_IMAGE_NON_NULL(out1->mask, false);
    674         PS_ASSERT_IMAGES_SIZE_EQUAL(out1->mask, ro1->image, false);
    675         PS_ASSERT_IMAGE_TYPE(out1->mask, PS_TYPE_MASK, false);
    676         PS_ASSERT_IMAGE_NON_NULL(subMask, false);
    677     }
    678     if (out1->weight) {
    679         PS_ASSERT_IMAGE_NON_NULL(out1->weight, false);
    680         PS_ASSERT_IMAGES_SIZE_EQUAL(out1->weight, ro1->image, false);
    681         PS_ASSERT_IMAGE_TYPE(out1->weight, PS_TYPE_F32, false);
    682652    }
    683653    if (region && psRegionIsNaN(*region)) {
    … …  
    688658    }
    689659
    690     const pmReadout *source;            // Source for image parameters
    691     switch (kernels->mode) {
    692       case PM_SUBTRACTION_MODE_TARGET:
    693       case PM_SUBTRACTION_MODE_1:
    694       case PM_SUBTRACTION_MODE_DUAL:
    695         source = ro1;
    696         break;
    697       case PM_SUBTRACTION_MODE_2:
    698         source = ro2;
    699         break;
    700       default:
    701         psAbort("Unsupported subtraction mode: %x", kernels->mode);
    702     }
    703     psImage *image = source->image, *weight = source->weight; // Image and weight map to convolve
    704     int numCols = image->numCols, numRows = image->numRows; // Image dimensions
    705     int x0 = source->col0, y0 = source->row0; // Image offset
    706 
    707     psImage *convImage1 = out1->image;   // Convolved image
    708     if (!convImage1) {
    709         convImage1 = out1->image = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    710     }
    711     psImage *convMask = NULL;           // Convolved mask image
    712     if (subMask) {
    713         if (!out1->mask) {
    714             out1->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK);
    715         }
    716         convMask = out1->mask;
    717         psImageInit(convMask, 0);
    718     }
    719     psImage *convWeight1 = NULL;         // Convolved weight (variance) image
    720     if (weight) {
    721         if (!out1->weight) {
    722             out1->weight = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    723         }
    724         convWeight1 = out1->weight;
    725         psImageInit(convWeight1, 0.0);
    726     }
    727 
    728     psImage *convImage2 = NULL;
    729     psImage *convWeight2 = NULL;   // Convolved products for dual mode
    730     if (kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
     660    // Inputs
     661    psImage *image1 = ro1->image, *weight1 = ro1->weight; // Image and weight map from input 1
     662    psImage *image2 = ro2->image, *weight2 = ro2->weight; // Image and weight map from input 2
     663    int numCols = image1->numCols, numRows = image1->numRows; // Image dimensions
     664    int x0 = image1->col0, y0 = image1->row0; // Image offset
     665
     666    // Outputs
     667    psImage *convImage1 = NULL, *convWeight1 = NULL; // Convolved image and weight from input 1
     668    if (kernels->mode == PM_SUBTRACTION_MODE_1 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
     669        convImage1 = out1->image;
     670        if (!convImage1) {
     671            convImage1 = out1->image = psImageAlloc(numCols, numRows, PS_TYPE_F32);
     672        }
     673        if (weight1) {
     674            if (!out1->weight) {
     675                out1->weight = psImageAlloc(numCols, numRows, PS_TYPE_F32);
     676            }
     677            convWeight1 = out1->weight;
     678            psImageInit(convWeight1, 0.0);
     679        }
     680    }
     681    psImage *convImage2 = NULL, *convWeight2 = NULL; // Convolved image and weight from input 2
     682    if (kernels->mode == PM_SUBTRACTION_MODE_2 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
    731683        convImage2 = out2->image;
    732684        if (!convImage2) {
    733685            convImage2 = out2->image = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    734686        }
    735         convWeight2 = NULL;         // Convolved weight (variance) image
    736         if (ro2->weight) {
     687        if (weight2) {
    737688            if (!out2->weight) {
    738689                out2->weight = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    … …  
    741692            psImageInit(convWeight2, 0.0);
    742693        }
    743         if (subMask) {
    744             // Copying mask --- they're the same!
     694    }
     695    psImage *convMask = NULL;           // Convolved mask image (common to inputs 1 and 2)
     696    if (subMask) {
     697        if (!out1->mask) {
     698            out1->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK);
     699        }
     700        convMask = out1->mask;
     701        psImageInit(convMask, 0);
     702        if (out2->mask) {
    745703            psFree(out2->mask);
    746             out2->mask = psMemIncrRefCounter(convMask);
    747         }
    748     }
     704        }
     705        out2->mask = psMemIncrRefCounter(convMask);
     706    }
     707
    749708
    750709    int size = kernels->size;           // Half-size of kernel
    … …  
    769728    psMaskType maskTarget;              // Mark these pixels as bad when propagating the subtractionMask
    770729    switch (kernels->mode) {
    771       case PM_SUBTRACTION_MODE_TARGET:
    772730      case PM_SUBTRACTION_MODE_1:
    773731        maskSource = PM_SUBTRACTION_MASK_BAD_1;
    … …  
    806764            psRegion subRegion = psRegionSet(i, xSubMax, j, ySubMax); // Sub-region to convolve
    807765
    808             convolveRegion(convImage1, convWeight1, &kernelImage, &kernelWeight, image, weight,
    809                            subMask, maskSource, kernels, polyValues, background, subRegion, useFFT, false);
    810 
    811             if (kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
    812                 convolveRegion(convImage2, convWeight2, &kernelImage, &kernelWeight, ro2->image, ro2->weight,
    813                                subMask, maskSource, kernels, polyValues, background, subRegion, useFFT, true);
     766            if (kernels->mode == PM_SUBTRACTION_MODE_1 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
     767                convolveRegion(convImage1, convWeight1, &kernelImage, &kernelWeight, image1, weight1,
     768                               subMask, maskSource, kernels, polyValues, background, subRegion, useFFT,
     769                               false);
     770            }
     771            if (kernels->mode == PM_SUBTRACTION_MODE_2 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
     772                convolveRegion(convImage2, convWeight2, &kernelImage, &kernelWeight, image2, weight2,
     773                               subMask, maskSource, kernels, polyValues, background, subRegion, useFFT,
     774                               kernels->mode == PM_SUBTRACTION_MODE_DUAL);
    814775            }
    815776
    … …  
    820781                        if (subMask->data.PS_TYPE_MASK_DATA[y][x] & maskTarget) {
    821782                            convMask->data.PS_TYPE_MASK_DATA[y][x] |= blank;
    822                             convImage1->data.F32[y][x] = NAN;
    823                             if (weight) {
    824                                 convWeight1->data.F32[y][x] = NAN;
    825                             }
    826783                        }
    827784                    }
    828785                }
    829786            }
    830 
    831787        }
    832788    }
    … …  
    835791    psFree(polyValues);
    836792
     793    // Copy anything that wasn't convolved
     794    switch (kernels->mode) {
     795      case PM_SUBTRACTION_MODE_1:
     796        out2->image = psMemIncrRefCounter(ro2->image);
     797        out2->weight = psMemIncrRefCounter(ro2->weight);
     798        out2->mask = psMemIncrRefCounter(ro2->mask);
     799        break;
     800      case PM_SUBTRACTION_MODE_2:
     801        out1->image = psMemIncrRefCounter(ro1->image);
     802        out1->weight = psMemIncrRefCounter(ro1->weight);
     803        out1->mask = psMemIncrRefCounter(ro1->mask);
     804        break;
     805      case PM_SUBTRACTION_MODE_DUAL:
     806        break;
     807      default:
     808        psAbort("Should never get here.");
     809    }
     810
    837811    return true;
    838812}
Note: See TracChangeset for help on using the changeset viewer.