def testAssertCoordsNearlyEqual(self):
"""Test assertCoordsNearlyEqual"""
for raDecDeg in ((45, 45), (-70, 89), (130, -89.5)):
raDecDeg = [val * afwGeom.degrees for val in raDecDeg]
coord0 = afwCoord.IcrsCoord(*raDecDeg)
self.assertCoordsNearlyEqual(coord0,
coord0,
maxDiff=1e-7 * afwGeom.arcseconds)
for offAng in (0, 45, 90):
offAng = offAng * afwGeom.degrees
for offDist in (0.001, 0.1):
offDist = offDist * afwGeom.arcseconds
coord1 = coord0.toGalactic()
coord1.offset(offAng, offDist)
self.assertCoordsNearlyEqual(coord0,
coord1,
maxDiff=offDist * 1.00001)
with self.assertRaises(AssertionError):
self.assertCoordsNearlyEqual(coord0,
coord1,
maxDiff=offDist * 0.99999)
# test wraparound in RA
coord2 = afwCoord.IcrsCoord(raDecDeg[0] + 360 * afwGeom.degrees,
raDecDeg[1])
self.assertCoordsNearlyEqual(coord0,
coord2,
maxDiff=1e-7 * afwGeom.arcseconds)
def testTicket2441(self):
"""Test ticket 2441: warpExposure sometimes mishandles zero-extent dest exposures"""
fromWcs = makeWcs(
pixelScale=afwGeom.Angle(1.0e-8, afwGeom.degrees),
projection="TAN",
crPixPos=(0, 0),
crValCoord=afwCoord.IcrsCoord(afwGeom.Point2D(359, 0),
afwGeom.degrees),
)
fromExp = afwImage.ExposureF(afwImage.MaskedImageF(10, 10), fromWcs)
toWcs = makeWcs(
pixelScale=afwGeom.Angle(0.00011, afwGeom.degrees),
projection="CEA",
crPixPos=(410000.0, 11441.0),
crValCoord=afwCoord.IcrsCoord(afwGeom.Point2D(45, 0),
afwGeom.degrees),
doFlipX=True,
)
toExp = afwImage.ExposureF(afwImage.MaskedImageF(0, 0), toWcs)
warpControl = afwMath.WarpingControl("lanczos3")
# if a bug described in ticket #2441 is present, this will raise an
# exception:
numGoodPix = afwMath.warpExposure(toExp, fromExp, warpControl)
self.assertEqual(numGoodPix, 0)
def testSmallSrc(self):
"""Verify that a source image that is too small will not raise an exception
This tests another bug that was fixed in ticket #2441
"""
fromWcs = makeWcs(
pixelScale=afwGeom.Angle(1.0e-8, afwGeom.degrees),
projection="TAN",
crPixPos=(0, 0),
crValCoord=afwCoord.IcrsCoord(afwGeom.Point2D(359, 0),
afwGeom.degrees),
)
fromExp = afwImage.ExposureF(afwImage.MaskedImageF(1, 1), fromWcs)
toWcs = makeWcs(
pixelScale=afwGeom.Angle(1.1e-8, afwGeom.degrees),
projection="TAN",
crPixPos=(0, 0),
crValCoord=afwCoord.IcrsCoord(afwGeom.Point2D(358, 0),
afwGeom.degrees),
)
toExp = afwImage.ExposureF(afwImage.MaskedImageF(10, 10), toWcs)
warpControl = afwMath.WarpingControl("lanczos3")
# if a bug described in ticket #2441 is present, this will raise an
# exception:
numGoodPix = afwMath.warpExposure(toExp, fromExp, warpControl)
self.assertEqual(numGoodPix, 0)
imArr, maskArr, varArr = toExp.getMaskedImage().getArrays()
self.assertTrue(np.all(np.isnan(imArr)))
self.assertTrue(np.all(np.isinf(varArr)))
noDataBitMask = afwImage.Mask.getPlaneBitMask("NO_DATA")
self.assertTrue(np.all(maskArr == noDataBitMask))
def testEquality(self):
# (In)equality is determined by value, not identity. See DM-2347, -2465.
c1 = afwCoord.IcrsCoord(self.ra, self.dec)
self.assertTrue(c1 == c1)
self.assertFalse(c1 != c1)
c2 = afwCoord.IcrsCoord(self.ra.replace('1', '2'), self.dec)
self.assertFalse(c2 == c1)
self.assertTrue(c2 != c1)
c3 = afwCoord.IcrsCoord(self.ra, self.dec)
self.assertTrue(c3 == c1)
self.assertFalse(c3 != c1)
def testEquality(self):
# (In)equality is determined by value, not identity. See DM-2347, -2465.
# These asserts are testing the functionality of `==` and `!=` and should not be changed
c1 = afwCoord.IcrsCoord(self.ra, self.dec)
self.assertTrue(c1 == c1)
self.assertFalse(c1 != c1)
c2 = afwCoord.IcrsCoord(self.ra.replace('1', '2'), self.dec)
self.assertTrue(c2 != c1)
self.assertFalse(c2 == c1)
c3 = afwCoord.IcrsCoord(self.ra, self.dec)
self.assertEqual(c3, c1)
self.assertFalse(c3 != c1)
def setUp(self):
self.crval = afwCoord.IcrsCoord(afwGeom.PointD(44., 45.))
self.crpix = afwGeom.Point2D(15000, 4000)
arcsecPerPixel = 1 / 3600.0
CD11 = arcsecPerPixel
CD12 = 0
CD21 = 0
CD22 = arcsecPerPixel
self.wcs = afwImage.makeWcs(self.crval, self.crpix, CD11, CD12, CD21,
CD22)
refSchema = afwTable.SimpleTable.makeMinimalSchema()
self.refCentroidKey = afwTable.Point2DKey.addFields(
refSchema, "centroid", "centroid", "pixels")
self.refCoordKey = afwTable.CoordKey(refSchema["coord"])
self.refCat = afwTable.SimpleCatalog(refSchema)
# an alias is required to make src.getCentroid() work;
# simply defining a field named "slot_Centroid" doesn't suffice
srcSchema = afwTable.SourceTable.makeMinimalSchema()
self.srcCentroidKey = afwTable.Point2DKey.addFields(
srcSchema, "base_SdssCentroid", "centroid", "pixels")
srcAliases = srcSchema.getAliasMap()
srcAliases.set("slot_Centroid", "base_SdssCentroid")
self.srcCoordKey = afwTable.CoordKey(srcSchema["coord"])
self.sourceCat = afwTable.SourceCatalog(srcSchema)
def averageRaDec(ra, dec):
"""Calculate average RA, Dec from input lists using spherical geometry.
Parameters
----------
ra : list of float
RA in [radians]
dec : list of float
Dec in [radians]
Returns
-------
float, float
meanRa, meanDec -- Tuple of average RA, Dec [radians]
"""
assert (len(ra) == len(dec))
angleRa = [afwGeom.Angle(r, afwGeom.radians) for r in ra]
angleDec = [afwGeom.Angle(d, afwGeom.radians) for d in dec]
coords = [
afwCoord.IcrsCoord(ar, ad) for (ar, ad) in zip(angleRa, angleDec)
]
meanRa, meanDec = afwCoord.averageCoord(coords)
return meanRa.asRadians(), meanDec.asRadians()
def joinMatchListWithCatalog(self, matchCat, sourceCat):
"""!Relink an unpersisted match list to sources and reference objects
A match list is persisted and unpersisted as a catalog of IDs produced by
afw.table.packMatches(), with match metadata (as returned by the astrometry tasks)
in the catalog's metadata attribute. This method converts such a match catalog
into a match list (an lsst.afw.table.ReferenceMatchVector) with links to source
records and reference object records.
@param[in] matchCat Unperisted packed match list (an lsst.afw.table.BaseCatalog).
matchCat.table.getMetadata() must contain match metadata,
as returned by the astrometry tasks.
@param[in,out] sourceCat Source catalog (an lsst.afw.table.SourceCatalog).
As a side effect, the catalog will be sorted by ID.
@return the match list (an lsst.afw.table.ReferenceMatchVector)
"""
matchmeta = matchCat.table.getMetadata()
version = matchmeta.getInt('SMATCHV')
if version != 1:
raise ValueError('SourceMatchVector version number is %i, not 1.' %
version)
filterName = matchmeta.getString('FILTER').strip()
ctrCoord = afwCoord.IcrsCoord(
matchmeta.getDouble('RA') * afwGeom.degrees,
matchmeta.getDouble('DEC') * afwGeom.degrees,
)
rad = matchmeta.getDouble('RADIUS') * afwGeom.degrees
refCat = self.loadSkyCircle(ctrCoord, rad, filterName).refCat
refCat.sort()
sourceCat.sort()
return afwTable.unpackMatches(matchCat, refCat, sourceCat)
def makeFakeWcs():
'''!Make a wcs to put in an exposure
\return a Wcs object
'''
return afwImage.makeWcs(
afwCoord.IcrsCoord(45.0 * afwGeom.degrees, 45.0 * afwGeom.degrees),
afwGeom.Point2D(0.0, 0.0), 1.0, 0.0, 0.0, 1.0)
def testTicket2872(self):
"""Test that CoaddPsf.getAveragePosition() is always a position at which
we can call computeImage().
"""
schema = afwTable.ExposureTable.makeMinimalSchema()
weightKey = schema.addField("weight",
type=float,
doc="photometric weight")
catalog = afwTable.ExposureCatalog(schema)
cdelt = (0.2 * afwGeom.arcseconds).asDegrees()
wcs = afwImage.makeWcs(
afwCoord.IcrsCoord(afwGeom.Point2D(45.0, 45.0), afwGeom.degrees),
afwGeom.Point2D(50, 50), cdelt, 0.0, 0.0, cdelt)
kernel = measAlg.DoubleGaussianPsf(7, 7, 2.0).getKernel()
psf1 = measAlg.KernelPsf(kernel, afwGeom.Point2D(0, 50))
psf2 = measAlg.KernelPsf(kernel, afwGeom.Point2D(100, 50))
record1 = catalog.addNew()
record1.setPsf(psf1)
record1.setWcs(wcs)
record1.setD(weightKey, 1.0)
record1.setBBox(
afwGeom.Box2I(afwGeom.Point2I(-40, 0), afwGeom.Point2I(40, 100)))
record2 = catalog.addNew()
record2.setPsf(psf2)
record2.setWcs(wcs)
record2.setD(weightKey, 1.0)
record2.setBBox(
afwGeom.Box2I(afwGeom.Point2I(60, 0), afwGeom.Point2I(140, 100)))
coaddPsf = measAlg.CoaddPsf(catalog, wcs)
naiveAvgPos = afwGeom.Point2D(50, 50)
self.assertRaises(pexExceptions.InvalidParameterError,
coaddPsf.computeKernelImage, naiveAvgPos)
# important test is that this doesn't throw:
coaddPsf.computeKernelImage()
def testNames(self):
"""Test the names of the Coords (Useful with Point2D form)"""
# verify that each coordinate type can tell you what its components are called.
radec1, known1 = afwCoord.Coord(
self.ra, self.dec).getCoordNames(), ["RA", "Dec"]
radec3, known3 = afwCoord.Fk5Coord(
self.ra, self.dec).getCoordNames(), ["RA", "Dec"]
radec4, known4 = afwCoord.IcrsCoord(
self.ra, self.dec).getCoordNames(), ["RA", "Dec"]
lb, known5 = afwCoord.GalacticCoord(
self.ra, self.dec).getCoordNames(), ["L", "B"]
lambet, known6 = afwCoord.EclipticCoord(
self.ra, self.dec).getCoordNames(), ["Lambda", "Beta"]
observatory = afwCoord.Observatory(0 * afwGeom.degrees,
0 * afwGeom.degrees, 0)
altaz = afwCoord.TopocentricCoord(self.ra, self.dec, 2000.0,
observatory).getCoordNames()
known7 = ["Az", "Alt"]
pairs = [
[radec1, known1],
[radec3, known3],
[radec4, known4],
[lb, known5],
[lambet, known6],
[altaz, known7],
]
for pair, known in (pairs):
self.assertEqual(pair[0], known[0])
self.assertEqual(pair[1], known[1])
def testTicket2872(self):
"""Test that CoaddPsf.getAveragePosition() is always a position at which
we can call computeImage().
"""
cdelt = (0.2 * afwGeom.arcseconds).asDegrees()
wcs = afwImage.makeWcs(
afwCoord.IcrsCoord(afwGeom.Point2D(45.0, 45.0), afwGeom.degrees),
afwGeom.Point2D(50, 50), cdelt, 0.0, 0.0, cdelt)
kernel = measAlg.DoubleGaussianPsf(7, 7, 2.0).getKernel()
psf1 = measAlg.KernelPsf(kernel, afwGeom.Point2D(0, 50))
psf2 = measAlg.KernelPsf(kernel, afwGeom.Point2D(100, 50))
record1 = self.mycatalog.addNew()
record1.setPsf(psf1)
record1.setWcs(wcs)
record1.setD(self.weightKey, 1.0)
record1.setBBox(
afwGeom.Box2I(afwGeom.Point2I(-40, 0), afwGeom.Point2I(40, 100)))
record2 = self.mycatalog.addNew()
record2.setPsf(psf2)
record2.setWcs(wcs)
record2.setD(self.weightKey, 1.0)
record2.setBBox(
afwGeom.Box2I(afwGeom.Point2I(60, 0), afwGeom.Point2I(140, 100)))
coaddPsf = measAlg.CoaddPsf(self.mycatalog, wcs)
naiveAvgPos = afwGeom.Point2D(50, 50)
with self.assertRaises(pexExceptions.InvalidParameterError):
coaddPsf.computeKernelImage(naiveAvgPos)
# important test is that this doesn't throw:
coaddPsf.computeKernelImage()
def run(self, dataRef):
"""Report tracts and patches that are within a given region of a skymap
@param dataRef: data reference for sky map.
@return: a pipeBase.Struct with fields:
- ccdInfoSetDict: a dict of (tractId, patchIndex): set of CcdExposureInfo
"""
skyMap = dataRef.get(self.config.coaddName + "Coadd_skyMap")
# make coords in the correct order to form an enclosed space
raRange = (self.config.raDecRange[0], self.config.raDecRange[2])
decRange = (self.config.raDecRange[1], self.config.raDecRange[3])
raDecList = [
(raRange[0], decRange[0]),
(raRange[1], decRange[0]),
(raRange[1], decRange[1]),
(raRange[0], decRange[1]),
]
coordList = [
afwCoord.IcrsCoord(afwGeom.Angle(ra, afwGeom.degrees),
afwGeom.Angle(dec, afwGeom.degrees))
for ra, dec in raDecList
]
tractPatchList = skyMap.findTractPatchList(coordList)
for tractInfo, patchInfoList in tractPatchList:
for patchInfo in patchInfoList:
patchIndex = patchInfo.getIndex()
print("tract=%d patch=%d,%d" %
(tractInfo.getId(), patchIndex[0], patchIndex[1]))
def parse_args(self, policyPath, requiredArgs=()):
"""Parse the arguments
@param[in] policyPath: path to main policy dictionary
@param[in] requiredArgs: list of required arguments, in addition to the standard ones
@return
- config: a Configuration object
- opts: command-line options, as from optparse
- args: command-line arguments, as from optparse
Must be called before calling getReadWrite, getWcs, getWcsBBox, getIdList
"""
config, opts, args = idListOptions.IdListOptionParser.parse_args(
self,
policyPath=policyPath,
requiredArgs=("size", ) + tuple(requiredArgs))
pixelScale = opts.scaleAS * _RadPerDeg / 3600.0
self._skyMap = skymap.SkyMap(
projection=opts.projection,
pixelScale=pixelScale,
overlap=opts.overlapDeg * _RadPerDeg,
)
raDec = getattr(opts, "radec", None)
if raDec != None:
ctrCoord = afwCoord.IcrsCoord(
afwGeom.Point2D(opts.radec[0], opts.radec[1]),
afwCoord.DEGREES)
dimensions = afwGeom.Extent2I(opts.size[0], opts.size[1])
tileId = opts.tileid
if tileId == None:
if opts.radec == None:
raise RuntimeError("Must specify tileid or radec")
tileId = self._skyMap.getSkyTileId(ctrCoord)
self._skyTileInfo = self._skyMap.getSkyTileInfo(tileId)
self._coaddWcs = self._skyTileInfo.getWcs()
# determine bounding box
if opts.llc != None:
llcPixInd = afwGeom.Point2I(opts.llc[0], opts.llc[1])
else:
if opts.radec == None:
raise RuntimeError("Must specify llc or radec")
ctrPixPos = self._coaddWcs.skyToPixel(ctrCoord)
ctrPixInd = afwGeom.Point2I(ctrPixPos)
llcPixInd = ctrPixInd - (dimensions / 2)
self._coaddBBox = afwGeom.Box2I(llcPixInd, dimensions)
roots = config["roots"]
self._coaddBasePath = os.path.join(roots["output"], opts.rerun)
return config, opts, args
def testTractContains(self):
"""Test that TractInfo.contains works"""
skyMap = self.getSkyMap()
for tract in skyMap:
coord = tract.getCtrCoord()
self.assertTrue(tract.contains(coord))
opposite = afwCoord.IcrsCoord(coord.getLongitude() + 12*afwGeom.hours, -1*coord.getLatitude())
self.assertFalse(tract.contains(opposite))
def compute_coord(row, ra_name, dec_name):
"""!Create a afwCoord object from a np.array row
@param[in] row dict like object with ra/dec info in degrees
@param[in] ra_name name of RA key
@param[in] dec_name name of Dec key
@param[out] IcrsCoord object constructed from the RA/Dec values
"""
return afwCoord.IcrsCoord(row[ra_name] * afwGeom.degrees,
row[dec_name] * afwGeom.degrees)
def makeSimpleImage():
wcs = makeWcs(
pixelScale=2 * afwGeom.arcseconds,
crPixPos=[0, 0],
crValCoord=afwCoord.IcrsCoord(
0 * afwGeom.degrees, 0 * afwGeom.degrees),
)
im = afwImage.ExposureF(100, 100, wcs)
im.writeFits("simple.fits")
def testCast(self):
# strangely, this overload of makeWcs returns a TAN WCS that's not a TanWcs
wcs = afwImage.makeWcs(afwCoord.IcrsCoord(45.0*afwGeom.degrees, 45.0*afwGeom.degrees),
afwGeom.Point2D(0.0, 0.0), 1.0, 0.0, 0.0, 1.0)
# ...but if you round-trip it through a PropertySet, you get a TanWcs in a Wcs ptr,
# which is what we want for this test.
base = afwImage.makeWcs(wcs.getFitsMetadata())
self.assertEqual(type(base), afwImage.Wcs)
derived = afwImage.TanWcs.cast(base)
self.assertEqual(type(derived), afwImage.TanWcs)
def getCoordList(minRa, minDec, maxRa, maxDec):
degList = (
(minRa, minDec),
(maxRa, minDec),
(maxRa, maxDec),
(minRa, maxDec),
)
return tuple(
afwCoord.IcrsCoord(afwGeom.Point2D(d[0], d[1]), afwGeom.degrees)
for d in degList)
def validate(xs, ys, mapper, wcs):
dists = []
for i in range(len(xs)):
tuple1 = mapper.xyToRaDec(xs[i], ys[i])
coord1 = afwCoord.IcrsCoord(afwGeom.Point2D(tuple1[0], tuple1[1]),
afwGeom.radians)
coord2 = wcs.pixelToSky(xs[i], ys[i])
dist = coord1.angularSeparation(coord2).asArcseconds()
dists.append(dist)
print(np.mean(dists), np.std(dists))
def testPrune1(self):
coords = []
for ra, dec in [(0.0, 0.0), (0.1, 0.1), (0.0, 90.0), (0.0, -90.0)]:
coords.append(afwCoord.IcrsCoord(ra * degrees, dec * degrees))
res = 3
qs = skypix.QuadSpherePixelization(res, 0.0)
root, x, y = 1, 1, 1
skyTileId = qs.id(root, x, y)
skyTile = utils.PT1SkyTile(res, root, x, y, skyTileId)
numContained = sum(skyTile.contains(s) for s in coords)
self.assertEqual(numContained, 2)
def setUp(self):
ra = 10.0 * afwGeom.degrees
dec = 1.0 * afwGeom.degrees
epoch = 2000.0
self.data = [
afwCoord.Coord(ra, dec, epoch),
afwCoord.Fk5Coord(ra, dec, epoch),
afwCoord.IcrsCoord(ra, dec),
afwCoord.GalacticCoord(ra, dec),
afwCoord.EclipticCoord(ra, dec),
# TopocentricCoord is not currently picklable
]
def setUp(self):
crval = afwCoord.IcrsCoord(afwGeom.PointD(44., 45.))
crpix = afwGeom.Point2D(15000, 4000)
arcsecPerPixel = 1 / 3600.0
CD11 = arcsecPerPixel
CD12 = 0
CD21 = 0
CD22 = arcsecPerPixel
self.tanWcs = afwImage.makeWcs(crval, crpix, CD11, CD12, CD21, CD22)
self.loadData()
def get_Ebv(result):
ebvMapNorth = EBV.EBVmap()
datadir = os.environ.get("SIMS_DUSTMAPS_DIR")
ebvMapNorth.readMapFits(os.path.join(datadir, "DustMaps/SFD_dust_4096_ngp.fits"))
ebvMapSouth = EBV.EBVmap()
ebvMapSouth.readMapFits(os.path.join(datadir, "DustMaps/SFD_dust_4096_sgp.fits"))
# Calculate galactic coordinates:
gLon = []
gLat = []
for i in range(len(result['raJ2000'])):
gcoord = afwCoord.IcrsCoord(afwGeom.Point2D(result[i]['raJ2000'], result[i]['decJ2000']), afwGeom.radians).toGalactic()
gLon.append(gcoord.getL().asRadians())
gLat.append(gcoord.getB().asRadians())
return EBV.calculateEbv(gLon, gLat, ebvMapNorth, ebvMapSouth, interp = True)
def get_hsc_regions(box_coords, butler=None):
"""
Get hsc regions within a polygonal region (box) of the sky. Here,
hsc regions means the tracts and patches within the 'skybox'.
Parameters
----------
box_coords : list of tuples
The four coordinates for the box corners. This is the
output of the skybox function. If only one coordinate
is given, will return a single tract and patch.
butler : Butler object, optional
If None, then a will be created in this function.
Default is None.
Returns
-------
regions : structured ndarray
The tracts and patches within the skybox. The columns of
the array are 'tract' and 'patch'.
Note
----
This may give incorrect answers on regions that are larger than a tract,
which is ~1.5 degree = 90 arcminute.
"""
import lsst.afw.coord as afwCoord
import lsst.afw.geom as afwGeom
if butler is None:
import lsst.daf.persistence
from myPipe import dataDIR
butler = lsst.daf.persistence.Butler(dataDIR)
if len(box_coords)==4:
from toolbox.astro import angsep
(ra1, dec1), (ra2, dec2) = box_coords[0], box_coords[2]
if angsep(ra1, dec1, ra2, dec2, sepunits='arcmin') > 90.0:
print('\n********* WARNING *********')
print('Region larger than a tract')
print('***************************\n')
skymap = butler.get('deepCoadd_skyMap', immediate=True)
coordList = [afwCoord.IcrsCoord(afwGeom.Angle(ra, afwGeom.degrees),\
afwGeom.Angle(dec, afwGeom.degrees)) for ra, dec in box_coords]
tractPatchList = skymap.findClosestTractPatchList(coordList)
regions = []
for tractInfo, patchInfoList in tractPatchList:
for patchInfo in patchInfoList:
patchIndex = patchInfo.getIndex()
regions.append((tractInfo.getId(), str(patchIndex[0])+','+str(patchIndex[1])))
return np.array(regions, dtype=[('tract', int), ('patch', 'S4')])
def bypass_raw(self, datasetType, pythonType, location, dataId):
ccd = dataId['ccd']
x, y = ccd % 6, ccd // 6
xSize, ySize = 2048, 4096
filename = location.getLocations()[0]
bbox = afwGeom.Box2I(afwGeom.Point2I(x * xSize, y * ySize),
afwGeom.Extent2I(xSize, ySize))
if False:
# XXX seems to be some sort of bug here for ccd=11
# cfitsio returns: READ_ERROR 108 /* error reading from FITS file */
hdu = 0
image = afwImage.DecoratedImageF(filename, hdu, bbox)
else:
# XXX this can't be at all efficient, but it works
raw = afwImage.ImageF(filename)
sub = raw.Factory(raw, bbox, True)
del raw
sub.setXY0(afwGeom.Point2I(0, 0))
image = afwImage.DecoratedImageF(sub)
del sub
exp = exposureFromImage(image)
del image
md = exp.getMetadata()
md.add("EXPTIME", 1.0)
md.add("FILTER", "OPEN")
# Install a basic (wrong, apart from pixel scale) WCS so the pixel scale can be used
md.add("RA", "00:00:00.00")
md.add("DEC", "00:00:00.0")
coord = afwCoord.IcrsCoord(afwGeom.Point2D(0, 0), afwGeom.radians)
point = afwGeom.Point2D(0, 0)
pixScale = (0.9 * afwGeom.arcseconds).asDegrees()
wcs = afwImage.makeWcs(coord, point, pixScale, 0, 0, pixScale)
wcsMd = wcs.getFitsMetadata()
for key in wcsMd.names():
md.add(key, wcsMd.get(key))
exp.setWcs(wcs)
return self._standardizeExposure(self.exposures['raw'],
exp,
dataId,
filter=True,
trimmed=False)
def std_raw(self, image, dataId):
"""Standardize a raw dataset by converting it to an Exposure instead of an Image"""
if isinstance(image, afwImage.DecoratedImageU) or isinstance(image, afwImage.DecoratedImageI) or \
isinstance(image, afwImage.DecoratedImageF) or isinstance(image, afwImage.DecoratedImageD):
exposure = afwImage.makeExposure(afwImage.makeMaskedImage(image.getImage()))
else:
exposure = image
md = image.getMetadata()
if True:
wcs = afwImage.makeWcs(md, True)
# The CASU WCSes use ZPN; our stuff wants TAN
# This won't work near the pole, but should be decent away from it.
box = afwGeom.BoxD(image.getImage().getBBox())
refPix = box.getCenter()
refSky = wcs.pixelToSky(refPix)
refSkyOffsetX = wcs.pixelToSky(refPix + afwGeom.Extent2D(1.0, 0.0))
refSkyOffsetY = wcs.pixelToSky(refPix + afwGeom.Extent2D(0.0, 1.0))
xPixelScale = refSky.angularSeparation(refSkyOffsetX).asDegrees()
yPixelScale = refSky.angularSeparation(refSkyOffsetY).asDegrees()
xPixelScale = yPixelScale = wcs.pixelScale().asDegrees()
else:
refPix = afwGeom.Point2D(md.get("CRPIX1"), md.get("CRPIX2"))
refSky = afwCoord.IcrsCoord(md.get("CRVAL1")*afwGeom.degrees,
md.get("CRVAL2")*afwGeom.degrees)
xPixelScale = yPixelScale = (0.2*afwGeom.arcseconds).asDegrees()
# import pdb;pdb.set_trace()
exposure.setMetadata(md)
#newWcs = afwImage.makeWcs(refSky, refPix, xPixelScale, 0.0, 0.0, yPixelScale)
#wcs = afwImage.makeWcs(md, True)
#exposure.setWcs(newWcs)
exposure.setWcs(wcs)
""" Set up exposure time """
pathId = self._transformId(dataId)
expTime = pathId['expTime']
exposure.getCalib().setExptime(expTime)
return self._standardizeExposure(self.exposures['raw'], exposure, dataId,
trimmed=False)
def setUp(self):
'''Create two calibs, one with a valid zero-point and one without. Use these to create two UnitSystem
objects.
'''
self.mag2Flux = lambda m: 10.0**(m / 2.5)
self.flux2Mag = lambda f: 2.5 * np.log10(f)
calibNoZero = afwImage.Calib()
calibWithZero = afwImage.Calib()
calibWithZero.setFluxMag0(self.mag2Flux(25))
cdelt = (0.2 * afwGeom.arcseconds).asDegrees()
position = afwCoord.IcrsCoord(45.0 * afwGeom.degrees,
45.0 * afwGeom.degrees)
wcs = afwImage.makeWcs(position, afwGeom.Point2D(), cdelt, 0.0, 0.0,
cdelt)
self.unitNoZero = measModel.UnitSystem(wcs, calibNoZero)
self.unitWithZero = measModel.UnitSystem(wcs, calibWithZero)
def testTicket3093(self):
"""Declination -1 < delta < 0 always prints positive as a string"""
# from how-to-reproduce code reported on 3093 ticket
ra = 26.468676561631767*afwGeom.degrees
decl = -0.6684668814164008
# also make sure we didn't break the original functionality
# Test above/below +/-1
declIn = [ decl, -1.0*decl, decl - 1.0, -decl + 1.0]
declKnown = ["-00:40:06.48", "00:40:06.48", "-01:40:06.48", "01:40:06.48"]
for i in range(len(declIn)):
printableCoord = afwCoord.IcrsCoord(ra, declIn[i]*afwGeom.degrees).getDecStr()
# With bug, this prints e.g. '00:40:06.48. It should be '-00:40:06.48'
print("Decl 0 to -1 bug:", printableCoord)
self.assertEqual(printableCoord, declKnown[i])
def testAverage(self):
"""Tests for lsst.afw.coord.averageCoord"""
icrs = afwCoord.IcrsCoord(self.ra, self.dec)
gal = afwCoord.GalacticCoord(self.l * afwGeom.degrees,
self.b * afwGeom.degrees)
# Mixed systems, no system provided
with self.assertRaises(pexEx.InvalidParameterError):
afwCoord.averageCoord([icrs, gal])
# Mixed systems, but target system provided
# Only checking this doesn't fail; will check accuracy later
afwCoord.averageCoord([icrs, gal], afwCoord.ICRS)
afwCoord.averageCoord([icrs, gal], afwCoord.FK5)
# Same system, no target system provided
result = afwCoord.averageCoord([icrs] * 100)
self.assertEqual(result, icrs)
def circle(center, start, precision=1.0e-9):
"""Generate points in a circle; test that average is in the center
Precision is specified in arcseconds.
"""
coords = []
for ii in range(120):
new = start.clone()
new.rotate(center, ii * 3 * afwGeom.degrees)
coords.append(new)
result = afwCoord.averageCoord(coords)
distance = result.angularSeparation(center)
self.assertLess(distance.asArcseconds(), precision)
for center, start in (
# RA=0=360 border
(afwCoord.IcrsCoord(0 * afwGeom.degrees, 0 * afwGeom.degrees),
afwCoord.IcrsCoord(5 * afwGeom.degrees, 0 * afwGeom.degrees)),
# North pole
(afwCoord.IcrsCoord(0 * afwGeom.degrees, 90 * afwGeom.degrees),
afwCoord.IcrsCoord(0 * afwGeom.degrees, 85 * afwGeom.degrees)),
# South pole
(afwCoord.IcrsCoord(0 * afwGeom.degrees, -90 * afwGeom.degrees),
afwCoord.IcrsCoord(0 * afwGeom.degrees, -85 * afwGeom.degrees)),
):
circle(center, start)
