2021-07-02

channelSelect. Added additional 'pattern_exclude' knob to always exclude aovs like *variance, P, N etc.
channelSelect. Added unpremult option and additional grading possibilities.
channelSelect. Internal shuffle nodes are now labelled with the resolved channel name.
Denoise with noice. Fixed issue with large number of aovs.
Gimmicks. Added BalanceGrade and CalibrateMacbeth.

README.md

 
 ##### Changelog:
 
+
+
+`2021-07-02`
+
+`channelSelect. Added additional 'pattern_exclude' knob to always exclude aovs like *variance, P, N etc.`
+
+`channelSelect. Added unpremult option and additional grading possibilities.`
+
+`channelSelect. Internal shuffle nodes are now labelled with the resolved channel name.`
+
+`Denoise with noice. Fixed issue with large number of aovs.`
+
+`Gimmicks. Added BalanceGrade and CalibrateMacbeth.`
+
+
+`__________`
+
 `2021-06-18`
 
 `sceneControl. Fixed issue if element is not set.`
 
 `Denoise with noice. Initial version.`
 
-`ocio config, image formats, fps and favorites are set from KEnv project_config.py.`
+`ocio config, image formats, fps and favorites are set from KEnv project_config.py.`
+
+

gimmicks/Gimmicks/_gen/BalanceGrade.gimmick

+set cut_paste_input [stack 0]
+version 12.2 v5
+push $cut_paste_input
+Group {
+ name BalanceGrade3
+ tile_color 0x6c9de1ff
+ selected true
+ xpos -641
+ ypos 75
+ addUserKnob {20 BalanceGrade}
+ addUserKnob {26 ColorMatrix_label l "@b;ColorMatrix" T " "}
+ addUserKnob {41 matrix T ColorMatrix.matrix}
+ addUserKnob {22 reset_mtx l Reset T "nuke.thisNode()\['matrix'].setValue(\[1,0,0,0,1,0,0,0,1])" +STARTLINE}
+ addUserKnob {26 ""}
+ addUserKnob {26 match_label l "@b;Match" T ""}
+ addUserKnob {18 matchsrc l "src color"}
+ matchsrc 0.18
+ addUserKnob {6 matchsrc_panelDropped l "panel dropped state" -STARTLINE +HIDDEN}
+ addUserKnob {18 matchdst l "dst color"}
+ matchdst 0.18
+ addUserKnob {6 matchdst_panelDropped l "panel dropped state" -STARTLINE +HIDDEN}
+ addUserKnob {18 blackpoint t "this value will be subtracted from the offset"}
+ blackpoint {0 0 0}
+ addUserKnob {6 blackpoint_panelDropped l "panel dropped state" -STARTLINE +HIDDEN}
+ addUserKnob {22 set_blackpoint l "Set Blackpoint" t "Set blackpoint based on selected region in the viewer. If preserve luminance is checked, the rgb will be balanced but the overall luminance will not be changed." T "node = nuke.thisNode()\nblackpoint_preserve_luminance = node\['blackpoint_preserve_luminance'].getValue()\nnuke.root().begin()\n\n# Get viewer and connected node to calculate format resolution\nviewer = nuke.activeViewer().node()\nif viewer.input(0):\n    viewed_node = viewer.input(0)\n    if not nuke.selectedNodes():\n        viewed_node.setSelected(1)\nelse:\n    viewed_node = nuke.activeViewer().node()\n\n# Get selected sample area\nbboxinfo = nuke.activeViewer().node()\['colour_sample_bbox'].value()\naspect = float(viewed_node.width() * viewed_node.pixelAspect()) / float(viewed_node.height())\ncornerA = \[(bboxinfo\[0]*0.5+0.5) * viewed_node.width(), (((bboxinfo\[1] * 0.5) + (0.5/aspect)) * aspect) * viewed_node.height()]\ncornerB = \[(bboxinfo\[2]*0.5+0.5) * viewed_node.width(), (((bboxinfo\[3] * 0.5) + (0.5/aspect)) * aspect) * viewed_node.height()]\narea = \[cornerB\[0] - cornerA\[0], cornerB\[1] - cornerA\[1]]\ncenter = \[cornerA\[0] + (area\[0]/2), cornerA\[1] + (area\[1] / 2)]\n\n# Reset blackpoint and add knob\nnode\['blackpoint'].setValue(\[0, 0, 0])\nadd_value = node\['add'].getValue()\nnode\['add'].setValue(\[0, 0, 0])\n\n# Sample input colors within box\ncolor_sample = \[node.sample('rgba.red', center\[0], center\[1], area\[0], area\[1]), node.sample('rgba.green', center\[0], center\[1], area\[0], area\[1]), node.sample('rgba.blue', center\[0], center\[1], area\[0], area\[1])]\n\nif blackpoint_preserve_luminance:\n    # calculate average luminance with rec709 weighting\n    average_luminance = color_sample\[0]*0.2126 + color_sample\[1]*0.7152 + color_sample\[2]*0.0722\n    color_sample = \[v - average_luminance for v in color_sample]\n\n# Set blackpoint to sampled value\nnode\['blackpoint'].setValue(color_sample)\nnode\['add'].setValue(add_value)\n" +STARTLINE}
+ addUserKnob {6 blackpoint_preserve_luminance l "preserve luminance" t "Try not to shift luminance of the blackpoint when sampling, only shift the color to be neutral." -STARTLINE}
+ blackpoint_preserve_luminance true
+ addUserKnob {22 reset_match l Reset T "n = nuke.thisNode()\nn\['blackpoint'].setValue(\[0, 0, 0])\nn\['add'].setValue(\[0, 0, 0])\nn\['matchsrc'].setValue(0.18)\nn\['matchdst'].setValue(0.18)" +STARTLINE}
+ addUserKnob {26 grade_label l "@b; Grade" T " "}
+ addUserKnob {7 exposure t "Adjust exposure in stops" R -4 4}
+ addUserKnob {6 exposure_panelDropped l "panel dropped state" -STARTLINE +HIDDEN}
+ addUserKnob {18 multiply R 0 4}
+ multiply {1 1 1}
+ addUserKnob {6 multiply_panelDropped l "panel dropped state" -STARTLINE +HIDDEN}
+ addUserKnob {18 add R -0.25 0.25}
+ add {0 0 0}
+ addUserKnob {6 add_panelDropped l "panel dropped state" -STARTLINE +HIDDEN}
+ addUserKnob {22 reset_grade l Reset T "n = nuke.thisNode()\nn\['exposure'].setValue(0)\nn\['multiply'].setValue(\[1, 1, 1])\nn\['add'].setValue(\[0, 0, 0])" +STARTLINE}
+ addUserKnob {26 ""}
+ addUserKnob {6 invert t "Invert the color transform." +STARTLINE}
+ addUserKnob {41 export_cc l "Export CC" T OCIOCDLTransform.export_cc}
+ addUserKnob {22 export_spimtx l "Export spimtx" t "Export spimtx format describing the balancegrade.\n\nSupports saturation, primaries multiply, offset." T "from __future__ import print_function\nfrom __future__ import with_statement\nimport nuke\n\ndef mtx_mult(a, b):\n    # multiply two 3x3 matrices and return the result\n    a = \[a\[0:3], a\[3:6], a\[6:9]]\n    b = \[b\[0:3], b\[3:6], b\[6:9]]\n    c = \[\[sum(a * b for a, b in zip(a_row, b_col)) for b_col in zip(*b)] for a_row in a]\n    return c\[0] + c\[1] + c\[2]\n\ndef export_spimtx(output_path=None):\n    # export an spimtx file given the color transformations specified on the balancegrade node.\n    node = nuke.thisNode()\n    nuke.root().begin()\n    spimtx_calibration_only = node\['spimtx_calibration_only'].getValue()\n\n    if not output_path:\n        output_path = nuke.getFilename('output_path')\n    if not output_path:\n        print('Error: no output path specified. Exiting...')\n        return\n\n    with node:\n        cdltransform = nuke.toNode('OCIOCDLTransform')\n    \n    mtx = node\['matrix'].getValue()\n\n    if spimtx_calibration_only:\n        dst_mtx = mtx\n        offset = \[0, 0, 0]\n        slope = \[1, 1, 1]\n    else:\n        offset = cdltransform\['offset'].getValue()\n        slope = cdltransform\['slope'].getValue()\n        mult_mtx = \[slope\[0], 0, 0, 0, slope\[1], 0, 0, 0, slope\[2]]\n        dst_mtx = mtx_mult(mult_mtx, mtx)\n\n    output_spimtx_string = '\{0\} \{1\} \{2\} \{3\} \{4\} \{5\} \{6\} \{7\} \{8\} \{9\} \{10\} \{11\}'.format(\n        dst_mtx\[0],\n        dst_mtx\[1],\n        dst_mtx\[2],\n        int(round(offset\[0] * 65535)),\n        dst_mtx\[3],\n        dst_mtx\[4],\n        dst_mtx\[5],\n        int(round(offset\[1] * 65535)),\n        dst_mtx\[6],\n        dst_mtx\[7],\n        dst_mtx\[8],\n        int(round(offset\[2] * 65535))\n        )\n\n    # Create spimtx file\n    spimtx_file = open(output_path, 'w+')\n    spimtx_file.write(output_spimtx_string)\n    spimtx_file.close()\n\n\nif __name__=='__main__':\n    export_spimtx()" +STARTLINE}
+ addUserKnob {6 spimtx_calibration_only l "calibration only" t "only export the colormatrix calibration to the spimtx file. \n\notherwise export the entire balancegrade to the spimtx file." -STARTLINE}
+}
+ Input {
+  inputs 0
+  name Input
+  xpos -370
+  ypos -562
+ }
+ Dot {
+  name Dot1
+  label " "
+  note_font "Helvetica Bold"
+  note_font_size 24
+  note_font_color 0xa5a5a501
+  xpos -336
+  ypos -486
+ }
+set N55320800 [stack 0]
+ OCIOCDLTransform {
+  slope {{parent.OCIOCDLTransform.slope} {parent.OCIOCDLTransform.slope} {parent.OCIOCDLTransform.slope}}
+  offset {{parent.OCIOCDLTransform.offset} {parent.OCIOCDLTransform.offset} {parent.OCIOCDLTransform.offset}}
+  direction inverse
+  working_space scene_linear
+  name OCIOCDLTransform_inverse
+  xpos -260
+  ypos -442
+ }
+ ColorMatrix {
+  matrix {
+      {{parent.ColorMatrix.matrix} {parent.ColorMatrix.matrix} {parent.ColorMatrix.matrix}}
+      {{parent.ColorMatrix.matrix} {parent.ColorMatrix.matrix} {parent.ColorMatrix.matrix}}
+      {{parent.ColorMatrix.matrix} {parent.ColorMatrix.matrix} {parent.ColorMatrix.matrix}}
+    }
+  invert true
+  name ColorMatrix_invert
+  xpos -260
+  ypos -370
+ }
+push $N55320800
+ ColorMatrix {
+  matrix {
+      {1 0 0}
+      {0 1 0}
+      {0 0 1}
+    }
+  name ColorMatrix
+  xpos -370
+  ypos -442
+ }
+ OCIOCDLTransform {
+  slope {{"matchdst/matchsrc*pow(2, exposure)*multiply"} {"matchdst/matchsrc*pow(2, exposure)*multiply"} {"matchdst/matchsrc*pow(2, exposure)*multiply"}}
+  offset {{"parent.add - parent.blackpoint"} {"parent.add - parent.blackpoint"} {"parent.add - parent.blackpoint"}}
+  working_space scene_linear
+  name OCIOCDLTransform
+  xpos -370
+  ypos -370
+ }
+ Switch {
+  inputs 2
+  which {{parent.invert}}
+  name Switch_inverse
+  xpos -370
+  ypos -274
+ }
+ Output {
+  name Output
+  xpos -370
+  ypos -202
+ }
+end_group
+# Creation Time=Mon Jun 28 09:30:30 2021
+# Creator=Martin

pythonplugins/_default_configs/projectDefaults.py

         # set viewer
         # viewer is set via config.ocio: active_views: [P3D65 Rec.709 Limited, sRGB, DCDM, DCDM P3D60 Limited..]
 
+        # Write
+        nuke.knobDefault("Write.channels", "rgba")
+        nuke.knobDefault("Write.dpx.channels", "rgb")
+        nuke.knobDefault("Write.create_directories", "1")
+        nuke.knobDefault("Write.exr.noprefix", "1")
+        nuke.knobDefault("Write.exr.metadata", "all metadata")
 
     def unconfigurePlugin(self):
         pass

pythonpluginsUI/ChannelSelect/ChannelSelect.py

 __version__ = '1.0'
 
 MODES = ['MergeBackIntoStream','SelectOnly', 'ContactSheet']
-PATTERNDEFAULT = "*direct* !*indirect* !*default"
+#PATTERNDEFAULT = "*direct* !*indirect* !*default"
+PATTERNDEFAULT = ""
+PATTERNIGNORE = "*variance *denoise* *matte* P N Z rgba albedo"
 INIT_DONE = False
 
 class ChannelSelect(KellerNukePlugin):
         m = self.menu.addMenu('Workgroup','Toolbar_Workgroup.png')
         m.addCommand('ChannelSelect', 'import ChannelSelect; ChannelSelect.createChannelSelect()',  icon=':qrc/images/ToolbarChannel.png')
         nuke.addKnobChanged(onKnobChanged)
+        nuke.addOnCreate(onCreate, nodeClass=('Group'))
 
     def unconfigurePlugin(self):
         self.menu.removeItem('ChannelSelect')
         nuke.removeKnobChanged(onKnobChanged)
+        nuke.removeOnCreate(onCreate)
         pass
 
 
 
     k = nuke.thisKnob()
     # do a refresh on these knobs
-    refresh_resolved = ['pattern','update']
+    refresh_resolved = ['pattern', 'pattern_exclude', 'update']
 
     if k.name() in refresh_resolved:
         print('ChannelSelect: Info. Event refresh triggered.')
         n = nuke.thisNode()
 
         pattern = n['pattern'].value()
-        resolved = resolvePattern(n, pattern)
+        pattern_exclude = n['pattern_exclude'].value()
+        resolved = resolvePattern(n, pattern, pattern_exclude)
         if resolved:
             resString = '\n'.join(resolved)
 
         pass
 
 
+def onCreate():
+    print('ChannelSelect: Info. On Create refresh triggered.')
+    n = nuke.thisNode()
+    # % (r * 255, g * 255, b * 255, 1), 16): change r g and b to your liking
+    hexColour = int('%02x%02x%02x%02x' % (0 * 255, 0 * 255, 0 * 255, 1), 16)
+    n['tile_color'].setValue(hexColour)
+
+
+
 def createChannelSelect():
     # get selected Node (for connecting our node below)
     try:
         n.setXYpos(s.xpos(), s.ypos() + 100)
 
     # tab ChannelSelect
-    k = nuke.Tab_Knob('select', 'Select')
+    k = nuke.Tab_Knob('select', 'select')
     n.addKnob(k)
 
     # Pattern
-    k = nuke.EvalString_Knob('pattern', 'Pattern')
+    k = nuke.EvalString_Knob('pattern', 'pattern')
     n.addKnob(k)
     n.knob('pattern').setTooltip('*diffuse* *SSS*\nwith exclude (! or ^):\n*direct* !*indirect*')
     n.knob('pattern').setValue(PATTERNDEFAULT)
     n.addKnob(k)
     n.knob('update').setTooltip('Creates Nodes in Group based on Search Pattern')
 
+    # Pattern
+    k = nuke.EvalString_Knob('pattern_exclude', 'exclude')
+    n.addKnob(k)
+    n.knob('pattern_exclude').setTooltip('always exclude this pattern')
+    n.knob('pattern_exclude').setValue(PATTERNIGNORE)
+
     # Resolved Channels
-    k = nuke.Multiline_Eval_String_Knob('resolved', 'Resolved')
+    k = nuke.Multiline_Eval_String_Knob('resolved', 'preview')
     n.addKnob(k)
-    n.knob('resolved').setTooltip('These AOVs are found based on your search Pattern above')
+    n.knob('resolved').setTooltip('These AOVs are found based on your search Pattern above. Press Set to use these aovs.')
+
+    # Divide and Conquer
+    k = nuke.Text_Knob('divider', '')
+    n.addKnob(k)
+
+    # unpremult
+    k = nuke.Boolean_Knob('unpremult', 'unpremult')
+    n.addKnob(k)
+    n.knob('unpremult').setValue(True)
+    n.knob('unpremult').setFlag(nuke.STARTLINE)
+
+    # Divide and Conquer
+    k = nuke.Text_Knob('divider', '')
+    n.addKnob(k)
+
+    # Saturation
+    k = nuke.Double_Knob('saturation', 'saturation')
+    n.addKnob(k)
+    n.knob('saturation').setRange(0,1)
+    n.knob('saturation').setValue(1)
 
     # Divide and Conquer
     k = nuke.Text_Knob('divider', '')
     n.addKnob(k)
 
     # Exposure
-    k = nuke.Double_Knob('exposure', 'Exposure')
+    k = nuke.Double_Knob('exposure', 'exposure')
     n.addKnob(k)
     n.knob('exposure').setRange(-2,2)
 
+    # Divide and Conquer
+    k = nuke.Text_Knob('divider', '')
+    n.addKnob(k)
+
+    # Blackpoint
+    k = nuke.Color_Knob('blackpoint', 'blackpoint')
+    n.addKnob(k)
+    n.knob('blackpoint').setRange(-1,1)
+    n.knob('blackpoint').setValue([0, 0, 0])
+
+    # Whitepoint
+    k = nuke.Color_Knob('whitepoint', 'whitepoint')
+    n.addKnob(k)
+    n.knob('whitepoint').setRange(0,4)
+    n.knob('whitepoint').setValue(1)
+    n.knob('whitepoint').setValue([1, 1, 1])
+
+    # Lift
+    k = nuke.Color_Knob('black', 'lift')
+    n.addKnob(k)
+    n.knob('black').setRange(-1,1)
+    n.knob('black').setValue([0, 0, 0])
+
     # Multiply
-    k = nuke.Color_Knob('multiply', 'Multiply')
+    k = nuke.Color_Knob('multiply', 'multiply')
     n.addKnob(k)
     n.knob('multiply').setValue([1, 1, 1])
+    n.knob('multiply').setRange(0, 4)
 
     # Gamma
-    k = nuke.Double_Knob('gamma', 'Gamma')
+    k = nuke.Double_Knob('gamma', 'gamma')
     n.addKnob(k)
     n.knob('gamma').setValue(1)
     n.knob('gamma').setRange(0.2, 2)
 
     # Compensate Mult
-    k = nuke.Boolean_Knob('compensate', 'Compensate Mult')
+    k = nuke.Boolean_Knob('compensate', 'compensate mult')
     n.addKnob(k)
     n.knob('compensate').setValue(True)
     n.knob('compensate').setFlag(nuke.STARTLINE)
 
     # Reset Values
-    k = nuke.PyScript_Knob('reset', 'Reset', 'ChannelSelect.resetValues(nuke.thisNode())')
+    k = nuke.PyScript_Knob('reset', 'reset', 'ChannelSelect.resetValues(nuke.thisNode())')
     n.addKnob(k)
     n.knob('reset').setTooltip('Reset Color Correct values')
     n.knob('reset').setFlag(nuke.STARTLINE)
     n.addKnob(k)
 
     # Mode
-    k = nuke.Enumeration_Knob('mode', 'Mode', MODES)
+    k = nuke.Enumeration_Knob('mode', 'mode', MODES)
     n.addKnob(k)
     k.setTooltip('MergeBackIntoStream: Shuffles the resolved aovs, applies the grading options and merges the result back to main comp stream\n\nSelectOnly: Just shuffles the resolved aovs and adds them together.\n\nLayerContactSheet: Displays the LayerContactSheet with layer names. Note. You need to Press Set in order for this to work. An empty Pattern is possible')
     n.knob('mode').clearFlag(nuke.STARTLINE)
     # refresh again
     n.knob('pattern').setValue('*key*')
     n.knob('pattern').setValue(PATTERNDEFAULT)
+    tmp = n.knob('resolved').getValue()
 
     global INIT_DONE
     INIT_DONE = True
 
 def resetValues(n):
     n['exposure'].setValue(0)
+    n['blackpoint'].setValue(0)
+    n['whitepoint'].setValue(1)
+    n['saturation'].setValue(1)
+    n['black'].setValue(0)
     n['multiply'].setValue([1, 1, 1])
     n['gamma'].setValue(1)
     n['compensate'].setValue(True)
 
 
-def resolvePattern(n, pattern):
+def resolvePattern(n, pattern, pattern_exclude):
     if pattern == "":
         return None
 
 
     matchChannels = []
     ignoreChannels = []
+    ignoreChannels2 = []
+
+    # pattern
     for p in pattern.split(' '):
         matchChannels += (fnmatch.filter(layers, p))
         # excludes
         if p[0] == '!' or p[0] == '^':
             ignoreChannels += (fnmatch.filter(layers, p[1:]))
 
-    matchChannels = list(set(matchChannels) - set(ignoreChannels))
+    # pattern exclude
+    for p in pattern_exclude.split(' '):
+        ignoreChannels2 += (fnmatch.filter(layers, p))
+
+    matchChannels = list(set(matchChannels) - set(ignoreChannels) - set(ignoreChannels2))
     matchChannels.sort()
+
     return matchChannels
 
 
 
     # n = node
     pattern = n['pattern'].value()
-    resolved = resolvePattern(n, pattern)
+    pattern_exclude = n['pattern_exclude'].value()
+    resolved = resolvePattern(n, pattern,pattern_exclude)
 
     # create nodes
     # input and output of Group
 
     # delete old nodes
     g = nuke.toNode(n.name())
-    oldNodes = [i for i in g.nodes() if '__' in i['name'].value()]
+    #oldNodes = [i for i in g.nodes() if '__' in i['name'].value()]
+    oldNodes = [i for i in g.nodes() if '__' in i['label'].value()]
 
     for node in oldNodes:
         nuke.delete(node)
     # dot input
     dot_input = nuke.nodes.Dot(xpos=input.xpos() , ypos=input.ypos()+100)
     dot_input['name'].setValue('dot_input__')
-    dot_input['label'].setValue('[value name]')
+    dot_input['label'].setValue('dot_input__')
     #dot_input['note_font_size'].setValue(25)
     # connect to the input1 node
 
     # dot input 2
     dot_input2 = nuke.nodes.Dot(xpos=dot_input.xpos()+1500 , ypos=dot_input.ypos())
     dot_input2['name'].setValue('dot_input2__')
-    dot_input2['label'].setValue('[value name]')
+    dot_input2['label'].setValue('dot_input2__')
     #dot_input2['note_font_size'].setValue(25)
     # connect to the input1 node
 
+    # unpremult
+    unpremult = nuke.nodes.Unpremult(xpos=dot_input.xpos()+700 , ypos=dot_input.ypos() )
+    #unpremult['name'].setValue('unpremult_node__')
+    unpremult['label'].setValue('unpremult__')
+
     # dot resolved
     dot_resolved = nuke.nodes.Dot(xpos=dot_input.xpos() , ypos=dot_input.ypos() + V_OFFSET)
     dot_resolved['name'].setValue('dot_resolved__')
-    dot_resolved['label'].setValue('[value name]')
+    dot_resolved['label'].setValue('dot_resolved__')
     #dot_resolved['note_font_size'].setValue(25)
 
     # dot resolved2
     dot_resolved2 = nuke.nodes.Dot(xpos=dot_resolved.xpos() - 100, ypos=dot_resolved.ypos())
     dot_resolved2['name'].setValue('dot_resolved2__')
-    dot_resolved2['label'].setValue('[value name]')
+    dot_resolved2['label'].setValue('dot_resolved2__')
     #dot_resolved2['note_font_size'].setValue(25)
 
     # dot resolved3
     dot_resolved3 = nuke.nodes.Dot(xpos=dot_resolved2.xpos(), ypos=dot_resolved.ypos() + V_OFFSET)
     dot_resolved3['name'].setValue('dot_resolved3__')
-    dot_resolved3['label'].setValue('[value name]')
+    dot_resolved3['label'].setValue('dot_resolved3__')
     #dot_resolved3['note_font_size'].setValue(25)
 
     # merge from
     merge_from = nuke.nodes.Merge2(xpos=dot_input.xpos()+500 , ypos=dot_input.ypos() )
+    merge_from['operation'].setValue("merge_from__")
     merge_from['name'].setValue('merge_from__')
-    merge_from['operation'].setValue("from")
+    merge_from['label'].setValue('merge_from__')
 
     # exposure
     exposure = nuke.nodes.EXPTool(xpos=dot_resolved.xpos() , ypos=dot_resolved.ypos() + V_OFFSET)
     exposure['name'].setValue('exposure__')
+    exposure['label'].setValue('exposure__')
 
     # grade
     grade = nuke.nodes.Grade(xpos=exposure.xpos() , ypos=exposure.ypos() + V_OFFSET)
     grade['name'].setValue('grade__')
+    grade['label'].setValue('grade__')
+
+    # saturation
+    saturation = nuke.nodes.Saturation(xpos=grade.xpos() , ypos=exposure.ypos() + V_OFFSET)
+    saturation['name'].setValue('saturation__')
+    saturation['label'].setValue('saturation__')
 
     # merge plus
-    merge_plus = nuke.nodes.Merge2(xpos=grade.xpos() , ypos=grade.ypos() + V_OFFSET)
+    merge_plus = nuke.nodes.Merge2(xpos=saturation.xpos() , ypos=saturation.ypos() + V_OFFSET)
     merge_plus['operation'].setValue("plus")
     merge_plus['name'].setValue('merge_plus__')
+    merge_plus['label'].setValue('merge_plus__')
 
     # dot input From
     dot_input_from = nuke.nodes.Dot(xpos=merge_from.xpos() , ypos=merge_plus.ypos())
     dot_input_from['name'].setValue('dot_input_from__')
-    dot_input_from['label'].setValue('[value name]')
+    dot_input_from['label'].setValue('dot_input_from__')
     #dot_input_from['note_font_size'].setValue(25)
 
     # contact_sheet_all
     contact_sheet_all = nuke.nodes.LayerContactSheet(xpos=merge_plus.xpos() +250 , ypos=merge_plus.ypos() + 200)
     contact_sheet_all['name'].setValue('contact_sheet__')
+    contact_sheet_all['label'].setValue('contact_sheet__')
 
     # switch
     switch = nuke.nodes.Switch(xpos=merge_plus.xpos() , ypos=merge_plus.ypos() + V_OFFSET)
     switch['name'].setValue('switch__')
+    switch['label'].setValue('switch__')
+
+    # premult
+    premult = nuke.nodes.Premult(xpos=switch.xpos()+50 , ypos=switch.ypos() )
+    #premult['name'].setValue('premult_node__')
+    premult['label'].setValue('premult_node__')
 
     # dot output
     dot_output = nuke.nodes.Dot(xpos=dot_input.xpos() , ypos=dot_input.ypos() + V_OFFSET)
     dot_output['name'].setValue('dot_output__')
-    dot_output['label'].setValue('[value name]')
+    dot_output['label'].setValue('dot_output__')
     #dot_output['note_font_size'].setValue(25)
 
     # create new nodes
                 shuffle['in2'].setValue('rgba')
                 shuffle['out'].setValue('rgb')
                 shuffle['name'].setValue('shuffle__' + str(i))
+                # set label of aov
+                shuffle['label'].setValue(resolved[i - 1] + '__')
                 # connect to the dot dot_input
                 shuffle.setInput(0, dot_input)
 
                     merge_resolved = nuke.nodes.Merge2(xpos=dot_input.xpos(), ypos=dot_output.ypos() + 50)
                     merge_resolved['operation'].setValue("plus")
                     merge_resolved['name'].setValue("merge_resolved__")
+                    merge_resolved['label'].setValue("merge_resolved__")
 
                 # connect plus
                 # skip Mask Input
                 j += 1
 
             # connect to the input1 node
-            dot_resolved.setInput(0, merge_resolved)
+            unpremult.setInput(0,merge_resolved)
+            dot_resolved.setInput(0, unpremult)
 
     else:
         # shuffle
         shuffle['in2'].setValue('none')
         shuffle['out'].setValue('rgb')
         shuffle['name'].setValue('shuffle_empty__')
+        shuffle['label'].setValue('shuffle_empty__')
 
         shuffle.setInput(0, dot_input)
 
         # connect to the input1 node
         dot_resolved.setInput(0, shuffle)
 
-
     # connect the nodes
     dot_input.setInput(0, input)
     dot_input2.setInput(0, dot_input)
     dot_input_from.setInput(0, merge_from)
     dot_resolved2.setInput(0, dot_resolved)
     dot_resolved3.setInput(0, dot_resolved2)
-    merge_plus.setInput(1, grade)
+    merge_plus.setInput(1, saturation)
     merge_plus.setInput(0, dot_input_from)
     grade.setInput(0, exposure)
+    saturation.setInput(0, grade)
     exposure.setInput(0, dot_resolved)
     merge_from.setInput(0, dot_input2)
     merge_from.setInput(1, dot_resolved)
     contact_sheet_all.setInput(0, dot_input2)
-    switch.setInput(0, merge_plus)
+    switch.setInput(0, premult)
     switch.setInput(1, contact_sheet_all)
     switch.setInput(2, dot_resolved3)
+    premult.setInput(0,merge_plus)
     dot_output.setInput(0,switch)
     output.setInput(0, dot_output)
 
     exposure['red'].setExpression('parent.exposure')
     exposure['green'].setExpression('parent.exposure')
     exposure['blue'].setExpression('parent.exposure')
-    # init
+    unpremult['disable'].setExpression('parent.unpremult == 1 ? 0 :1')
+    premult['disable'].setExpression('parent.unpremult == 1 ? 0 :1')
+
     grade['multiply'].setValue([1,1,1,1])
     grade['multiply'].setExpression('parent.multiply.r',0)
     grade['multiply'].setExpression('parent.multiply.g',1)
     grade['multiply'].setExpression('parent.multiply.b',2)
-    grade['multiply'].setValue(1, 3)
-    # enable Compensate Mult by default
+
+    grade['blackpoint'].setValue([0,0,0,0])
+    grade['blackpoint'].setExpression('parent.blackpoint.r',0)
+    grade['blackpoint'].setExpression('parent.blackpoint.g',1)
+    grade['blackpoint'].setExpression('parent.blackpoint.b',2)
+
+    grade['whitepoint'].setValue([1,1,1,1])
+    grade['whitepoint'].setExpression('parent.whitepoint.r',0)
+    grade['whitepoint'].setExpression('parent.whitepoint.g',1)
+    grade['whitepoint'].setExpression('parent.whitepoint.b',2)
+
+    grade['black'].setValue([0,0,0,0])
+    grade['black'].setExpression('parent.black.r',0)
+    grade['black'].setExpression('parent.black.g',1)
+    grade['black'].setExpression('parent.black.b',2)
+
+    grade['white'].setValue([1, 1, 1, 1])
     grade['white'].setExpression('parent.compensate == 1 ? 1/((parent.multiply.r+parent.multiply.g+parent.multiply.b)/3) : 1')
+    #grade['white'].setExpression(['parent.compensate == 1 ? 1/((parent.multiply.r+parent.multiply.g+parent.multiply.b)/3) : 1,parent.compensate == 1 ? 1/((parent.multiply.r+parent.multiply.g+parent.multiply.b)/3) : 1,parent.compensate == 1 ? 1/((parent.multiply.r+parent.multiply.g+parent.multiply.b)/3) : 1,1'])
     grade['gamma'].setExpression('parent.gamma')
+
+    saturation['saturation'].setExpression('parent.saturation')
+
     contact_sheet_all['width'].setExpression('parent.width')
     contact_sheet_all['height'].setExpression('parent.height')
     contact_sheet_all['showLayerNames'].setValue(1)
     switch['which'].setExpression('parent.mode == 0 ? 0 :(parent.mode == 1 ? 2 : 1)')
 
     # arrange the nodes
-    weird_dot_offset = 0
-    dot_input.setXYpos(input.xpos()+weird_dot_offset, input.ypos() + 100)
+    dot_input.setXYpos(input.xpos(), input.ypos() + 100)
     if merge_resolved:
         merge_resolved.setXYpos(input.xpos(), input.ypos() + 350)
-    dot_resolved.setXYpos(input.xpos()+weird_dot_offset, input.ypos() + 500)
-    dot_resolved2.setXYpos(dot_resolved.xpos()-250+weird_dot_offset, dot_resolved.ypos())
-    dot_resolved3.setXYpos(dot_resolved2.xpos()+weird_dot_offset, dot_resolved2.ypos() + 500)
+        unpremult.setXYpos(merge_resolved.xpos(), merge_resolved.ypos() + 75)
+
+    dot_resolved.setXYpos(input.xpos(), input.ypos() + 500)
+    dot_resolved2.setXYpos(dot_resolved.xpos()-250, dot_resolved.ypos())
+    dot_resolved3.setXYpos(dot_resolved2.xpos(), dot_resolved2.ypos() + 500)
     exposure.setXYpos(dot_resolved.xpos(), dot_resolved.ypos()+150)
     grade.setXYpos(exposure.xpos(), exposure.ypos() + 150)
-    merge_plus.setXYpos(grade.xpos(), grade.ypos() + 150)
-    switch.setXYpos(merge_plus.xpos(), merge_plus.ypos() + 150)
-    dot_output.setXYpos(switch.xpos()+weird_dot_offset, switch.ypos() + 150)
+    saturation.setXYpos(grade.xpos(), grade.ypos() + 150)
+    merge_plus.setXYpos(saturation.xpos(), saturation.ypos() + 150)
+    premult.setXYpos(merge_plus.xpos(), merge_plus.ypos() + 75)
+    switch.setXYpos(premult.xpos(), premult.ypos() + 150)
+    dot_output.setXYpos(switch.xpos(), switch.ypos() + 150)
     output.setXYpos(dot_output.xpos(), dot_output.ypos() + 150)
     merge_from.setXYpos(dot_input2.xpos(), dot_resolved.ypos())
-    dot_input_from.setXYpos(merge_from.xpos()+weird_dot_offset, merge_plus.ypos())
+    dot_input_from.setXYpos(merge_from.xpos(), merge_plus.ypos())
 
     n['label'].setValue('[value pattern]')
     return None

pythonpluginsUI/denoice/denoice.py

 # GLOBALS
 #
 #######################################################################################
-DISABLE_AOVS = ['default', 'variance', 'Matte', 'matte', 'Crypto', 'crypto', 'denoise_albedo']
+DISABLE_AOVS = ['albedo', 'default', 'variance', 'Matte', 'matte', 'Crypto', 'crypto', 'denoise_albedo', 'P', 'N', 'Z']
 # Muster
 MSTRSERVER = "192.168.0.251"
 SUBMISSION_USER ="admin"
         self.addKnob(self.div5)
 
         # window
-        height = len(self.layerKnobs) * 20
+        #height = len(self.layerKnobs) * 20
+        height = 1200
         width = 800
         #if height > 1200:
         #    width = 700

pythonpluginsUI/layoutNodes/layoutNodes.py

             dist = sel[len(sel) - 1].xpos() - sel[len(sel) - 2].xpos()
             #print "LayoutNodes: Offset %s Pixels" % dist
         offset = dist
-        fac = 1.15
+        fac = 1.05
         i = 0
         for node in sel:
             if i == 0:

pythonpluginsUI/nukeffmpeg/Preview_QT.nk

 push $cut_paste_input
 Group {
  name Preview_QT
- tile_color 0xbfbf00ff
+ tile_color 1
  label "h264 intra\n\[value nodeLabel]"
  selected true
- xpos 151
- ypos 68
+ xpos -5
+ ypos -51
  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"}
  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}
+ file //calculon/o/_projekte/HOTZ/550_previewQTs/010/010/HOT_comp_010_010.comp_v001/HOT_comp_010_010.comp_v001.mp4
+ 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, USE_ENV_PROJECTROOT=False)\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 {7 framerate R 23 30}
  framerate {{"\[python \{nuke.root().knobs()\['fps'].value()\}]"}}
  addUserKnob {1 framerange -STARTLINE}
- framerange 1001-1109
+ framerange 1001-1024
  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}
   xpos -6
   ypos -16
  }
-set N7f514400 [stack 0]
+set N4966fc00 [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_message {{72 79 84 95 99 111 109 112 95 48 49 48 95 48 49 48 46 99 111 109 112 95 118 48 48 49}
     }
   old_expression_markers {{0 25}
     }
   xpos -163
   ypos -19
  }
-push $N7f514400
+push $N4966fc00
  Switch {
   inputs 2
   which {{"\[value parent.burnName]"}}
   xpos -6
   ypos 79
  }
-set N434f7400 [stack 0]
+set N4966f000 [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_message {{49 48 50 52}
     }
   old_expression_markers {{0 3}
     }
   xpos -164
   ypos 76
  }
-push $N434f7400
+push $N4966f000
  Switch {
   inputs 2
   which {{"\[value parent.burnFrame]"}}