def testExportPerspectiveViewCheckCamera(self):
        """
        Tests exporting a specifically positioned perspective camera. Looking
        through this camera in the Maya scene and in usdview should show a cube
        in each of the four corners of the frame.
        """
        usdCamera = self._GetUsdCamera('ViewCheck/PerspectiveCamera')

        # There should be no animation on any of the camera attributes.
        expectedPropertyTuples = [
            ('clippingRange', Gf.Vec2f(0.1, 10000.0), False),
            ('focalLength', 35.0, False),
            ('focusDistance', 5.0, False),
            ('fStop', 5.6, False),
            ('horizontalAperture', 29.6, False),
            ('horizontalApertureOffset', 0.0, False),
            ('projection', UsdGeom.Tokens.perspective, False),
            ('verticalAperture', 16.0, False),
            ('verticalApertureOffset', 0.0, False),
            ('xformOpOrder',
             Vt.TokenArray(['xformOp:translate', 'xformOp:rotateXYZ']), False),
        ]

        # There should be no animation on the transform either.
        self._ValidateUsdCamera(usdCamera, expectedPropertyTuples, False)

        # Validate the camera's xformOps at the default time.
        (translateOp, rotateOp) = usdCamera.GetOrderedXformOps()
        self.assertEqual(translateOp.GetOpType(),
                         UsdGeom.XformOp.TypeTranslate)
        self.assertEqual(rotateOp.GetOpType(), UsdGeom.XformOp.TypeRotateXYZ)

        self.assertTrue(
            Gf.IsClose(translateOp.Get(), Gf.Vec3d(-25.0, 25.0, 25.0), 1e-6))
        self.assertTrue(
            Gf.IsClose(rotateOp.Get(), Gf.Vec3f(60.0, 0.0, -135.0), 1e-6))
Пример #2
0
    def test_ComputePickRay(self):
        f = Gf.Frustum()
        f.window = Gf.Range2d(Gf.Vec2d(3, 3), Gf.Vec2d(4, 4))
        f.ComputeNarrowedFrustum(Gf.Vec2d(3, 3), Gf.Vec2d(100, 100))

        r = Gf.Frustum().ComputePickRay(Gf.Vec2d(2, 2))
        self.assertTrue(
            Gf.IsClose(r.startPoint, Gf.Vec3d(2. / 3, 2. / 3, -1. / 3),
                       0.00001))
        self.assertTrue(
            Gf.IsClose(r.direction, Gf.Vec3d(2. / 3, 2. / 3, -1. / 3),
                       0.00001))

        f = Gf.Frustum()
        f.projectionType = f.Orthographic
        r = f.ComputePickRay(Gf.Vec2d(2, 2))
        self.assertTrue(Gf.IsClose(r.startPoint, Gf.Vec3d(2, 2, -1), 0.00001))
        self.assertTrue(Gf.IsClose(r.direction, Gf.Vec3d(0, 0, -1), 0.00001))

        r = Gf.Frustum().ComputePickRay(Gf.Vec3d(0, 0, -2))
        self.assertTrue(Gf.IsClose(r.startPoint, Gf.Vec3d(0, 0, -1), 0.00001))
        self.assertTrue(Gf.IsClose(r.direction, Gf.Vec3d(0, 0, -1), 0.00001))

        r = Gf.Frustum().ComputePickRay(Gf.Vec3d(2, 2, -1))
        self.assertTrue(
            Gf.IsClose(r.startPoint, Gf.Vec3d(2. / 3, 2. / 3, -1. / 3),
                       0.00001))
        self.assertTrue(
            Gf.IsClose(r.direction, Gf.Vec3d(2. / 3, 2. / 3, -1. / 3),
                       0.00001))

        f = Gf.Frustum()
        f.projectionType = f.Orthographic
        r = f.ComputePickRay(Gf.Vec3d(2, 2, -2))
        self.assertTrue(Gf.IsClose(r.startPoint, Gf.Vec3d(2, 2, -1), 0.00001))
        self.assertTrue(Gf.IsClose(r.direction, Gf.Vec3d(0, 0, -1), 0.00001))
Пример #3
0
    def _ValidateUsdLuxShapingAPI(self):
        lightPrimPath = '/RfMLightsTest/Lights/DiskLight'
        lightPrim = self._stage.GetPrimAtPath(lightPrimPath)
        self.assertTrue(lightPrim)

        shapingAPI = UsdLux.ShapingAPI(lightPrim)
        self.assertTrue(shapingAPI)

        expectedFocus = 0.1
        self.assertTrue(
            Gf.IsClose(shapingAPI.GetShapingFocusAttr().Get(), expectedFocus,
                       1e-6))

        expectedFocusTint = Gf.Vec3f(0.1)
        self.assertTrue(
            Gf.IsClose(shapingAPI.GetShapingFocusTintAttr().Get(),
                       expectedFocusTint, 1e-6))

        expectedConeAngle = 91.0
        self.assertTrue(
            Gf.IsClose(shapingAPI.GetShapingConeAngleAttr().Get(),
                       expectedConeAngle, 1e-6))

        expectedConeSoftness = 0.1
        self.assertTrue(
            Gf.IsClose(shapingAPI.GetShapingConeSoftnessAttr().Get(),
                       expectedConeSoftness, 1e-6))

        expectedProfilePath = './DiskLight_profile.ies'
        self.assertEqual(shapingAPI.GetShapingIesFileAttr().Get(),
                         expectedProfilePath)

        expectedProfileScale = 1.1
        self.assertTrue(
            Gf.IsClose(shapingAPI.GetShapingIesAngleScaleAttr().Get(),
                       expectedProfileScale, 1e-6))
Пример #4
0
    def test_vec4d(self):
        p = Gf.Plane(Gf.Vec4d(3, 4, 0, 5))
        self.assertEqual(p.normal, Gf.Vec3d(3, 4, 0) / 5, err("normal"))
        self.assertEqual(p.distanceFromOrigin, -1, err("distanceFromOrigin"))

        pt0 = Gf.Vec3d(2, 3, 1)
        pt1 = Gf.Vec3d(5, 1, 2)
        pt2 = Gf.Vec3d(6, 0, 7)

        p = Gf.Plane(pt0, pt1, pt2)
        eqn = p.GetEquation()

        for pt in [pt0, pt1, pt2]:
            v = eqn[0] * pt[0] + eqn[1] * pt[1] + eqn[2] * pt[2] + eqn[3]
            self.assertTrue(Gf.IsClose(v, 0, 1e-12))
Пример #5
0
    def _ValidateInstanceTransforms(self, instancer, expectedXforms):
        """
        Verifies that the instance transforms of the given
        UsdGeomPointInstancer match the given expected transforms.
        """
        xforms = instancer.ComputeInstanceTransformsAtTime(
            Usd.TimeCode.Default(), Usd.TimeCode.Default())

        self.assertEqual(len(xforms), len(expectedXforms))

        for i in xrange(len(xforms)):
            xf = xforms[i]
            ex = expectedXforms[i]
            for a, b in zip(xf, ex):
                self.assertTrue(Gf.IsClose(a, b, 1e-5))
Пример #6
0
    def __init__(self, stroke, startVert, vertCount, startIndex, indexCount):  # pylint: disable=too-many-arguments
        self.stroke = stroke
        self.startVert = startVert
        self.vertCount = vertCount
        self.startIndex = startIndex
        self.indexCount = indexCount
        self.i = startVert
        self.step = 10
        self.radius = 0
        self.indicesWritten = 0
        self.growthVel = 1
        self.minHeight = self.GetVertex(0)[2]
        self.maxHeight = self.GetVertex(0)[2]
        self.avgHeight = self.GetVertex(0)[2]
        self.minLen = 10000000
        self.minPoint = self.GetVertex(0)

        minVal = (self.minPoint - worldCenter).GetLength()
        for i in range(vertCount):
            v = self.GetVertex(i)
            length = (v - worldCenter).GetLength()
            if length < minVal:
                minVal = length
                self.minPoint = v
            if Gf.IsClose(v, Gf.Vec3f(), 1e-7):
                continue
            length = Gf.Vec2f(v[0], v[2]).GetLength()
            self.minHeight = min(self.minHeight, v[1])
            self.maxHeight = max(self.minHeight, v[1])
            self.avgHeight = (self.maxHeight - self.minHeight) / 2.0
            self.minLen = min(self.minLen, length)

        # Debug visualization.
        self.minPtDebug = UsdGeom.Sphere.Define(
            stroke.prim.GetStage(),
            str(stroke.prim.GetPath()) + "/minPt" + str(startIndex),
        )
        self.minPtDebug.GetPrim().GetAttribute("purpose").Set("guide")
        attr = self.minPtDebug.GetPrim().GetAttribute(
            "primvars:displayOpacity")
        attr.Set([0.25])
        attr.SetMetadata("interpolation", "constant")
        attr = self.minPtDebug.GetPrim().GetAttribute("primvars:displayColor")
        attr.Set([Gf.Vec3f(1, 1, 1)], 0)
        attr.SetMetadata("interpolation", "constant")
        self.minPtDebug.CreateRadiusAttr(1.0)
        UsdGeom.Xform(self.minPtDebug.GetPrim()).AddTranslateOp().Set(
            self.minPoint)
Пример #7
0
def VerifyOffset(adjPrim):
    prim = adjPrim.prim
    offset = adjPrim.layerOffset

    print("Testing offset:", offset.offset, "scale:", offset.scale,
          "prim:", adjPrim.prim.GetPath())

    # When offset=1.0:
    #
    #     1.  2.                              10.
    # ----|---|-------------------------------|-------
    # t:  0   1   2   3   4   5   6   7   8   9   10
    #
    # So we expect value( offset * t ) = original_t
    #
    expectedTimes = []
    attr = prim.GetAttribute("attr")
    for t in (1.,2.,10.):
        assert t == attr.Get(offset * t)
        expectedTimes.append(offset * t)

    print("    Expected Times:", tuple(expectedTimes))
    print("    Authored Times:", attr.GetTimeSamples())
    for index, time in enumerate(attr.GetTimeSamples()):
        assert Gf.IsClose(expectedTimes[index], time, 1e-5)

    for t in (1.,2.,10.):
        stageTime = offset * t
        print("    Bracketing time samples for t=%s: %s" \
            % (stageTime, attr.GetBracketingTimeSamples(stageTime)))
        assert (stageTime, stageTime) == attr.GetBracketingTimeSamples(stageTime)

    stageTime = offset * 0.
    print("    Bracketing time samples for t=%s: %s" \
        % (stageTime, attr.GetBracketingTimeSamples(stageTime)))
    assert (offset * 1., offset * 1.) == attr.GetBracketingTimeSamples(stageTime)

    for (lo, hi) in [(1., 2.), (2., 10.)]:
        stageTime = ((offset * lo) + (offset * hi)) / 2.
        print("    Bracketing time samples for t=%s: %s" \
            % (stageTime, attr.GetBracketingTimeSamples(stageTime)))
        assert ((offset * lo), (offset *hi)) == attr.GetBracketingTimeSamples(stageTime)
        
    stageTime = offset * 11.
    print("    Bracketing time samples for t=%s: %s" \
        % (stageTime, attr.GetBracketingTimeSamples(stageTime)))
    assert (offset * 10., offset * 10.) == attr.GetBracketingTimeSamples(stageTime)
Пример #8
0
    def test_FindClosestPoint(self):
        r = Gf.Ray(Gf.Vec3d(), Gf.Vec3d(3, 4, 5))
        (p, dist) = r.FindClosestPoint(Gf.Vec3d(1, 1, 1))
        self.assertTrue(Gf.IsClose(p, Gf.Vec3d(0.72, 0.96, 1.2), 0.00001))
        self.assertTrue(Gf.IsClose(dist, 0.24, 0.00001))

        # non-intersecting case
        r = Gf.Ray(Gf.Vec3d(), Gf.Vec3d(3, 4, 5))
        l = Gf.Line(Gf.Vec3d(1, 0, 0), Gf.Vec3d(3, 3, 3))
        (intersects, rayPoint, linePoint, rayDistance, lineDistance) = \
                    Gf.FindClosestPoints(r, l)
        self.assertTrue(intersects and \
            rayPoint == Gf.Vec3d() and \
            Gf.IsClose(linePoint, Gf.Vec3d(-4./3,-7./3,-7./3), 0.00001) and \
            rayDistance == 0 and \
            Gf.IsClose(lineDistance, -4.04145188433, 0.00001))

        r = Gf.Ray(Gf.Vec3d(), Gf.Vec3d(3, 4, 5))
        l = Gf.Line(Gf.Vec3d(1, 0, 0), Gf.Vec3d(3, 4, 5))
        (intersects, rayPoint, linePoint, rayDistance, lineDistance) = \
                    Gf.FindClosestPoints(r, l)
        self.assertFalse(intersects)

        # closest point on theis line segment to the ray is going to
        # be the near end, (1,0,0)
        r = Gf.Ray(Gf.Vec3d(), Gf.Vec3d(3, 4, 5))
        l = Gf.LineSeg(Gf.Vec3d(1, 0, 0), Gf.Vec3d(3, 3, 3))
        (intersects, rayPoint, linePoint, rayDistance, lineDistance) = \
                    Gf.FindClosestPoints(r, l)
        (closestRayPtToNearEnd,
         rayDistToNearEnd) = r.FindClosestPoint(Gf.Vec3d(1, 0, 0))

        self.assertTrue(intersects and \
            Gf.IsClose(rayPoint, closestRayPtToNearEnd, 0.00001) and \
            Gf.IsClose(linePoint, Gf.Vec3d(1,0,0), 0.00001) and \
            Gf.IsClose(rayDistance, rayDistToNearEnd, 0.00001) and \
            Gf.IsClose(lineDistance, 0, 0.00001))

        r = Gf.Ray(Gf.Vec3d(), Gf.Vec3d(3, 4, 5))
        l = Gf.LineSeg(Gf.Vec3d(1, 0, 0), Gf.Vec3d(4, 4, 5))
        (intersects, rayPoint, linePoint, rayDistance, lineDistance) = \
                    Gf.FindClosestPoints(r, l)
        self.assertFalse(intersects)
Пример #9
0
    def testComputeExtent(self):
        # Create a stage.
        stage = Usd.Stage.CreateInMemory()

        # Define a Triangle.
        triangle = UsdTri.Triangle.Define(stage, "/triangle")
        self.assertTrue(triangle)
        self.assertEqual(triangle.GetSideLengthAttr().Get(), 1)

        # Compute extent & validate.
        boundable = UsdGeom.Boundable(triangle.GetPrim())
        self.assertTrue(boundable)
        extent = UsdGeom.Boundable.ComputeExtentFromPlugins(
            boundable, Usd.TimeCode.Default())
        expectedExtent = Vt.Vec3fArray(
            ((0.5, -0.28867513, 0), (0.5, 0.57735026, 0)))
        for actualValue, expectedValue in zip(extent, expectedExtent):
            self.assertTrue(Gf.IsClose(actualValue, expectedValue, 1e-5))
Пример #10
0
 def testFactor(m, expectSuccess, eps=None):
     factor = lambda m : m.Factor()
     if eps is not None:
         factor = lambda m : m.Factor(eps)
     (success, scaleOrientation, scale, rotation, \
      translation, projection) = factor(m)
     self.assertEqual(success, expectSuccess)
     factorProduct = scaleOrientation * \
                     Matrix().SetScale(scale) * \
                     scaleOrientation.GetInverse() * \
                     rotation * \
                     Matrix().SetTranslate(translation) * \
                     projection
     maxEltErr = 0
     for i in range(4):
         for j in range(4):
             maxEltErr = max(maxEltErr, abs(factorProduct[i][j] - m[i][j]))
     self.assertTrue(Gf.IsClose(maxEltErr, 0.0, 1e-5), maxEltErr)
Пример #11
0
    def test_SetFromCamera(self):
        camera = Gf.Camera()

        usdStage = Usd.Stage.CreateInMemory()
        usdCamera = UsdGeom.Camera.Define(usdStage, '/camera')
        usdCameraProj = usdCamera.GetProjectionAttr()

        # test fall-back values
        self._CheckValues(camera, usdCamera, 1.0)
        self.assertEqual(usdCameraProj.GetResolveInfo().GetSource(),
                         Usd.ResolveInfoSourceFallback)

        camera.transform = (
            Gf.Matrix4d().SetRotate(Gf.Rotation(Gf.Vec3d(1.0, 2.0, 3.0), 10.0))
            * Gf.Matrix4d().SetTranslate(Gf.Vec3d(4.0, 5.0, 6.0)))
        camera.projection = Gf.Camera.Orthographic
        camera.horizontalAperture = 5.1
        camera.verticalAperture = 2.0
        camera.horizontalApertureOffset = 0.13
        camera.verticalApertureOffset = -0.14
        camera.focalLength = 28
        camera.clippingRange = Gf.Range1f(5, 15)
        camera.clippingPlanes = [[1, 2, 3, 4], [8, 7, 6, 5]]
        camera.fStop = 1.2
        camera.focusDistance = 300

        usdCamera.SetFromCamera(camera, 1.0)

        # test assigned values
        self._CheckValues(camera, usdCamera, 1.0)
        self.assertEqual(usdCameraProj.GetResolveInfo().GetSource(),
                         Usd.ResolveInfoSourceTimeSamples)

        usdCamera.SetFromCamera(camera, 1.0)

        actual = usdCamera.GetLocalTransformation(Usd.TimeCode(1.0))
        expected = Gf.Matrix4d(0.9858929135, 0.14139860385, -0.089563373740,
                               0.0, -0.1370579618, 0.98914839500,
                               0.052920390613, 0.0, 0.0960743367,
                               -0.03989846462, 0.994574197504, 0.0, 4.0, 5.0,
                               6.0, 1.0)

        for a, e in zip(actual, expected):
            self.assertTrue(Gf.IsClose(a, e, 1e-2))
Пример #12
0
    def testExportPerspectiveCameraAnimatedTransform(self):
        usdCamera = self._GetUsdCamera('PerspCamAnimTransform')

        # There should be no animation on any of the camera attributes.
        expectedPropertyTuples = [
            ('clippingRange', Gf.Vec2f(0.1, 10000.0), False),
            ('focalLength', 35.0, False),
            ('focusDistance', 5.0, False),
            ('fStop', 5.6, False),
            ('horizontalAperture', 36.0, False),
            ('horizontalApertureOffset', 0.0, False),
            ('projection', UsdGeom.Tokens.perspective, False),
            ('verticalAperture', 24.0, False),
            ('verticalApertureOffset', 0.0, False),

            ('xformOpOrder', Vt.TokenArray(['xformOp:translate', 'xformOp:rotateXYZ']), False),
        ]

        # There SHOULD be animation on the transform.
        self._ValidateUsdCamera(usdCamera, expectedPropertyTuples, True)

        # Get the camera's xformOps.
        (translateOp, rotateOp) = usdCamera.GetOrderedXformOps()
        self.assertEqual(translateOp.GetOpType(), UsdGeom.XformOp.TypeTranslate)
        self.assertEqual(rotateOp.GetOpType(), UsdGeom.XformOp.TypeRotateXYZ)
        self.assertTrue(UsdGeom.XformCommonAPI(usdCamera))

        # The xformOps should NOT have values at the default time.
        self.assertEqual(translateOp.Get(), None)
        self.assertEqual(rotateOp.Get(), None)

        # Validate the camera's xformOps at a few non-default timecodes.
        self.assertTrue(Gf.IsClose(translateOp.Get(1), Gf.Vec3d(0.0, -5.0, 5.0), 1e-6))
        self.assertTrue(Gf.IsClose(translateOp.Get(25), Gf.Vec3d(5.0, 0.0, 5.0), 1e-6))
        self.assertTrue(Gf.IsClose(translateOp.Get(49), Gf.Vec3d(0.0, 5.0, 5.0), 1e-6))
        self.assertTrue(Gf.IsClose(translateOp.Get(73), Gf.Vec3d(-5.0, 0.0, 5.0), 1e-6))

        self.assertTrue(Gf.IsClose(rotateOp.Get(1), Gf.Vec3f(45.0, 0.0, 0.0), 1e-6))
        self.assertTrue(Gf.IsClose(rotateOp.Get(25), Gf.Vec3f(45.0, 0.0, 90.0), 1e-6))
        self.assertTrue(Gf.IsClose(rotateOp.Get(49), Gf.Vec3f(45.0, 0.0, 180.0), 1e-6))
        self.assertTrue(Gf.IsClose(rotateOp.Get(73), Gf.Vec3f(45.0, 0.0, 270.0), 1e-6))
Пример #13
0
    def _ValidatePointLight(self):
        lightPrimPath = '/pointLight1'
        lightPrim = self._stage.GetPrimAtPath(lightPrimPath)
        self.assertTrue(lightPrim)
        sphereLight = UsdLux.SphereLight(lightPrim)
        self.assertTrue(sphereLight)
        self.assertTrue(Gf.IsClose(sphereLight.GetColorAttr().Get(1), Gf.Vec3f(1, 0.5, 0.1), 1e-6))

        self.assertTrue(Gf.IsClose(sphereLight.GetIntensityAttr().Get(1), 0.5, 1e-6))
        self.assertTrue(Gf.IsClose(sphereLight.GetIntensityAttr().Get(5), 2, 1e-6))
        self.assertTrue(Gf.IsClose(sphereLight.GetSpecularAttr().Get(1), 0, 1e-6))
        self.assertTrue(Gf.IsClose(sphereLight.GetTreatAsPointAttr().Get(1), 1, 1e-6))
        self.assertTrue(Gf.IsClose(sphereLight.GetRadiusAttr().Get(1), 0, 1e-6))
    
        translateOp = sphereLight.GetOrderedXformOps()
        self.assertEqual(translateOp[0].GetOpType(), UsdGeom.XformOp.TypeTranslate)
        self.assertTrue(UsdGeom.XformCommonAPI(sphereLight))
        self.assertTrue(Gf.IsClose(translateOp[0].Get(1), Gf.Vec3d(-10, 10, 0.0), 1e-6))
Пример #14
0
    def _ValidateXformOps(self, prim, expectedTranslation=None):
        xformable = UsdGeom.Xformable(prim)
        self.assertTrue(xformable)

        xformOps = xformable.GetOrderedXformOps()

        if expectedTranslation is None:
            self.assertEqual(len(xformOps), 0)
            return xformable

        self.assertEqual(len(xformOps), 1)

        translateOp = xformOps[0]

        self.assertEqual(translateOp.GetOpName(), 'xformOp:translate')
        self.assertEqual(translateOp.GetOpType(), UsdGeom.XformOp.TypeTranslate)

        self.assertTrue(Gf.IsClose(translateOp.Get(), expectedTranslation, 1e-6))

        return xformable
Пример #15
0
    def _ValidateDiskLightXformAnimation(self):
        lightPrimPath = '/RfMLightsTest/Lights/DiskLight'
        lightPrim = self._stage.GetPrimAtPath(lightPrimPath)
        self.assertTrue(lightPrim)

        diskLight = UsdLux.DiskLight(lightPrim)
        self.assertTrue(diskLight)

        xformOps = diskLight.GetOrderedXformOps()
        self.assertEqual(len(xformOps), 1)

        translateOp = xformOps[0]

        self.assertEqual(translateOp.GetOpName(), 'xformOp:translate')
        self.assertEqual(translateOp.GetOpType(), UsdGeom.XformOp.TypeTranslate)

        for frame in xrange(int(self.START_TIMECODE), int(self.END_TIMECODE + 1.0)):
            expectedTranslation = Gf.Vec3d(1.0, float(frame), 1.0)
            self.assertTrue(
                Gf.IsClose(translateOp.Get(frame), expectedTranslation, 1e-6))
Пример #16
0
    def test_IntersectBox(self):
        box = Gf.Range3d(Gf.Vec3d(1, 1, 1), Gf.Vec3d(2, 2, 2))
        r = Gf.Ray(Gf.Vec3d(), Gf.Vec3d(1.5, 1.5, 2))
        (hit, enterDistance, exitDistance) = r.Intersect(box)
        self.assertTrue(hit and Gf.IsClose(enterDistance, 2./3, 0.00001) and \
            Gf.IsClose(exitDistance, 1, 0.00001))

        box = Gf.Range3d(Gf.Vec3d(1, 1, 1), Gf.Vec3d())
        r = Gf.Ray(Gf.Vec3d(), Gf.Vec3d(1.5, 1.5, 2))
        (hit, enterDistance, exitDistance) = r.Intersect(box)
        self.assertFalse(hit)

        box = Gf.Range3d(Gf.Vec3d(), Gf.Vec3d(1, 1, 1))
        r = Gf.Ray(Gf.Vec3d(2, 2, 2), Gf.Vec3d(1, 0, 0))
        (hit, enterDistance, exitDistance) = r.Intersect(box)
        self.assertFalse(hit)

        box = Gf.Range3d(Gf.Vec3d(), Gf.Vec3d(1, 1, 1))
        r = Gf.Ray(Gf.Vec3d(2, 0.5, 0.5), Gf.Vec3d(-1, 0, 0))
        (hit, enterDistance, exitDistance) = r.Intersect(box)
        self.assertTrue(hit)

        box = Gf.Range3d(Gf.Vec3d(), Gf.Vec3d(1, 1, 1))
        r = Gf.Ray(Gf.Vec3d(0.5, 0.5, 0.5), Gf.Vec3d(1, 0, 0))
        (hit, enterDistance, exitDistance) = r.Intersect(box)
        self.assertTrue(hit and Gf.IsClose(enterDistance, -0.5, 0.00001) and \
            Gf.IsClose(exitDistance, 0.5, 0.00001))

        box = Gf.Range3d(Gf.Vec3d(1, 1, 1), Gf.Vec3d(2, 2, 2))
        r = Gf.Ray(Gf.Vec3d(), Gf.Vec3d(5, 1, 1))
        (hit, enterDistance, exitDistance) = r.Intersect(box)
        self.assertFalse(hit)

        # Ray originates on surface of box
        box = Gf.Range3d(Gf.Vec3d(), Gf.Vec3d(1, 1, 1))
        r = Gf.Ray(Gf.Vec3d(0.5, 0.5, 1), Gf.Vec3d.ZAxis())
        (hit, enterDistance, exitDistance) = r.Intersect(box)
        self.assertTrue(hit and Gf.IsClose(enterDistance, -1.0, 0.00001) and \
            Gf.IsClose(exitDistance, 0.0, 0.00001))

        # test rays parallel to bboxes
        box = Gf.Range3d(Gf.Vec3d(1, 1, 1), Gf.Vec3d(2, 2, 2))
        r = Gf.Ray(Gf.Vec3d(1.5, 0, 0), Gf.Vec3d(0, 1, 0))
        (hit, enterDistance, exitDistance) = r.Intersect(box)
        self.assertFalse(hit)
        r = Gf.Ray(Gf.Vec3d(1.5, 0, 1.5), Gf.Vec3d(0, 1, 0))
        (hit, enterDistance, exitDistance) = r.Intersect(box)
        self.assertTrue(hit)
Пример #17
0
    def test_ComputeNarrowedFrustum(self):
        f = Gf.Frustum()
        f.projectionType = f.Orthographic
        f.Transform(Gf.Matrix4d(Gf.Vec4d(3,2,1,1)))
        narrowF = f.ComputeNarrowedFrustum(Gf.Vec2d(0, 0), Gf.Vec2d(0.1, 0.1))
        self.assertTrue(Gf.IsClose(narrowF.window.min, Gf.Vec2d(-0.3, -0.2), 0.0001))
        self.assertTrue(Gf.IsClose(narrowF.window.max, Gf.Vec2d(0.3, 0.2), 0.0001))

        narrowF = f.ComputeNarrowedFrustum(Gf.Vec3d(0, 0, -1), Gf.Vec2d(0.1, 0.1))
        self.assertTrue(Gf.IsClose(narrowF.window.min, Gf.Vec2d(-0.3, -0.2), 0.0001))
        self.assertTrue(Gf.IsClose(narrowF.window.max, Gf.Vec2d(0.3, 0.2), 0.0001))

        # Given a point behind the eye should get the same frustum back
        narrowF = f.ComputeNarrowedFrustum(Gf.Vec3d(0, 0, 1), Gf.Vec2d(0.1, 0.1))
        self.assertTrue(Gf.IsClose(narrowF.window.min, Gf.Vec2d(-3.0,-2.0), 0.0001))
        self.assertTrue(Gf.IsClose(narrowF.window.max, Gf.Vec2d(3.0,2.0), 0.0001))
    def _ValidateUsdShader(self, shader, expectedInputTuples, expectedOutputs):
        for expectedInputTuple in expectedInputTuples:
            (inputName, expectedValue) = expectedInputTuple

            shaderInput = shader.GetInput(inputName)
            self.assertTrue(shaderInput)

            if expectedValue is None:
                self.assertFalse(shaderInput.GetAttr().HasAuthoredValueOpinion())
                continue

            # Validate the input value
            value = shaderInput.Get()
            if (isinstance(value, float) or isinstance(value, Gf.Vec3f)):
                self.assertTrue(Gf.IsClose(value, expectedValue, 1e-6))
            else:
                self.assertEqual(value, expectedValue)

        outputs = {output.GetBaseName() : output.GetTypeName()
            for output in shader.GetOutputs()}

        self.assertEqual(outputs, expectedOutputs)
Пример #19
0
    def _ValidatePxrDiskLightTransformAnimation(self):
        nodePath = '|RfMLightsTest|Lights|DiskLight'

        depNodeFn = self._GetMayaDependencyNode(nodePath)

        animatedPlugs = OpenMaya.MPlugArray()
        OpenMayaAnim.MAnimUtil.findAnimatedPlugs(depNodeFn.object(),
            animatedPlugs)
        self.assertEqual(animatedPlugs.length(), 1)

        translateYPlug = animatedPlugs[0]
        self.assertEqual(translateYPlug.name(), 'DiskLight.translateY')

        animObjs = OpenMaya.MObjectArray()
        OpenMayaAnim.MAnimUtil.findAnimation(translateYPlug, animObjs)
        self.assertEqual(animObjs.length(), 1)

        animCurveFn = OpenMayaAnim.MFnAnimCurve(animObjs[0])

        for frame in xrange(int(self.START_TIMECODE), int(self.END_TIMECODE + 1.0)):
            value = animCurveFn.evaluate(OpenMaya.MTime(frame))
            self.assertTrue(Gf.IsClose(float(frame), value, 1e-6))
Пример #20
0
    def testExportPerspectiveCameraNoDepthOfField(self):
        usdCamera = self._GetUsdCamera('PerspCamNoDOF')

        expectedPropertyTuples = [
            ('clippingRange', Gf.Vec2f(0.1, 10000.0), False),
            ('focalLength', 35.000, False),
            ('horizontalAperture', 35.999928, False),
            ('horizontalApertureOffset', 0.0, False),
            ('projection', UsdGeom.Tokens.perspective, False),
            ('verticalAperture', 23.999952, False),
            ('verticalApertureOffset', 0.0, False),
        ]

        # There should be no animation on the transform.
        self._ValidateUsdCamera(usdCamera, expectedPropertyTuples, False)

        # Depth of field is disabled, which means USD fStop must be 0
        fStop = usdCamera.GetFStopAttr().Get()
        self.assertTrue(fStop == 0)

        focusDist = usdCamera.GetFocusDistanceAttr().Get()
        self.assertTrue(Gf.IsClose(focusDist, 5.0, 1e-6))
Пример #21
0
    def testPivot(self):
        """
        Tests that pivotPosition attribute doesn't interfere with the matrix
        that we get in maya when importing a usd file.
        """
        def _usdToMayaPath(usdPath):
            return str(usdPath).replace('/', '|')

        from maya import cmds
        cmds.loadPlugin('pxrUsd')
        usdFile = './pivotTests.usda'
        from pxr import Usd, UsdGeom
        stage = Usd.Stage.Open(usdFile)
        xformCache = UsdGeom.XformCache()

        cmds.usdImport(file=os.path.abspath(usdFile), primPath='/World')

        usdPaths = [
            '/World/anim/chars/SomeCharacter/Geom/Face/Eyes/LEye',
            '/World/anim/chars/SomeCharacter/Geom/Face/Eyes/LEye/Sclera_sbdv',
            '/World/anim/chars/SomeCharacter/Geom/Face/Eyes/REye/Sclera_sbdv',
            '/World/anim/chars/SomeCharacter/Geom/Hair/HairStandin/Hair/Hair_sbdv',
            '/World/anim/chars/SomeCharacter/Geom/Hair/HairStandin/Hair/HairFrontPiece_sbdv',
        ]

        for usdPath in usdPaths:
            usdMatrix = xformCache.GetLocalToWorldTransform(
                stage.GetPrimAtPath(usdPath))
            mayaPath = _usdToMayaPath(usdPath)
            mayaMatrix = Gf.Matrix4d(*cmds.xform(
                mayaPath, query=True, matrix=True, worldSpace=True))

            print 'testing matrix at', usdPath
            self.assertTrue(
                Gf.IsClose(usdMatrix.ExtractTranslation(),
                           mayaMatrix.ExtractTranslation(), self.EPSILON))
Пример #22
0
 def _CheckValues(self, camera, schema, time):
     self.assertEqual(camera.transform,
                      schema.GetLocalTransformation(Usd.TimeCode(time)))
     self.assertEqual(camera.projection,
                      self._GetSchemaProjection(schema, time))
     self.assertEqual(camera.horizontalAperture,
                      schema.GetHorizontalApertureAttr().Get(time))
     self.assertEqual(camera.verticalAperture,
                      schema.GetVerticalApertureAttr().Get(time))
     self.assertEqual(camera.horizontalApertureOffset,
                      schema.GetHorizontalApertureOffsetAttr().Get(time))
     self.assertEqual(camera.verticalApertureOffset,
                      schema.GetVerticalApertureOffsetAttr().Get(time))
     self.assertEqual(camera.focalLength,
                      schema.GetFocalLengthAttr().Get(time))
     self.assertEqual(camera.clippingRange,
                      self._GetSchemaClippingRange(schema, time))
     self.assertEqual(camera.clippingPlanes,
                      self._GetSchemaClippingPlanes(schema, time))
     self.assertTrue(
         Gf.IsClose(camera.fStop,
                    schema.GetFStopAttr().Get(time), 1e-6))
     self.assertEqual(camera.focusDistance,
                      schema.GetFocusDistanceAttr().Get(time))
Пример #23
0
    def test_ConstructFromMatrix(self):
        m = Gf.Matrix4d(0.9987016645043332, -0.035803686178599,
                        -0.036236464677155, 0.0, 0.0362364646771555,
                        0.999278702502407, 0.011357524061459, 0.0,
                        0.0358036861785999, -0.012655859557126,
                        0.999278702502407, 0.0, 3.0, -6.0, 5.0, 1.0)

        f = Gf.Frustum(m, Gf.Range2d(Gf.Vec2d(-0.22,
                                              -0.2), Gf.Vec2d(0.2, 0.33)),
                       Gf.Range1d(20, 90), Gf.Frustum.Perspective)

        f = Gf.Frustum(m, Gf.Range2d(Gf.Vec2d(-0.22,
                                              -0.2), Gf.Vec2d(0.2, 0.33)),
                       Gf.Range1d(20, 90), Gf.Frustum.Perspective)

        corners = f.ComputeCorners()
        results = (Gf.Vec3d(-2.255306906099, -9.58646139968125,
                            -14.8715637017144),
                   Gf.Vec3d(6.133787075736, -9.88721236358150,
                            -15.1759500050026),
                   Gf.Vec3d(-1.871200380521, 1.00589284684426,
                            -14.7511739466630),
                   Gf.Vec3d(6.517893601314, 0.70514188294401,
                            -15.0555602499511),
                   Gf.Vec3d(-20.648881077448, -22.13907629856565,
                            -84.4220366577152),
                   Gf.Vec3d(17.102041840815, -23.49245563611677,
                            -85.7917750225117),
                   Gf.Vec3d(-18.920401712348, 25.52651781079917,
                            -83.8802827599836),
                   Gf.Vec3d(18.830521205915, 24.17313847324806,
                            -85.2500211247801))

        self.assertEqual(len(corners), len(results))
        for i in range(len(results)):
            self.assertTrue(Gf.IsClose(corners[i], results[i], 0.0001))
    def testPayloadExpansion(self):
        # Create a new stage.
        stage = Usd.Stage.CreateInMemory()

        # Define a un-typed prim, with side length metadatum value of 5.
        prim = stage.DefinePrim("/triangle")
        prim.SetMetadata("Usd_Triangle_SideLength", 5)

        # Set payload path to ../scenes/empty.triangle.
        payloadPath = os.path.join(os.path.dirname(__file__), "..", "scenes",
                                   "empty.triangle")
        prim.SetPayload(Sdf.Payload(payloadPath))

        # Should be expanded into a mesh!
        mesh = UsdGeom.Mesh(prim)
        self.assertTrue(mesh)

        # Validate mesh attribute values.
        self.assertEqual(mesh.GetFaceVertexCountsAttr().Get(),
                         Vt.IntArray((3, )))
        self.assertEqual(mesh.GetFaceVertexIndicesAttr().Get(),
                         Vt.IntArray((
                             0,
                             1,
                             2,
                         )))

        actualPoints = mesh.GetPointsAttr().Get()
        expectedPoints = Vt.Vec3fArray((
            Gf.Vec3f(0.0, 2.88675, 0.0),
            Gf.Vec3f(-2.5, -1.44337, 0.0),
            Gf.Vec3f(2.5, -1.44337, 0.0),
        ))
        self.assertEqual(len(actualPoints), len(expectedPoints))
        for actualPoint, expectedPoint in zip(actualPoints, expectedPoints):
            self.assertTrue(Gf.IsClose(actualPoint, expectedPoint, 1e-5))
Пример #25
0
    def test_Methods(self):
        for quatType, vec3Type, closeVal in testClasses:
            q = quatType()
            self.assertEqual(quatType.GetIdentity(), quatType(1, vec3Type()))

            self.assertTrue(quatType.GetIdentity().GetLength() == 1)
            self.assertTrue(
                Gf.IsClose(
                    quatType(1, vec3Type(2, 3, 4)).GetLength(),
                    5.4772255750516612, closeVal))

            q = quatType(1, vec3Type(2, 3, 4)).GetNormalized()
            self.assertTrue(
                Gf.IsClose(q.real, 0.182574, closeVal) and Gf.IsClose(
                    q.imaginary, vec3Type(0.365148, 0.547723, 0.730297),
                    closeVal))

            q = quatType(1, vec3Type(2, 3, 4)).GetNormalized(10)
            self.assertEqual(q, quatType.GetIdentity())

            # Note that in C++, Normalize returns the length before normalization
            # but in python it returns the quaternion itself.
            q = quatType(1, vec3Type(2, 3, 4)).Normalize()
            self.assertTrue(
                Gf.IsClose(q.real, 0.182574, closeVal) and Gf.IsClose(
                    q.imaginary, vec3Type(0.365148, 0.547723, 0.730297),
                    closeVal))

            q = quatType(1, vec3Type(2, 3, 4)).Normalize(10)
            self.assertEqual(q, quatType.GetIdentity())

            q = quatType.GetIdentity()
            self.assertEqual(q, q.GetInverse())
            q = quatType(1, vec3Type(1, 2, 3)).Normalize()
            (re, im) = (q.real, q.imaginary)
            self.assertTrue(
                Gf.IsClose(q.GetInverse().real, re, closeVal)
                and Gf.IsClose(q.GetInverse().imaginary, -im, closeVal))
Пример #26
0
    def test_Methods(self):
        l = Gf.Line(Gf.Vec3d(0, 0, 0), Gf.Vec3d(1, 1, 1))
        (point, t) = l.FindClosestPoint(Gf.Vec3d(0.5, 0.5, 1))
        self.assertTrue(Gf.IsClose(point, Gf.Vec3d(2./3, 2./3, 2./3), 0.00001), err("FindClosestPoint"))
        self.assertTrue(Gf.IsClose(t, 1.1547, 0.0001), err("FindClosestPoint"))

        # (parallel case)
        l1 = Gf.Line(Gf.Vec3d(0, 0, 0), Gf.Vec3d(1, 1, 1))
        l2 = Gf.Line(Gf.Vec3d(1, 0, 0), Gf.Vec3d(1, 1, 1))
        self.assertEqual(Gf.FindClosestPoints(l1, l2)[0], False, err("FindClosestPoints"))

        l1 = Gf.Line(Gf.Vec3d(0, 0, 0), Gf.Vec3d(1, 1, 1))
        l2 = Gf.Line(Gf.Vec3d(1, 0, 0), Gf.Vec3d(1, -1, 1))
        (intersects, p1, p2, t1, t2) = Gf.FindClosestPoints(l1, l2)
        self.assertTrue(intersects, err("FindClosestPoints"))
        self.assertTrue(Gf.IsClose(p1, Gf.Vec3d(0.25, 0.25, 0.25), 0.00001), err("FindClosestPoints"))
        self.assertTrue(Gf.IsClose(p2, Gf.Vec3d(0.75, 0.25, -0.25), 0.00001), err("FindClosestPoints"))
        self.assertTrue(Gf.IsClose(t1, 0.433012701892, 0.00001))
        self.assertTrue(Gf.IsClose(t2, -0.433012701892, 0.00001))
Пример #27
0
    def _ValidateMayaLightShaping(self):
        nodePath = '|RfMLightsTest|Lights|DiskLight|DiskLightShape'

        expectedFocus = 0.1
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.emissionFocus' % nodePath),
                       expectedFocus, 1e-6))

        expectedFocusTint = 0.1
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.emissionFocusTintR' % nodePath),
                       expectedFocusTint, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.emissionFocusTintG' % nodePath),
                       expectedFocusTint, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.emissionFocusTintB' % nodePath),
                       expectedFocusTint, 1e-6))

        expectedConeAngle = 91.0
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.coneAngle' % nodePath),
                       expectedConeAngle, 1e-6))

        expectedConeSoftness = 0.1
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.coneSoftness' % nodePath),
                       expectedConeSoftness, 1e-6))

        expectedProfilePath = './DiskLight_profile.ies'
        self.assertEqual(cmds.getAttr('%s.iesProfile' % nodePath),
                         expectedProfilePath)

        expectedProfileScale = 1.1
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.iesProfileScale' % nodePath),
                       expectedProfileScale, 1e-6))
Пример #28
0
    def test_Operators(self):
        for quatType, vec3Type, closeVal in testClasses:
            q1 = quatType(1, vec3Type(2, 3, 4))
            q2 = quatType(1, vec3Type(2, 3, 4))
            self.assertEqual(q1, q2)
            self.assertFalse(q1 != q2)
            q2.real = 2
            self.assertTrue(q1 != q2)

            q = quatType(1, vec3Type(2, 3, 4)) * quatType.GetIdentity()
            self.assertEqual(q, quatType(1, vec3Type(2, 3, 4)))

            q = quatType(1, vec3Type(2, 3, 4))
            q_original = q
            q *= quatType.GetIdentity()
            self.assertEqual(q, quatType(1, vec3Type(2, 3, 4)))
            self.assertTrue(q is q_original)

            q *= 10
            self.assertEqual(q, quatType(10, vec3Type(20, 30, 40)))
            self.assertTrue(q is q_original)
            q = q * 10
            self.assertEqual(q, quatType(100, vec3Type(200, 300, 400)))
            q = 10 * q
            self.assertEqual(q, quatType(1000, vec3Type(2000, 3000, 4000)))
            q_original = q
            q /= 100
            self.assertEqual(q, quatType(10, vec3Type(20, 30, 40)))
            self.assertTrue(q is q_original)
            q = q / 10
            self.assertEqual(q, quatType(1, vec3Type(2, 3, 4)))

            q_original = q
            q += q
            self.assertEqual(q, quatType(2, vec3Type(4, 6, 8)))
            self.assertTrue(q is q_original)

            q -= quatType(1, vec3Type(2, 3, 4))
            self.assertEqual(q, quatType(1, vec3Type(2, 3, 4)))
            self.assertTrue(q is q_original)

            q = q + q
            self.assertEqual(q, quatType(2, vec3Type(4, 6, 8)))

            q = q - quatType(1, vec3Type(2, 3, 4))
            self.assertEqual(q, quatType(1, vec3Type(2, 3, 4)))

            q = q * q
            self.assertEqual(q, quatType(-28, vec3Type(4, 6, 8)))

            q1 = quatType(1, vec3Type(2, 3, 4)).GetNormalized()
            q2 = quatType(4, vec3Type(3, 2, 1)).GetNormalized()
            self.assertEqual(Gf.Slerp(0, q1, q2), q1)
            self.assertEqual(Gf.Slerp(1, q1, q2), q2)
            q = Gf.Slerp(0.5, q1, q2)
            self.assertTrue(
                Gf.IsClose(q.real, 0.5, closeVal)
                and Gf.IsClose(q.imaginary, vec3Type(0.5, 0.5, 0.5), closeVal))

            # code coverage goodness
            q1 = quatType(0, vec3Type(1, 1, 1))
            q2 = quatType(0, vec3Type(-1, -1, -1))
            q = Gf.Slerp(0.5, q1, q2)
            self.assertTrue(
                Gf.IsClose(q.real, 0, closeVal)
                and Gf.IsClose(q.imaginary, vec3Type(1, 1, 1), closeVal))

            q1 = quatType(0, vec3Type(1, 1, 1))
            q2 = quatType(0, vec3Type(1, 1, 1))
            q = Gf.Slerp(0.5, q1, q2)
            self.assertTrue(
                Gf.IsClose(q.real, 0, closeVal)
                and Gf.IsClose(q.imaginary, vec3Type(1, 1, 1), closeVal))

            self.assertEqual(q, eval(repr(q)))

            self.assertTrue(len(str(quatType())))

            if quatType is Gf.Quaternion:
                # The remaining tests are not for Gf.Quaternion
                continue

            q1 = quatType(1, [2, 3, 4])
            q2 = quatType(2, [3, 4, 5])

            self.assertTrue(Gf.IsClose(Gf.Dot(q1, q2), 40, closeVal))

            # GetConjugate and Transform only exist on Quatd, Quatf, and Quath
            q = quatType(1, vec3Type(2, 3, 4)).GetConjugate()
            self.assertEqual(q, quatType(1, -vec3Type(2, 3, 4)))

            # q is a 90 degree rotation around Z axis.
            theta = math.radians(90)
            cosHalfTheta = math.cos(theta / 2)
            sinHalfTheta = math.sin(theta / 2)
            q = quatType(cosHalfTheta, sinHalfTheta * vec3Type(0, 0, 1))
            p = vec3Type(1.0, 0.0, 0.0)  # point on the x-axis

            r1 = (q * quatType(0, p) * q.GetInverse()).imaginary
            r2 = q.Transform(p)
            self.assertTrue(
                Gf.IsClose(r1, vec3Type(0.0, 1.0, 0.0), closeVal)
                and Gf.IsClose(r1, r2, closeVal))
Пример #29
0
    def _ValidateMayaAreaLight(self):
        nodePath = 'areaLight1'
        depNodeFn = self._GetMayaDependencyNode(nodePath)

        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.translateX' % nodePath), 8, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.translateY' % nodePath), 0, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.translateZ' % nodePath), 10, 1e-6))

        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.rotateX' % nodePath), 0, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.rotateY' % nodePath), 23, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.rotateZ' % nodePath), 0, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.scaleX' % nodePath), 4, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.scaleY' % nodePath), 3, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.scaleZ' % nodePath), 2, 1e-6))

        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.colorR' % nodePath), 0.8, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.colorG' % nodePath), 0.7, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.colorB' % nodePath), 0.6, 1e-6))
        if getMayaAPIVersion() > 2019:
            self.assertTrue(cmds.getAttr('%s.normalize' % nodePath) == 0)
Пример #30
0
    def _ValidateMayaSpotLight(self):
        nodePath = 'spotLight1'
        depNodeFn = self._GetMayaDependencyNode(nodePath)

        self.assertTrue(cmds.getAttr('%s.emitDiffuse' % nodePath) == 0)
        self.assertTrue(cmds.getAttr('%s.emitSpecular' % nodePath) == 1)

        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.translateX' % nodePath), 10, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.translateY' % nodePath), 7, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.translateZ' % nodePath), -8, 1e-6))

        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.rotateX' % nodePath), -45, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.rotateY' % nodePath), 90, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.rotateZ' % nodePath), -5, 1e-6))

        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.colorR' % nodePath), 0.3, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.colorG' % nodePath), 1, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.colorB' % nodePath), 0.2, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.intensity' % nodePath), 0.8, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.dropoff' % nodePath), 8, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.coneAngle' % nodePath), 30, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.penumbraAngle' % nodePath), 10, 1e-6))
        # verify the animation is imported properly, check at frame 5
        cmds.currentTime(5)
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.colorR' % nodePath), 0, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.colorG' % nodePath), 0.2, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.colorB' % nodePath), 0.1, 1e-6))

        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.translateX' % nodePath), 5, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.translateY' % nodePath), 3, 1e-6))
        self.assertTrue(
            Gf.IsClose(cmds.getAttr('%s.translateZ' % nodePath), 8, 1e-6))
        cmds.currentTime(1)