LSSTApplications: lsst.meas.algorithms.secondMomentStarSelector.

Inheritance diagram for lsst.meas.algorithms.secondMomentStarSelector._PsfShapeHistogram:

Public Member Functions
def	__init__

def	getImage

def	insert

def	momentsToPixel

def	pixelToMoments

def	getClumps

Public Attributes
	detector

	xy0

Private Attributes
	_ySize

	_yMax

	_psfImage

	_num

Detailed Description

A class to represent a histogram of (Ixx, Iyy)

Definition at line 270 of file secondMomentStarSelector.py.

Constructor & Destructor Documentation

def lsst.meas.algorithms.secondMomentStarSelector._PsfShapeHistogram.__init__	(	self,
		xSize = `32`,
		ySize = `32`,
		ixxMax = `30`,
		iyyMax = `30`,
		detector = `None`,
		xy0 = `afwGeom.Point2D(0,0`
	)

Construct a _PsfShapeHistogram

The maximum seeing FWHM that can be tolerated is [xy]Max/2.35 pixels.
The 'resolution' of stars vs galaxies/CRs is provided by [xy]Size/[xy]Max.
A larger (better) resolution may thresh the peaks, but a smaller (worse)
resolution will allow stars and galaxies/CRs to mix.  The disadvantages of
a larger (better) resolution can be compensated (some) by using multiple
histogram peaks.

@input[in] [xy]Size: the size of the psfImage (in pixels)
@input[in] ixxMax, iyyMax: the maximum values for I[xy][xy]

Definition at line 273 of file secondMomentStarSelector.py.

 
     def __init__(self, xSize=32, ySize=32, ixxMax=30, iyyMax=30, detector=None, xy0=afwGeom.Point2D(0,0)):
         """Construct a _PsfShapeHistogram
 
         The maximum seeing FWHM that can be tolerated is [xy]Max/2.35 pixels.
         The 'resolution' of stars vs galaxies/CRs is provided by [xy]Size/[xy]Max.
         A larger (better) resolution may thresh the peaks, but a smaller (worse)
         resolution will allow stars and galaxies/CRs to mix.  The disadvantages of
         a larger (better) resolution can be compensated (some) by using multiple
         histogram peaks.
         
         @input[in] [xy]Size: the size of the psfImage (in pixels)
         @input[in] ixxMax, iyyMax: the maximum values for I[xy][xy]
         """
         self._xSize, self._ySize = xSize, ySize 
         self._xMax, self._yMax = ixxMax, iyyMax
         self._psfImage = afwImage.ImageF(afwGeom.ExtentI(xSize, ySize), 0)
         self._num = 0
         self.detector = detector
         self.xy0 = xy0

lsst::afw::geom::Extent< int, 2 >

lsst::meas::algorithms.secondMomentStarSelector._PsfShapeHistogram._yMax

_yMax

Definition: secondMomentStarSelector.py:287

lsst::meas::algorithms.secondMomentStarSelector._PsfShapeHistogram.__init__

def __init__

Definition: secondMomentStarSelector.py:273

lsst::meas::algorithms.secondMomentStarSelector._PsfShapeHistogram.detector

detector

Definition: secondMomentStarSelector.py:290

lsst::meas::algorithms.secondMomentStarSelector._PsfShapeHistogram._ySize

_ySize

Definition: secondMomentStarSelector.py:286

lsst::meas::algorithms.secondMomentStarSelector._PsfShapeHistogram.xy0

xy0

Definition: secondMomentStarSelector.py:291

lsst::meas::algorithms.secondMomentStarSelector._PsfShapeHistogram._num

_num

Definition: secondMomentStarSelector.py:289

lsst::meas::algorithms.secondMomentStarSelector._PsfShapeHistogram._psfImage

_psfImage

Definition: secondMomentStarSelector.py:288

Member Function Documentation

def lsst.meas.algorithms.secondMomentStarSelector._PsfShapeHistogram.getClumps	(	self,
		sigma = `1.0`,
		display = `False`
	)

Definition at line 341 of file secondMomentStarSelector.py.

 
     def getClumps(self, sigma=1.0, display=False):
         if self._num <= 0:
             raise RuntimeError("No candidate PSF sources")
 
         psfImage = self.getImage()
         #
         # Embed psfImage into a larger image so we can smooth when measuring it
         #
         width, height = psfImage.getWidth(), psfImage.getHeight()
         largeImg = psfImage.Factory(afwGeom.ExtentI(2*width, 2*height))
         largeImg.set(0)
 
         bbox = afwGeom.BoxI(afwGeom.PointI(width, height), afwGeom.ExtentI(width, height))
         subLargeImg = psfImage.Factory(largeImg, bbox, afwImage.LOCAL)
         subLargeImg <<= psfImage
         del subLargeImg
         #
         # Now measure that image, looking for the highest peak.  Start by building an Exposure
         #
         msk = afwImage.MaskU(largeImg.getDimensions())
         msk.set(0)
         var = afwImage.ImageF(largeImg.getDimensions())
         var.set(1)
         mpsfImage = afwImage.MaskedImageF(largeImg, msk, var)
         mpsfImage.setXY0(afwGeom.PointI(-width, -height))
         del msk
         del var
         exposure = afwImage.makeExposure(mpsfImage)
         
         #
         # Next run an object detector
         #
         maxVal = afwMath.makeStatistics(psfImage, afwMath.MAX).getValue()
         threshold = maxVal - sigma*math.sqrt(maxVal)
         if threshold <= 0.0:
             threshold = maxVal
 
         threshold = afwDetection.Threshold(threshold)
             
         ds = afwDetection.FootprintSet(mpsfImage, threshold, "DETECTED")
         #
         # And measure it.  This policy isn't the one we use to measure
         # Sources, it's only used to characterize this PSF histogram
         #
         schema = afwTable.SourceTable.makeMinimalSchema()
         psfImageConfig = SingleFrameMeasurementConfig()
         psfImageConfig.doApplyApCorr = "no"
         psfImageConfig.slots.centroid = "base_SdssCentroid"
         psfImageConfig.slots.psfFlux = None #"base_PsfFlux"
         psfImageConfig.slots.apFlux = "base_CircularApertureFlux_3_0"
         psfImageConfig.slots.modelFlux = None
         psfImageConfig.slots.instFlux = None
         psfImageConfig.slots.calibFlux = None
         psfImageConfig.slots.shape = "base_SdssShape"
         #   Formerly, this code had centroid.sdss, flux.psf, flux.naive,
         #   flags.pixel, and shape.sdss
         psfImageConfig.algorithms.names = ["base_SdssCentroid", "base_CircularApertureFlux", "base_SdssShape"]
         psfImageConfig.algorithms["base_CircularApertureFlux"].radii = [3.0]
         psfImageConfig.validate()
         task = SingleFrameMeasurementTask(schema, config=psfImageConfig)
 
         catalog = afwTable.SourceCatalog(schema)
 
         gaussianWidth = 1.5                       # Gaussian sigma for detection convolution
         exposure.setPsf(algorithmsLib.DoubleGaussianPsf(11, 11, gaussianWidth))
 
         ds.makeSources(catalog)
         #
         # Show us the Histogram
         #
         if display:
             frame = 1
             dispImage = mpsfImage.Factory(mpsfImage, afwGeom.BoxI(afwGeom.PointI(width, height),
                                                                   afwGeom.ExtentI(width, height)),
                                                                   afwImage.LOCAL)
             ds9.mtv(dispImage,title="PSF Selection Image", frame=frame)
 
 
         clumps = list()                 # List of clumps, to return
         e = None                        # thrown exception
         IzzMin = 1.0                    # Minimum value for second moments
         IzzMax = (self._xSize/8.0)**2   # Max value ... clump r < clumpImgSize/8
                                         # diameter should be < 1/4 clumpImgSize
         apFluxes = []
         task.run(exposure, catalog)   # notes that this is backwards for the new framework
         for i, source in enumerate(catalog):
             if source.getCentroidFlag():
                 continue
             x, y = source.getX(), source.getY()
 
             apFluxes.append(source.getApFlux())
             
             val = mpsfImage.getImage().get(int(x) + width, int(y) + height)
 
             psfClumpIxx = source.getIxx()
             psfClumpIxy = source.getIxy()
             psfClumpIyy = source.getIyy()
 
             if display:
                 if i == 0:
                     ds9.pan(x, y, frame=frame)
 
                 ds9.dot("+", x, y, ctype=ds9.YELLOW, frame=frame)
                 ds9.dot("@:%g,%g,%g" % (psfClumpIxx, psfClumpIxy, psfClumpIyy), x, y,
                         ctype=ds9.YELLOW, frame=frame)
 
             if psfClumpIxx < IzzMin or psfClumpIyy < IzzMin:
                 psfClumpIxx = max(psfClumpIxx, IzzMin)
                 psfClumpIyy = max(psfClumpIyy, IzzMin)
                 if display:
                     ds9.dot("@:%g,%g,%g" % (psfClumpIxx, psfClumpIxy, psfClumpIyy), x, y,
                             ctype=ds9.RED, frame=frame)
 
             det = psfClumpIxx*psfClumpIyy - psfClumpIxy*psfClumpIxy
             try:
                 a, b, c = psfClumpIyy/det, -psfClumpIxy/det, psfClumpIxx/det
             except ZeroDivisionError:
                 a, b, c = 1e4, 0, 1e4
 
             clumps.append(Clump(peak=val, x=x, y=y, a=a, b=b, c=c,
                                 ixx=psfClumpIxx, ixy=psfClumpIxy, iyy=psfClumpIyy))
 
         if len(clumps) == 0:
             msg = "Failed to determine center of PSF clump"
             if e:
                 msg += ": %s" % e
             raise RuntimeError(msg)
 
         # if it's all we got return it
         if len(clumps) == 1:
             return clumps
         
         # which clump is the best?
         # if we've undistorted the moments, stars should only have 1 clump
         # use the apFlux from the clump measurement, and take the highest
         # ... this clump has more psf star candidate neighbours than the others.
 
         # get rid of any that are huge, and thus poorly defined
         goodClumps = []
         for clump in clumps:
             if clump.ixx < IzzMax and clump.iyy < IzzMax:
                 goodClumps.append(clump)
 
         # if culling > IzzMax cost us all clumps, we'll have to take what we have
         if len(goodClumps) == 0:
             goodClumps = clumps
             
         # use the 'brightest' clump
         iBestClump = numpy.argsort(apFluxes)[0]
         clumps = [clumps[iBestClump]]
         return clumps

def lsst.meas.algorithms.secondMomentStarSelector._PsfShapeHistogram.getImage ( self )

Definition at line 293 of file secondMomentStarSelector.py.

 
     def getImage(self):
         return self._psfImage

lsst::meas::algorithms.secondMomentStarSelector._PsfShapeHistogram.getImage

def getImage

Definition: secondMomentStarSelector.py:293

lsst::meas::algorithms.secondMomentStarSelector._PsfShapeHistogram._psfImage

_psfImage

Definition: secondMomentStarSelector.py:288

def lsst.meas.algorithms.secondMomentStarSelector._PsfShapeHistogram.insert	(	self,
		source
	)

Insert source into the histogram.

Definition at line 296 of file secondMomentStarSelector.py.

 
     def insert(self, source):
         """Insert source into the histogram."""
         
         ixx, iyy, ixy = source.getIxx(), source.getIyy(), source.getIxy()
         if self.detector:
             tanSys = self.detector.makeCameraSys(cameraGeom.TAN_PIXELS)
             if tanSys in self.detector.getTransformMap():
                 pixToTanXYTransform = self.detector.getTransformMap()[tanSys]
                 p = afwGeom.Point2D(source.getX(), source.getY())
                 linTransform = pixToTanXYTransform.linearizeForwardTransform(p).getLinear()
                 m = geomEllip.Quadrupole(ixx, iyy, ixy)
                 m.transform(linTransform)
                 ixx, iyy, ixy = m.getIxx(), m.getIyy(), m.getIxy()
             
         try:
             pixel = self.momentsToPixel(ixx, iyy)
             i = int(pixel[0])
             j = int(pixel[1])
         except:
             return 0
 
         if i in range(0, self._xSize) and j in range(0, self._ySize):
             if i != 0 or j != 0:
                 self._psfImage.set(i, j, self._psfImage.get(i, j) + 1)
                 self._num += 1
                 return 1                # success
 
         return 0                        # failure