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)
