LSSTApplications: lsst.meas.algorithms.objectSizeStarSelector.ObjectSizeStarSelector Class Reference

A measurePsfTask star selector. More...

Inheritance diagram for lsst.meas.algorithms.objectSizeStarSelector.ObjectSizeStarSelector:

Public Member Functions
def	__init__
	Construct a star selector that looks for a cluster of small objects in a size-magnitude plot. More...

def	selectStars
	Return a list of PSF candidates that represent likely stars. More...

Static Public Attributes
	ConfigClass = ObjectSizeStarSelectorConfig

Private Attributes
	_kernelSize

	_borderWidth

	_widthMin

	_widthMax

	_fluxMin

	_fluxMax

	_badFlags

	_sourceFluxField

	_widthStdAllowed

	_nSigmaClip

Detailed Description

A measurePsfTask star selector.

Definition at line 273 of file objectSizeStarSelector.py.

Constructor & Destructor Documentation

def lsst.meas.algorithms.objectSizeStarSelector.ObjectSizeStarSelector.__init__	(	self,
		config
	)

Construct a star selector that looks for a cluster of small objects in a size-magnitude plot.

Parameters

[in] config An instance of ObjectSizeStarSelectorConfig

Definition at line 279 of file objectSizeStarSelector.py.

 
     def __init__(self, config):
         """!
         Construct a star selector that looks for a cluster of small objects in a size-magnitude plot.
 
         \param[in] config An instance of ObjectSizeStarSelectorConfig
         """
         self._kernelSize  = config.kernelSize
         self._borderWidth = config.borderWidth
         self._widthMin = config.widthMin
         self._widthMax = config.widthMax
         self._fluxMin  = config.fluxMin
         self._fluxMax  = config.fluxMax
         self._badFlags = config.badFlags
         self._sourceFluxField = config.sourceFluxField
         self._widthStdAllowed = config.widthStdAllowed
         self._nSigmaClip = config.nSigmaClip

lsst::meas::algorithms.objectSizeStarSelector.ObjectSizeStarSelector._borderWidth

_borderWidth

Definition: objectSizeStarSelector.py:286

lsst::meas::algorithms.objectSizeStarSelector.ObjectSizeStarSelector._widthStdAllowed

_widthStdAllowed

Definition: objectSizeStarSelector.py:293

lsst::meas::algorithms.objectSizeStarSelector.ObjectSizeStarSelector._widthMin

_widthMin

Definition: objectSizeStarSelector.py:287

lsst::meas::algorithms.objectSizeStarSelector.ObjectSizeStarSelector._fluxMax

_fluxMax

Definition: objectSizeStarSelector.py:290

lsst::meas::algorithms.objectSizeStarSelector.ObjectSizeStarSelector._widthMax

_widthMax

Definition: objectSizeStarSelector.py:288

lsst::meas::algorithms.objectSizeStarSelector.ObjectSizeStarSelector._kernelSize

_kernelSize

Definition: objectSizeStarSelector.py:285

lsst::meas::algorithms.objectSizeStarSelector.ObjectSizeStarSelector._fluxMin

_fluxMin

Definition: objectSizeStarSelector.py:289

lsst::meas::algorithms.objectSizeStarSelector.ObjectSizeStarSelector._badFlags

_badFlags

Definition: objectSizeStarSelector.py:291

lsst::meas::algorithms.objectSizeStarSelector.ObjectSizeStarSelector.__init__

def __init__

Construct a star selector that looks for a cluster of small objects in a size-magnitude plot...

Definition: objectSizeStarSelector.py:279

lsst::meas::algorithms.objectSizeStarSelector.ObjectSizeStarSelector._sourceFluxField

_sourceFluxField

Definition: objectSizeStarSelector.py:292

lsst::meas::algorithms.objectSizeStarSelector.ObjectSizeStarSelector._nSigmaClip

_nSigmaClip

Definition: objectSizeStarSelector.py:294

def lsst.meas.algorithms.objectSizeStarSelector.ObjectSizeStarSelector.selectStars	(	self,
		exposure,
		catalog,
		matches = `None`
	)

Return a list of PSF candidates that represent likely stars.

A list of PSF candidates may be used by a PSF fitter to construct a PSF.

Parameters

[in]	exposure	the exposure containing the sources
[in]	catalog	a SourceCatalog containing sources that may be stars
[in]	matches	astrometric matches; ignored by this star selector

Returns: psfCandidateList a list of PSF candidates.

Definition at line 296 of file objectSizeStarSelector.py.

 
     def selectStars(self, exposure, catalog, matches=None):
         """!Return a list of PSF candidates that represent likely stars
 
         A list of PSF candidates may be used by a PSF fitter to construct a PSF.
 
         \param[in] exposure the exposure containing the sources
         \param[in] catalog a SourceCatalog containing sources that may be stars
         \param[in] matches astrometric matches; ignored by this star selector
 
         \return psfCandidateList a list of PSF candidates.
         """
         import lsstDebug
         display = lsstDebug.Info(__name__).display
         displayExposure = lsstDebug.Info(__name__).displayExposure     # display the Exposure + spatialCells
         plotMagSize = lsstDebug.Info(__name__).plotMagSize             # display the magnitude-size relation
         dumpData = lsstDebug.Info(__name__).dumpData                   # dump data to pickle file?
 
         # create a log for my application
         logger = pexLogging.Log(pexLogging.getDefaultLog(), "meas.algorithms.objectSizeStarSelector")
 
         detector = exposure.getDetector()
         pixToTanXYTransform = None
         if detector is not None:
             tanSys = detector.makeCameraSys(cameraGeom.TAN_PIXELS)
             pixToTanXYTransform = detector.getTransformMap().get(tanSys)
         #
         # Look at the distribution of stars in the magnitude-size plane
         #
         flux = catalog.get(self._sourceFluxField)
 
         xx = numpy.empty(len(catalog))
         xy = numpy.empty_like(xx)
         yy = numpy.empty_like(xx)
         for i, source in enumerate(catalog):
             Ixx, Ixy, Iyy = source.getIxx(), source.getIxy(), source.getIyy()
             if pixToTanXYTransform:
                 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()
 
             xx[i], xy[i], yy[i] = Ixx, Ixy, Iyy
 
         width = numpy.sqrt(0.5*(xx + yy))
 
         badFlags = self._badFlags
 
         bad = reduce(lambda x, y: numpy.logical_or(x, catalog.get(y)), badFlags, False)
         bad = numpy.logical_or(bad, flux < self._fluxMin)
         bad = numpy.logical_or(bad, numpy.logical_not(numpy.isfinite(width)))
         bad = numpy.logical_or(bad, numpy.logical_not(numpy.isfinite(flux)))
         bad = numpy.logical_or(bad, width < self._widthMin)
         bad = numpy.logical_or(bad, width > self._widthMax)
         if self._fluxMax > 0:
             bad = numpy.logical_or(bad, flux > self._fluxMax)
         good = numpy.logical_not(bad)
 
         if not numpy.any(good):
             raise RuntimeError("No objects passed our cuts for consideration as psf stars")
 
         mag = -2.5*numpy.log10(flux[good])
         width = width[good]
         #
         # Look for the maximum in the size histogram, then search upwards for the minimum that separates
         # the initial peak (of, we presume, stars) from the galaxies
         #
         if dumpData:
             import os, cPickle as pickle
             _ii = 0
             while True:
                 pickleFile = os.path.expanduser(os.path.join("~", "widths-%d.pkl" % _ii))
                 if not os.path.exists(pickleFile):
                     break
                 _ii += 1
 
             with open(pickleFile, "wb") as fd:
                 pickle.dump(mag, fd, -1)
                 pickle.dump(width, fd, -1)
 
         centers, clusterId = _kcenters(width, nCluster=4, useMedian=True,
                                        widthStdAllowed=self._widthStdAllowed)
 
         if display and plotMagSize and pyplot:
             fig = plot(mag, width, centers, clusterId, magType=self._sourceFluxField.split(".")[-1].title(),
                        marker="+", markersize=3, markeredgewidth=None, ltype=':', clear=True)
         else:
             fig = None
 
         clusterId = _improveCluster(width, centers, clusterId,
                                     nsigma = self._nSigmaClip, widthStdAllowed=self._widthStdAllowed)
 
         if display and plotMagSize and pyplot:
             plot(mag, width, centers, clusterId, marker="x", markersize=3, markeredgewidth=None, clear=False)
 
         stellar = (clusterId == 0)
         #
         # We know enough to plot, if so requested
         #
         frame = 0
 
         if fig:
             if display and displayExposure:
                 ds9.mtv(exposure.getMaskedImage(), frame=frame, title="PSF candidates")
 
                 global eventHandler
                 eventHandler = EventHandler(fig.get_axes()[0], mag, width,
                                             catalog.getX()[good], catalog.getY()[good], frames=[frame])
 
             fig.show()
 
             #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 
             while True:
                 try:
                     reply = raw_input("continue? [c h(elp) q(uit) p(db)] ").strip()
                 except EOFError:
                     reply = None
                 if not reply:
                     reply = "c"
 
                 if reply:
                     if reply[0] == "h":
                         print """\
     We cluster the points; red are the stellar candidates and the other colours are other clusters.
     Points labelled + are rejects from the cluster (only for cluster 0).
 
     At this prompt, you can continue with almost any key; 'p' enters pdb, and 'h' prints this text
 
     If displayExposure is true, you can put the cursor on a point and hit 'p' to see it in ds9.
     """
                     elif reply[0] == "p":
                         import pdb; pdb.set_trace()
                     elif reply[0] == 'q':
                         sys.exit(1)
                     else:
                         break
 
         if display and displayExposure:
             mi = exposure.getMaskedImage()
 
             with ds9.Buffering():
                 for i, source in enumerate(catalog):
                     if good[i]:
                         ctype = ds9.GREEN # star candidate
                     else:
                         ctype = ds9.RED # not star
 
                     ds9.dot("+", source.getX() - mi.getX0(),
                             source.getY() - mi.getY0(), frame=frame, ctype=ctype)
         #
         # Time to use that stellar classification to generate psfCandidateList
         #
         with ds9.Buffering():
             psfCandidateList = []
             for isStellar, source in zip(stellar, [s for g, s in zip(good, catalog) if g]):
                 if not isStellar:
                     continue
 
                 try:
                     psfCandidate = algorithmsLib.makePsfCandidate(source, exposure)
                     # The setXXX methods are class static, but it's convenient to call them on
                     # an instance as we don't know Exposure's pixel type
                     # (and hence psfCandidate's exact type)
                     if psfCandidate.getWidth() == 0:
                         psfCandidate.setBorderWidth(self._borderWidth)
                         psfCandidate.setWidth(self._kernelSize + 2*self._borderWidth)
                         psfCandidate.setHeight(self._kernelSize + 2*self._borderWidth)
 
                     im = psfCandidate.getMaskedImage().getImage()
                     vmax = afwMath.makeStatistics(im, afwMath.MAX).getValue()
                     if not numpy.isfinite(vmax):
                         continue
                     psfCandidateList.append(psfCandidate)
 
                     if display and displayExposure:
                         ds9.dot("o", source.getX() - mi.getX0(), source.getY() - mi.getY0(),
                                 size=4, frame=frame, ctype=ds9.CYAN)
                 except Exception as err:
                     logger.logdebug("Failed to make a psfCandidate from source %d: %s" % (source.getId(), err))
 
         return psfCandidateList
 
 starSelectorRegistry.register("objectSize", ObjectSizeStarSelector)

Public Member Functions

Static Public Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation