IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 21366 for trunk/ppStack


Ignore:
Timestamp:
Feb 5, 2009, 5:03:33 PM (17 years ago)
Author:
Paul Price
Message:

Merging pap_branch_20090128. Resolved a small number of conflicts. Compiles, but not tested in detail.

Location:
trunk/ppStack/src
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/ppStack/src/ppStack.h

    r21092 r21366  
    3838    psArray *imageFits;                 // FITS file pointers for images
    3939    psArray *maskFits;                  // FITS file pointers for masks
    40     psArray *weightFits;                // FITS file pointers for weights
     40    psArray *varianceFits;                // FITS file pointers for variances
    4141} ppStackThreadData;
    4242
    … …  
    4545                                          const psArray *imageNames, // Names of images to read
    4646                                          const psArray *maskNames, // Names of masks to read
    47                                           const psArray *weightNames, // Names of weight maps to read
     47                                          const psArray *varianceNames, // Names of variance maps to read
    4848                                          const pmConfig *config // Configuration
    4949    );

  • trunk/ppStack/src/ppStackArguments.c

    r21199 r21366  
    2424            "\tIMAGE(STR):     Image filename\n"
    2525            "\tMASK(STR):      Mask filename\n"
    26             "\tWEIGHT(STR):    Weight map filename\n"
     26            "\tVARIANCE(STR):  Variance map filename\n"
    2727            "\tPSF(STR):       PSF filename\n"
    2828            "\tSOURCES(STR):   Sources filename\n"
    … …  
    151151    psMetadataAddStr(arguments, PS_LIST_TAIL, "-mask-poor", 0, "Mask value to give poor pixels", NULL);
    152152    psMetadataAddF32(arguments, PS_LIST_TAIL, "-threshold-mask", 0, "Threshold for mask deconvolution", NAN);
    153     psMetadataAddF32(arguments, PS_LIST_TAIL, "-poor-frac", 0, "Fraction of weight for poor pixels", NAN);
     153    psMetadataAddF32(arguments, PS_LIST_TAIL, "-poor-frac", 0, "Fraction of variance for poor pixels", NAN);
    154154    psMetadataAddF32(arguments, PS_LIST_TAIL, "-deconv-limit", 0, "Maximum deconvolution fraction limit", NAN);
    155155    psMetadataAddF32(arguments, PS_LIST_TAIL, "-image-rej", 0,
    … …  
    183183    psMetadataAddStr(arguments, PS_LIST_TAIL, "-temp-image", 0, "Suffix for temporary images", NULL);
    184184    psMetadataAddStr(arguments, PS_LIST_TAIL, "-temp-mask", 0, "Suffix for temporary masks", NULL);
    185     psMetadataAddStr(arguments, PS_LIST_TAIL, "-temp-weight", 0, "Suffix for temporary weight maps", NULL);
     185    psMetadataAddStr(arguments, PS_LIST_TAIL, "-temp-variance", 0, "Suffix for temporary variance maps", NULL);
    186186    psMetadataAddBool(arguments, PS_LIST_TAIL, "-temp-delete", 0,
    187187                      "Delete temporary files on completion?", false);
    … …  
    283283    VALUE_ARG_RECIPE_INT("-renorm-num", "RENORM.NUM", S32, 0);
    284284    VALUE_ARG_RECIPE_FLOAT("-renorm-width", "RENORM.WIDTH", F32);
    285     valueArgRecipeStr(arguments, recipe, "-renorm-mean", "RENORM.MEAN", recipe);
     285    valueArgRecipeStr(arguments, recipe, "-renorm-mean",  "RENORM.MEAN", recipe);
    286286    valueArgRecipeStr(arguments, recipe, "-renorm-stdev", "RENORM.STDEV", recipe);
    287287
    288     valueArgRecipeStr(arguments, recipe, "-temp-image",  "TEMP.IMAGE",  recipe);
    289     valueArgRecipeStr(arguments, recipe, "-temp-mask",   "TEMP.MASK",   recipe);
    290     valueArgRecipeStr(arguments, recipe, "-temp-weight", "TEMP.WEIGHT", recipe);
     288    valueArgRecipeStr(arguments, recipe, "-temp-image",    "TEMP.IMAGE",  recipe);
     289    valueArgRecipeStr(arguments, recipe, "-temp-mask",     "TEMP.MASK",   recipe);
     290    valueArgRecipeStr(arguments, recipe, "-temp-variance", "TEMP.VARIANCE", recipe);
    291291
    292292    if (psMetadataLookupBool(NULL, arguments, "-temp-delete") ||

  • trunk/ppStack/src/ppStackCamera.c

    r20995 r21366  
    7171bool ppStackCamera(pmConfig *config)
    7272{
    73     bool haveWeights = false;           // Do we have weight maps?
     73    bool haveVariances = false;           // Do we have variance maps?
    7474    bool havePSFs = false;              // Do we have PSFs?
    7575
    … …  
    9797        bool mdok;
    9898        psString mask = psMetadataLookupStr(&mdok, input, "MASK"); // Name of mask
    99         psString weight = psMetadataLookupStr(&mdok, input, "WEIGHT"); // Name of weight map
     99        psString variance = psMetadataLookupStr(&mdok, input, "VARIANCE"); // Name of variance map
    100100        psString psf = psMetadataLookupStr(&mdok, input, "PSF"); // Name of PSF
    101101        psString sources = psMetadataLookupStr(&mdok, input, "SOURCES"); // Name of sources
    … …  
    140140        }
    141141
    142         // Optionally add the weight file
    143         if (weight && strlen(weight) > 0) {
    144             haveWeights = true;
    145             psArray *weightFiles = psArrayAlloc(1); // Array of filenames for this FPA
    146             weightFiles->data[0] = psMemIncrRefCounter(weight);
    147             psMetadataAddArray(config->arguments, PS_LIST_TAIL, "WEIGHT.FILENAMES", PS_META_REPLACE,
    148                                "Filenames of weight files", weightFiles);
    149             psFree(weightFiles);
     142        // Optionally add the variance file
     143        if (variance && strlen(variance) > 0) {
     144            haveVariances = true;
     145            psArray *varianceFiles = psArrayAlloc(1); // Array of filenames for this FPA
     146            varianceFiles->data[0] = psMemIncrRefCounter(variance);
     147            psMetadataAddArray(config->arguments, PS_LIST_TAIL, "VARIANCE.FILENAMES", PS_META_REPLACE,
     148                               "Filenames of variance files", varianceFiles);
     149            psFree(varianceFiles);
    150150
    151151            bool status;
    152             pmFPAfile *weightFile = pmFPAfileBindFromArgs(&status, imageFile, config, "PPSTACK.INPUT.WEIGHT",
    153                                                           "WEIGHT.FILENAMES");
     152            pmFPAfile *varianceFile = pmFPAfileBindFromArgs(&status, imageFile, config,
     153                                                            "PPSTACK.INPUT.VARIANCE", "VARIANCE.FILENAMES");
    154154            if (!status) {
    155                 psError(PS_ERR_UNKNOWN, false, "Unable to define file from weight %d (%s)", i, weight);
    156                 return false;
    157             }
    158             if (weightFile->type != PM_FPA_FILE_WEIGHT) {
    159                 psError(PS_ERR_IO, true, "PPSTACK.INPUT.WEIGHT is not of type WEIGHT");
     155                psError(PS_ERR_UNKNOWN, false, "Unable to define file from variance %d (%s)", i, variance);
     156                return false;
     157            }
     158            if (varianceFile->type != PM_FPA_FILE_VARIANCE) {
     159                psError(PS_ERR_IO, true, "PPSTACK.INPUT.VARIANCE is not of type VARIANCE");
    160160                return false;
    161161            }
    … …  
    217217#if 0
    218218        // Output convolved files
    219         pmFPAfile *outconvImage  = defineOutputConvolved("PPSTACK.OUTCONV", imageFile->fpa, config,
     219        pmFPAfile *outconvImage    = defineOutputConvolved("PPSTACK.OUTCONV", imageFile->fpa, config,
     220                                                           PM_FPA_FILE_IMAGE);
     221        pmFPAfile *outconvMask     = defineOutputConvolved("PPSTACK.OUTCONV.MASK", imageFile->fpa, config,
     222                                                           PM_FPA_FILE_MASK);
     223        pmFPAfile *outconvVariance = defineOutputConvolved("PPSTACK.OUTCONV.VARIANCE", imageFile->fpa, config,
     224                                                           PM_FPA_FILE_VARIANCE);
     225        if (!outconvImage || !outconvMask || !outconvVariance) {
     226            return false;
     227        }
     228
     229        // Input convolved files
     230        pmFPAfile *inconvImage    = defineInputConvolved("PPSTACK.INCONV", outconvImage, config,
    220231                                                         PM_FPA_FILE_IMAGE);
    221         pmFPAfile *outconvMask   = defineOutputConvolved("PPSTACK.OUTCONV.MASK", imageFile->fpa, config,
     232        pmFPAfile *inconvMask     = defineInputConvolved("PPSTACK.INCONV.MASK", outconvMask, config,
    222233                                                         PM_FPA_FILE_MASK);
    223         pmFPAfile *outconvWeight = defineOutputConvolved("PPSTACK.OUTCONV.WEIGHT", imageFile->fpa, config,
    224                                                          PM_FPA_FILE_WEIGHT);
    225         if (!outconvImage || !outconvMask || !outconvWeight) {
    226             return false;
    227         }
    228 
    229         // Input convolved files
    230         pmFPAfile *inconvImage  = defineInputConvolved("PPSTACK.INCONV", outconvImage, config,
    231                                                        PM_FPA_FILE_IMAGE);
    232         pmFPAfile *inconvMask   = defineInputConvolved("PPSTACK.INCONV.MASK", outconvMask, config,
    233                                                        PM_FPA_FILE_MASK);
    234         pmFPAfile *inconvWeight = defineInputConvolved("PPSTACK.INCONV.WEIGHT", outconvWeight, config,
    235                                                        PM_FPA_FILE_WEIGHT);
    236         if (!inconvImage || !inconvMask || !inconvWeight) {
     234        pmFPAfile *inconvVariance = defineInputConvolved("PPSTACK.INCONV.VARIANCE", outconvVariance, config,
     235                                                         PM_FPA_FILE_VARIANCE);
     236        if (!inconvImage || !inconvMask || !inconvVariance) {
    237237            return false;
    238238        }
    … …  
    246246        psMetadataRemoveKey(config->arguments, "MASK.FILENAMES");
    247247    }
    248     if (psMetadataLookup(config->arguments, "WEIGHT.FILENAMES")) {
    249         psMetadataRemoveKey(config->arguments, "WEIGHT.FILENAMES");
     248    if (psMetadataLookup(config->arguments, "VARIANCE.FILENAMES")) {
     249        psMetadataRemoveKey(config->arguments, "VARIANCE.FILENAMES");
    250250    }
    251251    if (psMetadataLookup(config->arguments, "PSF.FILENAMES")) {
    … …  
    295295    outMask->save = true;
    296296
    297     // Output weight
    298     if (haveWeights) {
    299         pmFPAfile *outWeight = pmFPAfileDefineOutput(config, output->fpa, "PPSTACK.OUTPUT.WEIGHT");
    300         if (!outWeight) {
    301             psError(PS_ERR_IO, false, _("Unable to generate output file from PPSTACK.OUTPUT.WEIGHT"));
    302             return false;
    303         }
    304         if (outWeight->type != PM_FPA_FILE_WEIGHT) {
    305             psError(PS_ERR_IO, true, "PPSTACK.OUTPUT.WEIGHT is not of type WEIGHT");
    306             return false;
    307         }
    308         outWeight->save = true;
     297    // Output variance
     298    if (haveVariances) {
     299        pmFPAfile *outVariance = pmFPAfileDefineOutput(config, output->fpa, "PPSTACK.OUTPUT.VARIANCE");
     300        if (!outVariance) {
     301            psError(PS_ERR_IO, false, _("Unable to generate output file from PPSTACK.OUTPUT.VARIANCE"));
     302            return false;
     303        }
     304        if (outVariance->type != PM_FPA_FILE_VARIANCE) {
     305            psError(PS_ERR_IO, true, "PPSTACK.OUTPUT.VARIANCE is not of type VARIANCE");
     306            return false;
     307        }
     308        outVariance->save = true;
    309309    }
    310310

  • trunk/ppStack/src/ppStackLoop.c

    r21258 r21366  
    2424
    2525// Files required for the convolution
    26 static char *convolveFiles[] = { "PPSTACK.INPUT", "PPSTACK.INPUT.MASK", "PPSTACK.INPUT.WEIGHT", NULL };
     26static char *convolveFiles[] = { "PPSTACK.INPUT", "PPSTACK.INPUT.MASK", "PPSTACK.INPUT.VARIANCE", NULL };
    2727
    2828// Output files for the combination
    29 static char *combineFiles[] = { "PPSTACK.OUTPUT", "PPSTACK.OUTPUT.MASK", "PPSTACK.OUTPUT.WEIGHT",
     29static char *combineFiles[] = { "PPSTACK.OUTPUT", "PPSTACK.OUTPUT.MASK", "PPSTACK.OUTPUT.VARIANCE",
    3030                                "PPSTACK.OUTPUT.JPEG1", "PPSTACK.OUTPUT.JPEG2", NULL };
    3131
    … …  
    204204    const char *tempImage = psMetadataLookupStr(NULL, recipe, "TEMP.IMAGE"); // Suffix for temporary images
    205205    const char *tempMask = psMetadataLookupStr(NULL, recipe, "TEMP.MASK"); // Suffix for temporary masks
    206     const char *tempWeight = psMetadataLookupStr(NULL, recipe, "TEMP.WEIGHT"); // Suffix for temp weight maps
    207     if (!tempImage || !tempMask || !tempWeight) {
     206    const char *tempVariance = psMetadataLookupStr(NULL, recipe, "TEMP.VARIANCE"); // Suffix for temp variance maps
     207    if (!tempImage || !tempMask || !tempVariance) {
    208208        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
    209                 "Unable to find TEMP.IMAGE, TEMP.MASK and TEMP.WEIGHT in recipe");
     209                "Unable to find TEMP.IMAGE, TEMP.MASK and TEMP.VARIANCE in recipe");
    210210        return false;
    211211    }
    … …  
    387387    psArray *imageNames = psArrayAlloc(num);
    388388    psArray *maskNames = psArrayAlloc(num);
    389     psArray *weightNames = psArrayAlloc(num);
     389    psArray *varianceNames = psArrayAlloc(num);
    390390    for (int i = 0; i < num; i++) {
    391         psString imageName = NULL, maskName = NULL, weightName = NULL; // Names for convolved images
     391        psString imageName = NULL, maskName = NULL, varianceName = NULL; // Names for convolved images
    392392        psStringAppend(&imageName, "%s/%s.%d.%s", tempDir, tempName, i, tempImage);
    393393        psStringAppend(&maskName, "%s/%s.%d.%s", tempDir, tempName, i, tempMask);
    394         psStringAppend(&weightName, "%s/%s.%d.%s", tempDir, tempName, i, tempWeight);
    395         psTrace("ppStack", 5, "Temporary files: %s %s %s\n", imageName, maskName, weightName);
     394        psStringAppend(&varianceName, "%s/%s.%d.%s", tempDir, tempName, i, tempVariance);
     395        psTrace("ppStack", 5, "Temporary files: %s %s %s\n", imageName, maskName, varianceName);
    396396        imageNames->data[i] = imageName;
    397397        maskNames->data[i] = maskName;
    398         weightNames->data[i] = weightName;
     398        varianceNames->data[i] = varianceName;
    399399    }
    400400    // Free the outputName that we grabbed above to set up tempName.
    … …  
    417417    psList *fpaList = psListAlloc(NULL); // List of input FPAs, for concept averaging
    418418    psList *cellList = psListAlloc(NULL); // List of input cells, for concept averaging
     419    psArray *covariances = psArrayAlloc(num); // Covariance matrices
    419420    for (int i = 0; i < num; i++) {
    420421        psTrace("ppStack", 2, "Convolving input %d of %d to target PSF....\n", i, num);
    … …  
    431432            psFree(fpaList);
    432433            psFree(cellList);
     434            psFree(covariances);
    433435            return false;
    434436        }
    … …  
    450452            psFree(fpaList);
    451453            psFree(cellList);
     454            psFree(covariances);
    452455            return false;
    453456        }
    … …  
    464467            continue;
    465468        }
     469        covariances->data[i] = psMemIncrRefCounter(readout->covariance);
    466470
    467471        if (stats) {
    … …  
    486490        pmHDU *hdu = readout->parent->parent->parent->hdu; // HDU for convolved image
    487491        assert(hdu);
    488         writeImage(imageNames->data[i],  hdu->header, readout->image, config);
    489492        psMetadata *maskHeader = psMetadataCopy(NULL, hdu->header); // Copy of header, for mask
    490493        pmConfigMaskWriteHeader(config, maskHeader);
    491         writeImage(maskNames->data[i],   maskHeader, readout->mask, config);
     494        writeImage(maskNames->data[i], maskHeader, readout->mask, config);
    492495        psFree(maskHeader);
    493         writeImage(weightNames->data[i], hdu->header, readout->weight, config);
     496        writeImage(varianceNames->data[i], hdu->header, readout->variance, config);
    494497
    495498        pmCell *inCell = readout->parent; // Input cell
    … …  
    502505            psFree(fpaList);
    503506            psFree(cellList);
     507            psFree(covariances);
    504508            return false;
    505509        }
    … …  
    523527        psFree(fpaList);
    524528        psFree(cellList);
     529        psFree(covariances);
    525530        return false;
    526531    }
    … …  
    570575            psFree(matchChi2);
    571576            psFree(values);
     577            psFree(covariances);
    572578            return false;
    573579        }
    … …  
    611617        psFree(inputMask);
    612618        psFree(matchChi2);
     619        psFree(covariances);
    613620        return false;
    614621    }
    … …  
    622629    // Start threading
    623630    ppStackThreadInit();
    624     ppStackThreadData *stack = ppStackThreadDataSetup(cells, imageNames, maskNames, weightNames, config);
     631    ppStackThreadData *stack = ppStackThreadDataSetup(cells, imageNames, maskNames, varianceNames, config);
    625632
    626633    psTimerStart("PPSTACK_INITIAL");
    … …  
    645652            psFree(matchChi2);
    646653            psFree(cells);
     654            psFree(covariances);
    647655            return false;
    648656        }
    … …  
    658666            psFree(matchChi2);
    659667            psFree(cells);
     668            psFree(covariances);
    660669            return false;
    661670        }
    … …  
    676685            psFree(outRO);
    677686            psFree(cells);
     687            psFree(covariances);
    678688            return false;
    679689        }
    … …  
    695705                psFree(view);
    696706                psFree(outRO);
     707                psFree(covariances);
    697708                return false;
    698709            }
    … …  
    721732                psFree(view);
    722733                psFree(outRO);
     734                psFree(covariances);
    723735                return false;
    724736            }
    … …  
    735747            psFree(view);
    736748            psFree(outRO);
     749            psFree(covariances);
    737750            return false;
    738751        }
    … …  
    803816                psFree(inspect);
    804817                psFree(rejected);
     818                psFree(covariances);
    805819                return false;
    806820            }
    … …  
    818832            psFree(inspect);
    819833            psFree(rejected);
     834            psFree(covariances);
    820835            return false;
    821836        }
    … …  
    912927            psFree(view);
    913928            psFree(outRO);
     929            psFree(covariances);
    914930            return false;
    915931        }
    … …  
    941957                psFree(view);
    942958                psFree(outRO);
     959                psFree(covariances);
    943960                return false;
    944961            }
    … …  
    962979                psFree(view);
    963980                psFree(outRO);
     981                psFree(covariances);
    964982                return false;
    965983            }
    … …  
    974992            psFree(view);
    975993            psFree(outRO);
     994            psFree(covariances);
    976995            return false;
    977996        }
    … …  
    979998
    980999    memDump("final");
     1000
     1001    // Sum covariance matrices
     1002    for (int i = 0; i < num; i++) {
     1003        if (inputMask->data.U8[i]) {
     1004            psFree(covariances->data[i]);
     1005            covariances->data[i] = NULL;
     1006        }
     1007    }
     1008    outRO->covariance = psImageCovarianceSum(covariances);
     1009    psFree(covariances);
    9811010
    9821011    if (stats) {
    … …  
    10401069            psString imageResolved = pmConfigConvertFilename(imageNames->data[i], config, false, false);
    10411070            psString maskResolved = pmConfigConvertFilename(maskNames->data[i], config, false, false);
    1042             psString weightResolved = pmConfigConvertFilename(weightNames->data[i], config, false, false);
     1071            psString varianceResolved = pmConfigConvertFilename(varianceNames->data[i], config, false, false);
    10431072            if (unlink(imageResolved) == -1 || unlink(maskResolved) == -1 ||
    1044                 unlink(weightResolved) == -1) {
     1073                unlink(varianceResolved) == -1) {
    10451074                psWarning("Unable to delete temporary files for image %d", i);
    10461075            }
    10471076            psFree(imageResolved);
    10481077            psFree(maskResolved);
    1049             psFree(weightResolved);
     1078            psFree(varianceResolved);
    10501079        }
    10511080    }
    10521081    psFree(imageNames);
    10531082    psFree(maskNames);
    1054     psFree(weightNames);
     1083    psFree(varianceNames);
    10551084
    10561085    psFree(inputMask);
    … …  
    10921121        float renormWidth = psMetadataLookupS32(&mdok, recipe, "RENORM.WIDTH"); // Width of Gaussian phot
    10931122        psImageMaskType maskValue = pmConfigMaskGet("BLANK", config); // Bits to mask
    1094         if (!pmReadoutWeightRenormPhot(outRO, maskValue, renormNum, renormWidth,
    1095                                        renormMean, renormStdev, NULL)) {
     1123        if (!pmReadoutVarianceRenormPhot(outRO, maskValue, renormNum, renormWidth,
     1124                                         renormMean, renormStdev, NULL)) {
    10961125            psError(PS_ERR_UNKNOWN, false, "Unable to renormalise variances.");
    10971126            psFree(outRO);

  • trunk/ppStack/src/ppStackMatch.c

    r21199 r21366  
    1616                     PM_SOURCE_MODE_CR_LIMIT) // Mask to apply to input sources
    1717#define FAINT_SOURCE_FRAC 1.0e-4         // Set minimum flux to this fraction of faintest source flux
     18#define COVAR_FRAC 0.01                 // Truncation fraction for covariance matrix
    1819
    1920//#define TESTING                         // Enable debugging output
    … …  
    233234        }
    234235
    235         // Read image, mask, weight
     236        // Read image, mask, variance
    236237        const char *tempImage = psMetadataLookupStr(NULL, recipe, "TEMP.IMAGE"); // Suffix for image
    237238        const char *tempMask = psMetadataLookupStr(NULL, recipe, "TEMP.MASK"); // Suffix for mask
    238         const char *tempWeight = psMetadataLookupStr(NULL, recipe, "TEMP.WEIGHT"); // Suffix for weight map
    239         psString imageName = NULL, maskName = NULL, weightName = NULL; // Names for convolved images
     239        const char *tempVariance = psMetadataLookupStr(NULL, recipe, "TEMP.VARIANCE"); // Suffix for variance map
     240        psString imageName = NULL, maskName = NULL, varianceName = NULL; // Names for convolved images
    240241        psStringAppend(&imageName, "%s.%d.%s", outName, numInput, tempImage);
    241242        psStringAppend(&maskName, "%s.%d.%s", outName, numInput, tempMask);
    242         psStringAppend(&weightName, "%s.%d.%s", outName, numInput, tempWeight);
     243        psStringAppend(&varianceName, "%s.%d.%s", outName, numInput, tempVariance);
    243244
    244245        if (!readImage(&readout->image, imageName, config) || !readImage(&readout->mask, maskName, config) ||
    245             !readImage(&readout->weight, weightName, config)) {
     246            !readImage(&readout->variance, varianceName, config)) {
    246247            psError(PS_ERR_IO, false, "Unable to read previously produced image.");
    247248            psFree(imageName);
    248249            psFree(maskName);
    249             psFree(weightName);
     250            psFree(varianceName);
    250251            return false;
    251252        }
    252253        psFree(imageName);
    253254        psFree(maskName);
    254         psFree(weightName);
     255        psFree(varianceName);
    255256
    256257        psRegion *region = psMetadataLookupPtr(NULL, output->analysis,
    … …  
    374375                                                                                         "RENORM.STDEV"));
    375376
    376                 if (!pmReadoutWeightRenormPixels(readout, maskBad, renormMean, renormStdev, rng)) {
     377                if (!pmReadoutVarianceRenormPixels(readout, maskBad, renormMean, renormStdev, rng)) {
    377378                    psError(PS_ERR_UNKNOWN, false, "Unable to renormalise variances.");
    378379                    psFree(output);
    … …  
    444445            psFree(readout->image);
    445446            psFree(readout->mask);
    446             psFree(readout->weight);
     447            psFree(readout->variance);
     448            psFree(readout->covariance);
    447449            readout->image  = psMemIncrRefCounter(output->image);
    448450            readout->mask   = psMemIncrRefCounter(output->mask);
    449             readout->weight = psMemIncrRefCounter(output->weight);
     451            readout->variance = psMemIncrRefCounter(output->variance);
     452            readout->covariance = psImageCovarianceTruncate(output->covariance, COVAR_FRAC);
    450453        } else {
    451454            // Fake the convolution
    … …  
    559562                                                                                 "RENORM.STDEV"));
    560563
    561         if (!pmReadoutWeightRenormPixels(readout, maskBad, renormMean, renormStdev, rng)) {
     564        if (!pmReadoutVarianceRenormPixels(readout, maskBad, renormMean, renormStdev, rng)) {
    562565            psError(PS_ERR_UNKNOWN, false, "Unable to renormalise variances.");
    563566            psFree(output);
    … …  
    583586    psFree(bg);
    584587
    585 
    586588#if 0
    587589#define RADIUS 10                       // Radius of photometry

  • trunk/ppStack/src/ppStackThread.c

    r20711 r21366  
    3838        psFitsClose(stack->imageFits->data[i]);
    3939        psFitsClose(stack->maskFits->data[i]);
    40         psFitsClose(stack->weightFits->data[i]);
    41         stack->imageFits->data[i] = stack->maskFits->data[i] = stack->weightFits->data[i] = NULL;
     40        psFitsClose(stack->varianceFits->data[i]);
     41        stack->imageFits->data[i] = stack->maskFits->data[i] = stack->varianceFits->data[i] = NULL;
    4242    }
    4343    psFree(stack->imageFits);
    4444    psFree(stack->maskFits);
    45     psFree(stack->weightFits);
     45    psFree(stack->varianceFits);
    4646    return;
    4747}
    4848
    4949ppStackThreadData *ppStackThreadDataSetup(const psArray *cells, const psArray *imageNames,
    50                                           const psArray *maskNames, const psArray *weightNames,
     50                                          const psArray *maskNames, const psArray *varianceNames,
    5151                                          const pmConfig *config)
    5252{
    … …  
    5454    PS_ASSERT_ARRAYS_SIZE_EQUAL(cells, imageNames, NULL);
    5555    PS_ASSERT_ARRAYS_SIZE_EQUAL(cells, maskNames, NULL);
    56     PS_ASSERT_ARRAYS_SIZE_EQUAL(cells, weightNames, NULL);
     56    PS_ASSERT_ARRAYS_SIZE_EQUAL(cells, varianceNames, NULL);
    5757
    5858    ppStackThreadData *stack = psAlloc(sizeof(ppStackThreadData)); // Thread data, to return
    … …  
    6464    stack->imageFits  = psArrayAlloc(numInputs);
    6565    stack->maskFits   = psArrayAlloc(numInputs);
    66     stack->weightFits = psArrayAlloc(numInputs);
     66    stack->varianceFits = psArrayAlloc(numInputs);
    6767    for (int i = 0; i < numInputs; i++) {
    6868        if (!cells->data[i]) {
    … …  
    7373        psString imageResolved = pmConfigConvertFilename(imageNames->data[i], config, false, false);
    7474        psString maskResolved = pmConfigConvertFilename(maskNames->data[i], config, false, false);
    75         psString weightResolved = pmConfigConvertFilename(weightNames->data[i], config, false, false);
     75        psString varianceResolved = pmConfigConvertFilename(varianceNames->data[i], config, false, false);
    7676        stack->imageFits->data[i] = psFitsOpen(imageResolved, "r");
    7777        stack->maskFits->data[i] = psFitsOpen(maskResolved, "r");
    78         stack->weightFits->data[i] = psFitsOpen(weightResolved, "r");
     78        stack->varianceFits->data[i] = psFitsOpen(varianceResolved, "r");
    7979        psFree(imageResolved);
    8080        psFree(maskResolved);
    81         psFree(weightResolved);
    82         if (!stack->imageFits->data[i] || !stack->maskFits->data[i] || !stack->weightFits->data[i]) {
     81        psFree(varianceResolved);
     82        if (!stack->imageFits->data[i] || !stack->maskFits->data[i] || !stack->varianceFits->data[i]) {
    8383            psError(PS_ERR_UNKNOWN, false, "Unable to open convolved files %s, %s, %s",
    84                     (char*)imageNames->data[i], (char*)maskNames->data[i], (char*)weightNames->data[i]);
     84                    (char*)imageNames->data[i], (char*)maskNames->data[i], (char*)varianceNames->data[i]);
    8585            return false;
    8686        }
    … …  
    156156                // override the recorded last scan
    157157                ro->thisImageScan  = thread->firstScan;
    158                 ro->thisWeightScan = thread->firstScan;
     158                ro->thisVarianceScan = thread->firstScan;
    159159                ro->thisMaskScan   = thread->firstScan;
    160160                ro->lastImageScan  = thread->lastScan;
    161161                ro->lastMaskScan   = thread->lastScan;
    162                 ro->lastWeightScan = thread->lastScan;
     162                ro->lastVarianceScan = thread->lastScan;
    163163                ro->forceScan      = true;
    164164
    165165                psFits *imageFits  = stack->imageFits->data[i]; // FITS file for image
    166166                psFits *maskFits   = stack->maskFits->data[i]; // FITS file for mask
    167                 psFits *weightFits = stack->weightFits->data[i]; // FITS file for weight
     167                psFits *varianceFits = stack->varianceFits->data[i]; // FITS file for variance
    168168
    169169
    … …  
    189189                }
    190190
    191                 if (pmReadoutMoreWeight(ro, weightFits, 0, rows, config)) {
     191                if (pmReadoutMoreVariance(ro, varianceFits, 0, rows, config)) {
    192192                    keepReading = true;
    193                     if (!pmReadoutReadChunkWeight(ro, weightFits, 0, rows, overlap, config)) {
    194                         psError(PS_ERR_IO, false, "Unable to read chunk %d for file PPSTACK.INPUT.WEIGHT %d",
     193                    if (!pmReadoutReadChunkVariance(ro, varianceFits, 0, rows, overlap, config)) {
     194                        psError(PS_ERR_IO, false,
     195                                "Unable to read chunk %d for file PPSTACK.INPUT.VARIANCE %d",
    195196                                numChunk, i);
    196197                        *status = false;
Note: See TracChangeset for help on using the changeset viewer.