def test_FrameDictRemapFrame(self):
for useDomainForRemapFrame in (False, True):
frameDict = ast.FrameDict(self.frame1, self.zoomMap, self.frame2)
indata = np.array([
[0.0, 0.1, -1.5],
[5.1, 0.0, 3.1],
])
predictedOut1 = indata * self.zoom
assert_allclose(frameDict.applyForward(indata), predictedOut1)
assert_allclose(frameDict.applyInverse(predictedOut1), indata)
self.checkMappingPersistence(frameDict, indata)
shift = (0.5, -1.5)
shiftMap = ast.ShiftMap(shift, "Ident=shift")
initialNumShiftMap = shiftMap.getNObject()
self.assertEqual(self.zoomMap.getNObject(),
self.initialNumZoomMap + 1)
if useDomainForRemapFrame:
frameDict.remapFrame("FRAME1", shiftMap)
else:
frameDict.remapFrame(1, shiftMap)
self.assertEqual(self.zoomMap.getNObject(),
self.initialNumZoomMap + 1)
self.assertEqual(shiftMap.getNObject(), initialNumShiftMap + 1)
predictedOut2 = (indata.T - shift).T * self.zoom
assert_allclose(frameDict.applyForward(indata), predictedOut2)
assert_allclose(frameDict.applyInverse(predictedOut2), indata)
def test_SeriesMapMatrixShiftSimplify(self):
"""Test that a non-square matrix map followed by a shift map can be simplified
This is ticket DM-10946
"""
m1 = 1.0
m2 = 2.0
shift = 3.0
matrixMap = ast.MatrixMap(np.array([[m1, m2]]))
self.assertEqual(matrixMap.nIn, 2)
self.assertEqual(matrixMap.nOut, 1)
shiftMap = ast.ShiftMap([shift])
seriesMap = matrixMap.then(shiftMap)
indata = np.array([
[1.0, 2.0, 3.0],
[0.0, 1.0, 2.0],
], dtype=float)
pred_outdata = m1 * indata[0] + m2 * indata[1] + shift
pred_outdata.shape = (1, len(pred_outdata))
outdata = seriesMap.applyForward(indata)
assert_allclose(outdata, pred_outdata)
simplifiedMap = seriesMap.simplify()
outdata2 = simplifiedMap.applyForward(indata)
assert_allclose(outdata2, pred_outdata)
def test_FitsChanInsertShift(self):
"""Check that a simple WCS can still be written as FITS-WCS
after inserting a shift at the beginning of GRID to IWC
This tests LSST ticket DM-12524
"""
ss = ast.StringStream("".join(self.cards))
fc = ast.FitsChan(ss, "Encoding=FITS-WCS, IWC=1")
frameSet = fc.read()
self.assertIsInstance(frameSet, ast.FrameSet)
self.assertAlmostEqual(fc.fitsTol, 0.1)
shift = 30
shiftMap = ast.ShiftMap([shift, shift])
shiftedFrameSet = self.insertPixelMapping(shiftMap, frameSet)
fc2 = writeFitsWcs(frameSet)
self.assertGreater(fc2.nCard, 9)
for i in (1, 2):
fv = fc2.getFitsF("CRPIX%d" % (i,))
self.assertAlmostEqual(fv.value, 100)
fc3 = writeFitsWcs(shiftedFrameSet)
self.assertGreaterEqual(fc3.nCard, fc2.nCard)
for i in (1, 2):
fv = fc3.getFitsF("CRPIX%d" % (i,))
self.assertAlmostEqual(fv.value, 100 - shift)
for name in fc2.getAllCardNames():
self.assertEqual(fc3.testFits(name), ast.FitsKeyState.PRESENT)
def test_FrameSetRemapFrame(self):
frame = ast.Frame(2, "Ident=base")
initialNumFrames = frame.getNObject() # may be >1 when run using pytest
frameSet = ast.FrameSet(frame)
self.assertIsInstance(frameSet, ast.FrameSet)
self.assertEqual(frameSet.nFrame, 1)
self.assertEqual(frame.getNObject(), initialNumFrames + 1)
newFrame = ast.Frame(2, "Ident=current")
self.assertEqual(frame.getNObject(), initialNumFrames + 2)
zoom = 0.5
zoomMap = ast.ZoomMap(2, zoom, "Ident=zoom")
initialNumZoomMap = zoomMap.getNObject()
frameSet.addFrame(1, zoomMap, newFrame)
self.assertEqual(frameSet.nFrame, 2)
self.assertEqual(frame.getNObject(), initialNumFrames + 3)
self.assertEqual(zoomMap.getNObject(), initialNumZoomMap + 1)
input_data = np.array([
[0.0, 0.1, -1.5],
[5.1, 0.0, 3.1],
])
predicted_output1 = input_data * zoom
assert_allclose(frameSet.applyForward(input_data), predicted_output1)
self.checkMappingPersistence(frameSet, input_data)
shift = (0.5, -1.5)
shiftMap = ast.ShiftMap(shift, "Ident=shift")
initialNumShiftMap = shiftMap.getNObject()
self.assertEqual(zoomMap.getNObject(), initialNumZoomMap + 1)
frameSet.remapFrame(1, shiftMap)
self.assertEqual(zoomMap.getNObject(), initialNumZoomMap + 1)
self.assertEqual(shiftMap.getNObject(), initialNumShiftMap + 1)
predicted_output2 = (input_data.T - shift).T * zoom
assert_allclose(frameSet.applyForward(input_data), predicted_output2)
def test_UnitNormMapSimplify(self):
"""Test advanced simplification of UnitNormMap
Basic simplification is tested elsewhere.
ShiftMap + UnitNormMap(forward) = UnitNormMap(forward)
UnitNormMap(inverted) + ShiftMap = UnitNormMap(inverted)
UnitNormMap(forward) + non-equal UnitNormMap(inverted) = ShiftMap
"""
center1 = [2, -1, 0]
center2 = [-1, 6, 4]
shift = [3, 7, -9]
# an array of points, each of 4 axes, the max we'll need
testpoints = np.array([
[1.0, 2.0, -6.0, 30.0, 1.0],
[3.0, 99.0, -5.0, 21.0, 0.0],
[-5.0, 3.0, -7.0, 37.0, 0.0],
[7.0, -23.0, -3.0, 45.0, 0.0],
],
dtype=float)
unm1 = ast.UnitNormMap(center1)
unm1inv = unm1.inverted()
unm2 = ast.UnitNormMap(center2)
unm2inv = unm2.inverted()
shiftmap = ast.ShiftMap(shift)
winmap_unitscale = ast.WinMap(np.zeros(3), shift, np.ones(3),
np.ones(3) + shift)
winmap_notunitscale = ast.WinMap(np.zeros(3), shift, np.ones(3),
np.ones(3) * 2 + shift)
if ast.astVersion() >= 9001003:
expected_map = "ShiftMap" # ShiftMap is ShiftMap in 9.1.3
else:
expected_map = "WinMap" # ShiftMap gets simplified to WinMap
for map1, map2, pred_simplified_class_name in (
(unm1, unm2inv, expected_map),
(shiftmap, unm1, "UnitNormMap"),
(winmap_unitscale, unm1, "UnitNormMap"),
(winmap_notunitscale, unm1, "SeriesMap"),
(unm1inv, shiftmap, "UnitNormMap"),
(unm1inv, winmap_unitscale, "UnitNormMap"),
(unm1inv, winmap_notunitscale, "SeriesMap"),
):
cmpmap = map1.then(map2)
self.assertEqual(map1.nIn, cmpmap.nIn)
self.assertEqual(map2.nOut, cmpmap.nOut)
cmpmap_simp = cmpmap.simplified()
self.assertEqual(cmpmap_simp.className, pred_simplified_class_name)
self.assertEqual(cmpmap.nIn, cmpmap_simp.nIn)
self.assertEqual(cmpmap.nOut, cmpmap_simp.nOut)
testptview = np.array(testpoints[0:cmpmap.nIn])
assert_allclose(cmpmap.applyForward(testptview),
cmpmap_simp.applyForward(testptview))
def test_ShiftMapBasics(self):
offset = np.array([1.1, -2.2, 3.3])
shiftmap = ast.ShiftMap(offset)
self.assertEqual(shiftmap.className, "ShiftMap")
self.assertEqual(shiftmap.nIn, 3)
self.assertEqual(shiftmap.nOut, 3)
self.checkBasicSimplify(shiftmap)
self.checkCopy(shiftmap)
indata = np.array([
[1.1, -43.5],
[2.2, 1309.31],
[3.3, 0.005],
])
outdata = shiftmap.applyForward(indata)
pred_outdata = (indata.T + offset).T
assert_allclose(outdata, pred_outdata)
self.checkRoundTrip(shiftmap, indata)
self.checkMappingPersistence(shiftmap, indata)
def makeSipIwcToPixel(metadata):
"""Make an IWC to pixel transform with SIP distortion from FITS-WCS metadata
This function is primarily intended for unit tests.
IWC is intermediate world coordinates, as described in the FITS papers.
Parameters
----------
metadata : lsst.daf.base.PropertySet
FITS metadata describing a WCS with inverse SIP coefficients
Returns
-------
lsst.afw.geom.TransformPoint2ToPoint2
Transform from IWC position to pixel position (zero-based)
in the forward direction. The inverse direction is not defined.
Notes
-----
The inverse SIP terms APn_m, BPn_m are polynomial coefficients x^n y^m
for computing transformed x, y respectively. If we call the resulting
polynomial inverseSipPolynomial, the returned transformation is:
pixelPosition = pixel origin + uv + inverseSipPolynomial(uv)
where uv = inverseCdMatrix * iwcPosition
"""
crpix = (metadata.getScalar("CRPIX1") - 1,
metadata.getScalar("CRPIX2") - 1)
pixelRelativeToAbsoluteMap = ast.ShiftMap(crpix)
cdMatrix = getCdMatrixFromMetadata(metadata)
cdMatrixMap = ast.MatrixMap(cdMatrix.copy())
coeffList = makeSipPolyMapCoeffs(metadata, "AP") + makeSipPolyMapCoeffs(
metadata, "BP")
coeffArr = np.array(coeffList, dtype=float)
sipPolyMap = ast.PolyMap(coeffArr, 2, "IterInverse=0")
iwcToPixelMap = cdMatrixMap.inverted().then(sipPolyMap).then(
pixelRelativeToAbsoluteMap)
return afwGeom.TransformPoint2ToPoint2(iwcToPixelMap)
def makeSipPixelToIwc(metadata):
"""Make a pixel to IWC transform with SIP distortion from FITS-WCS metadata
This function is primarily intended for unit tests.
IWC is intermediate world coordinates, as described in the FITS papers.
Parameters
----------
metadata : lsst.daf.base.PropertySet
FITS metadata describing a WCS with forward SIP coefficients
Returns
-------
lsst.afw.geom.TransformPoint2ToPoint2
Transform from pixel position (zero-based) to IWC position
in the forward direction. The inverse direction is not defined.
Notes
-----
The forward SIP terms An_m, Bn_m are polynomial coefficients x^n y^m
for computing transformed x, y respectively. If we call the resulting
polynomial sipPolynomial, the returned transformation is:
iwcPosition = cdMatrix * (dxy + sipPolynomial(dxy))
where dxy = pixelPosition - pixelOrigin
"""
crpix = (metadata.get("CRPIX1") - 1, metadata.get("CRPIX2") - 1)
pixelAbsoluteToRelativeMap = ast.ShiftMap(crpix).getInverse()
cdMatrix = getCdMatrixFromMetadata(metadata)
cdMatrixMap = ast.MatrixMap(cdMatrix.copy())
coeffList = makeSipPolyMapCoeffs(metadata, "A") + makeSipPolyMapCoeffs(
metadata, "B")
coeffArr = np.array(coeffList, dtype=float)
sipPolyMap = ast.PolyMap(coeffArr, 2, "IterInverse=0")
pixelToIwcMap = pixelAbsoluteToRelativeMap.then(sipPolyMap).then(
cdMatrixMap)
return afwGeom.TransformPoint2ToPoint2(pixelToIwcMap)
def setUp(self):
self.nin = 2
self.zoom = 1.3
self.shift = [-0.5, 1.2]
self.zoommap = ast.ZoomMap(self.nin, self.zoom)
self.shiftmap = ast.ShiftMap(self.shift)
def test_KeyMapVectors(self):
keyMap = ast.KeyMap()
zoomMap = ast.ZoomMap(2, 5)
shiftMap = ast.ShiftMap([3.3, -4.1])
keyMap.putI("ikey", [5, 2])
keyMap.putS("skey", [-3, -1])
keyMap.putB("bkey", [0, 2, 4, 8])
keyMap.putD("dkey", [3.14, 0.005, 9.123e5])
keyMap.putF("fkey", [2.78, 999.9])
keyMap.putC("ckey", ["val0", "val1", "a longer value"])
keyMap.putA("akey", [zoomMap, shiftMap])
self.assertEqual(len(keyMap), 7)
self.assertEqual(keyMap.length("ikey"), 2)
self.assertEqual(keyMap.length("skey"), 2)
self.assertEqual(keyMap.length("bkey"), 4)
self.assertEqual(keyMap.length("dkey"), 3)
self.assertEqual(keyMap.length("fkey"), 2)
self.assertEqual(keyMap.length("ckey"), 3)
self.assertEqual(keyMap.length("akey"), 2)
self.assertEqual(keyMap.type("ikey"), ast.DataType.IntType)
self.assertEqual(keyMap.type("skey"), ast.DataType.ShortIntType)
self.assertEqual(keyMap.type("bkey"), ast.DataType.ByteType)
self.assertEqual(keyMap.type("dkey"), ast.DataType.DoubleType)
self.assertEqual(keyMap.type("fkey"), ast.DataType.FloatType)
self.assertEqual(keyMap.type("ckey"), ast.DataType.StringType)
self.assertEqual(keyMap.type("akey"), ast.DataType.ObjectType)
self.assertEqual(keyMap.type("no"), ast.DataType.BadType)
self.assertEqual(keyMap.getI("ikey"), [5, 2])
self.assertEqual(keyMap.getS("skey"), [-3, -1])
self.assertEqual(keyMap.getB("bkey"), [0, 2, 4, 8])
self.assertEqual(keyMap.getB("bkey", 0), 0)
self.assertEqual(keyMap.getB("bkey", 3), 8)
assert_allclose(keyMap.getD("dkey"), [3.14, 0.005, 9.123e5])
assert_allclose(keyMap.getF("fkey"), [2.78, 999.9])
self.assertEqual(keyMap.getC("ckey"),
["val0", "val1", "a longer value"])
self.assertEqual([obj.show() for obj in keyMap.getA("akey")],
[zoomMap.show(), shiftMap.show()])
for i, val in enumerate(keyMap.getI("ikey")):
self.assertEqual(keyMap.getI("ikey", i), val)
for i, val in enumerate(keyMap.getS("skey")):
self.assertEqual(keyMap.getS("skey", i), val)
for i, val in enumerate(keyMap.getB("bkey")):
self.assertEqual(keyMap.getB("bkey", i), val)
for i, val in enumerate(keyMap.getD("dkey")):
self.assertAlmostEqual(keyMap.getD("dkey", i), val)
for i, val in enumerate(keyMap.getF("fkey")):
self.assertAlmostEqual(keyMap.getF("fkey", i), val, places=5)
for i, val in enumerate(keyMap.getC("ckey")):
self.assertEqual(keyMap.getC("ckey", i), val)
for i, val in enumerate(keyMap.getA("akey")):
self.assertEqual(keyMap.getA("akey", i).show(), val.show())
clen = keyMap.length("ckey")
with self.assertRaises(Exception):
keyMap.getC("ckey", clen) # invalid index
with self.assertRaises(Exception):
keyMap.replace("ckey", clen, "anything") # invalid index
keyMap.replace("ikey", 1, 3)
self.assertEqual(keyMap.getI("ikey"), [5, 3])
keyMap.replace("ikey", 0, -3)
self.assertEqual(keyMap.getI("ikey"), [-3, 3])
keyMap.append("ikey", 5)
self.assertEqual(keyMap.getI("ikey"), [-3, 3, 5])
keyMap.replace("skey", 1, 2)
self.assertEqual(keyMap.getS("skey"), [-3, 2])
keyMap.replace("skey", 0, 47)
self.assertEqual(keyMap.getS("skey"), [47, 2])
keyMap.append("skey", -35)
self.assertEqual(keyMap.getS("skey"), [47, 2, -35])
keyMap.replace("bkey", 0, 36)
self.assertEqual(keyMap.getB("bkey"), [36, 2, 4, 8])
keyMap.replace("bkey", 2, 0)
self.assertEqual(keyMap.getB("bkey"), [36, 2, 0, 8])
keyMap.replace("bkey", 1, 11)
self.assertEqual(keyMap.getB("bkey"), [36, 11, 0, 8])
keyMap.replace("bkey", 3, 77)
self.assertEqual(keyMap.getB("bkey"), [36, 11, 0, 77])
keyMap.append("bkey", 2)
self.assertEqual(keyMap.getB("bkey"), [36, 11, 0, 77, 2])
keyMap.replace("dkey", 1, 33.3)
assert_allclose(keyMap.getD("dkey"), [3.14, 33.3, 9.123e5])
keyMap.replace("dkey", 2, 152)
assert_allclose(keyMap.getD("dkey"), [3.14, 33.3, 152])
keyMap.replace("dkey", 0, 0.01)
assert_allclose(keyMap.getD("dkey"), [0.01, 33.3, 152])
keyMap.replace("fkey", 1, 3.012)
assert_allclose(keyMap.getF("fkey"), [2.78, 3.012])
keyMap.replace("fkey", 0, -32.1)
assert_allclose(keyMap.getF("fkey"), [-32.1, 3.012])
keyMap.append("fkey", 98.6)
assert_allclose(keyMap.getF("fkey"), [-32.1, 3.012, 98.6])
