def customBackgroundRender():
class ShapePanel(nukescripts.PythonPanel):
def __init__(self, node):
nukescripts.PythonPanel.__init__(self, 'CustomUI')
self.rpNode = node
self.paragraph = nuke.String_Knob('paragraph', 'Paragraph',
'%s' % 5)
self.memory = nuke.String_Knob('memory', 'Memory', '%s' % 4096)
self.thread = nuke.String_Knob('thread', 'Thread', '2')
for k in (self.paragraph, self.memory, self.thread):
self.addKnob(k)
p = ShapePanel('CustomUI')
if p.showModalDialog():
x = int(p.paragraph.value())
y = p.memory.value()
z = int(p.thread.value())
a = int(nuke.root()["first_frame"].value() - 1)
b = int(nuke.root()["last_frame"].value() + 1)
c = (b - a) // x
d = range(a, b, c)
for e in range(0, x):
write = nuke.selectedNode()
wviews = write['views'].value().split(' ')
if e == x - 1:
nuke.executeBackgroundNuke(nuke.EXE_PATH, [write],
nuke.FrameRanges('%s-%s' %
(d[e] + 1, b - 1)),
wviews, {
'maxThreads': z,
'maxCache': '%sM' % y
},
continueOnError=True)
else:
nuke.executeBackgroundNuke(nuke.EXE_PATH, [write],
nuke.FrameRanges(
'%s-%s' % (d[e] + 1, d[e + 1])),
wviews, {
'maxThreads': z,
'maxCache': '%sM' % y
},
continueOnError=True)
else:
pass
def run(self):
frame_ranges = nuke.FrameRanges(
self._frameRange.value().split(','))
views = self._selectedViews()
try:
nuke.Undo().disable()
if (self.isBackgrounded()):
nuke.executeBackgroundNuke(
nuke.EXE_PATH,
self._nodeSelection,
frame_ranges,
views,
self._getBackgroundLimits(),
continueOnError=self._continueOnError.value())
elif self._termRender.value():
terminal_render(self._nodeSelection, frame_ranges, views,
self._numInstances.value(),
self._numThreads.value(),
self._maxMem.value())
else:
nuke.executeMultiple(
self._nodeSelection,
frame_ranges,
views,
continueOnError=self._continueOnError.value())
except RuntimeError, e:
if self._exceptOnError or e.args[0][
0:
9] != "Cancelled": # TO DO: change this to an exception type
raise
def run(self):
frame_ranges = nuke.FrameRanges(self._frameRange.value().split(','))
views = self._selectedViews()
rootProxyMode = nuke.root().proxy()
try:
nuke.Undo().disable()
nuke.root().setProxy(self._useProxy.value())
if (self.isBackgrounded()):
print frame_ranges
make_out(self._nodeSelection)
nuke.executeBackgroundNuke(
nuke.EXE_PATH,
self._nodeSelection,
frame_ranges,
views,
self._getBackgroundLimits(),
continueOnError=self._continueOnError.value())
else:
if (self.skipExisting()):
nuke.addBeforeFrameRender(skippy, nodeClass='Write')
else:
nuke.removeBeforeFrameRender(skippy, nodeClass='Write')
make_out(self._nodeSelection)
nuke.executeMultiple(
self._nodeSelection,
frame_ranges,
views,
continueOnError=self._continueOnError.value())
except RuntimeError, e:
if self._exceptOnError or e.args[0][
0:
9] != "Cancelled": # TO DO: change this to an exception type
raise
def run(self):
if self.isTimelineWrite() and self._frameServerRender.value():
from hiero.ui.nuke_bridge.nukestudio import scriptSaveAndReRender
scriptSaveAndReRender()
return
frame_ranges = nuke.FrameRanges(self._frameRange.value().split(','))
views = self._selectedViews()
rootProxyMode = nuke.root().proxy()
try:
nuke.Undo().disable()
nuke.root().setProxy(self._useProxy.value())
if (self.isBackgrounded()):
nuke.executeBackgroundNuke(
nuke.EXE_PATH,
self._nodeSelection,
frame_ranges,
views,
self._getBackgroundLimits(),
continueOnError=self._continueOnError.value())
else:
nuke.executeMultiple(
self._nodeSelection,
frame_ranges,
views,
continueOnError=self._continueOnError.value())
except RuntimeError, e:
if self._exceptOnError or e.args[0][
0:
9] != "Cancelled": # TO DO: change this to an exception type
raise
def from_text(cls, text):
""""Get frame ranges from text. """
try:
return cls(nuke.FrameRanges(text))
except RuntimeError:
raise ValueError
def __getRange(self):
'''get the maximum frame range from all ranges requested'''
allRanges = nuke.FrameRanges()
n = nuke.toNode(self.outputNode.value())
if (n):
allRanges.add(n.frameRange())
return '%s-%sx1' % (allRanges.minFrame(), allRanges.maxFrame())
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 wrapped(self):
"""Get frame range from wrapped object."""
obj = self._wrapped
if isinstance(obj, nuke.FrameRanges):
return obj
# Get frame_list from obj
try:
ret = nuke.FrameRanges(self._frame_list())
# Save result for some case.
except (TypeError, ValueError, NotImplementedError):
ret = nuke.FrameRanges(self.from_root().to_frame_list())
if isinstance(obj, (list, str, unicode, PurePath, nuke.FrameRanges)):
self._wrapped = ret
return ret
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 run(self):
flipbookToRun = flipbooking.gFlipbookFactory.getApplication(
self._flipbookEnum.value())
if (flipbookToRun):
if not os.access(flipbookToRun.path(), os.X_OK):
raise RuntimeError("%s cannot be executed (%s)." % (
flipbookToRun.name(),
flipbookToRun.path(),
))
nodeToFlipbook = None
rootProxyMode = nuke.root().proxy()
try:
# Need this to prevent Bug 5295
nuke.Undo().disable()
nuke.root().setProxy(self._useProxy.value())
if self._cleanup.value():
self._deleteTemporaries()
calledOnNode = self._node
if self._node.Class() == "Viewer":
self._node = self._node.input(
int(self._node.knob("input_number").value()))
runFlipbook = False
# In many cases we need to create a temporary node and render that.
if not self._requireIntermediateNode(self._node):
nodeToFlipbook = self._node
runFlipbook = True
else:
nodeToFlipbook = self._createIntermediateNode()
runFlipbook = not self._bgRender.value()
if nodeToFlipbook and runFlipbook:
# get default options and extra options needed by the selected
# Flipbook application
options = self._getOptions(nodeToFlipbook)
extraOptions = flipbookToRun.getExtraOptions(
self, nodeToFlipbook)
options.update(extraOptions)
flipbookToRun.runFromNode(
nodeToFlipbook,
nuke.FrameRanges(self._frameRange.value().split(',')),
self._selectedViews(), options)
finally:
if self._node != nodeToFlipbook:
nuke.delete(nodeToFlipbook)
nuke.root().setProxy(rootProxyMode)
nuke.Undo().enable()
else:
raise RuntimeError(
"No flipbook called " + self._flipbookEnum.value() +
" found. Was it deregistered while the dialog was open?")
def __init__(self, flipbook, frameRange, viewer, selectedViews,
defaultWritePath, customWritePath, doFlipbook, doCleanup):
self._flipbook = flipbook
self._frameRange = nuke.FrameRanges(frameRange.split(','))
self._viewer = viewer
self._selectedViews = selectedViews
self._defaultWritePath = defaultWritePath
self._customWritePath = customWritePath
self._doFlipbook = doFlipbook
self._doCleanup = doCleanup
def setUp(self):
self.temp_dir = mkdtemp()
self.addCleanup(os.removedirs, self.temp_dir)
self.test_file = os.path.join(self.temp_dir, 'test_seq.%04d.exr')
self.expected_missing_frames = nuke.FrameRanges(
sample(xrange(1, 91), 10) + list(xrange(91, 101)))
self.expected_missing_frames.compact()
# Create temp file.
path = Path(Path(self.temp_dir) / 'test_seq.%04d.exr')
for i in set(xrange(1, 91)).difference(
self.expected_missing_frames.toFrameList()):
j = Path(path.with_frame(i))
with j.open('w') as f:
f.write(unicode(i))
self.addCleanup(j.unlink)
def run(self):
frame_ranges = nuke.FrameRanges(self._frameRange.value().split(','))
views = self._selectedViews()
rootProxyMode = nuke.root().proxy()
try:
nuke.Undo().disable()
nuke.root().setProxy(self._useProxy.value())
nuke.executeMultiple(self._nodeSelection,
frame_ranges,
views,
continueOnError=self._continueOnError.value())
except RuntimeError, e:
if self._exceptOnError or e.args[0][
0:
9] != "Cancelled": # TO DO: change this to an exception type
raise
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 render_next(self):
if not self.nodes:
return
node = self.nodes[0]
del self.nodes[0] # it's taken, so remove it
f = int(node['first'].value())
l = int(node['last'].value())
ranges = nuke.FrameRanges()
ranges.add(nuke.FrameRange('%d-%d' % (f,l)))
pid = nuke.executeBackgroundNuke(self.path, [node], ranges, ['main'], {})
self.pids[pid] = node.name()
self.pids_done[pid] = False
self.pids_time[pid] = time.time()
print 'Started rendering: %s, pid: %d' % (node.name(), pid)
def _deleteTemporaries(self):
"""Delete all the files in the range to be rendered."""
temporariesPath = self._getIntermediatePath()
temporariesPath = temporariesPath.replace("%V", "%s")
for r in nuke.FrameRanges(self._frameRange.value().split(',')):
deleteRange = xrange(r.minFrame(), r.maxFrame() + 1)
for v in self._selectedViews():
for i in deleteRange:
if len(self._selectedViews()) > 1:
f = temporariesPath % (
i,
v,
)
else:
f = temporariesPath % i
if os.access(f, os.F_OK):
os.remove(f)
def getKnobRange(knob):
'''
Return a frame range object of the knob's animation range.
If the knob has no keyframes the script range is returned
args:
knob - animated knob
'''
allRanges = nuke.FrameRanges()
for anim in knob.animations():
if not anim.keys():
#KNOB ONLY HAS EXPRESSION WITHOUT KEYS SO USE SCRIPT RANGE
first = nuke.root().firstFrame()
last = nuke.root().lastFrame()
allRanges.add(nuke.FrameRange(first, last))
else:
# GET FIRST FRAME
allKeys = anim.keys()
allRanges.add(nuke.FrameRange(allKeys[0].x, allKeys[-1].x, 1))
return nuke.FrameRange(allRanges.minFrame(), allRanges.maxFrame(), 1)
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())
if self._useRoi.value():
crop = nuke.createNode("Crop", inpanel=False)
crop['box'].fromScript(self._roi.toScript())
write = nuke.createNode("Write",
fieldname + " {" + flipbooktmp + "}",
inpanel=False)
write.knob('file_type').setValue(self._getIntermediateFileType())
selectedViews = self._selectedViews()
write.knob('views').fromScript(" ".join(selectedViews))
if self._getIntermediateFileType() == "exr":
write.knob('compression').setValue("B44")
# Set the 'heroview' to be the first of the selected views. If we don't
# do this then then 'heroview' is by default set to be 1 which may not
# be a valid view for this clip. The 'heroview' is used as a fallback if
# no view has been set on the reader. This assumes the user has selected
# sensible views if they haven't then the write may still fail.
if len(selectedViews) > 0:
firstView = nuke.OutputContext().viewFromName(
selectedViews[0])
write.knob('heroview').setValue(firstView)
writeColorspace = ""
if self._burnInLUT.value():
# The user has chosen to burn the viewer transform into the intermedate render so set the colorspace
# on the Write node appropriately.
writeColorspace = self._getBurninWriteColorspace()
else:
# The viewer transform is not being burnt into the intermediate render, set the Write node's colorspace
# to whatever the current working space is - when reading the file back in the flipbook we'll ssume
# the media was written out in the working space.
rootNode = nuke.root()
if rootNode:
workingSpaceKnob = rootNode.knob("workingSpaceLUT")
if workingSpaceKnob:
writeColorspace = workingSpaceKnob.value()
if writeColorspace:
write.knob('colorspace').setValue(writeColorspace)
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], ))
def test_bool(self):
empty = nuke.FrameRanges([])
self.assertFalse(FrameRanges(empty))
self.assertFalse(FrameRanges())
self.assert_(FrameRanges.from_root())
def test_to_frame_list(self):
empty = nuke.FrameRanges([])
self.assertIs(empty.toFrameList(), None)
self.assertIsInstance(FrameRanges(empty).to_frame_list(), list)
def createNukeFile(res={}):
import nuke
from nukeCore.nodes import sequenceGroup
allWriteNode = []
for key in res.keys():
if not os.path.isdir(res[key]['outDir']):
os.makedirs(res[key]['outDir'])
seq = res[key]['seq']
task = res[key]['task']
outFile = res[key]['fileOut']
format = res[key]['fileType']
showTask = res[key]['showTask']
status = res[key]['status']
name = res[key]['name']
label = res[key]['showLabel']
version = res[key]['version']
cutOrder = res[key]['cutOrder']
artist = res[key]['artist']
outDir = res[key]['outDir']
nbShots = res[key]['nbShots']
#nbShots = len(findShotsInSequence(seq,False))
intNb = nbShots / 5
floatNb = nbShots / 5.0
if floatNb - intNb > 0:
intNb += 1
sequenceGroupNode = sequenceGroup.create()
sequenceGroupNode['sequence'].setValue(seq)
sequenceGroupNode['task'].setValue(task)
sequenceGroupNode['outputMode'].setValue('contactSheet')
sequenceGroupNode['Rebuild'].execute()
sequenceGroupNode['RowCol'].setValue([intNb, 5])
sequenceGroupNode['Resolution'].setValue([5 * 2048, intNb * 858])
sequenceGroupNode['showName'].setValue(name)
sequenceGroupNode['showStatus'].setValue(status)
sequenceGroupNode['showTask'].setValue(showTask)
sequenceGroupNode['showLabel'].setValue(label)
sequenceGroupNode['showVersion'].setValue(version)
sequenceGroupNode['showArtist'].setValue(artist)
sequenceGroupNode['showCutOrder'].setValue(cutOrder)
colorConvertNode = nuke.nodes.OCIOColorSpace(in_colorspace="Linear",
out_colorspace="Lut")
colorConvertNode.setInput(0, sequenceGroupNode)
if format == 'jpg':
writeNode = nuke.nodes.Write(name=seq + "WriteLutBurn",
colorspace="linear",
file_type="jpeg",
_jpeg_sub_sampling="4:2:2",
file=outFile)
writeNode['_jpeg_quality'].setValue(0.75)
else:
writeNode = nuke.nodes.Write(name=seq + "WriteLutBurn",
colorspace="linear",
file_type="tiff",
file=outFile)
writeNode['datatype'].setValue('16 bit')
writeNode['use_limit'].setValue(1)
writeNode.setInput(0, colorConvertNode)
allWriteNode.append(writeNode)
nuke.scriptSave(outDir + seq + '_contactSheet.nk')
# time.sleep(5)
#nuke.execute(writeNode, 1, 1,1)
masterNukeFile = '/tmp/tmpContactSheet.nk'
nuke.filename()
nuke.scriptSave(masterNukeFile)
fRange = nuke.FrameRanges('1-1')
# proc = subprocess.Popen(['rez','env','asterix2NukeBeta','--','nuke', '-x', '/tmp/tmpContactSheet.nk','1,1'], stdout=subprocess.PIPE)
# output = proc.communicate()[0]
# print output
#subprocess.call(['nuke', '-x', '/tmp/tmpContactSheet.nk','1,1'])
#os.system('nuke -x '+masterNukeFile+' 1,1')
#nuke.executeMultiple(tuple(allWriteNode), fRange, continueOnError=True)
for renderNode in allWriteNode:
nuke.execute(renderNode, 1, 1, 1)
os.remove(masterNukeFile)
for key in res.keys():
rmTmpFile = 'rm ' + res[key]['outDir'] + 'tmp* '
os.system(rmTmpFile)
print 'donuts'
def create_snapshot_fullres(snapImageFile=None,
writeUniqueName=None,
fakeFrameRange=None):
"""
Check if input process and viewer input are valid, bake LUT, write full-res image, thumbnail, chmod 0444 both
:param snapImageFile: Absolute path to .jpeg
:param writeUniqueName: name of temporarily Write node
:param fakeFrameRange: current frame X represented as "X-X"
"""
try:
initial_node = nuke.selectedNodes()[0]
if initial_node.Class() == "Viewer":
initial_node.setSelected(False)
initial_node = initial_node.dependencies()[-1]
initial_node.setSelected(True)
except IndexError:
nuke.message("Select node from which to render full-res snapshot")
raise BaseException
ip_node = nuke.activeViewer().node().knob('input_process_node').value()
viewerInput = nuke.toNode(ip_node)
viewerProcess = nuke.ViewerProcess.node()
is_ip_valid = False
is_vp_valid = False
if 'None' not in str(viewerProcess):
is_vp_valid = True
root = nuke.root()
root.begin()
newVp = nuke.createNode(
viewerProcess.Class(),
viewerProcess.writeKnobs(nuke.WRITE_NON_DEFAULT_ONLY
| nuke.TO_SCRIPT),
inpanel=False)
root.end()
tmpViewerProcess = nuke.toNode(newVp.name())
tmpViewerProcess.setInput(0, nuke.selectedNode())
initial_node.setSelected(False)
tmpViewerProcess.setSelected(True)
initial_node = nuke.selectedNodes()[0]
else:
print "\n! No valid IP attached to the Viewer, going on..."
if 'Node' in str(type(viewerInput)) or 'Gizmo' in str(type(viewerInput)):
is_ip_valid = True
newIp = copy_viewer_input(viewerInput)
tmpViewerInput = nuke.toNode(newIp.name())
tmpViewerInput.setInput(0, nuke.selectedNode())
initial_node.setSelected(False)
tmpViewerInput.setSelected(True)
else:
print "\n! No valid VI attached to the Viewer, going on..."
nuke.nodes.Colorspace(name="cspTmp89", colorspace_in="sRGB").setInput(
0, nuke.selectedNode())
csp = nuke.toNode('cspTmp89') # This name is cool enough to be hard-coded
csp.setSelected(True)
if is_ip_valid:
tmpViewerInput.setSelected(False)
if is_vp_valid:
tmpViewerProcess.setSelected(False)
finWriteTxt = "finWrite = " + '"' + \
r"import os\nfrom PIL import Image\nimgPath = nuke.thisNode()['file'].getValue()\nim = Image.open(imgPath)\nimSize = ('', 100)\nim.thumbnail(imSize, Image.ANTIALIAS)\nimgPathThumb = str(imgPath).replace('jpg', 'thumb') + '.jpg'\nim.save(imgPathThumb, 'JPEG')\nos.chmod(imgPath, 0444)\nos.chmod(imgPathThumb, 0444)" + \
'"' + r"; exec finWrite"
print "\n~ Writing screenshot: " + snapImageFile
nuke.nodes.Write(name=writeUniqueName,
file=snapImageFile,
colorspace="sRGB",
file_type="jpeg").setInput(0, nuke.selectedNode())
writeUniqueNode = nuke.toNode(writeUniqueName)
writeUniqueNode.knob('afterRender').setValue(finWriteTxt)
nuke.executeBackgroundNuke(nuke.EXE_PATH, [writeUniqueNode],
nuke.FrameRanges(fakeFrameRange), ["main"], {})
nuke.delete(writeUniqueNode)
nuke.delete(csp)
if is_ip_valid:
nuke.delete(tmpViewerInput)
if is_vp_valid:
nuke.delete(tmpViewerProcess)
def SubmitJob( dialog, root, node, writeNodes, jobsTemp, tempJobName, tempFrameList, tempDependencies, tempChunkSize, tempIsMovie, jobCount, semaphore, extraInfo ):
# global ResolutionsDict
# global FormatsDict
viewsToRender = nuke.views()
print "Preparing job #%d for submission.." % jobCount
# Getting all of the project settings environment variables
# Create a task in Nuke's progress bar dialog
#progressTask = nuke.ProgressTask("Submitting %s to Deadline" % tempJobName)
progressTask = nuke.ProgressTask("Job Submission")
progressTask.setMessage("Creating Job Info File")
progressTask.setProgress(0)
# the open method does not understand relative paths
# so we have to join it with the path of the current script
jobInfoFile = ( u"%s/nuke_submit_info%d.job" % ( os.path.join(os.path.dirname(__file__), jobsTemp ), jobCount) )
fileHandle = open( jobInfoFile, "wb" )
fileHandle.write( EncodeAsUTF16String( "Plugin=Nuke\n" ) )
fileHandle.write( EncodeAsUTF16String( "Name=%s\n" % tempJobName ) )
fileHandle.write( EncodeAsUTF16String( "UserName=%s\n" % dialog.sgUserName.value() ) )
fileHandle.write( EncodeAsUTF16String( "Comment=%s\n" % '' ) )
fileHandle.write( EncodeAsUTF16String( "Department=%s\n" % '' ) )
fileHandle.write( EncodeAsUTF16String( "Pool=%s\n" % dialog.pool.value() ) )
fileHandle.write( EncodeAsUTF16String( "SecondaryPool=%s\n" % '' ) )
fileHandle.write( EncodeAsUTF16String( "Group=%s\n" % "none" ) )
fileHandle.write( EncodeAsUTF16String( "Priority=%s\n" % 50 ) )
fileHandle.write( EncodeAsUTF16String( "MachineLimit=%s\n" % 0 ) )
fileHandle.write( EncodeAsUTF16String( "TaskTimeoutMinutes=%s\n" % 15 ) )
fileHandle.write( EncodeAsUTF16String( "EnableAutoTimeout=%s\n" % True ) )
fileHandle.write( EncodeAsUTF16String( "ConcurrentTasks=%s\n" % 1 ) )
fileHandle.write( EncodeAsUTF16String( "LimitConcurrentTasksToNumberOfCpus=%s\n" % True ) )
fileHandle.write( EncodeAsUTF16String( "LimitGroups=%s\n" % "" ) )
fileHandle.write( EncodeAsUTF16String( "JobDependencies=%s\n" % tempDependencies ) )
fileHandle.write( EncodeAsUTF16String( "OnJobComplete=%s\n" % "Nothing" ) )
fileHandle.write( EncodeAsUTF16String( "ForceReloadPlugin=%s\n" % False ) )
fileHandle.write( EncodeAsUTF16String( "Frames=%s\n" % tempFrameList ) )
fileHandle.write( EncodeAsUTF16String( "ChunkSize=%s\n" % tempChunkSize ) )
fileHandle.write( EncodeAsUTF16String( "Whitelist=%s\n" % "" ) )
fileHandle.write( EncodeAsUTF16String( "PreJobScript=%s\n" % "" ) )
# fileHandle.write( EncodeAsUTF16String( "InitialStatus=%s\n" % "Active" ) )
extraKVPIndex = 0
index = 0
for v in viewsToRender:
for tempNode in writeNodes:
if not tempNode.knob( 'disable' ).value():
enterLoop = True
if dialog.selectedOnly.value():
enterLoop = enterLoop and IsNodeOrParentNodeSelected(tempNode)
if enterLoop:
#gets the filename/proxy filename and evaluates TCL + vars, but *doesn't* swap frame padding
fileValue = nuke.filename( tempNode )
if ( root.proxy() and tempNode.knob( 'proxy' ).value() != "" ):
evaluatedValue = tempNode.knob( 'proxy' ).evaluate(view=v)
else:
evaluatedValue = tempNode.knob( 'file' ).evaluate(view=v)
if fileValue != None and fileValue != "" and evaluatedValue != None and evaluatedValue != "":
tempPath, tempFilename = os.path.split( evaluatedValue )
fileHandle.write( EncodeAsUTF16String( "OutputDirectory%s=%s\n" % ( index, tempPath ) ) )
if IsPadded( os.path.basename( fileValue ) ):
tempFilename = GetPaddedPath( tempFilename )
paddedPath = os.path.join( tempPath, tempFilename )
#Handle escape character cases
paddedPath = paddedPath.replace( "\\", "/" )
fileHandle.write( EncodeAsUTF16String( "OutputFilename%s=%s\n" % (index, paddedPath ) ) )
#Check if the Write Node will be modifying the output's Frame numbers
if tempNode.knob( 'frame_mode' ):
if ( tempNode.knob( 'frame_mode' ).value() == "offset" ):
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=OutputFrameOffset%s=%s\n" % ( extraKVPIndex, index, str( int( tempNode.knob( 'frame' ).value() ) ) ) ) )
print "->enterLoop: frame_mode: {}".format(str( int( tempNode.knob( 'frame' ).value() ) ))
extraKVPIndex += 1
elif ( tempNode.knob( 'frame_mode' ).value() == "start at" or tempNode.knob( 'frame_mode' ).value() == "start_at"):
franges = nuke.FrameRanges( tempFrameList )
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=OutputFrameOffset%s=%s\n" % ( extraKVPIndex, index, str( int( tempNode.knob( 'frame' ).value() ) - franges.minFrame() ) ) ) )
print "->enterLoop: frame_mode: {}".format( str( int( tempNode.knob( 'frame' ).value() ) - franges.minFrame() ) )
extraKVPIndex += 1
else:
#TODO: Handle 'expression'? Would be much harder
pass
index = index + 1
# Write the shotgun data.
# groupBatch = True
# Creating a new version in SG
fileHandle.write( EncodeAsUTF16String( "ExtraInfo0=%s\n" % dialog.sgTaskCombo.value() ) )
fileHandle.write( EncodeAsUTF16String( "ExtraInfo1=%s\n" % dialog.sgProjectName.value() ) )
fileHandle.write( EncodeAsUTF16String( "ExtraInfo2=%s\n" % dialog.sgEntityName.value() ) )
fileHandle.write( EncodeAsUTF16String( "ExtraInfo3=%s\n" % dialog.sgVersionName.value() ) )
fileHandle.write( EncodeAsUTF16String( "ExtraInfo4=%s\n" % dialog.sgDescription.value() ) )
fileHandle.write( EncodeAsUTF16String( "ExtraInfo5=%s\n" % dialog.sgUserName.value() ) )
# ENV KEYS
EnvKeyValueIndex = 0
fileHandle.write( EncodeAsUTF16String( "EnvironmentKeyValue%s=%s=%s\n" % (EnvKeyValueIndex, "THEBOATFOLDER",os.environ.get("THEBOATFOLDER")) ) )
EnvKeyValueIndex += 1
fileHandle.write( EncodeAsUTF16String( "EnvironmentKeyValue%s=%s=%s\n" % (EnvKeyValueIndex, "SHOT",os.environ.get("SHOT")) ) )
EnvKeyValueIndex += 1
fileHandle.write( EncodeAsUTF16String( "EnvironmentKeyValue%s=%s=%s\n" % (EnvKeyValueIndex, "NUKE_PATH",os.environ.get("NUKE_PATH")) ) )
EnvKeyValueIndex += 1
fileHandle.write( EncodeAsUTF16String( "EnvironmentKeyValue%s=%s=%s\n" % (EnvKeyValueIndex, "JOB",os.environ.get("JOB")) ) )
EnvKeyValueIndex += 1
fileHandle.write( EncodeAsUTF16String( "EnvironmentKeyValue%s=%s=%s\n" % (EnvKeyValueIndex, "TASK",os.environ.get("TASK")) ) )
EnvKeyValueIndex += 1
# GET THE JOB SPECIFIC ENVIRONMENT VARS (FROM HS)
# we make everything uppercase because in windows
# the environments keys are ALWAYS in uppercase
for key, value in os.environ.iteritems():
if key.upper().find(os.environ["JOB"].upper()) > -1:
fileHandle.write( EncodeAsUTF16String( "EnvironmentKeyValue%s=%s=%s\n" % (EnvKeyValueIndex, key,value) ) )
EnvKeyValueIndex += 1
# Draft Stuff
extraKVPIndex = 0
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=UserName=%s\n" % (extraKVPIndex, dialog.sgUserName.value() ) ) )
extraKVPIndex += 1
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=Description=%s\n" % (extraKVPIndex, dialog.sgDescription.value() ) ) )
extraKVPIndex += 1
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=ProjectName=%s\n" % (extraKVPIndex, dialog.sgProjectName.value() ) ) )
extraKVPIndex += 1
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=EntityName=%s\n" % (extraKVPIndex, dialog.sgEntityName.value() ) ) )
extraKVPIndex += 1
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=EntityType=%s\n" % (extraKVPIndex, dialog.sgEntityType.value() ) ) )
extraKVPIndex += 1
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=VersionName=%s\n" % (extraKVPIndex, dialog.sgVersionName.value() ) ) )
extraKVPIndex += 1
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=ProjectId=%s\n" % (extraKVPIndex, dialog.sgProjectId.value() ) ) )
extraKVPIndex += 1
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=TaskId=%s\n" % (extraKVPIndex, dialog.sgTaskId.value() ) ) )
extraKVPIndex += 1
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=TaskName=%s\n" % (extraKVPIndex, dialog.sgTaskCombo.value() ) ) )
extraKVPIndex += 1
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=EntityId=%s\n" % (extraKVPIndex, dialog.sgEntityId.value() ) ) )
extraKVPIndex += 1
# Instead of using the quickdraft use the template, so we can burn-in the info
draftTemplateAbsolutePath = os.path.join(os.path.dirname(__file__), 'draft/draftTemplate.py')
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=DraftTemplate=%s\n" % (extraKVPIndex, draftTemplateAbsolutePath ) ) )
extraKVPIndex += 1
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=DraftUsername=%s\n" % (extraKVPIndex, dialog.sgUserName.value() ) ) )
extraKVPIndex += 1
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=DraftEntity=%s\n" % (extraKVPIndex, dialog.sgTaskCombo.value() ) ) )
extraKVPIndex += 1
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=DraftVersion=%s\n" % (extraKVPIndex, dialog.sgVersionName.value() ) ) )
extraKVPIndex += 1
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=DraftFrameWidth=%d\n" % (extraKVPIndex, int(dialog.draftSizeCombo.value().split("x")[0]) ) ) )
extraKVPIndex += 1
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=DraftFrameHeight=%d\n" % (extraKVPIndex, int(dialog.draftSizeCombo.value().split("x")[1]) ) ) )
extraKVPIndex += 1
DraftExtraArgs = (''' projectRatio="%s" ''' % ( dialog.projectSettings.get( uppercaseIfWindows("projectionAspectRatio") ) ) ) # should be in the project conf ini
DraftExtraArgs += (''' projectFramerate="%s" ''' % ( dialog.projectSettings.get( uppercaseIfWindows("fps") ) ) ) # should be in the project conf ini
DraftExtraArgs += (''' projectCodec="%s" ''' % (dialog.draftCodecCombo.value().replace(" ", "%20")) )
DraftExtraArgs += (''' projectAppendSlate="%s" ''' % (dialog.draftAppendSlate.value()) )
DraftExtraArgs += (''' projectBurnInInfo="%s" ''' % (dialog.draftBurnInInfo.value()) )
DraftExtraArgs += (''' projectBurnInMask="%s" ''' % (dialog.draftBurnInMask.value()) )
DraftExtraArgs += (''' projectName="%s" ''' % (dialog.sgProjectName.value().replace(" ", "%20")) )
DraftExtraArgs += (''' projectDesc="%s" ''' % (dialog.sgDescription.value().replace(" ", "%20")) )
DraftExtraArgs += (''' projectLut="%s" ''' % ( dialog.projectSettings.get( uppercaseIfWindows("defaultLut") ) ) )
DraftExtraArgs += (''' projectOCIOPath="%s" ''' % ( replacePlaceholdersInPaths(dialog.projectSettings.get( uppercaseIfWindows("defaultOCIOPath") )) ) )
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=DraftExtraArgs=%s\n" % (extraKVPIndex, DraftExtraArgs ) ) )
extraKVPIndex += 1
# This line renders a mov for shotgun using the Draft_CreateShotgunMovie.py from the repo
# fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%s=Draft_CreateSGMovie=True\n" % extraKVPIndex ) )
# extraKVPIndex += 1
# This line renders a filmstrip for shotgun
# fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%s=Draft_CreateSGFilmstrip=True\n" % extraKVPIndex ) )
# extraKVPIndex += 1
# This line uploads the movie to shotgun
fileHandle.write( EncodeAsUTF16String( "ExtraInfoKeyValue%d=DraftUploadToShotgun=%s\n" % (extraKVPIndex, True ) ) )
extraKVPIndex += 1
# fileHandle.write( EncodeAsUTF16String( "BatchName=%s\n" % dialog.jobName.value() ) )
fileHandle.close()
# Update task progress
progressTask.setMessage("Creating Plugin Info File")
progressTask.setProgress(10)
# Create the plugin info file
# the open method does not understand relative paths
# so we have to join it with the path of the current script
pluginInfoFile = (u"%s/nuke_plugin_info%d.job" % (os.path.join(os.path.dirname(__file__), jobsTemp), jobCount))
fileHandle = open( pluginInfoFile, "w" )
fileHandle.write( EncodeAsUTF16String( "Version=%s.%s\n" % (nuke.env[ 'NukeVersionMajor' ], nuke.env['NukeVersionMinor']) ) )
fileHandle.write( EncodeAsUTF16String( "Threads=%s\n" % 0 ) )
fileHandle.write( EncodeAsUTF16String( "RamUse=%s\n" % 0 ) )
# fileHandle.write( EncodeAsUTF16String( "BatchMode=%s\n" % True ) )
# fileHandle.write( EncodeAsUTF16String( "BatchModeIsMovie=%s\n" % tempIsMovie ) )
if dialog.selectedOnly.value():
writeNodesStr = ""
for tempNode in writeNodes:
if not tempNode.knob( 'disable' ).value():
enterLoop = True
if dialog.selectedOnly.value():
enterLoop = enterLoop and IsNodeOrParentNodeSelected(tempNode)
if enterLoop:
#we need the fullName of the node here, otherwise write nodes that are embedded in groups won't work
writeNodesStr += ("%s," % tempNode.fullName())
writeNodesStr = writeNodesStr.strip( "," )
fileHandle.write( EncodeAsUTF16String( "WriteNode=%s\n" % writeNodesStr ) )
fileHandle.write( EncodeAsUTF16String( "NukeX=%s\n" % True ) )
fileHandle.write( EncodeAsUTF16String( "UseGpu=%s\n" % False ) )
fileHandle.write( EncodeAsUTF16String( "RenderMode=%s\n" % "Use Scene Settings" ) )
fileHandle.write( EncodeAsUTF16String( "EnforceRenderOrder=%s\n" % False ) )
fileHandle.write( EncodeAsUTF16String( "ContinueOnError=%s\n" % False ) )
fileHandle.write( EncodeAsUTF16String( "PerformanceProfiler=%s\n" % False ) )
fileHandle.write( EncodeAsUTF16String( "PerformanceProfilerDir=%s\n" % "" ) )
fileHandle.write( EncodeAsUTF16String( "Views=%s\n" % "" ) )
fileHandle.write( EncodeAsUTF16String( "StackSize=%s\n" % 0 ) )
fileHandle.close()
# Update task progress
progressTask.setMessage("Submitting Job %d to Deadline" % jobCount)
progressTask.setProgress(30)
# Submit the job to Deadline
args = []
args.append( jobInfoFile.encode(locale.getpreferredencoding() ) )
args.append( pluginInfoFile.encode(locale.getpreferredencoding() ) )
args.append( root.name() ) # SUBMIT NK
# args.append( (os.path.join(os.path.dirname(__file__), "draft/slateBackground.dpx") ) ) # SUBMIT SLATE FRAME
tempResults = ""
# Submit Job
progressTask.setProgress(50)
# If submitting multiple jobs, acquire the semaphore so that only one job is submitted at a time.
if semaphore:
semaphore.acquire()
try:
tempResults = CallDeadlineCommand( args )
finally:
# Release the semaphore if necessary.
if semaphore:
semaphore.release()
# Update task progress
progressTask.setMessage("Complete!")
progressTask.setProgress(100)
print "Job submission #%d complete" % jobCount
# If submitting multiple jobs, just print the results to the console, otherwise show them to the user.
if semaphore:
print tempResults
else:
nuke.executeInMainThread( nuke.message, tempResults )
return tempResults
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], ))
start = int(nuke.numvalue("root.first_frame"))
end = int(nuke.numvalue("root.last_frame"))
incr = 1
if start < 1:
nuke.message("Start frame number cannot be less than 1")
return
try:
_range = str(nuke.FrameRange(start, end, incr))
except ValueError,e:
# In this case we have to extract from the error message the
# correct frame range format string representation.
# I'm expecting to have an error like: "Frame Range invalid (-1722942,-1722942)"
msg = e. __str__()
_range = msg[msg.index("(")+1: msg.index(")")]
r = nuke.getInput("Frames to render:", _range)
if r is not None:
frame_ranges = nuke.FrameRanges(r)
if nuke.thisNode()['slate'].value() is True:
frame_ranges.add(nuke.FrameRange(start - 1, start - 1, 1))
frame_ranges.compact()
nuke.tprint(frame_ranges)
try:
nuke.executeMultiple(_list, frame_ranges)
except RuntimeError, e:
if exceptOnError or e.message[0:9] != "Cancelled": # TO DO: change this to an exception type
raise
file=outFile)
writeNode['_jpeg_quality'].setValue(0.75)
elif format == 'tif':
writeNode = nuke.nodes.Write(name=seq + "WriteLutBurn",
colorspace="linear",
file_type="tiff",
file=outFile)
writeNode['datatype'].setValue('16 bit')
else:
writeNode = nuke.nodes.Write(name=seq + "WriteLutBurn",
colorspace="linear",
file_type="exr",
file=outFile)
writeNode['use_limit'].setValue(1)
if format != 'exr':
colorConvertNode = nuke.nodes.OCIOColorSpace(in_colorspace="Linear",
out_colorspace="Lut")
colorConvertNode.setInput(0, sequenceGroupNode)
writeNode.setInput(0, colorConvertNode)
else:
writeNode.setInput(0, sequenceGroupNode)
writeNode['views'].setValue('left')
allWriteNode.append(writeNode)
nuke.scriptSave(outDir + seq + '_contactSheet.nk')
masterNukeFile = '/tmp/tmpContactSheet.nk'
nuke.scriptSave(masterNukeFile)
fRange = nuke.FrameRanges('1-1')
nuke.executeMultiple(tuple(allWriteNode), fRange, ['left'])
os.remove(masterNukeFile)
