lsst.afw.geom.testUtils.TransformTestBaseClass Class Reference

Inheritance diagram for lsst.afw.geom.testUtils.TransformTestBaseClass:

Public Member Functions
def	getTestDir (self)
def	setUp (self)
def	makeGoodFrame (cls, name, nAxes=None)
def	makeFrameSet (self, baseFrame, currFrame)
def	checkTransformation (self, transform, mapping, msg="")
def	checkInverseTransformation (self, forward, inverse, msg="")
def	checkTransformFromMapping (self, fromName, toName)
def	checkTransformFromFrameSet (self, fromName, toName)
def	checkInverted (self, fromName, toName)
def	checkInverseMapping (self, TransformClass, mapping, msg)
def	checkGetJacobian (self, fromName, toName)
def	checkThen (self, fromName, midName, toName)
def	assertTransformsEqual (self, transform1, transform2)
def	checkPersistence (self, transform)

Static Public Member Functions
def	makeRawArrayData (nPoints, nAxes, delta=0.123)
def	makeRawPointData (nAxes, delta=0.123)
def	makeEndpoint (name, nAxes=None)
def	makeBadFrames (name)
def	permuteFrameSetIter (frameSet)
def	makeJacobian (nIn, nOut, inPoint)

Public Attributes
	longMessage
	endpointPrefixes
	goodNAxes
	badNAxes
	frameIdentDict

Detailed Description

Base class for unit tests of Transform<X>To<Y>

Subclasses must call `TransformTestBaseClass.setUp(self)`
if they provide their own version.

If a package other than afw uses this class then it must
override the `getTestDir` method to avoid writing into
afw's test directory.

Definition at line 330 of file testUtils.py.

Member Function Documentation

assertTransformsEqual()

def lsst.afw.geom.testUtils.TransformTestBaseClass.assertTransformsEqual	(		self,
			transform1,
			transform2
	)

Assert that two transforms are equal

Definition at line 1055 of file testUtils.py.

    def assertTransformsEqual(self, transform1, transform2):
        """Assert that two transforms are equal"""
        self.assertEqual(type(transform1), type(transform2))
        self.assertEqual(transform1.fromEndpoint, transform2.fromEndpoint)
        self.assertEqual(transform1.toEndpoint, transform2.toEndpoint)
        self.assertEqual(transform1.getMapping(), transform2.getMapping())
 
        fromEndpoint = transform1.fromEndpoint
        toEndpoint = transform1.toEndpoint
        mapping = transform1.getMapping()
        nIn = mapping.nIn
        nOut = mapping.nOut
 
        if mapping.hasForward:
            nPoints = 7  # arbitrary
            rawInArray = self.makeRawArrayData(nPoints, nIn)
            inArray = fromEndpoint.arrayFromData(rawInArray)
            outArray = transform1.applyForward(inArray)
            outData = toEndpoint.dataFromArray(outArray)
            outArrayRoundTrip = transform2.applyForward(inArray)
            outDataRoundTrip = toEndpoint.dataFromArray(outArrayRoundTrip)
            assert_allclose(outData, outDataRoundTrip)
 
        if mapping.hasInverse:
            nPoints = 7  # arbitrary
            rawOutArray = self.makeRawArrayData(nPoints, nOut)
            outArray = toEndpoint.arrayFromData(rawOutArray)
            inArray = transform1.applyInverse(outArray)
            inData = fromEndpoint.dataFromArray(inArray)
            inArrayRoundTrip = transform2.applyInverse(outArray)
            inDataRoundTrip = fromEndpoint.dataFromArray(inArrayRoundTrip)
            assert_allclose(inData, inDataRoundTrip)
 

checkGetJacobian()

def lsst.afw.geom.testUtils.TransformTestBaseClass.checkGetJacobian	(		self,
			fromName,
			toName
	)

Test Transform<fromName>To<toName>.getJacobian

Parameters
----------
fromName, toName : `str`
    Endpoint name prefix for "from" and "to" endpoints, respectively,
    e.g. "Point2" for `lsst.afw.geom.Point2Endpoint`

Definition at line 943 of file testUtils.py.

    def checkGetJacobian(self, fromName, toName):
        """Test Transform<fromName>To<toName>.getJacobian
 
        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)
            polyMap = makeForwardPolyMap(nIn, nOut)
            transform = TransformClass(polyMap)
            fromEndpoint = transform.fromEndpoint
 
            # Test multiple points to ensure correct functional form
            rawInPoint = self.makeRawPointData(nIn)
            inPoint = fromEndpoint.pointFromData(rawInPoint)
            jacobian = transform.getJacobian(inPoint)
            assert_allclose(jacobian, self.makeJacobian(nIn, nOut, rawInPoint),
                            err_msg=msg)
 
            rawInPoint = self.makeRawPointData(nIn, 0.111)
            inPoint = fromEndpoint.pointFromData(rawInPoint)
            jacobian = transform.getJacobian(inPoint)
            assert_allclose(jacobian, self.makeJacobian(nIn, nOut, rawInPoint),
                            err_msg=msg)
 

checkInverseMapping()

def lsst.afw.geom.testUtils.TransformTestBaseClass.checkInverseMapping	(		self,
			TransformClass,
			mapping,
			msg
	)

Test Transform<fromName>To<toName>.inverted for a specific
mapping.

Also check that inverted() and getInverted() return the same
transform.

Parameters
----------
TransformClass : `type`
    The class of transform to test, such as TransformPoint2ToPoint2
mapping : `ast.Mapping`
    The mapping to use for the transform
msg : `str`
    Error message suffix

Definition at line 919 of file testUtils.py.

    def checkInverseMapping(self, TransformClass, mapping, msg):
        """Test Transform<fromName>To<toName>.inverted for a specific
        mapping.
 
        Also check that inverted() and getInverted() return the same
        transform.
 
        Parameters
        ----------
        TransformClass : `type`
            The class of transform to test, such as TransformPoint2ToPoint2
        mapping : `ast.Mapping`
            The mapping to use for the transform
        msg : `str`
            Error message suffix
        """
        transform = TransformClass(mapping)
        inverse = transform.inverted()
        inverseInverse = inverse.inverted()
 
        self.checkInverseTransformation(transform, inverse, msg=msg)
        self.checkInverseTransformation(inverse, inverseInverse, msg=msg)
        self.checkTransformation(inverseInverse, mapping, msg=msg)
 

checkInverseTransformation()

def lsst.afw.geom.testUtils.TransformTestBaseClass.checkInverseTransformation	(		self,
			forward,
			inverse,
			msg = ""
	)

Check that two Transforms are each others' inverses.

Parameters
----------
forward : `lsst.afw.geom.Transform`
    the reference Transform to test
inverse : `lsst.afw.geom.Transform`
    the transform that should be the inverse of `forward`
msg : `str`
    error message suffix describing test parameters

Definition at line 699 of file testUtils.py.

    def checkInverseTransformation(self, forward, inverse, msg=""):
        """Check that two Transforms are each others' inverses.
 
        Parameters
        ----------
        forward : `lsst.afw.geom.Transform`
            the reference Transform to test
        inverse : `lsst.afw.geom.Transform`
            the transform that should be the inverse of `forward`
        msg : `str`
            error message suffix describing test parameters
        """
        fromEndpoint = forward.fromEndpoint
        toEndpoint = forward.toEndpoint
        forwardMapping = forward.getMapping()
        inverseMapping = inverse.getMapping()
 
        # properties
        self.assertEqual(forward.fromEndpoint,
                         inverse.toEndpoint, msg=msg)
        self.assertEqual(forward.toEndpoint,
                         inverse.fromEndpoint, msg=msg)
        self.assertEqual(forward.hasForward, inverse.hasInverse, msg=msg)
        self.assertEqual(forward.hasInverse, inverse.hasForward, msg=msg)
 
        # transformations of one point
        # we don't care about whether the transformation itself is correct
        # (see checkTransformation), so inPoint/outPoint need not be related
        rawInPoint = self.makeRawPointData(fromEndpoint.nAxes)
        inPoint = fromEndpoint.pointFromData(rawInPoint)
        rawOutPoint = self.makeRawPointData(toEndpoint.nAxes)
        outPoint = toEndpoint.pointFromData(rawOutPoint)
 
        # transformations of arrays of points
        nPoints = 7  # arbitrary
        rawInArray = self.makeRawArrayData(nPoints, fromEndpoint.nAxes)
        inArray = fromEndpoint.arrayFromData(rawInArray)
        rawOutArray = self.makeRawArrayData(nPoints, toEndpoint.nAxes)
        outArray = toEndpoint.arrayFromData(rawOutArray)
 
        if forward.hasForward:
            self.assertEqual(forward.applyForward(inPoint),
                             inverse.applyInverse(inPoint), msg=msg)
            self.assertEqual(forwardMapping.applyForward(rawInPoint),
                             inverseMapping.applyInverse(rawInPoint), msg=msg)
            # Assertions must work with both lists and numpy arrays
            assert_array_equal(forward.applyForward(inArray),
                               inverse.applyInverse(inArray),
                               err_msg=msg)
            assert_array_equal(forwardMapping.applyForward(rawInArray),
                               inverseMapping.applyInverse(rawInArray),
                               err_msg=msg)
 
        if forward.hasInverse:
            self.assertEqual(forward.applyInverse(outPoint),
                             inverse.applyForward(outPoint), msg=msg)
            self.assertEqual(forwardMapping.applyInverse(rawOutPoint),
                             inverseMapping.applyForward(rawOutPoint), msg=msg)
            assert_array_equal(forward.applyInverse(outArray),
                               inverse.applyForward(outArray),
                               err_msg=msg)
            assert_array_equal(forwardMapping.applyInverse(rawOutArray),
                               inverseMapping.applyForward(rawOutArray),
                               err_msg=msg)
 

checkInverted()

def lsst.afw.geom.testUtils.TransformTestBaseClass.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`

Definition at line 891 of file testUtils.py.

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

checkPersistence()

def lsst.afw.geom.testUtils.TransformTestBaseClass.checkPersistence	(		self,
			transform
	)

Check persistence of a transform

Definition at line 1088 of file testUtils.py.

    def checkPersistence(self, transform):
        """Check persistence of a transform
        """
        className = type(transform).__name__
 
        # check writeString and readString
        transformStr = transform.writeString()
        serialVersion, serialClassName, serialRest = transformStr.split(" ", 2)
        self.assertEqual(int(serialVersion), 1)
        self.assertEqual(serialClassName, className)
        badStr1 = " ".join(["2", serialClassName, serialRest])
        with self.assertRaises(lsst.pex.exceptions.InvalidParameterError):
            transform.readString(badStr1)
        badClassName = "x" + serialClassName
        badStr2 = " ".join(["1", badClassName, serialRest])
        with self.assertRaises(lsst.pex.exceptions.InvalidParameterError):
            transform.readString(badStr2)
        transformFromStr1 = transform.readString(transformStr)
        self.assertTransformsEqual(transform, transformFromStr1)
 
        # check transformFromString
        transformFromStr2 = afwGeom.transformFromString(transformStr)
        self.assertTransformsEqual(transform, transformFromStr2)
 
        # Check pickling
        self.assertTransformsEqual(transform, pickle.loads(pickle.dumps(transform)))
 
        # Check afw::table::io persistence round-trip
        with lsst.utils.tests.getTempFilePath(".fits") as filename:
            transform.writeFits(filename)
            self.assertTransformsEqual(transform, type(transform).readFits(filename))

checkThen()

def lsst.afw.geom.testUtils.TransformTestBaseClass.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

Definition at line 975 of file testUtils.py.

    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)
 

checkTransformation()

def lsst.afw.geom.testUtils.TransformTestBaseClass.checkTransformation	(		self,
			transform,
			mapping,
			msg = ""
	)

Check applyForward and applyInverse for a transform

Parameters
----------
transform : `lsst.afw.geom.Transform`
    The transform to check
mapping : `ast.Mapping`
    The mapping the transform should use. This mapping
    must contain valid forward or inverse transformations,
    but they need not match if both present. Hence the
    mappings returned by make*PolyMap are acceptable.
msg : `str`
    Error message suffix describing test parameters

Definition at line 625 of file testUtils.py.

    def checkTransformation(self, transform, mapping, msg=""):
        """Check applyForward and applyInverse for a transform
 
        Parameters
        ----------
        transform : `lsst.afw.geom.Transform`
            The transform to check
        mapping : `ast.Mapping`
            The mapping the transform should use. This mapping
            must contain valid forward or inverse transformations,
            but they need not match if both present. Hence the
            mappings returned by make*PolyMap are acceptable.
        msg : `str`
            Error message suffix describing test parameters
        """
        fromEndpoint = transform.fromEndpoint
        toEndpoint = transform.toEndpoint
        mappingFromTransform = transform.getMapping()
 
        nIn = mapping.nIn
        nOut = mapping.nOut
        self.assertEqual(nIn, fromEndpoint.nAxes, msg=msg)
        self.assertEqual(nOut, toEndpoint.nAxes, msg=msg)
 
        # forward transformation of one point
        rawInPoint = self.makeRawPointData(nIn)
        inPoint = fromEndpoint.pointFromData(rawInPoint)
 
        # forward transformation of an array of points
        nPoints = 7  # arbitrary
        rawInArray = self.makeRawArrayData(nPoints, nIn)
        inArray = fromEndpoint.arrayFromData(rawInArray)
 
        if mapping.hasForward:
            self.assertTrue(transform.hasForward)
            outPoint = transform.applyForward(inPoint)
            rawOutPoint = toEndpoint.dataFromPoint(outPoint)
            assert_allclose(rawOutPoint, mapping.applyForward(rawInPoint), err_msg=msg)
            assert_allclose(rawOutPoint, mappingFromTransform.applyForward(rawInPoint), err_msg=msg)
 
            outArray = transform.applyForward(inArray)
            rawOutArray = toEndpoint.dataFromArray(outArray)
            self.assertFloatsAlmostEqual(rawOutArray, mapping.applyForward(rawInArray), msg=msg)
            self.assertFloatsAlmostEqual(rawOutArray, mappingFromTransform.applyForward(rawInArray), msg=msg)
        else:
            # Need outPoint, but don't need it to be consistent with inPoint
            rawOutPoint = self.makeRawPointData(nOut)
            outPoint = toEndpoint.pointFromData(rawOutPoint)
            rawOutArray = self.makeRawArrayData(nPoints, nOut)
            outArray = toEndpoint.arrayFromData(rawOutArray)
 
            self.assertFalse(transform.hasForward)
 
        if mapping.hasInverse:
            self.assertTrue(transform.hasInverse)
            # inverse transformation of one point;
            # remember that the inverse need not give the original values
            # (see the description of the `mapping` parameter)
            inversePoint = transform.applyInverse(outPoint)
            rawInversePoint = fromEndpoint.dataFromPoint(inversePoint)
            assert_allclose(rawInversePoint, mapping.applyInverse(rawOutPoint), err_msg=msg)
            assert_allclose(rawInversePoint, mappingFromTransform.applyInverse(rawOutPoint), err_msg=msg)
 
            # inverse transformation of an array of points;
            # remember that the inverse will not give the original values
            # (see the description of the `mapping` parameter)
            inverseArray = transform.applyInverse(outArray)
            rawInverseArray = fromEndpoint.dataFromArray(inverseArray)
            self.assertFloatsAlmostEqual(rawInverseArray, mapping.applyInverse(rawOutArray), msg=msg)
            self.assertFloatsAlmostEqual(rawInverseArray, mappingFromTransform.applyInverse(rawOutArray),
                                         msg=msg)
        else:
            self.assertFalse(transform.hasInverse)
 

checkTransformFromFrameSet()

def lsst.afw.geom.testUtils.TransformTestBaseClass.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`

Definition at line 819 of file testUtils.py.

    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)
 

checkTransformFromMapping()

def lsst.afw.geom.testUtils.TransformTestBaseClass.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

Definition at line 764 of file testUtils.py.

    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)
 

getTestDir()

def lsst.afw.geom.testUtils.TransformTestBaseClass.getTestDir

(

self

)

Return a directory where temporary test files can be written

The default implementation returns the test directory of the `afw`
package.

If this class is used by a test in a package other than `afw`
then the subclass must override this method.

Definition at line 341 of file testUtils.py.

    def getTestDir(self):
        """Return a directory where temporary test files can be written
 
        The default implementation returns the test directory of the `afw`
        package.
 
        If this class is used by a test in a package other than `afw`
        then the subclass must override this method.
        """
        return os.path.join(lsst.utils.getPackageDir("afw"), "tests")
 

makeBadFrames()

def lsst.afw.geom.testUtils.TransformTestBaseClass.makeBadFrames (   name )

static

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

Definition at line 494 of file testUtils.py.

    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]
 

makeEndpoint()

def lsst.afw.geom.testUtils.TransformTestBaseClass.makeEndpoint (   name,   nAxes = None  )

static

Make an endpoint

Parameters
----------
name : `str`
    Endpoint class name prefix; the full class name is name + "Endpoint"
nAxes : `int` or `None`, optional
    number of axes; an int is required if `name` == "Generic";
    otherwise ignored

Returns
-------
subclass of `lsst.afw.geom.BaseEndpoint`
    The constructed endpoint

Raises
------
TypeError
    If `name` == "Generic" and `nAxes` is None or <= 0

Definition at line 440 of file testUtils.py.

    def makeEndpoint(name, nAxes=None):
        """Make an endpoint
 
        Parameters
        ----------
        name : `str`
            Endpoint class name prefix; the full class name is name + "Endpoint"
        nAxes : `int` or `None`, optional
            number of axes; an int is required if `name` == "Generic";
            otherwise ignored
 
        Returns
        -------
        subclass of `lsst.afw.geom.BaseEndpoint`
            The constructed endpoint
 
        Raises
        ------
        TypeError
            If `name` == "Generic" and `nAxes` is None or <= 0
        """
        EndpointClassName = name + "Endpoint"
        EndpointClass = getattr(afwGeom, EndpointClassName)
        if name == "Generic":
            if nAxes is None:
                raise TypeError("nAxes must be an integer for GenericEndpoint")
            return EndpointClass(nAxes)
        return EndpointClass()
 

makeFrameSet()

def lsst.afw.geom.testUtils.TransformTestBaseClass.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

Definition at line 522 of file testUtils.py.

    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
 

makeGoodFrame()

def lsst.afw.geom.testUtils.TransformTestBaseClass.makeGoodFrame	(		cls,
			name,
			nAxes = None
	)

Return the appropriate frame for the given name and nAxes

Parameters
----------
name : `str`
    Endpoint class name prefix; the full class name is name + "Endpoint"
nAxes : `int` or `None`, optional
    number of axes; an int is required if `name` == "Generic";
    otherwise ignored

Returns
-------
`ast.Frame`
    The constructed frame

Raises
------
TypeError
    If `name` == "Generic" and `nAxes` is `None` or <= 0

Definition at line 470 of file testUtils.py.

    def makeGoodFrame(cls, name, nAxes=None):
        """Return the appropriate frame for the given name and nAxes
 
        Parameters
        ----------
        name : `str`
            Endpoint class name prefix; the full class name is name + "Endpoint"
        nAxes : `int` or `None`, optional
            number of axes; an int is required if `name` == "Generic";
            otherwise ignored
 
        Returns
        -------
        `ast.Frame`
            The constructed frame
 
        Raises
        ------
        TypeError
            If `name` == "Generic" and `nAxes` is `None` or <= 0
        """
        return cls.makeEndpoint(name, nAxes).makeFrame()
 

makeJacobian()

def lsst.afw.geom.testUtils.TransformTestBaseClass.makeJacobian (   nIn,   nOut,   inPoint  )

static

Make a Jacobian matrix for the equation described by
`makeTwoWayPolyMap`.

Parameters
----------
nIn, nOut : `int`
    the dimensions of the input and output data; see makeTwoWayPolyMap
inPoint : `numpy.ndarray`
    an array of size `nIn` representing the point at which the Jacobian
    is measured

Returns
-------
J : `numpy.ndarray`
    an `nOut` x `nIn` array of first derivatives

Definition at line 595 of file testUtils.py.

    def makeJacobian(nIn, nOut, inPoint):
        """Make a Jacobian matrix for the equation described by
        `makeTwoWayPolyMap`.
 
        Parameters
        ----------
        nIn, nOut : `int`
            the dimensions of the input and output data; see makeTwoWayPolyMap
        inPoint : `numpy.ndarray`
            an array of size `nIn` representing the point at which the Jacobian
            is measured
 
        Returns
        -------
        J : `numpy.ndarray`
            an `nOut` x `nIn` array of first derivatives
        """
        basePolyMapCoeff = 0.001  # see makeTwoWayPolyMap
        baseCoeff = 2.0 * basePolyMapCoeff
        coeffs = np.empty((nOut, nIn))
        for iOut in range(nOut):
            coeffOffset = baseCoeff * iOut
            for iIn in range(nIn):
                coeffs[iOut, iIn] = baseCoeff * (iIn + 1) + coeffOffset
                coeffs[iOut, iIn] *= inPoint[iIn]
        assert coeffs.ndim == 2
        # Avoid spurious errors when comparing to a simplified array
        assert coeffs.shape == (nOut, nIn)
        return coeffs
 

makeRawArrayData()

def lsst.afw.geom.testUtils.TransformTestBaseClass.makeRawArrayData (   nPoints,   nAxes,   delta = 0.123  )

static

Make an array of generic point data

The data will be suitable for spherical points

Parameters
----------
nPoints : `int`
    Number of points in the array
nAxes : `int`
    Number of axes in the point

Returns
-------
np.array of floats with shape (nAxes, nPoints)
    The values are as follows; if nAxes != 2:
        The first point has values `[0, delta, 2*delta, ..., (nAxes-1)*delta]`
        The Nth point has those values + N
    if nAxes == 2 then the data is scaled so that the max value of axis 1
        is a bit less than pi/2

Definition at line 389 of file testUtils.py.

    def makeRawArrayData(nPoints, nAxes, delta=0.123):
        """Make an array of generic point data
 
        The data will be suitable for spherical points
 
        Parameters
        ----------
        nPoints : `int`
            Number of points in the array
        nAxes : `int`
            Number of axes in the point
 
        Returns
        -------
        np.array of floats with shape (nAxes, nPoints)
            The values are as follows; if nAxes != 2:
                The first point has values `[0, delta, 2*delta, ..., (nAxes-1)*delta]`
                The Nth point has those values + N
            if nAxes == 2 then the data is scaled so that the max value of axis 1
                is a bit less than pi/2
        """
        delta = 0.123
        # oneAxis = [0, 1, 2, ...nPoints-1]
        oneAxis = np.arange(nPoints, dtype=float)  # [0, 1, 2...]
        # rawData = [oneAxis, oneAxis + delta, oneAxis + 2 delta, ...]
        rawData = np.array([j * delta + oneAxis for j in range(nAxes)], dtype=float)
        if nAxes == 2:
            # scale rawData so that max value of 2nd axis is a bit less than pi/2,
            # thus making the data safe for SpherePoint
            maxLatitude = np.max(rawData[1])
            rawData *= math.pi * 0.4999 / maxLatitude
        return rawData
 

makeRawPointData()

def lsst.afw.geom.testUtils.TransformTestBaseClass.makeRawPointData (   nAxes,   delta = 0.123  )

static

Make one generic point

Parameters
----------
nAxes : `int`
    Number of axes in the point
delta : `float`
    Increment between axis values

Returns
-------
A list of `nAxes` floats with values `[0, delta, ..., (nAxes-1)*delta]

Definition at line 423 of file testUtils.py.

    def makeRawPointData(nAxes, delta=0.123):
        """Make one generic point
 
        Parameters
        ----------
        nAxes : `int`
            Number of axes in the point
        delta : `float`
            Increment between axis values
 
        Returns
        -------
        A list of `nAxes` floats with values `[0, delta, ..., (nAxes-1)*delta]
        """
        return [i*delta for i in range(nAxes)]
 

permuteFrameSetIter()

def lsst.afw.geom.testUtils.TransformTestBaseClass.permuteFrameSetIter (   frameSet )

static

Iterator over 0 or more frameSets with SkyFrames axes permuted

Only base and current SkyFrames are permuted. If neither the base nor
the current frame is a SkyFrame then no frames are returned.

Returns
-------
iterator over `PermutedFrameSet`

Definition at line 573 of file testUtils.py.

    def permuteFrameSetIter(frameSet):
        """Iterator over 0 or more frameSets with SkyFrames axes permuted
 
        Only base and current SkyFrames are permuted. If neither the base nor
        the current frame is a SkyFrame then no frames are returned.
 
        Returns
        -------
        iterator over `PermutedFrameSet`
        """
 
        fsInfo = FrameSetInfo(frameSet)
        if not (fsInfo.isBaseSkyFrame or fsInfo.isCurrSkyFrame):
            return
 
        permuteBaseList = [False, True] if fsInfo.isBaseSkyFrame else [False]
        permuteCurrList = [False, True] if fsInfo.isCurrSkyFrame else [False]
        for permuteBase in permuteBaseList:
            for permuteCurr in permuteCurrList:
                yield PermutedFrameSet(frameSet, permuteBase, permuteCurr)
 

setUp()

def lsst.afw.geom.testUtils.TransformTestBaseClass.setUp

(

self

)

Set up a test

Subclasses should call this method if they override setUp.

Definition at line 352 of file testUtils.py.

    def setUp(self):
        """Set up a test
 
        Subclasses should call this method if they override setUp.
        """
        # tell unittest to use the msg argument of asserts as a supplement
        # to the error message, rather than as the whole error message
        self.longMessage = True
 
        # list of endpoint class name prefixes; the full name is prefix + "Endpoint"
        self.endpointPrefixes = ("Generic", "Point2", "SpherePoint")
 
        # GoodNAxes is dict of endpoint class name prefix:
        #    tuple containing 0 or more valid numbers of axes
        self.goodNAxes = {
            "Generic": (1, 2, 3, 4),  # all numbers of axes are valid for GenericEndpoint
            "Point2": (2,),
            "SpherePoint": (2,),
        }
 
        # BadAxes is dict of endpoint class name prefix:
        #    tuple containing 0 or more invalid numbers of axes
        self.badNAxes = {
            "Generic": (),  # all numbers of axes are valid for GenericEndpoint
            "Point2": (1, 3, 4),
            "SpherePoint": (1, 3, 4),
        }
 
        # Dict of frame index: identity name for frames created by makeFrameSet
        self.frameIdentDict = {
            1: "baseFrame",
            2: "frame2",
            3: "frame3",
            4: "currFrame",
        }
 

Member Data Documentation

badNAxes

lsst.afw.geom.testUtils.TransformTestBaseClass.badNAxes

Definition at line 374 of file testUtils.py.

endpointPrefixes

lsst.afw.geom.testUtils.TransformTestBaseClass.endpointPrefixes

Definition at line 362 of file testUtils.py.

frameIdentDict

lsst.afw.geom.testUtils.TransformTestBaseClass.frameIdentDict

Definition at line 381 of file testUtils.py.

goodNAxes

lsst.afw.geom.testUtils.TransformTestBaseClass.goodNAxes

Definition at line 366 of file testUtils.py.

longMessage

lsst.afw.geom.testUtils.TransformTestBaseClass.longMessage

Definition at line 359 of file testUtils.py.

---

The documentation for this class was generated from the following file:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/afw/22.0.1-42-gca6935d93+ba5e5ca3eb/python/lsst/afw/geom/testUtils.py