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
