Added BVH to exponensial map conversion

Author: Svito-zar

data_processing/bvh2features.py

@@ -0,0 +1,86 @@
+# This code was written by Simon Alexanderson
+# and is released here: https://github.com/simonalexanderson/PyMO
+
+import numpy as np
+import pandas as pd
+from sklearn.pipeline import Pipeline
+
+from argparse import ArgumentParser
+
+import glob
+import os
+import sys
+module_path = os.path.abspath(os.path.join('..'))
+if module_path not in sys.path:
+    sys.path.append(module_path)
+
+from pymo.parsers import BVHParser
+from pymo.data import Joint, MocapData
+from pymo.preprocessing import *
+from pymo.viz_tools import *
+from pymo.writers import *
+
+import joblib as jl
+
+
+def extract_joint_angles(bvh_dir, files, dest_dir, pipeline_dir, fps):
+    p = BVHParser()
+
+    data_all = list()
+    for f in files:
+        ff = os.path.join(bvh_dir, f + '.bvh')
+        print(ff)
+        data_all.append(p.parse(ff))
+
+    data_pipe = Pipeline([
+       ('dwnsampl', DownSampler(tgt_fps=fps,  keep_all=False)),
+       ('root', RootTransformer('hip_centric')),
+       ('mir', Mirror(axis='X', append=True)),
+       ('jtsel', JointSelector(['Spine','Spine1','Spine2','Spine3','Neck','Neck1','Head','RightShoulder', 'RightArm', 'RightForeArm', 'RightHand', 'LeftShoulder', 'LeftArm', 'LeftForeArm', 'LeftHand'], include_root=True)),
+       ('exp', MocapParameterizer('expmap')), 
+       ('cnst', ConstantsRemover()),
+       ('np', Numpyfier())
+    ])
+
+    out_data = data_pipe.fit_transform(data_all)
+    
+    # the datapipe will append the mirrored files to the end
+    assert len(out_data) == 2*len(files)
+    
+    jl.dump(data_pipe, os.path.join(pipeline_dir + 'data_pipe.sav'))
+        
+    fi=0
+    for f in files:
+        ff = os.path.join(dest_dir, f)
+        print(ff)
+        np.savez(ff + ".npz", clips=out_data[fi])
+        np.savez(ff + "_mirrored.npz", clips=out_data[len(files)+fi])
+        fi=fi+1
+
+
+
+if __name__ == '__main__':
+
+    # Setup parameter parser
+    parser = ArgumentParser(add_help=False)
+    parser.add_argument('--bvh_dir', '-orig', default="./data/",
+                                   help="Path where original motion files (in BVH format) are stored")
+    parser.add_argument('--dest_dir', '-dest', default="./processed/",
+                                   help="Path where extracted motion features will be stored")
+    parser.add_argument('--pipeline_dir', '-pipe', default="./utils/",
+                        help="Path where the motion data processing pipeline will be stored")
+
+    params = parser.parse_args()
+
+    files = []
+    # Go over all BVH files
+    print("Going to pre-process the following motion files:")
+    for r, d, f in os.walk(params.bvh_dir):
+        for file in f:
+            print(file)
+            if '.bvh' in file:
+                ff=os.path.join(r, file)
+                basename = os.path.splitext(os.path.basename(ff))[0]
+                files.append(basename)
+
+    extract_joint_angles(params.bvh_dir, files, params.dest_dir, params.pipeline_dir , fps=20)

data_processing/features2bvh.py

@@ -0,0 +1,37 @@
+# This code was written by Simon Alexanderson
+# and is released here: https://github.com/simonalexanderson/PyMO
+
+
+import os
+import sys
+
+module_path = os.path.abspath(os.path.join('..'))
+if module_path not in sys.path:
+    sys.path.append(module_path)
+
+from pymo.parsers import BVHParser
+from pymo.data import Joint, MocapData
+from pymo.preprocessing import *
+from pymo.viz_tools import *
+from pymo.writers import *
+
+import joblib as jl
+
+# load data pipeline
+pipeline = jl.load('processed/data_pipe.sav')
+
+def feat2bvh(feat_file, bvh_file):
+    features = np.load(feat_file)['clips']
+    print(features.shape)
+
+    # transform the data back to it's original shape
+    # note: in a real scenario this is usually done with predicted data   
+    # note: some transformations (such as transforming to joint positions) are not inversible
+    bvh_data=pipeline.inverse_transform([features])
+
+    # Test to write some of it to file for visualization in blender or motion builder
+    writer = BVHWriter()
+    with open(bvh_file,'w') as f:
+        writer.write(bvh_data[0], f)
+
+feat2bvh("processed/NaturalTalking_002.npz", 'processed/converted2.bvh')

data_processing/pymo/__init__.py

@@ -0,0 +1,53 @@
+import numpy as np
+
+class Joint():
+    def __init__(self, name, parent=None, children=None):
+        self.name = name
+        self.parent = parent
+        self.children = children
+
+class MocapData():
+    def __init__(self):
+        self.skeleton = {}
+        self.values = None
+        self.channel_names = []
+        self.framerate = 0.0
+        self.root_name = ''
+    
+    def traverse(self, j=None):
+        stack = [self.root_name]
+        while stack:
+            joint = stack.pop()
+            yield joint
+            for c in self.skeleton[joint]['children']:
+                stack.append(c)
+
+    def clone(self):
+        import copy
+        new_data = MocapData()
+        new_data.skeleton = copy.deepcopy(self.skeleton)
+        new_data.values = copy.deepcopy(self.values)
+        new_data.channel_names = copy.deepcopy(self.channel_names)
+        new_data.root_name = copy.deepcopy(self.root_name)
+        new_data.framerate = copy.deepcopy(self.framerate)
+        return new_data
+
+    def get_all_channels(self):
+        '''Returns all of the channels parsed from the file as a 2D numpy array'''
+
+        frames = [f[1] for f in self.values]
+        return np.asarray([[channel[2] for channel in frame] for frame in frames])
+
+    def get_skeleton_tree(self):
+        tree = []
+        root_key =  [j for j in self.skeleton if self.skeleton[j]['parent']==None][0]
+        
+        root_joint = Joint(root_key)
+    
+    def get_empty_channels(self):
+        #TODO
+        pass
+
+    def get_constant_channels(self):
+        #TODO
+        pass

data_processing/pymo/data.py

@@ -0,0 +1,43 @@
+'''
+A set of mocap feature extraction functions
+
+Created by Omid Alemi | Nov 17 2017
+
+'''
+import numpy as np
+import pandas as pd
+import peakutils
+import matplotlib.pyplot as plt
+
+def get_foot_contact_idxs(signal, t=0.02, min_dist=120):
+    up_idxs = peakutils.indexes(signal, thres=t/max(signal), min_dist=min_dist)
+    down_idxs = peakutils.indexes(-signal, thres=t/min(signal), min_dist=min_dist)
+
+    return [up_idxs, down_idxs]
+
+
+def create_foot_contact_signal(mocap_track, col_name, start=1, t=0.02, min_dist=120):
+    signal = mocap_track.values[col_name].values
+    idxs = get_foot_contact_idxs(signal, t, min_dist)
+
+    step_signal = []
+
+    c = start
+    for f in range(len(signal)):    
+        if f in idxs[1]:
+            c = 0
+        elif f in idxs[0]:
+            c = 1
+                                            
+        step_signal.append(c)
+    
+    return step_signal
+
+def plot_foot_up_down(mocap_track, col_name, t=0.02, min_dist=120):
+    
+    signal = mocap_track.values[col_name].values
+    idxs = get_foot_contact_idxs(signal, t, min_dist)
+
+    plt.plot(mocap_track.values.index, signal)
+    plt.plot(mocap_track.values.index[idxs[0]], signal[idxs[0]], 'ro')
+    plt.plot(mocap_track.values.index[idxs[1]], signal[idxs[1]], 'go')

data_processing/pymo/features.py

@@ -0,0 +1,3 @@
+var dataBuffer = `$$DATA$$`;
+
+start(dataBuffer);