Hey all, I want to announce success with this project. By modifying the bvh_import script I was able to construct the armature and assign rotation values correctly to the bones of the armature. The most ‘difficult’ part was to find the correct sequence of matrices to multiply against the rotation matrix generated from the euler values.
In my next update I’d like to add a GUI to let the user map joint names from the BVH file to the names of bones in an existing Armature.
Oh, and I made all spaces tabs and set the tab stop to 4 instead of 8, I hope no one minds…
#!BPY
"""
Name: 'Motion Capture (.bvh)...'
Blender: 239
Group: 'Import'
Tip: 'Import a (.bvh) motion capture file'
"""
__author__ = "Campbell Barton"
__url__ = ("blender", "elysiun")
__version__ = "1.0.4 05/12/04"
__bpydoc__ = """\
This script imports BVH motion capture data to Blender.
Supported: Poser 3.01
Missing:
Known issues:
Notes:
Joe Garfield made changes to construct Armatures and Action from file
Jean-Michel Soler improved importer to support Poser 3.01 files;
Jean-Baptiste Perin wrote a script to create an armature out of the
Empties created by this importer, it's in the Scripts window -> Scripts -> Animation menu.
"""
# $Id: bvh_import.py,v 1.9 2006/01/12 21:30:00 letterrip Exp $
#
#===============================================#
# BVH Import script 1.?? #
# Changed loading of bvh files to load directly #
# into a new Armature. Also creates and fills #
# in the associated Action. #
# Next up is to find a way to map the joint #
# names within the HIERARCHY to bones within an #
# existing Armature as well as improve #
# performance. #
#===============================================#
#===============================================#
# BVH Import script 1.05 patched by Campbell #
# Modified to use Mathutils for matrix math, #
# Fixed possible joint naming bug, #
# Imports BVH's with bad EOF gracefully #
# Fixed duplicate joint names, make them unique #
# Use \r as well as
for newlines #
# Added suppot for nodes with 0 motion channels #
# Rotation IPOs never cross more then 180d #
# fixes sub frame tweening and time scaling #
# 5x overall speedup. #
# 06/12/2005, #
#===============================================#
#===============================================#
# BVH Import script 1.04 patched by jms #
# Small modif for blender 2.40 #
# 04/12/2005, #
#===============================================#
#===============================================#
# BVH Import script 1.03 patched by Campbell #
# Small optimizations and scale input #
# 01/01/2005, #
#===============================================#
#===============================================#
# BVH Import script 1.02 patched by Jm Soler #
# to the Poser 3.01 bvh file #
# 28/12/2004, #
#===============================================#
#===============================================#
# BVH Import script 1.0 by Campbell Barton #
# 25/03/2004, euler rotation code taken from #
# Reevan Mckay's BVH import script v1.1 #
# if you have any questions about this scrip. #
# email me [email protected] #
#===============================================#
#===============================================#
# TODO: #
# * Create GUI to handle joint->bone name #
# mapping among other options #
# * Make an IPO jitter removal script #
# * Work out a better naming system #
#===============================================#
# --------------------------------------------------------------------------
# BVH Import v1.05 by Campbell Barton (AKA Ideasman)
# --------------------------------------------------------------------------
# ***** BEGIN GPL LICENSE BLOCK *****
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#
# ***** END GPL LICENCE BLOCK *****
# --------------------------------------------------------------------------
import Blender
from Blender import Window, Object, Mathutils, Armature, Scene, Ipo, Draw
from Blender.Object import Pose
from Blender.Scene import Render
from Blender.Armature import NLA
import math
# Attempt to load psyco, speed things up
try:
import psyco
psyco.full()
print 'using psyco to speed up BVH importing'
except:
#print 'psyco is not present on this system'
pass
def main():
global scale
scale = None
# Update as we load?
debug = 1
def getScale():
return Draw.PupFloatInput('BVH Scale: ', 0.01, 0.001, 10.0, 0.1, 3)
#===============================================#
# MAIN FUNCTION - All things are done from here #
#===============================================#
def loadBVH(filename):
global scale
print '
BVH Importer 1.?? by Campbell Barton (Ideasman) - [email protected]'
objectCurveMapping = {}
objectNameMapping = {}
objectMotiondataMapping = {}
boneChannels = {}
armObj = Object.New('Armature', 'Armature')
armObj.RotX = math.pi/2.0
armData = Armature.Armature('Armature')
armObj.link(armData)
Scene.getCurrent().link(armObj)
action = NLA.NewAction("Action")
action.setActive(armObj)
# Here we store the Ipo curves in the order they load.
channelCurves = []
# Object list
# We need this so we can loop through the objects and edit there IPO's
# Chenging there rotation to EULER rotation
boneList = []
boneChildren = {}
boneStack = [None]
if scale == None:
tempscale = getScale()
if tempscale:
scale = tempscale
else:
scale = 1.0
Window.WaitCursor(1)
# Change the order rotation is applied.
RotationMatrix = Blender.Mathutils.RotationMatrix
MATRIX_IDENTITY_3x3 = Blender.Mathutils.Matrix([1.0,0.0,0.0],[0.0,1.0,0.0],[0.0,0.0,1.0])
def bvhRotate(x,y,z):
x,y,z = x%360,y%360,z%360 # Clamp all values between 0 and 360, values outside this raise an error.
xmat = RotationMatrix(x,3,'x')
ymat = RotationMatrix(y,3,'y')
zmat = RotationMatrix(z,3,'z')
# Standard BVH multiplication order, apply the rotation in the order Z,X,Y
ret = ymat*(xmat * (zmat * MATRIX_IDENTITY_3x3))
return ret
currentFrame = 1 # Set the initial frame to import all data to.
#===============================================#
# makeJoint: Here we use the node data #
# from the BVA file to create an empty #
#===============================================#
BVH2BLEND_TX_NAME = {'Xposition':'LocX','Yposition':'LocY','Zposition':'LocZ','Xrotation':'RotX','Yrotation':'RotY','Zrotation':'RotZ'}
def makeJoint(name, parent, offset, channels):
bone = Armature.Editbone()
boneList.append(name)
boneChannels[name] = channels
parentname = None
#Default to the absolute 'offset' if there is no parent
scaled_absolute = [a*scale for a in offset]
if parent:
parentname = parent.name
armData.makeEditable()
if parent:
parent = armData.bones[parentname]
bone.parent = parent
for i in range(3):
scaled_absolute[i] = scale*(offset[i]+parent.head[i])
if parentname not in boneChildren:
boneChildren[parentname] = [bone]
parent.tail = Mathutils.Vector(scaled_absolute[0], scaled_absolute[1], scaled_absolute[2])
else:
boneChildren[parentname].append(bone)
# Offset Empty from BVH's initial joint location.
bone.head = Mathutils.Vector(scaled_absolute[0], scaled_absolute[1], scaled_absolute[2])
# Add to bone list
armData.bones[name] = bone
armData.update()
# Redraw if debugging
if debug: Blender.Redraw()
return bone
#===============================================#
# makeEnd: Here we make an end node #
# This is needed when adding the last bone #
#===============================================#
def makeEnd(parent, offset):
parentname = parent.name
scaled_absolute = [0]*3
for i in range(3):
scaled_absolute[i] = scale*(offset[i]+parent.head[i])
armData.makeEditable()
armData.bones[parentname].tail = Mathutils.Vector(scaled_absolute[0],scaled_absolute[1], scaled_absolute[2])
armData.update()
# Redraw if debugging
if debug: Blender.Redraw()
# END FUNCTION DEFINITIONS ====================================#
time1 = Blender.sys.time()
# Get the current scene.
scn = Scene.GetCurrent()
#context = scn.getRenderingContext()
# DeSelect All
for ob in scn.getChildren():
ob.sel = 0
# File loading stuff
# Open the file for importing
file = open(filename, 'r')
# Seperate into a list of lists, each line a list of words.
lines = file.readlines()
# Non standard carrage returns?
if len(lines) == 1:
lines = lines[0].split('\r')
# Split by whitespace.
lines =[ll for ll in [ [w for w in l.split() if w != '
' ] for l in lines] if ll]
# End file loading code
# Create Hierarchy as empties
if lines[0][0] == 'HIERARCHY':
print 'Importing the BVH Hierarchy for:', filename
else:
return 'ERROR: This is not a BVH file'
# A linear list of ancestors to keep track of a single objects heratage
# at any one time, this is appended and removed, doesn't store tree- just a linear list.
# ZERO is a place holder that means we are a root node. (no parents)
parent = None
#channelList, sync with objectList: [[channelType1, channelType2...], [channelType1, channelType2...)]
channelList = []
channelIndex = -1
lineIdx = 0 # An index for the file.
while lineIdx < len(lines) -1:
#...
if lines[lineIdx][0] == 'ROOT' or lines[lineIdx][0] == 'JOINT':
# Join spaces into 1 word with underscores joining it.
if len(lines[lineIdx]) > 2:
lines[lineIdx][1] = '_'.join(lines[lineIdx][1:])
lines[lineIdx] = lines[lineIdx][:2]
# MAY NEED TO SUPPORT MULTIPLE ROOT's HERE!!!, Still unsure weather multiple roots are possible.??
# Make sure the names are unique- Object names will match joint names exactly and both will be unique.
name = lines[lineIdx][1]
if debug: print 'node: %s, parent: %s' % (name, parent)
lineIdx += 2 # Incriment to the next line (Offset)
offset = ( float(lines[lineIdx][1]), float(lines[lineIdx][2]), float(lines[lineIdx][3]) )
lineIdx += 1 # Incriment to the next line (Channels)
# newChannel[Xposition, Yposition, Zposition, Xrotation, Yrotation, Zrotation]
# newChannel references indecies to the motiondata,
# if not assigned then -1 refers to the last value that will be added on loading at a value of zero, this is appended
# We'll add a zero value onto the end of the MotionDATA so this is always refers to a value.
newChannel = [-1, -1, -1, -1, -1, -1]
for channel in lines[lineIdx][2:]:
channelIndex += 1 # So the index points to the right channel
if channel == 'Xposition':
newChannel[0] = channelIndex
elif channel == 'Yposition':
newChannel[1] = channelIndex
elif channel == 'Zposition':
newChannel[2] = channelIndex
elif channel == 'Xrotation':
newChannel[3] = channelIndex
elif channel == 'Yrotation':
newChannel[4] = channelIndex
elif channel == 'Zrotation':
newChannel[5] = channelIndex
channelList.append(newChannel)
channels = lines[lineIdx][2:]
if lines[lineIdx-3][0] == 'ROOT':
armData.makeEditable()
root = Armature.Editbone()
root.head = Mathutils.Vector( offset[0]*scale, offset[1]*scale, offset[2]*scale )
boneChannels[name] = channels
boneList.append(name)
armData.bones[name] = root
armData.update()
parent=root
else:
# Call funtion that uses the gatrhered data to make an empty.
parent = makeJoint(name, parent, offset, channels)
boneStack.append(parent.name)
# Account for an end node
if lines[lineIdx][0] == 'End' and lines[lineIdx][1] == 'Site': # There is somtimes a name after 'End Site' but we will ignore it.
lineIdx += 2 # Incriment to the next line (Offset)
offset = ( float(lines[lineIdx][1]), float(lines[lineIdx][2]), float(lines[lineIdx][3]) )
makeEnd(parent, offset)
boneStack.append(None)
if len(lines[lineIdx]) == 1 and lines[lineIdx][0] == '}': # == ['}']
boneStack.pop()
name = boneStack[-1]
if name: parent = armData.bones[name]
#=============================================#
# BVH Structure loaded, Now import motion #
#=============================================#
if len(lines[lineIdx]) == 1 and lines[lineIdx][0] == 'MOTION':
print '
Importing motion data'
lineIdx += 3 # Set the cursor to the first frame
#=============================================#
# Add a ZERO keyframe, this keeps the rig #
# so when we export we know where all the #
# joints start from #
#=============================================#
#=============================================#
# Loop through frames, each line a frame #
#=============================================#
MOTION_DATA_LINE_LEN = len(lines[lineIdx])
while lineIdx < len(lines):
line = lines[lineIdx]
if MOTION_DATA_LINE_LEN != len(line):
print 'ERROR: Incomplete motion data on line %i, finishing import.' % lineIdx
break
# Exit loop if we are past the motiondata.
# Some BVH's have extra tags like 'CONSTRAINTS and MOTIONTAGS'
# I dont know what they do and I dont care, they'll be ignored here.
if len(line) < len(boneList):
print '...ending on unknown tags'
break
currentFrame += 1 # Incriment to next frame
if currentFrame > Blender.Get("endframe"):
break
#=============================================#
# Import motion data and assign it to an IPO #
#=============================================#
line.append(0.0) # Use this as a dummy var for objects that dont have a loc/rotate channel.
if debug: Blender.Redraw()
poseObject = armObj.getPose()
poseBones = poseObject.bones
for index, bonename in enumerate(boneList):
restBone = armData.bones[bonename]
poseBone = poseBones[bonename]
parentRestMatrix = Mathutils.RotationMatrix(0,4, "x")
if restBone.parent:
parentRestMatrix = restBone.parent.matrix['ARMATURESPACE']
trans = Mathutils.Vector(0.0,0.0,0.0)
obChannel = channelList[index]
xformConstants = []
if channelList[index][0] != -1:
trans[0] = scale * float( line[obChannel[0]] )
if channelList[index][1] != -1:
trans[1] = scale * float( line[obChannel[1]] )
if channelList[index][2] != -1:
trans[2] = scale * float( line[obChannel[2]] )
#Apply transformation
if channelList[index][-1] != -1 or channelList[index][1] != -1 or channelList[index][2] != -1:
poseBone.loc = trans
xformConstants.append( Object.Pose.LOC )
#Apply rotation as matrix
if obChannel[3] != -1 or obChannel[4] != -1 or obChannel[5] != -1:
parentMat = None
boneRest = restBone.matrix['ARMATURESPACE'].rotationPart()
boneRestInv = Mathutils.Matrix(boneRest)
boneRestInv.invert()
objVec = [float(line[obChannel[i]]) for i in range(3,6)]
accum = Mathutils.Vector(tuple(objVec))
action = bvhRotate(accum[0],accum[1],accum[2])
finalMatrix = boneRest*action*boneRestInv
poseBone.quat = finalMatrix.toQuat()
xformConstants.append( Object.Pose.ROT )
# Done importing motion data #
poseBone.insertKey(armObj, currentFrame, xformConstants)
armObj.getPose().update()
lineIdx += 1
# Imported motion to an IPO
# No point in looking further, when this loop is done
# There is nothine else left to do
break
# Main file loop
lineIdx += 1
print '
bvh import time for %i frames: %.6f' % (currentFrame, Blender.sys.time() - time1)
Window.RedrawAll()
Window.WaitCursor(0)
Blender.Window.FileSelector(loadBVH, "Import BVH")
#=============#
# TESTING #
#=============#
'''
#loadBVH('/metavr/mocap/bvh/boxer.bvh')
#loadBVH('/metavr/mocap/bvh/dg-306-g.bvh') # Incompleate EOF
#loadBVH('/metavr/mocap/bvh/wa8lk.bvh') # duplicate joint names, \r line endings.
#loadBVH('/metavr/mocap/bvh/walk4.bvh') # 0 channels
scale = 0.01
import os
DIR = '/metavr/mocap/bvh/'
for f in os.listdir(DIR):
if f.endswith('.bvh'):
s = Scene.New(f)
s.makeCurrent()
loadBVH(DIR + f)
'''
if __name__ == '__main__':
main()