def std_raw(self, item, dataId):
"""Standardize a raw dataset by converting it to an Exposure.
Raw images are MEF files with one HDU for each detector.
Parameters
----------
item : `lsst.afw.image.DecoratedImage`
The image read by the butler.
dataId : data ID
Data identifier.
Returns
-------
result : `lsst.afw.image.Exposure`
The standardized Exposure.
"""
# Convert the raw DecoratedImage to an Exposure, set metadata and wcs.
exp = exposureFromImage(item, logger=self.log)
md = exp.getMetadata()
visitInfo = self.makeRawVisitInfo(md=md)
exp.getInfo().setVisitInfo(visitInfo)
# Standardize an Exposure, including setting the photoCalib object
return self._standardizeExposure(self.exposures['raw'],
exp,
dataId,
trimmed=False)
def std_raw(self, item, dataId):
"""Standardize a raw dataset by converting it to an Exposure.
Raw images are MEF files with one HDU for each detector.
Header keywords EXPTIME and MJD-OBS exist only in the zeroth
extension and are copied to metadata.
@param item: The image read by the butler
@param dataId: Data identifier
@return (lsst.afw.image.Exposure) the standardized Exposure
"""
# Convert the raw DecoratedImage to an Exposure, set metadata and wcs.
exp = exposureFromImage(item, logger=self.log)
md = exp.getMetadata()
rawPath = self.map_raw(dataId).getLocationsWithRoot()[0]
headerPath = re.sub(r'[\[](\d+)[\]]$', "[0]", rawPath)
md0 = readMetadata(headerPath)
# extra keywords to copy to the exposure
for kw in ('DARKTIME', ):
if kw in md0.paramNames() and kw not in md.paramNames():
md.add(kw, md0.get(kw))
exposureId = self._computeCcdExposureId(dataId)
visitInfo = self.makeRawVisitInfo(md=md0, exposureId=exposureId)
exp.getInfo().setVisitInfo(visitInfo)
# Standardize an Exposure, including setting the calib object
return self._standardizeExposure(self.exposures['raw'],
exp,
dataId,
trimmed=False)
def _standardizeDetrend(self, detrend, image, dataId, filter=False):
"""Hack up detrend images to remove troublesome keyword"""
md = image.getMetadata()
removeKeyword(md, 'RADECSYS') # Irrelevant, and use of "GAPPT" breaks wcslib
md.set('TELAZ', 0) # Irrelevant, -9999 value breaks VisitInfo, and absence generates a warning
md.set('TELALT', 0) # Irrelevant, -9999 value breaks VisitInfo, and absence generates a warning
exp = exposureFromImage(image, logger=self.log)
return self._standardizeExposure(self.calibrations[detrend], exp, dataId, filter=filter,
trimmed=False)
def _standardizeDetrend(self, detrend, image, dataId, filter=False):
"""Hack up detrend images to remove troublesome keyword"""
md = image.getMetadata()
removeKeyword(md, 'RADECSYS') # Irrelevant, and use of "GAPPT" breaks wcslib
md.set('TELAZ', 0) # Irrelevant, -9999 value breaks VisitInfo, and absence generates a warning
md.set('TELALT', 0) # Irrelevant, -9999 value breaks VisitInfo, and absence generates a warning
exp = exposureFromImage(image, logger=self.log)
return self._standardizeExposure(self.calibrations[detrend], exp, dataId, filter=filter,
trimmed=False)
def testDecoratedImage(self):
image = self.maskedImage.getImage()
decoImage = afwImage.DecoratedImageF(image)
metadata = PropertyList()
metadata.set("FOO", "BAR")
decoImage.setMetadata(metadata)
exposure = exposureFromImage(decoImage)
self.assertImagesEqual(exposure.getMaskedImage().getImage(), image)
md = exposure.getMetadata()
self.assertEqual(md.get("FOO"), "BAR")
def std_dark(self, item, dataId):
"""Standardiation of master dark frame. Must only be called on master darks.
@param[in,out] item the master dark, as an image-like object
@param[in] dataId unused
"""
exp = exposureFromImage(item)
if not exp.getInfo().hasVisitInfo():
# hard-coded, but pipe_drivers always(?) normalises darks to a darktime of 1s so this is OK?
exp.getInfo().setVisitInfo(afwImage.VisitInfo(darkTime=1.0))
return exp
def std_eimage(self, item, dataId):
"""Standardize a eimage dataset by converting it to an Exposure instead of an Image"""
exposure = obsBase.exposureFromImage(item, logger=self.log)
exposureId = self._computeCcdExposureId(dataId)
md = exposure.getMetadata()
visitInfo = self.makeRawVisitInfo(md=md, exposureId=exposureId)
exposure.getInfo().setVisitInfo(visitInfo)
return self._standardizeExposure(self.exposures['eimage'],
exposure,
dataId,
trimmed=True)
def testDecoratedImageBadWcs(self):
"""Test that exposureFromImage() attaches a None wcs to the exposure
when the WCS cannot be constructed
"""
image = self.maskedImage.getImage()
decoImage = afwImage.DecoratedImageF(image)
metadata = PropertyList()
metadata.set("CTYPE1", "RA---TPV")
metadata.set("CTYPE2", "DEC--TPV")
decoImage.setMetadata(metadata)
exposure = exposureFromImage(decoImage)
self.assertIs(exposure.getWcs(), None)
def testDecoratedImageBadWcs(self):
"""Test that exposureFromImage() attaches a None wcs to the exposure
when makeWcs() raises an invalidParameter error
"""
image = self.maskedImage.getImage()
decoImage = afwImage.DecoratedImageF(image)
metadata = PropertyList()
metadata.set("CTYPE1", "RA---TPV")
metadata.set("CTYPE2", "DEC--TPV")
decoImage.setMetadata(metadata)
exposure = exposureFromImage(decoImage)
self.assertIs(exposure.getWcs(), None)
def _standardizeExposure(self, mapping, item, dataId, filter=True,
trimmed=True):
"""Default standardization function for images.
@param mapping (lsst.obs.base.Mapping)
@param[in,out] item (lsst.afw.image.Exposure)
@param dataId (dict) Dataset identifier
@param filter (bool) Set filter?
@param trimmed (bool) Should detector be marked as trimmed?
@return (lsst.afw.image.Exposure) the standardized Exposure"""
if (re.search(r'Exposure', mapping.python) and re.search(r'Image', mapping.persistable)):
item = exposureFromImage(item, logger=self.log)
return item
def std_raw(self, item, dataId):
"""Standardize a raw dataset by converting it to an Exposure.
Raw images are MEF files with one HDU for each detector.
Header keywords EXPTIME and MJD-OBS exist only in the zeroth
extension and are copied to metadata.
@param item: The image read by the butler
@param dataId: Data identifier
@return (lsst.afw.image.Exposure) the standardized Exposure
"""
# Convert the raw DecoratedImage to an Exposure, set metadata and wcs.
exp = exposureFromImage(item, logger=self.log)
md = exp.getMetadata()
rawPath = self.map_raw(dataId).getLocationsWithRoot()[0]
headerPath = re.sub(r'[\[](\d+)[\]]$', "[0]", rawPath)
md0 = afwImage.readMetadata(headerPath)
# extra keywords to copy to the exposure
for kw in ('DARKTIME', ):
if kw in md0.paramNames() and kw not in md.paramNames():
md.add(kw, md0.get(kw))
exposureId = self._computeCcdExposureId(dataId)
visitInfo = self.makeRawVisitInfo(md=md0, exposureId=exposureId)
exp.getInfo().setVisitInfo(visitInfo)
# As TPV is not supported yet, the wcs keywords are not pruned
# from the metadata. Once TPV is supported, the following keyword
# removal may not be necessary here and would probably be done at
# makeWcs() when the raw image is converted to an Exposure.
for kw in ('LTV1', 'LTV2'):
md.remove(kw)
# Currently the existence of some PV cards in the metadata combined
# with a CTYPE of TAN is interpreted as TPV (DM-2883).
# However, `lsst.afw.image.makeWcs` (which is called by `exposureFromImage`,
# and strips most WCS keywords from the metadata) does not strip the PVn_n keywords
# (except on an internal deep copy), so do that here.
for kw in md.paramNames():
if re.match(r'PV\d_\d', kw):
md.remove(kw)
# Standardize an Exposure, including setting the calib object
return self._standardizeExposure(self.exposures['raw'], exp, dataId,
trimmed=False)
def std_raw(self, item, dataId):
"""
Added because there are no valid Wcs in fits headers
Convert the raw DecoratedImage to an Exposure, set metadata and wcs.
"""
exp = exposureFromImage(item)
md = exp.getMetadata()
rawPath = self.map_raw(dataId).getLocations()[0]
headerPath = re.sub(r'[\[](\d+)[\]]$', "[0]", rawPath)
md0 = afwImage.readMetadata(headerPath)
crval = afwCoord.makeCoord(afwCoord.ICRS, 0 * afwGeom.degrees,
0 * afwGeom.degrees)
crpix = afwGeom.PointD(0, 0)
wcs = afwImage.makeWcs(crval, crpix, 1, 0, 0, 1)
exp.setWcs(wcs)
exposureId = self._computeCcdExposureId(dataId)
visitInfo = self.makeRawVisitInfo(md=md0, exposureId=exposureId)
exp.getInfo().setVisitInfo(visitInfo)
return self._standardizeExposure(self.exposures['raw'],
exp,
dataId,
trimmed=True)
def testMaskedImage(self):
exposure = exposureFromImage(self.maskedImage)
self.assertMaskedImagesEqual(self.maskedImage,
exposure.getMaskedImage())
def testImage(self):
image = self.maskedImage.getImage()
exposure = exposureFromImage(image)
self.assertImagesEqual(image, exposure.getMaskedImage().getImage())
def testExposure(self):
inExposure = afwImage.ExposureF(self.maskedImage)
outExposure = exposureFromImage(inExposure)
self.assertIs(inExposure, outExposure)
