def confirm(self): if self.checkFakeEnter() == False: self.answerList = [ self.in1.lineEdit.text(), self.out1.lineEdit.text(), self.in2.lineEdit.text(), self.out2.lineEdit.text() ] self.createList = [] for x in self.answerList: if not x in nuke.layers() and not x in self.extras: self.createList.append(x) if not self.createList == []: self.hide() if nuke.ask( '''<font left>The following layers don't exist. Do you want to create them? <i>%s</i>''' % ''' '''.join(self.createList)): for l in self.createList: nuke.Layer(l, [ '%s.red' % l, '%s.green' % l, '%s.blue' % l, '%s.alpha' % l ]) self.show() if self.node == None or not self.modifyNodeCheckBox.isChecked(): with self.context: if self.typeCheckbox.isChecked(): node = nuke.createNode('ShuffleCopy') else: node = nuke.createNode('Shuffle') else: node = self.node node['in'].setValue(self.answerList[0]) node['out'].setValue(self.answerList[1]) node['in2'].setValue(self.answerList[2]) node['out2'].setValue(self.answerList[3]) self.close()
def _update_encyptomatte_setup_layers(gizmo): setup_layers = gizmo.knob('setupLayers').value() num_layers = gizmo.knob('cryptoLayers').value() input_layers = gizmo.knob('inputCryptoLayers').value() crypto_layer = _legal_nuke_layer_name(gizmo.knob('cryptoLayer').value()) if not setup_layers: gizmo.knob('manifestKey').setValue("") for ch_add, ch_remove in zip(GIZMO_ADD_CHANNEL_KNOBS, GIZMO_REMOVE_CHANNEL_KNOBS): gizmo.knob(ch_add).setValue("none") gizmo.knob(ch_remove).setValue("none") return all_layers = nuke.layers() num_ch = len(GIZMO_ADD_CHANNEL_KNOBS) for i, ch_add, ch_remove in zip(list(range(num_ch)), GIZMO_ADD_CHANNEL_KNOBS, GIZMO_REMOVE_CHANNEL_KNOBS): this_layer = "{0}{1:02d}".format(crypto_layer, i) # Add if i < num_layers: if not this_layer in all_layers: channels = [ "%s.%s" % (this_layer, c) for c in ['red', 'green', 'blue', 'alpha'] ] nuke.Layer(this_layer, channels) gizmo.knob(ch_add).setValue(this_layer) gizmo.knob(ch_remove).setValue("none") else: gizmo.knob(ch_add).setValue("none") if i <= input_layers: gizmo.knob(ch_remove).setValue(this_layer) else: gizmo.knob(ch_remove).setValue("none")
def exrCompile(self, x, y): s1 = nuke.nodes.ShuffleCopy() self.sGroup.append(s1) s1.autoplace() if s1.canSetInput(0, self.node) and s1.canSetInput(1, self.node2): s1.setInput(0, self.node) s1.setInput(1, self.node2) chan = s1["in2"].value() s1["red"].setValue('red') s1["green"].setValue('green') s1["blue"].setValue('blue') s1["alpha"].setValue('alpha') self.name(self.node2) nameTemp = '' listTemp = [] #listTemp=str.split(self.currentlayerName,'_') listTemp = self.currentlayerName #for x in range(int(float(self.removeFront)),len(listTemp)-int(float(self.removeBack)),1): #nameTemp= nameTemp+'_'+listTemp[x] nameTemp = listTemp nuke.tprint(nameTemp) currentlayerNameRed = str(nameTemp) + ".red" currentlayerNameGreen = str(nameTemp) + ".green" currentlayerNameBlue = str(nameTemp) + ".blue" currentlayerNameAlpha = str(nameTemp) + ".alpha" nuke.Layer(nameTemp, [ currentlayerNameRed, currentlayerNameGreen, currentlayerNameBlue, currentlayerNameAlpha ]) s1["out"].setValue(nameTemp) self.node = s1 self.node.knob("selected").setValue(False) self.node2.knob("selected").setValue(False) else: pass
def rePass(): node = nuke.selectedNode() p = ShapePanel(node) v = { 'ol': { 'shuffle':{}, 'copy':[], 'curr_channel_index':{}, 'remove':[] } } order = ['red','green','blue','alpha'] if p.showModalDialog(): #show dialog k=0 # loop through all rows while k < len(p.layers): j = str(k) tmp_layer = p.var['mp_layer'+j].value() tmp_layer_new = p.var['mp_layernew'+j].value() tmp_remove = p.var['mp_remove'+j].value() # add to copy list if tmp_layer_new: a_layer = tmp_layer_new.strip().split('.') if tmp_layer not in v['ol']['curr_channel_index']: v['ol']['curr_channel_index'][tmp_layer] = 0 curr_index = v['ol']['curr_channel_index'][tmp_layer] if len(a_layer) > 1: s_from = tmp_layer + '.' + p.layers[tmp_layer][curr_index] s_to = tmp_layer_new nuke.Layer(a_layer[0], [s_to]) v['ol']['copy'].append({'from': s_from, 'to': s_to}) v['ol']['curr_channel_index'][tmp_layer] += 1 else: a_tmp_layers_new = [] a_tmp_channels = [] for channel in p.layers[tmp_layer]: s_from = tmp_layer + '.' + channel s_to = tmp_layer_new + '.' + channel a_tmp_layers_new.append(s_to) a_tmp_channels.append(channel) v['ol']['copy'].append({'from': s_from, 'to': s_to}) v['ol']['curr_channel_index'][tmp_layer] += 1 if (False not in [ e in order for e in a_tmp_channels ]): # sort channel order to ['red','green','blue','alpha'] a_tmp_layers_new.sort(key=lambda L: order.index(L.split('.')[1])) # create new layer and its channels nuke.Layer(tmp_layer_new, a_tmp_layers_new) # add to remove list if tmp_remove and tmp_layer not in v['ol']['remove']: if tmp_layer != 'rgba': v['ol']['remove'].append(tmp_layer) k += 1 # copy layers while len(v['ol']['copy']) > 0: tmp_layers = [] s_range = 4 if len(v['ol']['copy']) > 4 else len(v['ol']['copy']) for i in range(s_range): tmp_layers.append(v['ol']['copy'][0]) v['ol']['copy'].pop(0) node = copyNodes(node, tmp_layers, 'Copy Node') # remove layers k = 0 counter = 0 tmp_layers = [] while k < len(v['ol']['remove']): counter += 1 tmp_layers.append(v['ol']['remove'][k]) k += 1 if counter == 4 or k >= len(v['ol']['remove']): counter = 0 node = removeNodes(node, tmp_layers, 'Remove Layers') tmp_layers = []
def grainBuild(nodes_merge): ''' Build Grain nodes set up ''' node_color, spacing, ch_grain = defaultValue() nuke.Layer(ch_grain, ["%s.red", "%s.green", "%s.blue", "%s.alpha"]) console = [] grain_merge = [] for n in nodes_merge: base_node, m_A, m_ASide, m_pos = n spacing = (80, 74) node_color = 1163603199 # Dark Green node_connected = base_node.dependent(nuke.INPUTS | nuke.HIDDEN_INPUTS) # Create Nodes ## Dot node node_dot = nuke.nodes.Dot(inputs=[m_A], tile_color=node_color) node_dot_diff = (node_dot.screenHeight() - base_node.screenHeight()) / 2 if m_ASide < 0: node_dot.setXpos(m_pos[0] + spacing[0] * m_ASide) else: node_dot.setXpos(m_pos[0] + base_node.screenWidth() + spacing[0] * m_ASide) node_dot.setYpos(m_pos[1] - node_dot_diff) base_node.setInput(1, node_dot) ## Shuffle node node_shuffle = nuke.nodes.Shuffle(inputs=[node_dot], tile_color=node_color, label='[value out]') node_shuffle.hideControlPanel() node_shuffle_diff = (node_dot.screenWidth() - node_shuffle.screenWidth()) / 2 node_shuffle.setXpos(node_dot.xpos() + node_shuffle_diff) node_shuffle.setYpos(node_dot.ypos() + spacing[1]) node_shuffle['in'].setValue('alpha') node_shuffle['out'].setValue(ch_grain) ## Merge node node_grainMerge = nuke.nodes.Merge2(inputs=[base_node, node_shuffle], tile_color=node_color, operation='screen', Achannels='alpha', Bchannels='grain', output=ch_grain) node_grainMerge.hideControlPanel() node_grainMerge.setXpos(base_node.xpos()) node_grainMerge.setYpos(node_shuffle.ypos()) nodeInsert(base_node, node_grainMerge) console.append(base_node.name()) grain_merge.append(node_grainMerge) print "Grain Channel set up for\n%s" % console # if len(console_fail)>0: # print "Grain Channel fail to set up for\n%s" % console_fail # else: # pass return grain_merge
def create_rgba_layer(lpass): ''' Creates an rgba layer ''' lpass = nuke.Layer('{}'.format(lpass.upper()), ['{}.red'.format(lpass.upper()), '{}.green'.format(lpass.upper()), '{}.blue'.format(lpass.upper()), '{}.alpha'.format(lpass.upper())])
def create_lp_layer(lpass): ''' Creates an alpha layer based on a Light Pass List item ''' lpass = nuke.Layer('LGHT_{}'.format(lpass.upper()), ['LGHT_{}.alpha'.format(lpass.upper())])
def create(): """ For a selected group of read nodes from the same rendering process (i.e. same naming pattern, using "." as a separator for Render Elements), create a multichannel EXR. """ def is_number(value): """ Check if a value is a number by trying to cast it as an integer :param value: Input value to check :type: any """ try: int(value) return True except ValueError: return False exr_data = { 'channels': 'all', 'file_type': 'exr', 'datatype': '16 bit half', 'compression': 'Zip (1 scanline)', 'reading': True } copy_data = { 'from0': 'red', 'to0': '{0}.red', 'from1': 'green', 'to1': '{0}.green', 'from2': 'blue', 'to2': '{0}.blue', 'from3': 'none', 'to3': 'none' } import nuke if not nuke.selectedNodes(): return passes = [] rgba = None for node in nuke.selectedNodes(): if node.Class() != 'Read': continue fp_base = os.path.basename(node['file'].value()) split_vals = fp_base.split('.') if len(split_vals) > 2 and not is_number(split_vals[-2]): passes.append(node) else: rgba = node last_copy = None for pass_read in sorted(passes, key=lambda x: os.path.basename(x['file'].value()). split('.')[-2].lower()): pass_name = os.path.basename(pass_read['file'].value()).split('.')[-2] nuke.Layer(pass_name, [ '{0}.red'.format(pass_name), '{0}.green'.format(pass_name), '{0}.blue'.format(pass_name) ]) if not last_copy: copy = nuke.nodes.Copy(name='copy_{0}'.format(pass_name), inputs=[rgba, pass_read]) last_copy = copy else: copy = nuke.nodes.Copy(name='copy_{0}'.format(pass_name), inputs=[last_copy, pass_read]) last_copy = copy for attr, value in copy_data.iteritems(): copy[attr].setValue(value.format(pass_name)) write = nuke.nodes.Write(name='multichannel_write', inputs=[last_copy]) write['file'].setValue(rgba['file'].value().replace( '.exr', '_multichannel.exr')) for attr, value in exr_data.iteritems(): write[attr].setValue(value)
def autoShuffleReads(nodes): import re import nuke nuke.Undo().name('organize and split') nuke.Undo().begin() readList = [] yPosAvg = 0 xPosAvg = 0 count = 0 try: nodes # does a exist in the current namespace except NameError: nodes = nuke.selectedNodes() for curNode in nodes: if curNode.Class() == 'Read': readList.append({'file': nuke.filename(curNode), 'node': curNode}) yPosAvg = yPosAvg + curNode['ypos'].value() xPosAvg = xPosAvg + curNode['xpos'].value() count += 1 readListSorted = sorted(readList, key=lambda k: k['file']) xPosAvg = int(xPosAvg / count) yPosAvg = int(yPosAvg / count) count = 0 for readNode in readListSorted: readNode['node']['xpos'].setValue(xPosAvg - 110 * count) readNode['node']['ypos'].setValue(yPosAvg) readNode['node']['selected'].setValue(True) count += 1 for n in nuke.selectedNodes(): n.autoplace() prevNode = nuke.nodes.Dot() originalDot = prevNode for curNode in nuke.selectedNodes(): if curNode.Class() == 'Read': count += 1 filename = nuke.filename(curNode) passName = filename.split('.')[1] if re.match(r'^[A-Za-z0-9_]+$', passName): newLayer = nuke.Layer(passName, [ passName + '.red', passName + '.green', passName + '.blue' ]) shuffle = nuke.nodes.Shuffle(label=passName, inputs=[curNode]) shuffle['out'].setValue(passName) dotNode = nuke.nodes.Dot(inputs=[shuffle]) copyNode = nuke.nodes.Copy(inputs=[prevNode, dotNode], channels=passName, selected=True) prevNode = copyNode else: masterNode = curNode if count % 2 == 0: curNode['ypos'].setValue(curNode['ypos'].value() + 110) originalDot.setInput(0, masterNode) backdrop = nukescripts.autoBackdrop() backdrop.knob('tile_color').setValue(2139062271) nuke.Undo().end()
def SequenceLoader(self): '''main function construct the image group''' dir_renderVersion = joinPath(self.lgtPath.text(), self.renderVersion_mu.currentText()) if dir_renderVersion == None: nuke.message("Import Canceled") else: name_renderVersion = os.path.basename( dir_renderVersion.rstrip('/')) # TIO_orbit_1k_v001 ver_renderVersion = int(name_renderVersion.split('_v')[1]) RGBA = 'beauty' # Building Image Group ls_aov = getAOVs(dir_renderVersion) for p in ls_aov[ls_aov.keys()[0]]: nuke.Layer(p, [ '%s.red' % p, '%s.green' % p, '%s.blue' % p, '%s.alpha' % p ]) # nodeLabel = '%s\nv%s' % (name_renderVersion.split('_v')[0], name_renderVersion.split('_v')[1]) nodeLabel = "nuke.thisNode().name()+'\\n'+nuke.thisNode()['tx_version'].value()+'\\n\\n'+nuke.thisNode()['tx_layer'].value()+'\\n'+'v'+nuke.thisNode()['int_thisVersion'].value()" for l in ls_aov.keys(): imgGroup = nuke.nodes.Group(autolabel=nodeLabel, postage_stamp=1) imgGroup.setName('kpRead1') t_tab = nuke.Tab_Knob('tb_user', 'kpRead') k_pipeline = nuke.Text_Knob('kupipeline', 'kpRead', 'kpRead') # Ku Pipeline Identifier k_renderVersion = nuke.Text_Knob( 'tx_version', '<b>render: </b>', name_renderVersion.split('_v')[0]) mod = os.path.basename(__file__).split('.py')[0] k_verUp = nuke.PyScript_Knob( 'btn_verUp', '<b>▲</b>', '%s.versionUp(nuke.thisNode())' % mod) k_verDown = nuke.PyScript_Knob( 'btn_verDown', '<b>▼</b>', '%s.versionDown(nuke.thisNode())' % mod) k_verLatest = nuke.PyScript_Knob( 'btn_verLatest', '<b>★</b>', '%s.versionLatest(nuke.thisNode())' % mod) k_thisVersion = nuke.Text_Knob('int_thisVersion', '<b>version: </b>') k_thisVersion.setValue('%03d' % ver_renderVersion) k_renderLayer = nuke.Text_Knob('tx_layer', '<b>layer: </b>', l) k_div = nuke.Text_Knob('', "<b>Switch Version:</b>") k_path = nuke.Text_Knob('tx_dir', '<b>path: </b>', dir_renderVersion) # k_aov = nuke.Text_Knob('tx_aov', '<b>aovs: </b>', '\n'.join(ls_aov[l])) # k_thisVersion.setEnabled(False) k_thisVersion.setFlag(nuke.STARTLINE) k_path.setVisible(False) k_verUp.setFlag(nuke.STARTLINE) k_verUp.setTooltip("Version Up") k_verDown.clearFlag(nuke.STARTLINE) k_verDown.setTooltip("Version Down") k_verLatest.clearFlag(nuke.STARTLINE) k_verLatest.setTooltip("Latest Version") k_pipeline.setVisible(False) for k in [ t_tab, k_pipeline, k_path, k_renderVersion, k_thisVersion, k_renderLayer, k_div, k_verUp, k_verDown, k_verLatest ]: imgGroup.addKnob(k) with imgGroup: aov_beauty = None aov_rest = [] for p in ls_aov[l]: path = joinPath(dir_renderVersion, l, p) createRead(path) aov_beauty = nuke.toNode(RGBA) aov_rest = [ n for n in nuke.allNodes('Read') if n != aov_beauty ] shuffling(aov_beauty, aov_rest) self.close()
def breakdown(sel, createWrites, renderTo): ''' create breakdown with all the shuffle nodes etc. ''' createWrites = createWrites renderTo = renderTo sel = sel leftOffset = findMostLeftNode() - 300 i = 0 createdNodes = [] for n in sel: #step01 # step01 has some special features so all necessary steps here in a row if i == 0: posX = sel[i].xpos() posY = sel[i].ypos() #shuffle shuffle = nuke.nodes.Shuffle() shuffle.setInput(0, sel[0]) shuffle.setXpos(leftOffset) shuffle.setYpos(posY) createdNodes.append(shuffle) #creating channels chTemp = "step%s" % (i + 1) r_temp = "step%s" % (i + 1) + ".red" g_temp = "step%s" % (i + 1) + ".green" b_temp = "step%s" % (i + 1) + ".blue" newLayer = nuke.Layer(chTemp, [r_temp, g_temp, b_temp]) #setting up the shuffle nodes inputs and outputs shuffle.knob("out").setValue(("step%s" % (i + 1))) if createWrites: w = nuke.nodes.Write() w.setInput(0, shuffle) w.setXpos(leftOffset - 120) w.setYpos(posY) w.knob("file").setValue(renderTo + "step%s.jpg" % (i + 1)) w.knob("channels").setValue("step%s" % (i + 1)) #remove remove = nuke.nodes.Remove() remove.knob("operation").setValue("keep") remove.knob("channels").setValue("step1") remove.setInput(0, createdNodes[i]) remove.setXpos(leftOffset) remove.setYpos(posY + 70) createdNodes.append(remove) i += 1 #step02+ #all next steps else: posX = sel[i].xpos() posY = sel[i].ypos() shuffle = nuke.nodes.ShuffleCopy() shuffle.setInput(1, sel[i]) shuffle.setInput(0, createdNodes[i]) shuffle.setXpos(leftOffset) shuffle.setYpos(posY) createdNodes.append(shuffle) #creating channels chTemp = "step%s" % (i + 1) r_temp = "step%s" % (i + 1) + ".red" g_temp = "step%s" % (i + 1) + ".green" b_temp = "step%s" % (i + 1) + ".blue" newLayer = nuke.Layer(chTemp, [r_temp, g_temp, b_temp]) #setting up the shuffle nodes inputs and outputs shuffle.knob("out2").setValue(("step%s" % (i + 1))) shuffle['red'].setValue('red2') shuffle['green'].setValue('green2') shuffle['blue'].setValue('blue2') shuffle['alpha'].setValue('alpha2') shuffle['black'].setValue('red') shuffle['white'].setValue('green') shuffle['red2'].setValue('blue') shuffle['green2'].setValue('alpha') if createWrites: w = nuke.nodes.Write() w.setInput(0, shuffle) w.setXpos(leftOffset - 120) w.setYpos(posY) w.knob("file").setValue(renderTo + "step%s.jpg" % (i + 1)) w.knob("channels").setValue("step%s" % (i + 1)) i += 1 #final layersheet = nuke.nodes.LayerContactSheet() layersheet.setInput(0, createdNodes[(len(createdNodes) - 1)]) layersheet.setXpos(leftOffset) layersheet.setYpos(posY + 50) createdNodes.append(layersheet) if createWrites: w = nuke.nodes.Write() w.setInput(0, layersheet) w.setXpos(leftOffset) w.setYpos(posY + 150) w.knob("file").setValue(renderTo + "layersheet.jpg") w.knob("channels").setValue("rgb")
def relightComp(self): self.fromRGBA = ['from0', 'from1', 'from2', 'from3'] self.toRGBA = ['to0', 'to1', 'to2', 'to3'] self.RGBA = ['red', 'green', 'blue', 'alpha'] self.aovNodes = {} # build an aov dictionary for readNode, gradeNodes in self.readNodes: if 'beauty' in readNode.name(): self.aovNodes['beauty'] = readNode for aov in self.aovs: if readNode.name() == aov: self.aovNodes[aov] = readNode # build the layers and channels for aovNode in self.aovNodes: channels = len(self.aovNodes[aovNode].channels()) for x in range(0, channels): nuke.Layer(aovNode, [aovNode + "." + self.RGBA[x]]) ypos = self.lastNodes[-1][1].ypos() self.linkAov(self.lastNodes[-1][1], '__Pworld') self.linkAov(self.copyNodes[-1], '__Nworld') self.linkAov(self.copyNodes[-1], 'z') pointCloudNode = nuke.nodes.PositionToPoints2( inputs=[self.copyNodes[-1]]) pointCloudNode.knob('P_channel').setValue('__Pworld') pointCloudNode.knob('N_channel').setValue('__Nworld') pointCloudNode.setXpos(self.copyNodes[-1].xpos() + 140) pointCloudNode.setYpos(self.copyNodes[-1].ypos()) defaultCameras = [ 'Producer Perspective', 'Producer Top', 'Producer Bottom', 'Producer Front', 'Producer Back', 'Producer Right', 'Producer Left' ] cameraPath = "%s/data/export/cameras.fbx" % self.currentPath cameraNode = nuke.nodes.Camera2(file=cameraPath, read_from_file=True) cameraName = [ camera for camera in cameraNode.knob('fbx_node_name').values() if camera not in defaultCameras ][0] cameraNode.knob('fbx_node_name').setValue(cameraName) cameraNode.setXpos(pointCloudNode.xpos() + 140) cameraNode.setYpos(pointCloudNode.ypos()) lightNode = nuke.nodes.Light() lightNode.setXpos(cameraNode.xpos() + 140) lightNode.setYpos(cameraNode.ypos()) sceneNode = nuke.nodes.Scene( inputs=[cameraNode, pointCloudNode, lightNode]) sceneNode.setXpos(cameraNode.xpos()) sceneNode.setYpos(cameraNode.ypos() + 140) phongNode = nuke.nodes.Phong() phongNode.setXpos(sceneNode.xpos()) phongNode.setYpos(sceneNode.ypos() + 140) relightNode = nuke.nodes.ReLight() relightNode.connectInput(0, sceneNode) relightNode.connectInput(1, cameraNode) relightNode.connectInput(2, self.copyNodes[-1]) relightNode.connectInput(0, phongNode) relightNode.knob('position').value() relightNode.knob('point') relightNode.knob('normal').setValue('__Nworld') relightNode.knob('position').setValue('__Pworld') relightNode.setXpos(pointCloudNode.xpos()) relightNode.setYpos(sceneNode.ypos() + 140) keyerNode = nuke.nodes.Keyer(inputs=[relightNode]) keyerNode.setYpos(relightNode.ypos() + 140) keyerNode.knob('operation').setValue('luminance key') colorCorrectNode = nuke.nodes.ColorCorrect( inputs=[self.copyNodes[-1], keyerNode]) colorCorrectNode.setXpos(self.copyNodes[-1].xpos()) colorCorrectNode.setYpos(keyerNode.ypos() + 140) colorCorrectNode.knob('gain').setValue(5)
def buildAOVDivide(aovkey, filepath, first, last, lastShuffle, xpos_read, dot): xpos_shuffle = lastShuffle['xpos'].value() aovPass = str(aovkey) aovFpn = str(filepath) aovPassGreen = str(aovPass + ".green") aovPassRed = str(aovPass + ".red") aovPassBlue = str(aovPass + ".blue") aovPassAlpha = str(aovPass + ".alpha") aovFirstFrame = first aovLastFrame = last aovReadNodeName = str(aovPass[3:] + '_Read') # create AOV read node readNode = nuke.nodes.Read(name=aovReadNodeName, file=aovFpn, xpos=xpos_read, ypos=lastShuffle.ypos() + 100, postage_stamp=False, first=aovFirstFrame, last=aovLastFrame, origfirst=aovFirstFrame, origlast=aovLastFrame) # create AOV layer in nuke nuke.Layer(aovPass, [aovPassRed, aovPassGreen, aovPassBlue, aovPassAlpha]) # create shuffle and shuffle in aov pass, except for light, gi, zDepth shuffleNode = nuke.nodes.ShuffleCopy(name=aovPass, out=aovPass, red='red', green='green', blue='blue', selected=True, xpos=xpos_shuffle, ypos=lastShuffle.ypos() + 100) diffuse = nuke.toNode('diffuse_Read') lightDiv = nuke.nodes.Merge(name="lightDiv", operation='divide', selected=True, xpos=readNode['xpos'].value() + 150, ypos=shuffleNode['ypos'].value()) lightDiv.setInput(0, diffuse) lightDiv.setInput(1, readNode) copyAlpha_light = nuke.nodes.Copy(from0='rgba.alpha', to0='rgba.alpha', selected=True, xpos=readNode['xpos'].value() + 300, ypos=shuffleNode['ypos'].value() - 10) copyAlpha_light.setInput(0, lightDiv) copyAlpha_light.setInput(1, dot) premultLight = nuke.nodes.Premult(selected=True, xpos=readNode['xpos'].value() + 450, ypos=shuffleNode['ypos'].value()) premultLight.setInput(0, copyAlpha_light) shuffleNode.setInput(1, premultLight) shuffleNode.setInput(0, lastShuffle) aovPass2 = aovPass.replace('raw', '').replace('t', 'ting').replace('L', 'l') aovPass2Green = str(aovPass2 + ".green") aovPass2Red = str(aovPass2 + ".red") aovPass2Blue = str(aovPass2 + ".blue") aovPass2Alpha = str(aovPass2 + ".alpha") nuke.Layer(aovPass2, [aovPass2Red, aovPass2Green, aovPass2Blue, aovPass2Alpha]) shuffleNode2 = nuke.nodes.ShuffleCopy(name=aovPass2, out=aovPass2, red='red', green='green', blue='blue', selected=True, xpos=xpos_shuffle, ypos=shuffleNode.ypos() + 50) shuffleNode2.setInput(1, readNode) shuffleNode2.setInput(0, shuffleNode) lastShuffle = shuffleNode2 return lastShuffle
def textureTrackSetup(DIP): # Create variables # DIP = nuke.selectedNode() channels = DIP.channels() global m_layers m_layers = [] # Create sorted list of DIP layers global layers layers = sorted(list(set([c.split('.')[0] for c in channels]))) # Look for layers that have "m_" and append them to m_layers for layer in layers: if "m_" in layer: m_layers.append(layer) print("Added " + str(layer)) if len(m_layers) < 1: nuke.message('No layers starting with "m_" found...') return # Create DIP layer if it's not found if 'DIP' not in nuke.layers(): nuke.Layer('DIP', ['DIP.red', 'DIP.green', 'DIP.blue', 'DIP.alpha']) "DIP layer not found. Creating DIP layer." else: print("DIP layer found.") # Clear selection #nukescripts.clear_selection_recursive() # Create tex01 layer if not found if 'tex01' not in nuke.layers(): nuke.Layer('tex01', ['tex01.red', 'tex01.green', 'tex01.blue', 'tex01.alpha']) nukescripts.clear_selection_recursive() DIP['selected'].setValue(True) grp = nuke.createNode('Group', inpanel=False) grp.setName('TPD_TextureTrack') grp['xpos'].setValue(DIP.xpos()) grp['ypos'].setValue(85 + DIP.ypos()) grp.setInput(0, DIP) print('Created Group node') text = nuke.Text_Knob( 'title', ' ', '<i>TPD_TextureTrack</i></b> {}<br>by Noah Catan<br><br><b>'.format( version)) div1 = nuke.Text_Knob('div', ' ') grp.addKnob(text) grp.addKnob(div1) global_scale = nuke.Double_Knob('global_scale', 'global scale') global_rotate = nuke.Double_Knob('global_rotate', 'global rotate') div = nuke.Text_Knob('div', ' ') grp.addKnob(global_scale) grp.addKnob(global_rotate) grp.addKnob(div) grp['global_scale'].setRange(1, 5) grp['global_scale'].setValue(1) grp['global_rotate'].setRange(0, 360) grp['global_rotate'].setValue(0) with grp: input1 = nuke.nodes.Input() dot = nuke.nodes.Dot(xpos=34 + input1.xpos(), ypos=200 + input1.ypos(), inputs=[input1]) create_nodeTree(dot) '''for transform in transformList: knobTarget = "{}.{}".format(transform.name(), 'scaleOffset') linkedKnobs.append(knobTarget) for knob in linkedKnobs: link_knob = nuke.Link_Knob("{}".format(layers[linkedKnobs.index(knob)])) link_knob.setLink(knob) grp.addKnob(link_knob)''' for knob in knobList: link_knob = nuke.Link_Knob('{}'.format(knob[9:])) link_knob.setLink(knob) grp.addKnob(link_knob)
def makeCrowd(group): ''' Atists hits make crowd button and we make a crowd ''' with group: # get a list of points we want to creat cards on points = [] if group['useSelection'].value() and len( group['vertexStore'].value()) > 0: allPoints = retrieveSavedVertices(group) points = everyNthPointOfPoints(allPoints, group) else: allPoints = verticesFromInput(group) points = everyNthPointOfPoints(allPoints, group) cardWarningLevel = 500 if len(points) > cardWarningLevel: if not nuke.ask( 'Are you sure you want to create %s cards? This may take a long time...' % (len(points))): return #delete the old scene removePreviousScene(group) with group: # pity the fool who doesn't use default node graph preferences prefs = nuke.toNode('preferences') gridWidth = prefs['GridWidth'].value() gridHeight = prefs['GridHeight'].value() lookDot = nuke.toNode('lookDot') img1 = nuke.toNode('img1') lastXY = [img1['xpos'].value() - gridWidth, img1['ypos'].value()] lookDot.setYpos(int(lastXY[1] + gridHeight * 76)) switchInputs = imageInputList(group) # make channels, channel strings are used later in node creation crowdRandomColorStr = 'crowdRandomColor' nuke.Layer(crowdRandomColorStr, ['red', 'green', 'blue']) crowdIDStr = 'crowdID' nuke.Layer(crowdIDStr, ['id', 'sprite']) ''' crowdCharacterMaskStr = 'crowdCharacterMask' nuke.Layer( crowdCharacterMaskStr , ['alpha'] ) ''' crowdMirrorMaskStr = 'crowdMirrorMask' nuke.Layer(crowdMirrorMaskStr, ['alpha']) transformGeoList = [] cardList = [] whichInput = 0 for i in range(len(points)): point = points[i] # make a switch to plug in the image inputs inputSwitch = nuke.createNode('Switch', inpanel=False) inputSwitch.setName('imgSwitch') inputSwitch['label'].setValue( 'which: [value which]\nauto-generated') inputSwitch.setXpos(int(lastXY[0] + gridWidth)) inputSwitch.setYpos(int(lastXY[1] + gridHeight * 20)) for j in range(len(switchInputs)): inputSwitch.setInput(j, nuke.toNode(switchInputs[j])) # Input switch to chose what images appear on what cards # TODO: Make a a fucntion for Duplication radius inputFromDuplicationRadius = whichInput ifStepExpr = '[string match [value inputOrder] "Step"]?%s' % ( whichInput) ifRandomExpr = '[string match [value inputOrder] "Random"]?'\ 'rint(random(%s+%s,1)*%s)' % ('parent.inputSeed', i, len(switchInputs)-1) inputSwitch['which'].setExpression( '%s:%s:%s' % (ifStepExpr, ifRandomExpr, str(inputFromDuplicationRadius))) whichInput = whichInput + 1 if whichInput >= len(switchInputs): whichInput = 0 ''' # make the id channel idShuffle = nuke.createNode('Shuffle', inpanel = False) idShuffle.setName('aov_idShuffle') idShuffle['in'].setValue('none') idShuffle['out'].setValue(crowdIDStr) idShuffle['label'].setValue('([value out])\nauto-generated') idShuffle['disable'].setExpression('!parent.displayAOVs') idShuffle.setXpos(int(lastXY[0]+gridWidth)) idShuffle.setYpos(int(lastXY[1]+gridHeight*30)) # make the id mult idKnob = nuke.Int_Knob('ID','ID') idKnob.setValue(i) idMult = nuke.createNode('Multiply' ,inpanel = False) idMult.addKnob( idKnob ) idMult.setName('aov_idMult') idMult['channels'].setValue(crowdIDStr) idMult['value'].setSingleValue(True) idMult['value'].setExpression('%s' % ('this.ID+1')) #idMult['maskChannelInput'].setValue('rgba.alpha') idMult['label'].setValue('auto-generated') idMult['disable'].setExpression('!parent.aov_id') idMult.setXpos(int(lastXY[0]+gridWidth)) idMult.setYpos(int(lastXY[1]+gridHeight*32)) ''' # make the id expression idExpr = nuke.createNode('Expression', inpanel=False) idExpr.setName('aov_idExpr') idExpr['temp_name0'].setValue('id') idExpr['temp_expr0'].setValue(str(i)) idExpr['temp_name1'].setValue('inp') idExpr['temp_expr1'].setValue('[value %s.which]' % inputSwitch.name()) idExpr['channel0'].setValue(crowdIDStr) idExpr['channel0'].enableChannel(0, True) idExpr['channel0'].enableChannel(1, False) idExpr['channel0'].enableChannel(2, False) idExpr['expr0'].setValue('id*rgba.alpha') idExpr['channel1'].setValue(crowdIDStr) idExpr['channel1'].enableChannel(0, False) idExpr['channel1'].enableChannel(1, True) idExpr['channel1'].enableChannel(2, False) idExpr['expr1'].setValue('inp*rgba.alpha') idExpr['channel2'].setValue('none') idExpr['channel3'].setValue('none') idExpr['label'].setValue('auto-generated') idExpr['disable'].setExpression('!parent.displayAOVs') idExpr.setXpos(int(lastXY[0] + gridWidth)) idExpr.setYpos(int(lastXY[1] + gridHeight * 30)) # make the grade layer which shuffles in the alpha randomShuffle = nuke.createNode('Shuffle', inpanel=False) randomShuffle.setName('aov_randomShuffle') randomShuffle['in'].setValue('alpha') randomShuffle['out'].setValue(crowdRandomColorStr) randomShuffle['label'].setValue('([value out])\nauto-generated') randomShuffle['disable'].setExpression('!parent.displayAOVs') randomShuffle.setXpos(int(lastXY[0] + gridWidth)) randomShuffle.setYpos(int(lastXY[1] + gridHeight * 40)) # make the grade layer mult randomColorMult = nuke.createNode('Multiply', inpanel=False) randomColorMult.setName('aov_randomMult') randomColorMult['channels'].setValue(crowdRandomColorStr) randomColorMult['value'].setSingleValue(False) randomColorMult['value'].setExpression( 'random(%s+%s,1)' % ('parent.aov_randomSeed', str(i + 0)), 0) randomColorMult['value'].setExpression( 'random(%s+%s,1)' % ('parent.aov_randomSeed', str(i + 1)), 1) randomColorMult['value'].setExpression( 'random(%s+%s,1)' % ('parent.aov_randomSeed', str(i + 2)), 2) randomColorMult['unpremult'].setValue('rgba.alpha') randomColorMult['label'].setValue('auto-generated') randomColorMult['disable'].setExpression('!parent.displayAOVs') randomColorMult.setXpos(int(lastXY[0] + gridWidth)) randomColorMult.setYpos(int(lastXY[1] + gridHeight * 42)) # make the character mask which can be used for lighting ''' charMaskShuffle = nuke.createNode('Shuffle', inpanel = False) charMaskShuffle['in'].setValue('alpha') charMaskShuffle['out'].setValue(crowdCharacterMaskStr) charMaskShuffle['label'].setValue('([value out])\nauto-generated') charMaskShuffle.setXpos(int(lastXY[0]+gridWidth)) charMaskShuffle.setYpos(int(lastXY[1]+gridHeight*40)) ''' # make the mirror mask which can be used for flipping AOVs mirrorMaskShuffle = nuke.createNode('Shuffle', inpanel=False) mirrorMaskShuffle.setName('aov_mirrorShuffle') mirrorMaskShuffle['in'].setValue('alpha') mirrorMaskShuffle['out'].setValue(crowdMirrorMaskStr) mirrorMaskShuffle['label'].setValue( '([value out])\nauto-generated') mirrorMaskShuffle['disable'].setExpression('!parent.displayAOVs') mirrorMaskShuffle.setXpos(int(lastXY[0] + gridWidth)) mirrorMaskShuffle.setYpos(int(lastXY[1] + gridHeight * 50)) # make the mirror for flopping random cards idKnob = nuke.Int_Knob('mirrorID', 'mirrorID') idKnob.setValue(i) flop = nuke.createNode('Mirror2', inpanel=False) flop.addKnob(idKnob) flop['flop'].setValue(True) flop['disable'].setExpression( 'parent.mirror?random(this.mirrorID+parent.mirrorSeed,1)>0.5?1:0:1' ) flop['label'].setValue('auto-generated') flop.setXpos(int(lastXY[0] + gridWidth)) flop.setYpos(int(lastXY[1] + gridHeight * 52)) # make the mirror mask mult which can be used for flipping AOVs mirrorMaskMult = nuke.createNode('Multiply', inpanel=False) mirrorMaskMult.setName('aov_mirrorMult') mirrorMaskMult['channels'].setValue(crowdMirrorMaskStr) mirrorMaskMult['value'].setValue(0) mirrorMaskMult['disable'].setExpression( 'parent.displayAOVs?!input0.disable:1') mirrorMaskMult['label'].setValue('(auto-generated') mirrorMaskMult.setXpos(int(lastXY[0] + gridWidth)) mirrorMaskMult.setYpos(int(lastXY[1] + gridHeight * 54)) # make the time offset idKnob = nuke.Int_Knob('offsetID', 'offsetID') idKnob.setValue(i) timeOffset = nuke.createNode('TimeOffset', inpanel=False) timeOffset.addKnob(nuke.Tab_Knob('User')) timeOffset.addKnob(idKnob) timeOffsetRandomizeExpr = 'rint(random(parent.timeOffsetSeed+%s,1)*parent.timeOffset*2-parent.timeOffset)' % ( 'this.offsetID') timeOffsetStepExpr = 'parent.timeOffset?parent.timeOffsetStep*this.offsetID%abs(parent.timeOffset):0' timeOffset['time_offset'].setExpression( 'parent.timeOffsetRandomize?%s:%s' % (timeOffsetRandomizeExpr, timeOffsetStepExpr)) timeOffset['label'].setValue( '[value time_offset] frames\nauto-generated') timeOffset.setXpos(int(lastXY[0] + gridWidth)) timeOffset.setYpos(int(lastXY[1] + gridHeight * 60)) # make the card idKnob = nuke.Double_Knob('cardID', 'cardID') idKnob.setRange(0, 100) idOffsetKnob = nuke.Double_Knob('cardIDOffset', 'cardIDOffset') idOffsetKnob.setRange(0, 100) card = nuke.createNode('Card', inpanel=False) card.addKnob(nuke.Tab_Knob('User')) card.addKnob(idKnob) card.addKnob(idOffsetKnob) card['cardIDOffset'].setExpression('parent.displayPercentOffset+this.cardID<=100?'\ 'parent.displayPercentOffset+this.cardID:this.cardID-100+parent.displayPercentOffset') card['disable'].setExpression( '$gui?parent.displayPercentage<100?parent.displayPercentage>this.cardIDOffset?0:1:0:0' ) card.setXpos(int(lastXY[0] + gridWidth)) card.setYpos(int(lastXY[1] + gridHeight * 70)) cardList.append(card) # make the transform geo transformGeo = nuke.createNode('TransformGeo', inpanel=False) transformGeo.setXpos(int(lastXY[0] + gridWidth)) transformGeo.setYpos(int(lookDot['ypos'].value())) transformGeo.setInput(0, card) transformGeo.setInput(2, lookDot) transformGeo['translate'].setExpression('random(%s+%s,1)*parent.positionOffset(0)' \ '-parent.positionOffset(0)/2+%s' % ('parent.positionOffsetXZseed',str(i+0),point[0]),0) transformGeo['translate'].setExpression('random(%s+%s,1)*parent.positionOffset(1)' \ '-parent.positionOffset(1)/2+%s' % ('parent.positionOffsetYseed',str(i+1),point[1]),1) transformGeo['translate'].setExpression('random(%s+%s,1)*parent.positionOffset(2)' \ ' -parent.positionOffset(2)/2+%s' % ('parent.positionOffsetXZseed',str(i+2),point[2]),2) transformGeo['pivot'].setExpression('parent.pivotOffset', 1) transformGeo['uniform_scale'].setExpression('parent.scale+random(%s+%s,1)*' \ '(scaleVariation*parent.scale)-(scaleVariation*parent.scale)/2' % ('parent.scaleSeed', str(i))) transformGeo['look_axis'].setExpression('parent.look_axis') transformGeo['look_rotate_x'].setExpression('parent.look_rotate_x') transformGeo['look_rotate_y'].setExpression('parent.look_rotate_y') transformGeo['look_rotate_z'].setExpression('parent.look_rotate_z') transformGeo['look_strength'].setExpression('parent.look_strength') transformGeo['look_use_quaternions'].setExpression( 'parent.look_use_quaternions') transformGeoList.append(transformGeo) lastXY = [lastXY[0] + gridWidth, lastXY[1]] # pipe up all the transform geos into the output scene scene = nuke.toNode('scene') for i in range(len(transformGeoList)): scene.setInput(i, transformGeoList[i]) scene.setYpos(int(lookDot['ypos'].value() + gridHeight * 10)) nuke.toNode('Output').setYpos( int(lookDot['ypos'].value() + gridHeight * 20)) # set up the cards so that they can be culled by a percentage in the gui random.seed(int(group['vertexStep'].value())) random.shuffle(cardList) for i in range(0, len(cardList)): cardID = float(i) * 100 / len(cardList) cardList[i]['cardID'].setValue(cardID) # change the group label and let artist know how many cards were created group['label'].setValue('%s Cards' % (len(transformGeoList)))
def MultiChannelCombine(): images = nuke.selectedNodes() passes = [] passesRename = [] lastPass = "" pipe2 = "" i = 0 noread = 0 inputReads = [] if len(images) > 1: #check if all selected nodes are read nodes imageIn = "" for img in images: if img.Class() != "Read": noread += 1 if noread == 0: for img in images: #get file path readPath = img["file"].value() #split by "/" to get the image name readPathArr = readPath.split("/") #image name is last item of arr imageName = readPathArr[len(readPathArr) - 1] #cut ending (.jpg, .png, .exr, etc...) imageRawArr = imageName.split(".") imageRawArr.pop() imageRaw = "".join(imageRawArr) #cut padding %05d etc... if "%" in imageRaw: temp = imageRaw.split("%") imageRaw = temp[0] #cut "_" , "." and "-" if that is the last character if imageRaw != "": if imageRaw[(len(imageRaw) - 1)] == "_" or imageRaw[( len(imageRaw) - 1)] == "." or imageRaw[(len(imageRaw) - 1)] == "-": imageRaw = imageRaw[:-1] inputReads.append(imageRaw) p = createPanel(inputReads) renamed = setLayerList(inputReads) if p.show(): channelNames = [] temp = 0 for cn in inputReads: channelNames.append(p.value(inputReads[temp])) temp += 1 #check if all channels have a name isEmpty = 0 allUnder30Char = 0 for c in channelNames: if c == "": isEmpty += 1 if len(c) > 30: allUnder30Char += 1 if isEmpty > 0: nuke.message("you haven't named all channels.") MultiChannelCombine() else: if allUnder30Char == 0: for img in images: #autoplace selected nodes nuke.autoplace(img) #get all the filenames to use them as pass name imagePath = img.knob("file").value() imageSplit = imagePath.split("/") lastVal = imageSplit.pop() #cutouts lastVal = lastVal.split(".") passName = lastVal[0] #frame padding % lastVal = passName.split("%") passName = lastVal[0] passes.append(passName) #creating channels r_temp = channelNames[i] + ".red" g_temp = channelNames[i] + ".green" b_temp = channelNames[i] + ".blue" a_temp = channelNames[i] + ".alpha" newLayer = nuke.Layer( channelNames[i], [r_temp, g_temp, b_temp, a_temp]) if i == 0: shuffle1 = nuke.nodes.Shuffle() shuffle1.setName("shuffle_%s" % channelNames[i]) shuffle1.setInput(0, images[0]) #setting up the shuffle nodes inputs and outputs shuffle1.knob("out").setValue(channelNames[i]) if i > 0: if i == 1: #initialize pipe2 for first round pipe2 = shuffle1 #creating shuffle shuffle = nuke.nodes.ShuffleCopy() shuffle.setName("shuffle_%s" % channelNames[i]) shuffle.setInput(0, pipe2) shuffle.setInput(1, images[i]) #setting up the shuffle nodes inputs and outputs shuffle.knob("out2").setValue(channelNames[i]) shuffle['red'].setValue('red2') shuffle['green'].setValue('green2') shuffle['blue'].setValue('blue2') shuffle['alpha'].setValue('alpha2') shuffle['black'].setValue('red') shuffle['white'].setValue('green') shuffle['red2'].setValue('blue') shuffle['green2'].setValue('alpha') #this was a reported bug; #it's right that red2 is actually called black, green2 is actually called white, blue2 is actually called red2 and alpha2 is actually called green2 #pretty strange but it is like that #look here: #http://forums.thefoundry.co.uk/phpBB2/viewtopic.php?t=5954&sid=5eba0be48c454bf34bc7bdf301983a21 #safe last shuffle for next round to pipe it in in shuffleknob pipe2 pipe2 = shuffle i += 1 #create metadata-tag when comment was set lastShuffle = nuke.toNode( "shuffle_" + channelNames[len(channelNames) - 1]) commentVal = "" commentVal = p.value("comment (optional): ") if commentVal != "": md = nuke.nodes.ModifyMetaData() md.knob("metadata").fromScript( "{set comment %s}" % commentVal.replace(" ", "_")) md.setName("comment") md.setInput(0, lastShuffle) #create write node write = nuke.nodes.Write() write.knob("file_type").setValue("exr") write.knob("compression").setValue( "Zip (16 scanlines)") write.knob("channels").setValue("all") if commentVal != "": write.setInput(0, md) write.knob("metadata").setValue("all metadata") else: write.setInput(0, lastShuffle) else: nuke.message( "Wait, the channel names are too long. Pleae make sure, that each channel name is under 30 characters long. Otherwise the exr does not work properly." ) else: nuke.message("Please make sure to select READ nodes only") else: nuke.message("Please select at least 2 Read Nodes")
def createGroup(node): # Create group group = nuke.createNode('Group', inpanel=False) group.setName('TPD_UpdateDIP') # Set group input and connect parent node's dependents group.setInput(0, node) if node.dependent() > 0: for dependent in node.dependent(): dependent.setInput(0, group) # Set group position group.knob('xpos').setValue(node.xpos()) group.knob('ypos').setValue(node.ypos() + 85) # Create text knob with title and version info; create divider knob text = nuke.Text_Knob( 'title', ' ', '<b><i>{} {}</i></b> by {}<br><br>'.format(title, version, author)) div = nuke.Text_Knob('div', ' ') group.addKnob(text) group.addKnob(div) satCtrl = nuke.Double_Knob('satCtrl', 'saturation') satCtrl.setRange(0, 4) satCtrl.setValue(2.5) group.addKnob(satCtrl) # Inside the group with group: # Create input input = nuke.nodes.Input() input.knob('name').setValue('Input') # Create Colorspace node converting all channels from sRGB to Linear colorspace = nuke.nodes.Colorspace(xpos=input.xpos(), ypos=input.ypos() + 25, colorspace_in='sRGB', inputs=[input], channels='all') # Create DIP layer if it doesn't exist if 'DIP' not in nuke.layers(): nuke.Layer('DIP', ['DIP.red', 'DIP.green', 'DIP.blue', 'DIP.alpha']) # Create Shuffle; shuffle rgba into DIP shuffle = nuke.nodes.Shuffle(xpos=input.xpos(), ypos=input.ypos() + 75, inputs=[colorspace], out='DIP') # Creates the main dot for the incremantal horizontal pipe dot = nuke.nodes.Dot(xpos=input.xpos() + 34, ypos=input.ypos() + 150, inputs=[shuffle]) # Create empty global variables disjoint, disjoint1 = None, None stencil, stencil1 = None, None grade, grade1 = None, None over, over1 = None, None for layer in m_layers: dot1 = nuke.nodes.Dot(xpos=dot.xpos() + 200, ypos=dot.ypos(), inputs=[dot]) dot = dot1 shuffle = nuke.nodes.Shuffle(xpos=dot.xpos() - 34, ypos=dot.ypos() + 50, inputs=[dot]) shuffle.knob('in').setValue(layer) shuffle.knob('label').setValue('[value in]') if m_layers.index(layer) < 1: dot2 = nuke.nodes.Dot(xpos=shuffle.xpos() + 34, ypos=shuffle.ypos() + 100, inputs=[shuffle]) shuffleA = nuke.nodes.Shuffle(xpos=shuffle.xpos(), ypos=shuffle.ypos() + 250, inputs=[dot2], red='alpha', green='alpha', blue='alpha', label='[value in]') grade1 = nuke.nodes.Grade(xpos=shuffle.xpos(), ypos=shuffle.ypos() + 300, inputs=[shuffleA]) r, g, b = (float(random.randint(30, 100))) / 100, (float( random.randint(30, 100))) / 100, (float( random.randint(30, 100))) / 100 grade1.knob('white').setValue([r, g, b, 1]) grade1.knob('multiply').setValue( (float(random.randint(30, 100))) / 100) grade1.knob('unpremult').setValue('rgba.alpha') elif m_layers.index(layer) == 1: disjoint = nuke.nodes.Merge2(xpos=shuffle.xpos() + 100, ypos=shuffle.ypos() + 100, inputs=[dot2, shuffle], operation='disjoint-over') stencil = nuke.nodes.Merge2(xpos=shuffle.xpos(), ypos=shuffle.ypos() + 200, inputs=[shuffle, dot2], operation='stencil') shuffleA = nuke.nodes.Shuffle(xpos=shuffle.xpos(), ypos=shuffle.ypos() + 250, inputs=[stencil], red='alpha', green='alpha', blue='alpha', label='[value in]') grade = nuke.nodes.Grade(xpos=shuffle.xpos(), ypos=shuffle.ypos() + 300, inputs=[shuffleA]) over = nuke.nodes.Merge2(xpos=shuffle.xpos(), ypos=shuffle.ypos() + 400, inputs=[grade1, grade], operation='disjoint-over') r, g, b = (float(random.randint(30, 100))) / 100, (float( random.randint(30, 100))) / 100, (float( random.randint(30, 100))) / 100 grade.knob('white').setValue([r, g, b, 1]) grade1.knob('multiply').setValue( (float(random.randint(30, 100))) / 100) grade.knob('unpremult').setValue('rgba.alpha') elif m_layers.index(layer) > 1: disjoint = nuke.nodes.Merge2(xpos=shuffle.xpos() + 100, ypos=shuffle.ypos() + 100, inputs=[disjoint1, shuffle], operation='disjoint-over') stencil = nuke.nodes.Merge2(xpos=shuffle.xpos(), ypos=shuffle.ypos() + 200, inputs=[shuffle, disjoint1], operation='stencil') shuffleA = nuke.nodes.Shuffle(xpos=shuffle.xpos(), ypos=shuffle.ypos() + 250, inputs=[stencil], red='alpha', green='alpha', blue='alpha', label='[value in]') grade = nuke.nodes.Grade(xpos=shuffle.xpos(), ypos=shuffle.ypos() + 300, inputs=[shuffleA]) over = nuke.nodes.Merge2(xpos=shuffle.xpos(), ypos=shuffle.ypos() + 400, inputs=[over1, grade], operation='disjoint-over') r, g, b = (float(random.randint(30, 100))) / 100, (float( random.randint(30, 100))) / 100, (float( random.randint(30, 100))) / 100 grade.knob('white').setValue([r, g, b, 1]) grade1.knob('multiply').setValue( (float(random.randint(30, 100))) / 100) grade.knob('unpremult').setValue('rgba.alpha') shuffle1 = shuffle disjoint1 = disjoint stencil1 = stencil over1 = over if m_layers.index(layer) == len(m_layers) - 1: if 'tpd_colormatte' not in nuke.layers(): nuke.Layer('tpd_colormatte', [ 'tpd_colormatte.red', 'tpd_colormatte.green', 'tpd_colormatte.blue', 'tpd_colormatte.alpha' ]) saturation = nuke.nodes.Saturation(xpos=shuffle.xpos(), ypos=shuffle.ypos() + 450, inputs=[over]) clamp = nuke.nodes.Clamp(xpos=shuffle.xpos(), ypos=shuffle.ypos() + 500, inputs=[saturation], channels='rgba') shuffle1 = nuke.nodes.Shuffle(xpos=shuffle.xpos(), ypos=shuffle.ypos() + 550, inputs=[clamp], in2='DIP', out='tpd_colormatte', out2='rgba', black='red2', white='green2', red2='blue2', green2='alpha2') remove = nuke.nodes.Remove(xpos=shuffle.xpos(), ypos=shuffle.ypos() + 600, inputs=[shuffle1], operation='keep', channels='rgba', channels2='tpd_colormatte') output = nuke.nodes.Output(xpos=shuffle.xpos(), ypos=shuffle.ypos() + 700, inputs=[remove]) saturation.knob('saturation').setExpression('satCtrl')