def link_roto(tracker_node, roto_node=False): ''' Utility function: Creates a layer in roto_node linked to tracker_node if roto_node is False, creates a roto node next to tracker node to link to ''' grid_x = int(nuke.toNode('preferences').knob('GridWidth').value()) grid_y = int(nuke.toNode('preferences').knob('GridHeight').value()) tracker_name = tracker_node.name() tracker_node.setSelected(False) # If Roto node not selected, create one. if not roto_node: roto_node = nuke.createNode('Roto') roto_node.setXYpos(tracker_node.xpos()-grid_x*0, tracker_node.ypos()+grid_y*2) roto_node.setSelected(True) # Create linked layer in Roto Node curves_knob = roto_node["curves"] stab_layer = rp.Layer(curves_knob) stab_layer.name = "stab_"+tracker_name trans_curve_x = cl.AnimCurve() trans_curve_y = cl.AnimCurve() trans_curve_x.expressionString = "parent.{0}.translate.x".format(tracker_name) trans_curve_y.expressionString = "parent.{0}.translate.y".format(tracker_name) trans_curve_x.useExpression = True trans_curve_y.useExpression = True rot_curve = cl.AnimCurve() rot_curve.expressionString = "parent.{0}.rotate".format(tracker_name) rot_curve.useExpression = True scale_curve = cl.AnimCurve() scale_curve.expressionString = "parent.{0}.scale".format(tracker_name) scale_curve.useExpression = True center_curve_x = cl.AnimCurve() center_curve_y = cl.AnimCurve() center_curve_x.expressionString = "parent.{0}.center.x".format(tracker_name) center_curve_y.expressionString = "parent.{0}.center.y".format(tracker_name) center_curve_x.useExpression = True center_curve_y.useExpression = True # Define variable for accessing the getTransform() transform_attr = stab_layer.getTransform() # Set the Animation Curve for the Translation attribute to the value of the previously defined curve, for both x and y transform_attr.setTranslationAnimCurve(0, trans_curve_x) transform_attr.setTranslationAnimCurve(1, trans_curve_y) # Index value of setRotationAnimCurve is 2 even though there is only 1 parameter... # http://www.mail-archive.com/[email protected]/msg02295.html transform_attr.setRotationAnimCurve(2, rot_curve) transform_attr.setScaleAnimCurve(0, scale_curve) transform_attr.setScaleAnimCurve(1, scale_curve) transform_attr.setPivotPointAnimCurve(0, center_curve_x) transform_attr.setPivotPointAnimCurve(1, center_curve_y) curves_knob.rootLayer.append(stab_layer)
def create_RotoNode(self): # create new roto node if self.enumKnobNodeType.value() == 'RotoPaint': self.rNode = nuke.nodes.RotoPaint() # set output to rgba self.rNode['output'].setValue('rgba') else: self.rNode = nuke.nodes.Roto() # set output to alpha self.rNode['output'].setValue('alpha') self.rCurves = self.rNode['curves'] self.root = self.rCurves.rootLayer self.layer = rp.Layer(self.rCurves) # create new layer self.root.append(self.layer) # set node position self.rNode.setXpos(self.trkNode.xpos()) # set x self.rNode.setYpos(self.trkNode.ypos() + self.trkNode.screenHeight() + 15) # set y if self.transBox.value() == True: if self.enumKnobMethod.value() == 'Parent': self.parentTranslate(self.root[0], self.trkNode_transExp) else: # run bake method for translate self.bakeTranslate(self.root[0], self.trkNode_transVals) if self.rotBox.value() == True: if self.enumKnobMethod.value() == 'Parent': self.parentRotate(self.root[0], self.trkNode_rotateExp) else: # run bake method for rotate self.bakeRotate(self.root[0], self.trkNode_rotVal) if self.scaleBox.value() == True: if self.enumKnobMethod.value() == 'Parent': self.parentScale(self.root[0], self.trkNode_scaleExp) else: # run bake method for scale self.bakeScale(self.root[0], self.trkNode_scaleVals) # run pivot no matter what if self.enumKnobMethod.value() == 'Parent': self.parentPivotPoint(self.root[0], self.trkNode_centerExp) else: # run bake method for pp self.bakePivotPoint(self.root[0], self.trkNode_centerVals) if self.enumKnobMethod.value() == 'Parent': print(self.rNode.name() + ' has parented tracking data from ' + self.trkNode_Name) else: print(self.rNode.name() + ' has baked tracking data from ' + self.trkNode_Name) # return roto node return self.rNode
def RotoTrack(): import nuke import nuke.curvelib import nuke.rotopaint as rp # Trackerlist tracker_list = [] tracker_list_print = '' for i in nuke.allNodes('Tracker4'): name = i['name'].value() tracker_list.append(name) tracker_list_print = tracker_list_print + name + ' ' # check auf Tracker if tracker_list_print == '': nuke.message('no Trackers found') return # User Input p = nuke.Panel('meins') p.addEnumerationPulldown('Select Tracker', tracker_list_print) p.addEnumerationPulldown('Matchmove / Stabilize', 'Matchmove Stablilize') p.addEnumerationPulldown('Layer', 'Root Layer1') p.addEnumerationPulldown('Link / Bake', 'Link Link') p.addBooleanCheckBox('Translation', True) p.addBooleanCheckBox('Rotation', True) p.addBooleanCheckBox('Scale', True) p.addBooleanCheckBox('Center', True) p.addBooleanCheckBox('Use different Ref Frame?', False) p.addExpressionInput('Ref Frame', '0') p.show() # cancel if not p.value('Select Tracker'): return # variablen von user input usr_tracker = p.value('Select Tracker') usr_mmstab = p.value('Matchmove / Stabilize') usr_layer = p.value('Layer') usr_link = p.value('Link / Bake') usr_trans = p.value('Translation') usr_rot = p.value('Rotation') usr_scale = p.value('Scale') usr_center = p.value('Center') usr_useRef = p.value('Use different Ref Frame?') usr_refFrame = str(p.value('Ref Frame')) # create new Roto r = nuke.createNode('Roto') cKnob = r['curves'] root = cKnob.rootLayer ## hier entscheiden, ob auf root oder auf layer1 if usr_layer == 'Root': tf = root.getTransform() if usr_layer == 'Layer1': layer = rp.Layer(cKnob) root.append(layer) tf = layer.getTransform() tf_translate_x = tf.getTranslationAnimCurve(0) tf_translate_y = tf.getTranslationAnimCurve(1) tf_rotate = tf.getRotationAnimCurve(0) tf_scale_x = tf.getScaleAnimCurve(0) tf_scale_y = tf.getScaleAnimCurve(1) tf_center_x = tf.getPivotPointAnimCurve(0) tf_center_y = tf.getPivotPointAnimCurve(1) if usr_useRef == False: if usr_layer == 'Root': # werte setzen LINKS ohne CustomRefFrame, nur auf ROOT (simpel) if usr_trans == True: r['translate'].setExpression('parent.' + usr_tracker + '.translate') if usr_rot == True: r['rotate'].setExpression('parent.' + usr_tracker + '.rotate') if usr_scale == True: r['scale'].setExpression('parent.' + usr_tracker + '.scale') if usr_center == True: r['center'].setExpression('parent.' + usr_tracker + '.center') if usr_layer == 'Layer1': # werte setzen LINKS ohne CustomRefFrame, nur auf Layer1 (simpel) t = nuke.createNode('Roto') ## temp container if usr_trans == True: t['translate'].setExpression('parent.' + usr_tracker + '.translate') if usr_rot == True: t['rotate'].setExpression('parent.' + usr_tracker + '.rotate') if usr_scale == True: t['scale'].setExpression('parent.' + usr_tracker + '.scale') if usr_center == True: t['center'].setExpression('parent.' + usr_tracker + '.center') transObj = t['curves'].rootLayer.getTransform() layer.setTransform(transObj) nuke.delete(t) if usr_useRef == True: if usr_layer == 'Root': # werte setzen LINKS mit CustomRefFrame, nur auf ROOT (simpel) if usr_trans == True: r['translate'].setExpression(usr_tracker + '.translate(' + usr_tracker + '.reference_frame+frame-' + usr_refFrame + ')') if usr_rot == True: r['rotate'].setExpression(usr_tracker + '.rotate(' + usr_tracker + '.reference_frame+frame-' + usr_refFrame + ')') if usr_scale == True: r['scale'].setExpression(usr_tracker + '.scale(' + usr_tracker + '.reference_frame+frame-' + usr_refFrame + ')') if usr_center == True: r['center'].setExpression(usr_tracker + '.center(' + usr_tracker + '.reference_frame+frame-' + usr_refFrame + ')') if usr_layer == 'Layer1': # werte setzen LINKS mit CustomRefFrame, nur auf Layer1 (simpel) t = nuke.createNode('Roto') ## temp container if usr_trans == True: t['translate'].setExpression(usr_tracker + '.translate(' + usr_tracker + '.reference_frame+frame-' + usr_refFrame + ')') if usr_rot == True: t['rotate'].setExpression(usr_tracker + '.rotate(' + usr_tracker + '.reference_frame+frame-' + usr_refFrame + ')') if usr_scale == True: t['scale'].setExpression(usr_tracker + '.scale(' + usr_tracker + '.reference_frame+frame-' + usr_refFrame + ')') if usr_center == True: t['center'].setExpression(usr_tracker + '.center(' + usr_tracker + '.reference_frame+frame-' + usr_refFrame + ')') transObj = t['curves'].rootLayer.getTransform() layer.setTransform(transObj) nuke.delete(t)
def manageTransforms(fRange, rotoNode, rptsw_shapeList): #,task): ''' Creates new parent Layers and transfer shapes transforms to them ''' global cancel rotoCurve = rotoNode['curves'] createdShapes = [] #=*=*=*=*=*=*==task=related=code======================================== task = nuke.ProgressTask('Manage Transforms') taskCount = 0 taskLenght = len(rptsw_shapeList) #=*=*=*=*=*=*==task=related=code======================================== for item in rptsw_shapeList: #=*=*=*=*=*=*==task=related=code======================================== task.setMessage('Preparing Shapes and Layers') if cancel: return task.setProgress(int(taskCount / taskLenght * 100)) taskCount += 1 #=*=*=*=*=*=*==task=related=code======================================== if isinstance(item[0], nuke.rotopaint.Shape): #=================================================================== # optimization: verify if shapes share the very same transform data and put them on the same layer #=================================================================== sametransform = False for shape in createdShapes: if shape[1].name == item[1].name: #share the same parent if checkEqualTransform(item[0], shape[0], fRange): sametransform = True sameparent = shape[3] break createdShapes.append(item) #=================================================================== shapeTransf = item[0].getTransform() if len(item[1]) > 1: #apply to a new layer if not sametransform: newLayer = rp.Layer(rotoCurve) newLayer.name = item[0].name + "_trkdata" newLayer.setTransform(shapeTransf) item[1].append(newLayer) newLayer.append(item[0]) createdShapes[-1].append(newLayer) else: sameparent.append(item[0]) else: #=============================================================== # this shape is single child, transfer the transform data to the parent layer #=============================================================== newLayer = rp.Layer(rotoCurve) #temp Layer to hold the data newLayerTransf = newLayer.getTransform() matrixCurves = [] for i in range(4): matrixCurves.append([]) for j in range(4): matrixCurves[i].append( newLayerTransf.getExtraMatrixAnimCurve(i, j)) parentTranf = item[1].getTransform() for f in fRange: m1 = shapeTransf.evaluate(f).getMatrix() m2 = parentTranf.evaluate(f).getMatrix() m3 = m2 * m1 m = 0 for i in range(4): for j in range(4): matrixCurves[i][j].addKey(f, m3.__getitem__(m)) m += 1 newLayerTransf = newLayer.getTransform() item[1].setTransform(newLayerTransf)
typeF = str(attrs.getValue(0,'ltt')) if typeF=='0.0': frame = 'all' elif typeF=='1.0': frame = 'start-' + str(firstF) elif typeF=='2.0': frame = str(firstF) elif typeF=='3.0': frame = str(firstF) + '-end' elif typeF=='4.0': frame = str(firstF)+'-'+str(lastF) if frame not in frameArray: frameArray.append(frame) for i in frameArray: layer = rp.Layer(n2_curves) layer.name = 'frame_' + str(i) n2_curves.rootLayer.append(layer) for shape in shapeArray: attrs = shape.getAttributes() firstF = attrs.getValue(0,'ltn') lastF = attrs.getValue(0,'ltm') typeF = str(attrs.getValue(0,'ltt')) if typeF=='0.0': frame = 'all' elif typeF=='1.0': frame = 'start-' + str(firstF) elif typeF=='2.0': frame = str(firstF) elif typeF=='3.0': frame = str(firstF) + '-end'
def TrackToRoto(): ###### checking if we are connected to the Tracker node try: sDude = nuke.selectedNode() sDudeLabel = sDude['label'].evaluate() sDudeLabel = sDudeLabel.replace("none ","MM").replace("_","") sDudeName = sDude['name'].value() if sDude.Class() == "Tracker3" or sDude.Class() == "Tracker4":###### rising th panel and collecting the info panel=nuke.Panel("roto name") panel.addSingleLineInput("name",sDudeLabel) panel.addSingleLineInput("range:",'%s-%s' % (nuke.root().firstFrame(),nuke.root().lastFrame())) panel.addBooleanCheckBox('bake', True) panel.addBooleanCheckBox('create RotoPaint', False) panel.show() kind = panel.value("create RotoPaint") baked = panel.value('bake') name = panel.value("name") first = int(panel.value('range:').rpartition("-")[0]) last = int(panel.value('range:').rpartition("-")[2])+1 if "ref:" not in name: name = name+"\n"+sDudeLabel ###### checking which node to create roto or rotopaint if kind == 1: roto = nuke.nodes.RotoPaint() else: roto = nuke.nodes.Roto() roto['label'].setValue(name) #######setting position of the new node in the graph x = int(sDude['xpos'].value()) y = int(sDude['ypos'].value()) roto.setXYpos(x,y+100) roto['tile_color'].setValue(11632127) roto['cliptype'].setValue("no clip") m = nuke.Text_Knob("","","<font color='DaimGray'><b> Created with TrackToRoto. ",) roto.addKnob(m) if baked is True:##############baking the track################# #########checking the frame range #first = nuke.Root().knob('first_frame').getValue() #first = int(first) #last = nuke.Root().knob('last_frame').getValue() #last = int(last)+1 frame = first #######acsessing the roto guts Knobs = roto['curves'] root=Knobs.rootLayer transform = root.getTransform() while frame<last: r = sDude['rotate'].getValueAt(frame,0) rr = transform.getRotationAnimCurve(2) rr.addKey(frame,r) tx = sDude['translate'].getValueAt(frame,0) translx = transform.getTranslationAnimCurve(0) translx.addKey(frame,tx) ty = sDude['translate'].getValueAt(frame,1) transly = transform.getTranslationAnimCurve(1) transly.addKey(frame,ty) sx = sDude['scale'].getValueAt(frame,0) ssx = transform.getScaleAnimCurve(0) ssx.addKey(frame,sx) sy = sDude['scale'].getValueAt(frame,1) ssy = transform.getScaleAnimCurve(1) ssy.addKey(frame,sy) cx = sDude['center'].getValueAt(frame,0) ccx = transform.getPivotPointAnimCurve(0) ccx.addKey(frame,cx) cy = sDude['center'].getValueAt(frame,1) ccy = transform.getPivotPointAnimCurve(1) ccy.addKey(frame,cy) frame = frame+1 roto['tile_color'].setValue(9658367) roto.setSelected(True) sDude.setSelected(False) else:##############linking the track################# roto['tile_color'].setValue(11645695) curves_knob = roto["curves"] stab_layer = rp.Layer(curves_knob) stab_layer.name = "stab_"+sDudeName trans_curve_x = cl.AnimCurve() trans_curve_y = cl.AnimCurve() trans_curve_x.expressionString = "parent.{0}.translate.x".format(sDudeName) trans_curve_y.expressionString = "parent.{0}.translate.y".format(sDudeName) trans_curve_x.useExpression = True trans_curve_y.useExpression = True rot_curve = cl.AnimCurve() rot_curve.expressionString = "parent.{0}.rotate".format(sDudeName) rot_curve.useExpression = True scale_curve = cl.AnimCurve() scale_curve.expressionString = "parent.{0}.scale".format(sDudeName) scale_curve.useExpression = True center_curve_x = cl.AnimCurve() center_curve_y = cl.AnimCurve() center_curve_x.expressionString = "parent.{0}.center.x".format(sDudeName) center_curve_y.expressionString = "parent.{0}.center.y".format(sDudeName) center_curve_x.useExpression = True center_curve_y.useExpression = True # Define variable for accessing the getTransform() transform_attr = stab_layer.getTransform() # Set the Animation Curve for the Translation attribute to the value of the previously defined curve, for both x and y transform_attr.setTranslationAnimCurve(0, trans_curve_x) transform_attr.setTranslationAnimCurve(1, trans_curve_y) # Index value of setRotationAnimCurve is 2 even though there is only 1 parameter... # http://www.mail-archive.com/[email protected]/msg02295.html transform_attr.setRotationAnimCurve(2, rot_curve) transform_attr.setScaleAnimCurve(0, scale_curve) transform_attr.setScaleAnimCurve(1, scale_curve) transform_attr.setPivotPointAnimCurve(0, center_curve_x) transform_attr.setPivotPointAnimCurve(1, center_curve_y) curves_knob.rootLayer.append(stab_layer) roto.setSelected(True) sDude.setSelected(False) roto['curves'].changed() else:############ if the selected node is not a tracker ############ roto = nuke.createNode("Roto") x = int(sDude['xpos'].value()) y = int(sDude['ypos'].value()) roto.setXYpos(x,y+50) roto['hide_input'].setValue(0) ############################################################## ############### if no node selected except: import traceback; traceback.print_exc() nuke.createNode("Roto")
def TrackerToRoto(): #CREATES NEW LAYER ON ROTO OR ROTOPAINT WITH TRACKING DATA import nuke.rotopaint as rp n = nuke.selectedNodes() try: nuke.selectedNode() except: print nuke.message("Select a Tracker and a Roto or Rotopaint!") for nodes in n: if nodes.Class() != 'RotoPaint' and nodes.Class( ) != 'Roto' and nodes.Class() != 'Tracker4': nuke.message("Select a Tracker and a Roto or Rotopaint!") break elif len(n) == 1: if nodes.Class() == 'Tracker4': p = nuke.createNode('Roto') else: nuke.message("Select a Tracker and a Roto or Rotopaint!") for nodes in n: if nodes.Class() == 'RotoPaint' or nodes.Class() == 'Roto': p = nodes elif nodes.Class() == 'Tracker4': track = nodes if track['label'].value(): tName = track['label'].value() else: tName = track['name'].value() #CREATE NEW LAYER pCurves = p['curves'] Layer = rp.Layer(pCurves) Layer.name = "%s_%s" % (tName, Layer.name) pLayer = pCurves.rootLayer.append(Layer) LayerName = Layer.name NewLayer = pCurves.toElement(LayerName) transform = NewLayer.getTransform() first = nuke.Root().knob('first_frame').getValue() first = int(first) last = nuke.Root().knob('last_frame').getValue() last = int(last) + 1 frame = first #COPY TRACKER'S TRANSFORM TO NEW LAYER while frame < last: r = track['rotate'].getValueAt(frame, 0) rr = transform.getRotationAnimCurve(2) rr.addKey(frame, r) tx = track['translate'].getValueAt(frame, 0) translx = transform.getTranslationAnimCurve(0) translx.addKey(frame, tx) ty = track['translate'].getValueAt(frame, 1) transly = transform.getTranslationAnimCurve(1) transly.addKey(frame, ty) sx = track['scale'].getValueAt(frame, 0) ssx = transform.getScaleAnimCurve(0) ssx.addKey(frame, sx) sy = track['scale'].getValueAt(frame, 1) ssy = transform.getScaleAnimCurve(1) ssy.addKey(frame, sy) cx = track['center'].getValueAt(frame, 0) ccx = transform.getPivotPointAnimCurve(0) ccx.addKey(frame, cx) cy = track['center'].getValueAt(frame, 1) ccy = transform.getPivotPointAnimCurve(1) ccy.addKey(frame, cy) frame = frame + 1
def TrackToRotoIn(): panel = nuke.Panel("roto name") panel.addSingleLineInput("name", "") panel.addBooleanCheckBox('create RotoPaint', False) panel.show() if panel.value("name") != '': name = panel.value("name").replace(' ', '_') #check for unique name nl = [] for nn in nuke.allNodes(): nl.append(nn.name()) if name in nl: #not unique i = 1 namei = name + '_' + str(i) while namei in nl: namei = name + '_' + str(i) i = i + 1 name = namei #check for unique name done kind = panel.value("create RotoPaint") track = nuke.selectedNode() if kind == 1: roto = nuke.nodes.RotoPaint() else: roto = nuke.nodes.Roto() x = track['xpos'].value() y = track['ypos'].value() roto.setXYpos(x, y + 100) first = nuke.Root().knob('first_frame').getValue() first = int(first) last = nuke.Root().knob('last_frame').getValue() last = int(last) + 1 frame = first Knobs = roto['curves'] root = rp.Layer(Knobs) root.name = track.name() Knobs.rootLayer.append(root) print root.name transform = root.getTransform() roto['name'].setValue(name) roto.setSelected(True) track.setSelected(False) while frame < last: r = track['rotate'].getValueAt(frame, 0) rr = transform.getRotationAnimCurve(2) rr.addKey(frame, r) tx = track['translate'].getValueAt(frame, 0) translx = transform.getTranslationAnimCurve(0) translx.addKey(frame, tx) ty = track['translate'].getValueAt(frame, 1) transly = transform.getTranslationAnimCurve(1) transly.addKey(frame, ty) sx = track['scale'].getValueAt(frame, 0) ssx = transform.getScaleAnimCurve(0) ssx.addKey(frame, sx) sy = track['scale'].getValueAt(frame, 1) ssy = transform.getScaleAnimCurve(1) ssy.addKey(frame, sy) cx = track['center'].getValueAt(frame, 0) ccx = transform.getPivotPointAnimCurve(0) ccx.addKey(frame, cx) cy = track['center'].getValueAt(frame, 1) ccy = transform.getPivotPointAnimCurve(1) ccy.addKey(frame, cy) frame = frame + 1