def testArrays(self):
image, mask, variance = self.mimage.getArrays()
self.assert_((self.mimage.getImage().getArray() == image).all())
self.assert_((self.mimage.getMask().getArray() == mask).all())
self.assert_((self.mimage.getVariance().getArray() == variance).all())
mimage2 = afwImage.makeMaskedImageFromArrays(image, mask, variance)
self.assertEqual(type(mimage2), type(self.mimage))
def testArrays(self):
"""
This method is testing that ``lsst.afw.image.MaskedImageF.getArrays()``
returns the proper image, mask, and variance.
"""
image, mask, variance = self.mimage.getArrays()
self.assertFloatsEqual(self.mimage.image.getArray(), image)
self.assertFloatsEqual(self.mimage.mask.getArray(), mask)
self.assertFloatsEqual(self.mimage.variance.getArray(), variance)
mimage2 = afwImage.makeMaskedImageFromArrays(image, mask, variance)
self.assertEqual(type(mimage2), type(self.mimage))
def runBasicTest(self, kernel, convControl, refKernel=None, kernelDescr="", rtol=1.0e-05, atol=1e-08):
"""Assert that afwMath::convolve gives the same result as reference convolution for a given kernel.
Inputs:
- kernel: convolution kernel
- convControl: convolution control parameters (afwMath.ConvolutionControl)
- refKernel: kernel to use for refConvolve (if None then kernel is used)
- kernelDescr: description of kernel
- rtol: relative tolerance (see below)
- atol: absolute tolerance (see below)
rtol and atol are positive, typically very small numbers.
The relative difference (rtol * abs(b)) and the absolute difference "atol" are added together
to compare against the absolute difference between "a" and "b".
"""
if refKernel == None:
refKernel = kernel
# strip garbage characters (whitespace and punctuation) to make a short description for saving files
shortKernelDescr = kernelDescr.translate(NullTranslator, GarbageChars)
doNormalize = convControl.getDoNormalize()
doCopyEdge = convControl.getDoCopyEdge()
maxInterpDist = convControl.getMaxInterpolationDistance()
imMaskVar = self.maskedImage.getArrays()
xy0 = self.maskedImage.getXY0()
refCnvImMaskVarArr = refConvolve(imMaskVar, xy0, refKernel, doNormalize, doCopyEdge)
refMaskedImage = afwImage.makeMaskedImageFromArrays(*refCnvImMaskVarArr)
afwMath.convolve(self.cnvImage, self.maskedImage.getImage(), kernel, convControl)
self.assertEqual(self.cnvImage.getXY0(), self.xy0)
afwMath.convolve(self.cnvMaskedImage, self.maskedImage, kernel, convControl)
if display and False:
ds9.mtv(displayUtils.Mosaic().makeMosaic([
self.maskedImage, refMaskedImage, self.cnvMaskedImage]), frame=0)
if False:
for (x, y) in ((0, 0), (1, 0), (0, 1), (50, 50)):
print "Mask(%d,%d) 0x%x 0x%x" % (x, y, refMaskedImage.getMask().get(x, y),
self.cnvMaskedImage.getMask().get(x, y))
self.assertImagesNearlyEqual(self.cnvImage, refMaskedImage.getImage(), atol=atol, rtol=rtol)
self.assertMaskedImagesNearlyEqual(self.cnvMaskedImage, refMaskedImage, atol=atol, rtol=rtol)
if not sameMaskPlaneDicts(self.cnvMaskedImage, self.maskedImage):
self.cnvMaskedImage.writeFits("act%s" % (shortKernelDescr,))
refMaskedImage.writeFits("des%s" % (shortKernelDescr,))
self.fail("convolve(MaskedImage, kernel=%s, doNormalize=%s, doCopyEdge=%s, maxInterpDist=%s) failed:\n%s" % \
(kernelDescr, doNormalize, doCopyEdge, maxInterpDist, "convolved mask dictionary does not match input"))
def makeGaussianNoiseMaskedImage(dimensions, sigma, variance=1.0):
"""Make a gaussian noise MaskedImageF
Inputs:
- dimensions: dimensions of output array (cols, rows)
- sigma; sigma of image plane's noise distribution
- variance: constant value for variance plane
"""
npSize = (dimensions[1], dimensions[0])
image = numpy.random.normal(loc=0.0, scale=sigma, size=npSize).astype(numpy.float32)
mask = numpy.zeros(npSize, dtype=numpy.uint16)
variance = numpy.zeros(npSize, dtype=numpy.float32) + variance
return afwImage.makeMaskedImageFromArrays(image, mask, variance)
def makeGaussianNoiseMaskedImage(dimensions, sigma, variance=1.0):
"""Make a gaussian noise MaskedImageF
Inputs:
- dimensions: dimensions of output array (cols, rows)
- sigma; sigma of image plane's noise distribution
- variance: constant value for variance plane
"""
npSize = (dimensions[1], dimensions[0])
image = numpy.random.normal(loc=0.0, scale=sigma,
size=npSize).astype(numpy.float32)
mask = numpy.zeros(npSize, dtype=numpy.uint16)
variance = numpy.zeros(npSize, dtype=numpy.float32) + variance
return afwImage.makeMaskedImageFromArrays(image, mask, variance)
def setUp(self):
"""Create a sqlite3 database with default tables and schemas.
"""
# CFHT Filters from the camera mapper.
self.filter_names = ["u", "g", "r", "i", "z"]
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.dia_object_schema = make_dia_object_schema()
# metadata taken from CFHT data
# v695856-e0/v695856-e0-c000-a00.sci_img.fits
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=1234,
exposureTime=200.,
date=dafBase.DateTime("2014-05-13T17:00:00.000000000",
dafBase.DateTime.Timescale.TAI))
self.exposure.setDetector(detector)
self.exposure.getInfo().setVisitInfo(visit)
self.exposure.setFilter(afwImage.Filter('g'))
self.flux0 = 10000
self.flux0_err = 100
self.exposure.setPhotoCalib(
afwImage.PhotoCalib(self.flux0, self.flux0_err))
bbox = geom.Box2D(self.exposure.getBBox())
wcs = self.exposure.getWcs()
self.pixelator = sphgeom.HtmPixelization(20)
region = sphgeom.ConvexPolygon([wcs.pixelToSky(pp).getVector()
for pp in bbox.getCorners()])
indices = self.pixelator.envelope(region, 64)
# Index types must be cast to int to work with dax_apdb.
self.index_ranges = indices.ranges()
def verifyMaskWarp(self,
kernelName,
maskKernelName,
growFullMask,
interpLength=10,
cacheSize=100000,
rtol=4e-05,
atol=1e-2):
"""Verify that using a separate mask warping kernel produces the correct results
Inputs:
- kernelName: name of warping kernel in the form used by afwImage.makeKernel
- maskKernelName: name of mask warping kernel in the form used by afwImage.makeKernel
- interpLength: interpLength argument for lsst.afw.math.WarpingControl
- cacheSize: cacheSize argument for lsst.afw.math.WarpingControl;
0 disables the cache
10000 gives some speed improvement but less accurate results (atol must be increased)
100000 gives better accuracy but no speed improvement in this test
- rtol: relative tolerance as used by np.allclose
- atol: absolute tolerance as used by np.allclose
"""
srcWcs = afwGeom.makeSkyWcs(
crpix=lsst.geom.Point2D(10, 11),
crval=lsst.geom.SpherePoint(41.7, 32.9, lsst.geom.degrees),
cdMatrix=afwGeom.makeCdMatrix(scale=0.2 * lsst.geom.degrees),
)
destWcs = afwGeom.makeSkyWcs(
crpix=lsst.geom.Point2D(9, 10),
crval=lsst.geom.SpherePoint(41.65, 32.95, lsst.geom.degrees),
cdMatrix=afwGeom.makeCdMatrix(scale=0.17 * lsst.geom.degrees),
)
srcMaskedImage = afwImage.MaskedImageF(100, 101)
srcExposure = afwImage.ExposureF(srcMaskedImage, srcWcs)
srcArrays = srcMaskedImage.getArrays()
shape = srcArrays[0].shape
srcArrays[0][:] = np.random.normal(10000, 1000, size=shape)
srcArrays[2][:] = np.random.normal(9000, 900, size=shape)
srcArrays[1][:] = np.reshape(
np.arange(0, shape[0] * shape[1], 1, dtype=np.uint16), shape)
warpControl = afwMath.WarpingControl(kernelName, maskKernelName,
cacheSize, interpLength,
growFullMask)
destMaskedImage = afwImage.MaskedImageF(110, 121)
destExposure = afwImage.ExposureF(destMaskedImage, destWcs)
afwMath.warpExposure(destExposure, srcExposure, warpControl)
# now compute with two separate mask planes
warpControl.setGrowFullMask(0)
narrowMaskedImage = afwImage.MaskedImageF(110, 121)
narrowExposure = afwImage.ExposureF(narrowMaskedImage, destWcs)
afwMath.warpExposure(narrowExposure, srcExposure, warpControl)
narrowArrays = narrowExposure.getMaskedImage().getArrays()
warpControl.setMaskWarpingKernelName("")
broadMaskedImage = afwImage.MaskedImageF(110, 121)
broadExposure = afwImage.ExposureF(broadMaskedImage, destWcs)
afwMath.warpExposure(broadExposure, srcExposure, warpControl)
broadArrays = broadExposure.getMaskedImage().getArrays()
if (kernelName != maskKernelName) and (growFullMask != 0xFFFF):
# we expect the mask planes to differ
if np.all(narrowArrays[1] == broadArrays[1]):
self.fail("No difference between broad and narrow mask")
predMask = (broadArrays[1] & growFullMask) | (
narrowArrays[1] & ~growFullMask).astype(np.uint16)
predArraySet = (broadArrays[0], predMask, broadArrays[2])
predExposure = afwImage.makeMaskedImageFromArrays(*predArraySet)
msg = f"Separate mask warping failed; warpingKernel={kernelName}; maskWarpingKernel={maskKernelName}"
self.assertMaskedImagesAlmostEqual(destExposure.getMaskedImage(),
predExposure,
doImage=True,
doMask=True,
doVariance=True,
rtol=rtol,
atol=atol,
msg=msg)
def makeExposure(flipX=False, flipY=False):
"""Create an exposure and flip the x or y (or both) coordinates.
Returns bounding boxes that are right or left handed around the bounding
polygon.
Parameters
----------
flipX : `bool`
Flip the x coordinate in the WCS.
flipY : `bool`
Flip the y coordinate in the WCS.
Returns
-------
exposure : `lsst.afw.image.Exposure`
Exposure with a valid bounding box and wcs.
"""
metadata = dafBase.PropertySet()
metadata.set("SIMPLE", "T")
metadata.set("BITPIX", -32)
metadata.set("NAXIS", 2)
metadata.set("NAXIS1", 1024)
metadata.set("NAXIS2", 1153)
metadata.set("RADECSYS", 'FK5')
metadata.set("EQUINOX", 2000.)
metadata.setDouble("CRVAL1", 215.604025685476)
metadata.setDouble("CRVAL2", 53.1595451514076)
metadata.setDouble("CRPIX1", 1109.99981456774)
metadata.setDouble("CRPIX2", 560.018167811613)
metadata.set("CTYPE1", 'RA---SIN')
metadata.set("CTYPE2", 'DEC--SIN')
xFlip = 1
if flipX:
xFlip = -1
yFlip = 1
if flipY:
yFlip = -1
metadata.setDouble("CD1_1", xFlip * 5.10808596133527E-05)
metadata.setDouble("CD1_2", yFlip * 1.85579539217196E-07)
metadata.setDouble("CD2_2", yFlip * -5.10281493481982E-05)
metadata.setDouble("CD2_1", xFlip * -8.27440751733828E-07)
wcs = afwGeom.makeSkyWcs(metadata)
exposure = afwImage.makeExposure(
afwImage.makeMaskedImageFromArrays(np.ones((1024, 1153))), wcs)
detector = DetectorWrapper(id=23, bbox=exposure.getBBox()).detector
visit = afwImage.VisitInfo(exposureId=1234,
exposureTime=200.,
date=dafBase.DateTime(
"2014-05-13T17:00:00.000000000",
dafBase.DateTime.Timescale.TAI))
exposure.info.id = 1234
exposure.setDetector(detector)
exposure.getInfo().setVisitInfo(visit)
exposure.setFilter(afwImage.FilterLabel(band='g'))
return exposure
def runBasicTest(self,
kernel,
convControl,
refKernel=None,
kernelDescr="",
rtol=1.0e-05,
atol=1e-08):
"""Assert that afwMath::convolve gives the same result as reference convolution for a given kernel.
Inputs:
- kernel: convolution kernel
- convControl: convolution control parameters (afwMath.ConvolutionControl)
- refKernel: kernel to use for refConvolve (if None then kernel is used)
- kernelDescr: description of kernel
- rtol: relative tolerance (see below)
- atol: absolute tolerance (see below)
rtol and atol are positive, typically very small numbers.
The relative difference (rtol * abs(b)) and the absolute difference "atol" are added together
to compare against the absolute difference between "a" and "b".
"""
if refKernel is None:
refKernel = kernel
# strip garbage characters (whitespace and punctuation) to make a short
# description for saving files
shortKernelDescr = self._removeGarbageChars(kernelDescr)
doNormalize = convControl.getDoNormalize()
doCopyEdge = convControl.getDoCopyEdge()
maxInterpDist = convControl.getMaxInterpolationDistance()
imMaskVar = self.maskedImage.getArrays()
xy0 = self.maskedImage.getXY0()
refCnvImMaskVarArr = refConvolve(imMaskVar, xy0, refKernel,
doNormalize, doCopyEdge)
refMaskedImage = afwImage.makeMaskedImageFromArrays(
*refCnvImMaskVarArr)
afwMath.convolve(self.cnvImage, self.maskedImage.getImage(), kernel,
convControl)
self.assertEqual(self.cnvImage.getXY0(), self.xy0)
afwMath.convolve(self.cnvMaskedImage, self.maskedImage, kernel,
convControl)
if display and False:
ds9.mtv(displayUtils.Mosaic().makeMosaic(
[self.maskedImage, refMaskedImage, self.cnvMaskedImage]),
frame=0)
if False:
for (x, y) in ((0, 0), (1, 0), (0, 1), (50, 50)):
print("Mask(%d,%d) 0x%x 0x%x" %
(x, y, refMaskedImage.getMask().get(
x, y), self.cnvMaskedImage.getMask().get(x, y)))
self.assertImagesAlmostEqual(self.cnvImage,
refMaskedImage.getImage(),
atol=atol,
rtol=rtol)
self.assertMaskedImagesAlmostEqual(self.cnvMaskedImage,
refMaskedImage,
atol=atol,
rtol=rtol)
if not sameMaskPlaneDicts(self.cnvMaskedImage, self.maskedImage):
self.cnvMaskedImage.writeFits("act%s" % (shortKernelDescr, ))
refMaskedImage.writeFits("des%s" % (shortKernelDescr, ))
self.fail("convolve(MaskedImage, kernel=%s, doNormalize=%s, "
"doCopyEdge=%s, maxInterpDist=%s) failed:\n%s" %
(kernelDescr, doNormalize, doCopyEdge, maxInterpDist,
"convolved mask dictionary does not match input"))
def verifyMaskWarp(self, kernelName, maskKernelName, growFullMask, interpLength=10, cacheSize=100000,
rtol=4e-05, atol=1e-2):
"""Verify that using a separate mask warping kernel produces the correct results
Inputs:
- kernelName: name of warping kernel in the form used by afwImage.makeKernel
- maskKernelName: name of mask warping kernel in the form used by afwImage.makeKernel
- interpLength: interpLength argument for lsst.afw.math.WarpingControl
- cacheSize: cacheSize argument for lsst.afw.math.WarpingControl;
0 disables the cache
10000 gives some speed improvement but less accurate results (atol must be increased)
100000 gives better accuracy but no speed improvement in this test
- rtol: relative tolerance as used by np.allclose
- atol: absolute tolerance as used by np.allclose
"""
srcWcs = afwGeom.makeSkyWcs(
crpix=lsst.geom.Point2D(10, 11),
crval=lsst.geom.SpherePoint(41.7, 32.9, lsst.geom.degrees),
cdMatrix=afwGeom.makeCdMatrix(scale=0.2*lsst.geom.degrees),
)
destWcs = afwGeom.makeSkyWcs(
crpix=lsst.geom.Point2D(9, 10),
crval=lsst.geom.SpherePoint(41.65, 32.95, lsst.geom.degrees),
cdMatrix=afwGeom.makeCdMatrix(scale=0.17*lsst.geom.degrees),
)
srcMaskedImage = afwImage.MaskedImageF(100, 101)
srcExposure = afwImage.ExposureF(srcMaskedImage, srcWcs)
srcArrays = srcMaskedImage.getArrays()
shape = srcArrays[0].shape
srcArrays[0][:] = np.random.normal(10000, 1000, size=shape)
srcArrays[2][:] = np.random.normal(9000, 900, size=shape)
srcArrays[1][:] = np.reshape(
np.arange(0, shape[0] * shape[1], 1, dtype=np.uint16), shape)
warpControl = afwMath.WarpingControl(
kernelName,
maskKernelName,
cacheSize,
interpLength,
growFullMask
)
destMaskedImage = afwImage.MaskedImageF(110, 121)
destExposure = afwImage.ExposureF(destMaskedImage, destWcs)
afwMath.warpExposure(destExposure, srcExposure, warpControl)
# now compute with two separate mask planes
warpControl.setGrowFullMask(0)
narrowMaskedImage = afwImage.MaskedImageF(110, 121)
narrowExposure = afwImage.ExposureF(narrowMaskedImage, destWcs)
afwMath.warpExposure(narrowExposure, srcExposure, warpControl)
narrowArrays = narrowExposure.getMaskedImage().getArrays()
warpControl.setMaskWarpingKernelName("")
broadMaskedImage = afwImage.MaskedImageF(110, 121)
broadExposure = afwImage.ExposureF(broadMaskedImage, destWcs)
afwMath.warpExposure(broadExposure, srcExposure, warpControl)
broadArrays = broadExposure.getMaskedImage().getArrays()
if (kernelName != maskKernelName) and (growFullMask != 0xFFFF):
# we expect the mask planes to differ
if np.all(narrowArrays[1] == broadArrays[1]):
self.fail("No difference between broad and narrow mask")
predMask = (broadArrays[1] & growFullMask) | (
narrowArrays[1] & ~growFullMask).astype(np.uint16)
predArraySet = (broadArrays[0], predMask, broadArrays[2])
predExposure = afwImage.makeMaskedImageFromArrays(*predArraySet)
msg = "Separate mask warping failed; warpingKernel=%s; maskWarpingKernel=%s" % \
(kernelName, maskKernelName)
self.assertMaskedImagesAlmostEqual(destExposure.getMaskedImage(), predExposure,
doImage=True, doMask=True, doVariance=True,
rtol=rtol, atol=atol, msg=msg)
def verifyMaskWarp(self,
kernelName,
maskKernelName,
growFullMask,
interpLength=10,
cacheSize=100000,
rtol=4e-05,
atol=1e-2):
"""Verify that using a separate mask warping kernel produces the correct results
Inputs:
- kernelName: name of warping kernel in the form used by afwImage.makeKernel
- maskKernelName: name of mask warping kernel in the form used by afwImage.makeKernel
- interpLength: interpLength argument for lsst.afw.math.WarpingControl
- cacheSize: cacheSize argument for lsst.afw.math.WarpingControl;
0 disables the cache
10000 gives some speed improvement but less accurate results (atol must be increased)
100000 gives better accuracy but no speed improvement in this test
- rtol: relative tolerance as used by numpy.allclose
- atol: absolute tolerance as used by numpy.allclose
"""
srcWcs = makeWcs(
pixelScale=afwGeom.Angle(0.2, afwGeom.degrees),
crPixPos=(10.0, 11.0),
crValCoord=afwCoord.IcrsCoord(afwGeom.Point2D(41.7, 32.9),
afwGeom.degrees),
)
destWcs = makeWcs(
pixelScale=afwGeom.Angle(0.17, afwGeom.degrees),
crPixPos=(9.0, 10.0),
crValCoord=afwCoord.IcrsCoord(afwGeom.Point2D(41.65, 32.95),
afwGeom.degrees),
posAng=afwGeom.Angle(31, afwGeom.degrees),
)
srcMaskedImage = afwImage.MaskedImageF(100, 101)
srcExposure = afwImage.ExposureF(srcMaskedImage, srcWcs)
srcArrays = srcMaskedImage.getArrays()
shape = srcArrays[0].shape
numpy.random.seed(0)
srcArrays[0][:] = numpy.random.normal(10000, 1000, size=shape)
srcArrays[2][:] = numpy.random.normal(9000, 900, size=shape)
srcArrays[1][:] = numpy.reshape(
numpy.arange(0, shape[0] * shape[1], 1, dtype=numpy.uint16), shape)
warpControl = afwMath.WarpingControl(kernelName, maskKernelName,
cacheSize, interpLength,
afwGpu.DEFAULT_DEVICE_PREFERENCE,
growFullMask)
destMaskedImage = afwImage.MaskedImageF(110, 121)
destExposure = afwImage.ExposureF(destMaskedImage, destWcs)
afwMath.warpExposure(destExposure, srcExposure, warpControl)
# now compute with two separate mask planes
warpControl.setGrowFullMask(0)
narrowMaskedImage = afwImage.MaskedImageF(110, 121)
narrowExposure = afwImage.ExposureF(narrowMaskedImage, destWcs)
afwMath.warpExposure(narrowExposure, srcExposure, warpControl)
narrowArrays = narrowExposure.getMaskedImage().getArrays()
warpControl.setMaskWarpingKernelName("")
broadMaskedImage = afwImage.MaskedImageF(110, 121)
broadExposure = afwImage.ExposureF(broadMaskedImage, destWcs)
afwMath.warpExposure(broadExposure, srcExposure, warpControl)
broadArrays = broadExposure.getMaskedImage().getArrays()
if (kernelName != maskKernelName) and (growFullMask != 0xFFFF):
# we expect the mask planes to differ
if numpy.all(narrowArrays[1] == broadArrays[1]):
self.fail("No difference between broad and narrow mask")
predMask = (broadArrays[1] & growFullMask) | (
narrowArrays[1] & ~growFullMask).astype(numpy.uint16)
predArraySet = (broadArrays[0], predMask, broadArrays[2])
predExposure = afwImage.makeMaskedImageFromArrays(*predArraySet)
msg = "Separate mask warping failed; warpingKernel=%s; maskWarpingKernel=%s" % \
(kernelName, maskKernelName)
self.assertMaskedImagesNearlyEqual(destExposure.getMaskedImage(),
predExposure,
doImage=True,
doMask=True,
doVariance=True,
rtol=rtol,
atol=atol,
msg=msg)
