[Bf-blender-cvs] SVN commit: /data/svn/bf-blender [27047] trunk/blender/release/scripts/io/ import_anim_bvh.py: remove pep8 warnings

Campbell Barton ideasman42 at gmail.com
Sun Feb 21 11:56:14 CET 2010


Revision: 27047
          http://projects.blender.org/plugins/scmsvn/viewcvs.php?view=rev&root=bf-blender&revision=27047
Author:   campbellbarton
Date:     2010-02-21 11:56:14 +0100 (Sun, 21 Feb 2010)

Log Message:
-----------
remove pep8 warnings

Modified Paths:
--------------
    trunk/blender/release/scripts/io/import_anim_bvh.py

Modified: trunk/blender/release/scripts/io/import_anim_bvh.py
===================================================================
--- trunk/blender/release/scripts/io/import_anim_bvh.py	2010-02-21 10:30:39 UTC (rev 27046)
+++ trunk/blender/release/scripts/io/import_anim_bvh.py	2010-02-21 10:56:14 UTC (rev 27047)
@@ -25,8 +25,9 @@
 import Mathutils
 from Mathutils import Vector, Euler, Matrix, RotationMatrix, TranslationMatrix
 
+
 class bvh_node_class(object):
-    __slots__=(\
+    __slots__ = (
     'name',# bvh joint name
     'parent',# bvh_node_class type or None for no parent
     'children',# a list of children of this type.
@@ -63,7 +64,6 @@
         #
         self.anim_data = [(0, 0, 0, 0, 0, 0)]
 
-
     def __repr__(self):
         return 'BVH name:"%s", rest_loc:(%.3f,%.3f,%.3f), rest_tail:(%.3f,%.3f,%.3f)' %\
         (self.name,\
@@ -71,25 +71,24 @@
         self.rest_head_world.x, self.rest_head_world.y, self.rest_head_world.z)
 
 
-
 # Change the order rotation is applied.
-MATRIX_IDENTITY_3x3 = Matrix([1,0,0],[0,1,0],[0,0,1])
-MATRIX_IDENTITY_4x4 = Matrix([1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1])
+MATRIX_IDENTITY_3x3 = Matrix([1, 0, 0], [0, 1, 0], [0, 0, 1])
+MATRIX_IDENTITY_4x4 = Matrix([1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1])
 
-def eulerRotate(x,y,z, rot_order):
+
+def eulerRotate(x, y, z, rot_order):
     # Clamp all values between 0 and 360, values outside this raise an error.
-    mats=[RotationMatrix(x, 3, 'X'), RotationMatrix(y, 3,'Y'), RotationMatrix(z, 3, 'Z')]
-    # print rot_order
-    # Standard BVH multiplication order, apply the rotation in the order Z,X,Y
+    mats = [RotationMatrix(x, 3, 'X'), RotationMatrix(y, 3, 'Y'), RotationMatrix(z, 3, 'Z')]
+    return (MATRIX_IDENTITY_3x3 * mats[rot_order[0]] * (mats[rot_order[1]] * (mats[rot_order[2]]))).to_euler()
 
-    #XXX, order changes???
-    #eul = (mats[rot_order[2]]*(mats[rot_order[1]]* (mats[rot_order[0]]* MATRIX_IDENTITY_3x3))).to_euler()
-    eul = (MATRIX_IDENTITY_3x3*mats[rot_order[0]]*(mats[rot_order[1]]* (mats[rot_order[2]]))).to_euler()
+    # Should work but doesnt!
+    '''
+    eul = Euler(x,y,z)
+    eul.order = "XYZ"[rot_order[0]] + "XYZ"[rot_order[1]] + "XYZ"[rot_order[2]]
+    return tuple(eul.to_matrix().to_euler())
+    '''
 
-    eul = eul.x, eul.y, eul.z
 
-    return eul
-
 def read_bvh(context, file_path, ROT_MODE='XYZ', GLOBAL_SCALE=1.0):
     # File loading stuff
     # Open the file for importing
@@ -102,7 +101,7 @@
         file_lines = file_lines[0].split('\r')
 
     # Split by whitespace.
-    file_lines =[ll for ll in [ l.split() for l in file_lines] if ll]
+    file_lines = [ll for ll in [l.split() for l in file_lines] if ll]
 
 
     # Create Hirachy as empties
@@ -137,7 +136,7 @@
             #print '%snode: %s, parent: %s' % (len(bvh_nodes_serial) * '  ', name,  bvh_nodes_serial[-1])
 
             lineIdx += 2 # Incriment to the next line (Offset)
-            rest_head_local = Vector( GLOBAL_SCALE * float(file_lines[lineIdx][1]), GLOBAL_SCALE * float(file_lines[lineIdx][2]), GLOBAL_SCALE * float(file_lines[lineIdx][3]))
+            rest_head_local = Vector(float(file_lines[lineIdx][1]), float(file_lines[lineIdx][2]), float(file_lines[lineIdx][3])) * GLOBAL_SCALE
             lineIdx += 1 # Incriment to the next line (Channels)
 
             # newChannel[Xposition, Yposition, Zposition, Xrotation, Yrotation, Zrotation]
@@ -150,9 +149,12 @@
             for channel in file_lines[lineIdx][2:]:
                 channel = channel.lower()
                 channelIndex += 1 # So the index points to the right channel
-                if   channel == 'xposition':	my_channel[0] = channelIndex
-                elif channel == 'yposition':	my_channel[1] = channelIndex
-                elif channel == 'zposition':	my_channel[2] = channelIndex
+                if channel == 'xposition':
+                    my_channel[0] = channelIndex
+                elif channel == 'yposition':
+                    my_channel[1] = channelIndex
+                elif channel == 'zposition':
+                    my_channel[2] = channelIndex
 
                 elif channel == 'xrotation':
                     my_channel[3] = channelIndex
@@ -173,7 +175,7 @@
 
 
             # Apply the parents offset accumletivly
-            if my_parent==None:
+            if my_parent == None:
                 rest_head_world = Vector(rest_head_local)
             else:
                 rest_head_world = my_parent.rest_head_world + rest_head_local
@@ -252,7 +254,7 @@
     for bvh_node in bvh_nodes.values():
 
         if not bvh_node.rest_tail_world:
-            if len(bvh_node.children)==0:
+            if len(bvh_node.children) == 0:
                 # could just fail here, but rare BVH files have childless nodes
                 bvh_node.rest_tail_world = Vector(bvh_node.rest_head_world)
                 bvh_node.rest_tail_local = Vector(bvh_node.rest_head_local)
@@ -275,24 +277,22 @@
                 bvh_node.rest_tail_local = rest_tail_local * (1.0 / len(bvh_node.children))
 
         # Make sure tail isnt the same location as the head.
-        if (bvh_node.rest_tail_local-bvh_node.rest_head_local).length <= 0.001*GLOBAL_SCALE:
+        if (bvh_node.rest_tail_local - bvh_node.rest_head_local).length <= 0.001 * GLOBAL_SCALE:
+            bvh_node.rest_tail_local.y = bvh_node.rest_tail_local.y + GLOBAL_SCALE / 10
+            bvh_node.rest_tail_world.y = bvh_node.rest_tail_world.y + GLOBAL_SCALE / 10
 
-            bvh_node.rest_tail_local.y = bvh_node.rest_tail_local.y + GLOBAL_SCALE/10
-            bvh_node.rest_tail_world.y = bvh_node.rest_tail_world.y + GLOBAL_SCALE/10
-
     return bvh_nodes
 
 
+def bvh_node_dict2objects(context, bvh_nodes, IMPORT_START_FRAME=1, IMPORT_LOOP=False):
 
-def bvh_node_dict2objects(context, bvh_nodes, IMPORT_START_FRAME= 1, IMPORT_LOOP= False):
+    if IMPORT_START_FRAME < 1:
+        IMPORT_START_FRAME = 1
 
-    if IMPORT_START_FRAME<1:
-        IMPORT_START_FRAME= 1
-
-    scn= context.scene
+    scn = context.scene
     scn.objects.selected = []
 
-    objects= []
+    objects = []
 
     def add_ob(name):
         ob = scn.objects.new('Empty')
@@ -301,23 +301,23 @@
 
     # Add objects
     for name, bvh_node in bvh_nodes.items():
-        bvh_node.temp= add_ob(name)
+        bvh_node.temp = add_ob(name)
 
     # Parent the objects
     for bvh_node in bvh_nodes.values():
-        bvh_node.temp.makeParent([ bvh_node_child.temp for bvh_node_child in bvh_node.children ], 1, 0) # ojbs, noninverse, 1 = not fast.
+        bvh_node.temp.makeParent([bvh_node_child.temp for bvh_node_child in bvh_node.children], 1, 0) # ojbs, noninverse, 1 = not fast.
 
     # Offset
     for bvh_node in bvh_nodes.values():
         # Make relative to parents offset
-        bvh_node.temp.loc= bvh_node.rest_head_local
+        bvh_node.temp.loc = bvh_node.rest_head_local
 
     # Add tail objects
     for name, bvh_node in bvh_nodes.items():
         if not bvh_node.children:
-            ob_end= add_ob(name + '_end')
+            ob_end = add_ob(name + '_end')
             bvh_node.temp.makeParent([ob_end], 1, 0) # ojbs, noninverse, 1 = not fast.
-            ob_end.loc= bvh_node.rest_tail_local
+            ob_end.loc = bvh_node.rest_tail_local
 
 
     # Animate the data, the last used bvh_node will do since they all have the same number of frames
@@ -327,10 +327,10 @@
         for bvh_node in bvh_nodes.values():
             lx, ly, lz, rx, ry, rz = bvh_node.anim_data[current_frame]
 
-            rest_head_local= bvh_node.rest_head_local
-            bvh_node.temp.loc= rest_head_local + Vector(lx, ly, lz)
+            rest_head_local = bvh_node.rest_head_local
+            bvh_node.temp.loc = rest_head_local + Vector(lx, ly, lz)
 
-            bvh_node.temp.rot= rx, ry, rz
+            bvh_node.temp.rot = rx, ry, rz
 
             bvh_node.temp.insertIpoKey(Blender.Object.IpoKeyTypes.LOCROT) # XXX invalid
 
@@ -338,12 +338,11 @@
     return objects
 
 
+def bvh_node_dict2armature(context, bvh_nodes, ROT_MODE='XYZ', IMPORT_START_FRAME=1, IMPORT_LOOP=False):
 
-def bvh_node_dict2armature(context, bvh_nodes, ROT_MODE='XYZ', IMPORT_START_FRAME= 1, IMPORT_LOOP= False):
+    if IMPORT_START_FRAME < 1:
+        IMPORT_START_FRAME = 1
 
-    if IMPORT_START_FRAME<1:
-        IMPORT_START_FRAME= 1
-
     # Add the new armature,
     scn = context.scene
 #XXX	scn.objects.selected = []
@@ -352,36 +351,35 @@
 
     scn.set_frame(IMPORT_START_FRAME)
 
-    arm_data= bpy.data.armatures.new("MyBVH")
-    arm_ob= bpy.data.objects.new("MyBVH", 'ARMATURE')
+    arm_data = bpy.data.armatures.new("MyBVH")
+    arm_ob = bpy.data.objects.new("MyBVH", 'ARMATURE')
     arm_ob.data = arm_data
-    
+
     scn.objects.link(arm_ob)
 
-    arm_ob.selected= True
-    scn.objects.active= arm_ob
+    arm_ob.selected = True
+    scn.objects.active = arm_ob
     print(scn.objects.active)
 
     bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
     bpy.ops.object.mode_set(mode='EDIT', toggle=False)
 
 
-
     # Get the average bone length for zero length bones, we may not use this.
-    average_bone_length= 0.0
-    nonzero_count= 0
+    average_bone_length = 0.0
+    nonzero_count = 0
     for bvh_node in bvh_nodes.values():
-        l= (bvh_node.rest_head_local-bvh_node.rest_tail_local).length
+        l = (bvh_node.rest_head_local - bvh_node.rest_tail_local).length
         if l:
-            average_bone_length+= l
-            nonzero_count+=1
+            average_bone_length += l
+            nonzero_count += 1
 
     # Very rare cases all bones couldbe zero length???
     if not average_bone_length:
         average_bone_length = 0.1
     else:
         # Normal operation
-        average_bone_length = average_bone_length/nonzero_count
+        average_bone_length = average_bone_length / nonzero_count
 
 
 #XXX - sloppy operator code
@@ -390,30 +388,29 @@
     bpy.ops.armature.select_all()
     bpy.ops.armature.delete()
 
-    ZERO_AREA_BONES= []
+    ZERO_AREA_BONES = []
     for name, bvh_node in bvh_nodes.items():
         # New editbone
         bpy.ops.armature.bone_primitive_add(name="Bone")
 
-#XXX		bone= bvh_node.temp= Blender.Armature.Editbone()
-        bone= bvh_node.temp= arm_data.edit_bones[-1]
+        bone = bvh_node.temp = arm_data.edit_bones[-1]
 
-        bone.name= name
+        bone.name = name
 #		arm_data.bones[name]= bone
 
-        bone.head= bvh_node.rest_head_world

@@ Diff output truncated at 10240 characters. @@




More information about the Bf-blender-cvs mailing list