def run(display=False):
exposure = loadData()
schema = afwTable.SourceTable.makeMinimalSchema()
#
# Create the detection and measurement Tasks
#
config = SourceDetectionTask.ConfigClass()
config.reEstimateBackground = False
detectionTask = SourceDetectionTask(config=config, schema=schema)
config = SingleFrameMeasurementTask.ConfigClass()
# Use the minimum set of plugins required.
config.plugins.names.clear()
for plugin in [
"base_SdssCentroid", "base_SdssShape", "base_CircularApertureFlux",
"base_PixelFlags"
]:
config.plugins.names.add(plugin)
config.plugins["base_CircularApertureFlux"].radii = [7.0]
# Use of the PSF flux is hardcoded in secondMomentStarSelector
config.slots.psfFlux = "base_CircularApertureFlux_7_0"
measureTask = SingleFrameMeasurementTask(schema, config=config)
#
# Create the measurePsf task
#
config = MeasurePsfTask.ConfigClass()
psfDeterminer = config.psfDeterminer.apply()
psfDeterminer.config.sizeCellX = 128
psfDeterminer.config.sizeCellY = 128
psfDeterminer.config.spatialOrder = 1
psfDeterminer.config.nEigenComponents = 3
measurePsfTask = MeasurePsfTask(config=config, schema=schema)
#
# Create the output table
#
tab = afwTable.SourceTable.make(schema)
#
# Process the data
#
sources = detectionTask.run(tab, exposure, sigma=2).sources
measureTask.measure(exposure, sources)
result = measurePsfTask.run(exposure, sources)
psf = result.psf
cellSet = result.cellSet
if display: # display on ds9 (see also --debug argparse option)
frame = 1
ds9.mtv(exposure, frame=frame)
with ds9.Buffering():
for s in sources:
xy = s.getCentroid()
ds9.dot('+', *xy, frame=frame)
if s.get("calib.psf.candidate"):
ds9.dot('x', *xy, ctype=ds9.YELLOW, frame=frame)
if s.get("calib.psf.used"):
ds9.dot('o', *xy, size=4, ctype=ds9.RED, frame=frame)
def run(display=False):
exposure = loadData()
schema = afwTable.SourceTable.makeMinimalSchema()
#
# Create the detection and measurement Tasks
#
config = SourceDetectionTask.ConfigClass()
config.reEstimateBackground = False
detectionTask = SourceDetectionTask(config=config, schema=schema)
config = SingleFrameMeasurementTask.ConfigClass()
# Use the minimum set of plugins required.
config.plugins.names.clear()
for plugin in ["base_SdssCentroid", "base_SdssShape", "base_CircularApertureFlux", "base_PixelFlags"]:
config.plugins.names.add(plugin)
config.plugins["base_CircularApertureFlux"].radii = [7.0]
config.slots.psfFlux = "base_CircularApertureFlux_7_0" # Use of the PSF flux is hardcoded in secondMomentStarSelector
measureTask = SingleFrameMeasurementTask(schema, config=config)
#
# Create the measurePsf task
#
config = MeasurePsfTask.ConfigClass()
psfDeterminer = config.psfDeterminer.apply()
psfDeterminer.config.sizeCellX = 128
psfDeterminer.config.sizeCellY = 128
psfDeterminer.config.spatialOrder = 1
psfDeterminer.config.nEigenComponents = 3
measurePsfTask = MeasurePsfTask(config=config, schema=schema)
#
# Create the output table
#
tab = afwTable.SourceTable.make(schema)
#
# Process the data
#
sources = detectionTask.run(tab, exposure, sigma=2).sources
measureTask.measure(exposure, sources)
result = measurePsfTask.run(exposure, sources)
psf = result.psf
cellSet = result.cellSet
if display: # display on ds9 (see also --debug argparse option)
frame = 1
ds9.mtv(exposure, frame=frame)
with ds9.Buffering():
for s in sources:
xy = s.getCentroid()
ds9.dot('+', *xy, frame=frame)
if s.get("calib.psf.candidate"):
ds9.dot('x', *xy, ctype=ds9.YELLOW, frame=frame)
if s.get("calib.psf.used"):
ds9.dot('o', *xy, size=4, ctype=ds9.RED, frame=frame)
def run(display=False):
exposure = loadData()
schema = afwTable.SourceTable.makeMinimalSchema()
#
# Create the detection task
#
config = SourceDetectionTask.ConfigClass()
config.thresholdPolarity = "both"
config.background.isNanSafe = True
config.thresholdValue = 3
detectionTask = SourceDetectionTask(config=config, schema=schema)
#
# And the measurement Task
#
config = SingleFrameMeasurementTask.ConfigClass()
config.plugins.names.clear()
for plugin in ["base_SdssCentroid", "base_SdssShape", "base_CircularApertureFlux", "base_GaussianFlux"]:
config.plugins.names.add(plugin)
config.slots.psfFlux = None
config.slots.apFlux = "base_CircularApertureFlux_3_0"
measureTask = SingleFrameMeasurementTask(schema, config=config)
#
# Print the schema the configuration produced
#
print(schema)
#
# Create the output table
#
tab = afwTable.SourceTable.make(schema)
#
# Process the data
#
result = detectionTask.run(tab, exposure)
sources = result.sources
print("Found %d sources (%d +ve, %d -ve)" % (len(sources), result.fpSets.numPos, result.fpSets.numNeg))
measureTask.run(sources, exposure)
if display: # display image (see also --debug argparse option)
frame = 1
disp = afwDisplay.Display(frame=frame)
disp.mtv(exposure)
with disp.Buffering():
for s in sources:
xy = s.getCentroid()
disp.dot('+', *xy, ctype=afwDisplay.CYAN if s.get("flags_negative") else afwDisplay.GREEN)
disp.dot(s.getShape(), *xy, ctype=afwDisplay.RED)
disp.dot('o', *xy, size=config.plugins["base_CircularApertureFlux"].radii[0],
ctype=afwDisplay.YELLOW)
def run(display=False):
exposure = loadData()
schema = afwTable.SourceTable.makeMinimalSchema()
#
# Create the detection task
#
config = SourceDetectionTask.ConfigClass()
config.thresholdPolarity = "both"
config.background.isNanSafe = True
config.thresholdValue = 3
detectionTask = SourceDetectionTask(config=config, schema=schema)
#
# And the measurement Task
#
config = SingleFrameMeasurementTask.ConfigClass()
config.algorithms.names = ["base_SdssCentroid", "base_SdssShape", "base_CircularApertureFlux"]
config.algorithms["base_CircularApertureFlux"].radii = [1, 2, 4, 8, 12, 16] # pixels
config.slots.gaussianFlux = None
config.slots.modelFlux = None
config.slots.psfFlux = None
algMetadata = dafBase.PropertyList()
measureTask = SingleFrameMeasurementTask(schema, algMetadata=algMetadata, config=config)
radii = algMetadata.getArray("base_CircularApertureFlux_radii")
#
# Create the output table
#
tab = afwTable.SourceTable.make(schema)
#
# Process the data
#
result = detectionTask.run(tab, exposure)
sources = result.sources
print("Found %d sources (%d +ve, %d -ve)" % (len(sources), result.fpSets.numPos, result.fpSets.numNeg))
measureTask.run(sources, exposure)
if display: # display image (see also --debug argparse option)
afwDisplay.setDefaultMaskTransparency(75)
frame = 1
disp = afwDisplay.Display(frame=frame)
disp.mtv(exposure)
with disp.Buffering():
for s in sources:
xy = s.getCentroid()
disp.dot('+', *xy, ctype=afwDisplay.CYAN if s.get("flags_negative") else afwDisplay.GREEN)
disp.dot(s.getShape(), *xy, ctype=afwDisplay.RED)
for radius in radii:
disp.dot('o', *xy, size=radius, ctype=afwDisplay.YELLOW)
def run(display=False):
exposure = loadData()
schema = afwTable.SourceTable.makeMinimalSchema()
#
# Create the detection task
#
config = SourceDetectionTask.ConfigClass()
config.thresholdPolarity = "both"
config.background.isNanSafe = True
config.thresholdValue = 3
detectionTask = SourceDetectionTask(config=config, schema=schema)
#
# And the measurement Task
#
config = SingleFrameMeasurementTask.ConfigClass()
config.algorithms.names = ["base_SdssCentroid", "base_SdssShape", "base_CircularApertureFlux"]
config.algorithms["base_CircularApertureFlux"].radii = [1, 2, 4, 8, 16] # pixels
config.slots.instFlux = None
config.slots.modelFlux = None
config.slots.psfFlux = None
algMetadata = dafBase.PropertyList()
measureTask = SingleFrameMeasurementTask(schema, algMetadata=algMetadata, config=config)
radii = algMetadata.get("base_CircularApertureFlux_radii")
#
# Create the output table
#
tab = afwTable.SourceTable.make(schema)
#
# Process the data
#
result = detectionTask.run(tab, exposure)
sources = result.sources
print("Found %d sources (%d +ve, %d -ve)" % (len(sources), result.fpSets.numPos, result.fpSets.numNeg))
measureTask.run(sources, exposure)
if display: # display on ds9 (see also --debug argparse option)
frame = 1
ds9.mtv(exposure, frame=frame)
with ds9.Buffering():
for s in sources:
xy = s.getCentroid()
ds9.dot('+', *xy, ctype=ds9.CYAN if s.get("flags.negative") else ds9.GREEN, frame=frame)
ds9.dot(s.getShape(), *xy, ctype=ds9.RED, frame=frame)
for i in range(s.get("flux.aperture.nProfile")):
ds9.dot('o', *xy, size=radii[i], ctype=ds9.YELLOW, frame=frame)
def run(args):
exposure = loadData(args.image)
if args.debug:
ds9.mtv(exposure, frame=1)
schema = afwTable.SourceTable.makeMinimalSchema()
# Create the detection task
config = SourceDetectionTask.ConfigClass()
config.thresholdPolarity = "both"
config.background.isNanSafe = True
config.thresholdValue = 3
detectionTask = SourceDetectionTask(config=config, schema=schema)
# And the measurement Task
config = DipoleMeasurementTask.ConfigClass()
config.plugins.names.remove('base_SkyCoord')
algMetadata = dafBase.PropertyList()
measureTask = DipoleMeasurementTask(schema, algMetadata, config=config)
# Create the output table
tab = afwTable.SourceTable.make(schema)
# Process the data
results = detectionTask.run(tab, exposure)
# Merge the positve and negative sources
fpSet = results.fpSets.positive
growFootprint = 2
fpSet.merge(results.fpSets.negative, growFootprint, growFootprint, False)
diaSources = afwTable.SourceCatalog(tab)
fpSet.makeSources(diaSources)
print("Merged %s Sources into %d diaSources (from %d +ve, %d -ve)" % (len(results.sources),
len(diaSources),
results.fpSets.numPos,
results.fpSets.numNeg))
measureTask.run(diaSources, exposure)
# Display dipoles if debug enabled
if args.debug:
dpa = DipoleAnalysis()
dpa.displayDipoles(exposure, diaSources)
def testMismatchedSchema(self):
schema = afwTable.SourceTable.makeMinimalSchema()
# Create the detection task and process the data
detectionTask = SourceDetectionTask(schema=schema)
table = afwTable.SourceTable.make(schema)
result = detectionTask.run(table, self.calexp)
self.assertEqual(schema, result.sources.getSchema())
# SourceDeblendTask modifies the schema in-place at construction
# and add extra keys to it
deblendTask = SourceDeblendTask(schema)
self.assertNotEqual(schema, result.sources.getSchema())
# As the deblendTask has a different schema than the original schema
# of the detectionTask, the assert should fail and stop running
with self.assertRaises(AssertionError):
deblendTask.run(self.calexp, result.sources)
def testInclude(self):
schema = afwTable.SourceTable.makeMinimalSchema()
# Create the detection task
config = SourceDetectionTask.ConfigClass()
config.reEstimateBackground = False # Turn off so that background does not change from orig
detectionTask = SourceDetectionTask(config=config, schema=schema)
# Create the deblender Task
debConfig = measDeb.SourceDeblendConfig()
debTask = measDeb.SourceDeblendTask(schema, config=debConfig)
# Create the measurement Task
config = SingleFrameMeasurementTask.ConfigClass()
measureTask = SingleFrameMeasurementTask(schema, config=config)
# Create the output table
tab = afwTable.SourceTable.make(schema)
# Process the data
result = detectionTask.run(tab, self.calexp)
sources = result.sources
# Run the deblender
debTask.run(self.calexp, sources)
# Run the measurement task: this where the replace-with-noise occurs
measureTask.run(sources, self.calexp)
plotOnFailure = False
if display:
plotOnFailure = True
# The relative differences ranged from 0.02 to ~2. This rtol is somewhat
# random, but will certainly catch the pathology if it occurs.
self.assertFloatsAlmostEqual(
self.calexpOrig.getMaskedImage().getImage().getArray(),
self.calexp.getMaskedImage().getImage().getArray(),
rtol=1E-3,
printFailures=False,
plotOnFailure=plotOnFailure)
def testInclude(self):
schema = afwTable.SourceTable.makeMinimalSchema()
# Create the detection task
config = SourceDetectionTask.ConfigClass()
config.reEstimateBackground = False # Turn off so that background does not change from orig
detectionTask = SourceDetectionTask(config=config, schema=schema)
# Create the deblender Task
debConfig = measDeb.SourceDeblendConfig()
debTask = measDeb.SourceDeblendTask(schema, config=debConfig)
# Create the measurement Task
config = SingleFrameMeasurementTask.ConfigClass()
measureTask = SingleFrameMeasurementTask(schema, config=config)
# Create the output table
tab = afwTable.SourceTable.make(schema)
# Process the data
result = detectionTask.run(tab, self.calexp)
sources = result.sources
# Run the deblender
debTask.run(self.calexp, sources)
# Run the measurement task: this where the replace-with-noise occurs
measureTask.run(sources, self.calexp)
plotOnFailure = False
if display:
plotOnFailure = True
# The relative differences ranged from 0.02 to ~2. This rtol is somewhat
# random, but will certainly catch the pathology if it occurs.
self.assertFloatsAlmostEqual(self.calexpOrig.getMaskedImage().getImage().getArray(),
self.calexp.getMaskedImage().getImage().getArray(),
rtol=1E-3, printFailures=False, plotOnFailure=plotOnFailure)
def detectAndMeasureWithDM():
### what file are you going to look at? This should be in fits format.
### The test image included in this example contains stars and galaxies in the center only.
imagefile = "test_image_stars.fits"
### open the file in the stack format
exposure = afwImage.ExposureF(imagefile)
im = exposure.getMaskedImage().getImage()
### display the original image
frame = 0
ds9.mtv(exposure, frame=frame, title="Original Image"); frame+=1
### Subtract background.
### To do this, we'll set up a grid of 64x64 pixel areas across th eimage
### Fit the second moment of the pixels in each (which should be bg-dominated) and a fit a smooth function
### Subtract this function.
print "** subtracting background"
#back_size = 256 ## dunno what this is
#back_ctrl = afwMath.BackgroundControl(im.getWidth()//back_size+1, im.getHeight()//back_size +1)
#back_obj = afwMath.makeBackground(im, back_ctrl)
#im -=back_obj.getImageF("LINEAR")
im -= float(np.median(im.getArray()))
ds9.mtv(exposure, frame=frame, title="Background removed"); frame+=1
### Set up the schema
schema = afwTable.SourceTable.makeMinimalSchema()
schema.setVersion(0)
### Create the detection task
config = SourceDetectionTask.ConfigClass()
config.reEstimateBackground = False
detectionTask = SourceDetectionTask(config=config, schema=schema)
### create the measurement task
config = SourceMeasurementTask.ConfigClass()
config.slots.psfFlux = "flux.sinc" # use of the psf flux is hardcoded in secondMomentStarSelector
measureTask = SourceMeasurementTask(schema, config=config)
### Create the measurePsf task
config = MeasurePsfTask.ConfigClass()
starSelector = config.starSelector.apply()
starSelector.name = "objectSize"
#starSelector.config.badFlags = ["flags.pixel.edge", "flags.pixel.cr.center",
# "flags.pixel.interpolated.center", "flags.pixel.saturated.center"]
psfDeterminer = config.psfDeterminer.apply()
psfDeterminer.config.sizeCellX = 128
psfDeterminer.config.sizeCellY = 128
psfDeterminer.config.nStarPerCell = 1
psfDeterminer.config.spatialOrder = 1
psfDeterminer.config.nEigenComponents = 3
measurePsfTask = MeasurePsfTask(config=config, schema=schema)
### Create the output table
tab = afwTable.SourceTable.make(schema)
lsstDebug.getInfo(MeasurePsfTask).display=True
### Process the data
print "*** running detection task..."
sources = detectionTask.run(tab, exposure, sigma=2).sources
print "*** running measure task..."
measureTask.measure(exposure, sources)
print "*** running measurePsf task..."
result = measurePsfTask.run(exposure, sources)
psf = result.psf
cellSet = result.cellSet
### Look at the psf
psfIm = psf.computeImage()
ds9.mtv(psfIm, frame=frame, title = "Psf Image"); frame+=1
### render it on a grid
import lsst.meas.algorithms.utils as measUtils
cellSet = result.cellSet
measUtils.showPsfMosaic(exposure, psf=psf, frame=frame); frame += 1
with ds9.Buffering():
for s in sources:
xy = s.getCentroid()
ds9.dot('+', *xy, ctype=ds9.GREEN, frame=frame)
if s.get("calib.psf.candidate"):
ds9.dot('x', *xy, ctype=ds9.YELLOW, frame=frame)
if s.get("calib.psf.used"):
ds9.dot('o', *xy, size=4, ctype=ds9.RED, frame=frame)
"""
def run(display=False):
exposure = loadData()
schema = afwTable.SourceTable.makeMinimalSchema()
#
# Create the detection task
#
config = SourceDetectionTask.ConfigClass()
config.thresholdPolarity = "both"
config.background.isNanSafe = True
config.thresholdValue = 3
detectionTask = SourceDetectionTask(config=config, schema=schema)
#
# And the measurement Task
#
config = SingleFrameMeasurementTask.ConfigClass()
config.algorithms.names = [
"base_SdssCentroid", "base_SdssShape", "base_CircularApertureFlux"
]
config.algorithms["base_CircularApertureFlux"].radii = [
1, 2, 4, 8, 12, 16
] # pixels
config.slots.gaussianFlux = None
config.slots.modelFlux = None
config.slots.psfFlux = None
algMetadata = dafBase.PropertyList()
measureTask = SingleFrameMeasurementTask(schema,
algMetadata=algMetadata,
config=config)
radii = algMetadata.getArray("BASE_CIRCULARAPERTUREFLUX_RADII")
#
# Create the output table
#
tab = afwTable.SourceTable.make(schema)
#
# Process the data
#
result = detectionTask.run(tab, exposure)
sources = result.sources
print("Found %d sources (%d +ve, %d -ve)" %
(len(sources), result.fpSets.numPos, result.fpSets.numNeg))
measureTask.run(sources, exposure)
if display: # display image (see also --debug argparse option)
afwDisplay.setDefaultMaskTransparency(75)
frame = 1
disp = afwDisplay.Display(frame=frame)
disp.mtv(exposure)
with disp.Buffering():
for s in sources:
xy = s.getCentroid()
disp.dot('+',
*xy,
ctype=afwDisplay.CYAN
if s.get("flags_negative") else afwDisplay.GREEN)
disp.dot(s.getShape(), *xy, ctype=afwDisplay.RED)
for radius in radii:
disp.dot('o', *xy, size=radius, ctype=afwDisplay.YELLOW)
def run(config, inputFiles, weightFiles=None, varianceFiles=None,
returnCalibSources=False, display=False, verbose=False):
#
# Create the tasks
#
schema = afwTable.SourceTable.makeMinimalSchema()
algMetadata = dafBase.PropertyList()
calibrateTask = CalibrateTask(config=config.calibrate)
sourceDetectionTask = SourceDetectionTask(config=config.detection, schema=schema)
if config.doDeblend:
if SourceDeblendTask:
sourceDeblendTask = SourceDeblendTask(config=config.deblend, schema=schema)
else:
print >> sys.stderr, "Failed to import lsst.meas.deblender; setting doDeblend = False"
config.doDeblend = False
sourceMeasurementTask = SingleFrameMeasurementTask(config=config.measurement,
schema=schema, algMetadata=algMetadata)
exposureDict = {}; calibSourcesDict = {}; sourcesDict = {}
for inputFile, weightFile, varianceFile in zip(inputFiles, weightFiles, varianceFiles):
#
# Create the output table
#
tab = afwTable.SourceTable.make(schema)
#
# read the data
#
if verbose:
print "Reading %s" % inputFile
exposure = makeExposure(inputFile, weightFile, varianceFile,
config.badPixelValue, config.variance, verbose)
#
# process the data
#
calibSources = None # sources used to calibrate the frame (photom, astrom, psf)
if config.doCalibrate:
result = calibrateTask.run(exposure)
exposure, sources = result.exposure, result.sources
if returnCalibSources:
calibSources = sources
else:
if not exposure.getPsf():
calibrateTask.installInitialPsf(exposure)
if config.edgeRolloff.applyModel:
if verbose:
print "Adding edge rolloff distortion to the exposure WCS"
addEdgeRolloffDistortion(exposure, config.edgeRolloff)
exposureDict[inputFile] = exposure
calibSourcesDict[inputFile] = calibSources
result = sourceDetectionTask.run(tab, exposure)
sources = result.sources
sourcesDict[inputFile] = sources
if config.doDeblend:
sourceDeblendTask.run(exposure, sources, exposure.getPsf())
sourceMeasurementTask.measure(exposure, sources)
if verbose:
print "Detected %d objects" % len(sources)
if display: # display on ds9 (see also --debug argparse option)
if algMetadata.exists("base_CircularApertureFlux_radii"):
radii = algMetadata.get("base_CircularApertureFlux_radii")
else:
radii = None
frame = 1
ds9.mtv(exposure, title=os.path.split(inputFile)[1], frame=frame)
with ds9.Buffering():
for s in sources:
xy = s.getCentroid()
ds9.dot('+', *xy, ctype=ds9.CYAN if s.get("flags_negative") else ds9.GREEN, frame=frame)
ds9.dot(s.getShape(), *xy, ctype=ds9.RED, frame=frame)
if radii:
for radius in radii:
ds9.dot('o', *xy, size=radius, ctype=ds9.YELLOW, frame=frame)
return exposureDict, calibSourcesDict, sourcesDict
def run(config,
inputFiles,
weightFiles=None,
varianceFiles=None,
returnCalibSources=False,
displayResults=[],
verbose=False):
#
# Create the tasks
#
schema = afwTable.SourceTable.makeMinimalSchema()
algMetadata = dafBase.PropertyList()
isrTask = IsrTask(config=config.isr)
charImageTask = CharacterizeImageTask(None, config=config.charImage)
sourceDetectionTask = SourceDetectionTask(config=config.detection,
schema=schema)
if config.doDeblend:
if SourceDeblendTask:
sourceDeblendTask = SourceDeblendTask(config=config.deblend,
schema=schema)
else:
print >> sys.stderr, "Failed to import lsst.meas.deblender; setting doDeblend = False"
config.doDeblend = False
sourceMeasurementTask = SingleFrameMeasurementTask(
schema=schema, config=config.measurement, algMetadata=algMetadata)
keysToCopy = []
for key in [
charImageTask.measurePsf.reservedKey,
charImageTask.measurePsf.usedKey,
]:
keysToCopy.append(
(schema.addField(charImageTask.schema.find(key).field), key))
exposureDict = {}
calibSourcesDict = {}
sourcesDict = {}
for inputFile, weightFile, varianceFile in zip(inputFiles, weightFiles,
varianceFiles):
#
# Create the output table
#
tab = afwTable.SourceTable.make(schema)
#
# read the data
#
if verbose:
print "Reading %s" % inputFile
exposure = makeExposure(inputFile, weightFile, varianceFile,
config.badPixelValue, config.variance)
#
if config.interpPlanes:
import lsst.ip.isr as ipIsr
defects = ipIsr.getDefectListFromMask(exposure.getMaskedImage(),
config.interpPlanes,
growFootprints=0)
isrTask.run(exposure, defects=defects)
#
# process the data
#
if config.doCalibrate:
result = charImageTask.characterize(exposure)
exposure, calibSources = result.exposure, result.sourceCat
else:
calibSources = None
if not exposure.getPsf():
charImageTask.installSimplePsf.run(exposure)
exposureDict[inputFile] = exposure
calibSourcesDict[
inputFile] = calibSources if returnCalibSources else None
result = sourceDetectionTask.run(tab, exposure)
sources = result.sources
sourcesDict[inputFile] = sources
if config.doDeblend:
sourceDeblendTask.run(exposure, sources)
sourceMeasurementTask.measure(exposure, sources)
if verbose:
print "Detected %d objects" % len(sources)
propagatePsfFlags(keysToCopy, calibSources, sources)
if displayResults: # display results of processing (see also --debug argparse option)
showApertures = "showApertures".upper() in displayResults
showPSFs = "showPSFs".upper() in displayResults
showShapes = "showShapes".upper() in displayResults
display = afwDisplay.getDisplay(frame=1)
if algMetadata.exists("base_CircularApertureFlux_radii"):
radii = algMetadata.get("base_CircularApertureFlux_radii")
else:
radii = []
display.mtv(exposure, title=os.path.split(inputFile)[1])
with display.Buffering():
for s in sources:
xy = s.getCentroid()
display.dot('+',
*xy,
ctype=afwDisplay.CYAN if
s.get("flags_negative") else afwDisplay.GREEN)
if showPSFs and (s.get("calib_psfUsed")
or s.get("calib_psfReserved")):
display.dot(
'o',
*xy,
size=10,
ctype=afwDisplay.GREEN
if s.get("calib_psfUsed") else afwDisplay.YELLOW)
if showShapes:
display.dot(s.getShape(), *xy, ctype=afwDisplay.RED)
if showApertures:
for radius in radii:
display.dot('o',
*xy,
size=radius,
ctype=afwDisplay.YELLOW)
return exposureDict, calibSourcesDict, sourcesDict
def run(display=False):
exposure = loadData()
schema = afwTable.SourceTable.makeMinimalSchema()
#
# Create the detection task
#
config = SourceDetectionTask.ConfigClass()
config.thresholdPolarity = "both"
config.background.isNanSafe = True
config.thresholdValue = 3
detectionTask = SourceDetectionTask(config=config, schema=schema)
#
# And the measurement Task
#
config = SingleFrameMeasurementTask.ConfigClass()
config.plugins.names.clear()
for plugin in [
"base_SdssCentroid", "base_SdssShape", "base_CircularApertureFlux",
"base_GaussianFlux"
]:
config.plugins.names.add(plugin)
config.slots.psfFlux = None
config.slots.apFlux = "base_CircularApertureFlux_3_0"
measureTask = SingleFrameMeasurementTask(schema, config=config)
#
# Print the schema the configuration produced
#
print schema
#
# Create the output table
#
tab = afwTable.SourceTable.make(schema)
#
# Process the data
#
result = detectionTask.run(tab, exposure)
sources = result.sources
print "Found %d sources (%d +ve, %d -ve)" % (
len(sources), result.fpSets.numPos, result.fpSets.numNeg)
measureTask.run(sources, exposure)
if display: # display on ds9 (see also --debug argparse option)
frame = 1
ds9.mtv(exposure, frame=frame)
with ds9.Buffering():
for s in sources:
xy = s.getCentroid()
ds9.dot(
'+',
*xy,
ctype=ds9.CYAN if s.get("flags_negative") else ds9.GREEN,
frame=frame)
ds9.dot(s.getShape(), *xy, ctype=ds9.RED, frame=frame)
ds9.dot(
'o',
*xy,
size=config.plugins["base_CircularApertureFlux"].radii[0],
ctype=ds9.YELLOW,
frame=frame)
def run(config, inputFiles, weightFiles=None, varianceFiles=None,
returnCalibSources=False, displayResults=[], verbose=False):
#
# Create the tasks
#
schema = afwTable.SourceTable.makeMinimalSchema()
algMetadata = dafBase.PropertyList()
isrTask = IsrTask(config=config.isr)
calibrateTask = CalibrateTask(config=config.calibrate)
sourceDetectionTask = SourceDetectionTask(config=config.detection, schema=schema)
if config.doDeblend:
if SourceDeblendTask:
sourceDeblendTask = SourceDeblendTask(config=config.deblend, schema=schema)
else:
print >> sys.stderr, "Failed to import lsst.meas.deblender; setting doDeblend = False"
config.doDeblend = False
sourceMeasurementTask = SingleFrameMeasurementTask(config=config.measurement,
schema=schema, algMetadata=algMetadata)
sourceMeasurementTask.config.doApplyApCorr = 'yes'
#
# Add fields needed to identify stars while calibrating
#
keysToCopy = [(schema.addField(afwTable.Field["Flag"]("calib_detected",
"Source was detected by calibrate")), None)]
for key in calibrateTask.getCalibKeys():
keysToCopy.append((schema.addField(calibrateTask.schema.find(key).field), key))
exposureDict = {}; calibSourcesDict = {}; sourcesDict = {}
for inputFile, weightFile, varianceFile in zip(inputFiles, weightFiles, varianceFiles):
#
# Create the output table
#
tab = afwTable.SourceTable.make(schema)
#
# read the data
#
if verbose:
print "Reading %s" % inputFile
exposure = makeExposure(inputFile, weightFile, varianceFile,
config.badPixelValue, config.variance)
#
if config.interpPlanes:
import lsst.ip.isr as ipIsr
defects = ipIsr.getDefectListFromMask(exposure.getMaskedImage(), config.interpPlanes,
growFootprints=0)
isrTask.run(exposure, defects=defects)
#
# process the data
#
if config.doCalibrate:
result = calibrateTask.run(exposure)
exposure, calibSources = result.exposure, result.sources
else:
calibSources = None
if not exposure.getPsf():
calibrateTask.installInitialPsf(exposure)
exposureDict[inputFile] = exposure
calibSourcesDict[inputFile] = calibSources if returnCalibSources else None
result = sourceDetectionTask.run(tab, exposure)
sources = result.sources
sourcesDict[inputFile] = sources
if config.doDeblend:
sourceDeblendTask.run(exposure, sources, exposure.getPsf())
sourceMeasurementTask.measure(exposure, sources)
if verbose:
print "Detected %d objects" % len(sources)
propagateCalibFlags(keysToCopy, calibSources, sources)
if displayResults: # display results of processing (see also --debug argparse option)
showApertures = "showApertures".upper() in displayResults
showShapes = "showShapes".upper() in displayResults
display = afwDisplay.getDisplay(frame=1)
if algMetadata.exists("base_CircularApertureFlux_radii"):
radii = algMetadata.get("base_CircularApertureFlux_radii")
else:
radii = []
display.mtv(exposure, title=os.path.split(inputFile)[1])
with display.Buffering():
for s in sources:
xy = s.getCentroid()
display.dot('+', *xy,
ctype=afwDisplay.CYAN if s.get("flags_negative") else afwDisplay.GREEN)
if showShapes:
display.dot(s.getShape(), *xy, ctype=afwDisplay.RED)
if showApertures:
for radius in radii:
display.dot('o', *xy, size=radius, ctype=afwDisplay.YELLOW)
return exposureDict, calibSourcesDict, sourcesDict
def detectAndMeasureWithDM(display):
### what file are you going to look at? This should be in fits format.
### The test image included in this example contains stars and galaxies in the center only.
imagefile = "test_image_stars.fits"
### open the file in the stack format
exposure = afwImage.ExposureF(imagefile)
im = exposure.getMaskedImage().getImage()
if display:
### display the original image
frame = 1
ds9.mtv(exposure, frame=frame, title="Original Image"); frame+=1
### Set up the schema
schema = afwTable.SourceTable.makeMinimalSchema()
schema.setVersion(0)
### Create the detection task
config = SourceDetectionTask.ConfigClass()
config.reEstimateBackground = False
detectionTask = SourceDetectionTask(config=config, schema=schema)
### create the measurement task
config = SourceMeasurementTask.ConfigClass()
### algMetadata is used to return info on the active algorithms
algMetadata = dafBase.PropertyList()
### Set up which algorithms you want to run
config.algorithms.names.clear()
for alg in ["shape.sdss", "flux.sinc", "flux.aperture", "flux.gaussian", "flux.psf"]:
config.algorithms.names.add(alg)
config.algorithms["flux.aperture"].radii = [1, 2, 4, 8, 16] # pixels
### Need to un-set some of the slots if we're not using them.
### If you include them in the alg list above, then you don't
###need to unset these quantities.
#config.slots.instFlux = None # flux.gaussian
#config.slots.modelFlux = None # flux.gaussian
#config.slots.psfFlux = None # flux.psf
measureTask = SourceMeasurementTask(schema, algMetadata, config=config)
### Create the output table
tab = afwTable.SourceTable.make(schema)
### uncomments this to see what algorithms have gone into the schema
#print schema
### Process the data
print "*** running detection task..."
sources = detectionTask.run(tab, exposure, sigma=5).sources
print "*** running measure task..."
measureTask.measure(exposure, sources)
if display:
### Plot the results
ds9.mtv(exposure, frame=frame, title="Measured Sources")
with ds9.Buffering():
for s in sources:
xy = s.getCentroid()
ds9.dot('+', *xy, ctype=ds9.CYAN if s.get("flags.negative") else ds9.GREEN, frame=frame)
ds9.dot(s.getShape(), *xy, ctype=ds9.RED, frame=frame)
print sources[0]
### Look at some of the information measured.
### TODO: add more useful quantities to this.
centroids = []
for i in range(len(sources)):
record = sources[i]
centroid = record.getCentroid() #Returns a Point object containing the measured x and y.
centroidErr = record.getCentroid()#Returns the 2x2 symmetric covariance matrix, with rows and columns ordered (x, y)
### quantities from the SdssShape class, calculated because we specified shape.sdss
ixx = record.getIxx()
iyy = record.getIyy()
ixy = record.getIxy()
centroids.append(centroid)
print "first centroid:", centroids[0]
