def _build_from_zip_file(self, ms_graph):
zip_path = self.motion_state_graph_path + ".zip"
zip_reader = ZipReader(zip_path, pickle_objects=True)
graph_data = zip_reader.get_graph_data()
self.pfnn_data = zip_reader.get_pfnn_data()
if SKELETON_BVH_STRING_KEY in graph_data.keys():
bvh_reader = BVHReader("").init_from_string(
graph_data[SKELETON_BVH_STRING_KEY])
ms_graph.skeleton = SkeletonBuilder().load_from_bvh(bvh_reader)
elif SKELETON_JSON_KEY in graph_data.keys():
#use_all_joints = False
if self.use_all_joints and "animated_joints" in graph_data[
SKELETON_JSON_KEY]:
del graph_data[SKELETON_JSON_KEY]["animated_joints"]
ms_graph.skeleton = SkeletonBuilder().load_from_json_data(
graph_data[SKELETON_JSON_KEY],
use_all_joints=self.use_all_joints)
print("load skeleton", ms_graph.skeleton.animated_joints)
else:
raise Exception("There is no skeleton defined in the graph file")
return
ms_graph.animated_joints = ms_graph.skeleton.animated_joints
ms_graph.mgrd_skeleton = convert_to_mgrd_skeleton(ms_graph.skeleton)
transition_dict = graph_data["transitions"]
actions = graph_data["subgraphs"]
for action_name in actions.keys():
node_group = self.build_node_group_from_dict(
actions[action_name], ms_graph)
ms_graph.nodes.update(node_group.nodes)
ms_graph.node_groups[node_group.ea_name] = node_group
if action_name == "walk" and len(node_group.idle_states) > 0:
idle_mp = node_group.idle_states[0]
ms_graph.start_node = (action_name, idle_mp)
self._set_transitions_from_dict(ms_graph, transition_dict)
self._update_motion_state_stats(ms_graph, recalculate=False)
if "hand_pose_info" in graph_data:
ms_graph.hand_pose_generator = HandPoseGenerator(ms_graph.skeleton)
ms_graph.hand_pose_generator.init_from_desc(
graph_data["hand_pose_info"])
if "actionDefinitions" in graph_data:
ms_graph.action_definitions = graph_data["actionDefinitions"]
if "startNode" in graph_data:
start_node = list(graph_data["startNode"])
if start_node[1].startswith("walk"):
start_node[1] = start_node[1][5:]
ms_graph.start_node = tuple(start_node)
def load_motion_vector_from_bvh_str(self, bvh_str):
bvh_reader = get_bvh_from_str(bvh_str)
animated_joints = list(bvh_reader.get_animated_joints())
motion_vector = MotionVector()
motion_vector.from_bvh_reader(bvh_reader, False)
motion_vector.skeleton = SkeletonBuilder().load_from_bvh(
bvh_reader, animated_joints)
return motion_vector
def load_skeleton(self, skeleton_name):
data, skeleton_model = self.get_skeleton_by_name(skeleton_name)
if data is not None:
data = bz2.decompress(data)
data = bson.loads(data)
add_extra_end_site = False
print("load default", len(data["referencePose"]["rotations"]))
skeleton = SkeletonBuilder().load_from_custom_unity_format(
data, add_extra_end_site=add_extra_end_site)
if skeleton_model is not None:
try:
skeleton_model = bz2.decompress(skeleton_model)
skeleton_model = bson.loads(skeleton_model)
skeleton.skeleton_model = skeleton_model
except Exception as e:
print("Could not load skeleton model", e.args)
return skeleton
def load_skeleton_and_animations_from_fbx(file_path):
mesh_list, skeleton_def, animations = load_fbx_file(file_path)
skeleton = SkeletonBuilder().load_from_fbx_data(skeleton_def)
anim_names = list(animations.keys())
motion_vectors = []
if len(anim_names) > 0:
anim_name = anim_names[0]
mv = MotionVector()
mv.from_fbx(animations[anim_name], skeleton.animated_joints)
motion_vectors.append(mv)
return skeleton, motion_vectors
def load_skeleton_legacy(self, skeleton_name):
skeleton = None
bvh_str, skeleton_model = self.get_skeleton_by_name_legacy(
skeleton_name)
ref_bvh = get_bvh_from_str(bvh_str)
animated_joints = list(ref_bvh.get_animated_joints())
n_joints = len(animated_joints)
print("animated joints", len(animated_joints))
if n_joints > 0:
skeleton = SkeletonBuilder().load_from_bvh(
ref_bvh, animated_joints, skeleton_model=skeleton_model)
return skeleton
def build_from_database(self,
db_url,
skeleton_name,
graph_id,
frame_time=None):
ms_graph = MotionStateGraph()
graph_data = download_graph_from_remote_db(db_url, graph_id)
if type(graph_data) == str:
graph_data = json.loads(graph_data)
skeleton_data = get_skeleton_from_remote_db(db_url, skeleton_name)
ms_graph.skeleton = SkeletonBuilder().load_from_custom_unity_format(
skeleton_data)
if frame_time is not None:
ms_graph.skeleton.frame_time = frame_time
ms_graph.skeleton.skeleton_model = get_skeleton_model_from_remote_db(
db_url, skeleton_name)
ms_graph.mgrd_skeleton = convert_to_mgrd_skeleton(ms_graph.skeleton)
ms_graph.action_definitions = dict()
transitions = dict()
for a in graph_data["nodes"]:
meta_info = dict()
start_states = []
end_states = []
idle_states = []
single_states = []
action_def = dict()
action_def["name"] = a
action_def["nodes"] = dict()
action_def["constraint_slots"] = dict()
motion_primitives = graph_data["nodes"][a]
for model_id in motion_primitives:
mp_name = motion_primitives[model_id]["name"]
if mp_name.startswith("walk"):
mp_name = mp_name[5:]
print("load", mp_name)
motion_state_def = dict()
motion_state_def["name"] = mp_name
mp_type = motion_primitives[model_id]["type"]
if mp_type == "start":
start_states.append(mp_name)
elif mp_type == "end":
end_states.append(mp_name)
elif mp_type == "idle":
idle_states.append(mp_name)
elif mp_type == "single":
single_states.append(mp_name)
mp_transitions = list(
motion_primitives[model_id]["transitions"].keys())
mp_transitions = [
key if not key[5:].startswith("walk") else key[:5] +
key[10:] for key in mp_transitions
]
mp_transitions = [
key.split(":") if ":" in key else None
for key in mp_transitions
]
transitions[(a, mp_name)] = mp_transitions
model_data_str = download_motion_model_from_remote_db(
db_url, model_id)
if model_data_str is None:
print("Could not load model")
continue
try:
motion_state_def["mm"] = json.loads(model_data_str)
except:
print("Could not load model")
continue
# store keyframes in action definition
if "keyframes" in motion_state_def["mm"]:
for key in motion_state_def["mm"]["keyframes"]:
action_def["constraint_slots"][key] = {
"node": mp_name,
"joint": "left_wrist"
}
cluster_tree_data_str = download_cluster_tree_from_remote_db(
db_url, model_id)
if cluster_tree_data_str is not None and len(
cluster_tree_data_str) > 0:
try:
motion_state_def["space_partition_json"] = json.loads(
cluster_tree_data_str)
except:
print("Could not load tree")
action_def["nodes"][mp_name] = motion_state_def
meta_info["start_states"] = start_states
meta_info["end_states"] = end_states
meta_info["idle_states"] = idle_states
meta_info["single_states"] = single_states
action_def["info"] = meta_info
node_group = self.build_node_group_from_dict(action_def, ms_graph)
ms_graph.nodes.update(node_group.nodes)
ms_graph.node_groups[node_group.ea_name] = node_group
if a == "walk" and len(node_group.idle_states) > 0:
idle_mp = node_group.idle_states[0]
ms_graph.start_node = (a, idle_mp)
# store action definition for constraint builder
action_def["node_sequence"] = []
if len(motion_primitives) == 1:
mp_id = list(motion_primitives.keys())[0]
mp_name = motion_primitives[mp_id]["name"]
action_def["node_sequence"] = [[mp_name, "single_primitive"]]
action_def["start_states"] = start_states
action_def["end_states"] = end_states
action_def["idle_states"] = idle_states
ms_graph.action_definitions[a] = action_def
for from_node_key in transitions:
for to_node_key in transitions[from_node_key]:
if to_node_key is not None:
self._add_transition(ms_graph, from_node_key,
tuple(to_node_key))
self._update_motion_state_stats(ms_graph, recalculate=True)
if "start_node" in graph_data:
start_node = graph_data["start_node"]
if start_node[1].startswith("walk"):
start_node[1] = start_node[1][5:]
ms_graph.start_node = tuple(start_node)
print("set start", ms_graph.start_node)
return ms_graph
def load_skeleton(self, skeleton_path):
bvh = BVHReader(skeleton_path)
self.animated_joints = list(bvh.get_animated_joints())
if has_mgrd:
self.mgrd_skeleton = MGRDSkeletonBVHLoader(skeleton_path).load()
self.skeleton = SkeletonBuilder().load_from_bvh(BVHReader(skeleton_path), self.animated_joints)
def load_skeleton_from_bvh_str(self, bvh_str):
bvh_reader = get_bvh_from_str(bvh_str)
animated_joints = list(bvh_reader.get_animated_joints())
skeleton = SkeletonBuilder().load_from_bvh(bvh_reader, animated_joints)
return skeleton