def load_bvh_file(builder,
path,
scale=1.0,
draw_mode=2,
offset=None,
reference_frame=None,
skeleton_model=None,
use_clip=False,
color=None,
visualize=True):
bvh_reader = BVHReader(path)
bvh_reader.scale(scale)
animated_joints = [
key for key in list(bvh_reader.node_names.keys())
if not key.endswith("EndSite")
]
o = None
if bvh_reader.frames is not None:
skeleton = SkeletonBuilder().load_from_bvh(
bvh_reader,
animated_joints,
reference_frame=reference_frame,
skeleton_model=skeleton_model)
motion_vector = MotionVector()
motion_vector.from_bvh_reader(bvh_reader, False)
motion_vector.skeleton = skeleton
if offset is not None:
motion_vector.translate_root(offset)
name = path.split("/")[-1]
o = builder.create_object("animation_controller", name, skeleton,
motion_vector, bvh_reader.frame_time,
draw_mode, visualize, color)
return o
def get_bvh_from_str(bvh_str):
bvh_reader = BVHReader("")
lines = bvh_str.split("\n")
# print(len(lines))
lines = [l for l in lines if len(l) > 0]
bvh_reader.process_lines(lines)
return bvh_reader
def load_motion_from_bvh(filename):
bvh_reader = BVHReader(filename)
motion_vector = MotionVector()
motion_vector.from_bvh_reader(bvh_reader, False)
animated_joints = list(bvh_reader.get_animated_joints())
motion_vector.skeleton = SkeletonBuilder().load_from_bvh(
bvh_reader, animated_joints=animated_joints)
return motion_vector
def load_file(self, filename):
bvh_reader = BVHReader(str(self.folder_path) + os.sep + filename)
mv = MotionVector()
mv.from_bvh_reader(bvh_reader, False)
animated_joints = list(bvh_reader.get_animated_joints())
mv.skeleton = SkeletonBuilder().load_from_bvh(
bvh_reader, animated_joints=animated_joints)
self.motion_cache[filename] = mv
def replace_motion_from_str(self, bvh_str):
bvh_reader = BVHReader("")
lines = bvh_str.split("\n")
print(len(lines))
lines = [l for l in lines if len(l) > 0]
bvh_reader.process_lines(lines)
motion_vector = MotionVector()
motion_vector.from_bvh_reader(bvh_reader, False)
self._motion.replace_frames(motion_vector.frames)
def load_data_for_normalization(self, data_folder):
if not data_folder.endswith(os.sep):
data_folder += os.sep
bvh_files = glob.glob(data_folder + '*.bvh')
self.ref_bvh = bvh_files[0]
self.ref_bvhreader = BVHReader(self.ref_bvh)
self.skeleton = SkeletonBuilder().load_from_bvh(self.ref_bvhreader)
for bvh_file_path in bvh_files:
bvhreader = BVHReader(bvh_file_path)
filename = os.path.split(bvh_file_path)[-1]
self.aligned_motions[filename] = bvhreader.frames
def load_target_skeleton(file_path, scale_factor=1.0):
skeleton = None
target_bvh = BVHReader(file_path)
animated_joints = list(target_bvh.get_animated_joints())
skeleton = SkeletonBuilder().load_from_bvh(target_bvh,
animated_joints,
add_tool_joints=False)
for node in list(skeleton.nodes.values()):
node.offset[0] *= scale_factor
node.offset[1] *= scale_factor
node.offset[2] *= scale_factor
return skeleton
def main():
global context, pool
port = 8888
target_skeleton_file = MODEL_DATA_DIR + os.sep + "iclone_female4.bvh"
skeleton_model = "iclone"
target_skeleton_file = None
parser = argparse.ArgumentParser(
description="Start the MorphableGraphs REST-interface")
parser.add_argument(
"-set",
nargs='+',
default=[],
help="JSONPath expression, e.g. -set $.model_data=path/to/data")
parser.add_argument("-config_file",
nargs='?',
default=SERVICE_CONFIG_FILE,
help="Path to default config file")
parser.add_argument("-target_skeleton",
nargs='?',
default=target_skeleton_file,
help="Path to target skeleton file")
parser.add_argument("-skeleton_scale",
nargs='?',
default=1.0,
help="Scale applied to the target skeleton offsets")
args = parser.parse_args()
if os.path.isfile(args.config_file):
service_config = load_json_file(args.config_file)
algorithm_config_file = "config" + os.sep + service_config[
"algorithm_settings"] + "_algorithm.config"
algorithm_config = load_json_file(algorithm_config_file)
port = service_config["port"]
if args.target_skeleton is not None:
# TODO use custom json file instead
bvh_reader = BVHReader(args.target_skeleton)
animated_joints = list(bvh_reader.get_animated_joints())
target_skeleton = SkeletonBuilder().load_from_bvh(
bvh_reader, animated_joints=animated_joints)
target_skeleton.skeleton_model = SKELETON_MODELS[skeleton_model]
else:
target_skeleton = None
context = Context(service_config, algorithm_config, target_skeleton)
count = cpu_count()
print("run {} processes on port {}".format(count, port))
pool = ProcessPoolExecutor(max_workers=count)
# configure tornado to work with the asynchio loop
tornado.platform.asyncio.AsyncIOMainLoop().install()
app.listen(port)
asyncio.get_event_loop().run_forever()
pool.shutdown()
def slot_load_bvh_str(self):
filename = QFileDialog.getOpenFileName(self, 'Open File', '.')[0]
filename = str(filename)
if os.path.isfile(filename):
try:
bvh = BVHReader(filename)
skeleton = SkeletonBuilder().load_from_bvh(
bvh, list(bvh.get_animated_joints()))
self.data = skeleton.to_unity_format()
print("loaded bvh string from", filename)
except Exception as e:
self.data = None
print("Could not read file", e.args, filename)
def replace_motion_from_file(self, filename):
if filename.endswith(".bvh"):
bvh_reader = BVHReader(filename)
motion_vector = MotionVector()
motion_vector.from_bvh_reader(bvh_reader, False)
self._motion.replace_frames(motion_vector.frames)
self.currentFrameNumber = 0
self.updateTransformation()
self.update_scene_object.emit(-1)
self.updated_animation_frame.emit(self.currentFrameNumber)
elif filename.endswith("_mg.zip"):
self.scene_object.scene.attach_mg_state_machine(
self.scene_object, filename)
self._motion = self.scene_object._components[
"morphablegraph_state_machine"]
self._motion.set_target_skeleton(self._visualization.skeleton)
self.activate_emit = False
elif filename.endswith("amc"):
amc_frames = parse_amc_file(filename)
motion_vector = MotionVector()
motion_vector.from_amc_data(self._visualization.skeleton,
amc_frames)
self._motion.replace_frames(motion_vector.frames)
self._motion.mv.frame_time = 1.0 / 120
self.currentFrameNumber = 0
self.updateTransformation()
self.update_scene_object.emit(-1)
self.updated_animation_frame.emit(self.currentFrameNumber)
def load_motion(path, skeleton_type=None):
bvh = BVHReader(path)
mv = MotionVector()
mv.from_bvh_reader(bvh)
skeleton = SkeletonBuilder().load_from_bvh(bvh)
skeleton.skeleton_model = load_skeleton_model(skeleton_type)
return skeleton, mv
def __init__(self,
elementary_action,
motion_primitive,
data_repo,
functional_motion_data,
npc,
skeleton_json,
knots,
n_joints):
"""
:param functional_motion_data (numpy.array<3d> n_samples * n_coeffs * n_dims): each dimension of motion data is
represented as a function, the dimension of motion data is: first three channels are Hips' translation, four
channels for the orientation of each joint
:return:
"""
self.functional_motion_data = functional_motion_data
self.motion_primitive = motion_primitive
self.elementary_action = elementary_action
self.cartesian_motion_data = convert_quat_functional_data_to_cartesian_functional_data(elementary_action,
motion_primitive,
data_repo,
skeleton_json,
functional_motion_data,
knots)
self.npc = npc
self.knots = knots
skeleton_bvh = os.path.join(os.path.dirname(__file__), r'../../../skeleton.bvh')
bvhreader = BVHReader(skeleton_bvh)
self.skeleton = SkeletonBuilder().load_from_bvh(bvhreader)
self.skeleton_json = skeleton_json
self.data_repo = data_repo
self.n_joints = n_joints
self.len_weights = self.n_joints + LEN_CARTESIAN
self.pca = PCA(n_components=self.npc)
def gen_synthetic_semantic_annotation_for_screw(elementary_action,
motion_primitive):
data_folder = get_aligned_data_folder(elementary_action,
motion_primitive)
# if motion_primitive == 'retrieve':
# semantic_annotation_data = {'annotation_list': ['retrieveTool', 'start', 'end'],
# 'data': {}}
# bvhfiles = glob.glob(os.path.join(data_folder, '*.bvh'))
# bvhreader = BVHReader(bvhfiles[0])
# n_frames = len(bvhreader.frames)
# for filename in bvhfiles:
#
# semantic_annotation_data = {'annotation_list': ['fastenerContact', 'toolActivity', 'retrieveTool'],
# 'data': {}}
# if
semantic_annotation_data = {'annotation_list': ['start', 'end'],
'data': {}}
bvhfiles = glob.glob(os.path.join(data_folder,'*.bvh'))
bvhreader = BVHReader(bvhfiles[0])
n_frames = len(bvhreader.frames)
for item in bvhfiles:
filename = os.path.split(item)[-1]
start = np.zeros(n_frames)
start[0] = 1.0
end = np.zeros(n_frames)
end[-1] = 1.0
semantic_annotation_data['data'][filename] = {'start': start.tolist(),
'end': end.tolist()}
output_path = data_folder + os.sep + '_'.join([elementary_action,
motion_primitive,
'semantic',
'annotation.json'])
with open(output_path, 'w') as outfile:
json.dump(semantic_annotation_data, outfile)
def load_motion_from_files_for_DTW(self, folder_path):
if not folder_path.endswith(os.sep):
folder_path += os.sep
print("search bvh files in " + folder_path)
motion_files = glob.glob(folder_path + '*.bvh')
print(str(len(motion_files)) + " are found!")
for bvh_file_path in motion_files:
bvhreader = BVHReader(bvh_file_path)
filename = os.path.split(bvh_file_path)[-1]
self.aligned_motions[filename] = bvhreader.frames
self.ref_bvhreader = bvhreader
def import_motion(db,new_id, skeleton, skeleton_name, filename):
bvh = BVHReader(filename)
name = filename.split(os.sep)[-1]
mv = MotionVector()
mv.from_bvh_reader(bvh)
mv.skeleton = skeleton
data = mv.to_db_format()
public = 0
n_frames = mv.n_frames
data = bson.dumps(data)
meta_data = b"x00"
db.insert_motion(new_id, skeleton_name, name, data, meta_data, n_frames, public)
def gen_synthetic_semantic_annotation_pick_and_place(elementary_action,
motion_primitive):
data_folder = get_aligned_data_folder(elementary_action,
motion_primitive)
semantic_annotation_data = {'annotation_list': ['leftHandContact', 'rightHandContact', 'leftFootContact',
'rightFootContact', 'start', 'end'],
'data':{}}
bvhfiles = glob.glob(data_folder + os.sep + '*.bvh')
bvhreader = BVHReader(bvhfiles[0])
n_frames = len(bvhreader.frames)
for item in bvhfiles:
filename = os.path.split(item)[-1]
leftHand = np.zeros(n_frames)
rightHand = np.zeros(n_frames)
leftFoot = np.ones(n_frames)
rightFoot = np.ones(n_frames)
start = np.zeros(n_frames)
start[0] = 1.0
end = np.zeros(n_frames)
end[-1] = 1.0
if motion_primitive == 'first' and 'left' in elementary_action.lower():
leftHand[-1] = 1
elif motion_primitive == 'first' and 'right' in elementary_action.lower():
rightHand[-1] = 1
elif motion_primitive == 'first' and 'both' in elementary_action.lower():
leftHand[-1] = 1
rightHand[-1] = 1
elif motion_primitive == 'second' and 'left' in elementary_action.lower():
leftHand[:] = 1
elif motion_primitive == 'second' and 'right' in elementary_action.lower():
rightHand[:] = 1
elif motion_primitive == 'second' and 'both' in elementary_action.lower():
leftHand[:] = 1
rightHand[:] = 1
else:
ValueError('motion primitive type is not support!')
semantic_annotation_data['data'][filename] = {'leftHandContact': leftHand.tolist(),
'rightHandContact': rightHand.tolist(),
'leftFootContact': leftFoot.tolist(),
'rightFootContact': rightFoot.tolist(),
'start': start.tolist(),
'end': end.tolist()}
output_path = data_folder + os.sep + '_'.join([elementary_action,
motion_primitive,
'semantic',
'annotation.json'])
with open(output_path, 'w') as outfile:
json.dump(semantic_annotation_data, outfile)
def get_reduced_euler_frames(self, load_data=True, export_data=False):
reduced_euler_frames_filename = os.path.join(
self.data_analysis_folder, 'reduced_euler_frames.json')
if load_data and os.path.exists(reduced_euler_frames_filename):
reduced_euler_frames_dic = load_json_file(
reduced_euler_frames_filename)['data']
else:
bvhreader = BVHReader(self.skeleton_bvh)
reduced_euler_frames_dic = {}
for filename, frames in self.spatial_data.items():
reduced_euler_frames_dic[
filename] = convert_euler_frames_to_reduced_euler_frames(
bvhreader, frames)
if export_data:
output_data = {'data': reduced_euler_frames_dic}
write_to_json_file(reduced_euler_frames_filename, output_data)
return reduced_euler_frames_dic
def create_quat_spline_from_bvhfile(self, bvhfile, n_basis, degree=3):
bvhreader = BVHReader(bvhfile)
quat_frames = convert_euler_frames_to_quaternion_frames(
bvhreader, bvhreader.frames)
fd = FunctionalData()
functional_coeffs = fd.convert_motion_to_functional_data(
quat_frames, n_basis, degree)
functional_coeffs = mgrd.asarray(functional_coeffs.tolist())
knots = fd.knots
sspm = mgrd.QuaternionSplineModel.load_from_json(
self.skeleton, self.mm_data['sspm'])
sspm.motion_primitive = self.motion_primitive
coeffs_structure = mgrd.CoeffStructure(
len(self.mm_data['sspm']['animated_joints']),
mgrd.CoeffStructure.LEN_QUATERNION,
mgrd.CoeffStructure.LEN_ROOT_POSITION)
quat_spline = mgrd.QuatSpline(functional_coeffs, knots,
coeffs_structure, degree, sspm)
return quat_spline
def gen_foot_contact_annotation(bvhfile, feature_joints,
motion_primitive_model):
"""
:param bvhfile:
:param feature_joints: [left joint, right joint]
:return:
"""
bvhreader = BVHReader(bvhfile)
n_frames = len(bvhreader.frames)
left_joint_speed, right_joint_speed = get_joint_speed(
bvhreader, feature_joints)
start_anno = np.zeros(n_frames)
start_anno[0] = 1.0
end_anno = np.zeros(n_frames)
end_anno[-1] = 1.0
semantic_annotation = {
'LeftFootContact': [],
'RightFootContact': [],
'start': start_anno.tolist(),
'end': end_anno.tolist()
}
if motion_primitive_model == 'leftStance':
semantic_annotation['RightFootContact'] = np.ones(n_frames).tolist()
semantic_annotation['LeftFootContact'] = gen_annotation(
left_joint_speed, right_joint_speed, 'left')
elif motion_primitive_model == 'rightStance':
semantic_annotation['RightFootContact'] = gen_annotation(
left_joint_speed, right_joint_speed, 'right')
semantic_annotation['LeftFootContact'] = np.ones(n_frames).tolist()
elif motion_primitive_model == 'sideStep':
semantic_annotation['RightFootContact'] = gen_annotation(
left_joint_speed, right_joint_speed, 'sideStep')
semantic_annotation['LeftFootContact'] = gen_annotation(
left_joint_speed, right_joint_speed, 'sideStep')
else:
raise NotImplementedError
return semantic_annotation
def normalize_root(self, origin_point):
"""set the offset of root joint to (0, 0, 0), and shift the motions to
original_point, if original_point is None, the set it as (0, 0, 0)
"""
origin_point = [origin_point['x'],
origin_point['y'],
origin_point['z']]
if self.ref_bvh is not None:
self.ref_bvhreader = BVHReader(self.ref_bvh)
elif self.bvhreader is not None:
self.ref_bvhreader = self.bvhreader
else:
raise ValueError('No reference BVH file for skeleton information')
self.ref_bvhreader.node_names['Hips']['offset'] = [0, 0, 0]
skeleton = SkeletonBuilder().load_from_bvh(self.ref_bvhreader)
for filename, frames in self.aligned_motions.items():
height_1 = get_cartesian_coordinates_from_euler_full_skeleton(self.ref_bvhreader,
skeleton,
'Bip01_R_Toe0',
frames[0])[1]
height_2 = get_cartesian_coordinates_from_euler_full_skeleton(self.ref_bvhreader,
skeleton,
'Bip01_L_Toe0',
frames[0])[1]
height_3 = get_cartesian_coordinates_from_euler_full_skeleton(self.ref_bvhreader,
skeleton,
'Bip01_R_Toe0',
frames[-1])[1]
height_4 = get_cartesian_coordinates_from_euler_full_skeleton(self.ref_bvhreader,
skeleton,
'Bip01_L_Toe0',
frames[-1])[1]
height_offset = (height_1 + height_2 + height_3 + height_4)/4.0
self.aligned_motions[filename] = self.translate_to_original_point(
frames,
origin_point,
height_offset)
import bson
import argparse
from motion_database import MotionDatabase
from anim_utils.utilities.io_helper_functions import load_json_file
from anim_utils.animation_data import BVHReader, SkeletonBuilder
CONFIG_FILE = "db_server_config.json"
if __name__ == "__main__":
config = load_json_file(CONFIG_FILE)
parser = argparse.ArgumentParser(description='Import skeleton to db.')
parser.add_argument('name', nargs='?', help='name')
parser.add_argument('skeleton_path', nargs='?', help='BVH file')
args = parser.parse_args()
if args.name is not None and args.skeleton_path is not None:
db = MotionDatabase()
db_path = config["db_path"]
db.connect(db_path)
bvh = BVHReader(args.skeleton_path)
skeleton = SkeletonBuilder().load_from_bvh(bvh)
data = skeleton.to_unity_format()
meta_data = dict()
meta_data["cos_map"] = dict()
meta_data["joints"] = dict()
meta_data["joint_constraints"] = dict()
data = bson.dumps(data)
meta_data = bson.dumps(meta_data)
print("add new skeleton", args.name)
db.add_new_skeleton(args.name, data, meta_data)
db.close()
def set_ref_motion(self, filepath):
ref_filename = os.path.split(filepath)[-1]
ref_bvh = BVHReader(filepath)
self.ref_motion['filename'] = ref_filename
self.ref_motion['frames'] = ref_bvh.frames
def load_skeleton(filename):
bvh = BVHReader(filename)
skeleton = SkeletonBuilder().load_from_bvh(bvh)
return skeleton
def load_from_file(self, file_name):
bvh = BVHReader(file_name)
self.skeleton = SkeletonBuilder().load_from_bvh(bvh)
def calc_bitvector_walking(frames,
features,
skeleton=None,
verbose=False,
threshold=0.2):
""" Detect a bit vector for each frame in the motion
Parameters
----------
frames : numpy.ndarray
The frames of the walking motion
feature : list of str
The Food features
skeleton: animation_data.skeleton.Skeleton
The skeleton to be used. If None, the default interact skeleton is
used.
verbose: bool
Wether to print / plot debug information or not
threshold: int
T.B.D.
Returns
-------
A list containing a bit vector for each frame. Each bit vector has one
element for each feature, indicating wether this feature is on the ground
or not.
"""
if skeleton is None:
reader = BVHReader('skeleton.bvh')
skeleton = Skeleton(reader)
if isinstance(features, str):
features = [features]
jointpositions = {}
# Get cartesian position frame wise. Change this for performance?
for feature in features:
jointpositions[feature] = []
for frame in frames:
jointpositions[feature].append(
get_cartesian_coords(reader, skeleton, feature, frame))
jointpositions[feature] = np.array(jointpositions[feature])
bitvector = {}
xz_threshold = threshold
relativ_velo = {}
for feature in features:
dif = np.diff(jointpositions[feature], axis=0)
relativ_velo[feature] = dif[:, 0]**2 + dif[:, 1]**2 + dif[:, 2]**2
bitvector[feature] = relativ_velo[feature] < threshold
bitvector[feature] = np.concatenate(
(bitvector[feature], [bitvector[feature][-1]],
[bitvector[feature][-1]]))
height_bitvectors = [{feature: 0
for feature in features}
for i in range(frames.shape[0])]
height_threshold = threshold
jointpositions_y = {}
for feature in features:
jointpositions_y[feature] = [pos[1] for pos in jointpositions[feature]]
for i in range(len(jointpositions_y[feature])):
if jointpositions_y[feature][i] < height_threshold:
height_bitvectors[i][feature] = 1
bitvectors_smoothed = smooth_bitvectors(bitvector, threshold=8)
bitvectors_smoothed = smooth_bitvectors(bitvectors_smoothed, threshold=4)
bitvectors_smoothed = smooth_bitvectors(bitvectors_smoothed, threshold=2)
bitvectors_smoothed = smooth_bitvectors(bitvectors_smoothed, threshold=1)
if verbose:
# Plots:
plt.figure()
for feature in ['Bip01_L_Toe0', 'Bip01_R_Toe0']:
plt.plot(bitvectors_smoothed[feature], label=feature)
plt.legend()
plt.ylim([0, 2])
plt.title('walk')
plt.xlabel('frameindex')
plt.ylabel('bitvalue')
plt.figure()
for feature in ['Bip01_L_Toe0', 'Bip01_R_Toe0']:
plt.plot(bitvector[feature], label=feature)
plt.legend()
plt.ylim([0, 2])
plt.title('walk')
plt.xlabel('frameindex')
plt.ylabel('bitvalue')
# plt.figure()
# for feature in ['LeftFoot', 'RightFoot']:
# plt.plot(bitvectors_smoothed[feature], label=feature)
# plt.legend()
# plt.ylim([0, 2])
# plt.title('walk')
# plt.xlabel('frameindex')
# plt.ylabel('bitvalue')
plt.figure()
line_x = list(range(len(relativ_velo[features[0]])))
line_y = [xz_threshold] * len(line_x)
plt.plot(line_x, line_y)
for feature in features:
plt.plot(relativ_velo[feature], label=feature)
plt.legend()
plt.xlabel('frameindex')
plt.ylabel('relativ velocity in xz')
# plt.figure()
# for feature in features:
# tmp = [vector[feature] for vector in height_bitvectors]
# plt.plot(tmp, label=feature)
# plt.legend()
# plt.ylim([0, 2])
# plt.title('walk')
# plt.xlabel('frameindex')
# plt.ylabel('bitvalue (using height)')
#
# plt.figure()
# line_x = range(len(relativ_velo_xz[features[0]]))
# line_y = [xz_threshold] * len(line_x)
# plt.plot(line_x, line_y)
# for feature in features:
# plt.plot(jointpositions_y[feature], label=feature)
# plt.legend()
# plt.xlabel('frameindex')
# plt.ylabel('relativ velocity in xz')
plt.ioff()
plt.show()
return bitvectors_smoothed
def splitt_motion(frames,
keyframes,
mname,
skeleton_file='skeleton.bvh',
outputpath=''):
""" Splitt a Motion by the given Keyframes
Parameters
----------
frames : numpy.ndarray
The frames of the walking motion
keyframes : dict of list of int
A dictionary containing a list for each feature.
Each list contains all Keyframes for this feature.
mname: string
Subfix of the splitted motions (i.e. the original name of the
motion)
skeleton_file: string (optional)
The path to the skeleton file. Default is the 'skeleton.bvh' in the
current folder
outputpath: string (optional)
The path where to save the motions. Default is the current folder
Returns
-------
None
"""
# Calc number of steps for status update
n = 0.0
counter = 0.0
for feature in keyframes:
n += len(keyframes[feature])
tmpmins = []
tmpmax = []
for feature in keyframes:
tmpmins.append(min(keyframes[feature])[0])
tmpmax.append(max(keyframes[feature])[1])
firstframe = min(tmpmins)
lastframe = max(tmpmax)
reader = BVHReader(skeleton_file)
skel = SkeletonBuilder().load_from_bvh(reader)
for feature in keyframes:
# save first step:
if firstframe in keyframes[feature][0]:
keyframe = keyframes[feature][0]
subframes = frames[keyframe[0]:keyframe[1]]
name = 'begin_' + str(keyframe[0]) + '_' + str(keyframe[1]) \
+ '_' + feature + '_' + mname
BVHWriter(outputpath + os.sep + name, skel, subframes, 0.013889)
keyframes[feature] = keyframes[feature][1:]
# last step:
if lastframe in keyframes[feature][-1]:
keyframe = keyframes[feature][-1]
subframes = frames[keyframe[0]:keyframe[1]]
name = 'end_' + str(keyframe[0]) + '_' + str(keyframe[1]) \
+ '_' + feature + '_' + mname
BVHWriter(outputpath + os.sep + name, skel, subframes, 0.013889)
keyframes[feature] = keyframes[feature][:-1]
for keyframe in keyframes[feature]:
subframes = frames[keyframe[0]:keyframe[1]]
name = str(keyframe[0]) + '_' + str(keyframe[1]) \
+ '_' + feature + '_' + mname
BVHWriter(outputpath + os.sep + name, skel, subframes, 0.013889)
counter += 1.0
def load_skeleton(path, skeleton_type=None):
bvh = BVHReader(path)
skeleton = SkeletonBuilder().load_from_bvh(bvh)
skeleton.skeleton_model = load_skeleton_model(skeleton_type)
return skeleton