[Bf-extensions-cvs] SVN commit: /data/svn/bf-extensions [2526] contrib/py/scripts/addons/ io_export_after_effects.py: modified version 0.55, naming convension fixes

Bartek Skorupa bartekskorupa at bartekskorupa.com
Tue Oct 25 18:04:47 CEST 2011


Revision: 2526
          http://projects.blender.org/scm/viewvc.php?view=rev&root=bf-extensions&revision=2526
Author:   bartekskorupa
Date:     2011-10-25 16:04:46 +0000 (Tue, 25 Oct 2011)
Log Message:
-----------
modified version 0.55, naming convension fixes

Modified Paths:
--------------
    contrib/py/scripts/addons/io_export_after_effects.py

Modified: contrib/py/scripts/addons/io_export_after_effects.py
===================================================================
--- contrib/py/scripts/addons/io_export_after_effects.py	2011-10-25 15:30:05 UTC (rev 2525)
+++ contrib/py/scripts/addons/io_export_after_effects.py	2011-10-25 16:04:46 UTC (rev 2526)
@@ -21,7 +21,7 @@
     'name': 'Export: Adobe After Effects (.jsx)',
     'description': 'Export selected cameras, objects & bundles to Adobe After Effects CS3 and above',
     'author': 'Bartek Skorupa',
-    'version': (0, 54),
+    'version': (0, 55),
     'blender': (2, 6, 0),
     'api': 41098,
     'location': 'File > Export > Adobe After Effects (.jsx)',
@@ -30,94 +30,101 @@
     "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.5/Py/Scripts/Import-Export/Adobe_After_Effects"
     }
 
+
 from math import pi
 import bpy
 import datetime
 
-# <pep8 compliant>
 
 # create list of static blender's data
-def GetCompData():
-    compData = {}
-    aspectX = bpy.context.scene.render.pixel_aspect_x
-    aspectY = bpy.context.scene.render.pixel_aspect_y
-    aspect = aspectX / aspectY
+def get_comp_data():
+    aspect_x = bpy.context.scene.render.pixel_aspect_x
+    aspect_y = bpy.context.scene.render.pixel_aspect_y
+    aspect = aspect_x / aspect_y
     fps = bpy.context.scene.render.fps
-    compData['scn'] = bpy.context.scene
-    compData['width'] = bpy.context.scene.render.resolution_x
-    compData['height'] = bpy.context.scene.render.resolution_y
-    compData['aspect'] = aspect
-    compData['fps'] = fps
-    compData['start'] = bpy.context.scene.frame_start
-    compData['end'] = bpy.context.scene.frame_end
-    compData['duration'] = (bpy.context.scene.frame_end-bpy.context.scene.frame_start + 1) / fps
-    compData['curframe'] = bpy.context.scene.frame_current
-    return compData
 
+    comp_data = {
+    'scn': bpy.context.scene,
+    'width': bpy.context.scene.render.resolution_x,
+    'height': bpy.context.scene.render.resolution_y,
+    'aspect': aspect,
+    'fps': fps,
+    'start': bpy.context.scene.frame_start,
+    'end': bpy.context.scene.frame_end,
+    'duration': (bpy.context.scene.frame_end-bpy.context.scene.frame_start + 1) / fps,
+    'curframe': bpy.context.scene.frame_current,
+    }
+
+    return comp_data
+
+
 # create managable list of selected objects
 # (only selected objects will be analyzed and exported)
-def GetSelected(prefix):
-    selection = {}
-    cameras = [] # list of selected cameras
-    cams_names = [] # list of selected cameras' names (prevent from calling "ConvertName(ob)" function too many times)
-    nulls = [] # list of all selected objects exept cameras (will be used to create nulls in AE) 
-    nulls_names = [] # list of above objects names (prevent from calling "ConvertName(ob)" function too many times)
+def get_selected(prefix):
+    cameras = []  # list of selected cameras
+    cams_names = []  # list of selected cameras' names (prevent from calling "ConvertName(ob)" function too many times)
+    nulls = []  # list of all selected objects exept cameras (will be used to create nulls in AE) 
+    nulls_names = []  # list of above objects names (prevent from calling "ConvertName(ob)" function too many times)
     obs = bpy.context.selected_objects
+
     for ob in obs:
         if ob.type == 'CAMERA':
             cameras.append(ob)
-            cams_names.append(ConvertName(ob,prefix))
+            cams_names.append(convert_name(ob,prefix))
         else:
             nulls.append(ob)
-            nulls_names.append(ConvertName(ob,prefix))
-    selection['cameras'] = cameras
-    selection['cams_names'] = cams_names
-    selection['nulls'] = nulls
-    selection['nulls_names'] = nulls_names
+            nulls_names.append(convert_name(ob,prefix))
+
+    selection = {
+    'cameras': cameras,
+    'cams_names': cams_names,
+    'nulls': nulls,
+    'nulls_names': nulls_names,
+    }
+
     return selection   
 
+
 # convert names of objects to avoid errors in AE. Add user specified prefix
-def ConvertName(ob,prefix):
-    obName = prefix + ob.name
-    obName = obName.replace('.','_')
-    obName = obName.replace(' ','_')
-    obName = obName.replace('-','_')
-    obName = obName.replace(',','_')
-    obName = obName.replace('=','_')
-    obName = obName.replace('+','_')
-    obName = obName.replace('*','_')
-    return obName
+def convert_name(ob, prefix):
+    ob_name = ob.name
+    for c in [" ",".",",","-","=","+","*"]:
+        ob_name = ob_name.replace(c, "_")
+    
+    return prefix + ob_name
 
+
 # get object's blender's location and rotation and return AE's Position and Rotation/Orientation
 # this function will be called for every object for every frame
-def ConvertPosRot(obs, width, height, aspect, x_rot_correction = False):
+def convert_pos_rot(obs, width, height, aspect, x_rot_correction = False):
     matrix = obs.matrix_world
 
     # get blender location for ob
-    bLocX = matrix.to_translation().x
-    bLocY = matrix.to_translation().y
-    bLocZ = matrix.to_translation().z
+    b_loc_x, b_loc_y, b_loc_z = matrix.to_translation()
+    b_rot_x, b_rot_y, b_rot_z = matrix.to_euler()
 
     # get blender rotation for ob
     if x_rot_correction:
-      bRotX = (matrix.to_euler().x) / pi * 180 - 90
+      b_rot_x = b_rot_x / pi * 180 - 90
     else:
-      bRotX = (matrix.to_euler().x) / pi * 180
-    bRotY = (matrix.to_euler().y) / pi * 180
-    bRotZ = (matrix.to_euler().z) / pi * 180
+      b_rot_x = b_rot_x / pi * 180
+    b_rot_y = b_rot_y / pi * 180
+    b_rot_z = b_rot_z / pi * 180
 
     # convert to AE Position and Rotation
     # Axes in AE are different. AE's X is blender's X, AE's Y is negative Blender's Z, AE's Z is Blender's Y
-    x = (bLocX * 100) / aspect + width / 2 #calculate AE's X position
-    y = (-1 * bLocZ * 100) + (height / 2) #calculate AE's Y position
-    z = bLocY * 100 #calculate AE's Z position
-    rx = bRotX #calculate AE's X rotation. Will become AE's RotationX property
-    ry = -1 * bRotZ #calculate AE's Y rotation. Will become AE's OrientationY property
-    rz = bRotY #calculate AE's Z rotation. Will become AE's OrentationZ property
+    x = (b_loc_x * 100) / aspect + width / 2  #calculate AE's X position
+    y = (-b_loc_z * 100) + (height / 2)  #calculate AE's Y position
+    z = b_loc_y * 100  #calculate AE's Z position
+    rx = b_rot_x  #calculate AE's X rotation. Will become AE's RotationX property
+    ry = -b_rot_z  #calculate AE's Y rotation. Will become AE's OrientationY property
+    rz = b_rot_y  #calculate AE's Z rotation. Will become AE's OrentationZ property
     # Using AE's rotation combined with AE's orientation allows to compensate for different euler rotation order.
-    aePosRot = ('%.3f' % x,'%.3f' % y,'%.3f' % z,'%.3f' % rx, '%.3f' % ry, '%.3f' % rz)
-    return aePosRot
+    ae_pos_rot = [x, y, z, rx, ry, rz]
 
+    return ae_pos_rot
+
+
 # get camera's lens and convert to AE's "zoom" value in pixels
 # this function will be called for every camera for every frame
 #
@@ -156,133 +163,136 @@
 #    above is true if square pixels are used. If not - aspect compensation is needed, so final formula is:
 #    zoom = lens * width * (1/sensor) * aspect
 #
-def ConvertLens(camera, width, aspect):
+def convert_lens(camera, width, aspect):
     # wrap camera.data.sensor_width in 'try' to maintain compatibility with blender version not supporting camera.data.sensor_width
     try:
         sensor = camera.data.sensor_width #if camera.data.sensor_width is supported - it will be taken into account
     except:
         sensor = 32 #if version of blender doesn't yet support sensor_width - default blender's 32mm will be taken.
     zoom = camera.data.lens * width * (1/sensor) * aspect
+
     return zoom
 
+
 # jsx script for AE creation
-def WriteJsxFile(file, data, selection, exportBundles, compName, prefix):
+def write_jsx_file(file, data, selection, export_bundles, comp_name, prefix):
     print("\n---------------------------\n- Export to After Effects -\n---------------------------")
     #store the current frame to restore it at the enf of export
     curframe = data['curframe']
     #create array which will contain all keyframes values
-    jsDatas = {}
-    jsDatas['times'] = ''
-    jsDatas['cameras'] = {}
-    jsDatas['objects'] = {}
+    js_data = {
+    'times': '',
+    'cameras': {},
+    'objects': {},
+    }
 
     # create camera structure
     for i, cam in enumerate (selection['cameras']): #more than one camera can be selected
-        nameAE = selection['cams_names'][i]
-        jsDatas['cameras'][nameAE] = {}
-        jsDatas['cameras'][nameAE]['position'] = ''
-        jsDatas['cameras'][nameAE]['pointOfInterest'] = ''
-        jsDatas['cameras'][nameAE]['orientation'] = ''
-        jsDatas['cameras'][nameAE]['rotationX'] = ''
-        jsDatas['cameras'][nameAE]['zoom'] = ''
+        name_ae = selection['cams_names'][i]
+        js_data['cameras'][name_ae] = {
+        'position': '',
+        'pointOfInterest': '',
+        'orientation': '',
+        'rotationX': '',
+        'zoom': '',
+        }
         
     # create object structure
     for i, obj in enumerate (selection['nulls']): #nulls representing blender's obs except cameras
-        nameAE = selection['nulls_names'][i]
-        jsDatas['objects'][nameAE] = {}
-        jsDatas['objects'][nameAE]['position'] = ''
-        jsDatas['objects'][nameAE]['orientation'] = ''
-        jsDatas['objects'][nameAE]['rotationX'] = ''
+        name_ae = selection['nulls_names'][i]
+        js_data['objects'][name_ae] = {
+        'position': '',
+        'orientation': '',
+        'rotationX': '',
+        }
 
-
     # get all keyframes for each objects and store into dico
     for frame in range(data['start'],data['end'] + 1):
         print("working on frame: " + str(frame))
         data['scn'].frame_set(frame)
         
         #get time for this loop
-        jsDatas['times'] += '%f ,' % float((frame-data['start']) / (data['fps']));
+        js_data['times'] += '%f ,' % float((frame-data['start']) / (data['fps']));
 
         # keyframes for all cameras
         for i, cam in enumerate (selection['cameras']):
             #get cam name
-            nameAE = selection['cams_names'][i]
+            name_ae = selection['cams_names'][i]
             #convert cam position to AE space

@@ Diff output truncated at 10240 characters. @@


More information about the Bf-extensions-cvs mailing list