def BatScriptRenderFull(): # Save Script nuke.scriptSave() # Variables of Script nukescript = nuke.value("root.name") start = nuke.knob("first_frame") end = nuke.knob("last_frame") path = nukescript + ".bat" # Cmd Message nuke.tprint("\nBatScriptRender\nSave Script " + nukescript) # Bat File Panel swt = ['-x', '-X'] nfr = ['""', ',2', ',5', ',10', ',15', ',20'] myPanel = nuke.Panel("BatScriptRender - Parameters", 338) myPanel.addSingleLineInput("nuke version: ", "nuke5.1") myPanel.addEnumerationPulldown("switches: ", ' '.join(swt)) myPanel.addSingleLineInput("node: ", "") myPanel.addSingleLineInput("script: ", nukescript) myPanel.addSingleLineInput("start frame: ", start) myPanel.addSingleLineInput("end frame: ", end) myPanel.addEnumerationPulldown("every n frame: ", ' '.join(nfr)) myPanel.addSingleLineInput("file path: ", path) myPanel.addButton("Quit") myPanel.addButton("Create") myPanel.addButton("Execute") result = myPanel.show() # Add Button's action & Cmd Message if result == 0: nuke.tprint("Bat File don't Create") elif result == 1: # Create Bat File curVersion = myPanel.value("nuke version: ") curSwitches = myPanel.value("switches: ") curNode = myPanel.value("node: ") curScript = myPanel.value("script: ") curStart = myPanel.value("start frame: ") curEnd = myPanel.value("end frame: ") curEvery = myPanel.value("every n frame: ") cmdLine = curVersion + " " + curSwitches + " " + curNode + " " + '"' + curScript + '"' + " " + curStart + "," + curEnd + curEvery cmdFile = myPanel.value("file path: ") file = open(cmdFile, 'w') file.write(cmdLine) file.close() nuke.tprint("Create Bat File " + cmdFile) elif result == 2: # Execute Bat File curVersion = myPanel.value("nuke version: ") curSwitches = myPanel.value("switches: ") curNode = myPanel.value("node: ") curScript = myPanel.value("script: ") curStart = myPanel.value("start frame: ") curEnd = myPanel.value("end frame: ") curEvery = myPanel.value("every n frame: ") cmdLine = curVersion + " " + curSwitches + " " + curNode + " " + '"' + curScript + '"' + " " + curStart + "," + curEnd + curEvery cmdFile = myPanel.value("file path: ") file = open(cmdFile, 'w') file.write(cmdLine) file.close() os.startfile(cmdFile) nuke.tprint("Execute Bat File " + cmdFile)
def test_use_relative_path(self): from edit import use_relative_path nuke.knob('root.project_directory', 'A:/test/') n = nuke.nodes.Read(file=b'A:/test/sc01/testfile测试.mov') use_relative_path(n) self.assertEqual(n['file'].value(), b'sc01/testfile测试.mov')
def buildScene(): # Assemble NK scene dataShotDic = buildShotDic() exrPath = dataShotDic['EXR'] endFrame = dataShotDic['endFrame'] # Define Pathes for Write Nodes exrPathFull = '{0}{1}/{2}/SHOT_{3}/MASTER/{4}'.format(root3D, codePart, codeSequence, codeShot, exrPath) dpxPathFull = '{3}{4}/{0}/{1}/SHOT_{2}/v{5}/E{1}_S{2}_v{5}.%04d.dpx'.format(codePart, codeSequence, codeShot, rootRND, 'DPX', '[knob VERSION.label]') movPathFull = '{3}{4}/{0}/{1}/SHOT_{2}/E{1}_S{2}_v{5}.mov'.format(codePart, codeSequence, codeShot, rootRND, 'MOV','[knob VERSION.label]' ) nameBase = 'E{0}_S{1}'.format(codeSequence, codeShot) reader = nuke.nodes.Read(name = 'REA_E{0}_S{1}'.format(codeSequence, codeShot), file = exrPathFull, first = 101, last = endFrame, xpos = 0, ypos = 0) #creating Reader Node dot_A = nuke.nodes.Dot(name = 'DOT', xpos = 34, ypos = 250) dot_A.setInput(0, reader) dot_B = nuke.nodes.Dot(name = 'DOT', xpos = 184, ypos = 250) dot_B.setInput(0, dot_A) verser = nuke.nodes.StickyNote(name = "VERSION", xpos = 0, ypos = 380) # Node to DRIVE VESIONS of Nuke renders verser['label'].setValue('001') # Create WRITE nodes writeDPX = nuke.nodes.Write( name ='DPX_E{0}_S{1}'.format(codeSequence, codeShot),file = dpxPathFull, file_type = 'dpx', colorspace='Cineon', first = 101, last = endFrame, xpos = 0, ypos = 300) writeDPX.setInput(0, dot_A) writeDPX['beforeRender'].setValue("if not os.path.isdir(os.path.dirname(nuke.thisNode()['file'].evaluate())):os.makedirs(os.path.dirname(nuke.thisNode()['file'].evaluate()))") # Create folder for writer output, if its not exists writeMOV = nuke.nodes.Write( name ='MOV_E{0}_S{1}'.format(codeSequence, codeShot),file = movPathFull, file_type = 'dpx', colorspace='sRGB', first = 101, last = endFrame, xpos = 150, ypos = 300) writeMOV.setInput(0, dot_B) writeMOV['beforeRender'].setValue("if not os.path.isdir(os.path.dirname(nuke.thisNode()['file'].evaluate())):os.makedirs(os.path.dirname(nuke.thisNode()['file'].evaluate()))") # Create folder for writer output, if its not exists # Setup NK scene view = nuke.toNode('Viewer1') view['xpos'].setValue( -140 ) view['ypos'].setValue( 30 ) nuke.knob('root.first_frame', str(frameStart) ) nuke.knob('root.last_frame', endFrame) nuke.connectViewer(0, reader)
def setup(self): """Add tag knob to read nodes, then set project framerange.""" if not nuke.value('root.project_directory'): nuke.knob( "root.project_directory", r"[python {os.path.join(" r"nuke.value('root.name', ''), '../'" r").replace('\\', '/')}]") nodes = nuke.allNodes('Read') if not nodes: raise FootageError('没有读取节点') n = None root_format = None root = nuke.Root() first = None last = None formats = [] for n in nodes: ReadNode(n) format_ = n.format() assert isinstance(format_, nuke.Format) if not n.hasError(): formats.append((format_.width(), format_.height())) n_first, n_last = n.firstFrame(), n.lastFrame() # Ignore single frame. if n_first == n_last: continue # Expand frame range. if first is None: first = n_first last = n_last else: first = min(last, n.firstFrame()) last = max(last, n.lastFrame()) if first is None: first = last = 1 root_format = root_format or n.format() root['first_frame'].setValue(first) root['last_frame'].setValue(last) nuke.frame((first + last) / 2) root['lock_range'].setValue(True) try: format_ = sorted([(formats.count(i), i) for i in set(formats)])[-1][1] root['format'].setValue(nuke.addFormat('{} {}'.format(*format_))) except IndexError: root['format'].setValue('HD_1080') LOGGER.warning('不能获取工程格式, 使用默认值HD_1080') root['fps'].setValue(self.fps)
def _create_deep_read_node(self, path, sg_publish_data): """ Create a read node representing the publish. :param path: Path to file. :param sg_publish_data: Shotgun data dictionary with all the standard publish fields. """ import nuke (_, ext) = os.path.splitext(path) # deep files should only be EXRs valid_extensions = [".exr"] if ext.lower() not in valid_extensions: raise Exception("Unsupported file extension for '%s'!" % path) # `nuke.createNode()` will extract the format from the # file itself (if possible), whereas `nuke.nodes.Read()` won't. We'll # also check to see if there's a matching template and override the # frame range, but this should handle the zero config case. This will # also automatically extract the format and frame range for movie files. read_node = nuke.createNode("DeepRead") # this detects frame range automatically only if it is explicitly passed # (i.e. if the argument to fromUserText() is of the format # "<img_seq_path> <start>-<end>") read_node["file"].fromUserText(path) # find the sequence range if it has one: seq_range = self._find_sequence_range(path) # to fetch the nuke prefs from pipeline step = self._find_pipe_step(path, sg_publish_data) nuke_prefs = NukePreferences(step) for knob_name, knob_value in nuke_prefs.getKnobOverridesGenerator( step): if read_node.Class() in knob_name: knob_name = knob_name.replace(read_node.Class(), read_node.name()) nuke.knob(knob_name, knob_value) if seq_range: # override the detected frame range. read_node["first"].setValue(seq_range[0]) read_node["last"].setValue(seq_range[1]) else: self.parent.logger.warning("{}: Not setting frame range.".format( read_node.name())) # try to fetch a proxy path using templates proxy_path = self._get_proxy_path(path) if proxy_path: read_node["proxy"].fromUserText(proxy_path) else: self.parent.logger.warning("{}: Not setting proxy path.".format( read_node.name()))
def set_f_range(): asset = asset_core.string_to_asset(os.environ[defaults._asset_var_]) f_range = prefs.asset(asset).name.range for n in nuke.allNodes('Read'): n['first'].setValue(f_range[0]) n['last'].setValue(f_range[1]) n['origfirst'].setValue(f_range[0]) n['origlast'].setValue(f_range[1]) nuke.knob("root.first_frame", str(f_range[0])) nuke.knob("root.last_frame", str(f_range[1]))
def set_indicators(self): # this function is copied from Foundry's autolabel.py and # is copyright Foundry, all rights reserved # seemingly more or less need to use this TCL code, as there doesn't # seem to be python equivalents for these functions ind = nuke.expression( "(keys?1:0)+(has_expression?2:0)+(clones?8:0)+(viewsplit?32:0)") if int(nuke.numvalue("maskChannelInput", 0)): ind += 4 if int(nuke.numvalue("this.mix", 1)) < 1: ind += 16 nuke.knob("this.indicators", str(ind))
def _create_read_node(self, path, sg_publish_data): """ Create a read node representing the publish. :param path: Path to file. :param sg_publish_data: Shotgun data dictionary with all the standard publish fields. """ import nuke (_, ext) = os.path.splitext(path) # If this is an Alembic cache, use a ReadGeo2 and we're done. if ext.lower() == '.abc' or ext.lower() == '.obj': read_geo = nuke.createNode('ReadGeo2') read_geo.knob('file').setValue(path) return valid_extensions = [ ".png", ".jpg", ".jpeg", ".exr", ".cin", ".dpx", ".tiff", ".tif", ".mov", ".psd", ".tga", ".ari", ".gif", ".iff" ] if ext.lower() not in valid_extensions: raise Exception("Unsupported file extension for '%s'!" % path) # `nuke.createNode()` will extract the format and frame range from the # file itself (if possible), whereas `nuke.nodes.Read()` won't. We'll # also check to see if there's a matching template and override the # frame range, but this should handle the zero config case. This will # also automatically extract the format and frame range for movie files. read_node = nuke.createNode("Read") read_node["file"].fromUserText(path) # find the sequence range if it has one: seq_range = self._find_sequence_range(path, sg_publish_data) # to fetch the nuke prefs from pipeline nuke_prefs = NukePreferences() for knob_name, knob_value in nuke_prefs.getKnobOverridesGenerator( self._find_pipe_step(path, sg_publish_data)): if read_node.Class() in knob_name: knob_name = knob_name.replace(read_node.Class(), read_node.name()) nuke.knob(knob_name, knob_value) if seq_range: # override the detected frame range. read_node["first"].setValue(seq_range[0]) read_node["last"].setValue(seq_range[1])
def nuke_viewerSnapshot(img_path=DEFAULT_PATH): LOG.info("nuke_viewerSnapshot") import nuke viewer = nuke.activeViewer() viewNode = nuke.activeViewer().node() actInput = nuke.ViewerWindow.activeInput(viewer) if actInput < 0: return False selInput = nuke.Node.input(viewNode, actInput) # look up filename based on top read node topName = "[file tail [knob [topnode].file]]" # create writes and define render format write1 = nuke.nodes.Write( file=img_path.replace("\\", "/"), name='writeNode1', file_type=Tank().data_project['EXTENSION']['thumnail']) write1.setInput(0, selInput) # look up current frame curFrame = int(nuke.knob("frame")) # start the render nuke.execute(write1.name(), curFrame, curFrame) # clean up for n in [write1]: nuke.delete(n)
def thumb_snap(self): self.check_for_tmp() #lets make sure were snapping for the current shot shot = self.shotcombo.currentText() if os.getenv('SHOT') == shot: viewer = nuke.activeViewer() actInput = nuke.ViewerWindow.activeInput(viewer) viewNode = nuke.activeViewer().node() selInput = nuke.Node.input(viewNode, actInput) reformatNode = nuke.nodes.Reformat( type = "to format", format = "240 135 eight_scaled", resize = 'fill') reformatNode.setInput(0, selInput) self.shot_thumb = os.path.join(jeeves_core.jobsRoot, self.job, 'vfx', 'nuke', self.shot, 'plates', '.tmp', '%s.jpg' % self.shot).replace('\\', '/') writeNode = nuke.nodes.Write( file = self.shot_thumb, name = 'tmpWrite2' , file_type = 'jpg') writeNode.setInput(0,reformatNode) curFrame = int(nuke.knob("frame")) nuke.execute(writeNode.name(), curFrame, curFrame) nuke.delete(writeNode) nuke.delete(reformatNode) self.update_thumb() else: #print 'not snapping for current shot' nuke.message('not snapping for current shot')
def createThumbNail(nodeObject): try: #test creating thumbnail reformatNode = nuke.nodes.Reformat() reformatNode['type'].setValue("to box") reformatNode['box_width'].setValue(200.0) reformatNode.setInput(0, nodeObject) w2 = nuke.nodes.Write() w2.setInput(0, reformatNode) thumbNailFilename = 'thumbnail_' + HelpFunctions.getUniqueNumber() + '.png' thumbnailDestination = os.path.join(tempfile.gettempdir(), thumbNailFilename) w2['file'].setValue(Connector.windowsFixPath(thumbnailDestination)) w2['file_type'].setValue('png') curFrame = int(nuke.knob("frame")) nuke.execute(w2, curFrame, curFrame) nuke.delete(reformatNode) nuke.delete(w2) return thumbnailDestination except: import traceback traceback.print_exc(file=sys.stdout) return None
def __init__(self): """ """ rvmon = initRvMon() panel = RvRenderPanel() panel.setMinimumSize(450, 100) if not panel.showModalDialog(): return panel.saveToRoot() node = nuke.toNode(panel.outputNode.value()) if (not node): nuke.message("No such node as '%s'." % panel.outputNode.value()) return if node.Class() == "Viewer": node = node.input(int(nuke.knob(node.name() + ".input_number"))) """ self.views = panel.views.value().split() self.output = panel.output.value() self.proxy = panel.proxy.value() """ dateStr = rvmon.prepForRender(node, "current") start = panel.firstFrame.value() end = panel.lastFrame.value() log(" start %d end %d" % (start, end)) """ log (" has_key %s" % str(node.knobs().has_key("use_limit"))) log (" firstFrame %d lastFrame %d" % (node.firstFrame(), node.lastFrame())) if ((not node.knobs().has_key("use_limit")) or node["use_limit"].value()) : start = max (start, node.firstFrame()) end = min (end, node.lastFrame()) log (" start %d end %d" % (start, end)) """ incr = 1 audioFile = "" audioOffset = 0.0 checkpointFrame = int((start + end) / 2) rvmon.initializeRvSide() if (nuke.views() == ['left', 'right']): stereo = "stereo" else: stereo = "mono" rvmon.queueCommand( "self.initRenderRun('%s', %d, %d, %d, \"%s\", %g, %d, '%s', '%s', '%s', '%s')" % (node.name(), start, end, incr, audioFile, audioOffset, checkpointFrame, encodeNL( node["label"].value()), dateStr, "current", stereo))
def _check_project(): project_directory = nuke.value('root.project_directory') if not project_directory: _name = nuke.value('root.name', '') if _name: _dir = os.path.dirname(_name) nuke.knob('root.project_directory', _dir) nuke.message(b'工程目录未设置, 已自动设为: {}'.format(_dir)) else: nuke.message(b'工程目录未设置') # avoid ValueError of script_directory() when no root.name. elif project_directory == r"[python {os.path.abspath(os.path.join("\ r"'D:/temp', nuke.value('root.name', ''), '../'"\ r")).replace('\\', '/')}]": nuke.knob('root.project_directory', r"[python {os.path.join(" r"nuke.value('root.name', ''), '../'" r").replace('\\', '/')}]")
def __init__( self): """ """ rvmon = initRvMon() panel = RvRenderPanel() panel.setMinimumSize (450, 100) if not panel.showModalDialog(): return panel.saveToRoot() node = nuke.toNode(panel.outputNode.value()) if (not node) : nuke.message ("No such node as '%s'." % panel.outputNode.value()) return; if node.Class() == "Viewer": node = node.input (int(nuke.knob (node.name() + ".input_number"))) """ self.views = panel.views.value().split() self.output = panel.output.value() self.proxy = panel.proxy.value() """ dateStr = rvmon.prepForRender (node, "current") start = panel.firstFrame.value() end = panel.lastFrame.value() log (" start %d end %d" % (start, end)) """ log (" has_key %s" % str(node.knobs().has_key("use_limit"))) log (" firstFrame %d lastFrame %d" % (node.firstFrame(), node.lastFrame())) if ((not node.knobs().has_key("use_limit")) or node["use_limit"].value()) : start = max (start, node.firstFrame()) end = min (end, node.lastFrame()) log (" start %d end %d" % (start, end)) """ incr = 1 audioFile = "" audioOffset = 0.0 checkpointFrame = int((start + end) / 2) rvmon.initializeRvSide() if (nuke.views() == ['left', 'right']) : stereo = "stereo" else : stereo = "mono" rvmon.queueCommand("self.initRenderRun('%s', %d, %d, %d, \"%s\", %g, %d, '%s', '%s', '%s', '%s')" % ( node.name(), start, end, incr, audioFile, audioOffset, checkpointFrame, encodeNL(node["label"].value()), dateStr, "current", stereo))
def _add_root_info(): """add info to root. """ artist = nuke.value('preferences.wlf_artist', '') if not artist: return if not nuke.exists('root.wlf'): n = nuke.Root() k = nuke.Tab_Knob('wlf', b'吾立方') k.setFlag(nuke.STARTLINE) n.addKnob(k) k = nuke.String_Knob('wlf_artist', b'制作人') k.setFlag(nuke.STARTLINE) k.setValue(artist) n.addKnob(k) else: if nuke.exists('root.wlf_artist') and not nuke.value('root.wlf_artist', ''): nuke.knob('root.wlf_artist', artist)
def GradeLabel(): # keep node indicators ind = nuke.expression( "(keys?1:0)+(has_expression?2:0)+(clones?8:0)+(viewsplit?32:0)") if int(nuke.numvalue("maskChannelInput", 0)): ind += 4 if int(nuke.numvalue("this.mix", 1)) < 1: ind += 16 nuke.knob("this.indicators", str(ind)) ### # get the node node = nuke.thisNode() if node.Class() == "Grade": # sets autolabel to node name autoLabel = node.name() # check if values are zero'ed or not BP = ('BP' if node['blackpoint'].value() != 0 else None) WP = ('WP' if node['whitepoint'].value() != 1 else None) Lift = ('Lift' if node['black'].value() != 0 else None) Gain = ('Gain' if node['white'].value() != 1 else None) Multiply = ('Multiply' if node['multiply'].value() != 1 else None) Offset = ('Offset' if node['add'].value() != 0 else None) Gamma = ('Gamma' if node['gamma'].value() != 1 else None) # creates list knobs = [BP, WP, Lift, Gain, Multiply, Offset, Gamma] # if value inside list != None, add to autoLabel for knob in knobs: if knob != None: autoLabel = autoLabel + '\n' + knob # adds custom user label if exists if node['label'].value(): autoLabel = autoLabel + '\n' + node['label'].value() return autoLabel
def takeScreenshot(self, fileName): fileName = fileName.replace('\\', '/') viewer = nuke.activeViewer() actInput = nuke.ViewerWindow.activeInput(viewer) viewNode = nuke.activeViewer().node() selInput = nuke.Node.input(viewNode, actInput) write = nuke.nodes.Write(file=fileName, name='tmpWrite', file_type='jpg') write.setInput(0, selInput) curFrame = int(nuke.knob("frame")) nuke.execute(write.name(), curFrame, curFrame) nuke.delete(write)
def BatScriptRenderLight(): # Save Script nuke.scriptSave() # Variables of Script nukescript = nuke.value("root.name") start = nuke.knob("first_frame") end = nuke.knob("last_frame") cmdLineVar = "nuke5.1" + " " + "-x" + " " + '"' + nukescript + '"' + " " + start + "," + end path = nukescript + ".bat" # Cmd Message nuke.tprint("\nBatScriptRender\nSave Script " + nukescript) # Bat File Panel myPanel = nuke.Panel("BatScriptRenderLight - Parameters", 338) myPanel.addSingleLineInput("Line: ", cmdLineVar) myPanel.addSingleLineInput("File: ", path) myPanel.addButton("Quit") myPanel.addButton("Create") myPanel.addButton("Execute") result = myPanel.show() # Add Button's action & Cmd Message if result == 0: nuke.tprint("Bat File don't Create") elif result == 1: # Create Bat File cmdLine = myPanel.value("Line: ") cmdFile = myPanel.value("File: ") file = open(cmdFile, 'w') file.write(cmdLine) file.close() nuke.tprint("Create Bat File " + cmdFile) elif result == 2: # Execute Bat File cmdLine = myPanel.value("Line: ") cmdFile = myPanel.value("File: ") file = open(cmdFile, 'w') file.write(cmdLine) file.close() os.startfile(cmdFile) nuke.tprint("Execute Bat File " + cmdFile)
def sendObjMesh(target_clientID, sender, tabTarget, alembic=False, frames=[0,0]): try: selectedNode = nuke.selectedNode() except ValueError: return False meshOut = {} geoType = ".obj" if alembic: geoType = ".abc" curFrame = int(nuke.knob("frame")) tmpfilePath = tempfile.gettempdir() + "\\hcom_tmp_" + ''.join([random.choice("abcdef0123456789") for n in xrange(5)]) + geoType tmpWriterName = "tmp_geoWriter_" + ''.join([random.choice("abcdef0123456789") for n in xrange(5)]) result = nuke.executeInMainThreadWithResult(_createObjWriter, args=(tmpWriterName, tmpfilePath, selectedNode, curFrame, alembic, frames)) if not result: return False with open(tmpfilePath, 'rb') as f: data = f.read() try: os.remove(tmpfilePath) except: pass meshOut["MESH_TYPE"] = geoType meshOut["MESH_NAME"] = selectedNode.name() meshOut["MESH_DATA"] = data w = nuke.toNode(tmpWriterName) if w: nuke.delete(w) outType = "mesh" if alembic: outType = "alembic" meshOut["NAME"]= selectedNode.name() meshOut["FRAME_RANGE"] = frames meshOut["DATA"]= data result = _sendData(target_clientID, sender, meshOut, outType, tabTarget) return result
def read(node): """Return user-defined knobs from given `node` Args: node (nuke.Node): Nuke node object Returns: list: A list of nuke.Knob object """ def compat_prefixed(knob_name): if knob_name.startswith("avalon:"): return knob_name[len("avalon:"):] elif knob_name.startswith("ak:"): return knob_name[len("ak:"):] else: return knob_name data = dict() pattern = ( "(?<=addUserKnob {)" "([0-9]*) (\\S*)" # Matching knob type and knob name "(?=[ |}])") tcl_script = node.writeKnobs(nuke.WRITE_USER_KNOB_DEFS) result = re.search(pattern, tcl_script) if result: first_user_knob = result.group(2) # Collect user knobs from the end of the knob list for knob in reversed(node.allKnobs()): knob_name = knob.name() if not knob_name: # Ignore unnamed knob continue knob_type = nuke.knob(knob.fullyQualifiedName(), type=True) value = knob.value() if (knob_type not in EXCLUDED_KNOB_TYPE_ON_READ or # For compating read-only string data that imprinted # by `nuke.Text_Knob`. (knob_type == 26 and value)): key = compat_prefixed(knob_name) data[key] = value if knob_name == first_user_knob: break return data
def saveFrame(thumbnailPath): viewer = nuke.activeViewer() inputNode = nuke.ViewerWindow.activeInput(viewer) viewNode = nuke.activeViewer().node() filetype = 'png' try: if inputNode != None: selInput = nuke.Node.input(viewNode, inputNode) if thumbnailPath != None: if not os.path.exists(os.path.dirname(thumbnailPath)): os.makedirs(os.path.dirname(thumbnailPath)) input_w = selInput.width() input_h = selInput.height() factor = input_h / 448 w = int(input_w / factor) h = int(input_h / factor) reformat = nuke.nodes.Reformat(format="%s %s" % (w, h), resize="width") reformat.setInput(0, selInput) write = nuke.nodes.Write(file=thumbnailPath, name='WriteSaveThisFrame', file_type=filetype) write.setInput(0, reformat) curFrame = int(nuke.knob("frame")) nuke.execute(write.name(), curFrame, curFrame) # Clear nuke.delete(write) nuke.delete(reformat) # Succcess # nuke.tprint("Save thumbnail : " + thumbnailPath) return thumbnailPath else: nuke.message("This viewer don't have any input connected!") except Exception as e: nuke.tprint(str(e))
def setFrameRange(hInHead=48, hInTail=48, hOutHead=8, hOutTail=8, headOffset=1): plate = nuke.selectedNode() # starts plate at frame 1000 plate["frame_mode"].setValue(1) plate["frame"].setValue(str(headOffset)) # calculates frame range firstFrame = str(headOffset + hInHead - hOutHead) lastFrame = str(headOffset + plate["last"].getValue() - plate["first"].getValue() - hInTail + hOutTail) # sets project frame range nuke.knob("root.first_frame", firstFrame) nuke.knob("root.last_frame", lastFrame) nuke.knob("root.lock_range", "1")
def createCheckpoint(): nodes = nuke.selectedNodes() if (len(nodes) != 1): nuke.message("Please select a node to checkpoint.") return node = nodes[0] if (type(node).__name__ != "Node" and type(node).__name__ != "Viewer"): nuke.message( "Node '%s' is not renderable, pleases select a node that can be rendered." % node.name()) return if (node.Class() == "Read" or node.Class() == "Write"): nuke.message( "There's no need to checkpoint Read or Write nodes, since they can be viewed directly in RV." ) return log("createCheckpoint %s" % node.name()) rvmon = initRvMon() rvmon.initializeRvSide() if node.Class() == "Viewer": node = node.input(int(nuke.knob(node.name() + ".input_number"))) dateStr = rvmon.prepForRender(node, "checkpoint") f = nuke.frame() if (nuke.views() == ['left', 'right']): stereo = "stereo" else: stereo = "mono" rvmon.queueCommand( "self.initRenderRun('%s', %d, %d, %d, \"%s\", %g, %d, '%s', '%s', '%s', '%s')" % (node.name(), f, f, 1, "", 0.0, f, encodeNL( node["label"].value()), dateStr, "checkpoint", stereo)) """
def updateAndSyncSelection (self, force=False) : nodes = nuke.selectedNodes() if (len(nodes) == 1) : node = nodes[0] if (node.Class() == "Viewer") : node = node.input (int(nuke.knob (node.name() + ".input_number"))) if (not node) : return log ("updateAndSyncSelection old %s new %s" % (self.selectedNode, node.name())) if (force or node.name() != self.selectedNode) : self.selectedNode = node.name() self.queueCommand ("self.selectCurrentByNodeName()") self.queueCommand ("self.changeFrame(%d)" % nuke.frame()) else : self.selectedNode = None
def read(node, filter=None): """Return user-defined knobs from given `node` Args: node (nuke.Node): Nuke node object filter (func, optional): Function for filtering knobs by knob name prefix and remove prefix as data entry name. If not provided, all user-defined knobs will be read. Returns: dict """ data = dict() filter = filter or (lambda name: name) first_user_knob = _parse_first_user_knob(node) if first_user_knob is not None: # Collect user knobs from the end of the knob list for knob in reversed(node.allKnobs()): knob_name = knob.name() if not knob_name: # Ignore unnamed knob continue knob_type = nuke.knob(knob.fullyQualifiedName(), type=True) value = knob.value() if (knob_type not in EXCLUDED_KNOB_TYPE_ON_READ or # For compating read-only string data that imprinted # by `nuke.Text_Knob`. (knob_type == 26 and value)): key = filter(knob_name) if key: data[key] = value if knob_name == first_user_knob: break return data
def createCheckpoint () : nodes = nuke.selectedNodes() if (len(nodes) != 1) : nuke.message ("Please select a node to checkpoint.") return node = nodes[0] if (type(node).__name__ != "Node" and type(node).__name__ != "Viewer") : nuke.message ("Node '%s' is not renderable, pleases select a node that can be rendered." % node.name()) return if (node.Class() == "Read" or node.Class() == "Write") : nuke.message ("There's no need to checkpoint Read or Write nodes, since they can be viewed directly in RV.") return log ("createCheckpoint %s" % node.name()) rvmon = initRvMon() rvmon.initializeRvSide() if node.Class() == "Viewer": node = node.input (int (nuke.knob (node.name() + ".input_number"))) dateStr = rvmon.prepForRender (node, "checkpoint") f = nuke.frame() if (nuke.views() == ['left', 'right']) : stereo = "stereo" else : stereo = "mono" rvmon.queueCommand("self.initRenderRun('%s', %d, %d, %d, \"%s\", %g, %d, '%s', '%s', '%s', '%s')" % ( node.name(), f, f, 1, "", 0.0, f, encodeNL (node["label"].value()), dateStr, "checkpoint", stereo)) """
def updateAndSyncSelection(self, force=False): nodes = nuke.selectedNodes() if (len(nodes) == 1): node = nodes[0] if (node.Class() == "Viewer"): node = node.input(int(nuke.knob(node.name() + ".input_number"))) if (not node): return log("updateAndSyncSelection old %s new %s" % (self.selectedNode, node.name())) if (force or node.name() != self.selectedNode): self.selectedNode = node.name() self.queueCommand("self.selectCurrentByNodeName()") self.queueCommand("self.changeFrame(%d)" % nuke.frame()) else: self.selectedNode = None
def sendNodeOuput(target_clientID, sender, tabTarget): fileType = HComNukeUtils.readIni()["OUTPUT_IMAGE_FORMAT"] try: selectedNode = nuke.selectedNode() except ValueError: return False curFrame = int(nuke.knob("frame")) tmpfilePath = tempfile.gettempdir() + "\\hcom_tmp_" + ''.join([random.choice("abcdef0123456789") for n in xrange(5)]) + "." + fileType tmpWriterName = "tmp_writer_" + ''.join([random.choice("abcdef0123456789") for n in xrange(5)]) result = nuke.executeInMainThreadWithResult(_createWriter, args=(tmpWriterName, tmpfilePath, selectedNode, curFrame)) if not result: return False with open(tmpfilePath, 'rb') as f: data = f.read() outImdageData = {} outImdageData["IMAGE_NAME"] = os.path.basename(selectedNode.name()) + "." + fileType outImdageData["BINARY_DATA"] = data try: os.remove(tmpfilePath) except: pass w = nuke.toNode(tmpWriterName) if w: nuke.delete(w) result = _sendData(target_clientID, sender, outImdageData, "pic", tabTarget) return result
def setFPS(self, origin, fps): return nuke.knob("root.fps", str(fps))
def launch_nukes(): a = nuke.knob("first_frame") b = nuke.knob("last_frame") start = int(a) end = int(b) incr = 1 instances = 1 _range = a+","+b p = nuke.Panel("Launch Nukes") p.addSingleLineInput("Frames to execute:", _range) p.addSingleLineInput("Number of background procs:", instances) p.addButton("Cancel") p.addButton("OK") result = p.show() r = p.value("Frames to execute:") s = p.value("Number of background procs:") if r is None: return if s is None: return # this is the requested frame range frames = r # this is the number of instances to launch inst = int(s) (scriptpath, scriptname) = os.path.split(nuke.value("root.name")) flags = "-ixfm 1" print ">>> launching %s nuke instances" % inst # create a frame range string for each renderer for i in range(inst): print ">>> generating range for instance %d" % i instRange = "" # separate ranges at spaces f = frames.split(" ") # separate individual start, end, and increment values for p in f: c = p.split(",") incr = 1 if len(c) > 0: start = int(c[0]) end = start if len(c) > 1: end = int(c[1]) if len(c) > 2: incr = int(c[2]) # re-jigger this range for this instance of the renderer st = start + ( i * incr ) en = end inc = incr * inst new = "%d,%d,%d" % (st, en, inc) if inc == 1: new = "%d,%d" % (st, en) if en == st: new = "%d" % st if st > en: new = "" else: # add the re-jiggered range to the instances range string instRange = instRange + " " + new print ">>> range for instance %d is: %s" % (i, instRange) logFile = "%s/%s_log%02d.log" % (scriptpath, scriptname, i) cmd = "%s %s %s/%s %s > %s &" % (nuke.EXE_PATH, flags, scriptpath, scriptname, instRange, logFile) print ">>> starting instance %d" % (i, ) print "command: " + cmd os.system(cmd)
def _createIntermediateNode(self): """Create a write node to render out the current node so that output may be used for flipbooking.""" flipbooktmp = self._getIntermediatePath() fieldname = "file" if self._useProxy.value(): fieldname = "proxy" fixup = nuke.createNode("Group", "tile_color 0xff000000", inpanel=False) with fixup: fixup.setName("Flipbook") inputNode = nuke.createNode("Input", inpanel=False) shuffle = nuke.createNode("Shuffle", inpanel=False) shuffle.knob("in").setValue(self._channels.value()) write = nuke.createNode("Write", fieldname + " {" + flipbooktmp + "}", inpanel=False) write.knob('file_type').setValue(self._getIntermediateFileType()) write.knob('views').fromScript(" ".join(self._selectedViews())) if self._getIntermediateFileType() == "exr": write.knob('compression').setValue("B44") if self._burnInLUT.value(): lut = self._getLUT() if lut != "None": write.knob('colorspace').setValue(lut) outputNode = nuke.createNode("Output", inpanel=False) #If called on a Viewer connect fixup node to the one immediately above if exists. if self._node.Class() == "Viewer": fixup.setInput( 0, self._node.input( int(nuke.knob(self._node.fullName() + ".input_number")))) else: fixup.setInput(0, self._node) try: # Throws exception on render failure if (self.isBackgrounded()): nuke.executeBackgroundNuke( nuke.EXE_PATH, [write], nuke.FrameRanges(self._frameRange.value().split(',')), self._selectedViews(), self._getBackgroundLimits(), self._continueOnError.value(), self._flipbookEnum.value(), self._getOptions(write)) else: nuke.executeMultiple( (write, ), nuke.FrameRanges(self._frameRange.value().split(',')), self._selectedViews(), self._continueOnError.value()) except RuntimeError, msg: if msg.args[0][0:9] == "Cancelled": splitMsg = string.split(msg.args[0]) msg = """Render did not complete, do you want to show the completed range? Frame range %s contains %s frames but only %s finished.""" % ( self._frameRange.value(), splitMsg[3], splitMsg[1]) if nuke.ask(msg) == False: nuke.delete(fixup) fixup = None else: nuke.delete(fixup) fixup = None nuke.message("Flipbook render failed:\n%s" % (msg.args[0], ))
if (start) < 0 or (end < 0): raise RuntimeError( "Flipbook cannot be executed, negative frame range not supported(%s)." % (str(f), )) proxy = nuke.toNode("root").knob("proxy").value() if (node.Class() == "Read" or node.Class() == "Write") and not proxy: try: command(node, start, end, incr, views_input) except Exception, msg: nuke.message("Error running flipbook:\n%s" % (msg, )) return if node.Class() == "Viewer": input_num = int(nuke.knob(node.name() + ".input_number")) input = node.input(input_num) if input is None: return if (input.Class() == "Read" or input.Class() == "Write") and not proxy: try: command(input, start, end, incr, views_input) except Exception, msg: nuke.message("Error running flipbook:\n%s" % (msg, )) return # okay now we must execute it... flipbooktmp = "" if flipbooktmp == "": try: flipbooktmp = os.environ["FC_DISK_CACHE"]
def _create_read_node(self, path, sg_publish_data): """ Create a read node representing the publish. :param path: Path to file. :param sg_publish_data: Shotgun data dictionary with all the standard publish fields. """ import nuke (_, ext) = os.path.splitext(path) valid_geo_extensions = [".abc", ".obj", ".fbx"] # If this is an Alembic cache, use a ReadGeo2 and we're done. if ext.lower() in valid_geo_extensions: read_geo = nuke.createNode('ReadGeo2') # TODO: check issue of alembic with multiple nodes # http://community.foundry.com/discuss/topic/103204 read_geo.knob('file').setValue(path) # add the SGTK metadata on the node self._add_node_metadata(read_geo, path, sg_publish_data) return valid_extensions = [".png", ".jpg", ".jpeg", ".exr", ".cin", ".dpx", ".tiff", ".tif", ".mov", ".psd", ".tga", ".ari", ".gif", ".iff"] if ext.lower() not in valid_extensions: raise Exception("Unsupported file extension for '%s'!" % path) # `nuke.createNode()` will extract the format from the # file itself (if possible), whereas `nuke.nodes.Read()` won't. We'll # also check to see if there's a matching template and override the # frame range, but this should handle the zero config case. This will # also automatically extract the format and frame range for movie files. read_node = nuke.createNode("Read") # this detects frame range automatically only if it is explicitly passed # (i.e. if the argument to fromUserText() is of the format # "<img_seq_path> <start>-<end>") read_node["file"].fromUserText(path) # find the sequence range if it has one: seq_range = self.parent.utils.find_sequence_range(self.sgtk, path) # to fetch the nuke prefs from pipeline step = self._find_pipe_step(path, sg_publish_data) nuke_prefs = NukePreferences(step) for knob_name, knob_value in nuke_prefs.getKnobOverridesGenerator(step): if read_node.Class() in knob_name: knob_name = knob_name.replace(read_node.Class(), read_node.name()) nuke.knob(knob_name, knob_value) if seq_range: # override the detected frame range. read_node["first"].setValue(seq_range[0]) read_node["last"].setValue(seq_range[1]) else: self.parent.logger.warning("{}: Not setting frame range.".format(read_node.name())) # try to fetch a proxy path using templates proxy_path = self._get_proxy_path(path) if proxy_path: read_node["proxy"].fromUserText(proxy_path) else: self.parent.logger.warning("{}: Not setting proxy path.".format(read_node.name())) # add the SGTK metadata on the node self._add_node_metadata(read_node, path, sg_publish_data)
def populate_ftrack(self): import nuke import legacy from nukescripts import panels from ftrack_connect_nuke.connector import Connector # Check if QtWebKit or QWebEngine is avaliable. from FnAssetAPI.ui.toolkit import is_webwidget_supported has_webwidgets = is_webwidget_supported() Connector.registerAssets() # wrappers for initializing the widgets with # the correct connector object def wrapImportAssetDialog(*args, **kwargs): from ftrack_connect.ui.widget.import_asset import FtrackImportAssetDialog return FtrackImportAssetDialog(connector=Connector()) def wrapAssetManagerDialog(*args, **kwargs): from ftrack_connect.ui.widget.asset_manager import FtrackAssetManagerDialog return FtrackAssetManagerDialog(connector=Connector()) # Populate the ui nukeMenu = nuke.menu("Nuke") ftrackMenu = nukeMenu.addMenu("&ftrack") ftrackMenu.addSeparator() # add ftrack publish node to the menu ftrackMenu.addCommand('Create Publish Node', lambda: legacy.createFtrackPublish()) ftrackMenu.addSeparator() globals()['ftrackImportAssetClass'] = wrapImportAssetDialog panels.registerWidgetAsPanel( '{0}.{1}'.format(__name__, 'ftrackImportAssetClass'), 'ftrackImportAsset', 'ftrackDialogs.ftrackImportAssetDialog') ftrackMenu.addSeparator() ftrackMenu.addCommand( 'Import Asset', 'pane = nuke.getPaneFor("Properties.1");' 'panel = nukescripts.restorePanel("ftrackDialogs.ftrackImportAssetDialog");' 'panel.addToPane(pane)') globals()['ftrackAssetManagerDialogClass'] = wrapAssetManagerDialog # Create the asset manager dialog entry in the menu panels.registerWidgetAsPanel( '{0}.{1}'.format(__name__, 'ftrackAssetManagerDialogClass'), 'ftrackAssetManager', 'ftrackDialogs.ftrackAssetManagerDialog') ftrackMenu.addCommand( 'Asset Manager', 'pane = nuke.getPaneFor("Properties.1");' 'panel = nukescripts.restorePanel("ftrackDialogs.ftrackAssetManagerDialog");' 'panel.addToPane(pane)') if has_webwidgets: def wrapAssetInfoDialog(*args, **kwargs): from ftrack_connect_nuke.ui.widget.info_view import AssetInfoView return AssetInfoView(bridge=self._bridge) globals()['ftrackAssetInfoDialogClass'] = wrapAssetInfoDialog # Create the crew dialog entry in the menu panels.registerWidgetAsPanel( '{0}.{1}'.format(__name__, 'ftrackAssetInfoDialogClass'), 'ftrackAssetInfo', 'ftrackDialogs.ftrackAssetInfoDialog') ftrackMenu.addCommand( 'Asset Info', 'pane = nuke.getPaneFor("Properties.1");' 'panel = nukescripts.restorePanel("ftrackDialogs.ftrackAssetInfoDialog");' 'panel.addToPane(pane)') ftrackMenu.addSeparator() if has_webwidgets: from ftrack_connect_foundry.ui.info_view import WorkingTaskInfoView as _WorkingTaskInfoView from ftrack_connect_foundry.ui.tasks_view import TasksView as _TasksView # Add Web Views located in the ftrack_connect_foundry package to the # menu for easier access. for widget in [_TasksView, _WorkingTaskInfoView]: ftrackMenu.addCommand( widget.getDisplayName(), 'pane = nuke.getPaneFor("Properties.1");' 'panel = nukescripts.restorePanel("{identifier}");' 'panel.addToPane(pane)'.format( identifier=widget.getIdentifier())) ftrackMenu.addSeparator() # Add new entries in the ftrack menu. ftrackMenu.addSeparator() if has_webwidgets: from ftrack_connect_nuke.ui.widget.publish_gizmo import GizmoPublisherDialog ftrackMenu.addCommand('Publish gizmo', GizmoPublisherDialog) # Add ftrack publish node toolbar = nuke.toolbar("Nodes") ftrackNodesMenu = toolbar.addMenu("ftrack", icon="ftrack_logo.png") ftrackNodesMenu.addCommand('ftrackPublish', lambda: legacy.createFtrackPublish()) # Set calbacks def asset_info_menu_switch(): '''Enable and disable asset info depending on selection.''' this_node = nuke.thisNode() # Do not continue if selection is not node. if not isinstance(this_node, nuke.Node): return try: is_ftrack = this_node.knob('assetVersionId') except ValueError: is_ftrack = False nuke_menu = nuke.menu('Nuke') menu_item = nuke_menu.findItem('&ftrack') asset_info_menu = menu_item.findItem('Asset Info') if has_webwidgets and asset_info_menu: if is_ftrack: asset_info_menu.setEnabled(True) else: asset_info_menu.setEnabled(False) nuke.addKnobChanged(asset_info_menu_switch) # other callbacks nuke.addOnScriptLoad(legacy.refAssetManager) nuke.addOnScriptLoad(legacy.scan_for_new_assets) nuke.addOnUserCreate(legacy.addFtrackComponentField, nodeClass='Write') nuke.addOnUserCreate(legacy.addFtrackComponentField, nodeClass='WriteGeo') nuke.addOnUserCreate(legacy.addFtrackComponentField, nodeClass='Read') nuke.addKnobChanged(legacy.ftrackPublishKnobChanged, nodeClass="Group") nuke.addOnCreate(legacy.ftrackPublishHieroInit) # Set default values from environments. start_frame = os.environ.get('FS', 0) end_frame = os.environ.get('FE', 100) FnAssetAPI.logging.debug( 'Setting start frame : {}'.format(start_frame)) nuke.knob('root.first_frame', str(start_frame)) FnAssetAPI.logging.debug('Setting end frame : {}'.format(end_frame)) nuke.knob('root.last_frame', str(end_frame))
def launch_nukes(nodes=[]): """ Launch single-core command-line Nuke renderers from inside the Nuke UI. """ if nuke.root().knob('name').value() == '': nuke.message('This script is not named. Please save it and try again.') return # Select Write nodes. nodelist = '' if nodes != []: nodelist = ','.join([n.name() for n in nodes if "Write" in n.Class()]) start = int(nuke.knob("first_frame")) end = int(nuke.knob("last_frame")) instances = nuke.env['numCPUs'] framerange = str(start) + "-" + str(end) p = nuke.Panel("Launch Nukes") p.addSingleLineInput("Frames to execute:", framerange) p.addSingleLineInput("Node(s) to execute:", nodelist) p.addSingleLineInput("Number of background procs:", instances) p.addButton("Cancel") p.addButton("OK") result = p.show() if not result: return framerange = p.value("Frames to execute:") nodelist = p.value("Node(s) to execute:").replace(' ', '') inst = int(p.value("Number of background procs:")) if framerange is None: return if inst is None: return (scriptpath, scriptname) = os.path.split(nuke.value("root.name")) flags = "-ixm 1" if nodelist != '': flags += " -X " + nodelist r = nuke.FrameRanges() r.add(framerange) r.compact() frame_list = r.toFrameList() print frame_list # Create lists of frames to render for each instance. inst_frame_list = [] for i in range(inst): inst_frame_list.append([]) print inst_frame_list cnt = 0 for frame in frame_list: inst_frame_list[cnt].append(str(frame)) cnt += 1 if cnt == inst: cnt = 0 print inst_frame_list print ">>> launching", inst, "nuke instances" # Launch each renderer logs = [] for i in range(inst): instRange = ' '.join(inst_frame_list[i]) print ">>> frame list for instance", i, "is:", instRange logFile = "%s/%s_log%02d.log" % (scriptpath, scriptname, i) logs.append(logFile) cmd = " ".join([nuke.env['ExecutablePath'], flags, '-F', '"' + instRange + '"', nuke.value("root.name"), '&>', logFile]) print ">>> starting instance %d" % (i, ) print "command: " + cmd subprocess.Popen(cmd, shell=True) nuke.message(str(inst) + ' renderers launched in the background.\nLog files: ' + ', '.join(logs))
if filePath != None: ======= if filePath != None: #Check Path path, ext = os.path.split(filePath) if not os.path.isdir(path): os.makedirs(path) >>>>>>> bed50f88abdec1936e64c57eccc98bf40a6253f5 write = nuke.nodes.Write(file = filePath, name = 'WriteSaveThisFrame', file_type=ext) write.setInput(0,selInput) curFrame = int(nuke.knob("frame")) nuke.execute(write.name(), curFrame, curFrame) nuke.delete(write) print "saved: " + filePath else: nuke.message("This viewer don't have any input connected!") def getSeqName(): res = "" scriptpath = str.split(nuke.root().knob('name').value() , "/") res = scriptpath[len(scriptpath)-3] return res <<<<<<< HEAD
def nuke_ui(): allWriteNodes = [ node for node in nuke.allNodes() if node.Class() == 'Write' or node.Class() == 'DeepWrite' ] panel = nuke.Panel('GS Render Submit') panel.addSingleLineInput('Project', PROJ_NAME) panel.addSingleLineInput( 'Job Name', os.path.splitext(os.path.split(nuke.value('root.name'))[1])[0]) if gsstartup.properties['location'] == 'NYC': panel.addBooleanCheckBox('Use LA Render Farm', 0) panel.addSingleLineInput( 'Frame Range', '%s-%s' % (nuke.knob('first_frame'), nuke.knob('last_frame'))) panel.addSingleLineInput('Packet Size', 5) panel.addSingleLineInput('Priority (1-100)', 50) for n in allWriteNodes: k = panel.addBooleanCheckBox(n.name(), n.isSelected()) panel.setWidth(300) panel.addButton('Cancel') panel.addButton('Submit') result = panel.show() selected_write_nodes = [n for n in allWriteNodes if panel.value(n.name())] selected_write_nodes_string = ','.join( [n.name() for n in selected_write_nodes]) if result and check_saved() == 1 and check_write_selected( selected_write_nodes_string) == 1: newfile = save_render_file() framerange = [ int(value) for value in re.sub( '[^0-9]', ',', panel.value('Frame Range')).split(',') ] musterflags = {} musterflags['-add'] = '--major %s --job %s -X \"%s\"' % ( nuke.NUKE_VERSION_STRING, panel.value('Project'), selected_write_nodes_string) musterflags['-e'] = '1105' musterflags['-n'] = panel.value('Job Name') musterflags['-parent'] = '33409' musterflags['-group'] = gsstartup.get_project_from_path(newfile) try: if panel.value('Use LA Render Farm' ) or gsstartup.properties['location'] == 'LAX': musterflags['-pool'] = 'NUKE' else: musterflags['-pool'] = 'WKSTN-NY' except: musterflags['-pool'] = 'NUKE' musterflags['-sf'] = str(framerange[0]) musterflags['-ef'] = str(framerange[1]) musterflags['-bf'] = len(framerange) > 2 and str(framerange[2]) or '1' musterflags['-pr'] = panel.value('Priority (1-100)') musterflags['-f'] = newfile for n in selected_write_nodes: if n.knob('file_type').value() in ['mov']: musterflags['-pk'] = '999999' break else: musterflags['-pk'] = panel.value('Packet Size') if gsstartup.properties[ 'location'] == 'NYC' and musterflags['-pool'] != 'WKSTN-NY': newfileup = newfile.replace("\\", "/").replace(" ", "\ ").replace("//", "/") newfiledest = os.path.split(newfileup)[0].replace( "\\", "/").replace(" ", "\ ").replace("//", "/") ascpupcmd = 'ascpgs render@nycbossman:%s %s;' % (newfileup, newfiledest) ascpupflags = {} ascpupflags['-e'] = '43' ascpupflags['-n'] = '%s Asset Upload' % (panel.value('Job Name')) ascpupflags['-parent'] = '33409' ascpupflags['-group'] = gsstartup.get_project_from_path(newfile) ascpupflags['-pool'] = 'ASPERA' for r in get_read_nodes(): #src = re.sub('%\d+d','*', r).replace("\\", "/").replace(" ", "\ ").replace("//","/") src = os.path.split(r)[0].replace("\\", "/").replace( " ", "\ ").replace("//", "/") dest = os.path.split(src)[0].replace("\\", "/").replace( " ", "\ ").replace("//", "/") ascpupcmd = ascpupcmd + 'ascpgs render@nycbossman:%s %s;' % ( src, dest) for w in selected_write_nodes: f = w.knob('file').value() dest = os.path.split(f)[0].replace("\\", "/").replace( " ", "\ ").replace("//", "/") ascpupcmd = ascpupcmd + 'mkdir -p %s;' % (dest) ascpupflags[ '-add'] = '-c \"script -q -c \'%s\' /tmp/last_aspera_xfer.log\"' % ( ascpupcmd) ascpupsubmit = muster.submit(ascpupflags) if ascpupsubmit: musterflags['-wait'] = ascpupsubmit rendersubmit = muster.submit(musterflags) if rendersubmit: ascpdownflags = {} ascpdownflags['-e'] = '43' ascpdownflags['-n'] = '%s Render Download' % ( panel.value('Job Name')) ascpdownflags['-parent'] = '33409' ascpdownflags['-group'] = gsstartup.get_project_from_path( newfile) ascpdownflags['-pool'] = 'ASPERA' ascpdownflags['-wait'] = rendersubmit ascpdowncmd = '' for w in selected_write_nodes: f = w.knob('file').value() src = re.sub('%\d+d', '*', f).replace("\\", "/").replace( " ", "\ ").replace("//", "/") dest = os.path.split(f)[0].replace("\\", "/").replace( " ", "\ ").replace("//", "/") #ascpdowncmd = ascpdowncmd + 'ascp -p -d -v -k 1 --remove-after-transfer -i ~/.ssh/id_rsa -l 1G %s render@nycbossman:%s;' %(src, dest) ascpdowncmd = ascpdowncmd + 'ascpgs %s render@nycbossman:%s;' % ( src, dest) ascpdownflags[ '-add'] = '-c \"script -q -c \'%s\' /tmp/last_aspera_xfer.log\"' % ( ascpdowncmd) ascpdownsubmit = muster.submit(ascpdownflags) if ascpdownsubmit: nuke.message('Jobs successfully submitted to Muster!') else: print 'There was an error submitting download job to Muster' else: print 'There was an error submitting render job to Muster.' else: print 'There was an error submitting upload job to Muster.' else: rendersubmit = muster.submit(musterflags) if rendersubmit: nuke.message('Job ID#%s successfully submitted to Muster!' % (rendersubmit)) else: print 'There was an error submitting render job to Muster.' else: print 'Cancelled Muster Render'
def _eval_proj_dir(): if nuke.numvalue('preferences.wlf_eval_proj_dir', 0.0): attr = 'root.project_directory' nuke.knob(attr, os.path.abspath(nuke.value(attr)).replace('\\', '/'))
def CLrender(nodes=[]): """ Creates command-line Nuke batch file with different control parameters (frame by frame, skip existing frame, Stereo) """ if nuke.root().knob('name').value() == '': nuke.message('This script is not named. Please save it and try again.') return nodelist = '' if nodes != []: nodelist = ','.join([n.name() for n in nodes if n.Class() == "Write"]) else: Writes = nuke.allNodes("Write") if len(Writes) == 1: nodelist = Writes[0].name() if nodelist == "": nuke.message("Please select Write node(s) !") return class CLrenderDialog(nukescripts.PythonPanel): def __init__(self): nukescripts.PythonPanel.__init__( self, 'Create rendering command line batch file(s) -- (philhub 2011)' ) self.setMinimumSize(600, 300) self.nodesKnob = nuke.String_Knob('nodesExec', 'Node(s) to execute:', nodelist) self.addKnob(self.nodesKnob) self.startKnob = nuke.Int_Knob('startFrame', 'Start frame :') self.addKnob(self.startKnob) self.endKnob = nuke.Int_Knob('endFrame', ' End frame :') self.addKnob(self.endKnob) self.endKnob.clearFlag(nuke.STARTLINE) self.spaceKnob = nuke.Text_Knob('space', '') self.addKnob(self.spaceKnob) self.spaceKnob.setFlag(nuke.STARTLINE) self.limitKnob = nuke.Boolean_Knob('limit', 'Limit Memory to (Go)') self.addKnob(self.limitKnob) self.limitKnob.setFlag(nuke.STARTLINE) self.memKnob = nuke.Int_Knob('mem', '') self.addKnob(self.memKnob) self.memKnob.clearFlag(nuke.STARTLINE) # self.unitKnob = nuke.Text_Knob('unit', 'Go') # self.addKnob(self.unitKnob) # self.unitKnob.clearFlag(nuke.STARTLINE) self.limitcpuKnob = nuke.Boolean_Knob('limitcpu', 'Limit Cores to') self.addKnob(self.limitcpuKnob) self.limitcpuKnob.clearFlag(nuke.STARTLINE) self.cpuKnob = nuke.Int_Knob('cpu', '') self.addKnob(self.cpuKnob) self.cpuKnob.clearFlag(nuke.STARTLINE) self.spaceKnob2 = nuke.Text_Knob('space2', '') self.addKnob(self.spaceKnob2) self.spaceKnob2.setFlag(nuke.STARTLINE) self.threadsKnob = nuke.Int_Knob('threads', 'Number of BAT files :') self.addKnob(self.threadsKnob) self.threadsKnob.setFlag(nuke.STARTLINE) self.threadWhyKnob = nuke.Text_Knob( 'threadWhy', '(to distrib on multiple cores/boxes)') self.addKnob(self.threadWhyKnob) self.threadWhyKnob.clearFlag(nuke.STARTLINE) self.fbfKnob = nuke.Boolean_Knob( 'fbf', 'Frame by Frame ? (to avoid some insanes increasing render time)' ) self.addKnob(self.fbfKnob) self.fbfKnob.setFlag(nuke.STARTLINE) self.skipKnob = nuke.Boolean_Knob('skip', 'Skip existing Frames ?') self.addKnob(self.skipKnob) self.skipKnob.setFlag(nuke.STARTLINE) self.stereoKnob = nuke.Boolean_Knob('stereo', 'Stereo ?') self.addKnob(self.stereoKnob) self.stereoKnob.setFlag(nuke.STARTLINE) self.backupKnob = nuke.Boolean_Knob( 'backup', "Create a comp's backup ? (and renders from it)") self.addKnob(self.backupKnob) self.openFolderKnob = nuke.Boolean_Knob('openFolder', "open folder ?") self.addKnob(self.openFolderKnob) self.openFolderKnob.setFlag(nuke.STARTLINE) self.spaceKnob2 = nuke.Text_Knob('space', '') self.addKnob(self.spaceKnob2) self.spaceKnob2.setFlag(nuke.STARTLINE) self.backupKnob.setFlag(nuke.STARTLINE) self.okButton = nuke.Script_Knob("OK") self.addKnob(self.okButton) self.okButton.setFlag(nuke.STARTLINE) self.cancelButton = nuke.Script_Knob("Cancel") self.addKnob(self.cancelButton) self.infosKnob = nuke.PyScript_Knob('infos', "infos") self.infosKnob.setCommand( '''import webbrowserwebbrowser.open("http://www.nukepedia.com/python/render/cmdlinerender/")''' ) self.addKnob(self.infosKnob) p = CLrenderDialog() p.startKnob.setValue(int(nuke.knob("first_frame"))) p.endKnob.setValue(int(nuke.knob("last_frame"))) p.memKnob.setValue(8) p.cpuKnob.setValue(2) p.threadsKnob.setValue(1) p.fbfKnob.setValue(1) p.skipKnob.setValue(0) p.stereoKnob.setValue(0) p.backupKnob.setValue(1) p.openFolderKnob.setValue(1) result = p.showModalDialog() if not result: return nuke.scriptSave('') start = p.startKnob.value() end = p.endKnob.value() threads = p.threadsKnob.value() mem = p.memKnob.value() cpu = p.cpuKnob.value() fbf = p.fbfKnob.value() skip = p.skipKnob.value() stereo = p.stereoKnob.value() if threads < 1: return flags = " -x -i " if stereo: views = ','.join(nuke.views()) else: views = nuke.views()[0] flags += " -view " + views if nodelist != '': flags += " -X " + nodelist if p.limitKnob.value(): flags += " -c " + str(mem) + "G" if p.limitcpuKnob.value(): flags += " -m " + str(cpu) comp_dirpath = nuke.value("root.name") exe = '"' + nuke.env[ 'ExecutablePath'] + '"' # for BAT file, " avoid error with names with spaces if p.backupKnob.value(): bkp_dirpath = os.path.dirname(comp_dirpath) + '/backup_from_CLrender/' if not os.path.exists(bkp_dirpath): os.makedirs(bkp_dirpath) bkp_filepath = bkp_dirpath + os.path.basename(comp_dirpath) shutil.copy(comp_dirpath, bkp_filepath) comp_dirpath = '"' + bkp_filepath + '"' # for BAT file, " avoid error with names with spaces else: comp_dirpath = '"' + comp_dirpath + '"' # for BAT file, " avoid error with names with spaces for thread in range(threads): bat_name = nuke.value("root.name").replace( '.nk', '_' + nodelist.replace(",", "-") + "_x" + str(threads) + "x" + str(start + thread) + "-" + str(end) + '.bat') if fbf and not (skip): cmd = r"FOR /l %%I IN (" + ",".join( [str(start + thread), str(threads), str(end)]) + r") DO (" + " ".join( [exe, flags, r"-F %%I-%%I", comp_dirpath]) + ")" bat_name = bat_name.replace('.bat', '_FrameByFrame.bat') elif skip: cmd = r"FOR /l %%I IN (" + ",".join( [str(start + thread), str(threads), str(end)]) + r") DO (" + " ".join([ exe, "-t", os.path.realpath(__file__), comp_dirpath, nodelist, "%%I", views ]) + ")" bat_name = bat_name.replace('.bat', '_SkipExisting.bat') else: cmd = " ".join([ exe, flags, '-F', '"' + str(start + thread) + "-" + str(end) + 'x' + str(threads) + '"', comp_dirpath ]) if stereo: bat_name = bat_name.replace('.bat', '_STEREO.bat') print "command : " + cmd print "saved to : " + bat_name try: file = open(bat_name, 'w') #file.write("mode con cols=500 lines=500") file.write("\nCOLOR 4f\n") file.write("\n") file.write(cmd) file.write("\n\nCOLOR 2f\n") file.write("pause") finally: file.close() if p.openFolderKnob.value(): openCompFolder()
def autolabel(): """This function is run automatically by Nuke during idle, and the return text is drawn on the box of the node. It can also have side effects by setting knobs. Currently two knobs are provided that are useful: indicators = integer bit flags to turn icons on/off. The icons named indicator1, indicator2, indicator4, indicator8, etc are drawn if the corresponding bit is on. By default these are loaded from the path as indicator1.xpm, etc, but you can use the load_icon command to load other files. icon = name of a whole extra image you can draw, but it replaces any previous one.""" # do the icons: ind = nuke.expression("(keys?1:0)+(has_expression?2:0)+(clones?8:0)+(viewsplit?32:0)") if int(nuke.numvalue("maskChannelInput", 0)) : ind += 4 if int(nuke.numvalue("this.mix", 1)) < 1: ind += 16 nuke.knob("this.indicators", str(ind)) this = nuke.toNode("this") # do stuff that works even if autolabel is turned off: name = nuke.value("name") _class = this.Class() label = nuke.value("label") if not label: label = "" else: try: label = nuke.tcl("subst", label) except: pass if _class == "Dot" or _class == "BackdropNode" or _class == "StickyNote": return label elif _class.startswith("Read") or _class.startswith("Write") or _class.startswith( "Precomp" ): reading = int(nuke.numvalue("this.reading", 0 )) if reading and _class.startswith( "Precomp" ): filename = nuke.filename( node = this.output().input(0), replace = nuke.REPLACE ) else: filename = nuke.filename(replace = nuke.REPLACE) if filename is not None: name = __concat_result_string(name, os.path.basename(filename)) if reading: checkHashOnRead = False if _class.startswith( "Precomp" ): if this.output() != None and this.output().input(0) != None: checkHashOnReadKnob = this.output().input(0).knob( "checkHashOnRead" ) if checkHashOnReadKnob: checkHashOnRead = checkHashOnReadKnob.value() else: checkHashOnRead = this.knob("checkHashOnRead").value() if checkHashOnRead == True and ( this.proxy() != True ): name = name + "\n(Read)" else: name = name + "\n(Read - unchecked)" elif _class == 'DeepRead': filename = nuke.filename(replace = nuke.REPLACE) if filename is not None: name = __concat_result_string(name, os.path.basename(filename)) elif _class.startswith("ParticleCache" ): rendering = int(nuke.numvalue("this.particle_cache_render_in_progress", 0 )) if rendering: name = name + "\n(Rendering)" else: reading = int(nuke.numvalue("this.particle_cache_read_from_file", 0 )) if reading: name = name + "\n(Read)" if nuke.numvalue("preferences.autolabel") == 0 or _class.find("OFX", 0) != -1: return __concat_result_string(name, label) # build the autolabel: operation = nuke.value('this.operation', '') if operation != '' and _class != 'ChannelMerge' and _class != 'Precomp': name = name + ' (' + operation + ')' layer = nuke.value("this.output", nuke.value("this.channels", "-")) mask = nuke.value("this.maskChannelInput", "none") unpremult = nuke.value("this.unpremult", "none") if _class.startswith("Read") or _class.startswith("Write"): # do colorspace labeling for reads and writes if int(nuke.numvalue("this.raw", 0)): layer = "RAW" else: colorspace = _getAutoLableColorspace() # additional to NUKE-mode default colorspaces not being shown, if the # colorspace is set to "custom" (aka unintialised) in the UI the name # comes through as empty, so ignore it. if colorspace: layer = colorspace if _class.startswith("Write"): order = nuke.numvalue("this.render_order", 1) mask = str(order) if int(order) == 1: mask = "none" elif _class == "Reformat": if nuke.expression("!type"): format = nuke.value("format") rootformat = nuke.value("root.format") if format is not None and format != rootformat: format_list = format.split() layer = " ".join(format_list[7:]) elif _class == "ChannelMerge": if operation == "union": operation = "U" elif operation == "intersect": operation = "I" elif operation == "stencil": operation = "S" elif operation == "absminus": operation = "abs-" elif operation == "plus": operation = "+" elif operation == "minus": operation = "-" elif operation == "multiply": operation = "*" layer = nuke.value("A") + " " + operation + " " + nuke.value("B") + " =\n" + nuke.value("output") elif _class == "Premult" or _class == "Unpremult": unpremult = nuke.value("alpha") if unpremult == "alpha": unpremult = "none" elif _class == "Copy": layer = "" if nuke.value("to0") != "none": layer += nuke.value("from0") + " -> " + nuke.value("to0") if nuke.value("to1") != "none": layer += "\n" + nuke.value("from1") + " -> " + nuke.value("to1") if nuke.value("to2") != "none": layer += "\n" + nuke.value("from2") + " -> " + nuke.value("to2") if nuke.value("to3") != "none": layer += "\n" + nuke.value("from3") + " -> " + nuke.value("to3") if nuke.value("channels") != "none": layer += ("\n" + nuke.value("channels") + "->" + nuke.value("channels")) elif _class == "FrameHold": value_inc = nuke.value("increment") if int(value_inc): layer = "frame "+nuke.value("knob.first_frame")+"+n*"+value_inc else: layer = "frame "+nuke.value("knob.first_frame") elif _class == "Precomp": layer = '-' if mask != "none": if int(nuke.numvalue("invert_mask", 0)): layer += (" / ~" + mask) else: layer += (" / " + mask) if unpremult != "none" and unpremult != mask and _class.find("Deep", 0) == -1: layer += ( " / " + unpremult) if layer != "rgba" and layer != "rgb" and layer != "-": result = __concat_result_string(name, "(" + layer + ")" + "\n" + str(label)) else: result = __concat_result_string(name, label) return result