def testVisitInfoFitsPersistence(self):
"""Test saving an exposure to FITS and reading it back in preserves (some) VisitInfo fields"""
exposureId = 5
exposureTime = 12.3
boresightRotAngle = 45.6 * afwGeom.degrees
weather = afwCoord.Weather(1.1, 2.2, 0.3)
visitInfo = afwImage.makeVisitInfo(
exposureId = exposureId,
exposureTime = exposureTime,
boresightRotAngle = boresightRotAngle,
weather = weather,
)
# Calib used to have exposure time and exposure date, so check for lack of interference
calib = afwImage.Calib(3.4)
exposureInfo = afwImage.ExposureInfo()
exposureInfo.setVisitInfo(visitInfo)
exposureInfo.setCalib(calib)
exposureInfo.setDetector(self.detector)
gFilter = afwImage.Filter("g")
exposureInfo.setFilter(gFilter)
maskedImage = afwImage.MaskedImageF(inFilePathSmall)
exposure = afwImage.ExposureF(maskedImage, exposureInfo)
with lsst.utils.tests.getTempFilePath(".fits") as tmpFile:
exposure.writeFits(tmpFile)
rtExposure = afwImage.ExposureF(tmpFile)
rtVisitInfo = rtExposure.getInfo().getVisitInfo()
self.assertEqual(rtVisitInfo.getWeather(), weather)
self.assertEqual(rtExposure.getCalib(), calib)
self.assertEqual(rtExposure.getFilter(), gFilter)
def testExposureInfoConstructor(self):
"""Test the Exposure(maskedImage, exposureInfo) constructor"""
exposureInfo = afwImage.ExposureInfo()
exposureInfo.setWcs(self.wcs)
exposureInfo.setDetector(self.detector)
gFilter = afwImage.Filter("g")
exposureInfo.setFilter(gFilter)
maskedImage = afwImage.MaskedImageF(inFilePathSmall)
exposure = afwImage.ExposureF(maskedImage, exposureInfo)
self.assertTrue(exposure.hasWcs())
self.assertEqual(exposure.getWcs().getPixelOrigin(),
self.wcs.getPixelOrigin())
self.assertEqual(exposure.getDetector().getName(),
self.detector.getName())
self.assertEqual(exposure.getDetector().getSerial(),
self.detector.getSerial())
self.assertEqual(exposure.getFilter(), gFilter)
self.assertTrue(exposure.getInfo().hasWcs())
self.assertEqual(exposure.getInfo().getWcs().getPixelOrigin(),
self.wcs.getPixelOrigin())
self.assertEqual(exposure.getInfo().getDetector().getName(),
self.detector.getName())
self.assertEqual(exposure.getInfo().getDetector().getSerial(),
self.detector.getSerial())
self.assertEqual(exposure.getInfo().getFilter(), gFilter)
def testVisitInfoFitsPersistence(self):
"""Test saving an exposure to FITS and reading it back in preserves (some) VisitInfo fields"""
exposureId = 5
exposureTime = 12.3
boresightRotAngle = 45.6 * lsst.geom.degrees
weather = Weather(1.1, 2.2, 0.3)
visitInfo = afwImage.VisitInfo(
exposureId=exposureId,
exposureTime=exposureTime,
boresightRotAngle=boresightRotAngle,
weather=weather,
)
photoCalib = afwImage.PhotoCalib(3.4, 5.6)
exposureInfo = afwImage.ExposureInfo()
exposureInfo.setVisitInfo(visitInfo)
exposureInfo.setPhotoCalib(photoCalib)
exposureInfo.setDetector(self.detector)
gFilter = afwImage.Filter("g")
exposureInfo.setFilter(gFilter)
maskedImage = afwImage.MaskedImageF(inFilePathSmall)
exposure = afwImage.ExposureF(maskedImage, exposureInfo)
with lsst.utils.tests.getTempFilePath(".fits") as tmpFile:
exposure.writeFits(tmpFile)
rtExposure = afwImage.ExposureF(tmpFile)
rtVisitInfo = rtExposure.getInfo().getVisitInfo()
self.assertEqual(rtVisitInfo.getWeather(), weather)
self.assertEqual(rtExposure.getPhotoCalib(), photoCalib)
self.assertEqual(rtExposure.getFilter(), gFilter)
def setUp(self):
super().setUp()
afwImage.Filter.reset()
afwImage.FilterProperty.reset()
defineFilter("g", 470.0)
self.wcs = afwGeom.makeSkyWcs(
lsst.geom.Point2D(0.0, 0.0),
lsst.geom.SpherePoint(2.0, 34.0, lsst.geom.degrees),
np.identity(2),
)
self.photoCalib = afwImage.PhotoCalib(1.5)
self.psf = DummyPsf(2.0)
self.detector = DetectorWrapper().detector
self.summaryStats = afwImage.ExposureSummaryStats(ra=100.0)
self.polygon = afwGeom.Polygon(
lsst.geom.Box2D(lsst.geom.Point2D(0.0, 0.0),
lsst.geom.Point2D(25.0, 20.0)))
self.coaddInputs = afwImage.CoaddInputs()
self.apCorrMap = afwImage.ApCorrMap()
self.transmissionCurve = afwImage.TransmissionCurve.makeIdentity()
self.exposureInfo = afwImage.ExposureInfo()
gFilter = afwImage.Filter("g")
gFilterLabel = afwImage.FilterLabel(band="g")
self.exposureInfo.setFilter(gFilter)
self.exposureInfo.setFilterLabel(gFilterLabel)
def testDefaultFilter(self):
"""Test that old convention of having a "default" filter replaced with `None`.
"""
exposureInfo = afwImage.ExposureInfo()
noFilter = afwImage.Filter()
exposureInfo.setFilter(noFilter)
self.assertFalse(exposureInfo.hasFilterLabel())
self.assertIsNone(exposureInfo.getFilterLabel())
def main(just_wfs=False, detector_list=None):
if (just_wfs is True) and (detector_list is not None):
raise RuntimeError("--just_wfs and --detector_list are exclusive.")
camera = LsstCam().getCamera()
if just_wfs:
ccd_list = [
camera[name] for name in [
"R00_SW0", "R00_SW1", "R04_SW0", "R04_SW1", "R44_SW0",
"R44_SW1", "R40_SW0", 'R40_SW1'
]
]
elif (detector_list is not None):
ccd_list = [camera[name] for name in detector_list]
else:
ccd_list = camera
for filt_name in 'ugrizy':
for ccd in ccd_list:
name = ccd.getName()
CHIPID = "".join([c for c in name if c != "," and c != ":"])
CHIPID = "_".join(CHIPID.split())
image = afwImage.ImageF(ccd.getBBox())
for amp in ccd:
subim = afwImage.ImageF(image, amp.getBBox())
subim[:] = 1 / amp.getGain()
print(amp.getName(), amp.getGain())
# need to flip the image to match the result of phosim repackager
oldImageArray = image.array.copy()
image.array[:] = np.flipud(oldImageArray)
expInfo = afwImage.ExposureInfo()
inFilter = afwImage.FilterLabel(filt_name)
expInfo.setFilterLabel(inFilter)
exp = afwImage.ExposureF(afwImage.MaskedImageF(image), expInfo)
md = exp.getMetadata()
md.set('CHIPID', CHIPID)
# Set place holder date
md.set('MJD-OBS', 53005.0)
md.set('OBSTYPE', 'flat')
# arbitrary for flats
md.set('EXPTIME', 100)
# need to be able to specify any filter
md.set('CALDATE', 53005.0)
# Add the CALIB_ID header card
md.set(
'CALIB_ID',
'raftName=%s detectorName=%s detector=%i filter=%s calibDate=%s'
% (CHIPID.split('_')[0], CHIPID.split('_')[1], ccd.getId(),
filt_name, datetime.now()))
exp.setMetadata(md)
exp.writeFits("%(name)s_%(filter)s.fits" % ({
'name': CHIPID,
'filter': filt_name
}))
def testExposureInfoSetNone(self):
exposureInfo = afwImage.ExposureInfo()
exposureInfo.setDetector(None)
exposureInfo.setValidPolygon(None)
exposureInfo.setPsf(None)
exposureInfo.setWcs(None)
exposureInfo.setCalib(None)
exposureInfo.setCoaddInputs(None)
exposureInfo.setVisitInfo(None)
exposureInfo.setApCorrMap(None)
def testCopy(self):
# Test that ExposureInfos have independently settable state
copy = afwImage.ExposureInfo(self.exposureInfo, True)
self.assertEqual(self.exposureInfo.getWcs(), copy.getWcs())
newWcs = afwGeom.makeSkyWcs(lsst.geom.Point2D(-23.0, 8.0),
lsst.geom.SpherePoint(0.0, 0.0, lsst.geom.degrees),
np.identity(2),
)
copy.setWcs(newWcs)
self.assertEqual(copy.getWcs(), newWcs)
self.assertNotEqual(self.exposureInfo.getWcs(), copy.getWcs())
def testExposureInfoSetNone(self):
exposureInfo = afwImage.ExposureInfo()
exposureInfo.setDetector(None)
exposureInfo.setValidPolygon(None)
exposureInfo.setPsf(None)
exposureInfo.setWcs(None)
exposureInfo.setPhotoCalib(None)
exposureInfo.setCoaddInputs(None)
exposureInfo.setVisitInfo(None)
exposureInfo.setApCorrMap(None)
for key in self.extras:
exposureInfo.setComponent(key, None)
def testSetExposureInfo(self):
exposureInfo = afwImage.ExposureInfo()
exposureInfo.setWcs(self.wcs)
exposureInfo.setDetector(self.detector)
gFilter = afwImage.Filter("g")
exposureInfo.setFilter(gFilter)
maskedImage = afwImage.MaskedImageF(inFilePathSmall)
exposure = afwImage.ExposureF(maskedImage)
self.assertFalse(exposure.hasWcs())
exposure.setInfo(exposureInfo)
self.assertTrue(exposure.hasWcs())
self.assertEqual(exposure.getWcs().getPixelOrigin(), self.wcs.getPixelOrigin())
self.assertEquals(exposure.getDetector().getName(), self.detector.getName())
self.assertEquals(exposure.getDetector().getSerial(), self.detector.getSerial())
self.assertEquals(exposure.getFilter(), gFilter)
def main(just_wfs=False, detector_list=None):
if (just_wfs is True) and (detector_list is not None):
raise RuntimeError("--just_wfs and --detector_list are exclusive.")
camera = PhosimMapper().camera
if just_wfs:
ccd_list = [camera[name] for name in ["R00_S22", "R04_S20", "R44_S00", "R40_S02"]]
elif (detector_list is not None):
ccd_list = [camera[name] for name in detector_list]
else:
ccd_list = camera
for filt_name in 'ugrizy':
for ccd in ccd_list:
name = ccd.getName()
# I'm not sure how to deal with the split chips yet.
if 'A' in name or 'B' in name:
continue
print(name)
CHIPID = "".join([c for c in name if c != "," and c != ":"])
CHIPID = "_".join(CHIPID.split())
image = afwImage.ImageF(ccd.getBBox())
for amp in ccd:
subim = afwImage.ImageF(image, amp.getBBox())
subim[:] = amp.getGain()
print(amp.getName(), amp.getGain())
expInfo = afwImage.ExposureInfo()
inFilter = afwImage.Filter(filt_name)
expInfo.setFilter(inFilter)
exp = afwImage.ExposureF(afwImage.MaskedImageF(image), expInfo)
md = exp.getMetadata()
md.set('CHIPID', CHIPID)
# Set place holder date
md.set('MJD-OBS', 53005.0)
md.set('OBSTYPE', 'flat')
# arbitrary for flats
md.set('EXPTIME', 100)
# need to be able to specify any filter
md.set('CALDATE', 53005.0)
# Add the CALIB_ID header card
md.set('CALIB_ID', 'raftName=%s detectorName=%s detector=%i filter=%s calibDate=%s' %
(CHIPID.split('_')[0], CHIPID.split('_')[1], ccd.getId(), filt_name, datetime.now()))
exp.setMetadata(md)
exp.writeFits("%(name)s_%(filter)s.fits"%({'name': CHIPID, 'filter': filt_name}))
def cutout_from_pos(self, params: dict):
""" Get cutout of source image by supported SODA shapes:
POS: CIRCLE, RANGE, POLYGON
LSST extension: BRECT
Parameters
----------
params: `dict`
the POS parameter.
Returns
-------
cutout: `afwImage.Exposure`
"""
_pos = params["POS"]
_id = params["ID"]
db, ds, filt = _id.split(".")
pos_items = _pos.split()
shape = pos_items[0]
if shape == "BRECT":
if len(pos_items) < 6:
raise Exception("BRECT: invalid parameters")
ra, dec = float(pos_items[1]), float(pos_items[2])
w, h = float(pos_items[3]), float(pos_items[4])
unit_size = pos_items[5]
cutout = self.cutout_from_nearest(ra, dec, w, h, unit_size, filt)
return cutout
elif shape == "CIRCLE":
if len(pos_items) < 4:
raise Exception("CIRCLE: invalid parameters")
ra, dec = float(pos_items[1]), float(pos_items[2])
radius = float(pos_items[3])
# convert from deg to pixels by wcs (ICRS)
q_result = self._metaservget.nearest_image_containing(ra, dec, filt)
data_id = self._data_id_from_qr(q_result)
metadata = self._metadata_from_data_id(data_id)
wcs = afwGeom.makeSkyWcs(metadata, strip=False)
pix_r = int(radius / wcs.getPixelScale().asArcseconds())
ss = SpanSet.fromShape(pix_r)
ss_width = ss.getBBox().getWidth()
src_image = self.cutout_from_nearest(ra, dec, ss_width, ss_width,
"pixel", filt)
src_cutout = src_image.getMaskedImage()
circle_cutout = afwImage.MaskedImageF(src_cutout.getBBox())
spanset = SpanSet.fromShape(pix_r, Stencil.CIRCLE,
offset=src_cutout.getXY0() +
afwGeom.Extent2I(pix_r, pix_r))
spanset.copyMaskedImage(src_cutout, circle_cutout)
# make an Exposure cutout with WCS info
cutout = afwImage.ExposureF(circle_cutout,
afwImage.ExposureInfo(wcs))
return cutout
elif shape == "RANGE":
if len(pos_items) < 5:
raise Exception("RANGE: invalid parameters")
# convert the pair of (ra,dec) to bbox
ra1, ra2 = float(pos_items[1]), float(pos_items[2])
dec1, dec2 = float(pos_items[3]), float(pos_items[4])
box = afwGeom.Box2D(afwGeom.Point2D(ra1, dec1),
afwGeom.Point2D(ra2, dec2))
# convert from deg to arcsec
w = box.getWidth()*3600
h = box.getHeight()*3600
# compute the arithmetic center (ra, dec) of the range
ra = (ra1 + ra2) / 2
dec = (dec1 + dec2) / 2
cutout = self.cutout_from_nearest(ra, dec, w, h, "arcsec", filt)
return cutout
elif shape == "POLYGON":
if len(pos_items) < 7:
raise Exception("POLYGON: invalid parameters")
vertices = []
pos_items.pop(0)
for long, lat in zip(pos_items[::2], pos_items[1::2]):
pt = afwGeom.Point2D(float(long), float(lat))
vertices.append(pt)
polygon = afwGeom.Polygon(vertices)
center = polygon.calculateCenter()
ra, dec = center.getX(), center.getY()
# afw limitation: can only return the bbox of the polygon
bbox = polygon.getBBox()
# convert from 'deg' to 'arcsec'
w = bbox.getWidth()*3600
h = bbox.getHeight()*3600
cutout = self.cutout_from_nearest(ra, dec, w, h, "arcsec", filt)
return cutout
