IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 17297


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.

Location:
trunk/psModules/src/imcombine
Files:
6 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}

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

    r16607 r17297  
    521521        bool status;                    // Status of least-squares matrix/vector calculation
    522522        switch (kernels->mode) {
    523           case PM_SUBTRACTION_MODE_TARGET:
    524523          case PM_SUBTRACTION_MODE_1:
    525524            status = calculateMatrix(stamp->matrix1, kernels, stamp->convolutions1, stamp->image1,
    … …  
    941940            psArray *convolutions;      // Convolution postage stamps for each kernel basis function
    942941            switch (kernels->mode) {
    943               case PM_SUBTRACTION_MODE_TARGET:
    944942              case PM_SUBTRACTION_MODE_1:
    945943                target = stamp->image2;

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

    r16607 r17297  
    1818typedef enum {
    1919    PM_SUBTRACTION_MODE_ERR,            // Error in the mode
    20     PM_SUBTRACTION_MODE_TARGET,         // Convolve image 1 to match target PSF
    2120    PM_SUBTRACTION_MODE_1,              // Convolve image 1
    2221    PM_SUBTRACTION_MODE_2,              // Convolve image 2

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

    r17295 r17297  
    101101                        psMaskType maskBlank, float badFrac, pmSubtractionMode mode)
    102102{
    103     PS_ASSERT_PTR_NON_NULL(conv1, false);
    104     if (mode == PM_SUBTRACTION_MODE_DUAL) {
    105         PS_ASSERT_PTR_NON_NULL(conv2, false);
    106     }
    107     PS_ASSERT_PTR_NON_NULL(ro1, false);
    108     PS_ASSERT_IMAGE_NON_NULL(ro1->image, false);
    109     PS_ASSERT_IMAGE_TYPE(ro1->image, PS_TYPE_F32, false);
    110     if (ro1->mask) {
    111         PS_ASSERT_IMAGE_NON_NULL(ro1->mask, false);
    112         PS_ASSERT_IMAGE_TYPE(ro1->mask, PS_TYPE_MASK, false);
    113         PS_ASSERT_IMAGES_SIZE_EQUAL(ro1->mask, ro1->image, false);
    114     }
    115     if (ro1->weight) {
    116         PS_ASSERT_IMAGE_NON_NULL(ro1->weight, false);
    117         PS_ASSERT_IMAGE_TYPE(ro1->weight, PS_TYPE_F32, false);
    118         PS_ASSERT_IMAGES_SIZE_EQUAL(ro1->weight, ro1->image, false);
    119     }
    120     if (ro2) {
    121         PS_ASSERT_IMAGE_NON_NULL(ro2->image, false);
    122         PS_ASSERT_IMAGE_TYPE(ro2->image, PS_TYPE_F32, false);
    123         PS_ASSERT_IMAGES_SIZE_EQUAL(ro2->image, ro1->image, false);
    124         if (ro2->mask) {
    125             PS_ASSERT_IMAGE_NON_NULL(ro2->mask, false);
    126             PS_ASSERT_IMAGE_TYPE(ro2->mask, PS_TYPE_MASK, false);
    127             PS_ASSERT_IMAGES_SIZE_EQUAL(ro2->mask, ro1->image, false);
    128         }
    129         if (ro2->weight) {
    130             PS_ASSERT_IMAGE_NON_NULL(ro2->weight, false);
    131             PS_ASSERT_IMAGE_TYPE(ro2->weight, PS_TYPE_F32, false);
    132             PS_ASSERT_IMAGES_SIZE_EQUAL(ro2->weight, ro1->image, false);
    133         }
    134     } else if (!stampsName && !sources) {
    135         psError(PS_ERR_UNEXPECTED_NULL, true,
    136                 "A list of sources is required for convolving to a target PSF.");
    137         return false;
    138     }
     103    PM_ASSERT_READOUT_NON_NULL(conv1, false);
     104    PM_ASSERT_READOUT_NON_NULL(conv2, false);
     105
     106    PM_ASSERT_READOUT_NON_NULL(ro1, false);
     107    PM_ASSERT_READOUT_NON_NULL(ro2, false);
     108    PM_ASSERT_READOUT_IMAGE(ro1, false);
     109    PM_ASSERT_READOUT_IMAGE(ro2, false);
     110    PS_ASSERT_IMAGES_SIZE_EQUAL(ro1->image, ro2->image, false);
     111
    139112    PS_ASSERT_INT_NONNEGATIVE(footprint, false);
    140113    // regionSize can be just about anything (except maybe negative, but it can be NAN)
    … …  
    182155    }
    183156
    184     // Reset the output readout, just in case
     157    // Reset the output readouts, just in case
    185158    if (conv1->image) {
    186159        psFree(conv1->image);
    … …  
    195168        conv1->weight = NULL;
    196169    }
     170    if (conv2->image) {
     171        psFree(conv2->image);
     172        conv2->image = NULL;
     173    }
     174    if (conv2->mask) {
     175        psFree(conv2->mask);
     176        conv2->mask = NULL;
     177    }
     178    if (conv2->weight) {
     179        psFree(conv2->weight);
     180        conv2->weight = NULL;
     181    }
    197182
    198183    // Where does our weight map come from?
     184    // Getting the weight exactly right is not necessary --- it's just used for weighting.
    199185    psImage *weight = NULL;             // Weight image to use
    200     if (ro1->weight && ro2 && ro2->weight) {
     186    if (ro1->weight && ro2->weight) {
    201187        weight = (psImage*)psBinaryOp(NULL, ro1->weight, "+", ro2->weight);
    202188    } else if (ro1->weight) {
    203189        weight = psMemIncrRefCounter(ro1->weight);
    204     } else if (ro2) {
    205         if (ro2->weight) {
    206             weight = psMemIncrRefCounter(ro2->weight);
    207         } else {
    208             weight = (psImage*)psBinaryOp(NULL, ro1->image, "+", ro2->image);
    209         }
     190    } else if (ro2->weight) {
     191        weight = psMemIncrRefCounter(ro2->weight);
    210192    } else {
    211         weight = psMemIncrRefCounter(ro1->image);
     193        weight = (psImage*)psBinaryOp(NULL, ro1->image, "+", ro2->image);
    212194    }
    213195
    … …  
    218200    pmSubtractionStampList *stamps = NULL; // Stamps for matching PSF
    219201    pmSubtractionKernels *kernels = NULL; // Kernel basis functions
     202
    220203    int numCols = ro1->image->numCols, numRows = ro1->image->numRows; // Image dimensions
    221204
    … …  
    272255            }
    273256
    274             if (mode == PM_SUBTRACTION_MODE_UNSURE || mode == PM_SUBTRACTION_MODE_TARGET) {
     257            if (mode == PM_SUBTRACTION_MODE_UNSURE) {
    275258                // Get backgrounds
    276259                psStats *bgStats = psStatsAlloc(BG_STAT); // Statistics for background
    … …  
    303286                    break;
    304287                  case PM_SUBTRACTION_MODE_2:
    305                     if (mode == PM_SUBTRACTION_MODE_TARGET) {
    306                         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    307                                 "Input PSF is larger than target PSF --- can't match image.");
    308                         goto MATCH_ERROR;
    309                     }
    310288                    psLogMsg("psModules.imcombine", PS_LOG_INFO, "Convolving image 2 to match image 1.");
    311289                    break;
    … …  
    334312            // Add analysis metadata
    335313            {
    336                 psMetadataAddPtr(conv1->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_KERNEL,
    337                                  PS_DATA_UNKNOWN | PS_META_DUPLICATE_OK, "Subtraction kernels", kernels);
    338                 if (conv2) {
    339                     psMetadataAddPtr(conv2->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_KERNEL,
    340                                      PS_DATA_UNKNOWN | PS_META_DUPLICATE_OK, "Subtraction kernels", kernels);
    341                 }
    342                 psMetadataAddS32(conv1->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_MODE,
    343                                  PS_META_DUPLICATE_OK, "Subtraction kernels", mode);
    344                 if (conv2) {
    345                     psMetadataAddS32(conv2->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_MODE,
    346                                      PS_META_DUPLICATE_OK, "Subtraction kernels", mode);
    347                 }
    348                 psRegion *subRegion;
     314                psRegion *subRegion;    // Region over which subtraction was performed
    349315                if (region) {
    350316                    subRegion = psMemIncrRefCounter(region);
    … …  
    352318                    subRegion = psRegionAlloc(0, numCols, 0, numRows);
    353319                }
    354                 psMetadataAddPtr(conv1->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_REGION,
    355                                   PS_DATA_REGION | PS_META_DUPLICATE_OK,
    356                                  "Region over which subtraction was performed", subRegion);
    357                 if (conv2) {
     320
     321                if (mode == PM_SUBTRACTION_MODE_1 || mode == PM_SUBTRACTION_MODE_DUAL) {
     322                    psMetadataAddPtr(conv1->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_KERNEL,
     323                                     PS_DATA_UNKNOWN | PS_META_DUPLICATE_OK, "Subtraction kernels", kernels);
     324                    psMetadataAddS32(conv1->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_MODE,
     325                                     PS_META_DUPLICATE_OK, "Subtraction kernels", mode);
     326                    psMetadataAddPtr(conv1->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_REGION,
     327                                     PS_DATA_REGION | PS_META_DUPLICATE_OK,
     328                                     "Region over which subtraction was performed", subRegion);
     329                }
     330                if (mode == PM_SUBTRACTION_MODE_2 || mode == PM_SUBTRACTION_MODE_DUAL) {
     331                    psMetadataAddPtr(conv2->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_KERNEL,
     332                                     PS_DATA_UNKNOWN | PS_META_DUPLICATE_OK, "Subtraction kernels", kernels);
     333                    psMetadataAddS32(conv2->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_MODE,
     334                                     PS_META_DUPLICATE_OK, "Subtraction kernels", mode);
    358335                    psMetadataAddPtr(conv2->analysis, PS_LIST_TAIL, PM_SUBTRACTION_ANALYSIS_REGION,
    359336                                     PS_DATA_REGION | PS_META_DUPLICATE_OK,

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

    r16607 r17297  
    5050/// Determine which image to convolve
    5151pmSubtractionMode pmSubtractionOrder(pmSubtractionStampList *stamps, ///< Stamps that have been extracted
    52                                      int footprint ///< Stamp half-size
     52                                     float bg1, float bg2 // Background for each image
    5353    );
    5454

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

    r15789 r17297  
    8686    switch (mode) {
    8787      case PM_SUBTRACTION_MODE_1:
    88       case PM_SUBTRACTION_MODE_TARGET:
    8988        maskVal |= PM_SUBTRACTION_MASK_FOOTPRINT_1;
    9089        break;
    … …  
    585584    // Let pmSubtractionStampsSet take care of the rest of the assertions
    586585
    587     const char *format = (mode == PM_SUBTRACTION_MODE_TARGET ? "%f %f %f" : "%f %f"); // Format of file
    588     psArray *data = psVectorsReadFromFile(filename, format);
     586    psArray *data = psVectorsReadFromFile(filename, "%f %f");
    589587    if (!data) {
    590588        psError(PS_ERR_IO, false, "Unable to read stamps file %s", filename);
    … …  
    592590    }
    593591    psVector *x = data->data[0], *y = data->data[1]; // Stamp positions
    594     psVector *flux = (mode == PM_SUBTRACTION_MODE_TARGET ? data->data[2] : NULL); // Stamp fluxes
    595592
    596593    // Correct for IRAF/FITS (unit-offset) positions to C (zero-offset) positions
    … …  
    598595    psBinaryOp(y, y, "-", psScalarAlloc(1.0, PS_TYPE_F32));
    599596
    600     pmSubtractionStampList *stamps = pmSubtractionStampsSet(x, y, flux, image, subMask, region, footprint,
     597    pmSubtractionStampList *stamps = pmSubtractionStampsSet(x, y, NULL, image, subMask, region, footprint,
    601598                                                            spacing, mode);
    602599    psFree(data);
Note: See TracChangeset for help on using the changeset viewer.