Exemplo n.º 1
0
	def testBoxOutputs( self ) :

		s = Gaffer.ScriptNode()

		s["n"] = Gaffer.Node()
		s["n"]["user"].addChild( Gaffer.Box2fPlug( "b2f", flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.Box2iPlug( "b2i", flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.Box3fPlug( "b3f", flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.Box3iPlug( "b3i", flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )

		s["e"] = Gaffer.Expression()
		s["e"].setExpression(
			'import IECore;'
			'parent["n"]["user"]["b2f"] = IECore.Box2f( IECore.V2f( 1, 2 ), IECore.V2f( 3, 4 ) );'
			'parent["n"]["user"]["b2i"] = IECore.Box2i( IECore.V2i( 5, 6 ), IECore.V2i( 7, 8 ) );'
			'parent["n"]["user"]["b3f"] = IECore.Box3f( IECore.V3f( 9, 10, 11 ), IECore.V3f( 12, 13, 14 ) );'
			'parent["n"]["user"]["b3i"] = IECore.Box3i( IECore.V3i( 15, 16, 17 ), IECore.V3i( 18, 19, 20 ) );'
		)

		def assertExpectedValues( script ) :

			self.assertEqual( script["n"]["user"]["b2f"].getValue(), IECore.Box2f( IECore.V2f( 1, 2 ), IECore.V2f( 3, 4 ) ) )
			self.assertEqual( script["n"]["user"]["b2i"].getValue(), IECore.Box2i( IECore.V2i( 5, 6 ), IECore.V2i( 7, 8 ) ) )
			self.assertEqual( script["n"]["user"]["b3f"].getValue(), IECore.Box3f( IECore.V3f( 9, 10, 11 ), IECore.V3f( 12, 13, 14 ) ) )
			self.assertEqual( script["n"]["user"]["b3i"].getValue(), IECore.Box3i( IECore.V3i( 15, 16, 17 ), IECore.V3i( 18, 19, 20 ) ) )

		assertExpectedValues( s )

		s2 = Gaffer.ScriptNode()
		s2.execute( s.serialise() )

		assertExpectedValues( s2 )
Exemplo n.º 2
0
	def testDefaultExpressionForSupportedPlugs( self ) :

		s = Gaffer.ScriptNode()

		s["n"] = Gaffer.Node()
		s["n"]["user"].addChild( Gaffer.IntPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.FloatPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.StringPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.BoolPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.V2fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.V2iPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.V3fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.V3iPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.Color3fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.Color4fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.Box2fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.Box2iPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.Box3fPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.Box3iPlug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.IntVectorDataPlug( defaultValue = IECore.IntVectorData( [ 0, 1 ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.FloatVectorDataPlug( defaultValue = IECore.FloatVectorData( [ 0, 1 ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.StringVectorDataPlug( defaultValue = IECore.StringVectorData( [ "a", "b" ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.V3fVectorDataPlug( defaultValue = IECore.V3fVectorData( [ IECore.V3f( 1 ) ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.Color3fVectorDataPlug( defaultValue = IECore.Color3fVectorData( [ IECore.Color3f( 1 ) ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.M44fVectorDataPlug( defaultValue = IECore.M44fVectorData( [ IECore.M44f() ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )
		s["n"]["user"].addChild( Gaffer.V2iVectorDataPlug( defaultValue = IECore.V2iVectorData( [ IECore.V2i() ] ), flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) )

		s["e"] = Gaffer.Expression()

		for plug in s["n"]["user"] :

			value = plug.getValue()
			s["e"].setExpression( s["e"].defaultExpression( plug, "python" ) )
			self.assertTrue( plug.getInput().node().isSame( s["e"] ) )
			self.assertEqual( plug.getValue(), value )
Exemplo n.º 3
0
		def __framePlug( node, createIfMissing = False ) :
			
			plugName = "__nodeGraphFraming%d" % id( self )
			result = node.getChild( plugName )
			if result is None and createIfMissing :
				result = Gaffer.Box2fPlug( plugName, flags = Gaffer.Plug.Flags.Default & ( ~Gaffer.Plug.Flags.Serialisable ) )
				node.addChild( result )
			
			return result
Exemplo n.º 4
0
def newBackdrop(parent, type_="default"):
    """
	Creates a new backdrop, initializing it with default tile, width and color
	based on the supplied type_ - @see backdropDefaults.
	"""

    with Gaffer.UndoScope(parent.ancestor(Gaffer.ScriptNode)):

        b = Gaffer.Backdrop()
        b.addChild(
            Gaffer.Box2fPlug(
                "__uiBound",
                defaultValue=imath.Box2f(imath.V2f(-10, -10),
                                         imath.V2f(10, 10)),
                flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic,
            ))
        conform(b, type_)
        parent.addChild(b)

        GafferUI.NodeEditor.acquire(b, floating=True)

        return b
Exemplo n.º 5
0
    def __init__(self, name="Trim"):

        GafferImage.ImageProcessor.__init__(self, name)

        self["flipHorizontal"] = Gaffer.BoolPlug()
        self["flipVertical"] = Gaffer.BoolPlug()
        self["rotate"] = Gaffer.FloatPlug()
        self["applyCrop"] = Gaffer.BoolPlug(defaultValue=False)
        self["crop"] = Gaffer.Box2fPlug(
            defaultValue=imath.Box2f(imath.V2f(0), imath.V2f(1)))

        mirror = GafferImage.Mirror()
        self["__Mirror"] = mirror
        mirror["horizontal"].setInput(self["flipHorizontal"])
        mirror["vertical"].setInput(self["flipVertical"])
        mirror["in"].setInput(self["in"])

        transform = GafferImage.ImageTransform()
        self["__Transform"] = transform
        transform["transform"]["rotate"].setInput(self["rotate"])
        transform["filter"].setValue("sharp-gaussian")
        transform["in"].setInput(mirror["out"])

        # Reset the display window to the data window, required for rotation without
        # the crop region being applied.
        transformCorrectionCrop = GafferImage.Crop()
        self["__TransformCorrectionCrop"] = transformCorrectionCrop
        transformCorrectionCrop["in"].setInput(transform["out"])
        transformCorrectionCrop["areaSource"].setValue(1)  # dataWindow

        transformCenterExpr = Gaffer.Expression()
        self["__Expression_Transform"] = transformCenterExpr
        transformCenterExpr.setExpression(
            inspect.cleandoc("""
				import imath
				f = parent["__Transform"]["in"]["format"]
				parent["__Transform"]["transform"]["pivot"] = imath.V2f( f.width() / 2.0, f.height() / 2.0 )
			"""), "python")

        crop = GafferImage.Crop()
        self["__Crop"] = crop
        crop["in"].setInput(transformCorrectionCrop["out"])

        options = GafferScene.StandardOptions()
        self["__CropWindow"] = options
        options["options"]["renderCropWindow"]["value"].setInput(self["crop"])

        cropExpr = Gaffer.Expression()
        self["__Expression_Crop"] = cropExpr
        cropExpr.setExpression(
            inspect.cleandoc("""
			import imath

			f = parent["__Crop"]["in"]["format"]
			w = parent["__CropWindow"]["options"]["renderCropWindow"]["value"]

			parent["__Crop"]["area"] = imath.Box2i(
				imath.V2i( f.width() * w.min().x, f.height() * ( 1 - w.max().y ) ),
				imath.V2i( f.width() * w.max().x, f.height() * ( 1 - w.min().y ) )
			)
			"""), "python")

        parentPath = GafferAstro.ParentPath()
        self["__ParentPath"] = parentPath

        imageMeta = GafferImage.ImageMetadata()
        self["__ImageMetadata"] = imageMeta
        imageMeta["metadata"].addChild(
            Gaffer.NameValuePlug("gaffer:sourceScene",
                                 Gaffer.StringPlug("value"), True, "member1"))
        imageMeta["user"].addChild(Gaffer.StringPlug("parentPath"))
        imageMeta["user"]["parentPath"].setInput(parentPath["parentPath"])
        imageMeta["in"].setInput(transformCorrectionCrop["out"])

        self["__Expression_Meta"] = Gaffer.Expression()
        expr = 'parent["__ImageMetadata"]["metadata"]["member1"]["value"] = parent["__ImageMetadata"]["user"]["parentPath"] + ".__CropWindow.out"'
        self["__Expression_Meta"].setExpression(expr, "python")

        switch = Gaffer.Switch()
        self["__Switch"] = switch
        switch.setup(crop["out"])
        switch["in"][0].setInput(imageMeta["out"])
        switch["in"][1].setInput(crop["out"])
        switch["index"].setInput(self["applyCrop"])

        self["out"].setInput(switch["out"])
Exemplo n.º 6
0
def encloseSelectionWithBackdrop(parent, padding=2):
    """
	Roughly encloses the selection in a backdrop node. If there are other
	backdrops in the selection, they will be re-layered on top of the new one.
	"""

    scriptNode = parent.ancestor(Gaffer.ScriptNode) or parent

    sel = scriptNode.selection()
    if len(sel) == 0:
        return

    with Gaffer.UndoScope(scriptNode):

        extents = imath.Box2f()
        extents.makeEmpty()

        color = None
        existingBackdrops = []

        for s in sel:
            p = s["__uiPosition"].getValue()
            b = s["__uiBound"].getValue(
            ) if "__uiBound" in s else defaultNodeSize
            extents.extendBy(p + b.min())
            extents.extendBy(p + b.max())
            if isinstance(s, Gaffer.Backdrop):
                color = Gaffer.Metadata.value(s, "nodeGadget:color")
                existingBackdrops.append(s)

        extents.extendBy(extents.min() - imath.V2f(padding))
        extents.extendBy(extents.max() + imath.V2f(padding))

        # We need to remove the existing backdrops, add the underlying one
        # then add the old ones back, otherwise the new one will be on top
        for b in existingBackdrops:
            parent.removeChild(b)

        backdrop = Gaffer.Backdrop()
        backdrop["title"].setValue("")
        setColor(backdrop, color)

        backdrop.addChild(
            Gaffer.V2fPlug(
                "__uiPosition",
                defaultValue=imath.V2f(0, 0),
                flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic,
            ))
        backdrop.addChild(
            Gaffer.Box2fPlug(
                "__uiBound",
                defaultValue=imath.Box2f(imath.V2f(-10, -10),
                                         imath.V2f(10, 10)),
                flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic,
            ))
        backdrop["__uiPosition"].setValue(extents.min())
        backdrop["__uiBound"].setValue(
            imath.Box2f(imath.V2f(0.0),
                        extents.max() - extents.min()))

        parent.addChild(backdrop)

        for b in existingBackdrops:
            parent.addChild(b)

    return backdrop