def testConstructorErrors(self):
"""Test constructor errors
"""
def duplicateAmpName(dw):
"""Set two amplifiers to the same name"""
dw.ampInfo[1].setName(dw.ampInfo[0].getName())
with self.assertRaises(lsst.pex.exceptions.Exception):
DetectorWrapper(modFunc=duplicateAmpName)
def addBadCameraSys(dw):
"""Add an invalid camera system"""
dw.transMap[cameraGeom.CameraSys("foo", "wrong detector")] = \
afwGeom.makeIdentityTransform()
with self.assertRaises(lsst.pex.exceptions.Exception):
DetectorWrapper(modFunc=addBadCameraSys)
# These break in the pybind layer
for crosstalk in (
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0], # 1D and not numpy
np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0,
9.0]), # 1D, wrong numpy type
np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0],
dtype=np.float32), # 1D
):
self.assertRaises(TypeError, DetectorWrapper, crosstalk=crosstalk)
# These break in the Detector ctor: wrong shape
self.assertRaises(lsst.pex.exceptions.InvalidParameterError,
DetectorWrapper,
crosstalk=np.array([[1.0, 2.0], [3.0, 4.0]]))
self.assertRaises(lsst.pex.exceptions.InvalidParameterError,
DetectorWrapper,
crosstalk=np.array([[1.0, 2.0], [3.0, 4.0],
[5.0, 6.0]]))
def testConstructorErrors(self):
"""Test constructor errors
"""
def duplicateAmpName(dw):
"""Set two amplifiers to the same name"""
dw.ampInfo[1].setName(dw.ampInfo[0].getName())
with self.assertRaises(lsst.pex.exceptions.Exception):
DetectorWrapper(modFunc=duplicateAmpName)
def addBadCameraSys(dw):
"""Add an invalid camera system"""
dw.transMap[cameraGeom.CameraSys("foo", "wrong detector")] = \
afwGeom.IdentityXYTransform()
with self.assertRaises(lsst.pex.exceptions.Exception):
DetectorWrapper(modFunc=addBadCameraSys)
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):
nSources = 10
# CFHT Filters from the camera mapper.
afwImageUtils.resetFilters()
afwImageUtils.defineFilter('u', lambdaEff=374, alias="u.MP9301")
afwImageUtils.defineFilter('g', lambdaEff=487, alias="g.MP9401")
afwImageUtils.defineFilter('r', lambdaEff=628, alias="r.MP9601")
afwImageUtils.defineFilter('i', lambdaEff=778, alias="i.MP9701")
afwImageUtils.defineFilter('z', lambdaEff=1170, alias="z.MP9801")
self.bbox = geom.Box2I(geom.Point2I(0, 0), geom.Extent2I(1024, 1153))
dataset = measTests.TestDataset(self.bbox)
for srcIdx in range(nSources):
dataset.addSource(100000.0, geom.Point2D(100, 100))
self.inputCatalogNoFlags, _ = make_input_source_catalog(dataset, False)
self.inputCatalog, self.exposure = \
make_input_source_catalog(dataset, True)
detector = DetectorWrapper(id=23,
bbox=self.exposure.getBBox()).detector
visit = afwImage.VisitInfo(exposureId=4321,
exposureTime=200.,
date=dafBase.DateTime(nsecs=1400000000 *
10**9))
self.exposure.setDetector(detector)
self.exposure.getInfo().setVisitInfo(visit)
self.exposure.setFilter(afwImage.Filter('g.MP9401'))
scale = 2
scaleErr = 1
self.photoCalib = afwImage.PhotoCalib(scale, scaleErr)
self.exposure.setPhotoCalib(self.photoCalib)
def testTransform(self):
"""Test the transform method
"""
dw = DetectorWrapper()
pixOffset = dw.orientation.getReferencePoint()
for xyMM in ((25.6, -31.07), (0, 0), (-1.234e5, 3.123e4)):
fpPoint = afwGeom.Point2D(*xyMM)
fpCamPoint = cameraGeom.CameraPoint(fpPoint,
cameraGeom.FOCAL_PLANE)
pixCamPoint = dw.detector.transform(fpCamPoint, cameraGeom.PIXELS)
pixPoint = pixCamPoint.getPoint()
for i in range(2):
self.assertAlmostEquals(
fpPoint[i] / dw.pixelSize[i] + pixOffset[i], pixPoint[i])
fpCamPoint2 = dw.detector.transform(pixCamPoint,
cameraGeom.FOCAL_PLANE)
fpPoint2 = fpCamPoint2.getPoint()
for i in range(2):
self.assertAlmostEquals(fpPoint[i], fpPoint2[i])
# test pix to pix
pixCamPoint2 = dw.detector.transform(pixCamPoint,
cameraGeom.PIXELS)
for i in range(2):
self.assertAlmostEquals(pixCamPoint.getPoint()[i],
pixCamPoint2.getPoint()[i])
# make sure you cannot transform to a different detector
pixCamPoint = dw.detector.makeCameraPoint(afwGeom.Point2D(1, 1),
cameraGeom.PIXELS)
otherCamSys = cameraGeom.CameraSys(cameraGeom.PIXELS, "other detector")
with self.assertRaises(lsst.pex.exceptions.Exception):
dw.detector.transform(pixCamPoint, otherCamSys)
def testTransformAccess(self):
"""Test hasTransform and getTransform
"""
detector = DetectorWrapper().detector
for fromSys in (cameraGeom.FOCAL_PLANE, cameraGeom.PIXELS,
cameraGeom.TAN_PIXELS):
fullFromSys = detector.makeCameraSys(fromSys)
for toSys in (cameraGeom.FOCAL_PLANE, cameraGeom.PIXELS,
cameraGeom.TAN_PIXELS):
fullToSys = detector.makeCameraSys(toSys)
self.assertTrue(detector.hasTransform(fromSys))
self.assertTrue(detector.hasTransform(fullFromSys))
self.assertTrue(detector.hasTransform(toSys))
self.assertTrue(detector.hasTransform(fullToSys))
detector.getTransform(fromSys, toSys)
detector.getTransform(fromSys, fullToSys)
detector.getTransform(fullFromSys, toSys)
detector.getTransform(fullFromSys, fullToSys)
for badCamSys in (cameraGeom.CameraSys("badName"),
cameraGeom.CameraSys("pixels", "badDetectorName")):
self.assertFalse(detector.hasTransform(badCamSys))
self.assertTrue(detector.hasTransform(cameraGeom.PIXELS))
with self.assertRaises(lsst.pex.exceptions.Exception):
detector.getTransform(cameraGeom.PIXELS, badCamSys)
def testMultiPlaneFitsReaders(self):
"""Run tests for MaskedImageFitsReader and ExposureFitsReader.
"""
metadata = PropertyList()
metadata.add("FIVE", 5)
metadata.add("SIX", 6.0)
wcs = makeSkyWcs(Point2D(2.5, 3.75),
SpherePoint(40.0 * degrees, 50.0 * degrees),
np.array([[1E-5, 0.0], [0.0, -1E-5]]))
defineFilter("test_readers_filter", lambdaEff=470.0)
calib = PhotoCalib(2.5E4)
psf = GaussianPsf(21, 21, 8.0)
polygon = Polygon(Box2D(self.bbox))
apCorrMap = ApCorrMap()
visitInfo = VisitInfo(exposureTime=5.0)
transmissionCurve = TransmissionCurve.makeIdentity()
coaddInputs = CoaddInputs(ExposureTable.makeMinimalSchema(),
ExposureTable.makeMinimalSchema())
detector = DetectorWrapper().detector
record = coaddInputs.ccds.addNew()
record.setWcs(wcs)
record.setPhotoCalib(calib)
record.setPsf(psf)
record.setValidPolygon(polygon)
record.setApCorrMap(apCorrMap)
record.setVisitInfo(visitInfo)
record.setTransmissionCurve(transmissionCurve)
record.setDetector(detector)
for n, dtypeIn in enumerate(self.dtypes):
with self.subTest(dtypeIn=dtypeIn):
exposureIn = Exposure(self.bbox, dtype=dtypeIn)
shape = exposureIn.image.array.shape
exposureIn.image.array[:, :] = np.random.randint(low=1,
high=5,
size=shape)
exposureIn.mask.array[:, :] = np.random.randint(low=1,
high=5,
size=shape)
exposureIn.variance.array[:, :] = np.random.randint(low=1,
high=5,
size=shape)
exposureIn.setMetadata(metadata)
exposureIn.setWcs(wcs)
exposureIn.setFilter(Filter("test_readers_filter"))
exposureIn.setFilterLabel(
FilterLabel(physical="test_readers_filter"))
exposureIn.setPhotoCalib(calib)
exposureIn.setPsf(psf)
exposureIn.getInfo().setValidPolygon(polygon)
exposureIn.getInfo().setApCorrMap(apCorrMap)
exposureIn.getInfo().setVisitInfo(visitInfo)
exposureIn.getInfo().setTransmissionCurve(transmissionCurve)
exposureIn.getInfo().setCoaddInputs(coaddInputs)
exposureIn.setDetector(detector)
with lsst.utils.tests.getTempFilePath(".fits") as fileName:
exposureIn.writeFits(fileName)
self.checkMaskedImageFitsReader(exposureIn, fileName,
self.dtypes[n:])
self.checkExposureFitsReader(exposureIn, fileName,
self.dtypes[n:])
def testTransform(self):
"""Test the transform method
"""
dw = DetectorWrapper()
pixOffset = dw.orientation.getReferencePoint()
for xyMM in ((25.6, -31.07), (0, 0), (-1.234e5, 3.123e4)):
fpPoint = afwGeom.Point2D(*xyMM)
pixPoint = dw.detector.transform(fpPoint, cameraGeom.FOCAL_PLANE,
cameraGeom.PIXELS)
for i in range(2):
self.assertAlmostEqual(
fpPoint[i] / dw.pixelSize[i] + pixOffset[i], pixPoint[i])
fpPoint2 = dw.detector.transform(pixPoint, cameraGeom.PIXELS,
cameraGeom.FOCAL_PLANE)
self.assertPairsAlmostEqual(fpPoint, fpPoint2)
# test pix to pix
pixPoint2 = dw.detector.transform(pixPoint, cameraGeom.PIXELS,
cameraGeom.PIXELS)
self.assertPairsAlmostEqual(pixPoint, pixPoint2)
# make sure you cannot transform to or from a different detector
otherCamSys = cameraGeom.CameraSys(cameraGeom.PIXELS, "other detector")
for goodSys in (cameraGeom.PIXELS, cameraGeom.FOCAL_PLANE):
with self.assertRaises(lsst.pex.exceptions.Exception):
dw.detector.transform(pixPoint, goodSys, otherCamSys)
with self.assertRaises(lsst.pex.exceptions.Exception):
dw.detector.transform(pixPoint, otherCamSys, goodSys)
def testCopyDetector(self):
"""Test copyDetector() method
"""
#
# Make a copy without any modifications
#
detector = DetectorWrapper().detector
ndetector = cameraGeom.copyDetector(detector)
self.assertEqual(detector.getName(), ndetector.getName())
self.assertEqual(detector.getBBox(), ndetector.getBBox())
for amp, namp in zip(detector, ndetector):
self.assertEqual(amp.getBBox(), namp.getBBox())
self.assertEqual(amp.getRawXYOffset(), namp.getRawXYOffset())
#
# Now make a copy with a hacked-up set of amps
#
ampInfoCatalog = detector.getAmpInfoCatalog().copy(deep=True)
for i, amp in enumerate(ampInfoCatalog, 1):
amp.setRawXYOffset(i * lsst.geom.ExtentI(1, 1))
ndetector = cameraGeom.copyDetector(detector,
ampInfoCatalog=ampInfoCatalog)
self.assertEqual(detector.getName(), ndetector.getName())
self.assertEqual(detector.getBBox(), ndetector.getBBox())
for i, (amp, namp) in enumerate(zip(detector, ndetector), 1):
self.assertEqual(amp.getBBox(), namp.getBBox())
self.assertNotEqual(amp.getRawXYOffset(), namp.getRawXYOffset())
self.assertEqual(namp.getRawXYOffset()[0], i)
def testDetectorRebuild(self):
"""Test Detector.rebuild() method
"""
#
# Make a copy without any modifications
#
detector = DetectorWrapper().detector
ndetector = detector.rebuild().finish()
self.assertEqual(detector.getName(), ndetector.getName())
self.assertEqual(detector.getBBox(), ndetector.getBBox())
self.assertEqual(detector.getPhysicalType(),
ndetector.getPhysicalType())
for amp, namp in zip(detector, ndetector):
self.assertEqual(amp.getBBox(), namp.getBBox())
self.assertEqual(amp.getRawXYOffset(), namp.getRawXYOffset())
#
# Now make a copy with a hacked-up set of amps
#
builder = detector.rebuild()
for i, amp in enumerate(builder, 1):
amp.setRawXYOffset(i * lsst.geom.ExtentI(1, 1))
ndetector = builder.finish()
self.assertEqual(detector.getName(), ndetector.getName())
self.assertEqual(detector.getBBox(), ndetector.getBBox())
for i, (amp, namp) in enumerate(zip(detector, ndetector), 1):
self.assertEqual(amp.getBBox(), namp.getBBox())
self.assertNotEqual(amp.getRawXYOffset(), namp.getRawXYOffset())
self.assertEqual(namp.getRawXYOffset()[0], i)
def testGainAndReadnoise(self):
isrTask = IsrTask()
detector = DetectorWrapper().detector
raw = afwImage.ExposureF(detector.getBBox())
level = 10
readNoise = 1.5
raw.image.set(level)
amp = detector[0]
for gain in [-1, 0, 0.1, 1, np.NaN]:
# Because amplifiers are immutable, we can't change the gain or
# read noise in-place. Instead, we clone, and update the clone.
testAmp = Amplifier.Builder()
testAmp.assign(amp)
testAmp.setReadNoise(readNoise)
testAmp.setGain(gain)
testAmp.finish()
isrTask.updateVariance(raw, testAmp)
if gain <= 0: # behave the same way as amp.setGain
gain = 1
if math.isnan(gain):
gain = 1
self.assertEqual(raw.variance[0, 0, afwImage.LOCAL],
level / gain + readNoise**2)
def testGainAndReadnoise(self):
import lsst.afw.image as afwImage
from lsst.afw.cameraGeom.testUtils import DetectorWrapper
from lsst.ip.isr import IsrTask
isrTask = IsrTask()
detector = DetectorWrapper().detector
raw = afwImage.ExposureF(detector.getBBox())
level = 10
readNoise = 1
raw.image.set(level)
amp = detector[0]
amp.setReadNoise(readNoise)
for gain in [-1, 0, 0.1, 1]:
amp.setGain(gain)
isrTask.updateVariance(raw, amp)
if gain <= 0:
gain = 1
self.assertEqual(raw.variance[0, 0, afwImage.LOCAL],
level / gain + readNoise**2)
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 testConstructorErrors(self):
"""Test constructor errors
"""
def duplicateAmpName(dw):
"""Set two amplifiers to the same name"""
dw.ampInfo[1].setName(dw.ampInfo[0].getName())
with self.assertRaises(lsst.pex.exceptions.Exception):
DetectorWrapper(modFunc=duplicateAmpName)
# These break in the pybind layer
for crosstalk in (
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0], # 1D and not numpy
np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0,
9.0]), # 1D, wrong numpy type
np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0],
dtype=np.float32), # 1D
):
self.assertRaises(TypeError, DetectorWrapper, crosstalk=crosstalk)
# These break in the Detector ctor: wrong shape
self.assertRaises(lsst.pex.exceptions.InvalidParameterError,
DetectorWrapper,
crosstalk=np.array([[1.0, 2.0], [3.0, 4.0]]))
self.assertRaises(lsst.pex.exceptions.InvalidParameterError,
DetectorWrapper,
crosstalk=np.array([[1.0, 2.0], [3.0, 4.0],
[5.0, 6.0]]))
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 test_makeWcs_fail_if_detector_is_bad(self):
"""If Detector is broken, raise an exception.
"""
# This detector doesn't know about FIELD_ANGLE, so can't be used to
# make a SkyWcs.
detector = DetectorWrapper().detector
with self.assertRaises(InitialSkyWcsError):
self.formatter.makeWcs(self.visitInfo, detector)
def testPersistence(self):
"""Test round-tripping a Detector through FITS I/O.
"""
dw = DetectorWrapper()
detectorIn = dw.detector
with lsst.utils.tests.getTempFilePath("*.fits") as filename:
detectorIn.writeFits(filename)
detectorOut = cameraGeom.Detector.readFits(filename)
self.assertDetectorsEqual(detectorIn, detectorOut)
def __init__(self,
shape=geom.Extent2I(201, 301),
offset=geom.Point2I(-123, -45),
backgroundLevel=314.592,
seed=42,
nSrc=37,
fluxRange=2.,
noiseLevel=5,
sourceSigma=200.,
minPsfSize=1.5,
maxPsfSize=3.,
pixelScale=0.2 * arcseconds,
ra=209. * degrees,
dec=-20.25 * degrees,
ccd=37,
patch=42,
patchGen2="2,3",
tract=0):
self.ra = ra
self.dec = dec
self.pixelScale = pixelScale
self.patch = patch
self.patchGen2 = patchGen2
self.tract = tract
self.filterLabel = afwImage.FilterLabel(band="gTest", physical="gTest")
self.rngData = np.random.default_rng(seed)
self.rngMods = np.random.default_rng(seed + 1)
self.bbox = geom.Box2I(offset, shape)
if not self.bbox.contains(0, 0):
raise ValueError(
f"The bounding box must contain the coordinate (0, 0). {repr(self.bbox)}"
)
self.wcs = self.makeDummyWcs()
# Set up properties of the simulations
nSigmaForKernel = 5
self.kernelSize = (int(maxPsfSize * nSigmaForKernel + 0.5) //
2) * 2 + 1 # make sure it is odd
bufferSize = self.kernelSize // 2
x0, y0 = self.bbox.getBegin()
xSize, ySize = self.bbox.getDimensions()
# Set the pixel coordinates and fluxes of the simulated sources.
self.xLoc = self.rngData.random(nSrc) * (
xSize - 2 * bufferSize) + bufferSize + x0
self.yLoc = self.rngData.random(nSrc) * (
ySize - 2 * bufferSize) + bufferSize + y0
self.flux = (self.rngData.random(nSrc) *
(fluxRange - 1.) + 1.) * sourceSigma * noiseLevel
self.backgroundLevel = backgroundLevel
self.noiseLevel = noiseLevel
self.minPsfSize = minPsfSize
self.maxPsfSize = maxPsfSize
self.detector = DetectorWrapper(name=f"detector {ccd}",
id=ccd).detector
def testGetCenter(self):
"""Test the getCenter method
"""
dw = DetectorWrapper()
ctrPixPoint = lsst.geom.Box2D(dw.detector.getBBox()).getCenter()
for cameraSys in (cameraGeom.FOCAL_PLANE, cameraGeom.PIXELS):
ctrPoint = dw.detector.getCenter(cameraSys)
transform = dw.detector.getTransform(cameraGeom.PIXELS, cameraSys)
predCtrPoint = transform.applyForward(ctrPixPoint)
self.assertPairsAlmostEqual(predCtrPoint, ctrPoint)
def testIteration(self):
"""Test iteration over amplifiers and __getitem__
"""
dw = DetectorWrapper()
ampList = [amp for amp in dw.detector]
self.assertEquals(len(ampList), len(dw.ampInfo))
for i, amp in enumerate(ampList):
self.assertEquals(amp.getName(), dw.detector[i].getName())
self.assertEquals(amp.getName(), dw.ampInfo[i].getName())
self.assertEquals(amp.getName(), dw.detector[amp.getName()].getName())
def setUp(self):
np.random.seed(1234)
self.cutoutSize = 35
self.center = lsst.geom.Point2D(50.1, 49.8)
self.bbox = lsst.geom.Box2I(lsst.geom.Point2I(-20, -30),
lsst.geom.Extent2I(140, 160))
self.dataset = lsst.meas.base.tests.TestDataset(self.bbox)
self.dataset.addSource(100000.0, self.center)
exposure, catalog = self.dataset.realize(
10.0, self.dataset.makeMinimalSchema(), randomSeed=0)
self.exposure = exposure
detector = DetectorWrapper(id=23, bbox=exposure.getBBox()).detector
self.exposure.setDetector(detector)
visit = afwImage.VisitInfo(exposureId=1234,
exposureTime=200.,
date=dafBase.DateTime(
"2014-05-13T17:00:00.000000000",
dafBase.DateTime.Timescale.TAI))
self.exposure.getInfo().setVisitInfo(visit)
self.filter_names = ["g"]
afwImageUtils.resetFilters()
afwImageUtils.defineFilter('g', lambdaEff=487, alias="g.MP9401")
self.exposure.setFilter(afwImage.Filter('g'))
diaObjects = makeDiaObjects(2, self.exposure)
diaSourceHistory = makeDiaSources(10, diaObjects["diaObjectId"],
self.exposure)
diaForcedSources = makeDiaForcedSources(10, diaObjects["diaObjectId"],
self.exposure)
self.diaObjects, diaSourceHistory, self.diaForcedSources = _roundTripThroughApdb(
diaObjects, diaSourceHistory, diaForcedSources,
self.exposure.getInfo().getVisitInfo().getDate().toPython())
self.diaObjects.replace(to_replace=[None], value=np.nan, inplace=True)
diaSourceHistory.replace(to_replace=[None], value=np.nan, inplace=True)
self.diaForcedSources.replace(to_replace=[None],
value=np.nan,
inplace=True)
diaSourceHistory["programId"] = 0
self.diaSources = diaSourceHistory.loc[[(0, "g", 8), (1, "g", 9)], :]
self.diaSources["bboxSize"] = self.cutoutSize
self.diaSourceHistory = diaSourceHistory.drop(labels=[(0, "g",
8), (1, "g",
9)])
self.cutoutWcs = wcs.WCS(naxis=2)
self.cutoutWcs.wcs.crpix = [self.center[0], self.center[1]]
self.cutoutWcs.wcs.crval = [
self.exposure.getWcs().getSkyOrigin().getRa().asDegrees(),
self.exposure.getWcs().getSkyOrigin().getDec().asDegrees()
]
self.cutoutWcs.wcs.cd = self.exposure.getWcs().getCdMatrix()
self.cutoutWcs.wcs.ctype = ["RA---TAN", "DEC--TAN"]
def setUp(self):
# Define point2D object which are distributed about a detector
self.positions = [lsst.afw.geom.Point2D(*x) for x in ((50.1, 49.8), (12, 15.6), (13.4, 100.0))]
# Define a box which will be used to as boundaries to construct an detector object
self.bbox = lsst.afw.geom.Box2I(lsst.afw.geom.Point2I(-20, -30),
lsst.afw.geom.Extent2I(140, 160))
self.dataset = lsst.meas.base.tests.TestDataset(self.bbox)
# Add in sources to synthetic dataset at defined positions with an arbitrary value
for pos in self.positions:
self.dataset.addSource(100000.0, pos)
self.dw = DetectorWrapper()
def testSetPolygonIntersect(self):
# Create a detector
detector = DetectorWrapper().detector
numPolygonPoints = 50
# Create an exposure with bounding box defined by detector
exposure = afwImage.ExposureF(detector.getBBox())
exposure.setDetector(detector)
pixelSizeMm = exposure.getDetector().getPixelSize()[0]
pixX0 = exposure.getX0()
pixY0 = exposure.getY0()
pixX1 = pixX0 + exposure.getWidth() - 1
pixY1 = pixY0 + exposure.getHeight() - 1
fpCenter = exposure.getDetector().getCenter(FOCAL_PLANE)
fpCenterX = fpCenter[0]
fpCenterY = fpCenter[1]
pixCenter = exposure.getDetector().getCenter(PIXELS)
# Create an instance of IsrTask
task = IsrTask()
# Make a polygon that encompases entire ccd (radius of 2*max of width/height)
fpRadius = 2.0*max(exposure.getWidth()*pixelSizeMm, exposure.getHeight()*pixelSizeMm)
fpPolygon = makeCircularPolygon(fpCenterX, fpCenterY, fpRadius, numPolygonPoints)
# Set the polygon that is the intersection of fpPolygon and ccd
task.setValidPolygonIntersect(exposure, fpPolygon)
# Since the ccd is fully contained in the fpPolygon, the intersection should be the ccdPolygon itself
ccdPolygonPix = afwGeom.Polygon(exposure.getDetector().getCorners(PIXELS))
self.assertEqual(exposure.getInfo().getValidPolygon(), ccdPolygonPix)
# Make a polygon that is entirely within, but smaller than, the ccd
# (radius of 0.2*min of width/height)
fpRadius = 0.2*min(exposure.getWidth()*pixelSizeMm, exposure.getHeight()*pixelSizeMm)
fpPolygon = makeCircularPolygon(fpCenterX, fpCenterY, fpRadius, numPolygonPoints)
# Set the polygon that is the intersection of fpPolygon and ccd
task.setValidPolygonIntersect(exposure, fpPolygon)
# all vertices of polygon should be contained within the ccd
for x in exposure.getInfo().getValidPolygon():
self.assertTrue(ccdPolygonPix.contains(afwGeom.Point2D(x)))
# intersection is smaller than the ccd
self.assertNotEqual(exposure.getInfo().getValidPolygon(), ccdPolygonPix)
# make a simple square polygon that partly intersects the ccd, centered at ccd center
fpPolygonSize = max(exposure.getWidth()*pixelSizeMm, exposure.getHeight()*pixelSizeMm)
fpPolygon = makeSquarePolygon(fpCenterX, fpCenterY, fpPolygonSize)
task.setValidPolygonIntersect(exposure, fpPolygon)
# Check that the polygon contains the central pixel (offset by one to actually be "contained")
pixCenterPlusOne = afwGeom.Point2D(pixCenter[0] + 1, pixCenter[1] + 1)
self.assertTrue(exposure.getInfo().getValidPolygon().contains(afwGeom.Point2D(pixCenterPlusOne)))
# Check that the polygon contains the upper right ccd edge
self.assertTrue(exposure.getInfo().getValidPolygon().contains(afwGeom.Point2D(pixX1, pixY1)))
def testMakeCameraSys(self):
"""Test the makeCameraSys method
"""
dw = DetectorWrapper()
for sysName in ("csys1", "csys2"):
for detectorName in ("", dw.name, "a different detector"):
inCamSys = cameraGeom.CameraSys(sysName, detectorName)
outCamSys = dw.detector.makeCameraSys(inCamSys)
self.assertEquals(inCamSys, outCamSys)
inCamSysPrefix = cameraGeom.CameraSysPrefix(sysName)
outCamSys2 = dw.detector.makeCameraSys(inCamSysPrefix)
self.assertEquals(outCamSys2, cameraGeom.CameraSys(sysName, dw.name))
def setUp(self):
# CFHT Filters from the camera mapper.
afwImageUtils.resetFilters()
afwImageUtils.defineFilter('u', lambdaEff=374, alias="u.MP9301")
afwImageUtils.defineFilter('g', lambdaEff=487, alias="g.MP9401")
afwImageUtils.defineFilter('r', lambdaEff=628, alias="r.MP9601")
afwImageUtils.defineFilter('i', lambdaEff=778, alias="i.MP9701")
afwImageUtils.defineFilter('z', lambdaEff=1170, alias="z.MP9801")
self.metadata = dafBase.PropertySet()
self.metadata.set("SIMPLE", "T")
self.metadata.set("BITPIX", -32)
self.metadata.set("NAXIS", 2)
self.metadata.set("NAXIS1", 1024)
self.metadata.set("NAXIS2", 1153)
self.metadata.set("RADECSYS", 'FK5')
self.metadata.set("EQUINOX", 2000.)
self.metadata.setDouble("CRVAL1", 215.604025685476)
self.metadata.setDouble("CRVAL2", 53.1595451514076)
self.metadata.setDouble("CRPIX1", 1109.99981456774)
self.metadata.setDouble("CRPIX2", 560.018167811613)
self.metadata.set("CTYPE1", 'RA---SIN')
self.metadata.set("CTYPE2", 'DEC--SIN')
self.metadata.setDouble("CD1_1", 5.10808596133527E-05)
self.metadata.setDouble("CD1_2", 1.85579539217196E-07)
self.metadata.setDouble("CD2_2", -5.10281493481982E-05)
self.metadata.setDouble("CD2_1", -8.27440751733828E-07)
self.wcs = afwGeom.makeSkyWcs(self.metadata)
self.exposure = afwImage.makeExposure(
afwImage.makeMaskedImageFromArrays(np.ones((1024, 1153))),
self.wcs)
detector = DetectorWrapper(id=23,
bbox=self.exposure.getBBox()).detector
visit = afwImage.VisitInfo(exposureId=4321,
exposureTime=200.,
date=dafBase.DateTime(nsecs=1400000000 *
10**9))
self.exposure.setDetector(detector)
self.exposure.getInfo().setVisitInfo(visit)
self.exposure.setFilter(afwImage.Filter('g'))
scale = 2
scaleErr = 1
self.photoCalib = afwImage.PhotoCalib(scale, scaleErr)
self.exposure.setPhotoCalib(self.photoCalib)
self.inputCatalogNoFlags = make_input_source_catalog(10, False)
self.inputCatalog = make_input_source_catalog(10, True)
def testGetCorners(self):
"""Test the getCorners method
"""
dw = DetectorWrapper()
for cameraSys in (cameraGeom.FOCAL_PLANE, cameraGeom.PIXELS):
# positions of corners in specified camera system
cornerList = dw.detector.getCorners(cameraSys)
for posPixels, posCameraSys in zip(
lsst.geom.Box2D(dw.bbox).getCorners(), cornerList):
pixelsToCameraSys = dw.detector.getTransform(
cameraGeom.PIXELS, cameraSys)
predPosCameraSys = pixelsToCameraSys.applyForward(posPixels)
self.assertPairsAlmostEqual(predPosCameraSys, posCameraSys)
if cameraSys == cameraGeom.PIXELS:
self.assertPairsAlmostEqual(posPixels, predPosCameraSys)
def testGetCenter(self):
"""Test the getCenter method
"""
dw = DetectorWrapper()
ctrPixPoint = afwGeom.Box2D(dw.detector.getBBox()).getCenter()
ctrPixCameraPoint = dw.detector.makeCameraPoint(ctrPixPoint, cameraGeom.PIXELS)
for cameraSys in (cameraGeom.FOCAL_PLANE, cameraGeom.PIXELS):
ctrCameraPoint = dw.detector.getCenter(cameraSys)
self.assertEquals(ctrCameraPoint.getCameraSys().getSysName(), cameraSys.getSysName())
ctrPoint = ctrCameraPoint.getPoint()
predCtrCameraPoint = dw.detector.transform(ctrPixCameraPoint, cameraSys)
predCtrPoint = predCtrCameraPoint.getPoint()
for i in range(2):
self.assertAlmostEquals(ctrPoint[i], predCtrPoint[i])
if cameraSys == cameraGeom.PIXELS:
self.assertAlmostEquals(ctrPixPoint[i], ctrPoint[i])
def testGetCorners(self):
"""Test the getCorners method
"""
dw = DetectorWrapper()
for cameraSys in (cameraGeom.FOCAL_PLANE, cameraGeom.PIXELS):
cornerList = dw.detector.getCorners(cameraSys)
for fromPoint, toPoint in itertools.izip(afwGeom.Box2D(dw.bbox).getCorners(), cornerList):
predToCameraPoint = dw.detector.transform(
dw.detector.makeCameraPoint(fromPoint, cameraGeom.PIXELS),
cameraSys,
)
predToPoint = predToCameraPoint.getPoint()
self.assertEquals(predToCameraPoint.getCameraSys().getSysName(), cameraSys.getSysName())
for i in range(2):
self.assertAlmostEquals(predToPoint[i], toPoint[i])
if cameraSys == cameraGeom.PIXELS:
self.assertAlmostEquals(fromPoint[i], toPoint[i])
def get_psf_exp(
exp,
coadd_cen_skypos,
var,
):
"""
create a psf exposure to be coadded, rendered at the
position in the exposure corresponding to the center of the
coadd
Parameters
----------
exp: afw_image.ExposureF
The exposure
coadd_cen_skypos: SpherePoint
The sky position of the center of the coadd within its
bbox
var: float
The variance to set in the psf variance map
Returns
-------
psf ExposureF
"""
wcs = exp.getWcs()
pos = wcs.skyToPixel(coadd_cen_skypos)
psf_obj = exp.getPsf()
psf_image = psf_obj.computeImage(pos).array
psf_dim = psf_image.shape[0]
psf_bbox = get_psf_bbox(pos=pos, dim=psf_dim)
# wcs same as SE exposure
psf_exp = afw_image.ExposureF(psf_bbox, wcs)
psf_exp.image.array[:, :] = psf_image
psf_exp.variance.array[:, :] = var
psf_exp.mask.array[:, :] = 0
psf_exp.setFilterLabel(exp.getFilterLabel())
detector = DetectorWrapper().detector
psf_exp.setDetector(detector)
return psf_exp
def testTransformAccess(self):
"""Test hasTransform and getTransform
"""
detector = DetectorWrapper().detector
for camSys in (cameraGeom.FOCAL_PLANE, cameraGeom.PIXELS, cameraGeom.TAN_PIXELS):
# camSys may be a CameraSys or a CameraSysPrefix
fullCamSys = detector.makeCameraSys(camSys)
self.assertTrue(detector.hasTransform(camSys))
self.assertTrue(detector.hasTransform(fullCamSys))
detector.getTransform(camSys)
detector.getTransform(fullCamSys)
for badCamSys in (
cameraGeom.CameraSys("badName"),
cameraGeom.CameraSys("pixels", "badDetectorName")
):
self.assertFalse(detector.hasTransform(badCamSys))
self.assertRaises(lsst.pex.exceptions.Exception, detector.getTransform, badCamSys)
