Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1import unittest 

2 

3import numpy as np 

4from numpy.testing import assert_allclose 

5 

6import astshim as ast 

7from astshim.test import MappingTestCase, makeTwoWayPolyMap 

8 

9 

10class TestMapping(MappingTestCase): 

11 """Test basics of Mapping 

12 

13 Note that Mapping.then and Mapping.under are tested by test_cmpMap.py 

14 """ 

15 

16 def setUp(self): 

17 self.nin = 2 

18 self.zoom = 1.3 

19 self.zoommap = ast.ZoomMap(self.nin, self.zoom) 

20 

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) 

31 

32 def test_MappingInvert(self): 

33 invmap = self.zoommap.inverted() 

34 

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) 

41 

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) 

48 

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) 

61 

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) 

68 

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]) 

74 

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) 

79 

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]) 

84 

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) 

94 

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]) 

106 

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) 

116 

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")) 

129 

130 def test_MappingSimplify(self): 

131 simpmap = self.zoommap.simplified() 

132 

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) 

140 

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) 

149 

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) 

159 

160 

161if __name__ == "__main__": 161 ↛ 162line 161 didn't jump to line 162, because the condition on line 161 was never true

162 unittest.main()