def make_dir_path(): file = "" # are we being called interactively, by the user hitting Ctrl+F8? if nuke.thisNode() == nuke.root(): sel = None try: sel = nuke.selectedNodes()[0] except: print "WARNING: No nodes selected." return file = nuke.filename(sel) else: # nuke.filename(nuke.thisNode()) occasionally throws a RuntimeError exception when ran from the addBeforeRender() callback. # catch the exception and do not proceed when the exception is thrown. # added by Ned, 2016-01-27 try: file = nuke.filename(nuke.thisNode()) except RuntimeError as re: return except ValueError as ve: return dir = os.path.dirname(file) osdir = nuke.callbacks.filenameFilter(dir) if not os.path.exists(osdir): print "INFO: Creating directory at: %s" % osdir try: os.makedirs(osdir) except OSError as e: print "ERROR: os.makedirs() threw exception: %d" % e.errno print "ERROR: Filename: %s" % e.filename print "ERROR: Error String: %s" % e.strerror
def get_current_value(self, instance): current = "" if nuke.filename(instance[0]): current = nuke.filename(instance[0]) return current
def get_current_value(self, instance): import nuke current = "" if nuke.filename(instance[0]): current = nuke.filename(instance[0]) return current
def autoShuffleReads(nodes): import re import nuke nuke.Undo().name("organize and split") nuke.Undo().begin() readList = [] yPosAvg = 0 xPosAvg = 0 count = 0 try: nodes # does a exist in the current namespace except NameError: nodes = nuke.selectedNodes() for curNode in nodes: if curNode.Class() == "Read": readList.append({"file": nuke.filename(curNode), "node": curNode}) yPosAvg = yPosAvg + curNode["ypos"].value() xPosAvg = xPosAvg + curNode["xpos"].value() count += 1 readListSorted = sorted(readList, key=lambda k: k["file"]) xPosAvg = int(xPosAvg / count) yPosAvg = int(yPosAvg / count) count = 0 for readNode in readListSorted: readNode["node"]["xpos"].setValue(xPosAvg - 110 * count) readNode["node"]["ypos"].setValue(yPosAvg) readNode["node"]["selected"].setValue(True) count += 1 for n in nuke.selectedNodes(): n.autoplace() prevNode = nuke.nodes.Dot() originalDot = prevNode for curNode in nuke.selectedNodes(): if curNode.Class() == "Read": count += 1 filename = nuke.filename(curNode) passName = filename.split(".")[1] if re.match(r"^[A-Za-z0-9_]+$", passName): newLayer = nuke.Layer(passName, [passName + ".red", passName + ".green", passName + ".blue"]) shuffle = nuke.nodes.Shuffle(label=passName, inputs=[curNode]) shuffle["out"].setValue(passName) dotNode = nuke.nodes.Dot(inputs=[shuffle]) copyNode = nuke.nodes.Copy(inputs=[prevNode, dotNode], channels=passName, selected=True) prevNode = copyNode else: masterNode = curNode if count % 2 == 0: curNode["ypos"].setValue(curNode["ypos"].value() + 110) originalDot.setInput(0, masterNode) backdrop = nukescripts.autoBackdrop() backdrop.knob("tile_color").setValue(2139062271) nuke.Undo().end()
def preview_on_rv(rv_player="/Applications/RV64.app/Contents/MacOS/RV64"): rv_arguments = [] sequence_list = [] # READ / WRITE NODES for node in (nuke.selectedNodes('Read') + nuke.selectedNodes('Write')): file_path = nuke.filename(node) if not file_path: continue file_path = nuke.callbacks.filenameFilter(file_path) first_frame = str( node.knob('first').value()) if node.Class() == 'Read' else str( node.firstFrame()) last_frame = str( node.knob('last').value()) if node.Class() == 'Read' else str( node.firstFrame()) sequence_list.append('[ ' + file_path + ' -in %s -out %s ]' % (first_frame, last_frame)) # FRAME RANGE NODES for node in nuke.selectedNodes('FrameRange'): input_node = node.input(0) if input_node.Class() in ['Read', 'Write']: file_path = nuke.filename(input_node) if not file_path: continue file_path = nuke.callbacks.filenameFilter(file_path) first_frame = node.knob('first_frame').value() last_frame = node.knob('last_frame').value() sequence_list.append('[ ' + file_path + ' -in %s -out %s ]' % (first_frame, last_frame)) total_files = len(sequence_list) if total_files == 0: nuke.message("You must select a Read or a Write node.") return elif total_files == 2: panel = nuke.Panel("Rv Viewer") panel.addEnumerationPulldown('Operation', 'Sequence Difference Wipe Tile') result = panel.show() if not result: return operation_type = panel.value("Operation") if operation_type != 'Sequence': rv_arguments.append('-' + operation_type.lower()[0:4]) ## OPEN RV command_line = '"' + rv_player + '"' + ' ' + ' '.join( rv_arguments) + ' ' + ' '.join(sequence_list) subprocess.Popen(command_line, shell=True)
def process(self, context): # Get remote nodes remote_nodes = [] for node in nuke.allNodes(): if node.Class() == "BackdropNode": if node.name().lower().startswith("remote"): remote_nodes.extend(node.getNodes()) remote_nodes = list(set(remote_nodes)) # creating instances per write node for node in nuke.allNodes(): if node.Class() != "Write": continue # Determine output type output_type = "img" if node["file_type"].value() == "mov": output_type = "mov" # Determine processing location from backdrops process_place = "local" if node in remote_nodes: process_place = "remote" # Create instance instance = context.create_instance(name=node.name()) instance.data["families"] = ["write", process_place, output_type] instance.data["family"] = output_type instance.add(node) label = "{0} - write - {1}" instance.data["label"] = label.format(node.name(), process_place) instance.data["publish"] = not node["disable"].getValue() # Get frame range start_frame = int(nuke.root()["first_frame"].getValue()) end_frame = int(nuke.root()["last_frame"].getValue()) if node["use_limit"].getValue(): start_frame = int(node["first"].getValue()) end_frame = int(node["last"].getValue()) # Add collection collection = None try: path = "" if nuke.filename(instance[0]): path = nuke.filename(instance[0]) path += " [{0}-{1}]".format(start_frame, end_frame) collection = clique.parse(path) except Exception as e: self.log.warning(e) instance.data["collection"] = collection
def process(self, context): import clique import nuke instances = [] # creating instances per write node for node in nuke.allNodes(): if node.Class() != "Write": continue # Determine output type output_type = "img" if node["file_type"].value() == "mov": output_type = "mov" # Create instance instance = api.Instance(node.name()) instance.data["family"] = output_type instance.add(node) instance.data["label"] = node.name() instance.data["publish"] = False # Get frame range start_frame = int(nuke.root()["first_frame"].getValue()) end_frame = int(nuke.root()["last_frame"].getValue()) if node["use_limit"].getValue(): start_frame = int(node["first"].getValue()) end_frame = int(node["last"].getValue()) # Add collection collection = None try: path = "" if nuke.filename(node): path = nuke.filename(node) path += " [{0}-{1}]".format(start_frame, end_frame) collection = clique.parse(path) except ValueError: # Ignore the exception when the path does not match the # collection. pass instance.data["collection"] = collection instances.append(instance) context.data["write_instances"] = instances context.data["instances"] = ( context.data.get("instances", []) + instances )
def sendData(): try: n = nuke.selectedNode() except : awNodes = nuke.allNodes('AutoWriter') n = awNodes[0] if len(awNodes) > 1 : nuke.message('Error :\nYou have more than one AutoWrite. Please select one.') return if n.Class() == 'AutoWriter': with n: nodes = nuke.allNodes('Write') for curNode in nodes: if 'exr' in nuke.filename(curNode).lower(): exrPath = nuke.filename(curNode) if 'jpeg' in nuke.filename(curNode).lower() and '2048x1080' in nuke.filename(curNode).lower(): outputFile = nuke.filename(curNode) frameFirst = int(nuke.root()['first_frame'].value()) frameLast = int(nuke.root()['last_frame'].value()) if os.path.exists(fxpipe.framePadReplace(outputFile, frameLast)) == False: nuke.message('Error : this output does not exist') return #frameFirst = int(nuke.root()['first_frame'].getValue())-1 #frameLast = int(nuke.root()['last_frame'].getValue()) progressTask = nuke.ProgressTask("Sending to Review Room") progressTask.setMessage("Pushing file to Playback Machine") progressTask.setProgress(0) fh = open('//svenplay/cache/%s.rv' % (os.path.basename(outputFile).split('.')[0]), 'w') fh.write('GTOa (3)\n\n') fh.write('sourceGroup0_source : RVFileSource(1)\n{\n media \n {\nstring movie = "%s" \n}\n}' % (outputFile)) fh.close() progressTask.setProgress(50) #progressTask.setMessage('Pushing Shotgun Version') sgu = shotgunUtils.genericUtils() project = sgu.project(fxpipe.showName(outputFile)) shot = sgu.shot(project,fxpipe.shotName(outputFile)) try: vData = sgu.versionCreate(project, shot, fxpipe.shotName(outputFile) + '_' + fxpipe.versionNumber(outputFile), 'Sent for Review', outputFile, frameFirst, frameLast, task='Comp', makeThumb=True,) except: vData = None progressTask.setProgress(100) if vData: nuke.message('Created Version: %s' % vData['code']) else: nuke.message('Error Creating Version') else: nuke.message ('You have not selected an AutoWrite node')
def process(self, context): instances = [] # creating instances per write node for node in nuke.allNodes(): if node.Class() != "Write": continue # Determine output type output_type = "img" if node["file_type"].value() == "mov": output_type = "mov" # Create instance instance = pyblish.api.Instance(node.name()) instance.data["family"] = output_type instance.add(node) instance.data["label"] = node.name() instance.data["publish"] = False # Get frame range start_frame = int(nuke.root()["first_frame"].getValue()) end_frame = int(nuke.root()["last_frame"].getValue()) if node["use_limit"].getValue(): start_frame = int(node["first"].getValue()) end_frame = int(node["last"].getValue()) # Add collection collection = None try: path = "" if nuke.filename(node): path = nuke.filename(node) path += " [{0}-{1}]".format(start_frame, end_frame) collection = clique.parse(path) except ValueError: # Ignore the exception when the path does not match the # collection. pass instance.data["collection"] = collection instances.append(instance) context.data["write_instances"] = instances context.data["instances"] = (context.data.get("instances", []) + instances)
def readFromWrite(): nodes = nuke.selectedNodes() for node in nodes: assert node.Class() == 'Write' filename = nuke.filename(node) while True: dir = os.path.dirname(filename) print("Looking for:", filename) try: fileset = nuke.getFileNameList(dir)[0] print("Found fileset on disk: ", fileset) break except: print("Version not found, searching for previous takes.") prefix, num = re.search(r'(v)(\d+)', filename, re.IGNORECASE).groups() new_ver = str(int(num) - 1).zfill(len(num)) assert int(new_ver) > 0, "NO VERSIONS FOUND" filename = re.sub(r'v(\d+)', prefix + new_ver, filename) fileset = os.path.join(dir, fileset) read = nuke.createNode('Read') read['file'].fromUserText(fileset) read.setXYpos(node.xpos(), node.ypos() + 120)
def versionChange(n, cur_ver, new_ver): '''change version, up/down/latest @n: node, obj @cur_ver: current version, int @new_ver: new version, int ''' new_ver_str = '_v%03d' % new_ver path_ver = n['tx_dir'].value() path_lgt = os.path.dirname(n['tx_dir'].value()) cur_ver_str = '_v%03d' % cur_ver new_path = path_ver.replace(cur_ver_str, new_ver_str) if os.path.isdir(new_path): with n: all_read = nuke.allNodes('Read') for r in all_read: thisFilename = nuke.filename(r) thisFilename = thisFilename.replace(cur_ver_str, new_ver_str) r['file'].setValue(thisFilename) n['tx_dir'].setValue(new_path) n['int_thisVersion'].setValue('%03d' % new_ver) else: print "No version %s found" % new_path
def actualFilename(node): """ Given a node that reads a file, returns a tuple where: [0] The parent/containing folder of the file [1] The file's name you see in nuke's panel [2] A real name for the file """ (dirPath, basename) = os.path.split(nuke.filename(node)) def getFirstFrameOfSequence(): first_frame = node["first"].value() if node.Class() == "Write" and (node["first"].value() == node["last"].value()): # For Write nodes without a render range set, assume the # first frame is the comp's first frame. first_frame = nuke.root().firstFrame() return first_frame if re.search("#+", basename): # NOTE: On Read nodes, for some fucky reason, if a node's file name # is file.%05d.jpg -- nuke.filename(node) gives you file.#####.jpg instead. # c = '%0' + str(len(re.findall('#',basename))) + 'd' # filename = re.sub('#+',c,basename) % getFirstFrameOfSequence() basename = nukescripts.replaceHashes(basename) if re.search(r"%\d+d", basename): # Sequence files filename = basename % getFirstFrameOfSequence() else: # Standalone/single non-sequence files filename = basename return dirPath, basename, filename
def AutoQT(): pan = nuke.Panel('AutoQT_by_ [email protected]') pan.addFilenameSearch('OUT PATH', 'output path here') pan.addEnumerationPulldown('Select Size', 'PAL HD 1K_Super_35(full-ap)') pan.show() Output_Path = pan.value('OUT PATH') QT_Size = pan.value('Select Size') sel = nuke.selectedNodes() for m in sel: fn = nuke.filename(m) fn = os.path.basename(fn) fn = os.path.splitext(fn)[0] firstFrame = m.knob('first').getValue() lastFrame = m.knob('last').getValue() print fn rf = nuke.createNode("Reformat") rf.setInput(0, m) rf['format'].setValue(QT_Size) rf['black_outside'].setValue('True') wr = nuke.createNode("Write") wr.setInput(0, rf) wr['file'].setValue(Output_Path + fn + ".mov") wr['file_type'].setValue('mov') wr['codec'].setValue('none') wr['use_limit'].setValue('True') wr['first'].setValue(firstFrame) wr['last'].setValue(lastFrame) return ()
def _evaluate_path_expression(node, knob): knob_value = knob.value() # If the knob value has an open bracket, assume it's an expression. if '[' in knob_value: if node.Class() == 'Write': knob.setValue(nuke.filename(node)) else: # Running knob.evaluate() will freeze not just expressions, but frame number as well. Use regex to search for # any frame number expressions, and replace them with a placeholder. to_eval = knob_value placeholders = {} regexs = [r'#+', r'%.*d'] for regex in regexs: match = 1 while match: match = re.search(regex, to_eval) if match: placeholder = '__frame%d' % (len(placeholders) + 1,) original = match.group() placeholders[placeholder] = original to_eval = to_eval[0:match.start()] + '{%s}' % (placeholder,) + to_eval[match.end():] # Set the knob value to our string with placeholders. knob.setValue(to_eval) # Now evaluate the knob to freeze the path. frozen_path = knob.evaluate() # Use our dictionary of placeholders to place the original frame number expressions back in. frozen_path = frozen_path.format(**placeholders) # Finally, set the frozen path back to the knob. knob.setValue(frozen_path)
def w_create_dir(): """ Automatically create write node directory. """ path = os.path.dirname(nuke.filename(nuke.thisNode())) if not os.path.isdir(path): os_wrapper.createDir(path) return path
def st_writeFromeReadMeta(custom): # make sure custom param doesnt connect with values ahead of it if custom: custom = "_" + custom # get selected nodes writeNodes = nuke.selectedNodes() for wnode in writeNodes: if wnode.Class() == "Write": # Get top node in chain topnode_name = nuke.tcl("full_name [topnode %s]" % wnode.name()) topnode = nuke.toNode(topnode_name) # Path to read node fullPath = nuke.filename(topnode) pathOnly = os.path.dirname(topnode['file'].value()) writePath = pathOnly + '/' # Focal Length fLength = topnode.metadata()['input/focal_length'] focalSplit = fLength.split('/',1) focal = focalSplit[0] focal = focal + "MM" # Split up "File.jpg" to "File" and ".jpg" fullPathSplit = fullPath.split("/") fileName = fullPathSplit[len(fullPathSplit)-1] fileNameSplit = fileName.split('.') # Define write path and assign to Write Node writePath = (writePath + fileNameSplit[0] + "_" + focal + custom + "." + fileNameSplit[1]) wnode['file'].setValue(writePath) # Print the result print (wnode.name() + " : " + (wnode['file'].getValue()))
def createWriteDir(): ''' This function creates a write directory automatically so the user does not have to do it. Supports stereo notation with %v and %V ''' import nuke, os curnode = nuke.thisNode() originalFileName = nuke.filename(curnode) allViews = curnode.knob('views').value() # look for views in the write node allViews = allViews.split() # split them out outputFilename = [] for view in allViews: fileName = originalFileName # check for the standard nuke view parameters if '%v' in fileName : outputFilename.append(fileName.replace('%v',view[:1])) if '%V' in fileName : outputFilename.append(fileName.replace('%V',view)) print outputFilename if len(outputFilename) < 1: outputFilename.append(originalFileName) for fileName in outputFilename: dir = os.path.dirname( fileName ) osdir = nuke.callbacks.filenameFilter( dir ) if not os.path.exists( osdir ): os.makedirs( osdir ) print 'Created : %s' % (osdir)
def sendToAvconv(codec = 'dnxhd'): # Configuration renderSlug = False vcodec = { 'x264' : 'libx264 -pre baseline', 'dnxhd' : 'dnxhd -b 36M', } extension = '.mov' # set some variables fps = nuke.root().knob('fps').value() firstFrame = nuke.root().knob('first_frame').value() ss = 0 if renderSlug == True else secondsToStr(firstFrame/fps) # grabs the write node's file value and makes sure the path uses printf style filenames imgSeqPath = nukescripts.replaceHashes(nuke.filename(nuke.thisNode())) # generate mov path base, ext = os.path.splitext(os.path.basename(imgSeqPath)) movPath = os.path.dirname(os.path.dirname(imgSeqPath)) + '/' + re.sub('\.?%0\d+d$', '', base) + extension # make shell command enc = 'avconv -y -r %s -i \'%s\' -s \'hd1080\' -an -ss %s -vcodec %s -threads 0 \'%s\'' % (fps, imgSeqPath, ss, vcodec[codec], movPath) #print enc subprocess.Popen(shlex.split(enc), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
def launchRV(): '''launch selected read nodes with RV''' path_read = [nuke.filename(n) for n in nuke.selectedNodes('Read')] if path_read: cmd = "rv -c -over %s &" % ' '.join(path_read) os.system(cmd)
def remove_duplicated_read(is_show_result=True): """Remove duplicated read to save memory. """ nodes = nuke.allNodes('Read') nodes.sort(key=lambda n: n.ypos()) distinct_read = [] removed_nodes = [] for n in nodes: same_node = _find_same(n, distinct_read) if same_node: dot = nuke.nodes.Dot(inputs=[same_node], label='代替: {}\n{}'.format( u(n.name()), u(nuke.filename(n))).encode('utf-8'), hide_input=True) dot.setXYpos(n.xpos() + 34, n.ypos() + 57) core.replace_node(n, dot) n_name = u(n.name()) removed_nodes.append(n_name) u_print('用 {0} 代替 {1} , 删除 {1}。'.format(u(same_node.name()), n_name)) nuke.delete(n) else: distinct_read.append(n) if not is_show_result: return if removed_nodes: nuke.message('合并时删除了{}个节点: \n{}'.format( len(removed_nodes), ', '.join(removed_nodes)).encode('utf-8')) else: nuke.message('没有发现重复读取节点。'.encode('utf-8'))
def freeze_node(node, view=None): """ If the node has an expression, evaluate it so that the ZYNC can parse it. Also accounts for and retains frame number expressions. Should be idempotent. """ knob_names = ['file', 'font'] for knob_name in knob_names: file_knob = node.knob(knob_name) if file_knob == None: continue knob_value = file_knob.value() # if the file param has an open bracket, let's assume that it's an # expression: if '[' in knob_value: if node.Class() == 'Write': file_knob.setValue(nuke.filename(node)) else: frozen_path = file_knob.evaluate() frozen_dir = os.path.split(frozen_path)[0] file_expr = os.path.split(knob_value)[-1] # sets the read node to be file_knob.setValue(os.path.join(frozen_dir, file_expr)) if view: knob_value = knob_value.replace('%v', view.lower()) knob_value = knob_value.replace('%V', view.upper()) node.knob(knob_name).setValue(knob_value)
def dpxNoAlpha(): """ Do not allow DPX files to be written with alpha """ n = nuke.thisNode() if nuke.filename(n).endswith("dpx"): n['channels'].setValue("rgb")
def createWriteDirs(): """ Automatically create directories in Write path if path doesn't exists. """ f = nuke.filename(nuke.thisNode()) dirr = os.path.dirname(f) if not os.path.exists(dirr): osdir = nuke.callbacks.filenameFilter(dirr) os.makedirs(osdir)
def output_to_h264(write_node=None): """an after render function which converts the input to h264 """ # get the file name if not write_node: write_node = nuke.thisNode() file_full_path = nuke.filename(write_node) # add the _h264 extension to the filename file_name = os.path.basename(file_full_path) path = file_full_path[:-len(file_name)] file_name_wo_ext, ext = os.path.splitext(file_name) # split any '.' (ex: a.%04d -> [a, %04d]) file_name_wo_ext = file_name_wo_ext.split('.')[0] # add _h264 output_file_name = file_name_wo_ext + '_h264.mov' output_full_path = os.path.join(path, output_file_name) # TODO: if it is a sequence of images rename them by creating temp soft # links to each frame and then use the sequence format in ffmpeg # run ffmpeg in a separate thread t = threading.Timer(1.0, convert_to_h264, args=[file_full_path, output_full_path]) t.start()
def nk_rv(nodes=None): """ Send to RV SS Shift+r """ f_image = lambda node: os.path.join(nuke.actualFilename(n)[0],nuke.actualFilename(n)[-1]) path = {} path['Write'] = f_image path['Read'] = f_image path['Precomp'] = lambda node: nuke.filename(node) inbox_rv = [] inbox_nuke = [] send_to = {} send_to['Read'] = inbox_rv send_to['Write'] = inbox_rv send_to['Precomp'] = inbox_nuke n = [send_to[n.Class()].append(path[n.Class()](n)) for n in nuke.selectedNodes() if n.Class() in path.keys()] [Popen("""nuke --nukex %s""" % p, stdout=PIPE, shell=True) for p in inbox_nuke] rv_cmd = {} rv_cmd[0] = lambda n: None rv_cmd[1] = lambda n: """%s -fullscreen "%s" """ % (os.environ['RVPATH'], n[0]) rv_cmd[2] = lambda n: """%s -fullscreen -sessionType stack %s """ % ( os.environ['RVPATH']," ".join(n) ) cmd = rv_cmd.get(len(inbox_rv), rv_cmd[2])(inbox_rv) if cmd: Popen(cmd, stdout=PIPE, shell=True)
def _evaluate_path_expression(node, knob): knob_value = knob.value() # If the knob value has an open bracket, assume it's an expression. if '[' in knob_value: if node.Class() in WRITE_NODE_CLASSES: knob.setValue(nuke.filename(node)) else: # Running knob.evaluate() will freeze not just expressions, but frame number as well. Use regex to search for # any frame number expressions, and replace them with a placeholder. to_eval = knob_value placeholders = {} regexs = [r'#+', r'%.*d'] for regex in regexs: match = 1 while match: match = re.search(regex, to_eval) if match: placeholder = '__frame%d' % (len(placeholders) + 1, ) original = match.group() placeholders[placeholder] = original to_eval = to_eval[0:match.start()] + '{%s}' % ( placeholder, ) + to_eval[match.end():] # Set the knob value to our string with placeholders. knob.setValue(to_eval) # Now evaluate the knob to freeze the path. frozen_path = knob.evaluate() # Use our dictionary of placeholders to place the original frame number expressions back in. frozen_path = frozen_path.format(**placeholders) # Finally, set the frozen path back to the knob. knob.setValue(frozen_path)
def rrSubmit_CreateSelectedJobs(node, jobList): if node['disable'].value(): writeError("please enable the Write node") return newJob = rrJob() rrSubmit_fillGlobalSceneInfo(newJob) #if node.knob('renderUseful').value(): # newJob.sceneName = newJob.sceneName.replace('.nk', '_lite.nk') if (node['use_limit'].value()): newJob.seqStart = node['first'].value() newJob.seqEnd = node['last'].value() newJob.imageFileName = nuke.filename(node) if ((newJob.imageFileName.find("%V") >= 0) or (newJob.imageFileName.find("%v") >= 0)): newJob.maxChannels = newJob.maxChannels + 1 newJob.channelFileName = list() newJob.channelFileName.append( string.replace(string.replace(newJob.imageFileName, "%v", "l"), "%V", "left")) newJob.channelExtension.append("") newJob.imageFileName = string.replace( string.replace(newJob.imageFileName, "%v", "r"), "%V", "right") # newJob.imageDir=os.path.dirname(newJob.imageFileName) newJob.layer = node['name'].value() newJob.isActive = False jobList.append(newJob)
def createWriteDir(): ''' This function creates a write directory automatically so the user does not have to do it. Supports stereo notation with %v and %V ''' import nuke, os curnode = nuke.thisNode() originalFileName = nuke.filename(curnode) allViews = curnode.knob( 'views').value() # look for views in the write node allViews = allViews.split() # split them out outputFilename = [] for view in allViews: fileName = originalFileName # check for the standard nuke view parameters if '%v' in fileName: outputFilename.append(fileName.replace('%v', view[:1])) if '%V' in fileName: outputFilename.append(fileName.replace('%V', view)) print outputFilename if len(outputFilename) < 1: outputFilename.append(originalFileName) for fileName in outputFilename: if fileName != '': dir = os.path.dirname(fileName) osdir = nuke.callbacks.filenameFilter(dir) if not os.path.exists(osdir): os.makedirs(osdir) print 'Created : %s' % (osdir)
def output_to_h264(write_node=None): """an after render function which converts the input to h264 """ # get the file name if not write_node: write_node = nuke.thisNode() file_full_path = nuke.filename(write_node) # add the _h264 extension to the filename file_name = os.path.basename(file_full_path) path = file_full_path[:-len(file_name)] file_name_wo_ext, ext = os.path.splitext(file_name) # split any '.' (ex: a.%04d -> [a, %04d]) file_name_wo_ext = file_name_wo_ext.split('.')[0] # add _h264 output_file_name = file_name_wo_ext + '_h264.mov' output_full_path = os.path.join(path, output_file_name) # TODO: if it is a sequence of images rename them by creating temp soft # links to each frame and then use the sequence format in ffmpeg # run ffmpeg in a seperate thread t = threading.Timer( 1.0, convert_to_h264, args=[file_full_path, output_full_path] ) t.start()
def process(self, context, plugin): import clique import nuke # Get the errored instances failed = [] for result in context.data["results"]: if (result["error"] is not None and result["instance"] is not None and result["instance"] not in failed): failed.append(result["instance"]) # Apply pyblish.logic to get the instances for the plug-in instances = api.instances_by_plugin(failed, plugin) for instance in instances: collection = clique.assemble([nuke.filename(instance[0])], minimum_items=1, patterns=[clique.PATTERNS['frames'] ])[0][0] instance[0]["file"].setValue( collection.format("{head}{padding}{tail}")) instance[0]["first"].setValue(list(collection.indexes)[0]) instance[0]["last"].setValue(list(collection.indexes)[0]) instance[0]["origfirst"].setValue(list(collection.indexes)[0]) instance[0]["origlast"].setValue(list(collection.indexes)[0])
def skippy(): n = nuke.thisNode() currentFrame = nuke.filename(n, nuke.REPLACE) tmpFrame = currentFrame + ".tmp" try: n['autocrop'].value() except: autoCropOn = 0 else: if n['autocrop'].value() is True: autoCropOn = 1 n['autocrop'].setValue(False) else: autoCropOn = 0 if os.path.exists(currentFrame) or os.path.exists(tmpFrame): #print "Frame exists: %s\t skipping..." %currentFrame nuke.cancel() if autoCropOn == 1: n['autocrop'].setValue(True) else: if autoCropOn == 1: n['autocrop'].setValue(True) else: pass
def create_read_from_write(): node_list = nuke.selectedNodes('Write') if len(node_list) == 0: nuke.message("You must select a WRITE node first.") return for node in node_list: file_knob = nuke.filename(node) if not file_knob: nuke.message( "No file output path on node '%s'. Add some path there and try again." % node.name()) continue read_node = nuke.createNode("Read", inpanel=False) read_node.setXYpos(node.xpos(), node.ypos() + 80) read_node.knob("file").setValue(file_knob) first_frame = int(node.firstFrame()) last_frame = int(node.lastFrame()) read_node.knob("first").setValue(first_frame) read_node.knob("last").setValue(last_frame) read_node.knob("origfirst").setValue(first_frame) read_node.knob("origlast").setValue(last_frame)
def process(self, context, plugin): import clique import nuke # Get the errored instances failed = [] for result in context.data["results"]: if (result["error"] is not None and result["instance"] is not None and result["instance"] not in failed): failed.append(result["instance"]) # Apply pyblish.logic to get the instances for the plug-in instances = api.instances_by_plugin(failed, plugin) for instance in instances: collection = clique.assemble( [nuke.filename(instance[0])], minimum_items=1, patterns=[clique.PATTERNS['frames']] )[0][0] instance[0]["file"].setValue( collection.format("{head}{padding}{tail}") ) instance[0]["first"].setValue(list(collection.indexes)[0]) instance[0]["last"].setValue(list(collection.indexes)[0]) instance[0]["origfirst"].setValue(list(collection.indexes)[0]) instance[0]["origlast"].setValue(list(collection.indexes)[0])
def readFromWrite(): nodes = nuke.selectedNodes() if len(nodes) < 1: print('No nodes selected') else : foundWrites = False writeNodes = [] for node in nodes: if node.Class() == 'Write': writeNodes.append(node) foundWrites = True if foundWrites == True: # we found some writes for node in writeNodes: nodeRead = nuke.nodes.Read() # create a read node nodeRead['file'].setValue(nuke.filename(node)) #set the filename if node['use_limit'].getValue() == 1: #check to see if there is a range and set the values in the read node nodeRead['first'].setValue(int(node['first'].getValue())) nodeRead['last'].setValue(int(node['last'].getValue())) else: # no range on the write? take a stab at using the range from the script value nodeRead['first'].setValue(int(nuke.root()['first_frame'].getValue())) nodeRead['last'].setValue(int(nuke.root()['last_frame'].getValue())) nodeRead.setXpos(node.xpos()) #let's set the position nodeRead.setYpos(node.ypos()+50) nodeRead['premultiplied'].setValue(node['premultiplied'].getValue()) # use premult if checked nodeRead['raw'].setValue(node['raw'].getValue()) # use raw if checked else: print('No Writes Found in Node Selection')
def rrSubmit_CreateSingleJobs_Node(jobList, noLocalSceneCopy, node): nViews = nuke.views() if node["disable"].value(): return pathScripted = "" writeNode = node writeNodeName = writeNode["name"].value() if isGizmo(node): with node: gList = nuke.allNodes("Write") + nuke.allNodes("DeepWrite") for gnode in gList: if gnode["disable"].value(): continue pathScripted = gnode["file"].value() if (pathScripted == None) or (len(pathScripted) < 3): continue writeNode = gnode if isScriptedOutput(pathScripted, True): noLocalSceneCopy[0] = True else: pathScripted = writeNode["file"].value() if (pathScripted == None) or (len(pathScripted) < 3): return newJob = rrJob() rrSubmit_fillGlobalSceneInfo(newJob) useStereoFlag = False if len(nViews) == 2: useStereoFlag = True newJob.imageStereoR = nViews[0] newJob.imageStereoL = nViews[1] if writeNode["use_limit"].value(): newJob.seqStart = writeNode["first"].value() newJob.seqEnd = writeNode["last"].value() newJob.imageFileName = nuke.filename(writeNode) if (newJob.imageFileName == None) or (len(newJob.imageFileName) < 3): return if newJob.seqStart == newJob.seqEnd and (newJob.imageFileName.find("#") < 0): newJob.imageSingleOutput = True if useStereoFlag: if newJob.imageFileName.find("%V") >= 0: newJob.imageFileName = string.replace(newJob.imageFileName, "%V", "<Stereo>") elif newJob.imageFileName.find("%v") >= 0: newJob.imageFileName = string.replace(newJob.imageFileName, "%v", "<Stereo>") newJob.imageStereoR = newJob.imageStereoR[0] newJob.imageStereoL = newJob.imageStereoL[0] else: useStereoFlag = False elif (newJob.imageFileName.find("%V") >= 0) or (newJob.imageFileName.find("%v") >= 0): for vn in range(1, len(nViews)): newJob.maxChannels = newJob.maxChannels + 1 newJob.channelFileName.append( string.replace(string.replace(newJob.imageFileName, "%v", nViews[vn][0]), "%V", nViews[vn]) ) newJob.channelExtension.append("") newJob.imageFileName = string.replace(string.replace(newJob.imageFileName, "%v", nViews[0][0]), "%V", nViews[0]) newJob.layer = writeNodeName newJob.isActive = False jobList.append(newJob)
def open_with_djv(): pattern_items = [ "C:" + os.sep, "Program Files", "djv-[0-9].[0-9].[0-9]-Windows-64", "bin", "djv_view.exe" ] executables = get_regex_files(pattern_items) args = [executables[0], nuke.filename(nuke.selectedNode(), nuke.REPLACE)] subprocess.Popen(args)
def createOutDirs(): trgDir = os.path.dirname(nuke.filename(nuke.thisNode())) if not os.path.isdir(trgDir): try: os.makedirs(trgDir) except: pass
def open_node_in_file_browser(node): """opens the node path in filebrowser """ file_full_path = nuke.filename(node) # get the path file_name = os.path.basename(file_full_path) path = file_full_path[:-len(file_name)] open_in_file_browser(path)
def writeNoOverwrite(): """ Automatically create directories in Write path if path doesn't exists. """ if nuke.thisNode()['no_overwrite'].value(): file_to_be_rendered = nuke.filename(nuke.thisNode(), nuke.REPLACE) if os.path.exists(file_to_be_rendered): msg = "File already exists: %s" % file_to_be_rendered try: raise RuntimeError(msg) except RuntimeError as e: print e
def process(self, context): import os import nuke instances = [] # creating instances per write node for node in nuke.allNodes(): if node.Class() != "WriteGeo": continue # Create cache instance instance = api.Instance(node.name()) instance.data["family"] = "cache" instance.data["families"] = ["writegeo"] instance.add(node) instance.data["label"] = node.name() instance.data["publish"] = False instance.data["output_path"] = nuke.filename(node) instances.append(instance) # Create camera instance instance = api.Instance(node.name()) instance.data["family"] = "camera" instance.data["families"] = ["writegeo"] instance.add(node) instance.data["label"] = node.name() instance.data["publish"] = False path, ext = os.path.splitext(nuke.filename(node)) instance.data["output_path"] = "{0}_camera{1}".format(path, ext) instances.append(instance) # Create geometry instance instance = api.Instance(node.name()) instance.data["family"] = "geometry" instance.data["families"] = ["writegeo"] instance.add(node) instance.data["label"] = node.name() instance.data["publish"] = False path, ext = os.path.splitext(nuke.filename(node)) instance.data["output_path"] = "{0}_geometry{1}".format(path, ext) instances.append(instance) context.data["instances"] = ( context.data.get("instances", []) + instances )
def createWriteDir(): file = nuke.filename(nuke.thisNode()) dir = os.path.dirname( file ) osdir = nuke.callbacks.filenameFilter( dir ) try: os.makedirs(osdir) except OSError: pass
def djv_this(node, start, end, incr, view): ''' Plays the selected node sequence in DJV. You can get DJV at: http://djv.sourceforge.net/ Use: djv_this( <node_object>, <start_frame>, <end_frame>, <frame_increment>, <view_name> ) ''' global djv_path if not os.access(djv_path, os.X_OK): raise RuntimeError('DJV cannot be executed "%s".' % djv_path) if len(view) > 1: raise RuntimeError('DJV currently does not support stereo sequences') filename = nuke.filename(node) if filename is None or filename == '': raise RuntimeError( 'DJV cannot be executed on "%s", expected to find a file and there was none.' % node.fullName()) try: padding = re.findall('%[0-9]*d', filename).pop() range = (padding % start) filename = re.sub('%[0-9]*d', range, filename) except: raise RuntimeError( 'djv_this.py was unable to form the necessary string with: %s' % filename) cmd = [] cmd.append(os.path.normpath(djv_path)) ### DJV Options Start ################################################ cmd.append(os.path.normpath(filename)) # cmd.append( '-file_layer (value)' ) #layer name cmd.append('-file_seq_auto True') cmd.append('-file_proxy 1/2') #Proxy scale: 1/2, 1/4, 1/8 cmd.append('-file_cache True') # Cache: True, False. # cmd.append( '-window_fullscreen' ) #Start in full screen # cmd.append("-window_toolbar False") # Toolbar controls: False, True. # cmd.append("-window_playbar False") # Window controls: False, True. # cmd.append("-view_grid None") # Grid overlay: None, 1x1, 10x10, 100x100. # cmd.append("-view_hud True") # Heads up display: True, False. cmd.append("-playback Forward") # Playback: Stop, Forward, Reverse. # cmd.append("-playback_frame (value)") # Frame. cmd.append("-playback_speed " + str(int(nuke.root().knob('fps').value()))) # cmd.append("-playback_timer (value)") # Timer: Sleep, Timeout. Value: Sleep. # cmd.append("-playback_timer_resolution (value)") # Timer resolution (seconds): 0.001. cmd.append("-time_units Frames") # Time units: Timecode, Frames. ### DJV Options End ################################################## print ' '.join(cmd) subprocess.Popen(' '.join(cmd), shell=True)
def process(self, context): import os import nuke instances = [] # creating instances per write node for node in nuke.allNodes(): if node.Class() != "WriteGeo": continue # Create cache instance instance = api.Instance(node.name()) instance.data["family"] = "cache" instance.data["families"] = ["writegeo"] instance.add(node) instance.data["label"] = node.name() instance.data["publish"] = False instance.data["output_path"] = nuke.filename(node) instances.append(instance) # Create camera instance instance = api.Instance(node.name()) instance.data["family"] = "camera" instance.data["families"] = ["writegeo"] instance.add(node) instance.data["label"] = node.name() instance.data["publish"] = False path, ext = os.path.splitext(nuke.filename(node)) instance.data["output_path"] = "{0}_camera{1}".format(path, ext) instances.append(instance) # Create geometry instance instance = api.Instance(node.name()) instance.data["family"] = "geometry" instance.data["families"] = ["writegeo"] instance.add(node) instance.data["label"] = node.name() instance.data["publish"] = False path, ext = os.path.splitext(nuke.filename(node)) instance.data["output_path"] = "{0}_geometry{1}".format(path, ext) instances.append(instance) context.data["instances"] = (context.data.get("instances", []) + instances)
def CheckOutputPath(): import nuke file = nuke.filename(nuke.thisNode()) dir = os.path.dirname(file) osdir = nuke.callbacks.filenameFilter(dir) try: os.makedirs(osdir) except OSError: pass
def __createRenderDirectory(cls, writeNode): """ Create the render directory for a write node. """ renderFilePath = nuke.filename(writeNode) if renderFilePath: renderFolder = os.path.dirname(renderFilePath) if not os.path.exists(renderFolder): os.makedirs(renderFolder)
def makeCurrent(): file = nuke.filename(nuke.thisNode(), nuke.REPLACE) scriptFilePath = nuke.root().name() if '/increments' in scriptFilePath: regex = re.compile("_[0-9]{3}[.]") incr = regex.findall(scriptFilePath)[0] scriptFilePath = scriptFilePath.replace('/increments', '').replace(incr, '.') fileName = file.split('/')[-1] outName = fileName.split("_")[1] outExt = fileName.split(".")[-1] if outExt == 'jpg': outExt = 'jpeg' scriptName = scriptFilePath.split('/')[-1] newFile = scriptFilePath.split( 'nuke')[0] + '_renders/nuke/' + scriptName.replace( '.nk', '') + '/' + outName + '/' + outExt + '/' + fileName print 'fileName', fileName print 'outName', outName print 'outExt', outExt print 'scriptName', scriptName regex = re.compile("_v[0-9]{2,9}") vers = regex.findall(file) for ver in vers: ver = ver.replace("_", "") newFile = newFile.replace(ver, 'current') print 'newFile', newFile thumbFile = file.replace('/exr/', '/exr/.thumbs/').replace('.exr', '.jpeg') newThumbFile = newFile.replace('/exr/', '/exr/.thumbs/').replace('.exr', '.jpeg') newDir = os.path.dirname(newFile) newThumbDir = os.path.dirname(newThumbFile) try: os.makedirs(newDir) except: pass try: os.makedirs(newThumbDir) except: pass try: shutil.copyfile(file, newFile) except: print 'noCopy file' pass try: shutil.copyfile(thumbFile, newThumbFile) except: print 'noCopy file' pass
def main(): file = nuke.filename(nuke.thisNode()) dir = os.path.dirname(file) osdir = nuke.callbacks.filenameFilter(dir) if not os.path.isdir(osdir): try: os.makedirs(osdir) except: pass
def findTopNode(n=nuke.selectedNode()): ''' Returns a string of the top node ''' topnode_name = nuke.tcl("full_name [topnode %s]" % n.name()) topnode_file = nuke.filename(nuke.toNode(topnode_name)) return topnode_name
def showReadWrite (): """ This panel gives you the number of reads that are either selected or in the entire script. Additionally, it tells you the path of either selected nodes or all read/write nodes. """ reads = [] readfiles = [] writes = [] writefiles = [] nodes = nuke.selectedNodes('Read') wnodes = nuke.selectedNodes('Write') if len(nodes) < 1: nodes = nuke.allNodes('Read') if len(wnodes) < 1: wnodes = nuke.allNodes('Write') for node in nodes: if nuke.filename(node) not in readfiles: reads.append ({'file':nuke.filename(node),'start':node['first'].value(),'end':node['last'].value()}) readfiles.append (nuke.filename(node)) for node in wnodes: if nuke.filename(node) not in writefiles: writes.append(nuke.filename(node)) read = '' output = '' writeOutput = '' x = 0 for read in reads: x = x + 1 output = '%s%s %d-%d\n' % (output, read['file'], int(read['start']), int(read['end'])) if len(writes) > 0: for write in writes: writeOutput = '%s%s\n' % (writeOutput, write) p = nuke.Panel('Read Paths', setWidth=650) p.addSingleLineInput('Script Name:', nuke.root()['name'].value()) p.addMultilineTextInput ('Read Paths:',output) p.addMultilineTextInput ('Write Paths:',writeOutput) p.addSingleLineInput ('Total Selected:', x) p.setWidth(1000) p.show()
def djv_this( node, start, end, incr, view ): ''' Plays the selected node sequence in DJV. You can get DJV at: http://djv.sourceforge.net/ Use: djv_this( <node_object>, <start_frame>, <end_frame>, <frame_increment>, <view_name> ) ''' global djv_path if not os.access( djv_path, os.X_OK ): raise RuntimeError( 'DJV cannot be executed "%s".' % djv_path ) if len( view ) > 1: raise RuntimeError( 'DJV currently does not support stereo sequences' ) filename = nuke.filename( node ) if filename is None or filename == '': raise RuntimeError( 'DJV cannot be executed on "%s", expected to find a file and there was none.' % node.fullName() ) try: padding = re.findall( '%[0-9]*d', filename ).pop() range = ( padding % start ) filename = re.sub( '%[0-9]*d', range, filename ) except: raise RuntimeError( 'djv_this.py was unable to form the necessary string with: %s' % filename ) cmd = [] cmd.append( os.path.normpath( djv_path ) ) ### DJV Options Start ################################################ cmd.append( os.path.normpath( filename ) ) # cmd.append( '-file_layer (value)' ) #layer name cmd.append( '-file_seq_auto True' ) cmd.append( '-file_proxy 1/2' ) #Proxy scale: 1/2, 1/4, 1/8 cmd.append( '-file_cache True' ) # Cache: True, False. # cmd.append( '-window_fullscreen' ) #Start in full screen # cmd.append("-window_toolbar False") # Toolbar controls: False, True. # cmd.append("-window_playbar False") # Window controls: False, True. # cmd.append("-view_grid None") # Grid overlay: None, 1x1, 10x10, 100x100. # cmd.append("-view_hud True") # Heads up display: True, False. cmd.append("-playback Forward") # Playback: Stop, Forward, Reverse. # cmd.append("-playback_frame (value)") # Frame. cmd.append("-playback_speed " + str( int( nuke.root().knob( 'fps' ).value() ) ) ) # cmd.append("-playback_timer (value)") # Timer: Sleep, Timeout. Value: Sleep. # cmd.append("-playback_timer_resolution (value)") # Timer resolution (seconds): 0.001. cmd.append("-time_units Frames") # Time units: Timecode, Frames. ### DJV Options End ################################################## print ' '.join(cmd) subprocess.Popen( ' '.join( cmd ), shell=True )
def createWriteDir(): import nuke, os file = nuke.filename(nuke.thisNode()) dir = os.path.dirname( file ) osdir = nuke.callbacks.filenameFilter( dir ) try: os.makedirs( osdir ) return except: return
def exrCompressionTest(): compressList = ['None', 'RLE', 'ZIP', 'ZIP 16 lines', 'PIZ', 'PXR24', 'B44', 'B44A'] try: n = nuke.selectedNode() if nuke.selectedNode().Class()!='Read' or nuke.selectedNode() == "" : nuke.message('No Read node selected.') elif os.path.splitext(nuke.filename(nuke.selectedNode()))[-1]!=".exr" : nuke.message('Selected Read is not an EXR') else: file = nuke.filename(n, nuke.REPLACE) fd = open(file, 'rb') header = fd.read(4096) index = header.find('compression') comp =ord(header[(index+28):(index+29)]) compressMethod = compressList[comp] print compressMethod nuke.message('EXR compression is %s' %(compressMethod)) except ValueError: nuke.message('Please select a Read node...')
def collect(): path = change_path(nuke.filename(nuke.thisNode(), nuke.REPLACE)) dir, file = os.path.split( path ) dir_list = dir.split('/') for i in range(len(dir_list)): if dir_list[i] and dir_list[i][0].lower() == 's' and dir_list[i][1:4].isdigit(): #print i, dir_list[i] string = '%s' % '/'.join(dir_list[0:i+1]) print string if os.path.exists(path): print '...'
def createWriteDir(): import nuke, os, errno file = nuke.filename(nuke.thisNode()) dir = os.path.dirname( file ) osdir = nuke.callbacks.filenameFilter( dir ) # cope with the directory existing already by ignoring that exception try: os.makedirs( osdir ) except OSError, e: if e.errno != errno.EEXIST: raise
def do(): """main""" sns = nuke.selectedNodes() for sn in sns: filepath = nuke.filename(sn) if filepath is not None: filepath = 'file:' + os.path.dirname(filepath) currentView = nuke.activeViewer().view() filepath = filepath.replace(r'%v', currentView[0]) filepath = filepath.replace(r'%V', currentView) print filepath openurl.start(filepath)
def pathExplorer(): ''' Open filename's path on explorer from Read or Write selected nodes ''' import os, subprocess sel = nuke.selectedNodes() for node in sel: if node.Class() == 'Read' or node.Class() == 'Write': File = nuke.filename(node) path = os.path.dirname(File) subprocess.Popen('explorer "%s"' % path.replace('/', '\\'))