def testKeepLightsAndCamerasHashing(self):
# - group
# - cameraGroup
# - camera
camera = GafferScene.Camera()
cameraGroup = GafferScene.Group()
cameraGroup["name"].setValue("cameraGroup")
cameraGroup["in"][0].setInput(camera["out"])
group = GafferScene.Group()
group["in"][0].setInput(cameraGroup["out"])
filter = GafferScene.PathFilter()
isolate = GafferScene.Isolate()
isolate["in"].setInput(group["out"])
isolate["filter"].setInput(filter["out"])
isolate["keepCameras"].setValue(True)
self.assertTrue(
GafferScene.SceneAlgo.exists(isolate["out"],
"/group/cameraGroup/camera"))
def testSets(self):
light1 = GafferSceneTest.TestLight()
light2 = GafferSceneTest.TestLight()
group = GafferScene.Group()
group["in"][0].setInput(light1["out"])
group["in"][1].setInput(light2["out"])
lightSet = group["out"].set("__lights")
self.assertEqual(set(lightSet.value.paths()),
set(["/group/light", "/group/light1"]))
isolate = GafferScene.Isolate()
isolate["in"].setInput(group["out"])
lightSet = isolate["out"].set("__lights")
self.assertEqual(set(lightSet.value.paths()),
set(["/group/light", "/group/light1"]))
filter = GafferScene.PathFilter()
isolate["filter"].setInput(filter["out"])
lightSet = isolate["out"].set("__lights")
self.assertEqual(set(lightSet.value.paths()), set([]))
filter["paths"].setValue(IECore.StringVectorData(["/group/light"]))
lightSet = isolate["out"].set("__lights")
self.assertEqual(set(lightSet.value.paths()), set(["/group/light"]))
filter["paths"].setValue(IECore.StringVectorData(["/group/light*"]))
lightSet = isolate["out"].set("__lights")
self.assertEqual(set(lightSet.value.paths()),
set(["/group/light", "/group/light1"]))
def testIsolate(self):
p1 = GafferScene.Plane()
p2 = GafferScene.Plane()
g = GafferScene.Group()
g["in"][0].setInput(p1["out"])
g["in"][1].setInput(p2["out"])
s1 = GafferScene.Set()
s1["name"].setValue("set1")
s1["paths"].setValue(IECore.StringVectorData(["/group/plane"]))
s1["in"].setInput(g["out"])
s2 = GafferScene.Set()
s2["name"].setValue("set2")
s2["paths"].setValue(
IECore.StringVectorData(["/group", "/group/plane1"]))
s2["in"].setInput(s1["out"])
f = GafferScene.SetFilter()
f["setExpression"].setValue("set1")
i = GafferScene.Isolate()
i["in"].setInput(s2["out"])
i["filter"].setInput(f["out"])
self.assertSceneValid(i["out"])
self.assertEqual(i["out"].childNames("/group"),
IECore.InternedStringVectorData(["plane"]))
self.assertEqual(i["out"].set("set1").value.paths(), ["/group/plane"])
self.assertEqual(i["out"].set("set2").value.paths(), ["/group"])
def testForwardDeclarations(self):
light1 = GafferSceneTest.TestLight()
light2 = GafferSceneTest.TestLight()
group = GafferScene.Group()
group["in"].setInput(light1["out"])
group["in1"].setInput(light2["out"])
fd = group["out"]["globals"].getValue()["gaffer:forwardDeclarations"]
self.assertEqual(set(fd.keys()), set(["/group/light",
"/group/light1"]))
isolate = GafferScene.Isolate()
isolate["in"].setInput(group["out"])
fd = isolate["out"]["globals"].getValue()["gaffer:forwardDeclarations"]
self.assertEqual(set(fd.keys()), set(["/group/light",
"/group/light1"]))
filter = GafferScene.PathFilter()
isolate["filter"].setInput(filter["match"])
fd = isolate["out"]["globals"].getValue()["gaffer:forwardDeclarations"]
self.assertEqual(set(fd.keys()), set([]))
filter["paths"].setValue(IECore.StringVectorData(["/group/light"]))
fd = isolate["out"]["globals"].getValue()["gaffer:forwardDeclarations"]
self.assertEqual(set(fd.keys()), set(["/group/light"]))
filter["paths"].setValue(IECore.StringVectorData(["/group/light*"]))
fd = isolate["out"]["globals"].getValue()["gaffer:forwardDeclarations"]
self.assertEqual(set(fd.keys()), set(["/group/light",
"/group/light1"]))
def testIsolation(self):
sphere = IECoreScene.SpherePrimitive()
input = GafferSceneTest.CompoundObjectSource()
input["in"].setValue(
IECore.CompoundObject({
"bound": IECore.Box3fData(sphere.bound()),
"children": {
"groupA": {
"bound": IECore.Box3fData(sphere.bound()),
"children": {
"sphereAA": {
"bound": IECore.Box3fData(sphere.bound()),
"object": sphere,
},
"sphereAB": {
"bound": IECore.Box3fData(sphere.bound()),
"object": sphere,
},
},
},
"groupB": {
"bound": IECore.Box3fData(sphere.bound()),
"children": {
"sphereBA": {
"bound": IECore.Box3fData(sphere.bound()),
"object": sphere,
},
"sphereBB": {
"bound": IECore.Box3fData(sphere.bound()),
"object": sphere,
},
},
},
},
}), )
isolate = GafferScene.Isolate()
isolate["in"].setInput(input["out"])
filter = GafferScene.PathFilter()
filter["paths"].setValue(IECore.StringVectorData(["/groupA/sphereAB"]))
isolate["filter"].setInput(filter["out"])
self.assertNotEqual(isolate["out"].childNamesHash("/groupA"),
input["out"].childNamesHash("/groupA"))
self.assertEqual(isolate["out"].childNames("/groupA"),
IECore.InternedStringVectorData(["sphereAB"]))
self.assertEqual(isolate["out"].childNames("/"),
IECore.InternedStringVectorData(["groupA"]))
filter["paths"].setValue(IECore.StringVectorData(["/groupA/sphereAA"]))
self.assertEqual(isolate["out"].childNames("/groupA"),
IECore.InternedStringVectorData(["sphereAA"]))
self.assertEqual(isolate["out"].childNames("/"),
IECore.InternedStringVectorData(["groupA"]))
def testConnectWithoutInputs(self):
s = Gaffer.ScriptNode()
s["i"] = GafferScene.Isolate()
s["p"] = GafferScene.PathFilter()
s["s"] = GafferScene.FilterSwitch()
s["s"]["in"][0].setInput(s["p"]["out"])
s["s"]["in"][0].setInput(None)
s["i"]["filter"].setInput(s["s"]["out"])
def testSetFilter( self ) : sphere = GafferScene.Sphere() sphere["sets"].setValue( "A" ) filter = GafferScene.SetFilter() filter["setExpression"].setValue( "A" ) isolate = GafferScene.Isolate() isolate["in"].setInput( sphere["out"] ) isolate["filter"].setInput( filter["out"] ) self.assertSceneValid( isolate["out"] ) self.assertTrue( GafferScene.SceneAlgo.exists( isolate["out"], "/sphere" ) )
def testIsolateNothing( self ) :
sphere = GafferScene.Sphere()
sphere["sets"].setValue("sphereSet")
i = GafferScene.Isolate()
i["in"].setInput( sphere["out"] )
pathFilter = GafferScene.PathFilter()
i["filter"].setInput( pathFilter["out"] )
pathFilter["paths"].setValue( IECore.StringVectorData( [ "/sphere" ] ) )
self.assertEqual( i["out"].childNames("/"), IECore.InternedStringVectorData( [ "sphere" ] ) )
self.assertEqual( i["out"].set( "sphereSet" ).value.paths(), ["/sphere"] )
pathFilter["paths"].setValue( IECore.StringVectorData() )
self.assertEqual( i["out"].set( "sphereSet" ).value.paths(), [] )
self.assertEqual( i["out"].childNames("/"), IECore.InternedStringVectorData() )
def testAdjustBounds(self):
sphere1 = IECoreScene.SpherePrimitive()
sphere2 = IECoreScene.SpherePrimitive(2)
input = GafferSceneTest.CompoundObjectSource()
input["in"].setValue(
IECore.CompoundObject({
"bound": IECore.Box3fData(sphere2.bound()),
"children": {
"group": {
"bound": IECore.Box3fData(sphere2.bound()),
"children": {
"sphere1": {
"bound": IECore.Box3fData(sphere1.bound()),
"object": sphere1,
},
"sphere2": {
"bound": IECore.Box3fData(sphere2.bound()),
"object": sphere2,
},
},
},
},
}), )
isolate = GafferScene.Isolate()
isolate["in"].setInput(input["out"])
filter = GafferScene.PathFilter()
filter["paths"].setValue(IECore.StringVectorData(["/group/sphere1"]))
isolate["filter"].setInput(filter["out"])
self.assertEqual(isolate["out"].bound("/"), sphere2.bound())
self.assertEqual(isolate["out"].bound("/group"), sphere2.bound())
self.assertEqual(isolate["out"].bound("/group/sphere1"),
sphere1.bound())
isolate["adjustBounds"].setValue(True)
self.assertEqual(isolate["out"].bound("/"), sphere1.bound())
self.assertEqual(isolate["out"].bound("/group"), sphere1.bound())
self.assertEqual(isolate["out"].bound("/group/sphere1"),
sphere1.bound())
def testTwoAffectedScenes(self):
setNode = GafferScene.Set()
setFilter = GafferScene.SetFilter()
prune = GafferScene.Prune()
prune["in"].setInput(setNode["out"])
prune["filter"].setInput(setFilter["out"])
isolate = GafferScene.Isolate()
isolate["in"].setInput(prune["out"])
isolate["filter"].setInput(setFilter["out"])
cs = GafferTest.CapturingSlot(prune.plugDirtiedSignal(),
isolate.plugDirtiedSignal())
setNode["name"].setValue("test")
self.assertTrue({x[0]
for x in cs
}.issuperset({prune["filter"], isolate["filter"]}))
def testGlobalsDoNotDependOnScenePath( self ) : pathFilter = GafferScene.PathFilter() pathFilter["paths"].setValue( IECore.StringVectorData( [ "/grid/borderLines" ] ) ) grid = GafferScene.Grid() isolate = GafferScene.Isolate() isolate["in"].setInput( grid["out"] ) isolate["filter"].setInput( pathFilter["out"] ) c = Gaffer.Context() with c : h1 = isolate["out"]["globals"].hash() c["scene:path"] = IECore.InternedStringVectorData( [ "grid" ] ) h2 = isolate["out"]["globals"].hash() c["scene:path"] = IECore.InternedStringVectorData( [ "grid", "centerLines" ] ) h3 = isolate["out"]["globals"].hash() self.assertEqual( h1, h2 ) self.assertEqual( h2, h3 )
def testPassThrough(self):
sphere = IECoreScene.SpherePrimitive()
input = GafferSceneTest.CompoundObjectSource()
input["in"].setValue(
IECore.CompoundObject({
"bound": IECore.Box3fData(sphere.bound()),
"children": {
"groupA": {
"bound": IECore.Box3fData(sphere.bound()),
"children": {
"sphereAA": {
"bound": IECore.Box3fData(sphere.bound()),
"object": sphere,
},
"sphereAB": {
"bound": IECore.Box3fData(sphere.bound()),
"object": sphere,
},
},
},
"groupB": {
"bound": IECore.Box3fData(sphere.bound()),
"children": {
"sphereBA": {
"bound": IECore.Box3fData(sphere.bound()),
"object": sphere,
},
"sphereBB": {
"bound": IECore.Box3fData(sphere.bound()),
"object": sphere,
},
},
},
},
}), )
isolate = GafferScene.Isolate()
isolate["in"].setInput(input["out"])
self.assertSceneValid(input["out"])
self.assertSceneValid(isolate["out"])
# with no filter applied, nothing should be isolated so we should have a perfect pass through
self.assertScenesEqual(input["out"], isolate["out"])
self.assertSceneHashesEqual(input["out"], isolate["out"])
self.assertTrue(input["out"].object(
"/groupA/sphereAA",
_copy=False).isSame(isolate["out"].object("/groupA/sphereAA",
_copy=False)))
# and even with a filter applied, we should have a perfect pass through if the node is disabled.
filter = GafferScene.PathFilter()
filter["paths"].setValue(IECore.StringVectorData(["/*"]))
isolate["filter"].setInput(filter["out"])
isolate["enabled"].setValue(False)
self.assertScenesEqual(input["out"], isolate["out"])
self.assertSceneHashesEqual(input["out"], isolate["out"])
self.assertTrue(input["out"].object(
"/groupA/sphereAA",
_copy=False).isSame(isolate["out"].object("/groupA/sphereAA",
_copy=False)))
def testKeepLightsAndCameras(self):
# - group
# - light
# - camera
# - model1
# - sphere
# - light
# - model2
# - sphere
# - light
light = GafferSceneTest.TestLight()
light["sets"].setValue("lightsAndSpheres")
sphere = GafferScene.Sphere()
sphere["sets"].setValue("lightsAndSpheres")
camera = GafferScene.Camera()
model1 = GafferScene.Group()
model1["in"][0].setInput(sphere["out"])
model1["in"][1].setInput(light["out"])
model1["name"].setValue("model1")
model2 = GafferScene.Group()
model2["in"][0].setInput(sphere["out"])
model2["in"][1].setInput(light["out"])
model2["name"].setValue("model2")
group = GafferScene.Group()
group["in"][0].setInput(light["out"])
group["in"][1].setInput(camera["out"])
group["in"][2].setInput(model1["out"])
group["in"][3].setInput(model2["out"])
self.assertSceneValid(group["out"])
filter = GafferScene.PathFilter()
filter["paths"].setValue(IECore.StringVectorData(["/group/model1"]))
isolate = GafferScene.Isolate()
isolate["in"].setInput(group["out"])
isolate["filter"].setInput(filter["out"])
# Keep neither
self.assertSceneValid(isolate["out"])
self.assertTrue(
GafferScene.SceneAlgo.exists(isolate["out"],
"/group/model1/sphere"))
self.assertTrue(
GafferScene.SceneAlgo.exists(isolate["out"],
"/group/model1/light"))
self.assertTrue(
GafferScene.SceneAlgo.exists(isolate["out"], "/group/model1"))
self.assertFalse(
GafferScene.SceneAlgo.exists(isolate["out"],
"/group/model2/sphere"))
self.assertFalse(
GafferScene.SceneAlgo.exists(isolate["out"], "/group/model2"))
self.assertFalse(
GafferScene.SceneAlgo.exists(isolate["out"], "/group/light"))
self.assertFalse(
GafferScene.SceneAlgo.exists(isolate["out"], "/group/camera"))
self.assertEqual(isolate["out"].set("__lights").value.paths(),
["/group/model1/light"])
self.assertEqual(isolate["out"].set("__cameras").value.paths(), [])
self.assertEqual(
isolate["out"].set("lightsAndSpheres").value,
IECore.PathMatcher(["/group/model1/sphere",
"/group/model1/light"]))
self.assertNotEqual(isolate["out"].setHash("__lights"),
group["out"].setHash("__lights"))
self.assertNotEqual(isolate["out"].setHash("__cameras"),
group["out"].setHash("__cameras"))
# Keep lights
isolate["keepLights"].setValue(True)
self.assertSceneValid(isolate["out"])
self.assertFalse(
GafferScene.SceneAlgo.exists(isolate["out"], "/group/camera"))
self.assertEqual(isolate["out"].set("__lights"),
group["out"].set("__lights"))
self.assertEqual(isolate["out"].set("__cameras").value.paths(), [])
self.assertEqual(
isolate["out"].set("lightsAndSpheres").value,
IECore.PathMatcher(["/group/model1/sphere"] +
group["out"].set("__lights").value.paths()))
self.assertEqual(isolate["out"].setHash("__lights"),
group["out"].setHash("__lights"))
self.assertNotEqual(isolate["out"].setHash("__cameras"),
group["out"].setHash("__cameras"))
# Keep cameras too
isolate["keepCameras"].setValue(True)
self.assertSceneValid(isolate["out"])
self.assertTrue(
GafferScene.SceneAlgo.exists(isolate["out"], "/group/camera"))
self.assertEqual(isolate["out"].set("__lights"),
group["out"].set("__lights"))
self.assertEqual(isolate["out"].set("__cameras"),
group["out"].set("__cameras"))
self.assertEqual(
isolate["out"].set("lightsAndSpheres").value,
IECore.PathMatcher(["/group/model1/sphere"] +
group["out"].set("__lights").value.paths()))
self.assertEqual(isolate["out"].setHash("__lights"),
group["out"].setHash("__lights"))
self.assertEqual(isolate["out"].setHash("__cameras"),
group["out"].setHash("__cameras"))
def testFrom(self):
# - group1
# - group2
# - light1
# - light2
# - light3
# - plane
light1 = GafferSceneTest.TestLight()
light1["name"].setValue("light1")
light2 = GafferSceneTest.TestLight()
light2["name"].setValue("light2")
light3 = GafferSceneTest.TestLight()
light3["name"].setValue("light3")
group1 = GafferScene.Group()
group1["name"].setValue("group1")
group2 = GafferScene.Group()
group2["name"].setValue("group2")
group1["in"][0].setInput(group2["out"])
group1["in"][1].setInput(light3["out"])
group2["in"][0].setInput(light1["out"])
group2["in"][1].setInput(light2["out"])
plane = GafferScene.Plane()
parent = GafferScene.Parent()
parent["parent"].setValue("/")
parent["in"].setInput(group1["out"])
parent["children"][0].setInput(plane["out"])
isolate = GafferScene.Isolate()
isolate["in"].setInput(parent["out"])
self.assertSceneValid(isolate["out"])
self.assertEqual(isolate["out"].childNames("/"),
IECore.InternedStringVectorData(["group1", "plane"]))
self.assertEqual(isolate["out"].childNames("/group1"),
IECore.InternedStringVectorData(["group2", "light3"]))
self.assertEqual(isolate["out"].childNames("/group1/group2"),
IECore.InternedStringVectorData(["light1", "light2"]))
filter = GafferScene.PathFilter()
filter["paths"].setValue(
IECore.StringVectorData(["/group1/group2/light1"]))
isolate["filter"].setInput(filter["out"])
self.assertSceneValid(isolate["out"])
self.assertEqual(isolate["out"].childNames("/"),
IECore.InternedStringVectorData(["group1"]))
self.assertEqual(isolate["out"].childNames("/group1"),
IECore.InternedStringVectorData(["group2"]))
self.assertEqual(isolate["out"].childNames("/group1/group2"),
IECore.InternedStringVectorData(["light1"]))
isolate["from"].setValue("/group1")
self.assertSceneValid(isolate["out"])
self.assertEqual(isolate["out"].childNames("/"),
IECore.InternedStringVectorData(["group1", "plane"]))
self.assertEqual(isolate["out"].childNames("/group1"),
IECore.InternedStringVectorData(["group2"]))
self.assertEqual(isolate["out"].childNames("/group1/group2"),
IECore.InternedStringVectorData(["light1"]))
isolate["from"].setValue("/group1/group2")
self.assertSceneValid(isolate["out"])
self.assertEqual(isolate["out"].childNames("/"),
IECore.InternedStringVectorData(["group1", "plane"]))
self.assertEqual(isolate["out"].childNames("/group1"),
IECore.InternedStringVectorData(["group2", "light3"]))
self.assertEqual(isolate["out"].childNames("/group1/group2"),
IECore.InternedStringVectorData(["light1"]))
