Foundry nuke - bake camera with Redshift metadata

bake_camera_redshift.py

import math
import nuke
import nukescripts


# Get Read Node Name to MetaData
READER_NAME = bakedNode.knob('readername').value()
CAMERA_NAME = bakedNode.knob('cameraname').value()


def createExrRSCam():

    node = nuke.toNode(READER_NAME)
    mDat = node.metadata()

    # Request fields
    reqFields = ['exr/RSCamera%s' % i for i in ('FOV', 'Aperture', 'Transform')]
    if not set( reqFields ).issubset( mDat ):
        print 'no metadata for camera found'
        return

    # Add/Check some Var, convert inch to mm

    ## extract RSCameraAperture
    val = eval(mDat['exr/RSCameraAperture'])            
    valh = val[0]*25.4
    valv = val[1]*25.4

    imageWidth = mDat['input/width']
    imageHeight = mDat['input/height']
    aspectRatio = float(imageWidth)/float(imageHeight)
    hAperture = valh
    vAperture = hAperture/aspectRatio
    fov = eval(mDat['exr/RSCameraFOV'])
    focal = (hAperture / (2 * math.tan(math.pi * fov / 360)))
    
    # Get frame settings and prompt user
    first = node.firstFrame()
    last = node.lastFrame()
    ret = nuke.getFramesAndViews( 'Create Camera from Metadata', '%s-%s' %( first, last )  )
    fRange = nuke.FrameRange( ret[0] )
    camViews = (ret[1])
    
    for act in camViews:

        # Get Camera node 
        cam = nuke.toNode(CAMERA_NAME)

        # Reset settings
        cam['focal'].clearAnimated() 
        cam['haperture'].clearAnimated()        
        cam['vaperture'].clearAnimated()
        cam['translate'].clearAnimated()        
        cam['rotate'].clearAnimated() 
        cam['useMatrix'].setValue(False)

        # Apply basic no keyframe value
        try :
            cam['focal'].setValue( round(focal, 1) )        
            cam['haperture'].setValue( hAperture )
            cam['vaperture'].setValue( vAperture )
            cam['translate'].setValue( float('0.0') )      
            cam['rotate'].setValue( float('0.0') )
            cam['useMatrix'].setValue( True )
        except ValueError:
            print "can't apply : focal, haperture, vaperture, translate or rotate value."

        
        for k in ( 'focal', 'haperture', 'vaperture', 'translate', 'rotate'):
            cam[k].setAnimated()

        # nuke prompt task begin
        task = nuke.ProgressTask( 'Baking camera %s' % node.name() )
        
        for curTask, frame in enumerate( fRange ):
            if task.isCancelled():
                    break
            task.setMessage( 'processing %s' % frame )

            cam['focal'].setValueAt( float(focal),frame, act )
            cam['haperture'].setValueAt( float(hAperture),frame, act )
            cam['vaperture'].setValueAt( float(vAperture),frame, act )
            

            matrixCamera = eval( node.metadata('exr/RSCameraTransform', frame) ) 

            # Matrix math for rotation and translation
            matrixCreated = nuke.math.Matrix4()
            
            for k,v in enumerate( matrixCamera ):
                matrixCreated[k] = v
            
            matrixCreated.rotateY( math.radians(-180) ) # backwards
            # trans vector to translate  
            translate = matrixCreated.transform( nuke.math.Vector3(0,0,0) )
            # give us xyz rotations from cam matrix (must be converted to degrees)        
            rotate = matrixCreated.rotationsZXY() 

            cam['translate'].setValueAt( float(translate.x),frame,0 )
            cam['translate'].setValueAt( float(translate.y),frame,1 )
            cam['translate'].setValueAt( float(translate.z),frame,2 )
            cam['rotate'].setValueAt( float(math.degrees(rotate[0])),frame,0 )
            cam['rotate'].setValueAt( float(math.degrees(rotate[1])),frame,1 ) 
            cam['rotate'].setValueAt( -float(math.degrees(rotate[2])),frame,2 ) 

            task.setProgress( int( float(curTask) / frameRange.frames() *100) )

createExrRSCam()