def testGetVectorValue(self):
        """Test if getVector() returns the expected value.

        The test includes conformance to vector-angle conventions.
        """
        pointList = [
            ((0.0, 0.0), afwGeom.Point3D(1.0, 0.0, 0.0)),
            ((90.0, 0.0), afwGeom.Point3D(0.0, 1.0, 0.0)),
            ((0.0, 90.0), afwGeom.Point3D(0.0, 0.0, 1.0)),
        ]

        for lonLat, vector in pointList:
            # Convert to Point3D.
            point = SpherePoint(lonLat[0]*degrees, lonLat[1]*degrees)
            newVector = point.getVector()
            self.assertIsInstance(newVector, afwGeom.Point3D)
            for oldElement, newElement in zip(vector, newVector):
                self.assertAlmostEqual(oldElement, newElement)

            # Convert back to spherical.
            newLon, newLat = SpherePoint(newVector)
            self.assertAlmostEqual(newLon.asDegrees(), lonLat[0])
            self.assertAlmostEqual(newLat.asDegrees(), lonLat[1])

        # Try some un-normalized ones, too.
        pointList = [
            ((0.0, 0.0), afwGeom.Point3D(1.3, 0.0, 0.0)),
            ((90.0, 0.0), afwGeom.Point3D(0.0, 1.2, 0.0)),
            ((0.0, 90.0), afwGeom.Point3D(0.0, 0.0, 2.3)),
            ((0.0, 0.0), afwGeom.Point3D(0.5, 0.0, 0.0)),
            ((90.0, 0.0), afwGeom.Point3D(0.0, 0.7, 0.0)),
            ((0.0, 90.0), afwGeom.Point3D(0.0, 0.0, 0.9)),
        ]

        for lonLat, vector in pointList:
            # Only convert from vector to spherical.
            point = SpherePoint(vector)
            newLon, newLat = point
            self.assertAlmostEqual(lonLat[0], newLon.asDegrees())
            self.assertAlmostEqual(lonLat[1], newLat.asDegrees())
            self.assertAlmostEqual(1.0,
                                   point.getVector().distanceSquared(
                                       afwGeom.Point3D(0.0, 0.0, 0.0)))

        # Ill-defined points should be all NaN after normalization
        cleanVector = afwGeom.Point3D(0.5, -0.3, 0.2)
        badValues = [nan, inf, -inf]
        for i in range(3):
            for badValue in badValues:
                # Ensure each subtest is independent
                dirtyVector = copy.deepcopy(cleanVector)
                dirtyVector[i] = badValue
                for element in SpherePoint(dirtyVector).getVector():
                    self.assertTrue(math.isnan(element))
    def testGetVectorValue(self):
        """Test if getVector() returns the expected value.

        The test includes conformance to vector-angle conventions.
        """
        for lon, lat, vector in [
            (0.0 * degrees, 0.0 * degrees,
             lsst.sphgeom.Vector3d(1.0, 0.0, 0.0)),
            (90.0 * degrees, 0.0 * degrees,
             lsst.sphgeom.Vector3d(0.0, 1.0, 0.0)),
            (0.0 * degrees, 90.0 * degrees,
             lsst.sphgeom.Vector3d(0.0, 0.0, 1.0)),
        ]:
            for point in (
                    SpherePoint(lon, lat),
                    SpherePoint(lon.asDegrees(), lat.asDegrees(), degrees),
                    SpherePoint(lon.asRadians(), lat.asRadians(), radians),
            ):
                newVector = point.getVector()
                self.assertIsInstance(newVector, lsst.sphgeom.UnitVector3d)
                for oldElement, newElement in zip(vector, newVector):
                    self.assertAlmostEqual(oldElement, newElement)

                # Convert back to spherical.
                newLon, newLat = SpherePoint(newVector)
                self.assertAlmostEqual(newLon.asDegrees(), lon.asDegrees())
                self.assertAlmostEqual(newLat.asDegrees(), lat.asDegrees())

        # Try some un-normalized ones, too.
        pointList = [
            ((0.0, 0.0), lsst.sphgeom.Vector3d(1.3, 0.0, 0.0)),
            ((90.0, 0.0), lsst.sphgeom.Vector3d(0.0, 1.2, 0.0)),
            ((0.0, 90.0), lsst.sphgeom.Vector3d(0.0, 0.0, 2.3)),
            ((0.0, 0.0), lsst.sphgeom.Vector3d(0.5, 0.0, 0.0)),
            ((90.0, 0.0), lsst.sphgeom.Vector3d(0.0, 0.7, 0.0)),
            ((0.0, 90.0), lsst.sphgeom.Vector3d(0.0, 0.0, 0.9)),
        ]

        for lonLat, vector in pointList:
            # Only convert from vector to spherical.
            point = SpherePoint(vector)
            newLon, newLat = point
            self.assertAlmostEqual(lonLat[0], newLon.asDegrees())
            self.assertAlmostEqual(lonLat[1], newLat.asDegrees())
            vector = lsst.sphgeom.Vector3d(point.getVector())
            self.assertAlmostEqual(1.0, vector.getSquaredNorm())

        # Ill-defined points should be all NaN after normalization
        cleanValues = [0.5, -0.3, 0.2]
        badValues = [nan, inf, -inf]
        for i in range(3):
            for badValue in badValues:
                values = cleanValues[:]
                values[i] = badValue
                nonFiniteVector = lsst.sphgeom.Vector3d(*values)
                for element in SpherePoint(nonFiniteVector).getVector():
                    self.assertTrue(math.isnan(element))