def testSerialisationWithoutRepr( self ) :
# Check that we can serialise plug values even when the
# stored `IECore::Object` does not have a suitable
# implementation of `repr()`.
v1 = IECore.TransformationMatrixfData(
IECore.TransformationMatrixf(
imath.V3f( 1, 2, 3 ),
imath.Eulerf(),
imath.V3f( 1, 1, 1 )
)
)
v2 = IECore.TransformationMatrixfData(
IECore.TransformationMatrixf(
imath.V3f( 4, 5, 6 ),
imath.Eulerf(),
imath.V3f( 2, 2, 2 )
)
)
v3 = IECore.CompoundObject( {
"a" : IECore.IntData( 10 ),
"b" : v1,
"c" : v2,
"d" : IECore.StringData( "test" ),
} )
with self.assertRaises( Exception ) :
eval( repr( v1 ) )
s = Gaffer.ScriptNode()
s["n"] = Gaffer.Node()
s["n"]["user"]["p1"] = Gaffer.ObjectPlug( defaultValue = v1, flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic )
s["n"]["user"]["p2"] = Gaffer.ObjectPlug( defaultValue = v2, flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic )
s["n"]["user"]["p3"] = Gaffer.ObjectPlug( defaultValue = v3, flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic )
s2 = Gaffer.ScriptNode()
s2.execute( s.serialise() )
self.assertEqual( s2["n"]["user"]["p1"].defaultValue(), v1 )
self.assertEqual( s2["n"]["user"]["p2"].defaultValue(), v2 )
self.assertEqual( s2["n"]["user"]["p3"].defaultValue(), v3 )
self.assertEqual( s2["n"]["user"]["p1"].getValue(), v1 )
self.assertEqual( s2["n"]["user"]["p2"].getValue(), v2 )
self.assertEqual( s2["n"]["user"]["p3"].getValue(), v3 )
s["n"]["user"]["p1"].setValue( v2 )
s["n"]["user"]["p2"].setValue( v3 )
s["n"]["user"]["p3"].setValue( v1 )
s2 = Gaffer.ScriptNode()
s2.execute( s.serialise() )
self.assertEqual( s2["n"]["user"]["p1"].defaultValue(), v1 )
self.assertEqual( s2["n"]["user"]["p2"].defaultValue(), v2 )
self.assertEqual( s2["n"]["user"]["p3"].defaultValue(), v3 )
self.assertEqual( s2["n"]["user"]["p1"].getValue(), v2 )
self.assertEqual( s2["n"]["user"]["p2"].getValue(), v3 )
self.assertEqual( s2["n"]["user"]["p3"].getValue(), v1 )
def testComparison(self): """Test TransformationMatrixfData comparison""" a = IECore.TransformationMatrixfData() b = IECore.TransformationMatrixfData() self.assertEqual( a, b ) b.value = IECore.TransformationMatrixf( imath.V3f( 0.00001, 0, 0 ), imath.Eulerf(), imath.V3f(0,0,0) ) self.assertNotEqual( a, b ) a.value = IECore.TransformationMatrixf( imath.V3f( 0.00001, 0, 0 ), imath.Eulerf(), imath.V3f(0,0,0) ) self.assertEqual( a, b )
def testOrientation(self):
script = Gaffer.ScriptNode()
script["cube"] = GafferScene.Cube()
script["cube"]["transform"]["rotate"]["y"].setValue(90)
script["group"] = GafferScene.Group()
script["group"]["in"][0].setInput(script["cube"]["out"])
script["group"]["transform"]["rotate"]["y"].setValue(90)
view = GafferSceneUI.SceneView()
view["in"].setInput(script["group"]["out"])
GafferSceneUI.ContextAlgo.setSelectedPaths(
view.getContext(), IECore.PathMatcher(["/group/cube"]))
tool = GafferSceneUI.RotateTool(view)
tool["active"].setValue(True)
# Local
tool["orientation"].setValue(tool.Orientation.Local)
with Gaffer.UndoScope(script):
tool.rotate(imath.Eulerf(0, 0, 90))
self.assertTrue(
imath.V3f(0, 1, 0).equalWithAbsError(
imath.V3f(1, 0, 0) *
script["group"]["out"].fullTransform("/group/cube"), 0.000001))
script.undo()
# Parent
tool["orientation"].setValue(tool.Orientation.Parent)
with Gaffer.UndoScope(script):
tool.rotate(imath.Eulerf(90, 0, 0))
self.assertTrue(
imath.V3f(0, 1, 0).equalWithAbsError(
imath.V3f(1, 0, 0) *
script["group"]["out"].fullTransform("/group/cube"), 0.000001))
script.undo()
# World
tool["orientation"].setValue(tool.Orientation.World)
with Gaffer.UndoScope(script):
tool.rotate(imath.Eulerf(0, 0, 90))
self.assertTrue(
imath.V3f(0, -1, 0).equalWithAbsError(
imath.V3f(1, 0, 0) *
script["group"]["out"].fullTransform("/group/cube"), 0.000001))
def testTransform(self):
"""Test TransformationMatrixf transform"""
a = IECore.TransformationMatrixf()
a.scale = imath.V3f(2, 2, 2)
self.assertEqual(a.transform, imath.M44f().scale(imath.V3f(2, 2, 2)))
a.rotate = imath.Eulerf(0.2, 0.2, 0.2)
self.assertTrue(
a.transform.equalWithAbsError(
imath.M44f().scale(imath.V3f(2, 2, 2)) *
imath.Eulerf(0.2, 0.2, 0.2).toMatrix44(), 0.01))
def testNegativeLocalScale(self):
script = Gaffer.ScriptNode()
script["plane"] = GafferScene.Plane()
script["plane"]["transform"]["scale"]["z"].setValue(-10)
view = GafferSceneUI.SceneView()
view["in"].setInput(script["plane"]["out"])
GafferSceneUI.ContextAlgo.setSelectedPaths(
view.getContext(), IECore.PathMatcher(["/plane"]))
tool = GafferSceneUI.RotateTool(view)
tool["active"].setValue(True)
tool["orientation"].setValue(tool.Orientation.Local)
# We want the direction of the handles to reflect the
# flipped scale, but not its magnitude.
self.assertTrue(tool.handlesTransform().equalWithAbsError(
imath.M44f().scale(imath.V3f(1, 1, -1)), 0.000001))
# And the handles need to move the object in the right
# direction still.
with Gaffer.UndoScope(script):
tool.rotate(imath.Eulerf(0, 45, 0))
self.assertTrue(script["plane"]["transform"]
["rotate"].getValue().equalWithAbsError(
imath.V3f(0, -45, 0), 0.0001))
script.undo()
# When orientation is Parent or World, the scale should
# not be reflected in the handles.
for orientation in (tool.Orientation.World, tool.Orientation.Parent):
tool["orientation"].setValue(orientation)
self.assertEqual(tool.handlesTransform(), imath.M44f())
with Gaffer.UndoScope(script):
tool.rotate(imath.Eulerf(0, 45, 0))
self.assertTrue(script["plane"]["transform"]
["rotate"].getValue().equalWithAbsError(
imath.V3f(0, 45, 0), 0.0001))
script.undo()
def testConvertsToPointsPrimitive(self):
self.makeScene()
converter = IECoreMaya.FromMayaDagNodeConverter.create("instancer1")
convertedPoints = converter.convert()
self.assertTrue(
convertedPoints.isInstanceOf(IECoreScene.TypeId.PointsPrimitive))
self.assertEqual(convertedPoints.numPoints, 4)
self.assertUnorderedEqual(
convertedPoints.keys(),
['P', 'age', 'id', 'instances', 'instanceType', 'orient'])
self.assertEqual(convertedPoints["P"].data[0], imath.V3f(4, 0, 0))
self.assertEqual(convertedPoints["P"].data[1], imath.V3f(4, 4, 0))
self.assertEqual(convertedPoints["P"].data[2], imath.V3f(0, 4, 0))
self.assertEqual(convertedPoints["P"].data[3], imath.V3f(0, 0, 0))
self.assertEqual(convertedPoints["id"].data[0], 0)
self.assertEqual(convertedPoints["id"].data[1], 1)
self.assertEqual(convertedPoints["id"].data[2], 2)
self.assertEqual(convertedPoints["id"].data[3], 3)
self.assertEqual(convertedPoints["age"].data[0], 0.0)
self.assertEqual(convertedPoints["age"].data[1], 0.0)
self.assertEqual(convertedPoints["age"].data[2], 0.0)
self.assertEqual(convertedPoints["age"].data[3], 0.0)
# instance indices to ensure we can instance the correct object
self.assertEqual(convertedPoints["instanceType"].data[0], 0)
self.assertEqual(convertedPoints["instanceType"].data[1], 1)
self.assertEqual(convertedPoints["instanceType"].data[2], 0)
self.assertEqual(convertedPoints["instanceType"].data[3], 1)
# rotation is converted to orient
self.assertEqual(convertedPoints["orient"].data[0],
imath.Eulerf(math.pi / 4.0, 0, 0).toQuat())
self.assertEqual(convertedPoints["orient"].data[1],
imath.Eulerf(0, math.pi / 4.0, 0).toQuat())
self.assertEqual(convertedPoints["orient"].data[2],
imath.Eulerf(0, 0, math.pi / 4.0).toQuat())
self.assertEqual(
convertedPoints["orient"].data[3],
imath.Eulerf(math.pi / 4.0, math.pi / 4.0, 0).toQuat())
# check we're capturing the locations in maya we're instancing
self.assertEqual(convertedPoints["instances"].data,
IECore.StringVectorData(['/pCube1', '/pSphere1']))
def testStaticPlugSerialisationWithoutRepr( self ) :
# This exposed a bug not exposed by `testSerialisationWithoutRepr()`. In
# this case the only part of the serialisation that requires `import
# IECore` is the value itself, exposing a bug where the import was not
# serialised.
value = IECore.CompoundObject( {
"a" : IECore.TransformationMatrixfData(
IECore.TransformationMatrixf(
imath.V3f( 1, 2, 3 ),
imath.Eulerf(),
imath.V3f( 1, 1, 1 )
)
)
} )
with self.assertRaises( Exception ) :
eval( repr( v1 ) )
s = Gaffer.ScriptNode()
s["n"] = self.TypedObjectPlugNode()
s["n"]["p"].setValue( value )
s2 = Gaffer.ScriptNode()
s2.execute( s.serialise() )
self.assertEqual( s2["n"]["p"].getValue(), s["n"]["p"].getValue() )
def testTransformationMatrixConverter(self):
sphereTransform = maya.cmds.polySphere()[0]
radToAng = 180. / 3.14159265
maya.cmds.setAttr(str(sphereTransform) + ".rotate",
-1000 * radToAng,
30 * radToAng,
100 * radToAng,
type="double3")
## \todo This section sometimes fails due to use of the unpredictable default conversion (see FromMayaObjectConverter.h
# for a description). We probably need to remove the default conversion so that people aren't exposed to it, or fix it
# so we can define which the default conversion is.
converter = IECoreMaya.FromMayaConverter.create(str(sphereTransform))
res = converter.convert()
self.assertTrue(not res.isInstanceOf(
IECore.TransformationMatrixfData.staticTypeId()))
self.assertTrue(not res.isInstanceOf(
IECore.TransformationMatrixdData.staticTypeId()))
# test TransformationMatrixData converter
converter = IECoreMaya.FromMayaConverter.create(
str(sphereTransform), IECore.TypeId.TransformationMatrixfData)
self.assertTrue(converter)
transform = converter.convert()
self.assertTrue(
transform.isInstanceOf(
IECore.TransformationMatrixfData.staticTypeId()))
self.assertAlmostEqual(
(transform.value.rotate - imath.Eulerf(-1000, 30, 100)).length(),
0, 2)
def testMultiplication(self):
vectorTypes = [
IECore.V3fVectorData(
[imath.V3f(1), imath.V3f(2),
imath.V3f(3)], IECore.GeometricData.Interpretation.Vector),
IECore.V3dVectorData(
[imath.V3d(1), imath.V3d(2),
imath.V3d(3)], IECore.GeometricData.Interpretation.Vector),
]
matrixTypes = [
IECore.M33fData(imath.M33f() * 3),
IECore.M33dData(imath.M33d() * 3),
IECore.M44fData(imath.M44f().scale(imath.V3f(3))),
IECore.M44dData(imath.M44d().scale(imath.V3d(3))),
IECore.TransformationMatrixfData(
IECore.TransformationMatrixf(imath.V3f(3), imath.Eulerf(),
imath.V3f(0))),
IECore.TransformationMatrixdData(
IECore.TransformationMatrixd(imath.V3d(3), imath.Eulerd(),
imath.V3d(0))),
]
for vector in vectorTypes:
targetVector = vector.copy()
for i in range(len(targetVector)):
targetVector[i] = targetVector[i] * 3
for matrix in matrixTypes:
res = IECore.MatrixMultiplyOp()(object=vector.copy(),
matrix=matrix)
if res == targetVector:
continue
raise Exception("Error testing vector " + str(type(vector)) +
" against matrix " + str(type(matrix)) +
". Resulted " + str(res))
def testTransformWithRotation(self):
script = Gaffer.ScriptNode()
script["plane"] = GafferScene.Plane()
script["transformFilter"] = GafferScene.PathFilter()
script["transformFilter"]["paths"].setValue(
IECore.StringVectorData(["/plane"]))
script["transform"] = GafferScene.Transform()
script["transform"]["in"].setInput(script["plane"]["out"])
script["transform"]["filter"].setInput(
script["transformFilter"]["out"])
script["transform"]["transform"]["rotate"]["y"].setValue(90)
view = GafferSceneUI.SceneView()
view["in"].setInput(script["transform"]["out"])
GafferSceneUI.ContextAlgo.setSelectedPaths(
view.getContext(), IECore.PathMatcher(["/plane"]))
tool = GafferSceneUI.RotateTool(view)
tool["active"].setValue(True)
tool.rotate(imath.Eulerf(90, 0, 0))
self.assertTrue(
imath.V3f(0, 1, 0).equalWithAbsError(
imath.V3f(1, 0, 0) *
script["transform"]["out"].fullTransform("/plane"), 0.000001))
self.assertTrue(
imath.V3f(0, 0, 1).equalWithAbsError(
imath.V3f(0, 1, 0) *
script["transform"]["out"].fullTransform("/plane"), 0.000001))
def testGlobalTransform(self):
g = IECoreScene.Group()
childGroup = IECoreScene.Group()
g.addChild(childGroup)
parentTransform = IECore.TransformationMatrixf()
parentTransform.rotate = imath.Eulerf(0, 3.1415926 / 2, 0)
childTransform = IECore.TransformationMatrixf()
childTransform.translate = imath.V3f(1, 0, 2)
childGroup.setTransform(
IECoreScene.MatrixTransform(childTransform.transform))
g.setTransform(IECoreScene.MatrixTransform(parentTransform.transform))
# child group's translation should have been rotated 90 degrees about the y axis:
s = imath.V3f()
h = imath.V3f()
r = imath.V3f()
childGroupGlobalTranslation = imath.V3f()
childGroup.globalTransformMatrix().extractSHRT(
s, h, r, childGroupGlobalTranslation)
self.assertAlmostEqual(childGroupGlobalTranslation.x, 2, 4)
self.assertAlmostEqual(childGroupGlobalTranslation.y, 0, 4)
self.assertAlmostEqual(childGroupGlobalTranslation.z, -1, 4)
def testConstructors(self):
"""Test TransformationMatrixfData constructors"""
a = IECore.TransformationMatrixfData()
self.assertEqual(a.value, IECore.TransformationMatrixf())
a = IECore.TransformationMatrixfData(
IECore.TransformationMatrixf(imath.V3f(2, 2, 2), imath.Eulerf(),
imath.V3f(1, 0, 0)))
self.assertEqual(a.value.scale, imath.V3f(2, 2, 2))
def testConstructors(self): """Test TransformationMatrixf constructors""" a = IECore.TransformationMatrixf() self.assertEqual( a.transform, imath.M44f() ) a = IECore.TransformationMatrixf( imath.V3f( 2, 2, 2 ), imath.Eulerf(), imath.V3f( 1, 0, 0 ) ) self.assertTrue( a.transform.equalWithAbsError( imath.M44f().scale( imath.V3f(2,2,2) ) * imath.M44f().translate( imath.V3f(1,0,0) ), 0.01) ) b = IECore.TransformationMatrixf( a ) self.assertEqual( a.transform, b.transform )
def testAngleOrder(self):
"""Test Eulerf angleOrder"""
e = imath.Eulerf()
o = e.angleOrder()
self.assertIsInstance(o, imath.V3i)
self.assertEqual(len(o), 3)
def testCopy(self):
"""Test TransformationMatrixfData copy"""
a = IECore.TransformationMatrixfData(
IECore.TransformationMatrixf(imath.V3f(2, 2, 2), imath.Eulerf(),
imath.V3f(1, 0, 0)))
self.assertEqual(a.value.scale, imath.V3f(2, 2, 2))
b = a.copy()
a.value = IECore.TransformationMatrixf()
self.assertEqual(b.value.scale, imath.V3f(2, 2, 2))
self.assertEqual(a.value.scale, imath.V3f(1, 1, 1))
def testOrder(self):
"""Test Eulerf order"""
self.assertEqual(len(imath.Eulerf.Order.values), 24)
e = imath.Eulerf()
for order in imath.Eulerf.Order.values.values():
e.setOrder(order)
self.assertEqual(e.order(), order)
def testIO(self):
"""Test TransformationMatrixfData IO"""
a = IECore.TransformationMatrixfData(
IECore.TransformationMatrixf(imath.V3f(2, 3, 4), imath.Eulerf(),
imath.V3f(1, 2, 3)))
w = IECore.ObjectWriter(a, self.testFile)
w.write()
r = IECore.ObjectReader(self.testFile)
b = r.read()
self.assertEqual(a, b)
def test(self):
tm = IECore.TransformationMatrixfData()
p = IECore.TransformationMatrixfParameter(
name="f",
description="d",
defaultValue=tm,
)
p.validate()
self.assertEqual(p.name, "f")
self.assertEqual(p.description, "d")
self.assertEqual(p.valueValid()[0], True)
self.assertTrue(isinstance(p.getTypedValue().translate, imath.V3f))
self.assertEqual(p.getTypedValue().translate, imath.V3f(0, 0, 0))
self.assertEqual(p.getTypedValue().rotate, imath.Eulerf(0, 0, 0))
self.assertEqual(p.getTypedValue().rotationOrientation,
imath.Quatf(1, 0, 0, 0))
self.assertEqual(p.getTypedValue().scale, imath.V3f(1, 1, 1))
self.assertEqual(p.getTypedValue().shear, imath.V3f(0, 0, 0))
self.assertEqual(p.getTypedValue().rotatePivot, imath.V3f(0, 0, 0))
self.assertEqual(p.getTypedValue().rotatePivotTranslation,
imath.V3f(0, 0, 0))
self.assertEqual(p.getTypedValue().scalePivot, imath.V3f(0, 0, 0))
self.assertEqual(p.getTypedValue().scalePivotTranslation,
imath.V3f(0, 0, 0))
tm = IECore.TransformationMatrixdData()
p = IECore.TransformationMatrixdParameter(
name="f",
description="d",
defaultValue=tm,
)
p.validate()
self.assertEqual(p.name, "f")
self.assertEqual(p.description, "d")
self.assertEqual(p.valueValid()[0], True)
self.assertTrue(isinstance(p.getTypedValue().translate, imath.V3d))
self.assertEqual(p.getTypedValue().translate, imath.V3d(0, 0, 0))
self.assertEqual(p.getTypedValue().rotate, imath.Eulerd(0, 0, 0))
self.assertEqual(p.getTypedValue().rotationOrientation,
imath.Quatd(1, 0, 0, 0))
self.assertEqual(p.getTypedValue().scale, imath.V3d(1, 1, 1))
self.assertEqual(p.getTypedValue().shear, imath.V3d(0, 0, 0))
self.assertEqual(p.getTypedValue().rotatePivot, imath.V3d(0, 0, 0))
self.assertEqual(p.getTypedValue().rotatePivotTranslation,
imath.V3d(0, 0, 0))
self.assertEqual(p.getTypedValue().scalePivot, imath.V3d(0, 0, 0))
self.assertEqual(p.getTypedValue().scalePivotTranslation,
imath.V3d(0, 0, 0))
def testCanChangeInstancerRotationUnits( self ) : self.makeRotationOrderOrUnitScene( 0, True ) converter = IECoreMaya.FromMayaDagNodeConverter.create( "instancer1" ) convertedPoints = converter.convert() self.assertTrue( convertedPoints.isInstanceOf( IECoreScene.TypeId.PointsPrimitive ) ) self.assertEqual( convertedPoints.numPoints, 1 ) self.assertUnorderedEqual( convertedPoints.keys(), ['P', 'age', 'id', 'instances', 'instanceType', 'orient'] ) self.assertEqual( convertedPoints["orient"].data[0], imath.Eulerf( 90.0, 90.0, 0, imath.Eulerf.XYZ ).toQuat() )
def testInterpolation(self):
"""Test TranformationMatrixfData interpolation"""
a = IECore.TransformationMatrixfData()
b = IECore.TransformationMatrixfData(
IECore.TransformationMatrixf(imath.V3f(2, 3, 4), imath.Eulerf(),
imath.V3f(1, 2, 3)))
c = IECore.linearObjectInterpolation(a, b, 0.5)
self.assertEqual(type(c), IECore.TransformationMatrixfData)
self.assertTrue(
c.value.scale.equalWithAbsError(imath.V3f(1.5, 2, 2.5), 0.01))
self.assertTrue(
c.value.translate.equalWithAbsError(imath.V3f(0.5, 1, 1.5), 0.01))
def testGettingKnobValues(self):
params = KnobConvertersTest.__parameters()
knobHolder = KnobConvertersTest.KnobHolder()
IECoreNuke.createKnobsFromParameter(knobHolder, params)
knobs = knobHolder.knobs()
IECoreNuke.setParameterFromKnobs(knobHolder, params)
self.assertEqual(params["A"].getNumericValue(), 1)
self.assertEqual(params["B"]["C"].getNumericValue(), 2.0)
self.assertEqual(params["B"]["D"].getNumericValue(), 3.0)
knobs["parm_A"].setValue(10)
knobs["parm_B_C"].setValue(20.0)
knobs["parm_B_D"].setValue(30.0)
knobs["parm_E"].setValue("40")
knobs["parm_F_G"].setValue("50 60 70")
knobs["parm_F_H"].setValue("80")
knobs["parm_F_I"].setValue("90")
knobs["parm_J"].setValue("100\n110\n120")
knobs["parm_K"].setValue("/tmp2/test.dpx")
knobs["parm_L"].setValue("/tmp2")
knobs["parm_M"].setValue("/tmp2/test.%02d.dpx")
knobs["parm_N"].setValue(False)
knobs["parm_O"].setValue("preset3")
IECoreNuke.setParameterFromKnobs(knobHolder, params)
self.assertEqual(params["A"].getNumericValue(), 10)
self.assertEqual(params["B"]["C"].getNumericValue(), 20.0)
self.assertEqual(params["B"]["D"].getNumericValue(), 30.0)
self.assertEqual(params["E"].getTypedValue(), "40")
self.assertEqual(params["F"]["G"].getValue(),
IECore.FloatVectorData([50, 60, 70]))
self.assertEqual(params["F"]["H"].getValue(),
IECore.IntVectorData([80]))
self.assertEqual(params["F"]["I"].getValue(),
IECore.DoubleVectorData([90]))
self.assertEqual(params["J"].getValue(),
IECore.StringVectorData(["100", "110", "120"]))
self.assertEqual(params["K"].getTypedValue(), "/tmp2/test.dpx")
self.assertEqual(params["L"].getTypedValue(), "/tmp2")
self.assertEqual(params["M"].getTypedValue(), "/tmp2/test.##.dpx")
self.assertEqual(params["N"].getTypedValue(), False)
self.assertEqual(
params["O"].getValue(),
IECore.TransformationMatrixfData(
IECore.TransformationMatrixf(imath.V3f(1), imath.Eulerf(),
imath.V3f(4))))
# raises exception when trying to convert an invalid file sequence syntax
knobs["parm_M"].setValue("/tmp2/test.%2d.dpx")
self.assertRaises(RuntimeError, IECoreNuke.setParameterFromKnobs,
knobHolder, params)
def testExtract(self):
"""Test Eulerf extract"""
e = imath.Eulerf()
e.extract(imath.M33f())
e.extract(imath.M44f())
e.extract(imath.Quatf())
m = e.toMatrix33()
m = e.toMatrix44()
q = e.toQuat()
v = e.toXYZVector()
def testInteractionWithParentConstraint(self):
script = Gaffer.ScriptNode()
script["sphere"] = GafferScene.Sphere()
script["cube"] = GafferScene.Cube()
script["cube"]["transform"]["translate"].setValue(imath.V3f(5, 5, 0))
script["cube"]["transform"]["rotate"]["x"].setValue(90)
script["parent"] = GafferScene.Parent()
script["parent"]["in"].setInput(script["sphere"]["out"])
script["parent"]["children"][0].setInput(script["cube"]["out"])
script["parent"]["parent"].setValue("/")
script["sphereFilter"] = GafferScene.PathFilter()
script["sphereFilter"]["paths"].setValue(
IECore.StringVectorData(["/sphere"]))
script["constraint"] = GafferScene.ParentConstraint()
script["constraint"]["in"].setInput(script["parent"]["out"])
script["constraint"]["filter"].setInput(script["sphereFilter"]["out"])
script["constraint"]["target"].setValue("/cube")
view = GafferSceneUI.SceneView()
view["in"].setInput(script["constraint"]["out"])
GafferSceneUI.ContextAlgo.setSelectedPaths(
view.getContext(), IECore.PathMatcher(["/sphere"]))
tool = GafferSceneUI.RotateTool(view)
tool["active"].setValue(True)
tool["orientation"].setValue(tool.Orientation.Parent)
self.assertEqual(
tool.handlesTransform(),
imath.M44f().translate(
script["cube"]["transform"]["translate"].getValue()))
tool["orientation"].setValue(tool.Orientation.Local)
self.assertEqual(tool.handlesTransform(),
script["constraint"]["out"].transform("/sphere"))
tool.rotate(imath.Eulerf(0, 90, 0))
self.assertEqual(script["sphere"]["transform"]["rotate"].getValue(),
imath.V3f(0, 90, 0))
def testEditScopes(self):
script = Gaffer.ScriptNode()
script["sphere"] = GafferScene.Sphere()
script["sphere"]["transform"]["translate"].setValue(imath.V3f(1, 0, 0))
script["editScope"] = Gaffer.EditScope()
script["editScope"].setup(script["sphere"]["out"])
script["editScope"]["in"].setInput(script["sphere"]["out"])
view = GafferSceneUI.SceneView()
view["in"].setInput(script["editScope"]["out"])
view["editScope"].setInput(script["editScope"]["out"])
GafferSceneUI.ContextAlgo.setSelectedPaths(
view.getContext(), IECore.PathMatcher(["/sphere"]))
tool = GafferSceneUI.RotateTool(view)
tool["active"].setValue(True)
self.assertEqual(tool.handlesTransform(),
imath.M44f().translate(imath.V3f(1, 0, 0)))
self.assertEqual(len(tool.selection()), 1)
self.assertTrue(tool.selection()[0].editable())
self.assertFalse(
GafferScene.EditScopeAlgo.hasTransformEdit(script["editScope"],
"/sphere"))
self.assertEqual(script["editScope"]["out"].transform("/sphere"),
imath.M44f().translate(imath.V3f(1, 0, 0)))
tool.rotate(imath.Eulerf(0, 90, 0))
self.assertEqual(tool.handlesTransform(),
imath.M44f().translate(imath.V3f(1, 0, 0)))
self.assertEqual(len(tool.selection()), 1)
self.assertTrue(tool.selection()[0].editable())
self.assertTrue(
GafferScene.EditScopeAlgo.hasTransformEdit(script["editScope"],
"/sphere"))
self.assertEqual(
script["editScope"]["out"].transform("/sphere"),
imath.M44f().translate(imath.V3f(1, 0, 0)).rotate(
imath.V3f(0, math.pi / 2, 0)),
)
def testRotate(self):
script = Gaffer.ScriptNode()
script["cube"] = GafferScene.Cube()
view = GafferSceneUI.SceneView()
view["in"].setInput(script["cube"]["out"])
GafferSceneUI.ContextAlgo.setSelectedPaths(
view.getContext(), IECore.PathMatcher(["/cube"]))
tool = GafferSceneUI.RotateTool(view)
tool["active"].setValue(True)
for i in range(0, 6):
tool.rotate(imath.Eulerf(0, 90, 0))
self.assertEqual(
script["cube"]["transform"]["rotate"]["y"].getValue(),
(i + 1) * 90)
def testAttributes(self):
"""Test TransformationMatrixf attributes"""
a = IECore.TransformationMatrixf()
self.assertEqual(a.scalePivot, imath.V3f(0, 0, 0))
self.assertEqual(a.scale, imath.V3f(1, 1, 1))
self.assertEqual(a.shear, imath.V3f(0, 0, 0))
self.assertEqual(a.scalePivotTranslation, imath.V3f(0, 0, 0))
self.assertEqual(a.rotatePivot, imath.V3f(0, 0, 0))
self.assertEqual(a.rotationOrientation, imath.Quatf())
self.assertEqual(a.rotate, imath.Eulerf())
self.assertEqual(a.rotatePivotTranslation, imath.V3f(0, 0, 0))
self.assertEqual(a.translate, imath.V3f(0, 0, 0))
try:
a.transform = 1
except:
pass
else:
raise Exception("Should not be able to set transform.")
def testSettingKnobValues(self):
params = KnobConvertersTest.__parameters()
knobHolder = KnobConvertersTest.KnobHolder()
IECoreNuke.createKnobsFromParameter(knobHolder, params)
# modify parameters
params['A'] = 2
params['F']['G'] = IECore.FloatVectorData()
params['F']['I'] = IECore.DoubleVectorData([9])
params['M'] = "/tmp/anotherTest.%d.dpx"
params['N'] = False
params['O'] = IECore.TransformationMatrixfData(
IECore.TransformationMatrixf(imath.V3f(1), imath.Eulerf(),
imath.V3f(3)))
IECoreNuke.setKnobsFromParameter(knobHolder, params)
knobs = knobHolder.knobs()
self.assertEqual(knobs["parm_A"].getValue(), 2)
self.assertEqual(knobs["parm_F_G"].getText(), "")
self.assertEqual(knobs["parm_F_I"].getText(), "9.0")
self.assertEqual(knobs["parm_M"].getText(), "/tmp/anotherTest.%d.dpx")
self.assertEqual(knobs["parm_N"].getValue(), False)
self.assertEqual(knobs["parm_O"].value(), "preset2")
def testMatrix(self):
p = Gaffer.TransformPlug()
p["translate"].setValue(imath.V3f(1, 2, 3))
p["rotate"].setValue(imath.V3f(90, 45, 0))
p["scale"].setValue(imath.V3f(1, 2, 4))
translate = imath.M44f().translate(p["translate"].getValue())
rotate = imath.Eulerf(IECore.degreesToRadians(p["rotate"].getValue()),
imath.Eulerf.Order.XYZ)
rotate = rotate.toMatrix44()
scale = imath.M44f().scale(p["scale"].getValue())
transforms = {
"t": translate,
"r": rotate,
"s": scale,
}
transform = imath.M44f()
for m in ("s", "r", "t"):
transform = transform * transforms[m]
self.assertEqual(p.matrix(), transform)
def testInteractionWithGroupRotation(self):
script = Gaffer.ScriptNode()
script["cube"] = GafferScene.Cube()
script["group"] = GafferScene.Group()
script["group"]["in"][0].setInput(script["cube"]["out"])
# Rotates the X axis onto the negative Z axis
script["group"]["transform"]["rotate"]["y"].setValue(90)
view = GafferSceneUI.SceneView()
view["in"].setInput(script["group"]["out"])
GafferSceneUI.ContextAlgo.setSelectedPaths(
view.getContext(), IECore.PathMatcher(["/group/cube"]))
tool = GafferSceneUI.RotateTool(view)
tool["active"].setValue(True)
# Rotates 90 degrees using the Z handle. This will
# rotate about the X axis in world space, because the
# handle orientation has been affected by the group
# transform (because default orientation is Parent).
tool.rotate(imath.Eulerf(0, 0, 90))
# We expect this to have aligned the cube's local X axis onto
# the Y axis in world space, and the local Y axis onto the world
# Z axis.
self.assertTrue(
imath.V3f(0, 1, 0).equalWithAbsError(
imath.V3f(1, 0, 0) *
script["group"]["out"].fullTransform("/group/cube"), 0.000001))
self.assertTrue(
imath.V3f(0, 0, 1).equalWithAbsError(
imath.V3f(0, 1, 0) *
script["group"]["out"].fullTransform("/group/cube"), 0.000001))
def test(self):
# Prepare some points with a variety of primitive
# variables specifying the same random orientations.
points = IECoreScene.PointsPrimitive(
IECore.V3fVectorData([imath.V3f(0)] * 100))
points["euler"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.V3fVectorData())
points["quaternion"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.QuatfVectorData())
points["axis"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.V3fVectorData())
points["angle"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex,
IECore.FloatVectorData())
random.seed(0)
for i in range(0, points["P"].data.size()):
radians = imath.Eulerf(random.uniform(0, math.pi / 2),
random.uniform(0, math.pi / 2),
random.uniform(0, math.pi / 2))
degrees = 180.0 * radians / math.pi
q = radians.toQuat()
points["euler"].data.append(degrees)
points["quaternion"].data.append(q)
points["axis"].data.append(q.axis())
points["angle"].data.append(q.angle())
pointsNode = GafferScene.ObjectToScene()
pointsNode["object"].setValue(points)
# No filter is applied, so should be a no-op
orientation = GafferScene.Orientation()
orientation["in"].setInput(pointsNode["out"])
self.assertScenesEqual(orientation["out"], orientation["in"])
self.assertSceneHashesEqual(orientation["out"], orientation["in"])
# Apply a filter
filter = GafferScene.PathFilter()
filter["paths"].setValue(IECore.StringVectorData(["/object"]))
orientation["filter"].setInput(filter["out"])
# Test euler -> euler round tripping
self.assertEqual(orientation["inMode"].getValue(),
orientation.Mode.Euler)
orientation["inEuler"].setValue("euler")
orientation["outMode"].setValue(orientation.Mode.Euler)
orientation["outEuler"].setValue("outEuler")
for order in [
imath.Eulerf.XYZ,
imath.Eulerf.XZY,
imath.Eulerf.YZX,
imath.Eulerf.YXZ,
imath.Eulerf.ZXY,
imath.Eulerf.ZYX,
]:
orientation["inOrder"].setValue(order)
orientation["outOrder"].setValue(order)
self.__assertVectorDataAlmostEqual(
orientation["in"].object("/object")["euler"].data,
orientation["out"].object("/object")["outEuler"].data,
delta=0.01)
# Test euler -> quaternion
orientation["inOrder"].setValue(imath.Eulerf.XYZ)
orientation["outMode"].setValue(orientation.Mode.Quaternion)
orientation["outQuaternion"].setValue("outQuaternion")
self.__assertVectorDataAlmostEqual(
orientation["in"].object("/object")["quaternion"].data,
orientation["out"].object("/object")["outQuaternion"].data,
)
# Test euler -> axis angle
orientation["outMode"].setValue(orientation.Mode.AxisAngle)
orientation["outAxis"].setValue("outAxis")
orientation["outAngle"].setValue("outAngle")
self.__assertVectorDataAlmostEqual(
orientation["in"].object("/object")["axis"].data,
orientation["out"].object("/object")["outAxis"].data,
)
self.__assertVectorDataAlmostEqual(
orientation["in"].object("/object")["angle"].data,
orientation["out"].object("/object")["outAngle"].data,
)
