def setUp(self):
"""Build up three different sets of objects that are to be merged"""
pos1 = [(40, 40), (220, 35), (40, 48), (220, 50),
(67, 67), (150, 50), (40, 90), (70, 160),
(35, 255), (70, 180), (250, 200), (120, 120),
(170, 180), (100, 210), (20, 210),
]
pos2 = [(43, 45), (215, 31), (171, 258), (211, 117),
(48, 99), (70, 160), (125, 45), (251, 33),
(37, 170), (134, 191), (79, 223), (258, 182)
]
pos3 = [(70, 170), (219, 41), (253, 173), (253, 192)]
box = lsst.geom.Box2I(lsst.geom.Point2I(0, 0), lsst.geom.Point2I(300, 300))
psfsig = 1.
kernelSize = 41
flux = 1000
# Create a different sized psf for each image and insert them at the
# desired positions
im1 = afwImage.MaskedImageD(box)
psf1 = afwDetect.GaussianPsf(kernelSize, kernelSize, psfsig)
im2 = afwImage.MaskedImageD(box)
psf2 = afwDetect.GaussianPsf(kernelSize, kernelSize, 2*psfsig)
im3 = afwImage.MaskedImageD(box)
psf3 = afwDetect.GaussianPsf(kernelSize, kernelSize, 1.3*psfsig)
insertPsf(pos1, im1, psf1, kernelSize, flux)
insertPsf(pos2, im2, psf2, kernelSize, flux)
insertPsf(pos3, im3, psf3, kernelSize, flux)
schema = afwTable.SourceTable.makeMinimalSchema()
self.idFactory = afwTable.IdFactory.makeSimple()
self.table = afwTable.SourceTable.make(schema, self.idFactory)
# Create SourceCatalogs from these objects
fp1 = afwDetect.FootprintSet(
im1, afwDetect.Threshold(0.001), "DETECTED")
self.catalog1 = afwTable.SourceCatalog(self.table)
fp1.makeSources(self.catalog1)
fp2 = afwDetect.FootprintSet(
im2, afwDetect.Threshold(0.001), "DETECTED")
self.catalog2 = afwTable.SourceCatalog(self.table)
fp2.makeSources(self.catalog2)
fp3 = afwDetect.FootprintSet(
im3, afwDetect.Threshold(0.001), "DETECTED")
self.catalog3 = afwTable.SourceCatalog(self.table)
fp3.makeSources(self.catalog3)
def setUp(self):
self.val = 10
self.nRow, self.nCol = 100, 200
self.sctrl = afwMath.StatisticsControl()
# Integers
self.mimgI = afwImage.MaskedImageI(
afwGeom.Extent2I(self.nRow, self.nCol))
self.mimgI.set(self.val, 0x0, self.val)
self.imgI = afwImage.ImageI(afwGeom.Extent2I(self.nRow, self.nCol),
self.val)
# TODO: pybind11, this should probably be ndarray
self.vecI = [self.val for i in range(self.nRow * self.nCol)]
# floats
self.mimgF = afwImage.MaskedImageF(
afwGeom.Extent2I(self.nRow, self.nCol))
self.mimgF.set(self.val, 0x0, self.val)
self.imgF = afwImage.ImageF(afwGeom.Extent2I(self.nRow, self.nCol),
self.val)
# TODO: pybind11, this should probably be ndarray
self.vecF = [float(self.val) for i in range(self.nRow * self.nCol)]
# doubles
self.mimgD = afwImage.MaskedImageD(
afwGeom.Extent2I(self.nRow, self.nCol))
self.mimgD.set(self.val, 0x0, self.val)
self.imgD = afwImage.ImageD(afwGeom.Extent2I(self.nRow, self.nCol),
self.val)
# TODO: pybind11, this should probably be ndarray
self.vecD = [float(self.val) for i in range(self.nRow * self.nCol)]
self.imgList = [self.imgI, self.imgF, self.imgD]
self.mimgList = [self.mimgI, self.mimgF, self.mimgD]
self.vecList = [self.vecI, self.vecF, self.vecD]
def setUp(self):
self.val = 10
self.nRow, self.nCol = 100, 200
self.sctrl = afwMath.StatisticsControl()
# Integers
self.mimgI = afwImage.MaskedImageI(afwGeom.Extent2I(self.nRow, self.nCol))
self.mimgI.set(self.val, 0x0, self.val)
self.imgI = afwImage.ImageI(afwGeom.Extent2I(self.nRow, self.nCol), self.val)
self.vecI = afwMath.vectorI(self.nRow*self.nCol, self.val)
# floats
self.mimgF = afwImage.MaskedImageF(afwGeom.Extent2I(self.nRow, self.nCol))
self.mimgF.set(self.val, 0x0, self.val)
self.imgF = afwImage.ImageF(afwGeom.Extent2I(self.nRow, self.nCol), self.val)
self.vecF = afwMath.vectorF(self.nRow*self.nCol, self.val)
# doubles
self.mimgD = afwImage.MaskedImageD(afwGeom.Extent2I(self.nRow, self.nCol))
self.mimgD.set(self.val, 0x0, self.val)
self.imgD = afwImage.ImageD(afwGeom.Extent2I(self.nRow, self.nCol), self.val)
self.vecD = afwMath.vectorD(self.nRow*self.nCol, self.val)
self.imgList = [self.imgI, self.imgF, self.imgD]
self.mimgList = [self.mimgI, self.mimgF, self.mimgD]
self.vecList = [self.vecI, self.vecF, self.vecD]
def testReadFitsWithOptions(self):
xy0Offset = lsst.geom.Extent2I(7, 5)
bbox = lsst.geom.Box2I(lsst.geom.Point2I(10, 11),
lsst.geom.Extent2I(31, 22))
with lsst.utils.tests.getTempFilePath(".fits") as filepath:
# write a temporary version of the image with non-zero XY0
imagePath = os.path.join(dataDir, "data", "med.fits")
maskedImage = afwImage.MaskedImageD(imagePath)
maskedImage.setXY0(lsst.geom.Point2I(xy0Offset))
maskedImage.writeFits(filepath)
for ImageClass, imageOrigin in itertools.product(
(afwImage.MaskedImageF, afwImage.MaskedImageD),
(None, "LOCAL", "PARENT"),
):
with self.subTest(ImageClass=ImageClass,
imageOrigin=imageOrigin):
fullImage = ImageClass(filepath)
options = dafBase.PropertySet()
options.set("llcX", bbox.getMinX())
options.set("llcY", bbox.getMinY())
options.set("width", bbox.getWidth())
options.set("height", bbox.getHeight())
if imageOrigin is not None:
options.set("imageOrigin", imageOrigin)
image1 = ImageClass.readFitsWithOptions(filepath, options)
readBBoxParent = lsst.geom.Box2I(bbox)
if imageOrigin == "LOCAL":
readBBoxParent.shift(xy0Offset)
self.assertMaskedImagesEqual(
image1, ImageClass(fullImage, readBBoxParent))
for name in ("llcY", "width", "height"):
badOptions = options.deepCopy()
badOptions.remove(name)
with self.assertRaises(pexEx.NotFoundError):
ImageClass.readFitsWithOptions(
filepath, badOptions)
badOptions = options.deepCopy()
badOptions.set("imageOrigin", "INVALID")
with self.assertRaises(RuntimeError):
ImageClass.readFitsWithOptions(
filepath, badOptions)
def testDM17431(self):
"""Test that priority order is respected
specifically when lower priority footprints overlap two previously
disconnected higher priority footprints.
"""
box = lsst.geom.Box2I(lsst.geom.Point2I(0, 0),
lsst.geom.Point2I(100, 100))
psfsig = 1.
kernelSize = 41
flux = 1000
cat1 = {}
cat2 = {}
peakDist = 10
samePeakDist = 3
# cat2 connects cat1's 2 separated footprints.
# 65 and 70 are too close to be new or same peaks.
# 70 is higher priority and should be in the catalog instead of 65.
cat1['pos'] = [(50, 50), (70, 50)]
cat2['pos'] = [(55, 50), (65, 50)]
schema = afwTable.SourceTable.makeMinimalSchema()
idFactory = afwTable.IdFactory.makeSimple()
table = afwTable.SourceTable.make(schema, idFactory)
for (cat, psfFactor) in zip([cat1, cat2], [1, 2]):
cat['mi'] = afwImage.MaskedImageD(box)
cat['psf'] = afwDetect.GaussianPsf(kernelSize, kernelSize,
psfFactor * psfsig)
insertPsf(cat['pos'], cat['mi'], cat['psf'], kernelSize, flux)
fp = afwDetect.FootprintSet(cat['mi'], afwDetect.Threshold(0.001),
"DETECTED")
cat['catalog'] = afwTable.SourceCatalog(table)
fp.makeSources(cat['catalog'])
merge, nob, npeak = mergeCatalogs([cat1['catalog'], cat2['catalog']],
["1", "2"],
peakDist,
idFactory,
samePeakDist=samePeakDist)
# Check that both higher-priority cat1 records survive peak merging
for record in cat1['catalog']:
for peak in record.getFootprint().getPeaks():
self.assertTrue(isPeakInCatalog(peak, merge))
def testTicket617(self):
"""Test reading an F64 image and converting it to a MaskedImage"""
im = afwImage.ImageD(lsst.geom.Extent2I(100, 100))
im.set(666)
afwImage.MaskedImageD(im)
# Copyright 2008, 2009, 2010 LSST Corporation.
#
# This product includes software developed by the
# LSST Project (http://www.lsst.org/).
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the LSST License Statement and
# the GNU General Public License along with this program. If not,
# see <http://www.lsstcorp.org/LegalNotices/>.
#
"""Demonstrate a segmentation fault
"""
import lsst.geom
import lsst.afw.image as afwImage
testMaskedImage = afwImage.MaskedImageD(lsst.geom.Extent2I(100, 100))
testImage = testMaskedImage.getImage().get() # no segfault if .get() omitted
addImage = afwImage.ImageD(testMaskedImage.getCols(),
testMaskedImage.getRows())
testImage += addImage # no segfault if this step omitted
print("Done")
# This product includes software developed by the
# LSST Project (http://www.lsst.org/).
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the LSST License Statement and
# the GNU General Public License along with this program. If not,
# see <http://www.lsstcorp.org/LegalNotices/>.
#
"""Demonstrate a segmentation fault
"""
from __future__ import absolute_import, division, print_function
import lsst.afw.image as afwImage
import lsst.afw.geom as afwGeom
testMaskedImage = afwImage.MaskedImageD(afwGeom.Extent2I(100, 100))
testImage = testMaskedImage.getImage().get() # no segfault if .get() omitted
addImage = afwImage.ImageD(testMaskedImage.getCols(),
testMaskedImage.getRows())
testImage += addImage # no segfault if this step omitted
print("Done")
coaddComponent = coaddKaiser.CoaddComponent(
exposure, psfKernel, normalizePsf)
print " Divide exposure by sigma squared = %s" % (
coaddComponent.getSigmaSq(), )
blurredExposure = coaddComponent.getBlurredExposure()
blurredMaskedImage = blurredExposure.getMaskedImage()
sigmaSq = coaddComponent.getSigmaSq()
if saveImages:
blurredExposure.writeFits("blurred%s" % (fileName, ))
blurredMaskedImage /= sigmaSq
if saveImages:
blurredExposure.writeFits("scaledBlurred%s" % (fileName, ))
print " Remap blurred exposure to match coadd WCS"
remappedBlurredMaskedImage = afwImage.MaskedImageD(
coaddExposure.getWidth(), coaddExposure.getHeight())
remappedBlurredExposure = afwImage.ExposureD(
remappedBlurredMaskedImage, coaddWcs)
if saveImages:
remappedBlurredExposure.writeFits("remappedBlurred%s" %
(fileName, ))
nGoodPix = afwMath.warpExposure(remappedBlurredExposure,
blurredExposure,
afwMath.LanczosWarpingKernel(3))
nPix = coaddExposure.getWidth() * coaddExposure.getHeight()
print " Remapped image has %d good pixels (%0.0f %%)" % (
nGoodPix, 100 * nGoodPix / float(nPix))
print " Add remapped blurred exposure to coadd and save updated coadd exposure"
coaddUtils.addToCoadd(coaddMaskedImage, depthMap,
remappedBlurredExposure.getMaskedImage(),
