View difference between Paste ID: 4vmAmARU and AQ7ZF826

-import nuke
+import math
 
 
 def createExrCamVray( node ):
     '''
     Create a camera node based on VRay metadata.
     This works specifically on VRay data coming from maya.
     '''
 
     #Big thanks to Ivan Busquets who helped me put this together!
     #(ok, ok, he really helped me a lot)
     #Also thanks to Nathan Dunsworth for giving me solid ideas and some code to get me started.
 
     ### TODO : add progress bar (even though it's really not needed here) that works
 
     mDat = node.metadata()
     reqFields = ['exr/camera%s' % i for i in ('FocalLength', 'Aperture', 'Transform')]
     if not set( reqFields ).issubset( mDat ):
         print 'no metdata for camera found'
         return
 
-    task = nuke.ProgressTask( 'Baking camera from meta data in %s' % node.name() )
+
     last = node.lastFrame()
     ret = nuke.getFramesAndViews( 'Create Camera from Metadata', '%s-%s' %( first, last )  )
-        if task.isCancelled():
+
-            break
+
-        task.setMessage( 'processing frame %s' % frame )
+
     cam['useMatrix'].setValue( False )
-        val = node.metadata( 'exr/cameraFocalLength')
+
     for k in ( 'focal', 'haperture', 'translate', 'rotate'):
         cam[k].setAnimated()
 
-        cam['focal'].setValueAt(float(val),frame)
+    #task = nuke.ProgressTask( 'Baking camera from meta data in %s' % node.name() )
 
-        val = node.metadata( 'exr/cameraAperture')
+
-        tx = node.metadata('exr/cameraTransform')[12]
+        #if task.isCancelled():
-        tx = node.metadata('exr/cameraTransform')[13]
+            #nuke.executeInMainThread( nuke.message, args=( "Phew!" ) )
-        tx = node.metadata('exr/cameraTransform')[14]
+            #break;
         #task.setMessage( 'processing frame %s' % frame )
 
-        cam['translate'].setValueAt(float(tx),frame,0)
+
-        cam['translate'].setValueAt(float(tx),frame,1)
+        # IB. If you get both focal and aperture as they are in the metadata, there's no guarantee
-        cam['translate'].setValueAt(float(tx),frame,2)
+        # your Nuke camera will have the same FOV as the one that rendered the scene (because the render could have been fit to horizontal, to vertical, etc)
         # Nuke always fits to the horizontal aperture. If you set the horizontal aperture as it is in the metadata,
-        # CONVERT STRING BACK TO LIST OBJECT AND ASSIGN
+        # then you should use the FOV in the metadata to figure out the correct focal length for Nuke's camera
-        matrixList = node.metadata('exr/cameraTransform')
+        # Or, you could keep the focal as is in the metadata, and change the horizontal_aperture instead.
-        #for i, v in enumerate( matrixList ):
+        # I'll go with the former here. Set the haperture knob as per the metadata, and derive the focal length from the FOV
-        #    cam[ 'matrix' ].setValueAt( v, frame, i)
+
-        # UPDATE PROGRESS BAR
+        val = node.metadata( 'exr/cameraAperture', frame) # get horizontal aperture
-        task.setProgress( int( float(curTask) / fRange.frames() *100) )
+        fov = node.metadata( 'exr/cameraFov', frame) # get camera FOV
 
         focal = val / (2 * math.tan(math.radians(fov)/2.0)) # convert the fov and aperture into focal length
 
         cam['focal'].setValueAt(float(focal),frame)
         cam['haperture'].setValueAt(float(val),frame)
 
         matrixCamera = node.metadata( 'exr/cameraTransform', frame) # get camera transform data
 
         #Create a matrix to shove the original data into
         matrixCreated = nuke.math.Matrix4()
 
         for k,v in enumerate(matrixCamera):
             matrixCreated[k] = v
 
         matrixCreated.rotateX(math.radians(-90)) # this is needed for VRay.  It's a counter clockwise rotation
         translate = matrixCreated.transform(nuke.math.Vector3(0,0,0))  # Get a vector that represents the camera translation
         rotate = matrixCreated.rotationsZXY() # give us xyz rotations from cam matrix (must be converted to degrees)
 
         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) / fRange.frames() *100) )