def test_SkyFrameLonLat(self):
frame = astshim.SkyFrame()
self.assertEqual(frame.lonAxis, 1)
self.assertEqual(frame.latAxis, 2)
self.assertTrue(frame.getIsLonAxis(1))
self.assertTrue(frame.getIsLatAxis(2))
self.assertFalse(frame.getIsLonAxis(2))
self.assertFalse(frame.getIsLatAxis(1))
# permute axes
frame.permAxes([2, 1])
self.assertEqual(frame.lonAxis, 2)
self.assertEqual(frame.latAxis, 1)
self.assertTrue(frame.getIsLonAxis(2))
self.assertTrue(frame.getIsLatAxis(1))
self.assertFalse(frame.getIsLonAxis(1))
self.assertFalse(frame.getIsLatAxis(2))
# permute again to restore original state
frame.permAxes([2, 1])
self.assertEqual(frame.lonAxis, 1)
self.assertEqual(frame.latAxis, 2)
self.assertTrue(frame.getIsLonAxis(1))
self.assertTrue(frame.getIsLatAxis(2))
self.assertFalse(frame.getIsLonAxis(2))
self.assertFalse(frame.getIsLatAxis(1))
def test_SkyFrameSkyRef(self):
frame = astshim.SkyFrame()
assert_allclose(frame.getSkyRef(), [0, 0])
newSkyRef = [-4.5, 1.23]
frame.setSkyRef(newSkyRef)
assert_allclose(frame.getSkyRef(), newSkyRef)
def test_SkyFrameSkyRefIs(self):
frame = astshim.SkyFrame()
self.assertEqual(frame.skyRefIs, "Ignored")
for newSkyRefIs in ("Origin", "Pole", "Ignored"):
frame.skyRefIs = newSkyRefIs
self.assertEqual(frame.skyRefIs, newSkyRefIs)
def test_SkyFrameAsTime(self):
frame = astshim.SkyFrame()
for axis, defAsTime in ((1, True), (2, False)):
self.assertEqual(frame.getAsTime(axis), defAsTime)
frame.setAsTime(axis, not defAsTime)
self.assertEqual(frame.getAsTime(axis), not defAsTime)
def test_SkyFrameProjection(self):
frame = astshim.SkyFrame()
self.assertEqual(frame.projection, "")
newProjection = "Arbitrary description"
frame.projection = newProjection
self.assertEqual(frame.projection, newProjection)
def test_SkyFrameEquinox(self):
frame = astshim.SkyFrame()
self.assertAlmostEqual(frame.equinox, 2000)
newEquinox = 2345.6
frame.equinox = newEquinox
self.assertAlmostEqual(frame.equinox, newEquinox)
def makeBadFrames(name):
"""Return a list of 0 or more frames that are not a valid match for the
named endpoint
Parameters
----------
name : `str`
Endpoint class name prefix; the full class name is name + "Endpoint"
Returns
-------
Collection of `ast.Frame`
A collection of 0 or more frames
"""
return {
"Generic": [],
"Point2": [
ast.SkyFrame(),
ast.Frame(1),
ast.Frame(3),
],
"SpherePoint": [
ast.Frame(1),
ast.Frame(2),
ast.Frame(3),
],
}[name]
def test_FrameDictPermutationSkyFrame(self):
"""Test permuting FrameDict axes using a SkyFrame
Permuting the axes of the current frame of a frame set
*in situ* (by calling `permAxes` on the frame set itself)
should update the connected mappings.
"""
# test with arbitrary values that will not be wrapped by SkyFrame
x = 0.257
y = 0.832
frame1 = ast.Frame(2)
unitMap = ast.UnitMap(2)
frame2 = ast.SkyFrame()
frameDict = ast.FrameDict(frame1, unitMap, frame2)
self.assertAlmostEqual(frameDict.applyForward([x, y]), [x, y])
self.assertAlmostEqual(frameDict.applyInverse([x, y]), [x, y])
# permuting the axes of the current frame also permutes the mapping
frameDict.permAxes([2, 1])
self.assertAlmostEqual(frameDict.applyForward([x, y]), [y, x])
self.assertAlmostEqual(frameDict.applyInverse([x, y]), [y, x])
# permuting again puts things back
frameDict.permAxes([2, 1])
self.assertAlmostEqual(frameDict.applyForward([x, y]), [x, y])
self.assertAlmostEqual(frameDict.applyInverse([x, y]), [x, y])
def testSpherePointEndpoint(self):
self.assertEqual("SpherePoint", afwGeom.SpherePointEndpoint.getClassPrefix())
endpoint = afwGeom.SpherePointEndpoint()
self.checkEndpointBasics(
endpoint=endpoint, pointType=lsst.geom.SpherePoint, nAxes=2)
self.assertEqual(repr(endpoint), "lsst.afw.geom.SpherePointEndpoint()")
self.assertEqual("{}".format(endpoint), "SpherePointEndpoint()")
for doPermute in (False, True):
frame = astshim.SkyFrame()
if doPermute:
frame.permAxes([2, 1])
self.assertEqual(frame.lonAxis, 2)
self.assertEqual(frame.latAxis, 1)
else:
self.assertEqual(frame.lonAxis, 1)
self.assertEqual(frame.latAxis, 2)
endpoint.normalizeFrame(frame)
# the normalized frame always has axis in order Lon, Lat
self.assertEqual(frame.lonAxis, 1)
self.assertEqual(frame.latAxis, 2)
badFrame = astshim.Frame(2)
with self.assertRaises(InvalidParameterError):
endpoint.normalizeFrame(badFrame)
newFrame = endpoint.makeFrame()
self.assertEqual(type(newFrame), astshim.SkyFrame)
self.assertEqual(newFrame.lonAxis, 1)
self.assertEqual(newFrame.latAxis, 2)
def test_SkyFrameSkyTol(self):
frame = astshim.SkyFrame()
# the default is arbitrary so do not to assume a specific value
defSkyTol = frame.skyTol
newSkyTol = defSkyTol * 1.2345
frame.skyTol = newSkyTol
self.assertAlmostEqual(frame.skyTol, newSkyTol)
def test_SkyFrameSkyRefP(self):
frame = astshim.SkyFrame()
defSkyRefP = [0.0, math.pi / 2]
assert_allclose(frame.getSkyRefP(), defSkyRefP)
newSkyRefP = [0.1234, 0.5643]
frame.setSkyRefP(newSkyRefP)
assert_allclose(frame.getSkyRefP(), newSkyRefP)
def test_SpecFrameSetGetRefPos(self):
frame = ast.SpecFrame()
self.assertEqual(frame.className, "SpecFrame")
sky = ast.SkyFrame()
frame.setRefPos(sky, 0, 1)
refpos = frame.getRefPos(sky)
self.assertAlmostEqual(refpos[0], 0, places=5)
self.assertAlmostEqual(refpos[1], 1)
self.assertEqual(frame.getInternalUnit(1), frame.getUnit(1))
self.assertEqual(frame.getInternalUnit(1), "Angstrom")
def test_NormMapSkyFrame(self):
"""Check NormMap(SkYFrame):
longitude wrapped to [0, 2 pi]
if pi < |latitude| < 2 pi:
offset longitude by pi and set latitutude = 2 pi - latitude
else:
wrap pi to range [-pi, pi]
This test intentionally stays a small delta away from boundaries (except 0)
because the expected behavior is not certain and not important
"""
normmap = astshim.NormMap(astshim.SkyFrame())
self.assertEqual(normmap.className, "NormMap")
self.assertEqual(normmap.nIn, 2)
self.assertEqual(normmap.nOut, 2)
self.checkBasicSimplify(normmap)
self.checkPersistence(normmap)
# I'm not sure why 100 is needed; I expected ~10 (2 pi)
eps = 100 * sys.float_info.epsilon
indata = (
np.array(
[
[0, 0],
[-eps, 0], # lon out of range
[2 * pi - eps, 0],
[2 * pi + eps, 0], # lon out of range
[0, -pi / 2 + eps],
[0, -pi / 2 - eps], # lat too small; offset lat by pi
[0, pi / 2 - eps],
[0, pi / 2 + eps], # lat too big; offset lat by pi
],
dtype=float)).T.copy() # applyForward can't accept a view
pred_outdata = np.array([
[0, 0],
[2 * pi - eps, 0],
[2 * pi - eps, 0],
[eps, 0],
[0, -pi / 2 + eps],
[pi, -pi / 2 + eps],
[0, pi / 2 - eps],
[pi, pi / 2 - eps],
]).T
outdata = normmap.applyForward(indata)
assert_allclose(outdata, pred_outdata)
def testPoint2Endpoint(self):
self.assertEqual("Point2", afwGeom.Point2Endpoint.getClassPrefix())
endpoint = afwGeom.Point2Endpoint()
self.checkEndpointBasics(
endpoint=endpoint, pointType=lsst.geom.Point2D, nAxes=2)
self.assertEqual(repr(endpoint), "lsst.afw.geom.Point2Endpoint()")
self.assertEqual("{}".format(endpoint), "Point2Endpoint()")
# normalize does not check the # of axes
for n in range(4):
frame1 = astshim.Frame(n)
try:
endpoint.normalizeFrame(frame1)
except Exception as e:
self.fail(
"endpoint.normalizeFrame(Frame({})) failed with error = {}".format(n, e))
badFrame = astshim.SkyFrame()
with self.assertRaises(InvalidParameterError):
endpoint.normalizeFrame(badFrame)
def test_FrameBasics(self):
frame = astshim.SkyFrame()
self.assertEqual(frame.className, "SkyFrame")
self.assertEqual(frame.nIn, 2)
self.assertEqual(frame.nAxes, 2)
self.assertEqual(frame.maxAxes, 2)
self.assertEqual(frame.minAxes, 2)
# default values for Frame properties (methods below test
# setters and getters of SkyFrame properties)
self.assertEqual(frame.alignSystem, "ICRS")
self.assertEqual(frame.dut1, 0.0)
self.assertEqual(frame.epoch, 2000.0)
self.assertEqual(frame.obsAlt, 0.0)
self.assertEqual(frame.obsLat, "N0:00:00.00")
self.assertEqual(frame.obsLon, "E0:00:00.00")
self.assertTrue(frame.permute)
self.assertFalse(frame.preserveAxes)
self.assertEqual(frame.system, "ICRS")
self.assertEqual(frame.title, "ICRS coordinates")
self.assertTrue(math.isinf(frame.getBottom(1)))
self.assertTrue(math.isinf(frame.getTop(1)))
self.assertGreater(frame.getTop(1), frame.getBottom(1))
self.assertFalse(frame.getDirection(1))
self.assertEqual(frame.getInternalUnit(1), "rad")
self.assertEqual(frame.getNormUnit(1), "rad")
self.assertEqual(frame.getSymbol(1), "RA")
self.assertEqual(frame.getUnit(1), "hh:mm:ss.s")
self.assertAlmostEqual(frame.getBottom(2), -math.pi / 2)
self.assertAlmostEqual(frame.getTop(2), math.pi / 2)
self.assertTrue(frame.getDirection(2))
self.assertEqual(frame.getInternalUnit(2), "rad")
self.assertEqual(frame.getNormUnit(2), "rad")
self.assertEqual(frame.getSymbol(2), "Dec")
self.assertEqual(frame.getUnit(2), "ddd:mm:ss")
self.checkCopy(frame)
self.checkPersistence(frame)
def test_SkyFrameNegLon(self):
frame = astshim.SkyFrame()
self.assertFalse(frame.negLon)
frame.negLon = True
self.assertTrue(frame.negLon)
def test_SkyFrameAlignOffset(self):
frame = astshim.SkyFrame()
self.assertFalse(frame.alignOffset)
frame.alignOffset = True
self.assertTrue(frame.alignOffset)
def test_SkyFrameSkyOffsetMap(self):
frame = astshim.SkyFrame()
mapping = frame.skyOffsetMap()
self.assertEqual(mapping.className, "UnitMap")
