Ejemplo n.º 1
0
def pStamp(nodes,posX,posY):
    #create postage stamp
    inputNodes = []
    inputNodes.append(nodes)
    for a in inputNodes:
        if a.Class()=='Read':
            namer = a.knob('file').getValue()
            col=2570627072
        else:
            namer=a.knob('name').getValue()
            col=2993684480
        namer= namer.split('/')[-1].split('.')[0]
        namer=namer+'_001'
        nukescripts.clear_selection_recursive()
        nuke.createNode('PostageStamp').setXYpos(posX,posY)
        for i in nuke.selectedNodes():
            i.setInput(0,a)
            i['tile_color'].setValue(col)
            verList=[]
            for i in nuke.allNodes():
                    if i.Class()=='PostageStamp':
                        if i.knob('name').getValue()[:-2]==namer[:-2]:
                            nVer = i.knob('name').getValue()[-1]
                            verList.append(nVer)
                            while namer[-1] in verList:
                                ver=int(namer[-1])
                                ver=str(int(ver)+1)
                                namer=namer[:-1]+ver
            for a in nuke.selectedNodes():
                if a.Class()=='PostageStamp':
                    a.knob('hide_input').setValue(True)
                    a.knob('name').setValue(namer)
                    nukescripts.clear_selection_recursive()
    return namer    
Ejemplo n.º 2
0
def select_children():
    n = nuke.thisNode()
    listOfChildren = postal_main.get_child_list(n)

    nukescripts.clear_selection_recursive()

    postal_main.set_child_list(n, listOfChildren, True)
Ejemplo n.º 3
0
    def swapOutNode(self, targetNode, newNode):
        '''
        Mostly mimics the Ctrl + Shift + drag-and-drop node functionality in Nuke.

        'targetNode': The node (or node name) to be replaced.
        'newNode': The node (or node name) that will replace it.
        '''
        if isinstance(targetNode, basestring):
            targetNode = nuke.toNode(targetNode)
        if isinstance(newNode, basestring):
            newNode = nuke.toNode(newNode)
        if not (isinstance(targetNode, nuke.Node) and isinstance(newNode, nuke.Node)):
            return
        sourcePos = (newNode.xpos(), newNode.ypos())
        targetPos = (targetNode.xpos(), targetNode.ypos())
        oldSel = nuke.selectedNodes()
        inputNodes, outputNodes = self.getConnectedNodes(targetNode)
        nukescripts.clear_selection_recursive()
        targetNode.setSelected(True)
        nuke.extractSelected()
        targetNode.setSelected(False)
        newNode.setXYpos(*targetPos)
        targetNode.setXYpos(*sourcePos)
        for inNode in inputNodes:
            newNode.setInput(*inNode)
        for index, node in outputNodes:
            node.setInput(index, newNode)
        for node in oldSel:
            node.setSelected(True)
        return True
Ejemplo n.º 4
0
def replaceGizmoWithGroup(node):
	### replaceGizmoWithGroup - takes a single node as input and if it is a gizmo, converts it into a group and replaces the old group.
	### Preserves the original selection state
	### requires nukescripts

    if isinstance(node, nuke.Gizmo):
        selection=nuke.selectedNodes()
        nukescripts.clear_selection_recursive()

        name=node['name'].getValue()
        inputs=node

        node.setSelected(True)




        group=node.makeGroup()

        group['xpos'].setValue(node['xpos'].getValue())
        group['ypos'].setValue(node['ypos'].getValue())

        for i in range (0,node.inputs()):
            group.setInput(i,node.input(i))

        for n in selection:
            n.setSelected(True)

        sel=node['selected'].getValue()
        nuke.delete(node)

        group['name'].setValue(name)
        group.setSelected(sel)
Ejemplo n.º 5
0
def performCustomAction():
	
	node = nuke.thisNode()
	knob = nuke.thisKnob()

	fileValue = node["file"].getValue()
	renderPath = os.path.dirname(fileValue)

	#reveal in explorer
	if knob.name() == "reveal in explorer":
		if renderPath!="":
			try:
				if platform.system() == "Windows":
					os.startfile(renderPath)
				elif platform.system() == "Darwin":
					subprocess.Popen(["open", renderPath])
				else:
					subprocess.Popen(["xdg-open", renderPath])
			except:
				nuke.message("couldn't open render path. No such directory")
		else:
			nuke.message("Please make sure to set a render path")

	#create next version
	if knob.name() == "create next version":	
		if renderPath != "":
			nukescripts.clear_selection_recursive()
			node.setSelected(True)
			nukescripts.version_up()
			node.setSelected(False)

			fileValue = node["file"].getValue()
			renderPath = os.path.dirname(fileValue)

			if not os.path.isdir(renderPath):
				os.makedirs(renderPath)
				nuke.message("successfully versioned up")
			else:
				nuke.message("Renderfolder '%s' seems to exist" % renderPath)
		else:
			nuke.message("Please make sure to set a render path")

	#force create directory
	if knob.name() == "force create directory":
		if renderPath != "":	
			if not os.path.isdir(renderPath):
				os.makedirs(renderPath)
				nuke.message("successfully created render directory at: \n\n%s" % renderPath)
			else:
				nuke.message("render directory exists")	
		else:
			nuke.message("Please make sure to set a render path")
	
	#save backup
	if knob.name() == "save backup":
		if knob.getValue() == 1.0:
			node["beforeRender"].setValue("nextVersion.saveBackup('%s')" % node.name())
		else:
			node["beforeRender"].setValue("")
Ejemplo n.º 6
0
def select_in_nuke(nodes):
    import nuke
    import nukescripts
    nukescripts.clear_selection_recursive()
    if isinstance(nodes, basestring):
        nodes = [nodes]
    for node in nodes:
        n = nuke.toNode(node)
        n.knob('selected').setValue(True)
Ejemplo n.º 7
0
def centerNodeInNodeGraph(node):
    try:
        xpos = node["xpos"].value()
        ypos = node["ypos"].value()
        factor = 1.0
        nukescripts.clear_selection_recursive()
        node["selected"].setValue(True)
        nuke.zoom(factor, (xpos, ypos))
    except:
        pass
Ejemplo n.º 8
0
def performCustomAction():	
	node = nuke.thisNode()
	knob = nuke.thisKnob()

	fileValue = node["file"].getValue()
	renderPath = os.path.abspath(fileValue)
	
	#create test folder		
	if knob.name() == "create test folder":
		if renderPath != "":	
			renderPath = os.path.join(renderPath ,'', "test_v1")
			#renderPath = os.path.join(renderPath, "test_v1")
			if os.path.isdir(renderPath):
				nuke.message("test folder already created, please version up")
			else:					
				os.makedirs(renderPath)
				node.knob('file').setValue(renderPath)
				nuke.message("successfully created test directory at: \n\n%s" % renderPath)	
		else:
			nuke.message("please make sure to set a render path")

	#open in finder
	if knob.name() == "open in explorer":
		if renderPath!="":
			try:
				if platform.system() == "Windows":
					os.startfile(renderPath)
				elif platform.system() == "Darwin":
					subprocess.Popen(["open", renderPath])
				else:
					subprocess.Popen(["xdg-open", renderPath])
			except:
				nuke.message("couldn't open render path. No such directory")
		else:
			nuke.message("please make sure to set a render path")		
	
	#create next version
	if knob.name() == "version up":	
		if renderPath != "":
			nukescripts.clear_selection_recursive()
			node.setSelected(True)
			nukescripts.version_up()
			node.setSelected(False)

			fileValue = node["file"].getValue()
			renderPath = os.path.dirname(fileValue)

			if not os.path.isdir(renderPath):
				os.makedirs(renderPath)
				nuke.message("successfully versioned up")
			else:
				nuke.message("please set file path with test_vxx at the end or create a test folder first")
		else:
			nuke.message("please make sure to set a render path")
Ejemplo n.º 9
0
def selectAllClassNodes():
    nukescripts.clear_selection_recursive()
    userInput = nuke.getInput(
        "What type of node do you want to select? \n" +
        "(Correct capitalization matters!) \n" + "no spaces", "Crop")

    for node in nuke.allNodes():
        if node.Class() == userInput:
            node.setSelected(True)

    nuke.message("Selected %d %s nodes." %
                 (len(nuke.selectedNodes()), userInput))
Ejemplo n.º 10
0
def create_child(parent_node):

    parentName = parent_node.knob('name').value()
    parentLabel = parent_node.knob('parentLabel').value()
    parentXpos = parent_node.knob('xpos').value()
    parentYpos = parent_node.knob('ypos').value()

    childName = parentLabel + '_' + str(random.randint(0, 1000000))
    prevChildList = parent_node.knob('childList').value()
    newChildList = prevChildList + childName + '\n'
    parent_node.knob('childList').setValue(newChildList)

    nukescripts.clear_selection_recursive()
    child = nuke.createNode('NoOp', inpanel=False)
    child.setInput(0, nuke.toNode(parentName))
    nuke.toNode(child['name'].value()).setSelected(True)

    child['hide_input'].setValue(
        nuke.toNode(parentName).knob('hideInputTracker').value())
    child['note_font_size'].setValue(20.0)
    child['tile_color'].setValue(3511807)
    child['note_font'].setValue('Verdana Bold Bold Bold')
    child['xpos'].setValue(parentXpos)
    child['ypos'].setValue(parentYpos + 50)
    child['name'].setValue(childName)

    childTabKnob = nuke.Tab_Knob('postalChild', 'postal child')
    child.addKnob(childTabKnob)

    parentIDKnob = nuke.String_Knob('parentID', 'parent ID', parentName)
    child.addKnob(parentIDKnob)

    parentLabelKnob = nuke.String_Knob('parentLabel', 'parent label',
                                       parentLabel)
    child.addKnob(parentLabelKnob)

    CONNECT_TO_PARENT = """
import connect_to_parent
connect_to_parent.connect_to_parent(nuke.thisNode())
"""
    CONNECT_TO_PARENT_TOOLTIP = """
Reconnects this node to its parentID. This button must be pressed to add this child to parent's list of children
	"""
    connectToParentButton = nuke.PyScript_Knob('connectToParent',
                                               'connect to parent',
                                               CONNECT_TO_PARENT)
    connectToParentButton.setFlag(0x0000000000001000)
    connectToParentButton.setTooltip(CONNECT_TO_PARENT_TOOLTIP)
    child.addKnob(connectToParentButton)

    nukescripts.clear_selection_recursive()
    nuke.toNode(child['name'].value()).setSelected(True)
    child['autolabel'].setValue("nuke.thisNode().knob('parentLabel').value()")
Ejemplo n.º 11
0
def copyPremult():

    n = nuke.createNode('Copy')
    m = nuke.createNode('Premult')

    n['selected'].setValue(True)
    m['selected'].setValue(True)

    sel = nuke.selectedNodes()
    for i in sel:
        nuke.autoplace(i)

    nukescripts.clear_selection_recursive()
Ejemplo n.º 12
0
def runner():
    if nuke.thisKnob().name() == 'selected':
        # RANDOM FOR X
        random.seed(random.random())
        randFactX = (random.random() - 0.5)
        # RANDOM FOR Y
        random.seed(random.random())
        randFactY = (random.random() - 0.5)
        # RUN AWAY
        nuke.thisNode().setXpos(nuke.thisNode().xpos() + int(500 * randFactX))
        nuke.thisNode().setYpos(nuke.thisNode().xpos() + int(500 * randFactY))
        # CLEAR SELECTION
        nukescripts.clear_selection_recursive()
Ejemplo n.º 13
0
def selectBackdropContents(backdropNode):
    '''Select all nodes inside a backdrop.
    There is a built in method for this on Nuke6.3v5,
    but this is kept here to expand compatibility
    to earlier versions
    '''
    bx, by = backdropNode.xpos(), backdropNode.ypos()
    nukescripts.clear_selection_recursive()
    backdropNode.setSelected(True)
    nuke.nodeCopy(nukescripts.cut_paste_file())
    nuke.nodeDelete(popupOnError=False)
    nuke.nodePaste(nukescripts.cut_paste_file())
    nuke.selectedNode().setXYpos(bx, by)
Ejemplo n.º 14
0
    def dAutocropFN():

        x = 0 #counter for process loop

        for each in selection:
            processing = selection[x]

            if x <= len(selection):

                x = x+1
            
                #clear selection and prepare a new one for processing 
                nukescripts.clear_selection_recursive()
                processing.knob("selected").setValue(True)

                #create tmp deep to image and store it in a tmp variable
                sSelection = nuke.selectedNode()
                deeptoimg = nuke.createNode('DeepToImage')
                    
                #create a crop to get root format and store in variable
                cropTool = nuke.createNode('Crop')
                cropTool.setInput(0,deeptoimg)
                cropBox = cropTool.knob('box').getValue()
                
                #create and run curvetool    
                curveNode = nuke.createNode('CurveTool')
                curveNode.knob('operation').setValue('AutoCrop')      
                curveNode.knob('name').setValue('tmp_AC')
                curveNode.knob('ROI').setValue(cropBox)    
                nuke.execute(curveNode, nuke.root().firstFrame(), nuke.root().lastFrame())
                
                #create, connect and copy anim to deepcrop
                cropNode = nuke.nodes.DeepCrop()            
                cropNode.knob('bbox').copyAnimations( curveNode.knob('autocropdata').animations() )
                cropNode.setInput(0,sSelection)
                cropNode.knob('use_znear').setValue(False)
                cropNode.knob('use_zfar').setValue(False)
                cropNode.knob('label').setValue('AutoCrop')
                
                #remove tmp nodes
                nuke.delete(deeptoimg)
                nuke.delete(cropTool)
                nuke.delete(curveNode)

            else:
                #break loop and give succes message            
                break       
        return
Ejemplo n.º 15
0
 def run(self):
     node = None
     incs = 1
     for i in range(incs):
         for n, m in self.adult_dict.items():
             if not m:
                 nukescripts.clear_selection_recursive()
                 continue
             node = nuke.createNode("Dot")
             x = m["pos"][0]
             y = m["pos"][1]
             color = m["color"]
             nuke.executeInMainThreadWithResult(node.setXpos, int(x))
             nuke.executeInMainThreadWithResult(node.setYpos, int(y))
             nuke.executeInMainThreadWithResult(node["tile_color"].setValue,
                                                (int(color)))
Ejemplo n.º 16
0
def filepathCreateNode(gizmoName):
    if '.nk' in gizmoName:
        nukescripts.clear_selection_recursive()
        nuke.nodePaste(gizmoName)
        fileNodes = nuke.selectedNodes()
    else:
        newGizmo = nuke.createNode(gizmoName)
        fileNodes = newGizmo.nodes()
    for i in fileNodes:
        if i.Class() == "Read" or i.Class() == "DeepRead" or i.Class(
        ) == "ReadGeo" or i.Class() == "ReadGeo2" or i.Class(
        ) == "Camera2" or i.Class() == "Axis2":
            filepath = i.knob("file").getValue()
            if "<<<replace>>>" in filepath:
                newFilepath = filepath.replace("<<<replace>>>", NST_FolderPath)
                i.knob("file").setValue(newFilepath)
Ejemplo n.º 17
0
def replaceGizmoWithGroup():
    '''
    replace the selected gizmos with the corresponding groups
    '''
    
    sel = nuke.selectedNodes()
    if len(sel)==1:
        gizmoToGroup(nuke.selectedNodes())
    elif len(sel)>1:
        for n in sel:
            nukescripts.clear_selection_recursive()
            if "gizmo" in n.Class():
                n.setSelected(True)
                gizmoToGroup(nuke.selectedNodes())    
    else:
        pass
Ejemplo n.º 18
0
def replaceGizmoWithGroup():
    """
    replace the selected gizmos with the corresponding groups
    """

    sel = nuke.selectedNodes()
    if len(sel) == 1:
        gizmoToGroup(nuke.selectedNodes())
    elif len(sel) > 1:
        for n in sel:
            nukescripts.clear_selection_recursive()
            if "gizmo" in n.Class():
                n.setSelected(True)
                gizmoToGroup(nuke.selectedNodes())
    else:
        pass
Ejemplo n.º 19
0
def view_edge_node(which):
    # print "view node: {}".format(get_edge_node(which).name())
    viewer_port = 8
    edge_node = get_edge_node(which)
    sel = nuke.selectedNodes()

    if edge_node is None:
        return

    nukescripts.clear_selection_recursive()
    edge_node.setSelected(True)
    nukescripts.connect_selected_to_viewer(viewer_port)
    edge_node.setSelected(False)

    for node in sel:
        node.setSelected(True)

    for node in nuke.allNodes("Viewer"):
        node.setSelected(False)
Ejemplo n.º 20
0
def add_cdl():
    '''adds cdl group to IP node'''
    node_cdl = nuke.root().selectedNode()
    print node_cdl.name()
    if node_cdl != nuke.thisNode():
        node_ip = nuke.thisNode()
        #node_ip = nuke.toNode('VIEWER_INPUT')
        with nuke.root():
            nuke.nodeCopy('%clipboard%')
            nukescripts.clear_selection_recursive()

        # k_cdl = nuke.Boolean_Knob('cdl', "AVID GRADE CDL")
        # k_cdl.setFlag(nuke.STARTLINE)
        # node_ip.addKnob(k_cdl)

        with node_ip:
            group_input = nuke.toNode('Input')
            group_input.setSelected(True)
            node_cdl = nuke.nodePaste('%clipboard%')
            node_cdl['disable'].setExpression('!parent.cdl')
Ejemplo n.º 21
0
def add_gizmo(menu_item):
    if nuke.selectedNode().Class() not in ('Group', 'Gizmo'):
        nuke.message('You should select a Group or Gizmo node.')
        return
    dialog = AddGizmoDialog()
    if dialog.exec_():
        name = dialog.name
        gizmo = nuke.selectedNode()
        nukescripts.clear_selection_recursive()
        gizmo.setSelected(True)
        if gizmo.name() != name:
            gizmo.setName('{}1'.format(name))
        gizmo_path = path_join(menu_item.path, '{}.gizmo'.format(name))
        makedirs(gizmo_path)
        nuke.nodeCopy(gizmo_path)
        command = menu_item.add_sub_command(
            name, "nuke.createNode('{}')".format(name))
        if command:
            command.file_path = gizmo_path
            command.create()
Ejemplo n.º 22
0
def build_remove(dict_remove, node):
    '''rebuild Remove node everytime it's called
    @dict_remove: (dict of str, int: [str,...]) filtered dict of layers
    @node: (obj) node object to build
    '''

    CH = ['channels', 'channels2', 'channels3', 'channels4']

    with node:
        for r in nuke.allNodes('Remove'):
            nuke.delete(r)

        nukescripts.clear_selection_recursive()
        nuke.toNode('Input').setSelected(True)
        
        for k in dict_remove:
            node_remove = nuke.createNode('Remove', 'operation remove', inpanel=False)
            thisGroup = dict_remove[k]
            node_remove['label'].setValue(', '.join(thisGroup))
            for idx, l in enumerate(thisGroup):
                node_remove[CH[idx]].setValue(l)
Ejemplo n.º 23
0
def replaceNode(oldNode, newNode):
    """
    Replace an node by new one.
    Relink the new node.
    The nodes should have the same inputs/outputs
    Rename the new node with the old one name
    """
    # TODO make a "clear selection" in pfNukeUtils
    nukescripts.clear_selection_recursive()

    # Store name and position
    oldName = oldNode.name()
    oldPosition = (oldNode.xpos(), oldNode.ypos())

    # Link node to the same inputs
    for i in range(oldNode.inputs()):
        newNode.setInput(i, oldNode.input(i))

    # Store inputs of dependent nodes
    inputs = [(n, i) for n in oldNode.dependent()
                        for i in range(n.inputs())
                            if n.input(i) == oldNode ]

    # Disconnect
    for i in range(oldNode.inputs()):
        oldNode.setInput(i, None)

    nuke.delete(oldNode)

    # Reconnect inputs of dependent nodes
    for n, i in inputs:
        n.setInput(i, newNode)

    # Set name
    newNode.setName(oldName)

    # Set position
    newNode.knob("xpos").setValue(oldPosition[0])
    newNode.knob("ypos").setValue(oldPosition[1])
Ejemplo n.º 24
0
def customSave(mode='save'):
    if mode == 'save':
        nuke.scriptSave("")

    elif mode == 'saveAs':
        nuke.scriptSaveAs("")

    elif mode == "saveNewVersion":
        write_list = [
            write for write in nuke.allNodes('Write') if script_name(
                nuke.filename(write)) == script_name(nuke.scriptName())
        ]
        nukescripts.script_and_write_nodes_version_up()
        if write_list:
            selectedNodes = nuke.selectedNodes()[:]
            nukescripts.clear_selection_recursive()
            for write in write_list:
                write.setSelected(True)
                nukescripts.version_up()
                write.setSelected(False)
            for node in selectedNodes:
                node.setSelected(True)
            nuke.scriptSave("")
Ejemplo n.º 25
0
 def selectObject(applicationObject='', clearSelection=True):
     if clearSelection:
         nukescripts.clear_selection_recursive()
     n = nuke.toNode(HelpFunctions.safeString(applicationObject))
     n.knob('selected').setValue(True)
Ejemplo n.º 26
0
def reset_selection():
    """Deselect all selected nodes
    """
    clear_selection_recursive()
Ejemplo n.º 27
0
def collectFilesPanel():
    cp = nuke.Panel("项目打包      by jgcy", 450)
    cp.addSingleLineInput("输出文件名:", nuke.Root().name().split("/")[-1][:-3])
    # addSingleLineInput() 添加文本输入框

    dirTemp = list(os.path.split(nuke.root()['name'].getValue()))[0] + "/"
    cp.addFilenameSearch("输出路径:", dirTemp)

    cp.addEnumerationPulldown("输出节点方式:", "所有节点 仅打包所选节点")
    cp.addButton("取消")
    cp.addButton("打包")

    result = cp.show()

    if result == 1:
        outDir = cp.value("输出路径:")
        inScriptName = cp.value("输出文件名:")
        allOrSel = cp.value("输出节点方式:")

        if allOrSel == "所有节点":
            doNodes = nuke.allNodes('Read')

            nuke.selectAll()
            newPath = outDir + inScriptName + ".nk"

            # 判断输出路径是否存在
            if os.path.exists(outDir):
                nuke.nodeCopy(newPath)

            else:
                os.mkdir(outDir)
                nuke.nodeCopy(newPath)

            fmat = nuke.root().format()

            # 设置项目尺寸与时间帧到新文件中
            f = open(newPath, "a")
            f.write("\n")
            f.write("Root {\n")
            f.write("first_frame {0} \n".format(
                nuke.root()["first_frame"].getValue()))
            f.write("last_frame {0} \n".format(
                nuke.root()["last_frame"].getValue()))
            f.write("fps {0} \n".format(nuke.root()["fps"].getValue()))
            f.write('format "{0} {1} {2} {3}"\n'.format(
                fmat.width(), fmat.height(), int(fmat.pixelAspect()),
                fmat.name()))
            f.write("}\n")
            f.close()

            nukescripts.clear_selection_recursive()

            return inScriptName, outDir, doNodes

        else:
            if nuke.selectedNodes() == []:
                nuke.message("请选择要输出的节点")

            doNodes = nuke.selectedNodes('Read')
            newPath = outDir + inScriptName + ".nk"

            # 判断输出路径是否存在
            if os.path.exists(outDir):

                nuke.nodeCopy(newPath)

            else:
                os.mkdir(outDir)
                nuke.nodeCopy(newPath)

            fmat = nuke.root().format()

            # 设置项目尺寸与时间帧到新文件中
            f = open(newPath, "a")
            f.write("\n")
            f.write("Root {\n")
            f.write("first_frame {0} \n".format(
                nuke.root()["first_frame"].getValue()))
            f.write("last_frame {0} \n".format(
                nuke.root()["last_frame"].getValue()))
            f.write("fps {0} \n".format(nuke.root()["fps"].getValue()))
            f.write('format "{0} {1} {2} {3}"\n'.format(
                fmat.width(), fmat.height(), int(fmat.pixelAspect()),
                fmat.name()))
            f.write("}\n")
            f.close()

            return inScriptName, outDir, doNodes
Ejemplo n.º 28
0
def create_nodeTree(node):

    n = node
    n1, n2, n3 = None, None, None

    controls = nuke.nodes.NoOp(name='CONTROLS',
                               xpos=n.xpos() + 300,
                               ypos=n.ypos())

    texInput = nuke.nodes.Input(name='tex01',
                                xpos=n.xpos() - 34,
                                ypos=250 + n.ypos())

    dot = nuke.nodes.Dot(xpos=0 + n.xpos(), ypos=100 + n.ypos(), inputs=[n])
    dot1 = nuke.nodes.Dot(xpos=250 + n.xpos(),
                          ypos=100 + n.ypos(),
                          inputs=[dot])

    n = dot1
    n1 = texInput

    for l in m_layers:
        print(str("Adding layer " + l))
        x, y = n.xpos(), n.ypos()

        dot1 = nuke.nodes.Dot(xpos=x + 350, ypos=y + 0, inputs=[n])
        shuffle = nuke.nodes.Shuffle(xpos=x - 34, ypos=y + 50, inputs=[n])
        shuffle['in'].setValue(str(l))
        shuffle['label'].setValue('[value in]')
        nukescripts.clear_selection_recursive()
        shuffle['selected'].setValue(True)

        try:
            nukescripts.autocrop(layer='a')
        except:
            print("oops")
            return

        autocrop = shuffle.dependent()[0]
        acName = autocrop.name()

        dot2 = nuke.nodes.Dot(xpos=x - 100, ypos=y + 200, inputs=[n1])

        transform = nuke.nodes.Transform(xpos=x - 134,
                                         ypos=y + 250,
                                         inputs=[dot2])
        transform['center'].setExpression('width/2', 0)
        transform['center'].setExpression('height/2', 1)

        scaleOffset = nuke.Double_Knob('{}_scale'.format(str(l)),
                                       '{}_scale'.format(str(l)))
        rotateOffset = nuke.Double_Knob('{}_rotate'.format(str(l)),
                                        '{}_rotate'.format(str(l)))
        controls.addKnob(scaleOffset)
        controls.addKnob(rotateOffset)
        controls['{}_scale'.format(str(l))].setRange(1, 5)
        controls['{}_scale'.format(str(l))].setValue(1)
        controls['{}_rotate'.format(str(l))].setRange(0, 360)
        controls['{}_rotate'.format(str(l))].setValue(0)
        transform['scale'].setExpression(
            'parent.global_scale * CONTROLS.{}_scale'.format(str(l)))
        transform['rotate'].setExpression(
            'parent.global_rotate + CONTROLS.{}_rotate'.format(str(l)))

        knobList.append('{}.{}_scale'.format(controls.name(), str(l)))
        knobList.append('{}.{}_rotate'.format(controls.name(), str(l)))

        cornerpin = nuke.nodes.CornerPin2D(xpos=x - 134,
                                           ypos=y + 300,
                                           inputs=[transform])

        cornerpin['to1'].setExpression('{}.bbox.x'.format(acName), 0)
        cornerpin['to1'].setExpression('{}.bbox.y'.format(acName), 1)
        cornerpin['to2'].setExpression('{}.bbox.r'.format(acName), 0)
        cornerpin['to2'].setExpression('{}.bbox.y'.format(acName), 1)
        cornerpin['to3'].setExpression('{}.bbox.r'.format(acName), 0)
        cornerpin['to3'].setExpression('{}.bbox.t'.format(acName), 1)
        cornerpin['to4'].setExpression('{}.bbox.x'.format(acName), 0)
        cornerpin['to4'].setExpression('{}.bbox.t'.format(acName), 1)

        cornerpin['from2'].setExpression('width', 0)
        cornerpin['from3'].setExpression('width', 0)
        cornerpin['from3'].setExpression('height', 1)
        cornerpin['from4'].setExpression('height', 1)

        copy = nuke.nodes.Copy(xpos=x - 34,
                               ypos=y + 290,
                               inputs=[autocrop, cornerpin])
        copy['from0'].setValue('none')
        copy['to0'].setValue('none')
        copy['channels'].setValue('rgb')
        copy['bbox'].setValue('B')

        premult = nuke.nodes.Premult(xpos=x - 34, ypos=y + 350, inputs=[copy])

        if m_layers.index(l) < 1:
            dot3 = nuke.nodes.Dot(xpos=x, ypos=y + 400, inputs=[premult])
            n2 = dot3
        elif m_layers.index(l) >= 1:
            merge = nuke.nodes.Merge2(xpos=x - 34,
                                      ypos=y + 400,
                                      inputs=[premult, n2])
            merge['operation'].setValue('disjoint_over')
            n2 = merge

        if m_layers.index(l) == len(m_layers) - 1:
            shuffle = nuke.nodes.Shuffle(xpos=x - 34,
                                         ypos=y + 600,
                                         inputs=[n2])
            shuffle['alpha'].setValue('red')
            output = nuke.nodes.Output(xpos=x - 34,
                                       ypos=y + 650,
                                       inputs=[shuffle])

        n = dot1
        n1 = dot2
Ejemplo n.º 29
0
def textureTrackSetup(DIP):

    # Create variables
    # DIP = nuke.selectedNode()
    channels = DIP.channels()
    global m_layers
    m_layers = []

    # Create sorted list of DIP layers
    global layers
    layers = sorted(list(set([c.split('.')[0] for c in channels])))

    # Look for layers that have "m_" and append them to m_layers
    for layer in layers:
        if "m_" in layer:
            m_layers.append(layer)
            print("Added " + str(layer))

    if len(m_layers) < 1:
        nuke.message('No layers starting with "m_" found...')
        return

    # Create DIP layer if it's not found
    if 'DIP' not in nuke.layers():
        nuke.Layer('DIP', ['DIP.red', 'DIP.green', 'DIP.blue', 'DIP.alpha'])
        "DIP layer not found. Creating DIP layer."
    else:
        print("DIP layer found.")

    # Clear selection
    #nukescripts.clear_selection_recursive()

    # Create tex01 layer if not found
    if 'tex01' not in nuke.layers():
        nuke.Layer('tex01',
                   ['tex01.red', 'tex01.green', 'tex01.blue', 'tex01.alpha'])

    nukescripts.clear_selection_recursive()
    DIP['selected'].setValue(True)
    grp = nuke.createNode('Group', inpanel=False)
    grp.setName('TPD_TextureTrack')
    grp['xpos'].setValue(DIP.xpos())
    grp['ypos'].setValue(85 + DIP.ypos())
    grp.setInput(0, DIP)
    print('Created Group node')

    text = nuke.Text_Knob(
        'title', ' ',
        '<i>TPD_TextureTrack</i></b> {}<br>by Noah Catan<br><br><b>'.format(
            version))
    div1 = nuke.Text_Knob('div', ' ')
    grp.addKnob(text)
    grp.addKnob(div1)

    global_scale = nuke.Double_Knob('global_scale', 'global scale')
    global_rotate = nuke.Double_Knob('global_rotate', 'global rotate')
    div = nuke.Text_Knob('div', ' ')
    grp.addKnob(global_scale)
    grp.addKnob(global_rotate)
    grp.addKnob(div)
    grp['global_scale'].setRange(1, 5)
    grp['global_scale'].setValue(1)
    grp['global_rotate'].setRange(0, 360)
    grp['global_rotate'].setValue(0)

    with grp:
        input1 = nuke.nodes.Input()
        dot = nuke.nodes.Dot(xpos=34 + input1.xpos(),
                             ypos=200 + input1.ypos(),
                             inputs=[input1])
        create_nodeTree(dot)
    '''for transform in transformList:
		knobTarget = "{}.{}".format(transform.name(), 'scaleOffset')
		linkedKnobs.append(knobTarget)

	for knob in linkedKnobs:
		link_knob = nuke.Link_Knob("{}".format(layers[linkedKnobs.index(knob)]))
		link_knob.setLink(knob)
		grp.addKnob(link_knob)'''

    for knob in knobList:
        link_knob = nuke.Link_Knob('{}'.format(knob[9:]))
        link_knob.setLink(knob)
        grp.addKnob(link_knob)
Ejemplo n.º 30
0
    def knobChanged(self, knob):

        #update
        if knob.name() == "update":

            #reset
            for btn in nuke.errors_footageBtn:
                self.removeKnob(btn)

            nuke.errors_footageBtn = []
            errors = []
            nuke.errors_nodes = []
            nuke.errors_missingFrames = []

            with nuke.root():
                all = nuke.allNodes()
                for n in all:
                    if n.Class() != "Read":
                        if n.hasError():
                            errors.append(n.name())
                            if n not in nuke.errors_nodes:
                                nuke.errors_nodes.append(n)
                    else:
                        for frame in range(int(n["first"].getValue()),
                                           int(n["last"].getValue()) + 1):
                            try:
                                f = nukescripts.replaceHashes(
                                    n['file'].value()) % (frame)
                            except:
                                f = ""
                            if not os.path.isfile(f):
                                errors.append(f)
                                if f not in nuke.errors_missingFrames:
                                    nuke.errors_missingFrames.append(f)
                                if n not in nuke.errors_nodes:
                                    nuke.errors_nodes.append(n)

            for errorNode in nuke.errors_nodes:
                self.en = nuke.PyScript_Knob(errorNode.name(),
                                             errorNode.name())
                self.addKnob(self.en)
                nuke.errors_footageBtn.append(self.en)

            nuke.errors_lenErrors = len(errors)

            if nuke.errors_lenErrors == 0:
                col = "green"
            else:
                col = "red"
            countErrors = '<span style="color:{col}">{countErr}</span>'.format(
                col=col, countErr=nuke.errors_lenErrors)
            self.errorCount.setValue(countErrors)

        #write
        if knob.name() == "write":
            if self.outputPath.getValue() != "":
                try:
                    script = os.path.basename(nuke.root().name())
                    output = os.path.dirname(self.outputPath.getValue(
                    )) + "/errorReport_%s" % script.replace(".nk", ".txt")

                    errorOutput = open(output, 'w')
                    date = time.strftime("%d-%m-%Y %H:%M:%S", time.gmtime())
                    header = "error report \nscript name: {scriptname}\nscript path: {scriptPath}\ndate: {date}\nnumber of errors: {countErrors}\n------------------------------".format(
                        scriptname=script,
                        scriptPath=nuke.root().name(),
                        date=date,
                        countErrors=nuke.errors_lenErrors)
                    errorOutput.write(header)

                    #all read nodes
                    errorOutput.write("\nread nodes\n\n")
                    for n in nuke.errors_nodes:
                        if n.Class() == "Read":
                            errorOutput.write("read node: %s\n" % n.name())
                    #all missing frames
                    errorOutput.write("\n----------\nmissing frames\n\n")
                    for f in nuke.errors_missingFrames:
                        errorOutput.write("missing frame: %s\n" % f)
                    #all other nodes
                    errorOutput.write("\n----------\nother nodes\n\n")
                    for n in nuke.errors_nodes:
                        if n.Class() != "Read":
                            errorOutput.write("node: %s\n" % n.name())

                    nuke.message(
                        "successfully written error report to:\n\n%s" % output)
                except:
                    nuke.message(
                        "some error occured. The report could not be written.")
            else:
                nuke.message(
                    "Please enter a output path for the error report.")

        #all other error nodes
        else:
            allNodes = nuke.allNodes()
            pKnob = knob.name()
            for n in allNodes:
                if n.name() == pKnob:
                    nuke.zoom(1, [n.xpos(), n.ypos()])
                    nukescripts.clear_selection_recursive()
                    n.setSelected(True)
Ejemplo n.º 31
0
 def selectObjects(selection):
     nukescripts.clear_selection_recursive()
     for obj in selection:
         Connector.selectObject(obj, clearSelection=False)
Ejemplo n.º 32
0
    def knobChanged( self, knob ): 
     
        #update
        if knob.name()=="update":
            
            #reset
            for btn in nuke.errors_footageBtn:
                self.removeKnob(btn)

            nuke.errors_footageBtn=[]
            errors=[]
            nuke.errors_nodes=[]
            nuke.errors_missingFrames=[]
            
            with nuke.root():
                all = nuke.allNodes()
                for n in all: 
                    if n.Class()!="Read":
                        if n.hasError():    
                            errors.append(n.name())
                            if n not in nuke.errors_nodes:
                                nuke.errors_nodes.append(n)
                    else:
                        for frame in range(int(n["first"].getValue()), int(n["last"].getValue())+1):
                            try:
                                f = nukescripts.replaceHashes(n['file'].value() ) % (frame)
                            except:
                                f = ""
                            if not os.path.isfile(f):
                                errors.append(f)
                                if f not in nuke.errors_missingFrames:
                                    nuke.errors_missingFrames.append(f)
                                if n not in nuke.errors_nodes:
                                    nuke.errors_nodes.append(n)

            for errorNode in nuke.errors_nodes:
                self.en = nuke.PyScript_Knob(errorNode.name(), errorNode.name())
                self.addKnob(self.en)   
                nuke.errors_footageBtn.append(self.en) 
            
            nuke.errors_lenErrors=len(errors)
           
            if nuke.errors_lenErrors==0:
                col="green"
            else:
                col="red"
            countErrors = '<span style="color:{col}">{countErr}</span>'.format(col=col, countErr=nuke.errors_lenErrors)
            self.errorCount.setValue(countErrors)
         
        #write
        if knob.name()=="write":
            if self.outputPath.getValue()!="":
                try:
                    script = os.path.basename(nuke.root().name())
                    output= os.path.dirname(self.outputPath.getValue()) + "/errorReport_%s" % script.replace(".nk",".txt")

                    errorOutput = open(output,'w')
                    date = time.strftime("%d-%m-%Y %H:%M:%S", time.gmtime())
                    header="error report \nscript name: {scriptname}\nscript path: {scriptPath}\ndate: {date}\nnumber of errors: {countErrors}\n------------------------------".format(scriptname=script, scriptPath=nuke.root().name(), date=date, countErrors=nuke.errors_lenErrors)
                    errorOutput.write(header)

                    #all read nodes
                    errorOutput.write("\nread nodes\n\n")
                    for n in nuke.errors_nodes:
                        if n.Class()=="Read":
                            errorOutput.write("read node: %s\n" % n.name())
                    #all missing frames
                    errorOutput.write("\n----------\nmissing frames\n\n")
                    for f in nuke.errors_missingFrames:
                        errorOutput.write("missing frame: %s\n" % f)
                    #all other nodes
                    errorOutput.write("\n----------\nother nodes\n\n")
                    for n in nuke.errors_nodes:
                        if n.Class()!="Read":
                            errorOutput.write("node: %s\n" % n.name())

                    nuke.message("successfully written error report to:\n\n%s" % output)
                except:
                    nuke.message("some error occured. The report could not be written.")
            else:
                nuke.message("Please enter a output path for the error report.")
         
        #all other error nodes   
        else:
            allNodes=nuke.allNodes()
            pKnob=knob.name()
            for n in allNodes:
                if n.name() == pKnob: 
                    nuke.zoom( 1, [ n.xpos(), n.ypos() ])
                    nukescripts.clear_selection_recursive()
                    n.setSelected(True)
            def multiChannelSplit():
                '''
                main function
                split the selected read node in separate channel layers
                if set create separate folders and write nodes
                '''
                sel = nuke.selectedNode()

                shuffles = []
                renderTo = ""
                autocropNodeRGB_exists = False
                cropNode = None
                dot = None

                if sel is not None:
                    # Main procedure
                    # Create shuffle, shuffle channel in, curvetool crop
                    # Create cropnode and paste that information in
                    # Delete crop node
                    o = 0
                    if self.autoCrop.getValue() == 1.0:
                        curveName = 'Autocrop_Master'
                        curveNode = nuke.nodes.CurveTool(name=curveName,
                                                         inputs=[sel],
                                                         operation="Auto Crop")
                        curveNode["channels"].setValue("rgba")
                        curveNode.knob("ROI").setValue(
                            [0, 0, sel.width(),
                             sel.height()])
                        nuke.execute(curveNode,
                                     sel.knob("first").value(),
                                     sel.knob("last").value())

                    layersToProcess = []
                    if self.which.getValue() == 0.0:
                        layersToProcess = uniqueLayers
                    else:
                        for layer in layerCheckboxes:
                            if layer.getValue() is True:
                                layersToProcess.append(layer.name())

                    if len(layersToProcess) > 0:
                        dot = nuke.createNode("Dot", inpanel=False)

                        for channelLayer in layersToProcess:
                            shuffleName = "Shuffle_" + channelLayer
                            shuffleNode = nuke.nodes.Shuffle(name=shuffleName)
                            shuffles.append(shuffleNode.name())
                            shuffleNode.knob("in").setValue(channelLayer)
                            shuffleNode["hide_input"].setValue(True)
                            shuffleNode.setInput(0, sel)

                            xpos = sel["xpos"].getValue() + (o * 100)
                            ypos = sel["ypos"].getValue() + 150
                            shuffleNode["xpos"].setValue(xpos)
                            shuffleNode["ypos"].setValue(ypos)
                            shuffleNode.setInput(0, dot)
                            shuffleNode["postage_stamp"].setValue(True)

                            # Auto crop if selected
                            if self.autoCrop.getValue() == 1.0:
                                if autocropNodeRGB_exists is False:
                                    cropNode = nuke.nodes.Crop(
                                        name=channelLayer,
                                        inputs=[shuffleNode])
                                    cropNode.knob("hide_input").setValue(True)
                                    cropNode.knob("box").copyAnimations(
                                        curveNode.knob(
                                            "autocropdata").animations())
                                    nuke.delete(curveNode)
                                    cropNode.knob("postage_stamp").setValue(
                                        True)

                                    xpos = int(shuffleNode["xpos"].getValue())
                                    ypos = shuffleNode["ypos"].getValue() + 80
                                    ypos = int(ypos)
                                    cropNode.setXpos(xpos)
                                    cropNode.setYpos(ypos)
                                    shuffleNode["hide_input"].setValue(False)
                                    cropNode["hide_input"].setValue(True)
                                    nukescripts.clear_selection_recursive()
                                    cropNode["selected"].setValue(True)
                                    nuke.nodeCopy("%clipboard%")
                                    autocropNodeRGB_exists = True
                                    shuffleNode["postage_stamp"].setValue(
                                        False)
                                    cropNode["postage_stamp"].setValue(True)
                                else:
                                    cropCopy = nuke.nodePaste("%clipboard%")
                                    cropCopy["name"].setValue(channelLayer)
                                    cropCopy.setInput(0, shuffleNode)

                                    xpos = int(shuffleNode["xpos"].getValue())
                                    ypos = shuffleNode["ypos"].getValue() + 80
                                    ypos = int(ypos)
                                    cropCopy.setXpos(xpos)
                                    cropCopy.setYpos(ypos)

                            # Create folders for all layer and
                            # Create write node for every shuffle
                            if self.outputPath.getValue() != "":
                                renderTo = self.outputPath.getValue()
                                # CreateFolder
                                createFolders(renderTo + "/" + channelLayer)
                                # Create write node
                                write = nuke.nodes.Write()
                                write.knob("file_type").setValue("exr")

                                fileValue = renderTo + channelLayer
                                fileValue += '/' + channelLayer + "_%04d.exr"
                                write.knob("file").setValue(fileValue)

                                cValue = "Zip (16 scanlines)"
                                write.knob("compression").setValue(cValue)
                                write.knob("channels").setValue("rgba")

                                if self.autoCrop.getValue() is True:
                                    write.setInput(0, cropNode)
                                else:
                                    write.setInput(0, shuffleNode)
                            o += 1

                    if len(layersToProcess) > 0:
                        nuke.delete(dot)

                    # Hide all created shuffle inputs
                    for shuffleNode in shuffles:
                        if self.autoCrop.getValue() == 1.0:
                            temp = nuke.toNode(shuffleNode)
                            temp.knob("hide_input").setValue(True)
                            temp.knob("postage_stamp").setValue(True)
                else:
                    pass
Ejemplo n.º 34
0
def create_lp_nodes(lpass, node):
    '''
        Creates a nodes for a single light pass
    '''

    #clear selection
    nukescripts.clear_selection_recursive()

    # Get parent_dot's position
    parent_dot = node
    x = parent_dot.xpos()
    y = parent_dot.ypos()

    #store nodes in a list
    nodes_created = []

    #node_Dot_2
    node_Dot_2 = nuke.nodes.Dot(xpos=0+x,ypos=81+y,inputs=[parent_dot])
    node_Dot_2['name'].setValue('DOT2_{}'.format(lpass.upper()))
    nodes_created.append(node_Dot_2)
    
    #node_Shuffle_1 - LIGHT PASS
    node_Shuffle_1 = nuke.nodes.Shuffle(xpos=-34+x,ypos=157+y,inputs=[node_Dot_2])
    node_Shuffle_1['name'].setValue('SHUFFLE_{}'.format(lpass.upper()))
    node_Shuffle_1['in'].fromScript('LGHT_{}'.format(lpass.upper()))
    node_Shuffle_1['label'].setValue('[value in]')
    node_Shuffle_1['red'].fromScript('black')
    node_Shuffle_1['green'].fromScript('black')
    node_Shuffle_1['blue'].fromScript('black')
    nodes_created.append(node_Shuffle_1)
    
    #node_Shuffle_2 - DIP ALPHA
    node_Shuffle_2 = nuke.nodes.Shuffle(xpos=90+x,ypos=72+y,inputs=[node_Dot_2])
    node_Shuffle_2['in'].fromScript('DIP')
    node_Shuffle_2['label'].setValue('[value in]')
    node_Shuffle_2['red'].fromScript('white')
    node_Shuffle_2['green'].fromScript('white')
    node_Shuffle_2['blue'].fromScript('white')
    nodes_created.append(node_Shuffle_2)
    
    #node_Grade_1      LIGHT
    node_Grade_1 = nuke.nodes.Grade(xpos=182+x,ypos=113+y,inputs=[node_Shuffle_2])
    node_Grade_1['name'].setValue('{}_LIGHT'.format(lpass.upper()))
    node_Grade_1['white'].setValue([0.0, 0.0, 0.0, 0.0])
    node_Grade_1['label'].setValue('LIGHT')
    nodes_created.append(node_Grade_1)
    
    #node_Grade_2      SHADOW
    node_Grade_2 = nuke.nodes.Grade(xpos=90+x,ypos=113+y,inputs=[node_Shuffle_2])
    node_Grade_2['name'].setValue('{}_SHADOW'.format(lpass.upper()))
    if lpass in lightPassesMultiply:
        node_Grade_2['white'].setValue([1.0,1.0,1.0,1.0])
    elif lightPasses.index(lpass)<=0:
        node_Grade_2['white'].setValue([0.2, 0.2, 0.2, 0.2])
    else:
        node_Grade_2['white'].setValue([0.0, 0.0, 0.0, 0.0])
    node_Grade_2['label'].setValue('SHADOW')
    nodes_created.append(node_Grade_2)
    
    #node_Keymix_1
    node_Keymix_1 = nuke.nodes.Keymix(xpos=90+x,ypos=157+y,inputs=[node_Grade_2,node_Grade_1,node_Shuffle_1])
    node_Keymix_1['name'].setValue('{}_KEYMIX'.format(lpass.upper()))
    node_Keymix_1['channels'].fromScript('rgb')
    nodes_created.append(node_Keymix_1)

    #node_Merge_1
    if lightPasses.index(lpass) > 0:
        node_Merge_1 = nuke.nodes.Merge2(xpos=90+x,ypos=250+y,inputs=[None, node_Keymix_1])
        node_Merge_1['name'].setValue('{}_MERGE'.format(lpass.upper()))
        node_Merge_1['Achannels'].setValue('rgb')
        node_Merge_1['Bchannels'].setValue('rgb')
        node_Merge_1['output'].setValue('rgb')
        if lpass in lightPassesMultiply:
            node_Merge_1['operation'].setValue('multiply')
        else:
            node_Merge_1['operation'].setValue('plus')
Ejemplo n.º 35
0
            def multiChannelSplit():
                '''
                main function
                split the selected read node in separate channel layers
                if set create separate folders and write nodes 
                '''
                sel = nuke.selectedNode()
                
                shuffles=[]
                renderTo=""
                autocropNodeRGB_exists=False
                cropNode=None
                dot=None

                if sel != None:

                    #main procedure
                    #create shuffle, shuffle channel in, curvetool crop, create cropnode and paste that information in, delete crop node
                            
                    o=0;
                    
                    if self.autoCrop.getValue()==1.0:
                        curveNode = nuke.nodes.CurveTool(name="Autocrop_Master", inputs = [sel], operation="Auto Crop")
                        curveNode["channels"].setValue("rgba")
                        curveNode.knob("ROI").setValue([0,0,sel.width(),sel.height()])
                        nuke.execute(curveNode, sel.knob("first").value(), sel.knob("last").value())
                    
                    layersToProcess=[]

                    if self.which.getValue()== 0.0:
                        layersToProcess = uniqueLayers
                    else:
                        for layer in layerCheckboxes:
                            if layer.getValue()==True:
                                layersToProcess.append(layer.name())

                    if len(layersToProcess)>0:
                        dot = nuke.createNode("Dot", inpanel=False)

                        for channelLayer in layersToProcess:
                            shuffleNode = nuke.nodes.Shuffle(name="Shuffle_"+channelLayer)        
                            shuffles.append(shuffleNode.name())
                            shuffleNode.knob("in").setValue(channelLayer)
                            shuffleNode["hide_input"].setValue(True)
                            shuffleNode.setInput(0,sel)
                            shuffleNode["xpos"].setValue(sel["xpos"].getValue()+(o*100))
                            shuffleNode["ypos"].setValue(sel["ypos"].getValue()+150)
                            shuffleNode.setInput(0,dot)
                            shuffleNode["postage_stamp"].setValue(True)
                            
                            #auto crop if selected
                            if self.autoCrop.getValue()==1.0:
                                if autocropNodeRGB_exists==False:
                                    cropNode = nuke.nodes.Crop(name=channelLayer, inputs = [shuffleNode])
                                    cropNode.knob("hide_input").setValue(True)
                                    cropNode.knob("box").copyAnimations(curveNode.knob("autocropdata").animations())
                                    nuke.delete(curveNode)
                                    cropNode.knob("postage_stamp").setValue(True)
                                    cropNode.setXpos(int(shuffleNode["xpos"].getValue()))
                                    cropNode.setYpos(int(shuffleNode["ypos"].getValue()+80))                                    
                                    shuffleNode["hide_input"].setValue(False)
                                    cropNode["hide_input"].setValue(True)
                                    nukescripts.clear_selection_recursive()
                                    cropNode["selected"].setValue(True)
                                    nuke.nodeCopy("%clipboard%")
                                    autocropNodeRGB_exists=True
                                    shuffleNode["postage_stamp"].setValue(False)
                                    cropNode["postage_stamp"].setValue(True)
                                else:    
                                    cropCopy = nuke.nodePaste("%clipboard%")
                                    cropCopy["name"].setValue(channelLayer)
                                    cropCopy.setInput(0,shuffleNode)
                                    cropCopy.setXpos(int(shuffleNode["xpos"].getValue()))
                                    cropCopy.setYpos(int(shuffleNode["ypos"].getValue()+80))        
                        
                            #create folders for all layer and create write node for every shuffle                       
                            if self.outputPath.getValue()!="":
                                renderTo = self.outputPath.getValue()
                                #createFolder
                                createFolders(renderTo+"/"+channelLayer)            
                                #create write node
                                write = nuke.nodes.Write()
                                write.knob("file_type").setValue("exr")
                                write.knob("file").setValue(renderTo+channelLayer+"/"+channelLayer+"_%04d.exr")
                                write.knob("compression").setValue("Zip (16 scanlines)")
                                write.knob("channels").setValue("rgba")
     
                                if self.autoCrop.getValue()==True:       
                                    write.setInput(0,cropNode) 
                                else:
                                    write.setInput(0,shuffleNode) 
                            o+=1  
                         
                    if len(layersToProcess)>0:
                        nuke.delete(dot)

                    #hide all created shuffle inputs
                    for shuffleNode in shuffles:
                        if self.autoCrop.getValue()==1.0:
                            temp = nuke.toNode(shuffleNode)
                            temp.knob("hide_input").setValue(True)
                            temp.knob("postage_stamp").setValue(True)
                else:
                    pass
Ejemplo n.º 36
0
def performCustomAction():

    node = nuke.thisNode()
    knob = nuke.thisKnob()

    fileValue = node["file"].getValue()
    renderPath = os.path.dirname(fileValue)

    #reveal in explorer
    if knob.name() == "reveal in explorer":
        if renderPath != "":
            try:
                if platform.system() == "Windows":
                    os.startfile(renderPath)
                elif platform.system() == "Darwin":
                    subprocess.Popen(["open", renderPath])
                else:
                    subprocess.Popen(["xdg-open", renderPath])
            except:
                nuke.message("couldn't open render path. No such directory")
        else:
            nuke.message("Please make sure to set a render path")

    #create next version
    if knob.name() == "create next version":
        if renderPath != "":
            nukescripts.clear_selection_recursive()
            node.setSelected(True)
            nukescripts.version_up()
            node.setSelected(False)

            fileValue = node["file"].getValue()
            renderPath = os.path.dirname(fileValue)

            if not os.path.isdir(renderPath):
                os.makedirs(renderPath)
                nuke.message("successfully versioned up")
            else:
                nuke.message("Renderfolder '%s' seems to exist" % renderPath)
        else:
            nuke.message("Please make sure to set a render path")

    #force create directory
    if knob.name() == "force create directory":
        if renderPath != "":
            if not os.path.isdir(renderPath):
                os.makedirs(renderPath)
                nuke.message(
                    "successfully created render directory at: \n\n%s" %
                    renderPath)
            else:
                nuke.message("render directory exists")
        else:
            nuke.message("Please make sure to set a render path")

    #save backup
    if knob.name() == "save backup":
        if knob.getValue() == 1.0:
            node["beforeRender"].setValue("nextVersion.saveBackup('%s')" %
                                          node.name())
        else:
            node["beforeRender"].setValue("")