def setUp(self):
maskedImage = afwImage.MaskedImageF(inFilePathSmall)
maskedImageMD = readMetadata(inFilePathSmall)
self.smallExposure = afwImage.ExposureF(inFilePathSmall)
self.width = maskedImage.getWidth()
self.height = maskedImage.getHeight()
self.wcs = afwGeom.makeSkyWcs(maskedImageMD, False)
self.md = maskedImageMD
self.psf = DummyPsf(2.0)
self.detector = DetectorWrapper().detector
self.extras = {"misc": DummyPsf(3.5)}
self.exposureBlank = afwImage.ExposureF()
self.exposureMiOnly = afwImage.makeExposure(maskedImage)
self.exposureMiWcs = afwImage.makeExposure(maskedImage, self.wcs)
# n.b. the (100, 100, ...) form
self.exposureCrWcs = afwImage.ExposureF(100, 100, self.wcs)
# test with ExtentI(100, 100) too
self.exposureCrOnly = afwImage.ExposureF(lsst.geom.ExtentI(100, 100))
afwImage.Filter.reset()
afwImage.FilterProperty.reset()
defineFilter("g", 470.0)
def setUp(self):
np.random.seed(1)
schema = lsst.afw.table.ExposureTable.makeMinimalSchema()
self.ka = schema.addField("a", type=float, doc="doc for a")
self.kb = schema.addField("b", type=int, doc="doc for b")
self.cat = lsst.afw.table.ExposureCatalog(schema)
self.wcs = self.createWcs()
self.psf = DummyPsf(2.0)
self.bbox0 = lsst.afw.geom.Box2I(
lsst.afw.geom.Box2D(
self.wcs.getPixelOrigin() - lsst.afw.geom.Extent2D(5.0, 4.0),
self.wcs.getPixelOrigin() +
lsst.afw.geom.Extent2D(20.0, 30.0)))
self.bbox1 = lsst.afw.geom.Box2I(
lsst.afw.geom.Box2D(
self.wcs.getPixelOrigin() - lsst.afw.geom.Extent2D(15.0, 40.0),
self.wcs.getPixelOrigin() + lsst.afw.geom.Extent2D(3.0, 6.0)))
self.calib = lsst.afw.image.Calib()
self.calib.setFluxMag0(56.0, 2.2)
self.visitInfo = self.createVisitInfo()
record0 = self.cat.addNew()
record0.setId(1)
record0.set(self.ka, np.pi)
record0.set(self.kb, 4)
record0.setBBox(self.bbox0)
record0.setPsf(self.psf)
record0.setWcs(self.wcs)
record0.setCalib(self.calib)
record0.setVisitInfo(self.visitInfo)
record1 = self.cat.addNew()
record1.setId(2)
record1.set(self.ka, 2.5)
record1.set(self.kb, 2)
record1.setWcs(self.wcs)
record1.setBBox(self.bbox1)
def setUp(self):
maskedImage = afwImage.MaskedImageF(inFilePathSmall)
maskedImageMD = afwImage.readMetadata(inFilePathSmall)
self.smallExposure = afwImage.ExposureF(inFilePathSmall)
self.width = maskedImage.getWidth()
self.height = maskedImage.getHeight()
self.wcs = afwImage.makeWcs(maskedImageMD)
self.psf = DummyPsf(2.0)
self.detector = DetectorWrapper().detector
self.exposureBlank = afwImage.ExposureF()
self.exposureMiOnly = afwImage.makeExposure(maskedImage)
self.exposureMiWcs = afwImage.makeExposure(maskedImage, self.wcs)
self.exposureCrWcs = afwImage.ExposureF(
100, 100, self.wcs) # n.b. the (100, 100, ...) form
self.exposureCrOnly = afwImage.ExposureF(afwGeom.ExtentI(
100, 100)) # test with ExtentI(100, 100) too
afwImage.Filter.reset()
afwImage.FilterProperty.reset()
filterPolicy = pexPolicy.Policy()
filterPolicy.add("lambdaEff", 470.0)
afwImage.Filter.define(afwImage.FilterProperty("g", filterPolicy))
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 testSetMembers(self):
"""
Test that the MaskedImage and the WCS of an Exposure can be set.
"""
exposure = afwImage.ExposureF()
maskedImage = afwImage.MaskedImageF(inFilePathSmall)
exposure.setMaskedImage(maskedImage)
exposure.setWcs(self.wcs)
exposure.setDetector(self.detector)
exposure.setFilter(afwImage.Filter("g"))
self.assertEqual(exposure.getDetector().getName(),
self.detector.getName())
self.assertEqual(exposure.getDetector().getSerial(),
self.detector.getSerial())
self.assertEqual(exposure.getFilter().getName(), "g")
try:
exposure.getWcs()
except pexExcept.Exception as e:
print("caught expected exception (getWcs): %s" % e)
pass
#
# Test the Calib member. The Calib tests are in color.py, here we just check that it's in Exposure
#
calib = exposure.getCalib()
fluxMag0, FluxMag0Err = 1.1e12, 2.2e10
calib.setFluxMag0(fluxMag0, FluxMag0Err)
self.assertEqual(exposure.getCalib().getFluxMag0(),
(fluxMag0, FluxMag0Err))
#
# now check that we can set Calib
#
calib = afwImage.Calib()
fluxMag0_2, fluxMag0Err_2 = (511.1, 44.4)
calib.setFluxMag0(fluxMag0_2, fluxMag0Err_2)
exposure.setCalib(calib)
self.assertEqual(exposure.getCalib().getFluxMag0(),
(fluxMag0_2, fluxMag0Err_2))
#
# Psfs next
#
self.assertFalse(exposure.hasPsf())
exposure.setPsf(self.psf)
self.assertTrue(exposure.hasPsf())
exposure.setPsf(DummyPsf(1.0)) # we can reset the Psf
# Test that we can set the MaskedImage and WCS of an Exposure
# that already has both
self.exposureMiWcs.setMaskedImage(maskedImage)
exposure.setWcs(self.wcs)
def testSetMembers(self):
"""
Test that the MaskedImage and the WCS of an Exposure can be set.
"""
exposure = afwImage.ExposureF()
maskedImage = afwImage.MaskedImageF(inFilePathSmall)
exposure.setMaskedImage(maskedImage)
exposure.setWcs(self.wcs)
exposure.setDetector(self.detector)
exposure.setFilter(afwImage.Filter("g"))
exposure.setFilterLabel(afwImage.FilterLabel(band="g"))
self.assertEqual(exposure.getDetector().getName(),
self.detector.getName())
self.assertEqual(exposure.getDetector().getSerial(),
self.detector.getSerial())
self.assertEqual(exposure.getFilter().getName(), "g")
self.assertEqual(exposure.getFilterLabel().bandLabel, "g")
self.assertEqual(exposure.getWcs(), self.wcs)
# The PhotoCalib tests are in test_photoCalib.py;
# here we just check that it's gettable and settable.
self.assertIsNone(exposure.getPhotoCalib())
photoCalib = afwImage.PhotoCalib(511.1, 44.4)
exposure.setPhotoCalib(photoCalib)
self.assertEqual(exposure.getPhotoCalib(), photoCalib)
# Psfs next
self.assertFalse(exposure.hasPsf())
exposure.setPsf(self.psf)
self.assertTrue(exposure.hasPsf())
exposure.setPsf(DummyPsf(1.0)) # we can reset the Psf
# extras next
info = exposure.getInfo()
for key, value in self.extras.items():
self.assertFalse(info.hasComponent(key))
self.assertIsNone(info.getComponent(key))
info.setComponent(key, value)
self.assertTrue(info.hasComponent(key))
self.assertEqual(info.getComponent(key), value)
info.removeComponent(key)
self.assertFalse(info.hasComponent(key))
# Test that we can set the MaskedImage and WCS of an Exposure
# that already has both
self.exposureMiWcs.setMaskedImage(maskedImage)
exposure.setWcs(self.wcs)
def testCopyExposure(self):
"""Copy an Exposure (maybe changing type)"""
exposureU = afwImage.ExposureU(inFilePathSmall)
exposureU.setWcs(self.wcs)
exposureU.setDetector(self.detector)
exposureU.setFilter(afwImage.Filter("g"))
exposureU.setPsf(DummyPsf(4.0))
exposureF = exposureU.convertF()
self.cmpExposure(exposureF, exposureU)
nexp = exposureF.Factory(exposureF, False)
self.cmpExposure(exposureF, nexp)
def testCopyExposure(self):
"""Copy an Exposure (maybe changing type)"""
exposureU = afwImage.ExposureU(inFilePathSmall)
exposureU.setWcs(self.wcs)
exposureU.setDetector(cameraGeom.Detector(cameraGeom.Id(666)))
exposureU.setFilter(afwImage.Filter("g"))
exposureU.getCalib().setExptime(666)
exposureU.setPsf(DummyPsf(4.0))
exposureF = exposureU.convertF()
self.cmpExposure(exposureF, exposureU)
nexp = exposureF.Factory(exposureF, False)
self.cmpExposure(exposureF, nexp)
def testCopyExposure(self):
"""Copy an Exposure (maybe changing type)"""
exposureU = afwImage.ExposureU(inFilePathSmall, allowUnsafe=True)
exposureU.setWcs(self.wcs)
exposureU.setDetector(self.detector)
exposureU.setFilter(afwImage.Filter("g"))
exposureU.setPsf(DummyPsf(4.0))
infoU = exposureU.getInfo()
for key, value in self.extras.items():
infoU.setComponent(key, value)
exposureF = exposureU.convertF()
self.cmpExposure(exposureF, exposureU)
nexp = exposureF.Factory(exposureF, False)
self.cmpExposure(exposureF, nexp)
def setUp(self):
np.random.seed(1)
schema = lsst.afw.table.ExposureTable.makeMinimalSchema()
self.ka = schema.addField("a", type=np.float64, doc="doc for a")
self.kb = schema.addField("b", type=np.int64, doc="doc for b")
self.cat = lsst.afw.table.ExposureCatalog(schema)
self.wcs = self.createWcs()
self.psf = DummyPsf(2.0)
self.bbox0 = lsst.geom.Box2I(
lsst.geom.Box2D(
self.wcs.getPixelOrigin() - lsst.geom.Extent2D(5.0, 4.0),
self.wcs.getPixelOrigin() + lsst.geom.Extent2D(20.0, 30.0)
)
)
self.bbox1 = lsst.geom.Box2I(
lsst.geom.Box2D(
self.wcs.getPixelOrigin() - lsst.geom.Extent2D(15.0, 40.0),
self.wcs.getPixelOrigin() + lsst.geom.Extent2D(3.0, 6.0)
)
)
# these numbers are what were persisted as `Calib` objects in the files.
self.photoCalib = lsst.afw.image.makePhotoCalibFromCalibZeroPoint(56.0, 2.2)
self.visitInfo = self.createVisitInfo()
self.detector = DetectorWrapper().detector
record0 = self.cat.addNew()
record0.setId(1)
record0.set(self.ka, np.pi)
record0.set(self.kb, 4)
record0.setBBox(self.bbox0)
record0.setPsf(self.psf)
record0.setWcs(self.wcs)
record0.setPhotoCalib(self.photoCalib)
record0.setVisitInfo(self.visitInfo)
record0.setValidPolygon(None)
record0.setDetector(None)
record1 = self.cat.addNew()
record1.setId(2)
record1.set(self.ka, 2.5)
record1.set(self.kb, 2)
record1.setWcs(self.wcs)
record1.setBBox(self.bbox1)
record1.setValidPolygon(self.makePolygon())
record1.setDetector(self.detector)
class ExposureTestCase(unittest.TestCase):
"""
A test case for the Exposure Class
"""
def setUp(self):
maskedImage = afwImage.MaskedImageF(inFilePathSmall)
maskedImageMD = afwImage.readMetadata(inFilePathSmall)
self.smallExposure = afwImage.ExposureF(inFilePathSmall)
self.width = maskedImage.getWidth()
self.height = maskedImage.getHeight()
self.wcs = afwImage.makeWcs(maskedImageMD)
self.psf = DummyPsf(2.0)
self.exposureBlank = afwImage.ExposureF()
self.exposureMiOnly = afwImage.makeExposure(maskedImage)
self.exposureMiWcs = afwImage.makeExposure(maskedImage, self.wcs)
self.exposureCrWcs = afwImage.ExposureF(
100, 100, self.wcs) # n.b. the (100, 100, ...) form
self.exposureCrOnly = afwImage.ExposureF(afwGeom.ExtentI(
100, 100)) # test with ExtentI(100, 100) too
afwImage.Filter.reset()
afwImage.FilterProperty.reset()
filterPolicy = pexPolicy.Policy()
filterPolicy.add("lambdaEff", 470.0)
afwImage.Filter.define(afwImage.FilterProperty("g", filterPolicy))
def tearDown(self):
del self.smallExposure
del self.wcs
del self.psf
del self.exposureBlank
del self.exposureMiOnly
del self.exposureMiWcs
del self.exposureCrWcs
del self.exposureCrOnly
def testGetMaskedImage(self):
"""
Test to ensure a MaskedImage can be obtained from each
Exposure. An Exposure is required to have a MaskedImage,
therefore each of the Exposures should return a MaskedImage.
MaskedImage class should throw appropriate
lsst::pex::exceptions::NotFound if the MaskedImage can not be
obtained.
"""
maskedImageBlank = self.exposureBlank.getMaskedImage()
blankWidth = maskedImageBlank.getWidth()
blankHeight = maskedImageBlank.getHeight()
if blankWidth != blankHeight != 0:
self.fail("%s = %s != 0" % (blankWidth, blankHeight))
maskedImageMiOnly = self.exposureMiOnly.getMaskedImage()
miOnlyWidth = maskedImageMiOnly.getWidth()
miOnlyHeight = maskedImageMiOnly.getHeight()
self.assertAlmostEqual(miOnlyWidth, self.width)
self.assertAlmostEqual(miOnlyHeight, self.height)
# NOTE: Unittests for Exposures created from a MaskedImage and
# a WCS object are incomplete. No way to test the validity of
# the WCS being copied/created.
maskedImageMiWcs = self.exposureMiWcs.getMaskedImage()
miWcsWidth = maskedImageMiWcs.getWidth()
miWcsHeight = maskedImageMiWcs.getHeight()
self.assertAlmostEqual(miWcsWidth, self.width)
self.assertAlmostEqual(miWcsHeight, self.height)
maskedImageCrWcs = self.exposureCrWcs.getMaskedImage()
crWcsWidth = maskedImageCrWcs.getWidth()
crWcsHeight = maskedImageCrWcs.getHeight()
if crWcsWidth != crWcsHeight != 0:
self.fail("%s != %s != 0" % (crWcsWidth, crWcsHeight))
maskedImageCrOnly = self.exposureCrOnly.getMaskedImage()
crOnlyWidth = maskedImageCrOnly.getWidth()
crOnlyHeight = maskedImageCrOnly.getHeight()
if crOnlyWidth != crOnlyHeight != 0:
self.fail("%s != %s != 0" % (crOnlyWidth, crOnlyHeight))
# Check Exposure.getWidth() returns the MaskedImage's width
self.assertEqual(crOnlyWidth, self.exposureCrOnly.getWidth())
self.assertEqual(crOnlyHeight, self.exposureCrOnly.getHeight())
def testGetWcs(self):
"""
Test if a WCS can be obtained from each Exposure created with
a WCS.
Test that appropriate exceptions are thrown if a WCS is
requested from an Exposure that was not created with a WCS.
Python turns the pex::exceptions in the Exposure and
MaskedImage classes into IndexErrors.
The exposureBlank, exposureMiOnly, and exposureCrOnly
Exposures should throw a lsst::pex::exceptions::NotFound.
"""
self.assertTrue(not self.exposureBlank.getWcs())
self.assertTrue(not self.exposureMiOnly.getWcs())
# These two should pass
self.exposureMiWcs.getWcs()
self.exposureCrWcs.getWcs()
self.assertTrue(not self.exposureCrOnly.getWcs())
def testSetMembers(self):
"""
Test that the MaskedImage and the WCS of an Exposure can be set.
"""
exposure = afwImage.ExposureF()
maskedImage = afwImage.MaskedImageF(inFilePathSmall)
exposure.setMaskedImage(maskedImage)
exposure.setWcs(self.wcs)
exposure.setDetector(cameraGeom.Detector(cameraGeom.Id(666)))
exposure.setFilter(afwImage.Filter("g"))
self.assertEquals(exposure.getDetector().getId().getSerial(), 666)
self.assertEquals(exposure.getFilter().getName(), "g")
try:
exposure.getWcs()
except pexExcept.LsstCppException, e:
print "caught expected exception (getWcs): %s" % e
pass
#
# Test the Calib member. The Calib tests are in color.py, here we just check that it's in Exposure
#
calib = exposure.getCalib()
dt = 10
calib.setExptime(dt)
self.assertEqual(exposure.getCalib().getExptime(), dt)
#
# now check that we can set Calib
#
calib = afwImage.Calib()
dt = 666
calib.setExptime(dt)
exposure.setCalib(calib)
self.assertEqual(exposure.getCalib().getExptime(), dt)
#
# Psfs next
#
w, h = 11, 11
self.assertFalse(exposure.hasPsf())
exposure.setPsf(self.psf)
self.assertTrue(exposure.hasPsf())
exposure.setPsf(DummyPsf(1.0)) # we can reset the Psf
# Test that we can set the MaskedImage and WCS of an Exposure
# that already has both
self.exposureMiWcs.setMaskedImage(maskedImage)
exposure.setWcs(self.wcs)
