Пример #1
0
    def addSnaps(self, snap0, snap1):
        """Add two snap exposures together, returning a new exposure

        @param[in] snap0 snap exposure 0
        @param[in] snap1 snap exposure 1
        @return combined exposure
        """
        self.log.info("snapCombine addSnaps")

        combinedExp = snap0.Factory(snap0, True)
        combinedMi = combinedExp.getMaskedImage()
        combinedMi.set(0)

        weightMap = combinedMi.getImage().Factory(combinedMi.getBBox())
        weight = 1.0
        badPixelMask = afwImage.Mask.getPlaneBitMask(self.config.badMaskPlanes)
        addToCoadd(combinedMi, weightMap, snap0.getMaskedImage(), badPixelMask, weight)
        addToCoadd(combinedMi, weightMap, snap1.getMaskedImage(), badPixelMask, weight)

        # pre-scaling the weight map instead of post-scaling the combinedMi saves a bit of time
        # because the weight map is a simple Image instead of a MaskedImage
        weightMap *= 0.5  # so result is sum of both images, instead of average
        combinedMi /= weightMap
        setCoaddEdgeBits(combinedMi.getMask(), weightMap)

        # note: none of the inputs has a valid PhotoCalib object, so that is not touched
        # Filter was already copied

        combinedMetadata = combinedExp.getMetadata()
        metadata0 = snap0.getMetadata()
        metadata1 = snap1.getMetadata()
        self.fixMetadata(combinedMetadata, metadata0, metadata1)

        return combinedExp
Пример #2
0
def simpleAdd(exp0, exp1, badPixelMask):
    """Add two exposures, avoiding bad pixels
    """
    imArr0, maskArr0, varArr0 = exp0.getMaskedImage().getArrays()
    imArr1, maskArr1, varArr1 = exp1.getMaskedImage().getArrays()
    expRes = exp0.Factory(exp0, True)
    miRes = expRes.getMaskedImage()
    imArrRes, maskArrRes, varArrRes = miRes.getArrays()

    weightMap = afwImage.ImageF(exp0.getDimensions())
    weightArr = weightMap.getArray()

    good0 = numpy.bitwise_and(maskArr0, badPixelMask) == 0
    good1 = numpy.bitwise_and(maskArr1, badPixelMask) == 0

    imArrRes[:, :] = numpy.where(good0, imArr0, 0) + numpy.where(
        good1, imArr1, 0)
    varArrRes[:, :] = numpy.where(good0, varArr0, 0) + numpy.where(
        good1, varArr1, 0)
    maskArrRes[:, :] = numpy.bitwise_or(numpy.where(good0, maskArr0, 0),
                                        numpy.where(good1, maskArr1, 0))
    weightArr[:, :] = numpy.where(good0, 1, 0) + numpy.where(good1, 1, 0)

    miRes /= weightMap
    miRes *= 2  # want addition, not mean, where both pixels are valid

    setCoaddEdgeBits(miRes.getMask(), weightMap)

    return expRes
Пример #3
0
    def addSnaps(self, snap0, snap1):
        """Add two snap exposures together, returning a new exposure
        
        @param[in] snap0 snap exposure 0
        @param[in] snap1 snap exposure 1
        @return combined exposure
        """
        self.log.info("snapCombine addSnaps")
        
        combinedExp = snap0.Factory(snap0, True)
        combinedMi = combinedExp.getMaskedImage()
        combinedMi.set(0)
        
        weightMap = combinedMi.getImage().Factory(combinedMi.getBBox(afwImage.PARENT))
        weight = 1.0
        badPixelMask = afwImage.MaskU.getPlaneBitMask(self.config.badMaskPlanes)
        addToCoadd(combinedMi, weightMap, snap0.getMaskedImage(), badPixelMask, weight)
        addToCoadd(combinedMi, weightMap, snap1.getMaskedImage(), badPixelMask, weight)

        # pre-scaling the weight map instead of post-scaling the combinedMi saves a bit of time
        # because the weight map is a simple Image instead of a MaskedImage
        weightMap *= 0.5 # so result is sum of both images, instead of average
        combinedMi /= weightMap
        setCoaddEdgeBits(combinedMi.getMask(), weightMap)
        
        # note: none of the inputs has a valid Calib object, so that is not touched
        # Filter was already copied
        
        combinedMetadata = combinedExp.getMetadata()
        metadata0 = snap0.getMetadata()
        metadata1 = snap1.getMetadata()
        self.fixMetadata(combinedMetadata, metadata0, metadata1)
        
        return combinedExp
    def testRandomMap(self):
        """Test setCoaddEdgeBits using a random depth map
        """
        imDim = afwGeom.Extent2I(50, 55)
        coaddMask = afwImage.MaskU(imDim)

        numpy.random.seed(12345)
        depthMapArray = numpy.random.randint(0, 3, list((imDim[1], imDim[0]))).astype(numpy.uint16)
        depthMap = afwImage.makeImageFromArray(depthMapArray)

        refCoaddMaskArray = coaddMask.getArray()
        edgeMask = afwImage.MaskU.getPlaneBitMask("NO_DATA")
        refCoaddMaskArray |= numpy.array(numpy.where(depthMapArray > 0, 0, edgeMask),
            dtype=refCoaddMaskArray.dtype)

        coaddUtils.setCoaddEdgeBits(coaddMask, depthMap)
        coaddMaskArray = coaddMask.getArray()
        if numpy.any(refCoaddMaskArray != coaddMaskArray):
            errMsgList = (
                "Coadd mask does not match reference:",
                "computed=  %s" % (coaddMaskArray,),
                "reference= %s" % (refCoaddMaskArray,),
            )
            errMsg = "\n".join(errMsgList)
            self.fail(errMsg)
Пример #5
0
def simpleAdd(exp0, exp1, badPixelMask):
    """Add two exposures, avoiding bad pixels
    """
    imArr0, maskArr0, varArr0 = exp0.getMaskedImage().getArrays()
    imArr1, maskArr1, varArr1 = exp1.getMaskedImage().getArrays()
    expRes = exp0.Factory(exp0, True)
    miRes = expRes.getMaskedImage()
    imArrRes, maskArrRes, varArrRes = miRes.getArrays()

    weightMap = afwImage.ImageF(exp0.getDimensions())
    weightArr = weightMap.getArray()

    good0 = np.bitwise_and(maskArr0, badPixelMask) == 0
    good1 = np.bitwise_and(maskArr1, badPixelMask) == 0

    imArrRes[:, :] = np.where(good0,  imArr0, 0) + np.where(good1,  imArr1, 0)
    varArrRes[:, :] = np.where(good0, varArr0, 0) + np.where(good1, varArr1, 0)
    maskArrRes[:, :] = np.bitwise_or(np.where(good0, maskArr0, 0), np.where(good1, maskArr1, 0))
    weightArr[:, :] = np.where(good0, 1, 0) + np.where(good1, 1, 0)

    miRes /= weightMap
    miRes *= 2  # want addition, not mean, where both pixels are valid

    setCoaddEdgeBits(miRes.getMask(), weightMap)

    return expRes
Пример #6
0
    def run(self,
            identMatrix,
            butler,
            ra,
            dec,
            scale,
            xSize,
            ySize,
            ignore=False):
        """Warp and stack images

        @param[in] identMatrix Matrix of warp identifiers
        @param[in] butler Data butler
        @param[in] ra Right Ascension (radians) of skycell centre
        @param[in] dec Declination (radians) of skycell centre
        @param[in] scale Scale (arcsec/pixel) of skycell
        @param[in] xSize Size in x
        @param[in] ySize Size in y
        @param[in] ignore Ignore missing files?
        @output Stacked exposure
        """
        assert identMatrix, "No identMatrix provided"

        skycell = self.skycell(ra, dec, scale, xSize, ySize)

        coaddDim = afwGeom.Extent2I(xSize, ySize)
        coadd = afwImage.ExposureF(coaddDim, skycell.getWcs())
        weight = afwImage.ImageF(coaddDim)

        badpix = afwImage.MaskU.getPlaneBitMask(
            "EDGE")  # Allow everything else through
        for identList in identMatrix:
            warp = self.warp(identList, butler, skycell, ignore=ignore)
            # XXX Save for later?

            coaddUtils.addToCoadd(coadd.getMaskedImage(), weight,
                                  warp.getMaskedImage(), badpix, 1.0)

        coaddUtils.setCoaddEdgeBits(coadd.getMaskedImage().getMask(), weight)

        coaddImage = coadd.getMaskedImage()
        coaddImage /= weight

        # XXX Coadd has NANs where weight=0

        return coadd
    def testRandomMap(self):
        """Test setCoaddEdgeBits using a random depth map
        """
        imDim = afwGeom.Extent2I(50, 55)
        coaddMask = afwImage.Mask(imDim)

        np.random.seed(12345)
        depthMapArray = np.random.randint(0, 3, list((imDim[1], imDim[0]))).astype(np.uint16)
        depthMap = afwImage.makeImageFromArray(depthMapArray)

        refCoaddMask = afwImage.Mask(imDim)
        refCoaddMaskArray = refCoaddMask.getArray()
        edgeMask = afwImage.Mask.getPlaneBitMask("NO_DATA")
        refCoaddMaskArray |= np.array(np.where(depthMapArray > 0, 0, edgeMask),
                                      dtype=refCoaddMaskArray.dtype)

        coaddUtils.setCoaddEdgeBits(coaddMask, depthMap)
        self.assertMasksEqual(coaddMask, refCoaddMask)
Пример #8
0
    def testRandomMap(self):
        """Test setCoaddEdgeBits using a random depth map
        """
        imDim = geom.Extent2I(50, 55)
        coaddMask = afwImage.Mask(imDim)

        np.random.seed(12345)
        depthMapArray = np.random.randint(0, 3, list(
            (imDim[1], imDim[0]))).astype(np.uint16)
        depthMap = afwImage.makeImageFromArray(depthMapArray)

        refCoaddMask = afwImage.Mask(imDim)
        refCoaddMaskArray = refCoaddMask.getArray()
        edgeMask = afwImage.Mask.getPlaneBitMask("NO_DATA")
        refCoaddMaskArray |= np.array(np.where(depthMapArray > 0, 0, edgeMask),
                                      dtype=refCoaddMaskArray.dtype)

        coaddUtils.setCoaddEdgeBits(coaddMask, depthMap)
        self.assertMasksEqual(coaddMask, refCoaddMask)
Пример #9
0
    def getCoadd(self):
        """Get the coadd exposure for all exposures you have coadded so far

        If all exposures in this coadd have the same-named filter then that
        filter is set in the coadd. Otherwise the coadd will have the default
        unknown filter.

        @warning: the Calib is not be set.
        """
        # make a deep copy so I can scale it
        coaddMaskedImage = self._coadd.getMaskedImage()
        scaledMaskedImage = coaddMaskedImage.Factory(coaddMaskedImage, True)

        # set the edge pixels
        coadd_utils.setCoaddEdgeBits(scaledMaskedImage.getMask(),
                                     self._weightMap)

        # scale non-edge pixels by weight map
        scaledMaskedImage /= self._weightMap

        scaledExposure = afwImage.makeExposure(scaledMaskedImage, self._wcs)
        if len(self._filterDict) == 1:
            scaledExposure.setFilter(list(self._filterDict.values())[0])
        return scaledExposure
Пример #10
0
    def assemble(self, skyInfo, tempExpRefList, imageScalerList, weightList, bgInfoList=None, 
                 altMaskList=None, doClip=False, mask=None):
        """Assemble a coadd from input warps

        The assembly is performed over small areas on the image at a time, to
        conserve memory usage.

        @param skyInfo: Patch geometry information, from getSkyInfo
        @param tempExpRefList: List of data references to tempExp
        @param imageScalerList: List of image scalers
        @param weightList: List of weights
        @param bgInfoList: List of background data from background matching, or None
        @param altMaskList: List of alternate masks to use rather than those stored with tempExp, or None
        @param doClip: Use clipping when codding?
        @param mask: Mask to ignore when coadding
        @return coadded exposure
        """
        tempExpName = self.getTempExpDatasetName()
        self.log.info("Assembling %s %s" % (len(tempExpRefList), tempExpName))
        if mask is None:
            mask = self.getBadPixelMask()

        statsCtrl = afwMath.StatisticsControl()
        statsCtrl.setNumSigmaClip(self.config.sigmaClip)
        statsCtrl.setNumIter(self.config.clipIter)
        statsCtrl.setAndMask(mask)
        statsCtrl.setNanSafe(True)
        statsCtrl.setWeighted(True)
        statsCtrl.setCalcErrorFromInputVariance(True)
        for plane, threshold in self.config.maskPropagationThresholds.items():
            bit = afwImage.MaskU.getMaskPlane(plane)
            statsCtrl.setMaskPropagationThreshold(bit, threshold)

        if doClip:
            statsFlags = afwMath.MEANCLIP
        else:
            statsFlags = afwMath.MEAN

        if bgInfoList is None:
            bgInfoList = [None]*len(tempExpRefList)

        if altMaskList is None:
            altMaskList = [None]*len(tempExpRefList)

        coaddExposure = afwImage.ExposureF(skyInfo.bbox, skyInfo.wcs)
        coaddExposure.setCalib(self.scaleZeroPoint.getCalib())
        coaddExposure.getInfo().setCoaddInputs(self.inputRecorder.makeCoaddInputs())
        self.assembleMetadata(coaddExposure, tempExpRefList, weightList)
        coaddMaskedImage = coaddExposure.getMaskedImage()
        subregionSizeArr = self.config.subregionSize
        subregionSize = afwGeom.Extent2I(subregionSizeArr[0], subregionSizeArr[1])
        for subBBox in _subBBoxIter(skyInfo.bbox, subregionSize):
            try:
                self.assembleSubregion(coaddExposure, subBBox, tempExpRefList, imageScalerList,
                                       weightList, bgInfoList, altMaskList, statsFlags, statsCtrl)
            except Exception as e:
                self.log.fatal("Cannot compute coadd %s: %s" % (subBBox, e,))

        coaddUtils.setCoaddEdgeBits(coaddMaskedImage.getMask(), coaddMaskedImage.getVariance())

        return coaddExposure
Пример #11
0
        coaddExposure = afwImage.ExposureF(skyInfo.bbox, skyInfo.wcs)
        coaddExposure.setCalib(self.scaleZeroPoint.getCalib())
        coaddExposure.getInfo().setCoaddInputs(self.inputRecorder.makeCoaddInputs())
        self.assembleMetadata(coaddExposure, tempExpRefList, weightList)
        coaddMaskedImage = coaddExposure.getMaskedImage()
        subregionSizeArr = self.config.subregionSize
        subregionSize = afwGeom.Extent2I(subregionSizeArr[0], subregionSizeArr[1])
        for subBBox in _subBBoxIter(skyInfo.bbox, subregionSize):
            try:
                self.assembleSubregion(coaddExposure, subBBox, tempExpRefList, imageScalerList,
                                       weightList, bgInfoList, statsFlags, statsCtrl)
            except Exception, e:
                self.log.fatal("Cannot compute coadd %s: %s" % (subBBox, e,))

        coaddUtils.setCoaddEdgeBits(coaddMaskedImage.getMask(), coaddMaskedImage.getVariance())

        return coaddExposure

    def assembleMetadata(self, coaddExposure, tempExpRefList, weightList):
        """Set the metadata for the coadd

        This basic implementation simply sets the filter from the
        first input.

        @param coaddExposure: The target image for the coadd
        @param tempExpRefList: List of data references to tempExp
        @param weightList: List of weights
        """
        tempExpName = self.getTempExpDatasetName()
        # We load a single pixel of each coaddTempExp, because we just want to get at the metadata
Пример #12
0
def main():
    # try out one exposure
    #visits = ["0288935","0288976"] #,"0289893","0289913","0289931","0289614","0289818","0289820", "0289850","0289851","0289871","0289892", "0288935","0288976","0289016","0289056","0289161","0289202","0289243","0289284","0289368","0289409","0289450","0289493","0289573","0289656"]
    visits = ["0288976", "0288935"]
    ccds = []
    exit(0)
    for i in range(1, 61):
        ccds.append(i)

    filterName = 'g'

    DATA_PATH = "/root/extra_home/lsst_data/"
    #spathprefix = "/home/dongfang/download/lsst_data/"
    spathprefix = DATA_PATH + "raw/"
    #calexpsloc = "/home/dongfang/download/lsst_data/calexps/"
    calexpsloc = DATA_PATH + "calexps/"
    #coaddloc = "/home/dongfang/download/lsst_data/coadds/"
    coaddloc = DATA_PATH + "coadds/"
    #mergecoaddloc = "/home/dongfang/download/lsst_data/merge/"
    mergecoaddloc = DATA_PATH + "merge/"

    # Characterize Image
    charImageConfig = CharacterizeImageConfig()
    charImage = CharacterizeImageTask()

    calibrateConfig = CalibrateConfig(doPhotoCal=False, doAstrometry=False)
    calibrateTask = CalibrateTask(config=calibrateConfig)

    makeCTEConfig = MakeCoaddTempExpConfig()
    makeCTE = MakeCoaddTempExpTask(config=makeCTEConfig)

    newSkyMapConfig = skymap.discreteSkyMap.DiscreteSkyMapConfig(
        projection='STG',
        decList=[-4.9325280994132905],
        patchInnerDimensions=[2000, 2000],
        radiusList=[4.488775723429071],
        pixelScale=0.333,
        rotation=0.0,
        patchBorder=100,
        raList=[154.10660740464786],
        tractOverlap=0.0)

    hits_skymap = skymap.discreteSkyMap.DiscreteSkyMap(config=newSkyMapConfig)
    tract = hits_skymap[0]
    coaddTempDict = {}
    calibResDict = {}
    f = open("log.txt", 'wb')
    start = datetime.datetime.now()
    #process CCDs to create calexps.
    for v in visits:
        for ccd in ccds:
            visit = int(v)
            filename = "instcal" + v + "." + str(ccd) + ".fits"
            calexpfn = calexpsloc + v + "/" + filename
            source = spathprefix + v + "/" + filename
            exposure = afwImg.ExposureF(source)

            try:
                # Characterize Image
                charRes = charImage.characterize(exposure,
                                                 exposureIdInfo=None,
                                                 background=None)
            except:
                f.write("DFZ DEBUG at charRes: errors in visit " + v +
                        ", ccd " + str(ccd) + "\n")

            try:
                # Caliberate Image
                calibRes = calibrateTask.calibrate(
                    charRes.exposure,
                    exposureIdInfo=None,
                    background=charRes.background,
                    icSourceCat=None)
            except:
                f.write("DFZ DEBUG at calibRes: errors in visit " + v +
                        ", ccd " + str(ccd) + "\n")

            try:
                #write out calexps
                calibRes.exposure.writeFits(calexpfn)
                #calbresDict.append((v,ccd),calibRes)
            except:
                f.write("DFZ DEBUG at calibRes.exposure: errors in visit " +
                        v + ", ccd " + str(ccd) + "\n")

    end = datetime.datetime.now()
    d = end - start

    f.write("time for creating calexps: ")
    f.write(str(d.total_seconds()))
    f.write("\n")

    #time for creating co-add tempexps.
    start = datetime.datetime.now()

    # map calexps to patch-ids
    visit = visits[0]
    ccdsPerPatch = []

    for ccd in ccds:
        filename = "instcal" + visit + "." + str(ccd) + ".fits"
        source = calexpsloc + visit + "/" + filename
        exposure = afwImg.ExposureF(source)
        bbox = exposure.getBBox()
        wcs = exposure.getWcs()
        corners = bbox.getCorners()
        xIndexMax, yIndexMax = tract.findPatch(
            wcs.pixelToSky(corners[0][0], corners[0][1])).getIndex()
        xIndexMin, yIndexMin = tract.findPatch(
            wcs.pixelToSky(corners[2][0], corners[2][1])).getIndex()
        yy = range(yIndexMin, yIndexMax + 1)
        xx = range(xIndexMin, xIndexMax + 1)

        for yIdx in yy:
            for xIdx in xx:
                ccdsPerPatch.append((ccd, (xIdx, yIdx)))
        print len(ccdsPerPatch)
    #import cPickle
    #cPickle.dump(open("ccdsinpatch.p",'wb'),ccdsPerPatch)

    # import cPickle
    # f = open("ccdsInPatch.p",'wb')
    # cPickle.dump(ccdsInPatch,f)
    #import cPickle

    #ccdsInPatch = cPickle.load(open("ccdsInPatch.p",'rb'))
    df = pd.DataFrame(ccdsPerPatch)

    dfgby = df.groupby(1)
    makeCTEConfig = MakeCoaddTempExpConfig()
    makeCTE = MakeCoaddTempExpTask(config=makeCTEConfig)
    coaddTempExpDict = {}
    for visit in visits:
        for a in dfgby.indices:
            coaddTempExpDict[a] = {}
            xInd = a[0]
            yInd = a[1]
            skyInfo = getSkyInfo(hits_skymap, xInd, yInd)
            v = int(visit)

            coaddTempExp = afwImage.ExposureF(skyInfo.bbox, skyInfo.wcs)
            coaddTempExp.getMaskedImage().set(
                numpy.nan, afwImage.MaskU.getPlaneBitMask("NO_DATA"),
                numpy.inf)
            totGoodPix = 0
            didSetMetadata = False
            modelPsf = makeCTEConfig.modelPsf.apply(
            ) if makeCTEConfig.doPsfMatch else None
            setInputRecorder = False

            for b in dfgby.get_group(a)[0].ravel():
                print a
                print b
                if not setInputRecorder:
                    ccdsinPatch = len(dfgby.get_group(a)[0].ravel())
                    try:
                        inputRecorder = makeCTE.inputRecorder.makeCoaddTempExpRecorder(
                            v, ccdsinPatch)
                    except:
                        f.write("DFZ DEBUG at inputRecorder\n")
                    setInputRecorder = True
                numGoodPix = 0
                ccd = b
                filename = "instcal" + visit + "." + str(ccd) + ".fits"
                source = calexpsloc + visit + "/" + filename
                calExp = afwImg.ExposureF(source)
                ccdId = calExp.getId()
                warpedCcdExp = makeCTE.warpAndPsfMatch.run(
                    calExp,
                    modelPsf=modelPsf,
                    wcs=skyInfo.wcs,
                    maxBBox=skyInfo.bbox).exposure
                if didSetMetadata:
                    mimg = calExp.getMaskedImage()
                    mimg *= (coaddTempExp.getCalib().getFluxMag0()[0] /
                             calExp.getCalib().getFluxMag0()[0])
                    del mimg

                numGoodPix = coaddUtils.copyGoodPixels(
                    coaddTempExp.getMaskedImage(),
                    warpedCcdExp.getMaskedImage(), makeCTE.getBadPixelMask())
                totGoodPix += numGoodPix
                if numGoodPix > 0 and not didSetMetadata:
                    coaddTempExp.setCalib(warpedCcdExp.getCalib())
                    coaddTempExp.setFilter(warpedCcdExp.getFilter())
                    didSetMetadata = True

                inputRecorder.addCalExp(calExp, ccdId, numGoodPix)

        ##### End loop over ccds here:
            inputRecorder.finish(coaddTempExp, totGoodPix)
            if totGoodPix > 0 and didSetMetadata:
                coaddTempExp.setPsf(
                    modelPsf if makeCTEConfig.doPsfMatch else CoaddPsf(
                        inputRecorder.coaddInputs.ccds, skyInfo.wcs))

            coaddTempExpDict[a][v] = coaddTempExp
            coaddfilename = coaddloc + visit + "/" + "instcal" + visit + "." + str(
                xInd) + "_" + str(yInd) + ".fits"
            coaddTempExp.writeFits(coaddfilename)

    end = datetime.datetime.now()
    d = end - start
    f.write("time for creating co-add tempexps:\n ")
    f.write(str(d.total_seconds()))
    f.write("\n")

    #DFZ: stop here
    exit(0)

    start = datetime.datetime.now()

    config = AssembleCoaddConfig()
    assembleTask = AssembleCoaddTask(config=config)
    mergcoadds = {}
    for a in dfgby.indices:
        ccdsinPatch = len(dfgby.get_group(a)[0].ravel())
        xInd = a[0]
        yInd = a[1]

        imageScalerRes = prepareInputs(coaddTempExpDict[a].values(),
                                       coaddTempExpDict[a].keys(),
                                       assembleTask)
        mask = None
        doClip = False
        if mask is None:
            mask = assembleTask.getBadPixelMask()

        statsCtrl = afwMath.StatisticsControl()
        statsCtrl.setNumSigmaClip(assembleTask.config.sigmaClip)
        statsCtrl.setNumIter(assembleTask.config.clipIter)
        statsCtrl.setAndMask(mask)
        statsCtrl.setNanSafe(True)
        statsCtrl.setWeighted(True)
        statsCtrl.setCalcErrorFromInputVariance(True)
        for plane, threshold in assembleTask.config.maskPropagationThresholds.items(
        ):
            bit = afwImage.MaskU.getMaskPlane(plane)
            statsCtrl.setMaskPropagationThreshold(bit, threshold)

        if doClip:
            statsFlags = afwMath.MEANCLIP
        else:
            statsFlags = afwMath.MEAN

        coaddExposure = afwImage.ExposureF(skyInfo.bbox, skyInfo.wcs)
        coaddExposure.setCalib(assembleTask.scaleZeroPoint.getCalib())
        coaddExposure.getInfo().setCoaddInputs(
            assembleTask.inputRecorder.makeCoaddInputs())

        #remember to set metadata if you want any hope of running detection and measurement on this coadd:
        #self.assembleMetadata(coaddExposure, tempExpRefList, weightList)

        #most important thing is the psf
        coaddExposure.setFilter(coaddTempExpDict[a].values()[0].getFilter())
        coaddInputs = coaddExposure.getInfo().getCoaddInputs()

        for tempExp, weight in zip(coaddTempExpDict[a].values(),
                                   imageScalerRes.weightList):
            assembleTask.inputRecorder.addVisitToCoadd(coaddInputs, tempExp,
                                                       weight)

        #takes numCcds as argument

        coaddInputs.ccds.reserve(ccdsinPatch)
        coaddInputs.visits.reserve(len(imageScalerRes.dataIdList))
        psf = measAlg.CoaddPsf(coaddInputs.ccds, coaddExposure.getWcs())
        coaddExposure.setPsf(psf)

        maskedImageList = afwImage.vectorMaskedImageF()
        coaddMaskedImage = coaddExposure.getMaskedImage()
        for dataId, imageScaler, exposure in zip(
                imageScalerRes.dataIdList, imageScalerRes.imageScalerList,
                coaddTempExpDict[a].values()):
            print dataId, imageScaler, exposure
            maskedImage = exposure.getMaskedImage()
            imageScaler.scaleMaskedImage(maskedImage)
            maskedImageList.append(maskedImage)

        maskedImage = afwMath.statisticsStack(maskedImageList, statsFlags,
                                              statsCtrl,
                                              imageScalerRes.weightList)

        coaddMaskedImage.assign(maskedImage, skyInfo.bbox)
        coaddUtils.setCoaddEdgeBits(coaddMaskedImage.getMask(),
                                    coaddMaskedImage.getVariance())

        # write out Coadd!
        mergefilename = mergecoaddloc + str(xInd) + "_" + str(yInd) + ".fits"
        mergcoadds[a] = coaddExposure
        coaddExposure.writeFits(mergefilename)

    end = datetime.datetime.now()
    d = end - start
    f.write("time for creating merged co-adds:\n ")
    f.write(str(d.total_seconds()))
    f.write("\n")

    start = datetime.datetime.now()
    config = DetectCoaddSourcesConfig()
    detectCoaddSources = DetectCoaddSourcesTask(config=config)
    for a in dfgby.indices:

        # Detect on Coadd
        exp = mergcoadds[a]
        detRes = detectCoaddSources.runDetection(exp, idFactory=None)

    end = datetime.datetime.now()
    d = end - start
    f.write("time for detecting sources:\n ")
    f.write(str(d.total_seconds()))
    f.close()
            print "  Compute coadd component"
            coaddComponent = coaddKaiser.CoaddComponent(exposure, psfKernel, normalizePsf)

            print "  Divide exposure by sigma squared = %s" % (coaddComponent.getSigmaSq(),)
            blurredExposure = coaddComponent.getBlurredExposure()
            blurredMaskedImage = blurredExposure.getMaskedImage()
            sigmaSq = coaddComponent.getSigmaSq()
            if saveImages:
                blurredExposure.writeFits("blurred%s" % (fileName,))
            blurredMaskedImage /= sigmaSq
            if saveImages:
                blurredExposure.writeFits("scaledBlurred%s" % (fileName,))
            
            print "  Remap blurred exposure to match coadd WCS"
            remappedBlurredMaskedImage = afwImage.MaskedImageD(
                coaddExposure.getWidth(), coaddExposure.getHeight())
            remappedBlurredExposure = afwImage.ExposureD(remappedBlurredMaskedImage, coaddWcs)
            if saveImages:
                remappedBlurredExposure.writeFits("remappedBlurred%s" % (fileName,))
            nGoodPix = afwMath.warpExposure(remappedBlurredExposure, blurredExposure,
                afwMath.LanczosWarpingKernel(3))
            nPix = coaddExposure.getWidth() * coaddExposure.getHeight()
            print "  Remapped image has %d good pixels (%0.0f %%)" % (nGoodPix, 100 * nGoodPix / float(nPix))

            print "  Add remapped blurred exposure to coadd and save updated coadd exposure"
            coaddUtils.addToCoadd(coaddMaskedImage, depthMap, remappedBlurredExposure.getMaskedImage(),
                coaddMask)
            coaddExposure.writeFits(outName)
            depthMap.writeFits(depthOutName)
    coaddUtils.setCoaddEdgeBits(coaddMaskedImage.getMask(), depthMap)
    coaddExposure.writeFits(outName)    
Пример #14
0
def mergeCoadd(a, dfgby_raveled, coaddTempExpDict_a, hits_skymap):
    from lsst.pipe.tasks.assembleCoadd import AssembleCoaddTask, AssembleCoaddConfig
    import lsst.afw.math as afwMath
    import lsst.afw.image as afwImage
    import lsst.coadd.utils as coaddUtils
    import lsst.meas.algorithms as measAlg

    config = AssembleCoaddConfig()
    assembleTask = AssembleCoaddTask(config=config)
    ccdsinPatch = len(dfgby_raveled)  # len(dfgby.get_group(a)[0].ravel())
    xInd = a[0]
    yInd = a[1]

    print xInd, yInd
    if xInd == 0 and yInd == 0:
        return None

    imageScalerRes = prepareInputs(coaddTempExpDict_a.values(),
                                   coaddTempExpDict_a.keys(), assembleTask)
    if imageScalerRes is None:
        return None

    mask = assembleTask.getBadPixelMask()
    statsCtrl = afwMath.StatisticsControl()
    statsCtrl.setNumSigmaClip(assembleTask.config.sigmaClip)
    statsCtrl.setNumIter(assembleTask.config.clipIter)
    statsCtrl.setAndMask(mask)
    statsCtrl.setNanSafe(True)
    statsCtrl.setWeighted(True)
    statsCtrl.setCalcErrorFromInputVariance(True)
    for plane, threshold in assembleTask.config.maskPropagationThresholds.items(
    ):
        bit = afwImage.MaskU.getMaskPlane(plane)
        statsCtrl.setMaskPropagationThreshold(bit, threshold)

    statsFlags = afwMath.MEAN

    skyInfo = getSkyInfo(hits_skymap, xInd, yInd)

    coaddExposure = afwImage.ExposureF(skyInfo.bbox, skyInfo.wcs)
    coaddExposure.setCalib(assembleTask.scaleZeroPoint.getCalib())
    coaddExposure.getInfo().setCoaddInputs(
        assembleTask.inputRecorder.makeCoaddInputs())

    # remember to set metadata if you want any hope of running detection and measurement on this coadd:
    # self.assembleMetadata(coaddExposure, tempExpRefList, weightList)

    # most important thing is the psf
    coaddExposure.setFilter(coaddTempExpDict_a.values()[0].getFilter())
    coaddInputs = coaddExposure.getInfo().getCoaddInputs()

    for tempExp, weight in zip(coaddTempExpDict_a.values(),
                               imageScalerRes.weightList):
        assembleTask.inputRecorder.addVisitToCoadd(coaddInputs, tempExp,
                                                   weight)

    # takes numCcds as argument
    coaddInputs.ccds.reserve(ccdsinPatch)
    coaddInputs.visits.reserve(len(imageScalerRes.dataIdList))
    psf = measAlg.CoaddPsf(coaddInputs.ccds, coaddExposure.getWcs())
    coaddExposure.setPsf(psf)

    maskedImageList = afwImage.vectorMaskedImageF()
    coaddMaskedImage = coaddExposure.getMaskedImage()
    for dataId, imageScaler, exposure in zip(imageScalerRes.dataIdList,
                                             imageScalerRes.imageScalerList,
                                             coaddTempExpDict_a.values()):
        print dataId, imageScaler, exposure
        maskedImage = exposure.getMaskedImage()
        imageScaler.scaleMaskedImage(maskedImage)
        maskedImageList.append(maskedImage)

    maskedImage = afwMath.statisticsStack(maskedImageList, statsFlags,
                                          statsCtrl, imageScalerRes.weightList)

    coaddMaskedImage.assign(maskedImage, skyInfo.bbox)
    coaddUtils.setCoaddEdgeBits(coaddMaskedImage.getMask(),
                                coaddMaskedImage.getVariance())
    return coaddExposure
Пример #15
0
                maskedImageView <<= afwImage.MaskedImageF(
                    expMeta.path, 0, dumPS, overlapBBox, afwImage.PARENT)
            maskedImageList.append(maskedImage)
            weightList.append(expMeta.weight)
        try:
            coaddSubregion = afwMath.statisticsStack(maskedImageList,
                                                     afwMath.MEANCLIP,
                                                     statsCtrl, weightList)

            coaddView <<= coaddSubregion
        except Exception, e:
            print "Outlier rejection failed; setting EDGE mask: %s" % (e, )
            raise
            # setCoaddEdgeBits does this later, so no need to do it here

    coaddUtils.setCoaddEdgeBits(coaddMaskedImage.getMask(),
                                coaddMaskedImage.getVariance())

    return coaddExposure


if __name__ == "__main__":
    algName = "outlierRejectedCoadd"
    pexLog.Trace.setVerbosity('lsst.coadd', 3)
    pexLog.Trace.setVerbosity('lsst.ip.diffim', 1)

    parser = lsst.pipette.coaddOptions.CoaddOptionParser()
    parser.add_option(
        "--fwhm",
        dest="fwhm",
        type="float",
        default=0.0,
            blurredMaskedImage = blurredExposure.getMaskedImage()
            sigmaSq = coaddComponent.getSigmaSq()
            if saveImages:
                blurredExposure.writeFits("blurred%s" % (fileName, ))
            blurredMaskedImage /= sigmaSq
            if saveImages:
                blurredExposure.writeFits("scaledBlurred%s" % (fileName, ))

            print "  Remap blurred exposure to match coadd WCS"
            remappedBlurredMaskedImage = afwImage.MaskedImageD(
                coaddExposure.getWidth(), coaddExposure.getHeight())
            remappedBlurredExposure = afwImage.ExposureD(
                remappedBlurredMaskedImage, coaddWcs)
            if saveImages:
                remappedBlurredExposure.writeFits("remappedBlurred%s" %
                                                  (fileName, ))
            nGoodPix = afwMath.warpExposure(remappedBlurredExposure,
                                            blurredExposure,
                                            afwMath.LanczosWarpingKernel(3))
            nPix = coaddExposure.getWidth() * coaddExposure.getHeight()
            print "  Remapped image has %d good pixels (%0.0f %%)" % (
                nGoodPix, 100 * nGoodPix / float(nPix))

            print "  Add remapped blurred exposure to coadd and save updated coadd exposure"
            coaddUtils.addToCoadd(coaddMaskedImage, depthMap,
                                  remappedBlurredExposure.getMaskedImage(),
                                  coaddMask)
            coaddExposure.writeFits(outName)
            depthMap.writeFits(depthOutName)
    coaddUtils.setCoaddEdgeBits(coaddMaskedImage.getMask(), depthMap)
    coaddExposure.writeFits(outName)