def make_wcs(self):
"""Construct a HEALPix WCS header"""
ps = dafBase.PropertySet()
ps.add('NAXIS', 2)
ps.add('CTYPE1', 'RA---HPX')
ps.add('CTYPE2', 'DEC--HPX')
ps.add('CUNIT1', 'deg')
ps.add('CUNIT2', 'deg')
ps.add('CDELT1', self.cdelt_deg)
ps.add('CDELT2', self.cdelt_deg)
ps.add('CRVAL1', 0)
ps.add('CRVAL2', 0)
ps.add('CRPIX1', 0)
ps.add('CRPIX2', 0)
return afwImage.makeWcs(ps)
def setEvent(self, name, eventData):
"""set data for an event to be received by the Stage prior to
being called. This implementation currently does not support
array-valued data.
@param name the topic name for the event
@param eventData the event data, either as a python dictionary or
a PropertySet
"""
if isinstance(eventData, dict):
evprop = dafBase.PropertySet()
for key in eventData.keys():
evprop.set(key, eventData[key])
eventData = evprop
self.event = (name, eventData)
def __init__(self, pythonType, cppType, storageName, locationList, dataId, mapper, storage,
usedDataId=None, datasetType=None, additionalData=None):
# pythonType is sometimes unicode with Python 2 and pybind11; this breaks the interpreter
self.pythonType = str(pythonType) if isinstance(pythonType, basestring) else pythonType
self.cppType = cppType
self.storageName = storageName
self.mapper = mapper
self.storage = storage
self.locationList = iterify(locationList)
self.additionalData = additionalData if additionalData else dafBase.PropertySet()
for k, v in dataId.items():
self.additionalData.set(k, v)
self.dataId = dataId
self.usedDataId = usedDataId
self.datasetType = datasetType
def testAddScalar(self):
ps = dafBase.PropertySet(flat=True)
v = [42, 2008, 1]
ps.setInt("ints", v)
ps.addInt("ints", -999)
ps.add("other", "foo")
ps.add("ints", 13)
w = ps.getArrayInt("ints")
self.assertEqual(len(w), 5)
self.assertEqual(v[0], w[0])
self.assertEqual(v[1], w[1])
self.assertEqual(v[2], w[2])
self.assertEqual(w[3], -999)
self.assertEqual(w[4], 13)
self.assertEqual(ps.getString("other"), "foo")
def makeWcs(crPixPos, crValDeg, projection):
ps = dafBase.PropertySet()
ctypes = [("%-5s%3s" % (("RA", "DEC")[i], projection)).replace(" ", "-") for i in range(2)]
for i in range(2):
ip1 = i + 1
ps.add("CTYPE%1d" % (ip1,), ctypes[i])
ps.add("CRPIX%1d" % (ip1,), crPixPos[i])
ps.add("CRVAL%1d" % (ip1,), crValDeg[i])
ps.add("RADECSYS", "ICRS")
ps.add("EQUINOX", 2000)
ps.add("CD1_1", -0.001)
ps.add("CD2_1", 0.0)
ps.add("CD1_2", 0.0)
ps.add("CD2_2", 0.001)
return afwImage.makeWcs(ps)
def sendEvent(self, broker, topic):
trans = events.EventTransmitter(broker, topic)
root = base.PropertySet()
root.set("DATE", "2007-07-01T14:28:32.546012")
root.setInt("PID", 200)
root.set("HOST", "lsstcorp.org")
root.set("IP", "1.2.3.4")
root.set("EVNT", "test")
root.set("misc1", "data 1")
root.set("misc2", "data 2")
root.set("value", 3.14)
event = events.Event("runid_test6", root)
trans.publishEvent(event)
def testCopy(self):
dest = dafBase.PropertySet()
source = dafBase.PropertySet()
value1 = [1.5, 3.2]
source.set("srcItem1", value1)
dest.copy("destItem1", source, "srcItem1")
self.assertEqual(dest.get("destItem1"), value1[-1])
self.assertEqual(dest.getArray("destItem1"), value1)
self.assertEqual(dest.getScalar("destItem1"), value1[-1])
# items are replaced, regardless of type
dest.set("destItem2", "string value")
value2 = [5, -4, 3]
source.set("srcItem2", value2)
dest.copy("destItem2", source, "srcItem2")
self.assertEqual(dest.get("destItem2"), value2[-1])
self.assertEqual(dest.getArray("destItem2"), value2)
self.assertEqual(dest.getScalar("destItem2"), value2[-1])
# asScalar copies only the last value
dest.copy("destItem2Scalar", source, "srcItem2", asScalar=True)
self.assertEqual(dest.get("destItem2Scalar"), value2[-1])
self.assertEqual(dest.getArray("destItem2Scalar"), [value2[-1]])
self.assertEqual(dest.getScalar("destItem2Scalar"), value2[-1])
def sendEvent(self, topicName):
root = base.PropertySet()
root.set("DATE", "2007-07-01T14:28:32.546012")
root.setInt("PID", 200)
root.set("HOST", "lsstcorp.org")
root.set("IP", "1.2.3.4")
root.set("EVNT", "test")
root.set("misc1", "data 1")
root.set("misc2", "data 2")
root.set("value", 3.14)
eventSystem = events.EventSystem.getDefaultEventSystem()
event = events.Event("runid_es6", root)
eventSystem.publishEvent(topicName, event)
def testFixedKernel(self):
"""Test FixedKernel using a ramp function
"""
kWidth = 5
kHeight = 6
inArr = numpy.arange(kWidth * kHeight, dtype=float)
inArr.shape = [kWidth, kHeight]
inImage = afwImage.ImageD(afwGeom.Extent2I(kWidth, kHeight))
for row in range(inImage.getHeight()):
for col in range(inImage.getWidth()):
inImage.set(col, row, inArr[col, row])
k = afwMath.FixedKernel(inImage)
pol = pexPolicy.Policy()
additionalData = dafBase.PropertySet()
loc = dafPersist.LogicalLocation("tests/data/kernel1.boost")
persistence = dafPersist.Persistence.getPersistence(pol)
storageList = dafPersist.StorageList()
storage = persistence.getPersistStorage("XmlStorage", loc)
storageList.append(storage)
persistence.persist(k, storageList, additionalData)
storageList2 = dafPersist.StorageList()
storage2 = persistence.getRetrieveStorage("XmlStorage", loc)
storageList2.append(storage2)
x = persistence.unsafeRetrieve("FixedKernel", storageList2, additionalData)
k2 = afwMath.FixedKernel.swigConvert(x)
self.kernelCheck(k, k2)
outImage = afwImage.ImageD(k2.getDimensions())
k2.computeImage(outImage, False)
outArr = outImage.getArray().transpose()
if not numpy.allclose(inArr, outArr):
self.fail("%s = %s != %s (not normalized)" % \
(k2.__class__.__name__, inArr, outArr))
normInArr = inArr / inArr.sum()
normOutImage = afwImage.ImageD(k2.getDimensions())
k2.computeImage(normOutImage, True)
normOutArr = normOutImage.getArray().transpose()
if not numpy.allclose(normOutArr, normInArr):
self.fail("%s = %s != %s (normalized)" % \
(k2.__class__.__name__, normInArr, normOutArr))
def testScalar(self):
ps = dafBase.PropertySet(flat=True)
ps.setBool("bool", True)
ps.setShort("short", 42)
ps.setInt("int", 2008)
ps.setLongLong("int64_t", 0xfeeddeadbeef)
ps.setFloat("float", 3.14159)
ps.setDouble("double", 2.718281828459045)
ps.set("char*", "foo")
ps.setString("string", "bar")
ps.set("int2", 2009)
ps.set(
"dt",
dafBase.DateTime("20090402T072639.314159265Z",
dafBase.DateTime.UTC))
ps.set("autobool", True)
self.assertEqual(ps.typeOf("bool"), dafBase.PropertySet.TYPE_Bool)
self.assertIs(ps.getBool("bool"), True)
self.assertIs(ps.get("bool"), True)
self.assertEqual(ps.getArray("bool"), [True])
self.assertIs(ps.getScalar("bool"), True)
self.assertEqual(ps.typeOf("short"), dafBase.PropertySet.TYPE_Short)
self.assertEqual(ps.getShort("short"), 42)
self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int)
self.assertEqual(ps.getInt("int"), 2008)
self.assertEqual(ps.typeOf("int64_t"),
dafBase.PropertySet.TYPE_LongLong)
self.assertEqual(ps.getLongLong("int64_t"), 0xfeeddeadbeef)
self.assertEqual(ps.typeOf("float"), dafBase.PropertySet.TYPE_Float)
self.assertAlmostEqual(ps.getFloat("float"), 3.14159, 6)
self.assertEqual(ps.typeOf("double"), dafBase.PropertySet.TYPE_Double)
self.assertEqual(ps.getDouble("double"), 2.718281828459045)
self.assertEqual(ps.typeOf("char*"), dafBase.PropertySet.TYPE_String)
self.assertEqual(ps.getString("char*"), "foo")
self.assertEqual(ps.typeOf("string"), dafBase.PropertySet.TYPE_String)
self.assertEqual(ps.getString("string"), "bar")
self.assertEqual(ps.typeOf("int2"), dafBase.PropertySet.TYPE_Int)
self.assertEqual(ps.getInt("int2"), 2009)
self.assertEqual(ps.get("int2"), 2009)
self.assertEqual(ps.getArray("int2"), [2009])
self.assertEqual(ps.getScalar("int2"), 2009)
self.assertEqual(ps.typeOf("dt"), dafBase.PropertySet.TYPE_DateTime)
self.assertEqual(ps.getDateTime("dt").nsecs(), 1238657233314159265)
self.assertEqual(ps.typeOf("autobool"), dafBase.PropertySet.TYPE_Bool)
self.assertIs(ps.get("autobool"), True)
self.assertEqual(ps.getArray("autobool"), [True])
self.assertIs(ps.getScalar("autobool"), True)
def makeWcs(pixelScale,
crPixPos,
crValCoord,
posAng=afwGeom.Angle(0.0),
doFlipX=False,
projection="TAN",
radDecCSys="ICRS",
equinox=2000):
"""Make a Wcs
@param[in] pixelScale: desired scale, as sky/pixel, an afwGeom.Angle
@param[in] crPixPos: crPix for WCS, using the LSST standard; a pair of floats
@param[in] crValCoord: crVal for WCS (afwCoord.Coord)
@param[in] posAng: position angle (afwGeom.Angle)
@param[in] doFlipX: flip X axis?
@param[in] projection: WCS projection (e.g. "TAN" or "STG")
"""
if len(projection) != 3:
raise RuntimeError("projection=%r; must have length 3" %
(projection, ))
ctypeList = [
("%-5s%3s" % (("RA", "DEC")[i], projection)).replace(" ", "-")
for i in range(2)
]
ps = dafBase.PropertySet()
# convert pix position to FITS standard
crPixFits = [ind + 1.0 for ind in crPixPos]
crValDeg = crValCoord.getPosition(afwGeom.degrees)
posAngRad = posAng.asRadians()
pixelScaleDeg = pixelScale.asDegrees()
cdMat = np.array(
[[math.cos(posAngRad), math.sin(posAngRad)],
[-math.sin(posAngRad), math.cos(posAngRad)]],
dtype=float) * pixelScaleDeg
if doFlipX:
cdMat[:, 0] = -cdMat[:, 0]
for i in range(2):
ip1 = i + 1
ps.add("CTYPE%1d" % (ip1, ), ctypeList[i])
ps.add("CRPIX%1d" % (ip1, ), crPixFits[i])
ps.add("CRVAL%1d" % (ip1, ), crValDeg[i])
ps.add("RADECSYS", radDecCSys)
ps.add("EQUINOX", equinox)
ps.add("CD1_1", cdMat[0, 0])
ps.add("CD2_1", cdMat[1, 0])
ps.add("CD1_2", cdMat[0, 1])
ps.add("CD2_2", cdMat[1, 1])
return afwImage.makeWcs(ps)
def testAnalyticKernel(self):
"""Test AnalyticKernel using a Gaussian function
"""
kWidth = 5
kHeight = 8
pol = pexPolicy.Policy()
additionalData = dafBase.PropertySet()
loc = dafPersist.LogicalLocation("tests/data/kernel2.boost")
persistence = dafPersist.Persistence.getPersistence(pol)
gaussFunc = afwMath.GaussianFunction2D(1.0, 1.0, 0.0)
k = afwMath.AnalyticKernel(kWidth, kHeight, gaussFunc)
fArr = numpy.zeros(shape=[k.getWidth(), k.getHeight()], dtype=float)
for xsigma in (0.1, 1.0, 3.0):
for ysigma in (0.1, 1.0, 3.0):
for angle in (0.0, 0.4, 1.1):
gaussFunc.setParameters((xsigma, ysigma, angle))
# compute array of function values and normalize
for row in range(k.getHeight()):
y = row - k.getCtrY()
for col in range(k.getWidth()):
x = col - k.getCtrX()
fArr[col, row] = gaussFunc(x, y)
fArr /= fArr.sum()
k.setKernelParameters((xsigma, ysigma, angle))
storageList = dafPersist.StorageList()
storage = persistence.getPersistStorage("XmlStorage", loc)
storageList.append(storage)
persistence.persist(k, storageList, additionalData)
storageList2 = dafPersist.StorageList()
storage2 = persistence.getRetrieveStorage("XmlStorage", loc)
storageList2.append(storage2)
x = persistence.unsafeRetrieve("AnalyticKernel",
storageList2, additionalData)
k2 = afwMath.AnalyticKernel.swigConvert(x)
self.kernelCheck(k, k2)
kImage = afwImage.ImageD(k2.getDimensions())
k2.computeImage(kImage, True)
kArr = kImage.getArray().transpose()
if not numpy.allclose(fArr, kArr):
self.fail("%s = %s != %s for xsigma=%s, ysigma=%s" % \
(k2.__class__.__name__, kArr, fArr, xsigma, ysigma))
def testPropertySetNames(self):
ps = dafBase.PropertySet()
ps.set("ps1.pre", 1)
ps.set("ps1.post", 2)
ps.set("int", 42)
ps.set("double", 3.14)
ps.set("ps2.plus", 10.24)
ps.set("ps2.minus", -10.24)
ps.set("ps3.sub.subsub", "foo")
v = set(ps.propertySetNames())
self.assertEqual(len(v), 3)
self.assertEqual(v, {"ps1", "ps2", "ps3"})
v = set(ps.propertySetNames(False))
self.assertEqual(len(v), 4)
self.assertEqual(v, {"ps1", "ps2", "ps3", "ps3.sub"})
def add_mask_files(mask_files, outfile, overwrite=True):
amp_list = imutils.allAmps(mask_files[0])
masks = dict([(amp, afwImage_Mask(mask_files[0], imutils.dm_hdu(amp)))
for amp in amp_list])
for mask_file in mask_files[1:]:
for amp in masks:
masks[amp] |= afwImage_Mask(mask_file, imutils.dm_hdu(amp))
output = fits.HDUList()
output.append(fits.PrimaryHDU())
output[0].header['MASKTYPE'] = 'SUMMED_MASKS'
fitsWriteto(output, outfile, overwrite=overwrite)
for amp in masks:
md = dafBase.PropertySet()
md.set('EXTNAME', 'SEGMENT%s' % imutils.channelIds[amp])
masks[amp].writeFits(outfile, md, 'a')
return masks
def makeWcs(projName, destCtrInd, skyOffset, rotAng, scaleFac, srcWcs,
srcCtrInd):
"""Make an RA/Dec WCS from another RA/Dec WCS
@param projName: projection, e,g, "TAN"
@param destCtrInd: pixel index of center of WCS; used to compute CRPIX;
typically the center of the destination exposure
@param skyOffset: offset in sky coords (axis 1, axis 2 degrees):
dest sky pos at destCtrInd = src sky pos at destCtrInd + skyOffset
@param rotAng: change of orientation with respect to srcWcs, in degrees
@param scaleFac: output resolution / input resolution
@param srcWcs: reference WCS
@param srcCtrInd: index of source pixel whose sky matches destCtrInd on new WCS
typically the center of the source exposure
"""
ps = dafBase.PropertySet()
destCtrFitsPix = afwGeom.Point2D(*[ind + 1.0 for ind in destCtrInd])
srcCtrFitsPix = afwGeom.Point2D(*[ind + 1.0 for ind in srcCtrInd])
# offset 1 pixel in x to compute orient & scale
srcOffFitsPix = srcCtrFitsPix + afwGeom.Extent2D(1.0, 0.0)
try:
srcCtrSkyPos = srcWcs.pixelToSky(srcCtrFitsPix).getPosition(
DegreesFlag)
except Exception:
import lsst.afw.coord as afwCoord
setDegreesFlag(afwCoord.DEGREES)
srcCtrSkyPos = srcWcs.pixelToSky(srcCtrFitsPix).getPosition(
DegreesFlag)
srcOffSkyPos = srcWcs.pixelToSky(srcOffFitsPix).getPosition(DegreesFlag)
srcSkyOff = srcOffSkyPos - srcCtrSkyPos
srcAngleRad = math.atan2(srcSkyOff[1], srcSkyOff[0])
destAngleRad = srcAngleRad + (rotAng / DegPerRad)
srcScale = math.sqrt(srcSkyOff[0]**2 + srcSkyOff[1]**2) # in degrees/pixel
destScale = srcScale / scaleFac
for i in range(2):
ip1 = i + 1
ctypeStr = ("%-5s%3s" % (("RA", "DEC")[i], projName)).replace(" ", "-")
ps.add("CTYPE%1d" % (ip1, ), ctypeStr)
ps.add("CRPIX%1d" % (ip1, ), destCtrFitsPix[i])
ps.add("CRVAL%1d" % (ip1, ), srcCtrSkyPos[i] + skyOffset[i])
ps.add("RADECSYS", "ICRS")
ps.add("EQUINOX", 2000)
ps.add("CD1_1", -destScale * math.cos(destAngleRad))
ps.add("CD2_1", destScale * math.sin(destAngleRad))
ps.add("CD1_2", destScale * math.sin(destAngleRad))
ps.add("CD2_2", destScale * math.cos(destAngleRad))
return afwImage.makeWcs(ps)
def process(self, clipboard):
self.log.log(Log.INFO, "Estimating Aperture Correction is in process")
#grab exposure from clipboard
exposure = clipboard.get(self.policy.get("inputKeys.exposure"))
cellSet = clipboard.get(self.policy.get("inputKeys.cellSet"))
metadata = dafBase.PropertySet()
apCorrCtrl = measAlg.ApertureCorrectionControl(self.ApCorrPolicy)
apCorr = measAlg.ApertureCorrection(exposure,
cellSet,
metadata,
apCorrCtrl,
log=self.log)
clipboard.put(self.policy.get("outputKeys.apCorr"), apCorr)
clipboard.put(self.policy.get("outputKeys.metadata"), metadata)
def testPropertySet(self):
pset = dafBase.PropertySet()
pset.set("foo", 3)
pset.set("bar", dafBase.DateTime.now())
pset.set("baz", ['a', 'b', 'c'])
pset.set("e", 2.71828)
pset.set("f.a", [1, 2, 3])
pset.set("f.b", 201805241715)
pset.setBool("bool0", False)
pset.setBool("bool1", True)
pset.setShort("short1", 32767)
pset.setShort("short2", -32768)
pset.setFloat("float1", 9.8765)
pset.setFloat("float2", -1.234)
self.butler.put(pset, self.localTypeName, ccd=3)
y = self.butler.get(self.localTypeName, ccd=3, immediate=True)
self.assertEqual(y, pset)
def process(self, clipboard):
self.log.log(Log.INFO, "Estimating PSF is in process")
#grab exposure from clipboard
exposure = clipboard.get(self.policy.get("inputKeys.exposure"))
sourceSet = clipboard.get(self.policy.get("inputKeys.sourceSet"))
psfCandidateList = self.starSelector.selectStars(exposure, sourceSet)
metadata = dafBase.PropertySet()
psf, psfCellSet = self.psfDeterminer.determinePsf(
exposure, psfCandidateList, metadata)
self.log.log(Log.INFO, "Calling exposure.setPsf(psf) in stage code")
exposure.setPsf(psf)
clipboard.put(self.policy.get("outputKeys.psf"), psf)
clipboard.put(self.policy.get("outputKeys.cellSet"), psfCellSet)
clipboard.put(self.policy.get("outputKeys.metadata"), metadata)
def sendEvent(self, topicName):
root = base.PropertySet()
root.set("DATE","2007-07-01T14:28:32.546012")
root.setInt("PID",200)
root.set("HOST","lsstcorp.org")
root.set("IP","1.2.3.4")
root.set("EVNT","test")
root.set("misc1","data 1")
root.set("misc2","data 2")
root.set("value", 3.14)
root.set("array1", ('a', 'b', 'c', 'd'))
root.set("array2", (1, 2, 3, 4, 5))
root.set("array3", (6.1, 6.2, 6.3, 6.4, 6.5))
eventSystem = events.EventSystem.getDefaultEventSystem()
event = events.Event("runid_es4", root)
eventSystem.publishEvent(topicName, event)
def getFullMetadata(self):
"""!Get metadata for all tasks
The returned metadata includes timing information (if \@timer.timeMethod is used)
and any metadata set by the task. The name of each item consists of the full task name
with "." replaced by ":", followed by "." and the name of the item, e.g.:
topLeveltTaskName:subtaskName:subsubtaskName.itemName
using ":" in the full task name disambiguates the rare situation that a task has a subtask
and a metadata item with the same name.
@return metadata: an lsst.daf.base.PropertySet containing full task name: metadata
for the top-level task and all subtasks, sub-subtasks, etc.
"""
fullMetadata = dafBase.PropertySet()
for fullName, task in self.getTaskDict().items():
fullMetadata.set(fullName.replace(".", ":"), task.metadata)
return fullMetadata
def testWriteBool(self):
"""Test that we can read and write bools"""
with lsst.utils.tests.getTempFilePath(".fits") as tmpFile:
im = afwImage.ImageF(lsst.geom.ExtentI(10, 20))
md = dafBase.PropertySet()
keys = {"BAD": False,
"GOOD": True,
}
for k, v in keys.items():
md.add(k, v)
im.writeFits(tmpFile, md)
jim = afwImage.DecoratedImageF(tmpFile)
for k, v in keys.items():
self.assertEqual(jim.getMetadata().getScalar(k), v)
def testArrayProperties(self):
ps = dafBase.PropertySet()
v = [42, 2008, 1]
ps.set("ints", v)
ps.set("int", 365)
ps.set("ints2", -42)
ps.add("ints2", -2008)
self.assertTrue(ps.isArray("ints"))
self.assertFalse(ps.isArray("int"))
self.assertTrue(ps.isArray("ints2"))
self.assertEqual(ps.valueCount("ints"), 3)
self.assertEqual(ps.valueCount("int"), 1)
self.assertEqual(ps.valueCount("ints2"), 2)
self.assertEqual(ps.typeOf("ints"), dafBase.PropertySet.TYPE_Int)
self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int)
self.assertEqual(ps.typeOf("ints2"), dafBase.PropertySet.TYPE_Int)
def testParamNames(self):
ps = dafBase.PropertySet()
ps.set("ps1.pre", 1)
ps.set("ps1.post", 2)
ps.set("int", 42)
ps.set("double", 3.14)
ps.set("ps2.plus", 10.24)
ps.set("ps2.minus", -10.24)
v = set(ps.paramNames())
self.assertEqual(len(v), 2)
self.assertEqual(v, {"double", "int"})
v = set(ps.paramNames(False))
self.assertEqual(len(v), 6)
self.assertEqual(
v,
{"double", "int", "ps1.post", "ps1.pre", "ps2.minus", "ps2.plus"})
def testGetVector(self):
ps = dafBase.PropertySet(flat=True)
v = [42, 2008, 1]
ps.setInt("ints", v)
ps.setInt("ints2", [10, 9, 8])
w = ps.getArrayInt("ints")
self.assertEqual(len(w), 3)
self.assertEqual(v, w)
self.assertEqual(ps.getInt("ints2"), 8)
self.assertEqual(ps.getArrayInt("ints2"), [10, 9, 8])
self.assertEqual(ps.getArray("ints"), v)
self.assertEqual(ps.getScalar("ints"), v[-1])
ps.setInt("int", 999)
x = ps.get("int")
self.assertEqual(x, 999)
self.assertEqual(ps.getArray("int"), [999])
self.assertEqual(ps.getScalar("int"), 999)
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 readData(self, fileName = None, subImage = False):
afwdataDir = eups.productDir("afwdata") or ""
if not fileName or isinstance(fileName, int):
if fileName:
which = fileName
else:
which = 1
fileName = os.path.join(afwdataDir, "med")
elif not os.path.exists(fileName):
fileName = os.path.join(afwdataDir, fileName)
#
# We could read into an Exposure, but we're going to want to determine our own WCS
#
hdu, metadata = 0, dafBase.PropertySet()
if True:
mi = afwImage.MaskedImageF(fileName, hdu, metadata) # read MaskedImage
self.XY0 = mi.getXY0()
else:
if subImage: # use sub-image
self.XY0 = afwImage.PointI(824, 140)
bbox = afwImage.BBox(self.XY0, 512, 512)
else: # use full image, trimmed to data section
self.XY0 = afwImage.PointI(32, 2)
bbox = afwImage.BBox(self.XY0, afwImage.PointI(2079, 4609))
mi = afwImage.MaskedImageF(fileName, hdu, metadata, bbox) # read MaskedImage
if not subImage:
mi.setXY0(afwImage.PointI(0, 0)) # we just trimmed the overscan
wcs = afwImage.makeWcs(metadata)
self.pixscale = wcs.pixelScale().asArcseconds()
#
# Just an initial guess
#
FWHM = 5
self.psf = measAlg.DoubleGaussianPsf(15, 15, FWHM/(2*sqrt(2*log(2))))
mi.getMask().addMaskPlane("DETECTED")
self.exposure = afwImage.makeExposure(mi, wcs)
self.exposure.setPsf(self.psf)
if self.display:
ds9.mtv(self.exposure)
def __init__(self, stageId, policy):
if policy is None:
raise RuntimeError, "Cannot create a lsst.ap.StoreStage without a policy"
harness.Stage.Stage.__init__(self, stageId, policy)
self.filterChars = ('u','g','r','i','z','y')
self.templateDict = {}
self.additionalData = base.PropertySet()
self.database = persistence.LogicalLocation(policy.getString('database'))
self.objectTable = policy.getString('objectTable') if policy.exists('objectTable') else None
self.storeOutputs = policy.getBool('storeOutputs')
self.appendTables = policy.getBool('appendTables')
self.dropTables = policy.getBool('dropTables')
self.scriptDir = persistence.LogicalLocation(policy.getString('scriptDirectory')).locString()
if not os.path.exists(self.scriptDir):
os.makedirs(self.scriptDir)
self.templateDict['diaSourceTable'] = policy.getString('diaSourceTable')
self.templateDict['varObjectTable'] = policy.getString('varObjectTable')
self.templateDict['nonVarObjectTable'] = policy.getString('nonVarObjectTable')
def setUp(self):
# Create the additionalData PropertySet
self.additionalData = dafBase.PropertySet()
self.additionalData.addInt("sliceId", 0)
self.additionalData.addString("visitId", "fov391")
self.additionalData.addInt("universeSize", 100)
self.additionalData.addString("itemName", "foo")
# Create an empty Policy
policy = pexPolicy.Policy()
# Get a Persistence object
self.persistence = dafPers.Persistence.getPersistence(policy)
# Choose a file to manipulate
self.infile = os.path.join(dataDir, "small_MI.fits")
self.maskedImage = afwImage.MaskedImageF(self.infile)
def testSetAddVector(self):
ps = dafBase.PropertySet()
boolArr = [True, False]
intArr = [1, -1, 2]
floatArr = [1.2, 99.5, -35.1]
strArr = ["this", "is", "some strings"]
ps.set("bools", boolArr)
ps.set("ints", intArr)
ps.set("floats", floatArr)
ps.set("strs", strArr)
self.assertEqual(ps.get("bools"), boolArr[-1])
self.assertEqual(ps.getArray("bools"), boolArr)
self.assertEqual(ps.getScalar("bools"), boolArr[-1])
self.assertEqual(ps.get("ints"), intArr[-1])
self.assertEqual(ps.getArray("ints"), intArr)
self.assertEqual(ps.getScalar("ints"), intArr[-1])
self.assertEqual(ps.get("floats"), floatArr[-1])
self.assertEqual(ps.getArray("floats"), floatArr)
self.assertEqual(ps.getScalar("floats"), floatArr[-1])
self.assertEqual(ps.get("strs"), strArr[-1])
self.assertEqual(ps.getArray("strs"), strArr)
self.assertEqual(ps.getScalar("strs"), strArr[-1])
self.assertEqual(ps.valueCount(), 11)
ps.add("bools", list(reversed(boolArr)))
ps.add("ints", list(reversed(intArr)))
ps.add("floats", list(reversed(floatArr)))
ps.add("strs", list(reversed(strArr)))
self.assertEqual(ps.get("bools"), boolArr[0])
self.assertEqual(ps.getArray("bools"),
boolArr + list(reversed(boolArr)))
self.assertEqual(ps.getScalar("bools"), boolArr[0])
self.assertEqual(ps.get("ints"), intArr[0])
self.assertEqual(ps.getArray("ints"), intArr + list(reversed(intArr)))
self.assertEqual(ps.getScalar("ints"), intArr[0])
self.assertEqual(ps.get("floats"), floatArr[0])
self.assertEqual(ps.getArray("floats"),
floatArr + list(reversed(floatArr)))
self.assertEqual(ps.getScalar("floats"), floatArr[0])
self.assertEqual(ps.get("strs"), strArr[0])
self.assertEqual(ps.getArray("strs"), strArr + list(reversed(strArr)))
self.assertEqual(ps.getScalar("strs"), strArr[0])
self.assertEqual(ps.valueCount(), 22)
self.checkPickle(ps)
def setUp(self):
# metadata taken from CFHT data
# v695856-e0/v695856-e0-c000-a00.sci_img.fits
metadata = dafBase.PropertySet()
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---TAN")
metadata.set("CTYPE2", "DEC--TAN")
metadata.setDouble("CD1_1", 5.10808596133527E-05)
metadata.setDouble("CD1_2", 1.85579539217196E-07)
metadata.setDouble("CD2_2", -5.10281493481982E-05)
metadata.setDouble("CD2_1", -8.27440751733828E-07)
self.tanWcs = afwImage.makeWcs(metadata)
