IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

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.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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);
Note: See TracChangeset for help on using the changeset viewer.