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)