def test_FrameSetRemoveFrame(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)
zoomMap = ast.ZoomMap(2, 0.5, "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)
# remove the frame named "base", leaving the frame named "current"
frameSet.removeFrame(1)
self.assertEqual(frameSet.nFrame, 1)
# removing one frame leaves frame, newFrame and a copy of newFrame in FrameSet
self.assertEqual(frame.getNObject(), initialNumFrames + 2)
self.assertEqual(zoomMap.getNObject(), initialNumZoomMap)
frameDeep = frameSet.getFrame(1)
self.assertEqual(frameDeep.ident, "current")
# it is not allowed to remove the last frame
with self.assertRaises(RuntimeError):
frameSet.removeFrame(1)
def test_copy_and_same(self):
"""Test Object.copy and Object.same"""
obj = astshim.ZoomMap(2, 1.3, "Ident=original")
# there may be more than one object in existence if run with pytest
initialNumObj = obj.getNObject()
self.checkCopy(obj)
cp = obj.copy()
# a deep copy does not increment
self.assertEqual(obj.getRefCount(), 1)
seriesMap = obj.then(obj)
# obj itself plus two copies in the SeriesMap
self.assertEqual(obj.getRefCount(), 3)
del seriesMap
self.assertEqual(obj.getRefCount(), 1)
cp.ident = "copy"
self.assertEqual(cp.ident, "copy")
self.assertEqual(obj.ident, "original")
del cp
self.assertEqual(obj.getNObject(), initialNumObj)
self.assertEqual(obj.getRefCount(), 1)
def makeHscDistortion(config):
"""Make an HSC distortion transform
Note that inverse coefficients provided, but they are not accurate enough
to use: test_distortion.py reports an error of 2.8 pixels
(HSC uses pixels for its focal plane units) when transforming
from pupil to focal plane. That explains why the original HSC model uses
the inverse coefficients in conjunction with iteration.
Parameters
----------
config: `lsst.obs.subaru.HscDistortionConfig`
Distortion coefficients
Returns
-------
focalPlaneToPupil: `lsst.afw.geom.TransformPoint2ToPoint2`
Transform from focal plane to field angle coordinates
"""
forwardCoeffs = makeAstPolyMapCoeffs(config.ccdToSkyOrder, config.xCcdToSky, config.yCcdToSky)
# Note that the actual error can be somewhat larger than TolInverse;
# the max error I have seen is less than 2, so I scale conservatively
ccdToSky = ast.PolyMap(forwardCoeffs, 2, "IterInverse=1, TolInverse=%s, NIterInverse=%s" %
(config.tolerance / 2.0, config.maxIter))
plateScaleAngle = config.plateScale * arcseconds
fullMapping = ccdToSky.then(ast.ZoomMap(2, plateScaleAngle.asRadians()))
return TransformPoint2ToPoint2(fullMapping)
def test_equality(self):
"""Test __eq__ and __ne__
"""
frame = ast.Frame(2)
zoomMap = ast.ZoomMap(2, 1.5)
frameSet1 = ast.FrameSet(frame, zoomMap, frame)
frameSet2 = ast.FrameSet(frame, zoomMap, frame)
self.assertTrue(frameSet1 == frameSet2)
self.assertFalse(frameSet1 != frameSet2)
self.assertEqual(frameSet1, frameSet2)
# the base attribute of frameSet1 is not set; set the base attribute
# of framesSet2 and make sure the frame sets are now not equal
self.assertFalse(frameSet1.test("Base"))
frameSet2.base = 1
self.assertTrue(frameSet2.test("Base"))
self.assertFalse(frameSet1 == frameSet2)
self.assertTrue(frameSet1 != frameSet2)
self.assertNotEqual(frameSet1, frameSet2)
# make sure base is unset in the inverse of the inverse of frameSet1,
# else the equality test will fail for hard-to-understand reasons
self.assertFalse(frameSet1.inverted().inverted().test("Base"))
self.assertNotEqual(frameSet1, frameSet1.inverted())
self.assertEqual(frameSet1, frameSet1.inverted().inverted())
self.assertFalse(frameSet1.inverted().inverted().test("Base"))
frame3 = ast.Frame(2)
frame3.title = "Frame 3"
frameSet3 = ast.FrameSet(frame3)
self.assertNotEqual(frameSet1, frameSet3)
def setUp(self):
self.frame1 = ast.Frame(2, "Domain=frame1, Ident=f1")
self.frame2 = ast.Frame(2, "Domain=frame2, Ident=f2")
self.zoom = 1.5
self.zoomMap = ast.ZoomMap(2, self.zoom, "Ident=zoomMap")
self.initialNumFrames = self.frame1.getNObject() # may be >2 when run using pytest
self.initialNumZoomMap = self.zoomMap.getNObject() # may be > 1 when run using pytest
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_copy_and_same(self):
"""Test Object.copy and Object.same"""
obj = ast.ZoomMap(2, 1.3, "Ident=original")
initialNumObj = obj.getNObject() # may be >1 when run using pytest
self.checkCopy(obj)
cp = obj.copy()
# A deep copy does not increment refCount but does incremente nObject
self.assertEqual(obj.getRefCount(), 1)
self.assertEqual(obj.getNObject(), initialNumObj + 1)
# A deep copy is not the `same` as the original:
# `same` compares AST pointers, similar to Python `is`
self.assertFalse(obj.same(cp))
self.assertTrue(obj.same(obj))
cp.ident = "copy"
self.assertEqual(cp.ident, "copy")
self.assertEqual(obj.ident, "original")
del cp
self.assertEqual(obj.getNObject(), initialNumObj)
self.assertEqual(obj.getRefCount(), 1)
seriesMap = obj.then(obj)
# The seriesMap contains two shallow copies of `obj`, so refCount
# is increased by 2 and nObject remains unchanged
self.assertEqual(obj.getRefCount(), 3)
self.assertEqual(obj.getNObject(), initialNumObj)
del seriesMap
self.assertEqual(obj.getRefCount(), 1)
self.assertEqual(obj.getNObject(), initialNumObj)
def test_ChannelFileStream(self):
path1 = os.path.join(self.dataDir, "channelFileStream1.txt")
path2 = os.path.join(self.dataDir, "channelFileStream2.txt")
outstream = ast.FileStream(path1, True)
outchan = ast.Channel(outstream)
self.assertIsInstance(outchan, ast.Object)
self.assertIsInstance(outchan, ast.Channel)
zoommap = ast.ZoomMap(2, 0.1, "ID=Hello there")
nobj = outchan.write(zoommap)
self.assertEqual(nobj, 1)
with self.assertRaises(RuntimeError):
obj = outchan.read()
instream = ast.FileStream(path1, False)
inchan = ast.Channel(instream)
obj = inchan.read()
self.assertEqual(obj.show(), zoommap.show())
outstream2 = ast.FileStream(path2, True)
outchan2 = ast.Channel(outstream2)
outchan2.write(obj)
self.assertTrue(filecmp.cmp(path1, path2, shallow=False))
os.remove(path1)
os.remove(path2)
def test_basics(self):
"""Test basics of ZoomMap including applyForward
"""
for nin in (1, 2, 3):
for zoom in (1.0, -1.1, 359.3):
zoommap = astshim.ZoomMap(nin, zoom)
self.assertEqual(zoommap.className, "ZoomMap")
self.assertEqual(zoommap.nIn, nin)
self.assertEqual(zoommap.nOut, nin)
self.assertTrue(zoommap.isLinear)
self.checkBasicSimplify(zoommap)
self.checkCopy(zoommap)
self.checkPersistence(zoommap)
indata = 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)[0:nin]
self.checkRoundTrip(zoommap, indata)
topos = zoommap.applyForward(indata)
assert_allclose(indata * zoom, topos)
def test_TranMapNotSymmetric(self):
zoomfac = 0.5
unitMap = ast.UnitMap(2)
zoomMap = ast.ZoomMap(2, zoomfac)
tranmap = ast.TranMap(unitMap, zoomMap)
# adding to a TranMap increases by 1
self.assertEqual(unitMap.getRefCount(), 2)
# adding to a TranMap increases by 1
self.assertEqual(zoomMap.getRefCount(), 2)
self.assertIsInstance(tranmap, ast.TranMap)
self.assertIsInstance(tranmap, ast.Mapping)
self.assertEqual(tranmap.nIn, 2)
self.assertEqual(tranmap.nOut, 2)
self.checkCopy(tranmap)
indata = np.array([
[1.0, 2.0, -6.0, 30.0, 1.0],
[3.0, 99.0, -5.0, 21.0, 0.0],
],
dtype=float)
outdata = tranmap.applyForward(indata)
assert_allclose(outdata, indata)
outdata_roundtrip = tranmap.applyInverse(outdata)
assert_allclose(indata, outdata_roundtrip * zoomfac)
with self.assertRaises(AssertionError):
self.checkRoundTrip(tranmap, indata)
self.checkMappingPersistence(tranmap, indata)
def test_id(self):
"""Test that ID is *not* transferred to copies"""
obj = ast.ZoomMap(2, 1.3)
self.assertEqual(obj.id, "")
obj.id = "initial_id"
self.assertEqual(obj.id, "initial_id")
cp = obj.copy()
self.assertEqual(cp.id, "")
def test_ident(self):
"""Test that Ident *is* transferred to copies"""
obj = ast.ZoomMap(2, 1.3)
self.assertEqual(obj.ident, "")
obj.ident = "initial_ident"
self.assertEqual(obj.ident, "initial_ident")
cp = obj.copy()
self.assertEqual(cp.ident, "initial_ident")
def test_XmlChanDefaultAttributes(self):
sstream = ast.StringStream()
chan = ast.XmlChan(sstream)
self.assertEqual(chan.xmlFormat, "NATIVE")
self.assertEqual(chan.xmlLength, 0)
self.assertEqual(chan.xmlPrefix, "")
zoommap = ast.ZoomMap(3, 2.0)
self.checkXmlPersistence(sstream=sstream, chan=chan, obj=zoommap)
def test_XmlChanSpecifiedAttributes(self):
sstream = ast.StringStream()
chan = ast.XmlChan(
sstream, 'XmlFormat="QUOTED", XmlLength=2000, XmlPrefix="foo"')
self.assertEqual(chan.xmlFormat, "QUOTED")
self.assertEqual(chan.xmlLength, 2000)
self.assertEqual(chan.xmlPrefix, "foo")
zoommap = ast.ZoomMap(4, 1.5)
self.checkXmlPersistence(sstream=sstream, chan=chan, obj=zoommap)
def testMappingIndependence(self):
"""Test that the mapping returned by getMapping is independent of the contained mapping
"""
initialMapping = ast.ZoomMap(2, 1.5)
initialIdent = "Initial Ident"
initialMapping.ident = initialIdent
transform = afwGeom.TransformGenericToGeneric(initialMapping)
extractedMapping = transform.getMapping()
extractedMapping.ident = "Extracted Ident"
self.assertEqual(initialIdent, transform.getMapping().ident)
def test_clear_and_test(self):
"""Test Object.clear and Object.test"""
obj = ast.ZoomMap(2, 1.3)
self.assertFalse(obj.test("ID"))
obj.id = "initial_id"
self.assertEqual(obj.id, "initial_id")
self.assertTrue(obj.test("ID"))
obj.clear("ID")
self.assertEqual(obj.id, "")
self.assertFalse(obj.test("ID"))
def test_TranMapSymmetric(self):
zoomfac = 0.53
tranmap = ast.TranMap(ast.ZoomMap(2, zoomfac), ast.ZoomMap(2, zoomfac))
self.assertIsInstance(tranmap, ast.TranMap)
self.assertIsInstance(tranmap, ast.Mapping)
self.assertEqual(tranmap.nIn, 2)
self.assertEqual(tranmap.nOut, 2)
self.checkCopy(tranmap)
indata = np.array([
[1.0, 2.0, -6.0, 30.0, 1.0],
[3.0, 99.0, -5.0, 21.0, 0.0],
],
dtype=float)
outdata = tranmap.applyForward(indata)
assert_allclose(outdata, indata * zoomfac)
self.checkRoundTrip(tranmap, indata)
self.checkMappingPersistence(tranmap, indata)
def test_XmlChanSetAttributes(self):
sstream = ast.StringStream()
chan = ast.XmlChan(sstream)
chan.xmlFormat = "QUOTED"
chan.xmlLength = 1500
chan.xmlPrefix = "test"
self.assertEqual(chan.xmlFormat, "QUOTED")
self.assertEqual(chan.xmlLength, 1500)
self.assertEqual(chan.xmlPrefix, "test")
zoommap = ast.ZoomMap(1, 0.5)
self.checkXmlPersistence(sstream=sstream, chan=chan, obj=zoommap)
def test_RateMap2(self):
zoomfac = 23.323
ratemap = ast.RateMap(ast.ZoomMap(2, zoomfac), 2, 1)
indata = np.array([
[1.1, -43.5, -5.54],
[2.2, 1309.31, 35.2],
])
outdata = ratemap.applyForward(indata)
assert_allclose(outdata, 0)
self.checkMappingPersistence(ratemap, indata)
def test_MakeRadialMappingErrorHandling(self):
"""Test error handling in makeRadialMapping"""
for bad_nin in (1, 2, 3):
for bad_nout in (1, 2, 3):
if bad_nin == bad_nout == 1:
continue # the only valid case
bad_mapping1d = makeForwardPolyMap(bad_nin, bad_nout)
with self.assertRaises(ValueError):
ast.makeRadialMapping([0.0], bad_mapping1d)
mapping1d = ast.ZoomMap(1, 5.5)
with self.assertRaises(RuntimeError):
ast.makeRadialMapping([], mapping1d)
def test_KeyMapScalars(self):
keyMap = ast.KeyMap()
zoomMap = ast.ZoomMap(2, 5)
keyMap.putI("ikey", 5)
keyMap.putS("skey", -3)
keyMap.putB("bkey", 2)
keyMap.putD("dkey", 3.14)
keyMap.putF("fkey", 2.78)
keyMap.putC("ckey", "strvalue")
keyMap.putA("akey", zoomMap)
self.assertEqual(len(keyMap), 7)
self.assertEqual(keyMap.length("ikey"), 1)
self.assertEqual(keyMap.length("skey"), 1)
self.assertEqual(keyMap.length("bkey"), 1)
self.assertEqual(keyMap.length("dkey"), 1)
self.assertEqual(keyMap.length("fkey"), 1)
self.assertEqual(keyMap.length("ckey"), 1)
self.assertEqual(keyMap.length("akey"), 1)
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])
self.assertEqual(keyMap.getI("ikey", 0), 5)
self.assertEqual(keyMap.getS("skey"), [-3])
self.assertEqual(keyMap.getS("skey", 0), -3)
self.assertEqual(keyMap.getB("bkey"), [2])
self.assertEqual(keyMap.getB("bkey", 0), 2)
assert_allclose(keyMap.getD("dkey"), [3.14])
self.assertAlmostEqual(keyMap.getD("dkey", 0), 3.14)
assert_allclose(keyMap.getF("fkey"), [2.78])
self.assertAlmostEqual(keyMap.getF("fkey", 0), 2.78)
self.assertEqual(keyMap.getC("ckey"), ["strvalue"])
self.assertEqual(keyMap.getC("ckey", 0), "strvalue")
self.assertEqual([obj.show() for obj in keyMap.getA("akey")],
[zoomMap.show()])
self.assertEqual(keyMap.getA("akey", 0).show(), zoomMap.show())
self.assertEqual(keyMap.getC("CkEy"),
[]) # invalid key (case is wrong)
with self.assertRaises(Exception):
keyMap.getC("CKey", 0) # invalid key (case is wrong)
with self.assertRaises(Exception):
keyMap.getC("ckey", 1) # invalid index
def test_ChannelStringStream(self):
ss = ast.StringStream()
channel = ast.Channel(ss)
zoommap = ast.ZoomMap(2, 0.1, "ID=Hello there")
n = channel.write(zoommap)
self.assertEqual(n, 1)
sinkData1 = ss.getSinkData()
ss.sinkToSource()
obj = channel.read()
self.assertEqual(obj.show(), zoommap.show())
n = channel.write(obj)
self.assertEqual(n, 1)
sinkData2 = ss.getSinkData()
self.assertEqual(sinkData1, sinkData2)
def test_attributes(self):
"""Test accessing object attributes
"""
nin = 2
zoom = 1.3
obj = ast.ZoomMap(nin, zoom)
self.assertEqual(obj.className, "ZoomMap")
self.assertTrue(obj.hasAttribute("ID"))
self.assertTrue(obj.hasAttribute("Ident"))
self.assertTrue(obj.hasAttribute("UseDefs"))
self.assertEqual(obj.id, "")
self.assertEqual(obj.ident, "")
self.assertEqual(obj.useDefs, True)
def test_MapSplit(self):
"""Test MapSplit for a simple case"""
nin = 3
zoom = 1.3
zoommap = ast.ZoomMap(nin, zoom)
for i in range(nin):
split = ast.MapSplit(zoommap, [i + 1])
self.assertEqual(split.splitMap.className, "ZoomMap")
self.assertEqual(split.splitMap.nIn, 1)
self.assertEqual(split.splitMap.nOut, 1)
self.assertEqual(tuple(split.origOut), (i + 1, ))
split2 = ast.MapSplit(zoommap, [1, 3])
self.assertEqual(split2.splitMap.className, "ZoomMap")
self.assertEqual(split2.splitMap.nIn, 2)
self.assertEqual(split2.splitMap.nOut, 2)
self.assertEqual(tuple(split2.origOut), (1, 3))
def test_RateMapBasics(self):
zoomfac = 0.523
ratemap = ast.RateMap(ast.ZoomMap(2, zoomfac), 2, 2)
self.assertIsInstance(ratemap, ast.RateMap)
self.assertIsInstance(ratemap, ast.Mapping)
self.assertEqual(ratemap.nOut, 1)
self.checkBasicSimplify(ratemap)
self.checkCopy(ratemap)
indata = np.array([
[1.1, -43.5, -5.54],
[2.2, 1309.31, 35.2],
])
outdata = ratemap.applyForward(indata)
assert_allclose(outdata, zoomfac)
self.checkMappingPersistence(ratemap, indata)
def test_FrameDictRemoveFrame(self):
frameDict = ast.FrameDict(self.frame1, self.zoomMap, self.frame2)
zoomMap2 = ast.ZoomMap(2, 1.3, "Ident=zoomMap2")
frame3 = ast.Frame(2, "Domain=FRAME3, Ident=f3")
frameDict.addFrame(2, zoomMap2, frame3)
self.assertEqual(frameDict.getAllDomains(),
{"FRAME1", "FRAME2", "FRAME3"})
self.assertEqual(frameDict.getIndex("FRAME1"), 1)
self.assertEqual(frameDict.getIndex("FRAME2"), 2)
self.assertEqual(frameDict.getIndex("FRAME3"), 3)
self.assertEqual(self.frame1.getNObject(), self.initialNumFrames + 4)
self.assertEqual(self.zoomMap.getNObject(), self.initialNumZoomMap + 3)
# remove the frame named "FRAME1" by name
# this will also remove one of the two zoom maps
frameDict.removeFrame("FRAME1")
self.checkDict(frameDict)
self.assertEqual(frameDict.getAllDomains(), {"FRAME2", "FRAME3"})
self.assertEqual(frameDict.nFrame, 2)
self.assertEqual(frameDict.getIndex("FRAME2"), 1)
self.assertEqual(frameDict.getIndex("FRAME3"), 2)
self.assertEqual(frameDict.getFrame("FRAME2").domain, "FRAME2")
self.assertEqual(frameDict.getFrame("FRAME3").domain, "FRAME3")
self.assertEqual(self.frame1.getNObject(), self.initialNumFrames + 3)
self.assertEqual(self.zoomMap.getNObject(), self.initialNumZoomMap + 2)
# remove the frame "FRAME3" by index
# this will also remove the remaining zoom map
frameDict.removeFrame(2)
self.checkDict(frameDict)
self.assertEqual(frameDict.getAllDomains(), {"FRAME2"})
self.assertEqual(frameDict.nFrame, 1)
self.assertEqual(frameDict.getIndex("FRAME2"), 1)
self.assertEqual(frameDict.getFrame("FRAME2").domain, "FRAME2")
self.assertEqual(self.frame1.getNObject(), self.initialNumFrames + 2)
self.assertEqual(self.zoomMap.getNObject(), self.initialNumZoomMap + 1)
frameDeep = frameDict.getFrame(1)
self.assertEqual(frameDeep.domain, "FRAME2")
# it is not allowed to remove the last frame
with self.assertRaises(RuntimeError):
frameDict.removeFrame(1)
self.checkDict(frameDict)
def test_show(self):
obj = astshim.ZoomMap(2, 1.3)
desShowLines = [
" Begin ZoomMap \t# Zoom about the origin",
" Nin = 2 \t# Number of input coordinates",
" IsA Mapping \t# Mapping between coordinate systems",
" Zoom = 1.3 \t# Zoom factor",
" End ZoomMap",
"",
]
desShowLinesNoComments = [
" Begin ZoomMap",
" Nin = 2",
" IsA Mapping",
" Zoom = 1.3",
" End ZoomMap",
"",
]
self.assertEqual(obj.show(), "\n".join(desShowLines))
self.assertEqual(obj.show(True), "\n".join(desShowLines))
self.assertEqual(obj.show(False), "\n".join(desShowLinesNoComments))
def test_MakeRadialMappingInvertible(self):
"""Test makeRadialMapping on a mapping that has an accurate inverse"""
zoom = 5.5
mapping1d = ast.ZoomMap(1, zoom)
self.assertTrue(mapping1d.hasForward)
self.assertTrue(mapping1d.hasInverse)
for center in (
[0.0],
[1.1],
[0.0, 0.0],
[-5.5, 4.7],
[0.0, 0.0, 0.0],
[1.1, 2.2, -3.3],
):
naxes = len(center)
center_reshaped = np.expand_dims(center, 1)
in_data = self.in_data_full[0:naxes]
radial_map = ast.makeRadialMapping(center, mapping1d)
self.assertTrue(radial_map.hasForward)
self.assertTrue(radial_map.hasInverse)
self.checkRoundTrip(radial_map, in_data)
# compute desired output
in_from_center = in_data - center_reshaped
in_norm = np.linalg.norm(in_from_center, axis=0)
with np.errstate(invalid='ignore'):
unit_vector = np.where(in_norm != 0, in_from_center / in_norm,
in_from_center)
out_norm = in_norm * zoom
out_from_center = unit_vector * out_norm
desired_out_data = out_from_center + center_reshaped
out_data = radial_map.applyForward(in_data)
npt.assert_allclose(out_data, desired_out_data)
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 setUp(self):
self.nin = 2
self.zoom = 1.3
self.zoommap = ast.ZoomMap(self.nin, self.zoom)
