lsst.meas.base.noiseReplacer.NoiseReplacer Class Reference

Class that handles replacing sources with noise during measurement. More...

Inheritance diagram for lsst.meas.base.noiseReplacer.NoiseReplacer:

Public Member Functions
def	__init__
	Initialize the NoiseReplacer. More...
def	insertSource
	Insert the heavy footprint of a given source into the exposure. More...
def	removeSource
	Remove the heavy footprint of a given source and replace with previous noise. More...
def	end
	End the NoiseReplacer. More...
def	getNoiseGenerator
	Generate noise image using parameters given. More...

Public Attributes
	noiseSource
	noiseOffset
	noiseSeedMultiplier
	noiseGenMean
	noiseGenStd
	log
	exposure
	footprints
	removeplanes
	otherbitmask
	heavies
	heavyNoise
	FIXME: the heavy footprint includes the mask and variance planes, which we shouldn't need (I don't think we ever want to modify them in the input image). More...

Static Public Attributes
	ConfigClass = NoiseReplacerConfig

Detailed Description

Class that handles replacing sources with noise during measurement.

When measuring a source (or the children associated with a parent source), this class is used to replace its neighbors with noise, using the deblender's definition of the sources as stored in HeavyFootprints attached to the SourceRecords. The algorithm works as follows:

• We start by replacing all pixels that are in source Footprints with artificially generated noise (init).
• When we are about to measure a particular source, we add it back in, by inserting that source's HeavyFootprint (from the deblender) into the image.
• When we are done measuring that source, we again replace the HeavyFootprint with (the same) artificial noise.
• After measuring all sources, we return the image to its original state.

This is a functional copy of the code in the older ReplaceWithNoiseTask, but with a slightly different API needed for the new measurement framework; note that it is not a Task, as the lifetime of a NoiseReplacer now corresponds to a single exposure, not an entire processing run.

Definition at line 52 of file noiseReplacer.py.

Constructor & Destructor Documentation

def lsst.meas.base.noiseReplacer.NoiseReplacer.__init__	(		self,
			config,
			exposure,
			footprints,
			noiseImage = None,
			exposureId = None,
			log = None
	)

Initialize the NoiseReplacer.

Parameters

[in]	config	instance of NoiseReplacerConfig
[in,out]	exposure	Exposure to be noise replaced. (All sources replaced on return)
[in]	footprints	dict of {id: (parent, footprint)};
[in]	noiseImage	an afw.image.ImageF used as a predictable noise replacement source (for tests only)
[in]	log	pex.logging.Log object to use for status messages; no status messages will be printed if None

'footprints' is a dict of {id: (parent, footprint)}; when used in SFM, the ID will be the source ID, but in forced photometry, this will be the reference ID, as that's what we used to determine the deblend families. This routine should create HeavyFootprints for any non-Heavy Footprints, and replace them in the dict. It should then create a dict of HeavyFootprints containing noise, but only for parent objects, then replace all sources with noise. This should ignore any footprints that lay outside the bounding box of the exposure, and clip those that lie on the border.

NOTE: as the code currently stands, the heavy footprint for a deblended object must be available from the input catalog. If it is not, it cannot be reproduced here. In that case, the topmost parent in the objects parent chain must be used. The heavy footprint for that source is created in this class from the masked image.

Definition at line 74 of file noiseReplacer.py.

    def __init__(self, config, exposure, footprints, noiseImage=None, exposureId=None, log=None):
        """!
        Initialize the NoiseReplacer.

        @param[in]      config       instance of NoiseReplacerConfig
        @param[in,out]  exposure     Exposure to be noise replaced. (All sources replaced on return)
        @param[in]      footprints   dict of {id: (parent, footprint)};
        @param[in]      noiseImage   an afw.image.ImageF used as a predictable noise replacement source
                                     (for tests only)
        @param[in]      log          pex.logging.Log object to use for status messages; no status messages
                                     will be printed if None

        'footprints' is a dict of {id: (parent, footprint)}; when used in SFM, the ID will be the
        source ID, but in forced photometry, this will be the reference ID, as that's what we used to
        determine the deblend families.  This routine should create HeavyFootprints for any non-Heavy
        Footprints, and replace them in the dict.  It should then create a dict of HeavyFootprints
        containing noise, but only for parent objects, then replace all sources with noise.
        This should ignore any footprints that lay outside the bounding box of the exposure,
        and clip those that lie on the border.

        NOTE: as the code currently stands, the heavy footprint for a deblended object must be available
        from the input catalog.  If it is not, it cannot be reproduced here.  In that case, the
        topmost parent in the objects parent chain must be used.  The heavy footprint for that source
        is created in this class from the masked image.
        """
        noiseMeanVar=None
        self.noiseSource = config.noiseSource
        self.noiseOffset = config.noiseOffset
        self.noiseSeedMultiplier = config.noiseSeedMultiplier
        self.noiseGenMean = None
        self.noiseGenStd = None
        self.log = log

        # creates heavies, replaces all footprints with noise
        # We need the source table to be sorted by ID to do the parent lookups
        self.exposure = exposure
        self.footprints = footprints
        mi = exposure.getMaskedImage()
        im = mi.getImage()
        mask = mi.getMask()
        # Add temporary Mask planes for THISDET and OTHERDET
        self.removeplanes = []
        bitmasks = []
        for maskname in ['THISDET', 'OTHERDET']:
            try:
                # does it already exist?
                plane = mask.getMaskPlane(maskname)
                if self.log: self.log.logdebug('Mask plane "%s" already existed' % maskname)
            except:
                # if not, add it; we should delete it when done.
                plane = mask.addMaskPlane(maskname)
                self.removeplanes.append(maskname)
            mask.clearMaskPlane(plane)
            bitmask = mask.getPlaneBitMask(maskname)
            bitmasks.append(bitmask)
            if self.log: self.log.logdebug('Mask plane "%s": plane %i, bitmask %i = 0x%x'
                % (maskname, plane, bitmask, bitmask))
        self.thisbitmask,self.otherbitmask = bitmasks
        del bitmasks
        self.heavies = {}
        # Start by creating HeavyFootprints for each source which has no parent
        # and just use them for children which do not already have heavy footprints.
        # If a heavy footprint is available for a child, we will use it. Otherwise,
        # we use the first parent in the parent chain which has a heavy footprint,
        # which with the one level deblender will alway be the topmost parent
        # NOTE: heavy footprints get destroyed by the transform process in forcedPhotImage.py,
        # so they are never available for forced measurements.

        # Create in the dict heavies = {id:heavyfootprint}
        for id in footprints.keys():
            fp = footprints[id]
            if fp[1].isHeavy():
                self.heavies[id] = afwDet.cast_HeavyFootprintF(fp[1])
            elif fp[0] == 0:
                self.heavies[id] = afwDet.makeHeavyFootprint(fp[1], mi)

        ### FIXME: the heavy footprint includes the mask
        ### and variance planes, which we shouldn't need
        ### (I don't think we ever want to modify them in
        ### the input image).  Copying them around is
        ### wasteful.

        # We now create a noise HeavyFootprint for each source with has a heavy footprint.
        # We'll put the noise footprints in a dict heavyNoise = {id:heavyNoiseFootprint}
        self.heavyNoise = {}
        noisegen = self.getNoiseGenerator(exposure, noiseImage, noiseMeanVar, exposureId=exposureId)
        #  The noiseGenMean and Std are used by the unit tests
        self.noiseGenMean = noisegen.mean
        self.noiseGenStd = noisegen.std
        if self.log: self.log.logdebug('Using noise generator: %s' % (str(noisegen)))
        for id in self.heavies.keys():
            fp = footprints[id][1]
            noiseFp = noisegen.getHeavyFootprint(fp)
            self.heavyNoise[id] = noiseFp
            # Also insert the noisy footprint into the image now.
            # Notice that we're just inserting it into "im", ie,
            # the Image, not the MaskedImage.
            noiseFp.insert(im)
            # Also set the OTHERDET bit
            afwDet.setMaskFromFootprint(mask, fp, self.otherbitmask)