Coverage for tests/test_mapping.py: 15%
107 statements
« prev ^ index » next coverage.py v7.2.3, created at 2023-04-19 10:51 +0000
« prev ^ index » next coverage.py v7.2.3, created at 2023-04-19 10:51 +0000
1import unittest
3import numpy as np
4from numpy.testing import assert_allclose
6import astshim as ast
7from astshim.test import MappingTestCase, makeTwoWayPolyMap
10class TestMapping(MappingTestCase):
11 """Test basics of Mapping
13 Note that Mapping.then and Mapping.under are tested by test_cmpMap.py
14 """
16 def setUp(self):
17 self.nin = 2
18 self.zoom = 1.3
19 self.zoommap = ast.ZoomMap(self.nin, self.zoom)
21 def test_MappingAttributes(self):
22 self.assertEqual(self.zoommap.className, "ZoomMap")
23 self.assertFalse(self.zoommap.isInverted)
24 self.assertTrue(self.zoommap.isLinear)
25 self.assertFalse(self.zoommap.isSimple)
26 self.assertEqual(self.zoommap.nIn, self.nin)
27 self.assertEqual(self.zoommap.nOut, self.nin)
28 self.assertFalse(self.zoommap.report)
29 self.assertTrue(self.zoommap.hasForward)
30 self.assertTrue(self.zoommap.hasInverse)
32 def test_MappingInvert(self):
33 invmap = self.zoommap.inverted()
35 self.assertEqual(invmap.className, "ZoomMap")
36 self.assertTrue(invmap.isInverted)
37 self.assertTrue(invmap.isLinear)
38 self.assertFalse(invmap.isSimple)
39 self.assertTrue(invmap.hasForward)
40 self.assertTrue(invmap.hasInverse)
42 indata = np.array([
43 [1.0, 2.0, -6.0, 30.0, 0.0],
44 [3.0, 99.0, -5.0, 21.0, 0.0],
45 ], dtype=float)
46 self.checkRoundTrip(self.zoommap, indata)
47 self.checkRoundTrip(invmap, indata)
49 def test_MapBox(self):
50 """Test MapBox for the simple case of a shift and zoom"""
51 shift = np.array([1.5, 0.5])
52 zoom = np.array([2.0, 3.0])
53 winmap = ast.WinMap(
54 [0, 0], [1, 1], zoom * [0, 0] + shift, zoom * [1, 1] + shift)
55 # Arbitrary values chosen so that inbnd_a is NOT < inbnd_b for both
56 # axes, because MapBox uses the minimum of inbnd_b, inbnd_a for each
57 # axis for the lower bound, and the maximum for the upper bound.
58 inbnd_a = np.array([-1.2, 3.3])
59 inbnd_b = np.array([2.7, 2.2])
60 mapbox = ast.MapBox(winmap, inbnd_a, inbnd_b)
62 lbndin = np.minimum(inbnd_a, inbnd_b)
63 ubndin = np.maximum(inbnd_a, inbnd_b)
64 predlbndOut = lbndin * zoom + shift
65 predubndOut = ubndin * zoom + shift
66 assert_allclose(mapbox.lbndOut, predlbndOut)
67 assert_allclose(mapbox.ubndOut, predubndOut)
69 # note that mapbox.xl and xu is only partially predictable
70 # because any X from the input gives the same Y
71 for i in range(2):
72 self.assertAlmostEqual(mapbox.xl[i, i], lbndin[i])
73 self.assertAlmostEqual(mapbox.xu[i, i], ubndin[i])
75 # confirm that order of inbnd_a, inbnd_b doesn't matter
76 mapbox2 = ast.MapBox(winmap, inbnd_b, inbnd_a)
77 assert_allclose(mapbox2.lbndOut, mapbox.lbndOut)
78 assert_allclose(mapbox2.ubndOut, mapbox.ubndOut)
80 # the xl and xu need only agree on the diagonal, as above
81 for i in range(2):
82 self.assertAlmostEqual(mapbox.xl[i, i], mapbox2.xl[i, i])
83 self.assertAlmostEqual(mapbox.xu[i, i], mapbox2.xu[i, i])
85 def test_MappingLinearApprox(self):
86 """Exercise Mapping.linearApprox for a trivial case"""
87 coeffs = self.zoommap.linearApprox([0, 0], [50, 50], 1e-5)
88 descoeffs = np.array([
89 [0.0, 0.0],
90 [1.3, 0.0],
91 [0.0, 1.3]
92 ], dtype=float)
93 assert_allclose(coeffs, descoeffs, atol=10E-14)
95 def test_QuadApprox(self):
96 # simple parabola
97 coeff_f = np.array([
98 [0.5, 1, 2, 0],
99 [0.5, 1, 0, 2],
100 ], dtype=float)
101 polymap = ast.PolyMap(coeff_f, 1)
102 qa = ast.QuadApprox(polymap, [-1, -1], [1, 1], 3, 3)
103 self.assertAlmostEqual(qa.rms, 0)
104 self.assertEqual(len(qa.fit), 6)
105 assert_allclose(qa.fit, [0, 0, 0, 0, 0.5, 0.5])
107 def test_MappingRate(self):
108 """Exercise Mapping.rate for a trivial case"""
109 for x in (0, 5, 55): # arbitrary, but include 0
110 for y in (0, -9.5, 47.6): # arbitrary, but include 0
111 for xaxis in (1, 2):
112 for yaxis in (1, 2):
113 desrate = self.zoom if xaxis == yaxis else 0
114 self.assertAlmostEqual(self.zoommap.rate(
115 [x, y], xaxis, yaxis), desrate)
117 def test_MappingSetReport(self):
118 self.assertFalse(self.zoommap.report)
119 self.assertFalse(self.zoommap.test("Report"))
120 self.zoommap.report = False
121 self.assertFalse(self.zoommap.report)
122 self.assertTrue(self.zoommap.test("Report"))
123 self.zoommap.report = True
124 self.assertTrue(self.zoommap.report)
125 self.assertTrue(self.zoommap.test("Report"))
126 self.zoommap.clear("Report")
127 self.assertFalse(self.zoommap.report)
128 self.assertFalse(self.zoommap.test("Report"))
130 def test_MappingSimplify(self):
131 simpmap = self.zoommap.simplified()
133 self.assertEqual(simpmap.className, "ZoomMap")
134 self.assertFalse(simpmap.isInverted)
135 self.assertTrue(simpmap.isSimple)
136 self.assertEqual(simpmap.nIn, self.nin)
137 self.assertEqual(simpmap.nOut, self.nin)
138 self.assertTrue(simpmap.hasForward)
139 self.assertTrue(simpmap.hasInverse)
141 def test_MapSplit(self):
142 """Test MapSplit for a simple case"""
143 for i in range(self.nin):
144 split = ast.MapSplit(self.zoommap, [i + 1])
145 self.assertEqual(split.splitMap.className, "ZoomMap")
146 self.assertEqual(split.splitMap.nIn, 1)
147 self.assertEqual(split.splitMap.nOut, 1)
148 self.assertEqual(split.origOut[0], i + 1)
150 def test_ZeroPoints(self):
151 """Test that Mapping.applyForward and applyInverse can handle
152 zero points
153 """
154 mapping = makeTwoWayPolyMap(2, 3)
155 out_points1 = mapping.applyForward([])
156 self.assertEqual(len(out_points1), 0)
157 out_points2 = mapping.applyInverse([])
158 self.assertEqual(len(out_points2), 0)
161if __name__ == "__main__": 161 ↛ 162line 161 didn't jump to line 162, because the condition on line 161 was never true
162 unittest.main()