def render(self, node, start, end, step): import nuke nuke.render(node, start=start, end=end, incr=step)
def Scan_for_missing_frames(): try: # node = nuke.toNode('_render') node = nuke.selectedNode() file = node.knob('file').getValue() filepath = os.path.dirname(nuke.root().name()) + os.sep + 'Prerenders' + os.sep arr = [] missing = [] i = 0 for img in os.listdir(filepath): n = int(img.split('.')[1]) # n = int(re.search(r'\d+', img).group(0)) arr.append(n) if len(arr) > 1: difference = arr[i] - arr[i-1] if difference > 1: #print(range(arr[i-1]+1, arr[i])) missing.append(range(arr[i-1]+1, arr[i])) i+=1 if len(missing) > 0: string = '' # hyphenate list... i = 1 for span in missing: if len(span) > 2: string = string + str(span[0]) + '-' + str(span[-1]) else: string = string + str(span[0]) if i < len(missing): string = string + ', ' i+=1 if nuke.ask('Found missing frames: ' + string + '\n' + 'Render these frames now?'): ranges = nuke.FrameRanges() for s in string.split(', '): fr = nuke.FrameRange(s) ranges.add(fr) if node.knob('use_limit').getValue == True: node.knob('use_limit').setValue(False) nuke.render(node, ranges) node.knob('use_limit').setValue(True) else: nuke.render(node, ranges) except: raise return nuke.message('Must have a write node selected!') # return nuke.message('Must have a write node named \'_render\' in your network!') # if type(node) == type(nuke.root()): # return nuke.message('Must have a write node selected!') # node.knob('Render').execute() # node.knob('frame_range_string').setValue(string) # tempNode = nuke.createNode('Write') # nuke.render(tempNode, ranges) return nuke.message( 'No Missing frame-ranges found!')
def main(): nodes = nuke.selectedNode("Write") for n in nodes: first = n.firstFrame() last = n.lastFrame() filename = n['file'].value() dirpath = os.path.dirname(filename) if os.path.exists(dirpath) == False: os.makedirs(dirpath) nuke.render(n.name(), first, last, 1) else: nuke.render(n.name(), first, last, 1)
def process(self, instance): import nuke context = instance.context if not all(result["success"] for result in context.data["results"]): self.log.warning("Atomicity not held, aborting.") return write = instance[0] nuke.render(write, start=instance.data["startFrame"], end=instance.data["endFrame"])
def generate(self): """Generate mov in current nuke session.""" if not host.cur_scene() == _REVIEW_MOV_EXPORT_NK: host.open_scene(_REVIEW_MOV_EXPORT_NK, force=True) for _idx, _mov in enumerate(self.input_movs): _node = nuke.toNode('Read{:d}'.format(_idx+1)) _node['file'].fromUserText(_mov.path) _last = _node['last'].value() print 'LAST', _last nuke.toNode('Write1')['file'].setValue(self.path) nuke.render('Write1', 1, _last)
def process(self, instance): '''Process *instance* and add review component to context.''' self.log.debug('Pre extracting reviewable component {0!r}'.format( instance.name)) import tempfile import nuke write = nuke.toNode(instance.name) # Get the input of the given write node. input_node = write.input(0) # Generate output file name for mov. temp_review_mov = tempfile.NamedTemporaryFile(suffix='.mov').name first = str(int(nuke.root().knob('first_frame').value())) last = str(int(nuke.root().knob('last_frame').value())) # Create a new write_node. review_node = nuke.createNode('Write') review_node.setInput(0, input_node) review_node['file'].setValue(temp_review_mov) review_node['file_type'].setValue('mov') review_node['mov64_codec'].setValue('png') # Store the temp write node for later deletion. instance.data['ftrack_tmp_review_node'] = review_node['name'].getValue( ) if write['use_limit'].getValue(): first = write['first'].getValue() last = write['last'].getValue() review_node['use_limit'].setValue(True) ranges = nuke.FrameRanges('{0}-{1}'.format(first, last)) nuke.render(review_node, ranges) instance.data['ftrack_web_reviewable_components'] = [{ 'name': 'web-reviewable', 'path': temp_review_mov }] self.log.debug('Extracted Reviewable component from {0!r}'.format( instance.name))
def generate_proxy(): proxy_status = nuke.root()['proxy'].value() nuke.root()['proxy'].setValue(False) for read in nuke.selectedNodes("Read"): path = read.knob('file').value() read.knob('file').setValue(path) match = re.findall('(.*?)(%\d+d|#+)(.*)', path) range = nuke.FrameRanges( '%s-%s' % (nuke.root().firstFrame(), nuke.root().lastFrame())) if match: splits = match[0] dir_, base = os.path.split(splits[0]) proxy_file = '/'.join([dir_, 'proxy', base]) + splits[1] + '.jpg' else: name, ext = os.path.splitext(path) dir_, base = os.path.split(name) if ext == '.mov': proxy_file = '%s/proxy/%s.#####.jpg' % (dir_, base) else: proxy_file = '%s/proxy/%s.jpg' % (dir_, base) range = nuke.FrameRanges('1') try: w = nuke.nodes.Write(file=proxy_file) w.knob('file_type').setValue('jpg') w.knob('_jpeg_quality').setValue(0.95) w.knob('beforeRender').setValue('createWriteDir()') reformat = nuke.nodes.Reformat(type=2, scale=0.5, resize=5, filter=8) reformat.setInput(0, read) w.setInput(0, reformat) nuke.render(w, range) read.knob('proxy').setValue(proxy_file) except Exception, e: print "Cancel Generating Proxy:", str(e) nuke.root()['proxy'].setValue(proxy_status) finally:
def finalRendering(): global flag for i in range(flag): if renderFirst[i] == 0 and renderLast[i] == 0: nuke.render(writeNodes[i].knob('name').value(), srcReadNodes[i].knob('first').value(), srcReadNodes[i].knob('last').value(), 1) elif srcReadNodes[i].knob('first').value( ) <= renderFirst[i] and 0 < renderLast[i] <= srcReadNodes[i].knob( 'last').value() and renderFirst[i] <= renderLast[i]: nuke.render(writeNodes[i].knob('name').value(), renderFirst[i], renderLast[i], 1) else: print 'illegal frame range' del srcReadNodes[:] #source files del mergeNodes[:] #merge nodes attached to source files del writeNodes[:] #write nodes del transformNodes[:] #transform nodes of multiple watermark flag = 0
def split(filename, output_dir, file_format=None): """Render splited files. """ path = PurePath(re.sub(r' [\d -]*$', '', filename)) output_dir = Path(output_dir) # Create read node. read_node = nuke.nodes.Read() read_node['file'].fromUserText(filename) if file_format: assert isinstance(file_format, (str, unicode)) suffix = '.{}'.format(file_format.strip('.')) else: suffix = path.suffix or '.mov' # Get layers for render. layers = nuke.layers(read_node) assert isinstance(layers, list) layers_overlap = {'rgba': ('rgb', 'alpha')} for k, v in layers_overlap.items(): if k in layers: for i in v: try: layers.remove(i) except ValueError: pass # Create write nodes. for layer in layers: _kwargs = {'in': layer} # Avoid use of python keyword 'in'. n = nuke.nodes.Shuffle(inputs=[read_node], label=layer, **_kwargs) n = nuke.nodes.Write( inputs=[n], file=((output_dir / '{}.{}{}'.format(path.stem, layer, suffix)).as_posix()), channels='rgba') # Render. output_dir.mkdir(parents=True, exist_ok=True) nuke.render(nuke.Root(), start=read_node.firstFrame(), end=read_node.lastFrame())
def writeGammaMan(): writes = nuke.all_nodes('Write') for w in writes: nuke.render(w, 1, 1, 1)
def writeGammaMan(): writes = nuke.allNodes("Write") for w in writes: nuke.render(w, 1, 1, 1)
def render(self): """Render all Write nodes - does not implement nuke.executeMultiple (yet) for stability.""" for args in self.writes: nuke.render(*args)
dissolveNode.setInput(kInputNum, readNode[kReadNode]) dissolveNode['which'].setValueAt(animationValue, animationKey) kInputNum += 1 animationValue += 1 # skip the mask input if kInputNum == 2: kInputNum = 3 # set dissolveNode animation curve to constant (step) dissolveNode.knobs()['which'].animations()[0].changeInterpolation( dissolveNode.knobs()['which'].animations()[0].keys(), nuke.CONSTANT) # create writeNode and set input to dissolve Node self.fileService.createFolders(os.path.dirname(destination)) log("destination path is %s"%destination, isInfo=True) writeJpgNode = nuke.createNode('Write') writeJpgNode['name'].setValue('saveJPG') writeJpgNode["file"].fromUserText(self.repath.localize(destination)) writeJpgNode.setInput(kInput1, dissolveNode) # setup root preferences nuke.root().knob("first_frame").setValue(1) nuke.root().knob("last_frame").setValue(lastFrame) nuke.root().knob("fps").setValue(frameRate) nuke.root().knob("format").setValue(flixFormat) # render then save the script nuke.scriptSave(scriptName) nuke.render(writeJpgNode, 1, int(lastFrame)) log('Render Complete. %s' % self.repath.localize(source['scriptName']), isInfo=True)