def makeFrameSet(self, nIn, nOut):
"""Create a FrameSet with the specified dimensions.
The FrameSet shall have the following Frames:
"base"(nIn, #1)
|
+--------------
| |
"mid"(4, #2) "fork"(1, #4)
|
"current"(nOut, #3)
"""
frameSet = FrameSet(Frame(nIn, "Ident=base"))
frameSet.addFrame(FrameSet.CURRENT, makeTwoWayPolyMap(nIn, 4),
Frame(4, "Ident=mid"))
frameSet.addFrame(FrameSet.CURRENT, makeTwoWayPolyMap(4, nOut),
Frame(nOut, "Ident=current"))
frameSet.addFrame(FrameSet.BASE, makeTwoWayPolyMap(nIn, 1),
Frame(1, "Ident=fork"))
frameSet.current = 3
assert frameSet.nFrame == 4
assert frameSet.base == 1
assert frameSet.getFrame(FrameSet.BASE).ident == "base"
assert frameSet.getFrame(2).ident == "mid"
assert frameSet.current == 3
assert frameSet.getFrame(FrameSet.CURRENT).ident == "current"
assert frameSet.getFrame(4).ident == "fork"
return frameSet
def makeFrameSet(self, nIn, nOut):
"""Create a FrameSet with the specified dimensions.
The FrameSet shall have the following Frames:
"base"(nIn, #1)
|
+--------------
| |
"mid"(4, #2) "fork"(1, #4)
|
"current"(nOut, #3)
"""
frameSet = FrameSet(Frame(nIn, "Ident=base"))
frameSet.addFrame(FrameSet.CURRENT,
makeTwoWayPolyMap(nIn, 4),
Frame(4, "Ident=mid"))
frameSet.addFrame(FrameSet.CURRENT,
makeTwoWayPolyMap(4, nOut),
Frame(nOut, "Ident=current"))
frameSet.addFrame(FrameSet.BASE,
makeTwoWayPolyMap(nIn, 1),
Frame(1, "Ident=fork"))
frameSet.current = 3
assert frameSet.nFrame == 4
assert frameSet.base == 1
assert frameSet.getFrame(FrameSet.BASE).ident == "base"
assert frameSet.getFrame(2).ident == "mid"
assert frameSet.current == 3
assert frameSet.getFrame(FrameSet.CURRENT).ident == "current"
assert frameSet.getFrame(4).ident == "fork"
return frameSet
def checkTransformFromMapping(self, fromName, toName):
"""Check Transform_<fromName>_<toName> using the Mapping constructor
Parameters
----------
fromName, toName : `str`
Endpoint name prefix for "from" and "to" endpoints, respectively,
e.g. "Point2" for `lsst.afw.geom.Point2Endpoint`
fromAxes, toAxes : `int`
number of axes in fromFrame and toFrame, respectively
"""
transformClassName = "Transform{}To{}".format(fromName, toName)
TransformClass = getattr(afwGeom, transformClassName)
baseMsg = "TransformClass={}".format(TransformClass.__name__)
# check valid numbers of inputs and outputs
for nIn, nOut in itertools.product(self.goodNAxes[fromName],
self.goodNAxes[toName]):
msg = "{}, nIn={}, nOut={}".format(baseMsg, nIn, nOut)
polyMap = makeTwoWayPolyMap(nIn, nOut)
transform = TransformClass(polyMap)
# desired output from `str(transform)`
desStr = "{}[{}->{}]".format(transformClassName, nIn, nOut)
self.assertEqual("{}".format(transform), desStr)
self.assertEqual(repr(transform), "lsst.afw.geom." + desStr)
self.checkTransformation(transform, polyMap, msg=msg)
# Forward transform but no inverse
polyMap = makeForwardPolyMap(nIn, nOut)
transform = TransformClass(polyMap)
self.checkTransformation(transform, polyMap, msg=msg)
# Inverse transform but no forward
polyMap = makeForwardPolyMap(nOut, nIn).inverted()
transform = TransformClass(polyMap)
self.checkTransformation(transform, polyMap, msg=msg)
# check invalid # of output against valid # of inputs
for nIn, badNOut in itertools.product(self.goodNAxes[fromName],
self.badNAxes[toName]):
badPolyMap = makeTwoWayPolyMap(nIn, badNOut)
msg = "{}, nIn={}, badNOut={}".format(baseMsg, nIn, badNOut)
with self.assertRaises(InvalidParameterError, msg=msg):
TransformClass(badPolyMap)
# check invalid # of inputs against valid and invalid # of outputs
for badNIn, nOut in itertools.product(
self.badNAxes[fromName],
self.goodNAxes[toName] + self.badNAxes[toName]):
badPolyMap = makeTwoWayPolyMap(badNIn, nOut)
msg = "{}, badNIn={}, nOut={}".format(baseMsg, nIn, nOut)
with self.assertRaises(InvalidParameterError, msg=msg):
TransformClass(badPolyMap)
def checkTransformFromMapping(self, fromName, toName):
"""Check Transform_<fromName>_<toName> using the Mapping constructor
Parameters
----------
fromName, toName : `str`
Endpoint name prefix for "from" and "to" endpoints, respectively,
e.g. "Point2" for `lsst.afw.geom.Point2Endpoint`
fromAxes, toAxes : `int`
number of axes in fromFrame and toFrame, respectively
"""
transformClassName = "Transform{}To{}".format(fromName, toName)
TransformClass = getattr(afwGeom, transformClassName)
baseMsg = "TransformClass={}".format(TransformClass.__name__)
# check valid numbers of inputs and outputs
for nIn, nOut in itertools.product(self.goodNAxes[fromName],
self.goodNAxes[toName]):
msg = "{}, nIn={}, nOut={}".format(baseMsg, nIn, nOut)
polyMap = makeTwoWayPolyMap(nIn, nOut)
transform = TransformClass(polyMap)
# desired output from `str(transform)`
desStr = "{}[{}->{}]".format(transformClassName, nIn, nOut)
self.assertEqual("{}".format(transform), desStr)
self.assertEqual(repr(transform), "lsst.afw.geom." + desStr)
self.checkTransformation(transform, polyMap, msg=msg)
# Forward transform but no inverse
polyMap = makeForwardPolyMap(nIn, nOut)
transform = TransformClass(polyMap)
self.checkTransformation(transform, polyMap, msg=msg)
# Inverse transform but no forward
polyMap = makeForwardPolyMap(nOut, nIn).inverted()
transform = TransformClass(polyMap)
self.checkTransformation(transform, polyMap, msg=msg)
# check invalid # of output against valid # of inputs
for nIn, badNOut in itertools.product(self.goodNAxes[fromName],
self.badNAxes[toName]):
badPolyMap = makeTwoWayPolyMap(nIn, badNOut)
msg = "{}, nIn={}, badNOut={}".format(baseMsg, nIn, badNOut)
with self.assertRaises(InvalidParameterError, msg=msg):
TransformClass(badPolyMap)
# check invalid # of inputs against valid and invalid # of outputs
for badNIn, nOut in itertools.product(self.badNAxes[fromName],
self.goodNAxes[toName] + self.badNAxes[toName]):
badPolyMap = makeTwoWayPolyMap(badNIn, nOut)
msg = "{}, badNIn={}, nOut={}".format(baseMsg, nIn, nOut)
with self.assertRaises(InvalidParameterError, msg=msg):
TransformClass(badPolyMap)
def checkGetInverse(self, fromName, toName):
"""Test Transform<fromName>To<toName>.getInverse
Parameters
----------
fromName, toName : `str`
Endpoint name prefix for "from" and "to" endpoints, respectively,
e.g. "Point2" for `lsst.afw.geom.Point2Endpoint`
"""
transformClassName = "Transform{}To{}".format(fromName, toName)
TransformClass = getattr(afwGeom, transformClassName)
baseMsg = "TransformClass={}".format(TransformClass.__name__)
for nIn, nOut in itertools.product(self.goodNAxes[fromName],
self.goodNAxes[toName]):
msg = "{}, nIn={}, nOut={}".format(baseMsg, nIn, nOut)
self.checkInverseMapping(
TransformClass,
makeTwoWayPolyMap(nIn, nOut),
"{}, Map={}".format(msg, "TwoWay"))
self.checkInverseMapping(
TransformClass,
makeForwardPolyMap(nIn, nOut),
"{}, Map={}".format(msg, "Forward"))
self.checkInverseMapping(
TransformClass,
makeForwardPolyMap(nOut, nIn).getInverse(),
"{}, Map={}".format(msg, "Inverse"))
self.checkInverseFrameSet(TransformClass,
self.makeGoodFrame(fromName, nIn),
self.makeGoodFrame(toName, nOut))
def checkInverted(self, fromName, toName):
"""Test Transform<fromName>To<toName>.inverted
Parameters
----------
fromName, toName : `str`
Endpoint name prefix for "from" and "to" endpoints, respectively,
e.g. "Point2" for `lsst.afw.geom.Point2Endpoint`
"""
transformClassName = "Transform{}To{}".format(fromName, toName)
TransformClass = getattr(afwGeom, transformClassName)
baseMsg = "TransformClass={}".format(TransformClass.__name__)
for nIn, nOut in itertools.product(self.goodNAxes[fromName],
self.goodNAxes[toName]):
msg = "{}, nIn={}, nOut={}".format(baseMsg, nIn, nOut)
self.checkInverseMapping(
TransformClass,
makeTwoWayPolyMap(nIn, nOut),
"{}, Map={}".format(msg, "TwoWay"))
self.checkInverseMapping(
TransformClass,
makeForwardPolyMap(nIn, nOut),
"{}, Map={}".format(msg, "Forward"))
self.checkInverseMapping(
TransformClass,
makeForwardPolyMap(nOut, nIn).inverted(),
"{}, Map={}".format(msg, "Inverse"))
def test_ZeroPoints(self):
"""Test that Mapping.applyForward and applyInverse can handle zero points
"""
mapping = makeTwoWayPolyMap(2, 3)
out_points1 = mapping.applyForward([])
self.assertEqual(len(out_points1), 0)
out_points2 = mapping.applyInverse([])
self.assertEqual(len(out_points2), 0)
def test_ZeroPoints(self):
"""Test that Mapping.applyForward and applyInverse can handle zero points
"""
mapping = makeTwoWayPolyMap(2, 3)
out_points1 = mapping.applyForward([])
self.assertEqual(len(out_points1), 0)
out_points2 = mapping.applyInverse([])
self.assertEqual(len(out_points2), 0)
def test_AppendIndependent(self):
"""Check that a concatenated FrameSet is not affected by changes
to its constituents.
"""
set1 = self.makeFrameSet(3, 3)
set2 = self.makeFrameSet(3, 3)
set12 = append(set1, set2)
nTotal = set12.nFrame
x = [1.2, 3.4, 5.6]
y = set12.applyForward(x)
set1.addFrame(2, makeTwoWayPolyMap(4, 2), Frame(2, "Ident=extra"))
set1.addFrame(1, makeTwoWayPolyMap(3, 3), Frame(3, "Ident=legume"))
set1.removeFrame(3)
set2.addFrame(4, makeForwardPolyMap(1, 4), Frame(4, "Ident=extra"))
set2.base = 2
# Use exact equality because nothing should change
self.assertEquals(set12.nFrame, nTotal)
self.assertEquals(set12.applyForward(x), y)
def test_AppendIndependent(self):
"""Check that a concatenated FrameSet is not affected by changes
to its constituents.
"""
set1 = self.makeFrameSet(3, 3)
set2 = self.makeFrameSet(3, 3)
set12 = append(set1, set2)
nTotal = set12.nFrame
x = [1.2, 3.4, 5.6]
y = set12.applyForward(x)
set1.addFrame(2, makeTwoWayPolyMap(4, 2), Frame(2, "Ident=extra"))
set1.addFrame(1, makeTwoWayPolyMap(3, 3), Frame(3, "Ident=legume"))
set1.removeFrame(3)
set2.addFrame(4, makeForwardPolyMap(1, 4), Frame(4, "Ident=extra"))
set2.base = 2
# Use exact equality because nothing should change
self.assertEqual(set12.nFrame, nTotal)
self.assertEqual(set12.applyForward(x), y)
def makeFrameSet(self, baseFrame, currFrame):
"""Make a FrameSet
The FrameSet will contain 4 frames and three transforms connecting them.
The idenity of each frame is provided by self.frameIdentDict
Frame Index Mapping from this frame to the next
`baseFrame` 1 `ast.UnitMap(nIn)`
Frame(nIn) 2 `polyMap`
Frame(nOut) 3 `ast.UnitMap(nOut)`
`currFrame` 4
where:
- `nIn` = `baseFrame.nAxes`
- `nOut` = `currFrame.nAxes`
- `polyMap` = `makeTwoWayPolyMap(nIn, nOut)`
Returns
------
`ast.FrameSet`
The FrameSet as described above
Parameters
----------
baseFrame : `ast.Frame`
base frame
currFrame : `ast.Frame`
current frame
"""
nIn = baseFrame.nAxes
nOut = currFrame.nAxes
polyMap = makeTwoWayPolyMap(nIn, nOut)
# The only way to set the Ident of a frame in a FrameSet is to set it in advance,
# and I don't want to modify the inputs, so replace the input frames with copies
baseFrame = baseFrame.copy()
baseFrame.ident = self.frameIdentDict[1]
currFrame = currFrame.copy()
currFrame.ident = self.frameIdentDict[4]
frameSet = ast.FrameSet(baseFrame)
frame2 = ast.Frame(nIn)
frame2.ident = self.frameIdentDict[2]
frameSet.addFrame(ast.FrameSet.CURRENT, ast.UnitMap(nIn), frame2)
frame3 = ast.Frame(nOut)
frame3.ident = self.frameIdentDict[3]
frameSet.addFrame(ast.FrameSet.CURRENT, polyMap, frame3)
frameSet.addFrame(ast.FrameSet.CURRENT, ast.UnitMap(nOut), currFrame)
return frameSet
def makeFrameSet(self, baseFrame, currFrame):
"""Make a FrameSet
The FrameSet will contain 4 frames and three transforms connecting them.
The idenity of each frame is provided by self.frameIdentDict
Frame Index Mapping from this frame to the next
`baseFrame` 1 `ast.UnitMap(nIn)`
Frame(nIn) 2 `polyMap`
Frame(nOut) 3 `ast.UnitMap(nOut)`
`currFrame` 4
where:
- `nIn` = `baseFrame.nAxes`
- `nOut` = `currFrame.nAxes`
- `polyMap` = `makeTwoWayPolyMap(nIn, nOut)`
Returns
------
`ast.FrameSet`
The FrameSet as described above
Parameters
----------
baseFrame : `ast.Frame`
base frame
currFrame : `ast.Frame`
current frame
"""
nIn = baseFrame.nAxes
nOut = currFrame.nAxes
polyMap = makeTwoWayPolyMap(nIn, nOut)
# The only way to set the Ident of a frame in a FrameSet is to set it in advance,
# and I don't want to modify the inputs, so replace the input frames with copies
baseFrame = baseFrame.copy()
baseFrame.ident = self.frameIdentDict[1]
currFrame = currFrame.copy()
currFrame.ident = self.frameIdentDict[4]
frameSet = ast.FrameSet(baseFrame)
frame2 = ast.Frame(nIn)
frame2.ident = self.frameIdentDict[2]
frameSet.addFrame(ast.FrameSet.CURRENT, ast.UnitMap(nIn), frame2)
frame3 = ast.Frame(nOut)
frame3.ident = self.frameIdentDict[3]
frameSet.addFrame(ast.FrameSet.CURRENT, polyMap, frame3)
frameSet.addFrame(ast.FrameSet.CURRENT, ast.UnitMap(nOut), currFrame)
return frameSet
def checkTransformFromFrameSet(self, fromName, toName):
"""Check Transform_<fromName>_<toName> using the FrameSet constructor
Parameters
----------
fromName, toName : `str`
Endpoint name prefix for "from" and "to" endpoints, respectively,
e.g. "Point2" for `lsst.afw.geom.Point2Endpoint`
"""
transformClassName = "Transform{}To{}".format(fromName, toName)
TransformClass = getattr(afwGeom, transformClassName)
baseMsg = "TransformClass={}".format(TransformClass.__name__)
for nIn, nOut in itertools.product(self.goodNAxes[fromName],
self.goodNAxes[toName]):
msg = "{}, nIn={}, nOut={}".format(baseMsg, nIn, nOut)
baseFrame = self.makeGoodFrame(fromName, nIn)
currFrame = self.makeGoodFrame(toName, nOut)
frameSet = self.makeFrameSet(baseFrame, currFrame)
self.assertEqual(frameSet.nFrame, 4)
# construct 0 or more frame sets that are invalid for this transform class
for badBaseFrame in self.makeBadFrames(fromName):
badFrameSet = self.makeFrameSet(badBaseFrame, currFrame)
with self.assertRaises(InvalidParameterError):
TransformClass(badFrameSet)
for badCurrFrame in self.makeBadFrames(toName):
reallyBadFrameSet = self.makeFrameSet(
badBaseFrame, badCurrFrame)
with self.assertRaises(InvalidParameterError):
TransformClass(reallyBadFrameSet)
for badCurrFrame in self.makeBadFrames(toName):
badFrameSet = self.makeFrameSet(baseFrame, badCurrFrame)
with self.assertRaises(InvalidParameterError):
TransformClass(badFrameSet)
transform = TransformClass(frameSet)
desStr = "{}[{}->{}]".format(transformClassName, nIn, nOut)
self.assertEqual("{}".format(transform), desStr)
self.assertEqual(repr(transform), "lsst.afw.geom." + desStr)
self.checkPersistence(transform)
mappingFromTransform = transform.getMapping()
transformCopy = TransformClass(mappingFromTransform)
self.assertEqual(type(transform), type(transformCopy))
self.assertEqual(transform.getMapping(), mappingFromTransform)
polyMap = makeTwoWayPolyMap(nIn, nOut)
self.checkTransformation(transform, mapping=polyMap, msg=msg)
# If the base and/or current frame of frameSet is a SkyFrame,
# try permuting that frame (in place, so the connected mappings are
# correctly updated). The Transform constructor should undo the permutation,
# (via SpherePointEndpoint.normalizeFrame) in its internal copy of frameSet,
# forcing the axes of the SkyFrame into standard (longitude, latitude) order
for permutedFS in self.permuteFrameSetIter(frameSet):
if permutedFS.isBaseSkyFrame:
baseFrame = permutedFS.frameSet.getFrame(ast.FrameSet.BASE)
# desired base longitude axis
desBaseLonAxis = 2 if permutedFS.isBasePermuted else 1
self.assertEqual(baseFrame.lonAxis, desBaseLonAxis)
if permutedFS.isCurrSkyFrame:
currFrame = permutedFS.frameSet.getFrame(
ast.FrameSet.CURRENT)
# desired current base longitude axis
desCurrLonAxis = 2 if permutedFS.isCurrPermuted else 1
self.assertEqual(currFrame.lonAxis, desCurrLonAxis)
permTransform = TransformClass(permutedFS.frameSet)
self.checkTransformation(permTransform,
mapping=polyMap,
msg=msg)
def checkThen(self, fromName, midName, toName):
"""Test Transform<fromName>To<midName>.then(Transform<midName>To<toName>)
Parameters
----------
fromName : `str`
the prefix of the starting endpoint (e.g., "Point2" for a
Point2Endpoint) for the final, concatenated Transform
midName : `str`
the prefix for the shared endpoint where two Transforms will be
concatenated
toName : `str`
the prefix of the ending endpoint for the final, concatenated
Transform
"""
TransformClass1 = getattr(afwGeom,
"Transform{}To{}".format(fromName, midName))
TransformClass2 = getattr(afwGeom,
"Transform{}To{}".format(midName, toName))
baseMsg = "{}.then({})".format(TransformClass1.__name__,
TransformClass2.__name__)
for nIn, nMid, nOut in itertools.product(self.goodNAxes[fromName],
self.goodNAxes[midName],
self.goodNAxes[toName]):
msg = "{}, nIn={}, nMid={}, nOut={}".format(
baseMsg, nIn, nMid, nOut)
polyMap1 = makeTwoWayPolyMap(nIn, nMid)
transform1 = TransformClass1(polyMap1)
polyMap2 = makeTwoWayPolyMap(nMid, nOut)
transform2 = TransformClass2(polyMap2)
transform = transform1.then(transform2)
fromEndpoint = transform1.fromEndpoint
toEndpoint = transform2.toEndpoint
inPoint = fromEndpoint.pointFromData(self.makeRawPointData(nIn))
outPointMerged = transform.applyForward(inPoint)
outPointSeparate = transform2.applyForward(
transform1.applyForward(inPoint))
assert_allclose(toEndpoint.dataFromPoint(outPointMerged),
toEndpoint.dataFromPoint(outPointSeparate),
err_msg=msg)
outPoint = toEndpoint.pointFromData(self.makeRawPointData(nOut))
inPointMerged = transform.applyInverse(outPoint)
inPointSeparate = transform1.applyInverse(
transform2.applyInverse(outPoint))
assert_allclose(fromEndpoint.dataFromPoint(inPointMerged),
fromEndpoint.dataFromPoint(inPointSeparate),
err_msg=msg)
# Mismatched number of axes should fail
if midName == "Generic":
nIn = self.goodNAxes[fromName][0]
nOut = self.goodNAxes[toName][0]
polyMap = makeTwoWayPolyMap(nIn, 3)
transform1 = TransformClass1(polyMap)
polyMap = makeTwoWayPolyMap(2, nOut)
transform2 = TransformClass2(polyMap)
with self.assertRaises(InvalidParameterError):
transform = transform1.then(transform2)
# Mismatched types of endpoints should fail
if fromName != midName:
# Use TransformClass1 for both args to keep test logic simple
outName = midName
joinNAxes = set(self.goodNAxes[fromName]).intersection(
self.goodNAxes[outName])
for nIn, nMid, nOut in itertools.product(self.goodNAxes[fromName],
joinNAxes,
self.goodNAxes[outName]):
polyMap = makeTwoWayPolyMap(nIn, nMid)
transform1 = TransformClass1(polyMap)
polyMap = makeTwoWayPolyMap(nMid, nOut)
transform2 = TransformClass1(polyMap)
with self.assertRaises(InvalidParameterError):
transform = transform1.then(transform2)
def checkThen(self, fromName, midName, toName):
"""Test Transform<fromName>To<midName>.then(Transform<midName>To<toName>)
Parameters
----------
fromName : `str`
the prefix of the starting endpoint (e.g., "Point2" for a
Point2Endpoint) for the final, concatenated Transform
midName : `str`
the prefix for the shared endpoint where two Transforms will be
concatenated
toName : `str`
the prefix of the ending endpoint for the final, concatenated
Transform
"""
TransformClass1 = getattr(afwGeom,
"Transform{}To{}".format(fromName, midName))
TransformClass2 = getattr(afwGeom,
"Transform{}To{}".format(midName, toName))
baseMsg = "{}.then({})".format(TransformClass1.__name__,
TransformClass2.__name__)
for nIn, nMid, nOut in itertools.product(self.goodNAxes[fromName],
self.goodNAxes[midName],
self.goodNAxes[toName]):
msg = "{}, nIn={}, nMid={}, nOut={}".format(
baseMsg, nIn, nMid, nOut)
polyMap1 = makeTwoWayPolyMap(nIn, nMid)
transform1 = TransformClass1(polyMap1)
polyMap2 = makeTwoWayPolyMap(nMid, nOut)
transform2 = TransformClass2(polyMap2)
transform = transform1.then(transform2)
fromEndpoint = transform1.fromEndpoint
toEndpoint = transform2.toEndpoint
inPoint = fromEndpoint.pointFromData(self.makeRawPointData(nIn))
outPointMerged = transform.applyForward(inPoint)
outPointSeparate = transform2.applyForward(
transform1.applyForward(inPoint))
assert_allclose(toEndpoint.dataFromPoint(outPointMerged),
toEndpoint.dataFromPoint(outPointSeparate),
err_msg=msg)
outPoint = toEndpoint.pointFromData(self.makeRawPointData(nOut))
inPointMerged = transform.applyInverse(outPoint)
inPointSeparate = transform1.applyInverse(
transform2.applyInverse(outPoint))
assert_allclose(
fromEndpoint.dataFromPoint(inPointMerged),
fromEndpoint.dataFromPoint(inPointSeparate),
err_msg=msg)
# Mismatched number of axes should fail
if midName == "Generic":
nIn = self.goodNAxes[fromName][0]
nOut = self.goodNAxes[toName][0]
polyMap = makeTwoWayPolyMap(nIn, 3)
transform1 = TransformClass1(polyMap)
polyMap = makeTwoWayPolyMap(2, nOut)
transform2 = TransformClass2(polyMap)
with self.assertRaises(InvalidParameterError):
transform = transform1.then(transform2)
# Mismatched types of endpoints should fail
if fromName != midName:
# Use TransformClass1 for both args to keep test logic simple
outName = midName
joinNAxes = set(self.goodNAxes[fromName]).intersection(
self.goodNAxes[outName])
for nIn, nMid, nOut in itertools.product(self.goodNAxes[fromName],
joinNAxes,
self.goodNAxes[outName]):
polyMap = makeTwoWayPolyMap(nIn, nMid)
transform1 = TransformClass1(polyMap)
polyMap = makeTwoWayPolyMap(nMid, nOut)
transform2 = TransformClass1(polyMap)
with self.assertRaises(InvalidParameterError):
transform = transform1.then(transform2)
def checkTransformFromFrameSet(self, fromName, toName):
"""Check Transform_<fromName>_<toName> using the FrameSet constructor
Parameters
----------
fromName, toName : `str`
Endpoint name prefix for "from" and "to" endpoints, respectively,
e.g. "Point2" for `lsst.afw.geom.Point2Endpoint`
"""
transformClassName = "Transform{}To{}".format(fromName, toName)
TransformClass = getattr(afwGeom, transformClassName)
baseMsg = "TransformClass={}".format(TransformClass.__name__)
for nIn, nOut in itertools.product(self.goodNAxes[fromName],
self.goodNAxes[toName]):
msg = "{}, nIn={}, nOut={}".format(baseMsg, nIn, nOut)
baseFrame = self.makeGoodFrame(fromName, nIn)
currFrame = self.makeGoodFrame(toName, nOut)
frameSet = self.makeFrameSet(baseFrame, currFrame)
self.assertEqual(frameSet.nFrame, 4)
# construct 0 or more frame sets that are invalid for this transform class
for badBaseFrame in self.makeBadFrames(fromName):
badFrameSet = self.makeFrameSet(badBaseFrame, currFrame)
with self.assertRaises(InvalidParameterError):
TransformClass(badFrameSet)
for badCurrFrame in self.makeBadFrames(toName):
reallyBadFrameSet = self.makeFrameSet(badBaseFrame, badCurrFrame)
with self.assertRaises(InvalidParameterError):
TransformClass(reallyBadFrameSet)
for badCurrFrame in self.makeBadFrames(toName):
badFrameSet = self.makeFrameSet(baseFrame, badCurrFrame)
with self.assertRaises(InvalidParameterError):
TransformClass(badFrameSet)
transform = TransformClass(frameSet)
desStr = "{}[{}->{}]".format(transformClassName, nIn, nOut)
self.assertEqual("{}".format(transform), desStr)
self.assertEqual(repr(transform), "lsst.afw.geom." + desStr)
self.checkPersistence(transform)
mappingFromTransform = transform.getMapping()
transformCopy = TransformClass(mappingFromTransform)
self.assertEqual(type(transform), type(transformCopy))
self.assertEqual(transform.getMapping(), mappingFromTransform)
polyMap = makeTwoWayPolyMap(nIn, nOut)
self.checkTransformation(transform, mapping=polyMap, msg=msg)
# If the base and/or current frame of frameSet is a SkyFrame,
# try permuting that frame (in place, so the connected mappings are
# correctly updated). The Transform constructor should undo the permutation,
# (via SpherePointEndpoint.normalizeFrame) in its internal copy of frameSet,
# forcing the axes of the SkyFrame into standard (longitude, latitude) order
for permutedFS in self.permuteFrameSetIter(frameSet):
if permutedFS.isBaseSkyFrame:
baseFrame = permutedFS.frameSet.getFrame(ast.FrameSet.BASE)
# desired base longitude axis
desBaseLonAxis = 2 if permutedFS.isBasePermuted else 1
self.assertEqual(baseFrame.lonAxis, desBaseLonAxis)
if permutedFS.isCurrSkyFrame:
currFrame = permutedFS.frameSet.getFrame(ast.FrameSet.CURRENT)
# desired current base longitude axis
desCurrLonAxis = 2 if permutedFS.isCurrPermuted else 1
self.assertEqual(currFrame.lonAxis, desCurrLonAxis)
permTransform = TransformClass(permutedFS.frameSet)
self.checkTransformation(permTransform, mapping=polyMap, msg=msg)
