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