sceneControl. Fixed issue if element is not set.

sceneControl. Improved debugging.
sceneControl. Deletion now also deletes Kenv
sceneControl. Write Nodes get a new label with the used exr compression type.
sceneControl. Fixed issue when unloading plugin
sceneControl. Simplified kenv queries
sceneControl. updateWriteNodeConfig() for updating the Keller tab on write nodes
ffmpeg_write. Initial version. NNode with correct names and burn-ins
our_write. Write nodes now have a compression label and a custom color to see which exr compression type is set.
added search and replace panel.
Denoise with noice. Initial version.
ocio config, image formats, fps and favorites are now set from KEnv project_config.py.

fixed missing folders and files, added nuke.bat

Nuke12.2v5_GEN.bat

@@ -0,0 +1,60 @@
+@echo off
+
+:SHARED_LIBS
+set KELLER_PY_DISABLE=bcrypt;boto3;botocore;cffi;cryptography;deadline;deepdiff;ExecortexAlembic;FileMaker;getmac;jmespath;jsonpaht_rw;jsonpickle;lxml;Muster;Muster8;nacl;OpenGL;paramiko;ply;psutil;pycparser;s3transfer;scandir;shotgun_api3;tqdm;vrml;win32;ws3build
+
+:NUKE_VARIABLES
+set NUKE_VER=12.2v5
+set NUKE_MAJOR=12
+set NUKE_MINOR=2
+set NUKE_INSTALL_PATH=C:\Program Files\Nuke%NUKE_VER%
+
+:USER
+set USER=ms
+set NUKE_TEMP_DIR=E:\_CACHE\NUKE
+set RV=c:\mrtn\tools\RV\_versions\_current\bin\
+:/USER
+
+:INACTIVE
+rem set LENSMODEL_PATH=%NUKE_PATH%\3delens\
+
+:WORKGROUP
+set NUKE_PATH=\\hades\p\env\nuke\_workgroup\%NUKE_MAJOR%.%NUKE_MINOR%\
+set NUKE_PLUGINS=%NUKE_PATH%
+set OFX_PLUGIN_PATH=%NUKE_PATH%\ofx
+
+:DEV MODE
+set DEV=0
+
+:JOB SPECIFIC:
+set JOB=GEN
+set PROJECT=%JOB%
+set PROJECT_ROOT_3D=\\hades\p\_projekte\%JOB%
+set PROJECT_ROOT_2D=\\calculon\o\_projekte\%JOB%
+set FTRACK_API_PYTHONPATH=%PROJECT_ROOT_3D%\000_env\python\keller-ftrack-connect
+
+REM if %DEV%==1 (set NUKE_PATH=%JOB%\000_dev\nuke\) else (set NUKE_PATH=%JOB%\000_env\nuke\)
+
+:LICENSE
+set foundry_LICENSE=4101@192.168.10.25;49172@192.168.10.205;5053@192.168.0.223
+set peregrinel_LICENSE=5053@192.168.0.223
+set keller_LICENSE=5053@192.168.0.223
+
+:START
+title Nuke %NUKE_VER% Console
+echo ###################################################################################################
+echo
+echo Starting Nuke %NUKE_VER% ...
+echo StartPath: %NUKE_INSTALL_PATH%
+echo Workgroup: %NUKE_PATH%
+echo Devmode: %DEV%
+echo Project_Root_2D: %PROJECT_ROOT_2D%
+echo Project_Root_3D: %PROJECT_ROOT_3D%
+echo Job / Project: %PROJECT%
+echo User: %USER%
+echo User Temp Dir: %NUKE_TEMP_DIR%
+echo User RV Install Path: %RV%
+echo Ftrack Api Python Path: %FTRACK_API_PYTHONPATH%
+echo
+echo ###################################################################################################
+"%NUKE_INSTALL_PATH%\nuke12.2.exe" -V --disable-nuke-frameserver %*

doc/channelSelect.jpg (Stored with Git LFS)

+oid sha256:9ccbaf70b4036c7adc4a4cf7177373fb79ba987d9eb22062726c6be7bc324676
+size 63434

doc/ffmpegWrite.jpg (Stored with Git LFS)

+oid sha256:93723d8341cd2767e274f7f8b2970a2cfb376279c7a2bc27560064570fb53181
+size 77334

doc/musterSubmit2.jpg (Stored with Git LFS)

+oid sha256:1d060f8c94096395673d08a4b2aad066a35d444661544515610831f09d162a18
+size 35092

doc/nukeNoice.jpg (Stored with Git LFS)

+oid sha256:9fd1c309167c679cc2ac5ee01daca76f4e738fa21257f5c0962ea74d038f95f9
+size 132493

doc/ourWrite.jpg (Stored with Git LFS)

+oid sha256:f433699a3cbd4fbb23098a7ab916d3584aec01e6864b4bc085c08cd8e16a5279
+size 49438

doc/sceneControl.jpg (Stored with Git LFS)

+oid sha256:ee1187d72b6ab8cbbf5aa10da17919dffc3e958e40fe8d4ddd825b5ce07d7991
+size 73740

doc/sceneControl_m0.jpg (Stored with Git LFS)

+oid sha256:35ccb42fba3ae1c4c7989ac3bc07a788c4cdf51bb74b84566885035c7557fb55
+size 21393

doc/sceneControl_m1.jpg (Stored with Git LFS)

+oid sha256:072d6d461ca66cf1b104b1c390f5ef7493c721ca425f9ac3d730caea8ec4389a
+size 22804

doc/sceneControl_m2.jpg (Stored with Git LFS)

+oid sha256:389131bc6ea21ef6c265fc8e31c8c5d2235aab320d31a1a9ae5eb4422b5b2a7d
+size 18077

gimmicks/Gimmicks/_KF/KF_Handles.gimmick

@@ -0,0 +1,71 @@
+set cut_paste_input [stack 0]
+version 10.5 v3
+push $cut_paste_input
+Group {
+name KF_Handles1
+selected true
+xpos -198
+ypos 523
+addUserKnob {20 User}
+addUserKnob {3 Handles}
+Handles 24
+}
+Input {
+inputs 0
+name Input1
+xpos -476
+ypos 213
+}
+set N3b3f800 [stack 0]
+push $N3b3f800
+Text2 {
+font_size_toolbar 100
+font_width_toolbar 100
+font_height_toolbar 100
+cliptype none
+message Handles
+old_message {{72 97 110 100 108 101 115}
+  }
+box {{width/2} 100 {width/2} 10}
+xjustify center
+yjustify center
+transforms {{0 2}
+  }
+font_size_values {{0 100 1 100 2 100 3 100 4 100 5 100 6 100 0 25 1 25 2 25 3 25 4 25 5 25 6 25}
+  }
+scale {1 1}
+center {1024 778}
+cursor_initialised true
+autofit_bbox false
+initial_cursor_position {{756 102.5}
+  }
+group_animations {{0} imported: 0 selected: 0 items: "root transform/"}
+animation_layers {{1 11 1024 778 0 0 1 1 0 0 0 0}
+  }
+name Text1
+xpos -405
+ypos 271
+}
+set N9d5fc800 [stack 0]
+Switch {
+inputs 2
+which {{frame>root.first_frame+(parent.Handles-1)?frame<root.last_frame-(parent.Handles-1)?1:0:0}}
+name Switch1
+xpos -476
+ypos 325
+}
+Output {
+name Output1
+xpos -476
+ypos 377
+}
+push $N9d5fc800
+Viewer {
+frame_range 1001-1101
+name Viewer1
+xpos -291
+ypos 384
+}
+end_group
+# Creation Time=Thu Jun 07 17:42:55 2018
+# Creator=ne

gimmicks/Templates/_KF/KF_Bokeh.gimmick

@@ -0,0 +1,84 @@
+set cut_paste_input [stack 0]
+version 10.5 v3
+BackdropNode {
+ inputs 0
+ name BackdropNode1
+ tile_color 0x388e8e00
+ note_font_size 42
+ selected true
+ xpos -224
+ ypos -68
+ bdwidth 269
+ bdheight 196
+}
+push $cut_paste_input
+Dot {
+ name IMAGE_INPUT
+ label IMAGE_INPUT
+ note_font Verdana
+ note_font_size 15
+ note_font_color 0xffffffff
+ selected true
+ xpos -180
+ ypos -129
+}
+Copy {
+ from0 rgba.red
+ to0 depth.Z
+ name Copy1
+ selected true
+ xpos -214
+ ypos 10
+}
+pgBokeh {
+ focalPlane {{LensMetaData.LensFocus+LensMetaData.FocusOffset}}
+ realWorldLens true
+ focalLength {{LensMetaData.LensFocalLength}}
+ fStop {{LensMetaData.LensIris+LensMetaData.IrisOffset}}
+ worldScale m
+ filmFormat Custom
+ apertureWidth 54.12
+ apertureHeight 25.58
+ name pgBokeh1
+ selected true
+ xpos -214
+ ypos 96
+}
+Dot {
+ name IMAGE_OUTPUT
+ label IMAGE_OUTPUT
+ note_font Verdana
+ note_font_size 15
+ note_font_color 0xffffffff
+ selected true
+ xpos -180
+ ypos 175
+}
+Dot {
+ inputs 0
+ name METADATA_INPUT
+ label METADATA_INPUT
+ note_font Verdana
+ note_font_size 15
+ note_font_color 0xffffffff
+ selected true
+ xpos 23
+ ypos -91
+}
+Dot {
+ name LensMetaData
+ selected true
+ xpos 23
+ ypos 101
+ addUserKnob {20 User}
+ addUserKnob {7 LensFocalLength l "Lens Focal Length"}
+ LensFocalLength {{"\[metadata \"ext/Lens Focal Length\"]"}}
+ addUserKnob {7 LensFocus l "Lens Focus Distance"}
+ LensFocus {{"\[metadata \"ext/Lens Focus Distance\"]"}}
+ addUserKnob {7 LensIris l "Lens Iris"}
+ LensIris {{"\[metadata \"ext/Lens Iris\"]"}}
+ addUserKnob {7 FocusOffset l "Lens Focus Distance Offset"}
+ addUserKnob {7 IrisOffset l "Lens Iris Offset"}
+}
+# Creation Time=Mon Jun 11 15:40:27 2018
+# Creator=ne

gimmicks/Templates/_KF/KF_Thumbnails_first.gimmick

@@ -0,0 +1,51 @@
+set cut_paste_input [stack 0]
+version 10.5 v3
+BackdropNode {
+ inputs 0
+ name BackdropNode1
+ tile_color 0x999999ff
+ gl_color 0x999999ff
+ label "first_frame\n"
+ note_font_size 15
+ selected true
+ xpos -181
+ ypos -131
+ bdheight 200
+}
+push $cut_paste_input
+Reformat {
+ type "to box"
+ box_width 500
+ name Reformat1
+ selected true
+ xpos -171
+ ypos -51
+}
+Vectorfield {
+ vfield_file O:/LUTs/K1S1_3D_Neutral.cube
+ version 3
+ file_type cube
+ colorspaceIn AlexaV3LogC
+ name Vectorfield1
+ selected true
+ xpos -171
+ ypos -25
+}
+Write {
+ channels rgba
+ file "//calculon/o/_projekte/KalteFuesse/000_A_TrelloThumbs/\[file tail \[lrange \[split \[file rootname \[value root.name]] ] 0 1]].####.jpg"
+ raw true
+ file_type jpeg
+ first {{root.first_frame}}
+ last {{root.first_frame}}
+ use_limit true
+ checkHashOnRead false
+ version 1
+ beforeRender createWriteDir.createWriteDir()
+ name Write1
+ selected true
+ xpos -171
+ ypos 11
+}
+# Creation Time=Tue Jun 05 18:16:39 2018
+# Creator=ne

gimmicks/Templates/_KF/KF_Thumbnails_last.gimmick

@@ -0,0 +1,51 @@
+set cut_paste_input [stack 0]
+version 10.5 v3
+BackdropNode {
+ inputs 0
+ name BackdropNode3
+ tile_color 0x999999ff
+ gl_color 0x999999ff
+ label "last frame\n"
+ note_font_size 15
+ selected true
+ xpos 147
+ ypos -134
+ bdheight 202
+}
+push $cut_paste_input
+Reformat {
+ type "to box"
+ box_width 500
+ name Reformat3
+ selected true
+ xpos 157
+ ypos -54
+}
+Vectorfield {
+ vfield_file O:/LUTs/K1S1_3D_Neutral.cube
+ version 4
+ file_type cube
+ colorspaceIn AlexaV3LogC
+ name Vectorfield3
+ selected true
+ xpos 157
+ ypos -28
+}
+Write {
+ channels rgba
+ file "//calculon/o/_projekte/KalteFuesse/000_A_TrelloThumbs/\[file tail \[lrange \[split \[file rootname \[value root.name]] ] 0 1]].####.jpg"
+ raw true
+ file_type jpeg
+ first {{root.last_frame}}
+ last {{root.last_frame}}
+ use_limit true
+ checkHashOnRead false
+ version 1
+ beforeRender createWriteDir.createWriteDir()
+ name Write3
+ selected true
+ xpos 157
+ ypos 11
+}
+# Creation Time=Tue Jun 05 18:17:13 2018
+# Creator=ne

gimmicks/Templates/_KF/KF_Thumbnails_middle.gimmick

@@ -0,0 +1,51 @@
+set cut_paste_input [stack 0]
+version 10.5 v3
+BackdropNode {
+ inputs 0
+ name BackdropNode2
+ tile_color 0x999999ff
+ gl_color 0x999999ff
+ label "mid_frame\n"
+ note_font_size 15
+ selected true
+ xpos -22
+ ypos -132
+ bdheight 198
+}
+push $cut_paste_input
+Reformat {
+ type "to box"
+ box_width 500
+ name Reformat2
+ selected true
+ xpos -12
+ ypos -52
+}
+Vectorfield {
+ vfield_file O:/LUTs/K1S1_3D_Neutral.cube
+ version 4
+ file_type cube
+ colorspaceIn AlexaV3LogC
+ name Vectorfield2
+ selected true
+ xpos -12
+ ypos -26
+}
+Write {
+ channels rgba
+ file "//calculon/o/_projekte/KalteFuesse/000_A_TrelloThumbs/\[file tail \[lrange \[split \[file rootname \[value root.name]] ] 0 1]].####.jpg"
+ raw true
+ file_type jpeg
+ first {{int((root.first_frame+root.last_frame)/2)}}
+ last {{int((root.first_frame+root.last_frame)/2)}}
+ use_limit true
+ checkHashOnRead false
+ version 1
+ beforeRender createWriteDir.createWriteDir()
+ name Write2
+ selected true
+ xpos -12
+ ypos 10
+}
+# Creation Time=Tue Jun 05 18:17:00 2018
+# Creator=ne

pythonpluginsUI/SearchReplacePanel/SearchReplacePanel.py

@@ -0,0 +1,184 @@
+from xml.etree import ElementTree
+import nuke
+import nukescripts
+import os
+import re
+
+class SearchReplacePanel( nukescripts.PythonPanel ):
+    def __init__( self, historyFile='~/.nuke/srhistory.xml', maxSteps=10 ):
+        '''
+        Search and Replace panel
+        args:
+           historyFile  -  file to manage recent search&replace actions
+           maxSteps  -  amount of steps to keep in history file
+        '''
+        nukescripts.PythonPanel.__init__( self, 'Search and Replace', 'com.ohufx.SearchReplace')
+
+        # VARS
+        self.historyFile = os.path.expandvars( os.path.expanduser( historyFile ) )
+        self.maxSteps = maxSteps
+        self.delimiter = ' |>>| '
+        # CREATE KNOBS
+        self.nodesChoice = nuke.Enumeration_Knob( 'nodes', 'Source Nodes', ['all', 'selected'])
+        self.nodesChoice.setTooltip( 'Chose to perform action on all nodes with file knobs or only selected ones' )
+        self.history = nuke.Enumeration_Knob( 'history', 'Recent Searches', self.loadHistory() )
+        self.history.setTooltip( 'Use the history to quicky access previous search&replace actions.\n By default the history file is stored as "~/.nuke/srhistory.xml" but this can be changed via the "historyFile" argument when creating the panel object. It is also possible to change the size of the history via the "maxSteps" argument to the panel object. Default is 10' )
+        self.case = nuke.Boolean_Knob( 'case', 'case sensitive' )
+        self.case.setFlag( nuke.STARTLINE )
+        self.case.setValue( True )
+        self.case.setTooltip( 'Set whether or not the search should be case sensitive' )
+        self.searchStr = nuke.String_Knob('searchStr', 'Search for:')
+        self.searchStr.setTooltip( 'The text to search for' )
+        self.update = nuke.PyScript_Knob('update', 'Update')
+        self.update.setTooltip( 'update the search result and preview. This is automaticaly performed and usually should only be required when the node selection has canged' )
+        self.replaceStr = nuke.String_Knob('replaceStr', 'Replace with:')
+        self.replaceStr.setTooltip( 'Text to replace the found text with' )
+        self.replace = nuke.PyScript_Knob('replace', 'Replace')
+        self.replace.setTooltip( 'Perform replace action. The preview will update afterwards and the action is added to the history' )
+        self.info = nuke.Multiline_Eval_String_Knob('info', 'Found')
+        self.info.setEnabled( False )
+        self.info.setTooltip( 'See the search results and a preview of the replace action before it is performed' )
+        # ADD KNOBS
+        for k in ( self.nodesChoice, self.history, self.case, self.searchStr, self.update, self.replaceStr, self.replace, self.info):
+            self.addKnob( k )
+        self.matches = None
+
+    def loadHistory( self ):
+        '''load history file to update knob'''
+        print("loading search&replace history")
+        # GET EXISTING HISTORY
+        if not os.path.isfile( self.historyFile ):
+            return []
+        # READ EXISTING FILE
+        xmlTree = ElementTree.parse( self.historyFile )
+        itemList = ['%s%s%s' % ( n.attrib['search'], self.delimiter, n.attrib['replace'] ) for n in xmlTree.findall( 'ITEM' )][-self.maxSteps:]
+        itemList.reverse()
+        itemList.insert( 0, '-- select --' )
+        return itemList
+    
+    def updateHistory( self, sString, rString ):
+        '''
+        updates history file
+        args:
+           sString  -  search string to add to history
+           rString  -  replace string to add to history
+        TODO  -  IMPLEMENT MAX VALUE
+        '''
+        itemList = []
+        # READ EXISTING FILE
+        if os.path.isfile( self.historyFile ):
+            xmlTree = ElementTree.parse( self.historyFile )
+            for n in xmlTree.findall( 'ITEM' ):
+                attr = n.attrib
+                itemList.append( attr )
+       
+        # IGNORE ATTRIBUTES THAT ARE ALREADY IN HISTORY
+        entryExists = False
+        for i in itemList:
+            if i['search'] == sString and i['replace']==rString:
+                entryExists = True
+                break
+
+        # IF ATTRIBUTES DONT EXIST IN HISTORY, ADD THEM
+        if not entryExists:
+            # PREP DICTIONARY FOR XML DUMP
+            srItem = dict(search=sString, replace=rString )
+            itemList.append( srItem )
+            # BUILD XML TREE
+            root = ElementTree.Element( 'SearchReplacePanel')
+            for i in itemList[-self.maxSteps:]:
+                ElementTree.SubElement( root, 'ITEM', attrib=i )
+            tree = ElementTree.ElementTree( root )
+            # DUMP XML TREE
+            print("WRITING TO:", self.historyFile)
+            tree.write( self.historyFile )
+
+    def search( self, searchstr, nodes ):
+        """ Search in nodes with file knobs. """
+        fileKnobNodes = [i for i in nodes if self.__NodeHasKnobWithName(i, 'file')]
+        proxyKnobNodes = [i for i in nodes if self.__NodeHasKnobWithName(i, 'proxy')]
+        if not fileKnobNodes and not proxyKnobNodes: raise ValueError("No file nodes selected")
+        nodeMatches = []
+        knobMatches = []
+        for i in fileKnobNodes:
+            if self.__findNode(searchstr, i['file'] ):
+                nodeMatches.append( i )
+                knobMatches.append( i['file'] )            
+        for i in proxyKnobNodes:
+            if self.__findNode(searchstr, i['proxy'] ):
+                nodeMatches.append( i )
+                knobMatches.append( i['proxy'] )
+        return nodeMatches, knobMatches        
+        
+    def getSearchResults( self, nodes ):
+        # PERFORM SEARCH AND UPDATE INFO KNOB
+        nodeMatches, knobMatches = self.search( self.searchStr.value(), nodes )
+        nodes = [n.name() for n in nodeMatches]
+        infoStr1 = '%s node(s) found:\n\t%s' % ( len(nodes), ', '.join( nodes ) )
+        infoStr2 = ''
+        for k in knobMatches:
+            newStr = nukescripts.replaceHashes( self.__doReplace( k ) )
+            # CHECK IF PATH IS VALID FOR CURRENT FRAME
+            curFrame = int( nuke.Root()['frame'].value() ) # there is a bug which prevents nuke.frame() to work properly inside of python panels (6.3v5)
+            try:
+                curPath = newStr % curFrame
+            except:
+                curPath = newStr
+            exists = {True:'  VALID PATH AT FRAME %s' % curFrame, False:'  !!! PATH IS INVALID AT CURRENT FRAME (%s)!!!' % curFrame}[os.path.exists( curPath )]
+            # BUILD INFO STRING
+            infoStr2 += '%s.%s:\n\tbefore\t%s\n\tafter\t%s  %s\n' % ( k.node().name(), k.name(), k.value(), newStr, exists )
+        self.info.setValue( '\n'.join( [infoStr1, infoStr2] ) )
+        return knobMatches
+
+    def __NodeHasKnobWithName( self, node, name):
+        try:
+            node[name]
+        except NameError:
+            return False
+        return True
+    
+    def __findNode( self, searchstr, knob ):
+        v = knob.value()
+        if not self.case.value():
+            v = v.lower()
+            searchstr = searchstr.lower()
+        if v and searchstr and searchstr in v:
+            return True    
+    
+    def __doSearch( self ):
+        # LAUNCH SEARCH
+        srcNodes = { 'all': nuke.allNodes(), 'selected': nuke.selectedNodes() }
+        self.matches = self.getSearchResults( srcNodes[self.nodesChoice.value()] )
+
+    def __doReplace( self, knob ):
+        # PERFORM REPLACE
+        if self.case.value():
+            # CASE SENSITIVE
+            newStr = re.sub( self.searchStr.value(), self.replaceStr.value(), knob.value() )
+        else:
+            # IGNORE CASE
+            newStr = knob.value()
+            for m in re.findall( self.searchStr.value(), knob.value(), re.IGNORECASE ):
+                newStr = re.sub( m, self.replaceStr.value(), newStr )
+
+        return newStr
+
+    def knobChanged( self, knob ):
+        if knob in ( self.searchStr, self.replaceStr, self.update, self.nodesChoice, self.case ):
+            # PERFORM SEARCH
+            self.__doSearch()
+        elif knob is self.replace and self.matches is not None:
+            # PERFORM REPLACE AND UPDATE HISTORY
+            print("replacing")
+            for k in self.matches:
+                k.setValue( self.__doReplace( k ) )
+
+            self.updateHistory( self.searchStr.value(), self.replaceStr.value() )
+            self.history.setValues( self.loadHistory() )
+            self.history.setValue( 0 )
+            self.__doSearch()
+        elif knob is self.history:
+            search, replace = knob.value().split( self.delimiter )
+            self.searchStr.setValue( search )
+            self.replaceStr.setValue( replace )
+            self.__doSearch()

pythonpluginsUI/denoice/denoice.py

@@ -0,0 +1,414 @@
+import os
+import nuke
+import nukescripts
+import re
+import subprocess
+import tempfile
+
+# martin@keller.io
+# numpy install:
+# https://jurajtomori.wordpress.com/2018/11/28/nuke-tip-installing-numpy-for-nuke-python-on-windows/
+
+'''noice 6.2.1.0 [359aaa66] - the Arnold denoiser
+Usage:  noice [options] ...
+  -i,    --input %s           Input image, multiple images can be included for stability, only first input image will be denoised
+  -ef,   --extraframes %d     Number of frames to pad before and after for temporal stability (0 - 2, default:0)
+  -f,    --frames %d          Number of frames to denoise in the sequence (default:1)
+  -fe,   --feature %s         Use this AOV as a denoising feature
+  -pr,   --patchradius %d     Neighborhood patch radius, size of pixel neighborhood to compare (0 - 6, default:3)
+  -sr,   --searchradius %d    Search radius, higher values mean a wider search for similar pixel neighborhoods (6 - 21, default:9)
+  -v,    --variance %f        Variance threshold, higher values mean more aggressive denoising (0.0 - 1.0, default:0.25)
+  -l,    --aov %s             Light AOV name to be co-denoised, multiple can be specified
+  -o,    --output %s          Output image
+  -t,    --threads %d         Number of threads (0: use all cores, negative numbers specify number of idle cores)
+  -irgba,--ignore_rgba        Ignore RGBA layer: will not denoise it or copy it to output file
+  -n,    --notices            Print copyright notices'''
+
+class denoice(KellerNukePlugin):
+
+    def configurePlugin(self):
+        menubar = nuke.menu("Nuke")
+        self.m = menubar.addMenu("&Render")
+        self.m.addCommand('Denoise with Noice', 'import denoice; denoice.addPanel()')
+
+
+    def unconfigurePlugin(self):
+        self.m.removeItem("Denoise with Noice")
+
+
+
+#######################################################################################
+#
+# GLOBALS
+#
+#######################################################################################
+DISABLE_AOVS = ['default', 'variance', 'Matte', 'matte', 'Crypto', 'crypto', 'denoise_albedo']
+# Muster
+MSTRSERVER = "192.168.0.251"
+SUBMISSION_USER ="admin"
+PASSWORD = ""
+MRTOOL = "\\\\hades\\p\\env\\muster9\\Mrtool.exe"
+USERNAME = "admin"
+TEMPLATE = "2008"
+MUSTERFOLDER = "34758"
+POOL = "arnold_16thread"
+PSIZE = 1
+PRIO = 10
+
+
+def find_node_layers(node):
+    node_channels = node.channels()
+    store_layers = []
+    for channel in node_channels:
+        cut = channel.split(".")
+        last = cut[0]
+        store_layers.append(last)
+    node_layers = list(set(store_layers))
+    node_layers.sort()
+
+    # put on top if rgb in layers
+    if 'rgba' in node_layers:
+        node_layers.remove("rgba")
+        node_layers.insert(0, "rgba")
+    return node_layers
+
+
+class denoicePanel(nukescripts.PythonPanel):
+    def __init__(self):
+        nukescripts.panels.PythonPanel.__init__(self, "KellerDenoicePanel", scrollable=True)
+
+
+        self.node = nuke.selectedNode()
+        self.nodeLayers = find_node_layers(self.node)
+        self.layerKnobs = []
+
+        # just disable layers
+        disable = [lay for lay in self.nodeLayers if any(x in lay for x in DISABLE_AOVS)]
+        num = len(self.nodeLayers)
+        for layer in self.nodeLayers:
+            self.layer = nuke.Boolean_Knob(layer, layer, True)
+            self.layer.setFlag(nuke.STARTLINE)
+            self.addKnob(self.layer)
+            self.layerKnobs.append(self.layer)
+            if layer in disable:
+                self.layer.setValue(False)
+
+        # interface selection
+        self.div1 = nuke.Text_Knob("div1", " ", "")
+        self.addKnob(self.div1)
+        self.all = nuke.PyScript_Knob("select_all", " Select All ")
+        self.addKnob(self.all)
+        self.invert = nuke.PyScript_Knob("invert_selection", " Invert Selection ")
+        self.addKnob(self.invert)
+        self.clear = nuke.PyScript_Knob("clear_selection", " Clear Selection ")
+        self.addKnob(self.clear)
+        self.div2 = nuke.Text_Knob("div2", " ", "")
+        self.addKnob(self.div2)
+
+        # settings
+        # variance
+        self.variance = nuke.Double_Knob("variance", "Variance", arraysize=1)
+        self.variance.setRange(0,1)
+        self.variance.setTooltip(
+            'Default: 0.25\nThe strength of the filter is determined by the variance parameter, the higher the variance the more forceful the denoising will be. '
+            'For variance maybe 0.25 (the default) / 0.5 / 0.75 are good low/min/max values. How aggressive the Arnold denoiser is in removing noise can be controlled by '
+            'setting a variance threshold with the command line argument -variance (-v). The default value is 0.25, higher values will make the denoising more aggressive by '
+            'considering similar neighborhoods that have bigger color disparities.')
+        self.addKnob(self.variance)
+        self.variance.setValue(0.25)
+
+        # patchradius
+        self.patchradius = nuke.Int_Knob("patchradius", "Patchradius", arraysize=1)
+        self.patchradius.setRange(0, 10)
+        self.patchradius.setTooltip(
+            'Default: 3\nThis increases the softness of the denoising (while always preserving the features). The default is 3 (on the big side), but a low value would be maybe 0 or 1, middle 3, and high 5. '
+            'For every pixel, the Arnold denoiser will consider its neighborhood patch and look for other pixels with similar neighborhood patches. The radius of this neighborhood can be controlled with the -patchradius '
+            ' (or -pr) command-line argument. The default value is set to 3, which gives a 7x7 square neighborhood.')
+        self.addKnob(self.patchradius)
+        self.patchradius.setValue(3)
+
+        # searchradius
+        self.searchradius = nuke.Int_Knob("searchradius", "Searchradius", arraysize=1)
+        self.searchradius.setRange(0, 50)
+        self.searchradius.setTooltip(
+            'Default: 9\nThis is the area over which similar neighborhoods are found. The higher the better, but it will increase '
+            'the cost of denoising. For every pixel noice will search a square area with a radius set with the '
+            'command line argument -searchradius (-sr). The bigger this area the bigger the denoising stability and '
+            'the higher the chance that similar neighborhoods to be considered will be found. The default value is 9, '
+            'which gives a 19x19 square neighborhood. Setting it to 21 (a search window of 42 x 42) will look over a '
+            'pixel area equivalent to loading 5 frames.')
+        self.addKnob(self.searchradius)
+        self.searchradius.setValue(9)
+
+        # extraFrames
+        self.temporalFrames = nuke.Int_Knob("temporalFrames", "ExtraFrames", arraysize=1)
+        self.temporalFrames.setRange(0, 2)
+        self.temporalFrames.setTooltip('This argument (-ef n or --extraframes n) specifies how many additional source frames before and after the current one should be used, for improved stability in animation sequences.\n(0-2. default:0)')
+        self.addKnob(self.temporalFrames)
+        self.temporalFrames.setValue(0)
+
+        # threads
+        self.threads = nuke.Int_Knob("threads", "Threads", arraysize=1)
+        self.threads.setTooltip('Number of threads (0: use all cores, negative numbers specify number of idle cores)')
+        self.addKnob(self.threads)
+        self.threads.setValue(-2)
+
+        # div
+        self.div3 = nuke.Text_Knob("div3", " ", "")
+        self.addKnob(self.div3)
+
+        # filepatn in
+        self.inputpath = nuke.File_Knob("input", "Input")
+        self.addKnob(self.inputpath)
+        self.inputpath.setTooltip('Needs to be in #### syntax. Not in %04d')
+        self.inputpath.setValue(nuke.selectedNode().knobs()['file'].value().replace('%04d','####'))
+
+        # filepath out
+        self.outputpath = nuke.File_Knob("output", "Output")
+        file = nuke.selectedNode().knobs()['file'].value().replace('%04d', '####')
+        file = file.replace('####', 'denoise.####')
+        self.outputpath.setValue(file)
+        self.addKnob(self.outputpath)
+
+        # set path
+        self.setpath = nuke.PyScript_Knob("setpath", " Set Path ")
+        self.layer.setFlag(nuke.STARTLINE)
+        self.addKnob(self.setpath)
+
+        # startframe
+        self.startframe = nuke.Int_Knob("startframe", "Startframe")
+        self.addKnob(self.startframe)
+
+        # endframe
+        self.endframe = nuke.Int_Knob("endframe", "Endframe")
+        self.addKnob(self.endframe)
+        self.endframe.clearFlag(nuke.STARTLINE)
+
+        # set to input
+        self.setToInput = nuke.PyScript_Knob("setToInput", " Set to Input ")
+        self.addKnob(self.setToInput)
+        selected = nuke.selectedNode()
+        fr = selected.frameRange()
+        start = fr.first()
+        end = fr.last()
+        self.startframe.setValue(start)
+        self.endframe.setValue(end)
+        self.setToInput.clearFlag(nuke.STARTLINE)
+
+        # set framerange
+        self.setFrameRange = nuke.PyScript_Knob("setFrameRange", " Set Framerange ")
+        self.addKnob(self.setFrameRange)
+        self.setFrameRange.clearFlag(nuke.STARTLINE)
+
+        # filepath
+        self.arnoldBinPath = nuke.File_Knob("arnoldBinPath", " Arnold Bin Path ")
+        self.addKnob(self.arnoldBinPath)
+        self.arnoldBinPath.setValue('$env(PROJECT_ROOT_3D)/000_env/arnold/_noice/bin/')
+        self.arnoldBinPath.setTooltip('Please be sure to select the bin folder with a "/" at the end.')
+
+        # div
+        self.div4 = nuke.Text_Knob("div4", " ", "")
+        self.addKnob(self.div4)
+
+        # render mode
+        self.renderChoice = nuke.Enumeration_Knob('renderChoice', 'Render On', ['muster', 'local_machine'])
+        self.renderChoice.setTooltip('local_machine: creates a .bat file with all frames, saves it to the temp directory and runs it on the local machine.\nmuster: sends the job to muster.')
+        self.addKnob(self.renderChoice)
+
+        # muster pool
+        self.musterPool = nuke.String_Knob("musterPool", "Muster Pool")
+        self.musterPool.setValue(POOL)
+        self.addKnob(self.musterPool)
+
+        # muster pool
+        self.musterFolder = nuke.String_Knob("musterFolder", "Muster Folder ID")
+        self.musterFolder.setValue(MUSTERFOLDER)
+        self.addKnob(self.musterFolder)
+
+        # div
+        self.div5 = nuke.Text_Knob("div5", " ", "")
+        self.addKnob(self.div5)
+
+        # window
+        height = len(self.layerKnobs) * 20
+        width = 800
+        #if height > 1200:
+        #    width = 700
+        #    height = 1200
+        self.setMinimumSize(width, height)
+        #self.setMaximumSize(800, 1050)
+
+
+    def knobChanged(self, knob):
+        if knob.name() == "select_all":
+            for layer in self.layerKnobs:
+                layer.setValue(True)
+
+        if knob.name() == "invert_selection":
+            selected = []
+            for layer in self.layerKnobs:
+                if layer.value() is True:
+                    selected.append(layer)
+                    layer.setValue(False)
+            inverse = list(set(self.layerKnobs).difference(set(selected)))
+            for check in inverse:
+                check.setValue(True)
+
+        if knob.name() == "clear_selection":
+            for layer in self.layerKnobs:
+                layer.setValue(False)
+
+        if knob.name() == "setToInput":
+            selected = nuke.selectedNode()
+            fr = selected.frameRange()
+            start = fr.first()
+            end = fr.last()
+            self.startframe.setValue(start)
+            self.endframe.setValue(end)
+
+        if knob.name() == "setFrameRange":
+            self.startframe.setValue(int(nuke.root()['first_frame'].value()))
+            self.endframe.setValue(int(nuke.root()['last_frame'].value()))
+
+        if knob.name() == "setpath":
+            file = nuke.selectedNode().knobs()['file'].value().replace('%04d','####')
+            file = file.replace('####','denoise.####')
+            self.outputpath.setValue(file)
+
+        if knob.name() == "renderChoice":
+            if self.renderChoice.value() == "local_machine":
+                self.musterPool.setVisible(False)
+                self.musterFolder.setVisible(False)
+            if self.renderChoice.value() == "muster":
+                self.musterPool.setVisible(True)
+                self.musterFolder.setVisible(True)
+
+
+        if knob.name() == "OK":
+            if self.renderChoice.value() == "local_machine":
+                print('Denoising locally......')
+                self.executeNoiceLocally()
+            if self.renderChoice.value() == "muster":
+                print('Denoising on Muster......')
+                self.sendToMuster()
+
+
+    def executeNoiceLocally(self):
+        # saving selected aovs
+        light_aov_names = []
+        for layer in self.layerKnobs:
+            if layer.value() is True:
+                light_aov_names.append(layer.name())
+
+        binpath = self.arnoldBinPath.evaluate().replace('\\','/')
+
+        filename_input_sequence_number = re.sub(r'#+', lambda m: r'{{:0{}d}}'.format(len(m.group(0))), self.inputpath.value().replace('%04d','####'))
+        filename_output_sequence_number = re.sub(r'#+', lambda m: r'{{:0{}d}}'.format(len(m.group(0))), self.outputpath.value().replace('%04d','####'))
+
+        command = ''
+        for i in range(self.startframe.value(), self.endframe.value() + 1):
+            light_aov_string = ""
+
+            for k in light_aov_names:
+                print('Denoice: Info. AOV: %s') % k
+                light_aov_string += "-aov " + str(k) + " "
+
+            command += '"' + binpath + '/noice.exe' + '"' + ' ' \
+                  + '-patchradius ' + str(self.patchradius.value()) + ' ' \
+                  + '-searchradius ' + str(self.searchradius.value()) + ' ' \
+                  + '-variance ' + str(self.variance.value()) + ' ' \
+                  + light_aov_string \
+                  + '-i ' + filename_input_sequence_number.format(i) + ' ' \
+                  + '-t ' + str(self.threads.value()) + ' ' \
+                  + '-ef ' + str(self.temporalFrames.value()) + ' ' \
+                  + '-output ' + filename_output_sequence_number.format(i)
+
+            print('_________________________________________________________________________________________________')
+            print('')
+            print('--------------------------------> Denoise Command for Frame %s <---------------------------') %i
+            print('_________________________________________________________________________________________________')
+            print('')
+            print('')
+            print('')
+
+            if i is not self.endframe.value():
+                command += "\n"
+        print(command)
+
+        temp = tempfile.NamedTemporaryFile(prefix='Noice_', suffix='.bat', delete=False)
+        temp.write(command)
+        print('Created temp file is:', temp.name)
+        temp.close()
+
+        filepath = 'cmd /c start "Denoice " "%s"' %temp.name
+        p = subprocess.call(filepath, shell=True, stdout=subprocess.PIPE)
+
+
+    def fixfilename(self,infile):
+
+        infile = infile.replace("p:/", "//hades/p/")
+        infile = infile.replace("P:/", "//hades/p/")
+        infile = infile.replace("o:/", "//calculon/o/")
+        infile = infile.replace("O:/", "//calculon/o/")
+        infile = infile.replace("/", "\\")
+
+        return infile
+
+
+    def sendToMuster(self):
+        # jobname
+        jobname = nuke.selectedNode().knobs()['file'].value().split("/")[-1].replace('.%04d.exr',"__denoise")
+        # aovs
+        # saving selected aovs
+        light_aov_names = []
+        light_aov_string = ""
+        for layer in self.layerKnobs:
+            if layer.value() is True:
+                light_aov_names.append(layer.name())
+        for k in light_aov_names:
+            print('Denoice: Info. AOV: %s') % k
+            light_aov_string += "-l " + str(k) + " "
+        light_aov_string = light_aov_string.rstrip()
+        light_aov_string = '"' + light_aov_string + '"'
+
+        a_bin_path = self.fixfilename(self.arnoldBinPath.evaluate())
+        a_input_path = self.fixfilename(self.inputpath.evaluate().replace('%04d','####'))
+        a_output_path = self.fixfilename(self.outputpath.evaluate().replace('%04d','####'))
+
+        # building Command
+        cmd = '%s -s %s -u %s -b -e %s -n %s' % (MRTOOL, MSTRSERVER, USERNAME, TEMPLATE, jobname)
+        cmd += ' -pk %i -pr %i -pool "%s" -parent %i' % (int(PSIZE), int(PRIO), self.musterPool.value(), int(self.musterFolder.value()))
+        cmd += ' -attr "NOICEBIN" %s 0' % a_bin_path
+        cmd += ' -attr "PATCHRADIUS" %i 0' % int(self.patchradius.value())
+        cmd += ' -attr "SEARCHRADIUS" %i 0' % int(self.searchradius.value())
+        cmd += ' -attr "VARIANCE" %s 0' % self.variance.value()
+        cmd += ' -sf %i' % int(self.startframe.value())
+        cmd += ' -ef %i' % int(self.endframe.value())
+        cmd += ' -bf %i' % 1
+        cmd += ' -f %s' % a_input_path
+
+        cmd += ' -attr "LIGHTAOVSTRING" %s 0' % light_aov_string
+        cmd += ' -attr "TEMPORALFRAMES" %i 0' % int(self.temporalFrames.value())
+        cmd += ' -attr "DENOISETHREADS" %i 0' % int(self.threads.value())
+        cmd += ' -attr "OUTPUTFILE" %s 0' % a_output_path
+
+        # send
+        print (cmd)
+        print (os.system(cmd))
+        return
+
+
+def addPanel():
+    try:
+        selected = nuke.selectedNode()
+    except:
+        nuke.message("Denoice: Error. Please select a Read node with EXR file")
+        return
+    if selected.Class() == "Read":
+        if os.path.splitext(selected["file"].value())[1] == ".exr":
+            launch_panel = denoicePanel()
+            launch_panel.showModalDialog()
+        else:
+            nuke.message("Denoice: Error. Please select a Read node with EXR file")
+    else:
+        nuke.message("Denoice: Error. Please select a Read node")

pythonpluginsUI/denoice/muster_template.py.txt

@@ -0,0 +1,210 @@
+''' Muster 8 Generic script template class '''
+
+''' Import Muster base modules '''
+import MClientAPI
+import MTemplateAPI
+
+''' Import Python base lib modules '''
+import os.path
+import re
+
+''' Get the template manager singleton '''
+manager = MTemplateAPI.MManager.getUniqueClass()
+
+''' Define a new class derived from MTemplateAPI.MTemplate base class , override required methods '''
+
+
+class ShellTemplate(MTemplateAPI.MTemplate):
+    def __init__(self):
+        MTemplateAPI.MTemplate.__init__(self)
+        self.setID(2008)
+        self.setName("Denoise_Noice")
+        self.setDescription("Denoise with Noice")
+        self.setTemplateLogic(MTemplateAPI.kTemplateMultiframe)
+        self.setDefaultPriority(1)
+        self.setDefaultPools("arnold_16thread")
+        self.setDefaultExcludedPools("")
+        self.setMaximumLicenses(0)
+        self.setEnableAdditionalFlagsField(1)
+
+        ''' Submission form items allocation '''
+        NoiceBin = MTemplateAPI.MTemplateItemFolder("NOICEBIN", "Noice Bin Path", "Specifies the Noice bin Path", "", 0,
+                                                    1, 1)
+        patchRadius = MTemplateAPI.MTemplateItemInteger("PATCHRADIUS", "PatchRadius", "Specify the patch radius", 3, 0,
+                                                        0, 1)
+        searchRadius = MTemplateAPI.MTemplateItemInteger("SEARCHRADIUS", "PatchRadius", "Specify the patch radius", 9,
+                                                         0, 0, 1)
+        variance = MTemplateAPI.MTemplateItemDouble("VARIANCE", "Variance", "Specifies the variance", 0.25, 0, 0, 1)
+        lightAovString = MTemplateAPI.MTemplateItemString("LIGHTAOVSTRING", "Light AOV String",
+                                                          "Specifies the AOVs to be denoised. Syntax: -aov aovname1 -aov aovname2 -aov aovname3",
+                                                          "-aov rgba", 0, 0, 1)
+        temporalFrames = MTemplateAPI.MTemplateItemInteger("TEMPORALFRAMES", "Temporal Frames",
+                                                           "Specifies the temporal frames", 0, 0, 0, 1)
+        denoiseThreads = MTemplateAPI.MTemplateItemInteger("DENOISETHREADS", "Threads", "Specify the denoise threads",
+                                                           -2, 1, 0, 1)
+        startFrame = MTemplateAPI.MTemplateItemInteger("NOICESTARTFRAME", "Start frame",
+                                                       "Specifies the starting frame for the rendering job", 1001, 0, 0,
+                                                       1)
+        endFrame = MTemplateAPI.MTemplateItemInteger("NOICEENDFRAME", "End frame",
+                                                     "Specifies the ending frame for the rendering job", 1010, 0, 0, 1)
+        inputFile = MTemplateAPI.MTemplateItemFile("INPUTFILE", "Input File", "Specifies the File to be denoised", "",
+                                                   0, 1, 1, "*.exr")
+        outputFile = MTemplateAPI.MTemplateItemFile("OUTPUTFILE", "Output File", "Specifies the output File", "", 0, 1,
+                                                    1, "*.exr")
+
+        self.addSubmissionItem(NoiceBin)
+        self.addSubmissionItem(patchRadius)
+        self.addSubmissionItem(searchRadius)
+        self.addSubmissionItem(variance)
+        self.addSubmissionItem(lightAovString)
+        self.addSubmissionItem(temporalFrames)
+        self.addSubmissionItem(denoiseThreads)
+        self.addSubmissionItem(startFrame)
+        self.addSubmissionItem(endFrame)
+        self.addSubmissionItem(inputFile)
+        self.addSubmissionItem(outputFile)
+
+        ''' items mapping to Muster default tags '''
+        self.addMapping("INPUTFILE", "job_file")
+        self.addMapping("NOICESTARTFRAME", "start_frame")
+        self.addMapping("NOICEENDFRAME", "end_frame")
+
+        ''' Windows support '''
+        self.platformWindows.setPlatformEnabled(1)
+        self.platformWindows.setEnableErrorCheck(1)
+        self.platformWindows.setEnabledByDefault(1)
+        self.platformWindows.setDetectionLogic(MTemplateAPI.kProcessChild)
+        #self.platformWindows.setDetectionLogic(MTemplateAPI.kProcessDirect)
+        self.platformWindows.setDetectionLogicProcessName("noice.exe")
+
+        ''' OSX support '''
+        self.platformOSX.setPlatformEnabled(0)
+        self.platformOSX.setEnableErrorCheck(1)
+        self.platformOSX.setEnabledByDefault(1)
+        self.platformOSX.setDetectionLogic(MTemplateAPI.kProcessDirect)
+
+        applicationPath = MTemplateAPI.MTemplateItemFile("SHELLCMD", "Script interpreter executable",
+                                                         "Specifies the OS X script executable", "/bin/sh", 0, 0, 1,
+                                                         "*.exe")
+        self.platformOSX.addClientConfigurationItem(applicationPath)
+
+        ''' Linux support '''
+        self.platformLinux.setPlatformEnabled(0)
+        self.platformLinux.setEnableErrorCheck(1)
+        self.platformLinux.setEnabledByDefault(1)
+        self.platformLinux.setDetectionLogic(MTemplateAPI.kProcessDirect)
+
+        applicationPath = MTemplateAPI.MTemplateItemFile("SHELLCMD", "Script interpreter executable",
+                                                         "Specifies the Linux script executable", "/bin/sh", 0, 0, 1,
+                                                         "*.exe")
+        self.platformLinux.addClientConfigurationItem(applicationPath)
+
+    ''' virtual functions overrides '''
+
+    def onBuildCommandLine(self, platform, job, chunk, clientTemplatePreferences, instanceNum):
+        # sequence with sequence string bla.1001.exr
+        fileIn = job.attributeGetString(manager.resolveMappingToJob(self.getID(), "INPUTFILE"))
+        fileOut = job.attributeGetString(manager.resolveMappingToJob(self.getID(), "OUTPUTFILE"))
+
+        # regex
+        patternSeq = re.compile(r'\.\d\d\d+\.')
+
+        # extract frame substring
+        frame = patternSeq.findall(fileIn)
+        # if there are more matches due to non-conform naming
+        frame = frame[-1]
+        chunkFrame = "." + str(int(chunk.getStartFrame())) + "."
+
+        # replace padding with the startFrame of the chunk
+        fileIn = fileIn.replace(frame, chunkFrame)
+        fileOut = fileOut.replace(frame, chunkFrame)
+
+        renderCmd = ""
+        if platform == MClientAPI.kPlatformWindows:
+            renderCmd += "/c "
+            renderCmd += "\""
+            renderCmd += job.attributeGetString("NOICEBIN") + "noice.exe"
+            renderCmd += " -patchradius %s" % job.attributeGetInt("PATCHRADIUS")
+            renderCmd += " -searchradius %s" % job.attributeGetInt("SEARCHRADIUS")
+            renderCmd += " -variance %s" % job.attributeGetFloat("VARIANCE")
+            renderCmd += " " + job.attributeGetString("LIGHTAOVSTRING")  # '-aov aovname1 -aov aovname2'
+            renderCmd += " -i " + fileIn
+            renderCmd += " -t " + job.attributeGetString("DENOISETHREADS")
+            renderCmd += " -ef %s" % job.attributeGetInt("TEMPORALFRAMES")
+            renderCmd += " -output " + fileOut
+            renderCmd += "\""
+
+            addFlags = job.attributeGetString("ADD_FLAGS")
+            if len(addFlags) > 0:
+                renderCmd += " " + addFlags
+        return renderCmd
+
+    def onCheckLog(self, job, chunk, clientTemplatePreferences, log, warnings, errors, silencedWarnings,
+                   silencedErrors):
+        ## WARNINGS
+        noWarnings = []
+        foundset = []
+
+        for line in log.splitlines():
+            if line.lower().find("warning") != -1:
+                foundset.append(line)
+        # remove no warning strings
+        result = [x for x in foundset if not any(y in x for y in noWarnings)]
+        if len(result) != 0:
+            return MTemplateAPI.MTemplateError(2, "Warning keyword found",
+                                               MTemplateAPI.MTemplateError.kTemplateErrorTypeWarning)
+        ## ERRORS
+        if log.lower().find("error") != -1:
+            return MTemplateAPI.MTemplateError(1, "Error keyword found",
+                                               MTemplateAPI.MTemplateError.kTemplateErrorTypeError)
+        if log.lower().find("no licenses could be found to run this application") != -1:
+            return MTemplateAPI.MTemplateError(1, "No license available",
+                                               MTemplateAPI.MTemplateError.kTemplateErrorTypeError)
+        return MTemplateAPI.MTemplateError()
+
+    def onCheckLogLine(self, job, chunk, clientTemplatePreferences, line, lineNum, warnings, errors, silencedWarnings,
+                       silencedErrors):
+        return MTemplateAPI.MTemplateError()
+
+    def onBuildEnvironment(this, job, chunk, clientTemplatePreferences, existingEnvironment):
+        return existingEnvironment
+
+    def onGetApplicationPath(self, job, chunk, clientTemplatePreferences, pathOut):
+        platform = MClientAPI.GetPlatform()
+        if platform == MClientAPI.kPlatformWindows:
+            pathOut.setString("cmd.exe")
+        else:
+            pathOut.setString("/bin/sh")
+        return MTemplateAPI.MTemplateError()
+
+    def onGetApplicationStartingFolder(self, job, chunk, clientTemplatePreferences, pathOut):
+        pathStart = "c:\\Windows\\System32"
+        platform = MClientAPI.GetPlatform()
+        if platform == MClientAPI.kPlatformWindows:
+            #pathOut.setString(job.attributeGetString("NOICEBIN"))
+            pathOut.setString(pathStart)
+        else:
+            pass
+        return MTemplateAPI.MTemplateError()
+
+    def onCheckForSubframeAdvancingString(self, job, chunk, line):
+        return 0
+
+    def onCheckForSubframeProgress(self, job, chunk, line, progressOut):
+        return 0
+
+    def onCheckExitCode(self, job, chunk, clientTemplatePreferences, exitCode):
+        if exitCode != 0:
+            return MTemplateAPI.MTemplateError(exitCode, "%d Exit code different from expected 0 value" % exitCode,
+                                               MTemplateAPI.MTemplateError.kTemplateErrorTypeWarning)
+        return MTemplateAPI.MTemplateError()
+
+    def onApplicationFinder(self, moduleRegExp, moduleTag):
+        return MTemplateAPI.kTemplateScanNone
+
+    def onFindApplication(self, basePath, clientTemplatePreferences):
+        pass
+
+''' Create an instance of the template class and install it into the template manager context '''
+template = ShellTemplate()
+manager.installPyTemplate(template)

pythonpluginsUI/nukeffmpeg/Preview_QT.nk

@@ -0,0 +1,185 @@
+set cut_paste_input [stack 0]
+version 12.2 v5
+push $cut_paste_input
+Group {
+ name Preview_QT
+ tile_color 0xbfbf00ff
+ label "h264 intra\n\[value nodeLabel]"
+ selected true
+ xpos 151
+ ypos 68
+ addUserKnob {20 ffmpeg}
+ addUserKnob {35 presets M {"Prores 422" "knobs this \{ffmpeg_args \"-c:v prores_ks -profile:v 2 -qscale:v 7 -pix_fmt yuv444p10le -r 24 -vf colormatrix=bt601:bt709 -vendor ap10 -metadata:s encoder=\\\"Apple ProRes 422\\\"\" framerate 24 label \"Prores 422\\n\[value nodeLabel]\"\}" "Prores 422 HQ" "knobs this \{ffmpeg_args \"-c:v prores_ks -profile:v 3 -qscale:v 7 -pix_fmt yuv444p10le -r 24 -vf colormatrix=bt601:bt709 -vendor ap10 -metadata:s encoder=\\\"Apple ProRes 422 HQ\\\"\" framerate 24 label \"Prores 422 HQ\\n\[value nodeLabel]\"\}" "Prores 4444" "knobs this \{ffmpeg_args \"-c:v prores_ks -profile:v 4 -qscale:v 5 -pix_fmt yuv444p10le -r 24 -vf colormatrix=bt601:bt709 -vendor ap10 -metadata:s encoder=\\\"Apple ProRes 4444\\\"\\\"\" framerate 24 label \"Prores 4444\\n\[value nodeLabel]\"\}" "DNxHD 36" "knobs this \{ffmpeg_args \"-c:v dnxhd -profile:v dnxhd -pix_fmt yuv422p -b:v 36M -vf \\\"scale=1920:1080,fps=24000/1001,colormatrix=bt601:bt709\\\"\" framerate 23.976 label \"DNxHD 36\\n\[value nodeLabel]\"\}" "DNxHD 115" "knobs this \{ffmpeg_args \"-c:v dnxhd -profile:v dnxhd -pix_fmt yuv422p -b:v 115M -vf \\\"scale=1920:1080,fps=24000/1001,colormatrix=bt601:bt709\\\"\" framerate 23.976 label \"DNxHD 115\\n\[value nodeLabel]\"\}" "DNxHD 175" "knobs this \{ffmpeg_args \"-c:v dnxhd -profile:v dnxhd -pix_fmt yuv422p -b:v 175M -vf \\\"scale=1920:1080,fps=24000/1001,colormatrix=bt601:bt709\\\"\" framerate 23.976 label \"DNxHD 175\\n\[value nodeLabel]\"\}" "DNxHD 175 10bit" "knobs this \{ffmpeg_args \"-c:v dnxhd -profile:v dnxhd -pix_fmt yuv422p10 -b:v 175M -vf \\\"scale=1920:1080,fps=24000/1001,colormatrix=bt601:bt709\\\"\" framerate 23.976 label \"DNxHD 175 10bit\\n\[value nodeLabel]\"\}" "DNxHD 220 10bit" "knobs this \{ffmpeg_args \"-c:v dnxhd -profile:v dnxhd -pix_fmt yuv422p10 -b:v 220M -vf \\\"scale=1920:1080,fps=24000/1001,colormatrix=bt601:bt709\\\"\" framerate 23.976 label \"DNxHD 220 10bit\\n\[value nodeLabel]\"\}" "DNxHR HQ" "knobs this \{ffmpeg_args \"-c:v dnxhd -profile:v dnxhr_hq -pix_fmt yuv422p -vf \\\"colormatrix=bt601:bt709\\\"\" framerate 24 label \"DNxHR HQ\\n\[value nodeLabel]\"\}" "DNxHR HQX" "knobs this \{ffmpeg_args \"-c:v dnxhd -profile:v dnxhr_hqx -pix_fmt yuv422p10le -vf \\\"colormatrix=bt601:bt709\\\"\" framerate 24 label \"DNxHR HQX\\n\[value nodeLabel]\"\}" "DNxHR 444" "knobs this \{ffmpeg_args \"-c:v dnxhd -profile:v dnxhr_444 -pix_fmt yuv444p10le -vf \\\"colormatrix=bt601:bt709\\\"\" framerate 24 label \"DNxHR 444\\n\[value nodeLabel]\"\}" "h264 standard" "knobs this \{ffmpeg_args \"-c:v libx264 -profile:v high -crf 15 -preset slow -tune film -pix_fmt yuv420p -g 4 -bf 2 -vf colormatrix=bt601:bt709\" framerate 24 label \"h264 standard\\n\[value nodeLabel]\"\}" "h264 intra" "knobs this \{ffmpeg_args \"-c:v libx264 -profile:v high -crf 12 -preset slow -tune film -pix_fmt yuv420p -g 1 -bf 0 -vf colormatrix=bt601:bt709\" framerate 24 label \"h264 intra\\n\[value nodeLabel]\"\}" "h264 intra 444" "knobs this \{ffmpeg_args \"-c:v libx264 -profile:v high444 -crf 12 -preset slow -tune film -pix_fmt yuv444p -g 1 -bf 0 -vf colormatrix=bt601:bt709\" framerate 24 label \"h264 intra 444\\n\[value nodeLabel]\"\}" "h264 intra 444 10bit" "knobs this \{ffmpeg_args \"-c:v libx264 -profile:v high444 -crf 12 -preset slow -tune film -pix_fmt yuv444p10le -g 1 -bf 0 -vf colormatrix=bt601:bt709\" framerate 24 label \"h264 intra 444 10bit\\n\[value nodeLabel]\"\}" "h265 standard 10bit" "knobs this \{ffmpeg_args \"-c:v libx265 -profile:v main10 -crf 15 -preset slow -tune psnr -pix_fmt yuv420p10le -g 2 -bf 0 -vf colormatrix=bt601:bt709\" framerate 24 label \"h265 standard 10bit\\n\[value nodeLabel]\"\}" "h265 intra 422 10bit" "knobs this \{ffmpeg_args \"-c:v libx265 -profile:v main422-10-intra -crf 12 -preset slow -tune psnr -pix_fmt yuv422p10le -g 1 -bf 0 -vf colormatrix=bt601:bt709\" framerate 24 label \"h265 intra 10bit\\n\[value nodeLabel]\"\}" "h265 intra 444 10bit" "knobs this \{ffmpeg_args \"-c:v libx265 -profile:v main444-10-intra -crf 12 -preset slow -tune psnr -pix_fmt yuv444p10le -g 1 -bf 0 -vf colormatrix=bt601:bt709\" framerate 24 label \"h265 intra 444 10bit\\n\[value nodeLabel]\"\}"}}
+ addUserKnob {1 ffmpeg_args l "ffmpeg args"}
+ ffmpeg_args "-c:v libx264 -profile:v high -crf 12 -preset slow -tune film -pix_fmt yuv420p -g 1 -bf 0 -vf colormatrix=bt601:bt709"
+ addUserKnob {26 ""}
+ addUserKnob {1 info t "Additional non-mandatory File Info"}
+ addUserKnob {2 file t "output file"}
+ file "\$env(PROJECT_ROOT_3D)/550_previewQTs/HOT_comp_001_010.comp_v001/HOT_comp_001_010.comp_v001.mov"
+ addUserKnob {22 setfilepath l "Set Filepath" t "Creates a valid filename.\nUses the main task of SceneControl and points to the PreviewQT Dir." T "n = nuke.thisNode()\ninfo = n\['info'].value()\nffmpeg_args = n\['ffmpeg_args'].value()\n\nif 'dnxhd' in ffmpeg_args:\n    extension = 'mov'\nif 'libx264' in ffmpeg_args:\n    extension = 'mp4'\nif 'libx265' in ffmpeg_args:\n    extension = 'mp4'\nif 'prores' in ffmpeg_args:\n    extension = 'mov'\n\noutputpath = sceneControl.kenvQuery('PREVIEW_QT_FILE', minor_version=None, info=info, ext=extension)\n\nn.knobs()\[\"file\"].setValue(outputpath)\n\n# create label for displaying the generated output\n# autoLabel = \"n.name() + '\\\\n' +n\['file'].value().split('/')\[-1] +  '\\\\n' + n\['label'].value()\"\n# n\['autolabel'].setValue(autoLabel)" +STARTLINE}
+ addUserKnob {26 ""}
+ addUserKnob {1 burnNameText l burn-in}
+ burnNameText "\[python \{nuke.thisNode().knobs()\['file'].value().split('/')\[-1].replace('.mp4','').replace('.mov','')\}]"
+ addUserKnob {20 config n 1}
+ config 0
+ addUserKnob {1 ffmpeg_cmd l command t "Enter the path to the ffmpeg executable. \nWindows:\nffmpeg.exe uses the ffmpeg provided with the nuke tool.\n\nLinux/MacOS (untested!)\nffmpeg without a path will use the environment."}
+ ffmpeg_cmd ffmpeg.exe
+ addUserKnob {1 nodeLabel l label t "used for node labelling."}
+ nodeLabel "\[python \{nuke.thisNode().knobs()\['file'].value().split('/')\[-1]\}]"
+ addUserKnob {1 helper t "Expression string if you want to derive the burn-in via expression from SceneControl config."}
+ helper "\[value sceneCtrl.project]_\[value sceneCtrl.dept]_\[value sceneCtrl.sequence]_\[value sceneCtrl.shot].\[value sceneCtrl.task]_v\[format %03s \[value sceneCtrl.major_version]]"
+ addUserKnob {1 helper2 l helper t "Default string for burn-in name."}
+ helper2 "\[python \{nuke.thisNode().knobs()\['file'].value().split('/')\[-1].replace('.mp4','').replace('.mov','')\}]"
+ addUserKnob {7 fontScale l "font scale"}
+ fontScale 0.25
+ addUserKnob {20 endGroup_defaults l "endGroup Defaults" n -1}
+ addUserKnob {6 burnName l "Burn-in Name" +STARTLINE}
+ burnName true
+ addUserKnob {6 burnFrame l "Burn-in Frame" -STARTLINE}
+ burnFrame true
+ addUserKnob {26 ""}
+ addUserKnob {7 framerate R 23 30}
+ framerate {{"\[python \{nuke.root().knobs()\['fps'].value()\}]"}}
+ addUserKnob {1 framerange -STARTLINE}
+ framerange 1001-1109
+ addUserKnob {22 set_framerange l "Set to Input" -STARTLINE T "n = nuke.thisNode()\nfr = n.frameRange()\nn\['framerange'].setValue(\"\{0\}-\{1\}\".format(fr.first(), fr.last()))"}
+ addUserKnob {22 set_sc_framerange l "Set Framerange" t "Set framerange from SceneControl." -STARTLINE T "c = nuke.exists(\"sceneCtrl\")\nif c:\n    sc = nuke.toNode('sceneCtrl')\n    \n    n = nuke.thisNode()\n    n\['framerange'].setValue(\"\{0\}-\{1\}\".format(int(sc.knobs()\['fStart'].getValue()), int(sc.knobs()\['fEnd'].getValue())))\nelse:\n    print('No SceneControl found.')\n"}
+ addUserKnob {22 render l Render t "Saves your scene and renders.\nSee the progress in the Nuke Console Window." T "import ffmpeg_render\nffmpeg_render.prep()" +STARTLINE}
+ addUserKnob {20 help_1 l Help}
+ addUserKnob {26 helptext l "Help     " T "1. choose preset\n\n2. set info if needed\n\n3. <Set Filepath>\n\n4. enable or disable burn ins\n\n5. <Render>\n\n6. Look at the Nuke Console for progress\n"}
+}
+ Input {
+  inputs 0
+  name Input
+  xpos -40
+  ypos -112
+ }
+ Dot {
+  name Dot66
+  xpos -6
+  ypos -16
+ }
+set N7f514400 [stack 0]
+ Text2 {
+  font_size_toolbar 100
+  font_width_toolbar 100
+  font_height_toolbar 100
+  message "\[value parent.burnNameText]"
+  old_message {{72 79 84 95 99 111 109 112 95 48 48 49 95 48 49 48 46 99 111 109 112 95 118 48 48 49}
+    }
+  old_expression_markers {{0 25}
+    }
+  box {15 5 {box.x+600 x1001 525} 100}
+  yjustify bottom
+  transforms {{0 2}
+    }
+  cursor_position 27
+  font {{ Arial : Regular : arial.ttf : 0 }}
+  global_font_scale {{"\[value parent.fontScale]"}}
+  scale {1 1}
+  cursor_initialised true
+  autofit_bbox false
+  initial_cursor_position {{27.5 118.5}
+    }
+  group_animations {{0} imported: 0 selected: items: "root transform/"}
+  animation_layers {{1 11 1024 778 0 0 1 1 0 0 0 0}
+    }
+  name Text_SHOTNAME1
+  xpos -163
+  ypos -19
+ }
+push $N7f514400
+ Switch {
+  inputs 2
+  which {{"\[value parent.burnName]"}}
+  name switch_name
+  xpos -40
+  ypos 41
+ }
+ Dot {
+  name Dot1
+  xpos -6
+  ypos 79
+ }
+set N434f7400 [stack 0]
+ Text2 {
+  font_size_toolbar 100
+  font_width_toolbar 100
+  font_height_toolbar 100
+  message "\[format %04s \[frame]]"
+  old_message {{48 48 48 49}
+    }
+  old_expression_markers {{0 3}
+    }
+  box {{width-15-500} 5 {width-15} 100}
+  xjustify right
+  yjustify bottom
+  transforms {{0 2}
+    }
+  font_size_values {{0 100 1 100 2 100 3 100}
+    }
+  baseline_values {{0 0 1 0 2 0 3 0}
+    }
+  cursor_position 21
+  font {{ Arial : Regular : arial.ttf : 0 }}
+  global_font_scale {{"\[value parent.fontScale]"}}
+  scale {1 1}
+  cursor_initialised true
+  autofit_bbox false
+  initial_cursor_position {{1876.5 146.5}
+    }
+  group_animations {{0} imported: 0 selected: items: "root transform"}
+  animation_layers {{1 11 1024 778 0 0 1 1 0 0 0 0}
+    }
+  name Text_FRAMECOUNT1
+  xpos -164
+  ypos 76
+ }
+push $N434f7400
+ Switch {
+  inputs 2
+  which {{"\[value parent.burnFrame]"}}
+  name switch_frame
+  xpos -40
+  ypos 136
+ }
+ Write {
+  raw true
+  file_type tiff
+  datatype "16 bit"
+  compression none
+  checkHashOnRead false
+  version 486
+  name write_tmp
+  selected true
+  xpos -40
+  ypos 246
+  addUserKnob {20 keller l Keller}
+  addUserKnob {4 subtask t "Defaults to the Task selected in sceneControl, ignoring Element and Info.\nAll other subtasks are pre-renders and get rendered into the precomp (=prerender) directory." M {scriptTask denoise key neutralgrade prerender stabilize}}
+  addUserKnob {22 w_reload l Reload t "Reload Tasks" -STARTLINE T sceneControl.kenvWriteReloadSubTasks(nuke.thisNode())}
+  addUserKnob {1 element l Element t "Optional Specifier. For example \[BG]_denoise. \[FG]_denoise."}
+  addUserKnob {1 info l Info t "Optional Info before Framenumber.\nPRO_comp3d_001_010.comp3d_v008.\[acescg].%04d.exr"}
+  addUserKnob {22 set l Set t "Set Output Path of this node" T sceneControl.kenvWriteSetPath(nuke.thisNode()) +STARTLINE}
+  addUserKnob {26 divider1 l "" +STARTLINE}
+  addUserKnob {6 ignore l "ignore in sceneControl" -STARTLINE}
+  ignore true
+  addUserKnob {26 divider2 l "" +STARTLINE}
+  addUserKnob {22 playinrv l "Play in RV" t "Opens new instance of RV" T playInRV.playInRV(nuke.thisNode().knob('file').getValue(),0) +STARTLINE}
+  addUserKnob {22 pushtorv l "Push to RV" t "Push to tagged RV. Will open RV and uses this instance to directly push sequences." -STARTLINE T playInRV.playInRV(nuke.thisNode().knob('file').getValue(),1)}
+  addUserKnob {22 pushtorvappend l "Push to RV (append)" t "Push to RV and append to existing sources" -STARTLINE T playInRV.playInRV(nuke.thisNode().knob('file').getValue(),2)}
+  addUserKnob {26 divider3 l "" +STARTLINE}
+  addUserKnob {22 explore l Explore t "Open Folder" -STARTLINE T exploreThis.exploreThis()}
+ }
+ Output {
+  name Output
+  xpos -40
+  ypos 355
+ }
+ StickyNote {
+  inputs 0
+  name StickyNote1
+  label keep_name!
+  xpos 60
+  ypos 253
+ }
+end_group

pythonpluginsUI/nukeffmpeg/ffmpeg.exe (Stored with Git LFS)

+oid sha256:cf19f79b8ee6bc1c83438ea8f6d266496681f686cc87bf1d295126621700a1eb
+size 112424960

pythonpluginsUI/nukeffmpeg/ffmpeg_render.py

@@ -0,0 +1,160 @@
+from __future__ import with_statement
+from __future__ import print_function
+from __future__ import division
+import os, sys
+import subprocess, shlex
+import argparse
+import tempfile
+import numpy as np
+import nuke
+import tifffile
+
+
+class ffmpeg_render(KellerNukePlugin):
+
+    def configurePlugin(self):
+        workgroup = os.getenv('NUKE_PATH')
+        nk = os.path.join(workgroup, "pythonpluginsUI/nukeffmpeg", "Preview_QT.nk")
+        nk = nk.replace('\\','/')
+        nk = "\"" + nk + "\""
+        menubar = nuke.menu("Nuke")
+        self.m = menubar.addMenu("&Render")
+        self.m.addCommand('FFmpeg Render', 'nuke.nodePaste({nk})'.format(nk=nk),shortcut='F6')
+
+
+    def unconfigurePlugin(self):
+        self.m.removeItem("FFmpeg Render")
+
+
+from sys import platform as __platform
+if __platform == "linux" or __platform == "linux2":
+    _platform = 'linux'
+elif __platform == "darwin":
+    _platform = 'osx'
+elif __platform == "win32":
+    _platform = 'win'
+
+
+def frames_to_tc(total_frames, frame_rate):
+    fps_int = int(round(frame_rate))
+    smpte_token = ":"
+    hours = int(total_frames / (3600 * fps_int))
+    minutes = int(total_frames / (60 * fps_int) % 60)
+    seconds = int(total_frames / fps_int % 60)
+    frames = int(total_frames % fps_int)
+    return "%02d:%02d:%02d%s%02d" % (hours, minutes, seconds, smpte_token, frames)
+
+def terminal_render():
+    parser = argparse.ArgumentParser(description='Render from Nuke to ffmpeg.')
+    parser.add_argument("nuke_script",
+                        help="Nuke script to render.")
+    parser.add_argument("-X", "--write",
+                        help="Name of the WriteFFMPEG node to render.")
+    parser.add_argument("-F", "--framerange",
+                        help="framerange to render. Please specify <start>-<end>.",
+                        required=False)
+    parser.add_argument("-o", "--output",
+                        help="Output qt to render to. Will use the value of the file knob on the WriteFFMPEG node if not specified.",
+                        required=False)
+    args = parser.parse_args()
+    nuke_script = args.nuke_script
+    nuke.scriptOpen(nuke_script)
+    node = nuke.toNode(args.write)
+    node.begin()
+    write = nuke.toNode('write_tmp')
+    if args.framerange and "-" in args.framerange:
+        fr = nuke.FrameRange()
+        fr.setLast(int(args.framerange.split('-')[-1]))
+        fr.setFirst(int(args.framerange.split('-')[0]))
+    else:
+        node_framerange = node['framerange'].getValue()
+        if node_framerange and "-" in node_framerange:
+            fr = nuke.FrameRange()
+            fr.setLast(int(node_framerange.split('-')[-1]))
+            fr.setFirst(int(node_framerange.split('-')[0]))
+        else:
+            fr = node.frameRange()
+
+    tmpimg = tempfile.mkstemp('.tiff', "ffmpeg_temp_")[1]
+    if _platform == 'win':
+        write['file'].setValue(tmpimg.replace("\\","/"))
+    else:
+        write['file'].setValue(tmpimg)
+    framerate = node['framerate'].getValue()
+    output = node['file'].getValue()
+
+    # create folder if necessary
+    dir = os.path.dirname(output)
+    osdir = nuke.callbacks.filenameFilter(dir)
+    try:
+        os.makedirs(osdir)
+    except OSError:
+        pass
+
+    tc = frames_to_tc(fr.first(), framerate)
+    ffmpeg_args = "ffmpeg -hide_banner -loglevel info -y \
+        -f rawvideo -pixel_format rgb48le -video_size {0}x{1} \
+        -framerate {2} -i pipe:0 -timecode {3} {4} {5}".format(
+            node.width(), node.height(), framerate, tc,
+            node['ffmpeg_args'].getValue(), output)
+    print(ffmpeg_args)
+    ffproc = subprocess.Popen(
+        shlex.split(ffmpeg_args),
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE
+        )
+    for i, f in enumerate(fr):
+        nuke.execute(write, f, f)
+        print("Rendering frame \t{0} of {1}".format(i, fr.frames()))
+        # tifffile usage
+        img = tifffile.imread(tmpimg)
+        # numpy usage
+        img.tofile(ffproc.stdin)
+
+    if _platform == 'win':
+        try:
+            os.remove(tmpimg.replace("\\","/"))
+        except:
+            pass
+    else:
+        try:
+            os.remove(tmpimg)
+        except:
+            pass
+    result, error = ffproc.communicate()
+    print("Rendering done.")
+
+if __name__=="__main__":
+    terminal_render()
+
+
+def prep():
+    nuke.scriptSave()
+    node = nuke.thisNode()
+    ffpy = __file__
+    ffpy = ffpy.replace('pyc', 'py')
+    node_framerange = node['framerange'].getValue()
+
+    nk_cmd = "{0} -t {1} {2} --write {3} --output {4}".format(
+        "\"" + nuke.EXE_PATH + "\"",
+        ffpy,
+        nuke.root().knob("name").value(),
+        node.fullName(),
+        node['file'].getValue())
+    print("RENDER COMMAND:\n\t{0}".format(nk_cmd))
+    if _platform == "win":
+        print (os.system(nk_cmd))
+        return
+    if _platform == "osx":
+        cmd = '''osascript 2>/dev/null <<EOF
+                tell application "Terminal"
+                  if not (exists window 1) then reopen
+                  activate
+                  do script "{0}"
+                end tell
+                EOF'''.format(nk_cmd)
+    elif _platform == "linux":
+        # cmd = 'xterm -e "bash {0}"'.format(nk_cmd)
+        cmd = 'gnome-terminal -e "bash -c \\"{0}; exec bash\\""'.format(nk_cmd)
+        #cmd = 'gnome-terminal -e "bash -c \\"{0}\\""'.format(nk_cmd)
+    subprocess.Popen(cmd, shell=True)