Upload 11 files

REC-MV_preprocess.md

@@ -0,0 +1,68 @@
+# This is the tutorial of data processing of REC-MV.
+
+The data pre-processing part includes img, mask, normal, parsing (garment segmentation), camera, smpl parameters (beta & theta), featurelines, skinning weight.
+## Step0
+set up the environment (or you can directly use REC-MV environment)
+```
+pip install -r requirements.txt
+```
+
+
+## Step1
+You should make directory to save all processed data, named, to say, xiaoming.
+And you turn the video into images:
+```
+encodepngffmpeg()
+{
+	# $1: target folder
+	# $2: save video name
+    ffmpeg -r ${1} -pattern_type glob -i '*.png' -vcodec libx264 -crf 18 -vf "pad=ceil(iw/2)*2:ceil(ih/2)*2" -pix_fmt yuv420p ${2}
+}
+
+
+encodepngffmpeg 30 ./xiaoming.mp4
+```
+Then, your data directory:
+```
+xiaoming/
+└── imgs
+```
+## Step2 Normal, Parsing, and Mask
+Get the normal map, parsing mask, masks.
+```
+python prcess_data_all.py --gid <gpu_id> --root <Your data root> --gender <data gender>
+# example
+python prcess_data_all.py --gid 0 --root /data/xiaoming --gender male 
+```
+Your data directory:
+```
+xiaoming/
+├── imgs
+├── masks
+├── normals
+└── parsing_SCH_ATR
+```
+
+## Step3 SMPL & Camera
+To get smpl paramaters (pose and shape), here we use [videoavatar](https://github.com/thmoa/videoavatars):
+- Set up the env (**Note it use python2**)
+- Prepare keypoints files for each frame in the video and put them under `xiaoming/openpose`, which I use [Openpose](https://github.com/CMU-Perceptual-Computing-Lab/openpose).
+- Run three python files in videoavatars/prepare_data, you'll get `keypoints.hdf5, masks.hdf5, camera.hdf5.` Or you can just use my script: ```cd videoavatars; python get_reconstructed_poses.py --root xiaoming --out xiaoming --gender male```
+- `bash run_step1.sh`
+
+After you run through videoavatar, you will get `camera.pkl, reconstructed_poses.hdf5`. Put it also under the root(xiaoming).
+
+You can get `smpl_rec.npz, camera.npz` by running:
+```
+python get_smpl_rec_camera.py --root xiaoming --save_root xiaoming --gender male
+```
+
+**Note: You can use any other smpl estimation algorithm, but you should follow the way how smpl_rec.npz save pose, shape, and trans.**
+
+## Step4 Skining Weight
+We follow [fite](https://github.com/jsnln/fite) to get the lbs skinning weight to prevent artifacts.
+
+ In fite's readme, you'll get a skining weight cube after finishing 3.Diffused Skinning. Name it `diffused_skinning_weights.npy` and put it under xiaoming.
+ 
+
+

depth2normal.py

@@ -0,0 +1,146 @@
+import cv2
+from cv2 import imread
+import numpy as np
+from numpy import unique, load
+import argparse
+import os, os.path as osp
+import tqdm
+import pdb
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--root', type=str, required=True, help='root dir of one identity')
+    parser.add_argument('--cam_file', type=str,  default='camera.npz')
+
+    parser.add_argument('--depth_dir',  help='depth map path', default='depth', type=str)
+    parser.add_argument('--out_dir', '-n',  help='outputnormal path', default='normal_depth', type=str)
+    parser.add_argument('--mask_dir', help='mask path', default='masks', type=str)
+    parser.add_argument('--mask_total_dir',  help='total mask path', default='masks_total', type=str)
+    args = parser.parse_args()
+    return args
+
+def get_surface_normal_by_depth(depth, fx, fy):
+    """
+    depth: (h, w) of float, the unit of depth is meter
+    K: (3, 3) of float, the depth camere's intrinsic
+    """
+
+    dz_dv, dz_du = np.gradient(depth)  # u, v mean the pixel coordinate in the image
+    # u*depth = fx*x + cx --> du/dx = fx / dept
+    # smooth
+    # dz_du = cv2.Sobel(depth, cv2.CV_64F, 1, 0, ksize=5)     
+    # dz_dv = cv2.Sobel(depth, cv2.CV_64F, 0, 1, ksize=5)
+    du_dx = fx / depth  # x is xyz of camera coordinate
+    dv_dy = fy / depth
+
+    dz_dx = dz_du * du_dx
+    dz_dy = dz_dv * dv_dy
+    # cross-product (1,0,dz_dx)X(0,1,dz_dy) = (-dz_dx, -dz_dy, 1)
+    normal_cross = np.dstack((-dz_dx, -dz_dy, np.ones_like(depth)))
+    # normalize to unit vector
+    normal_unit = normal_cross / np.linalg.norm(normal_cross, axis=2, keepdims=True)
+    # set default normal to [0, 0, 1]
+    # pdb.set_trace()
+    nan_mask = np.isfinite(normal_unit).all(2)
+    normal_unit[~np.isfinite(normal_unit).all(2)] = [-1, -1, -1]
+    return normal_unit, nan_mask
+
+# def delete_holes(img):
+#     im = img.copy()
+#     h, w = im.shape[:2]
+#     mask = np.zeros((h+2, w+2), dtype=np.uint8)
+#     holes = cv2.floodFill(im.copy(), mask, (0, 0), 255)[1]
+#     holes = ~holes
+#     im[holes == 255] = 255
+#     return im
+def denoise(img):
+    
+    kernel = np.ones((11, 11), np.uint8)
+    img= cv2.erode(img, kernel, iterations=2)
+    img= cv2.dilate(img, kernel, iterations=2)
+
+    return img
+
+def main():
+    args = parse_args()
+    root = args.root
+    cam_file = osp.join(root, args.cam_file)
+    depth_dir = osp.join(root, args.depth_dir)
+    out_dir = osp.join(root, args.out_dir)
+    os.makedirs(out_dir, exist_ok=True)
+    mask_dir = osp.join(root, args.mask_dir)
+    mask_total_dir = osp.join(root, args.mask_total_dir)
+    os.makedirs(mask_total_dir, exist_ok=True)
+
+    cam = np.load(cam_file)
+    fx, fy = cam['fx'], cam['fy']
+
+    assert osp.exists(depth_dir), 'depth dir not exists'
+
+    depth_paths = sorted([
+        osp.join(depth_dir, f) for f in os.listdir(depth_dir)])
+    mask_paths = sorted([osp.join(mask_dir, f) for f in os.listdir(mask_dir)])
+
+
+    assert depth_paths[0].endswith('.npy'), 'depth dir must be .npy'
+
+    # [-1,1] -> [0, 2]/2 -> [0,1]*255 -> [0,255]
+    vis_normal = lambda normal: np.uint8((normal + 1) / 2 * 255)[..., ::-1]
+    for idx, depth_p in enumerate(depth_paths):
+
+        # mask is [0, 1]
+        mask = cv2.imread(mask_paths[idx], -1)[..., 0] / 255
+        assert len(mask.shape) == 2, 'dims of mask are not 2'
+
+        depth = np.load(depth_p) # the unit of depth is meter
+        # the val of normal is between [-1, 1]
+        normal, nan_mask = get_surface_normal_by_depth(depth, fx, fy)
+        mask_total = nan_mask * mask
+        #mask_total = denoise(mask_total)
+        # normal should be filtered by mask and nan_mask
+        normal = vis_normal(normal) * mask_total[..., None]
+        
+        cv2.imwrite(osp.join(out_dir, f'{idx:05d}.png'), normal)
+        cv2.imwrite(osp.join(mask_total_dir, f'{idx:05d}.png'), mask_total.astype(np.uint8) * 255)
+        #cv2.imwrite(osp.join(root, 'nan_mask.png'), nan_mask.astype(np.uint8))
+        #xxx
+        
+
+
+if __name__ == '__main__':
+    #os.makedirs(args.normalPath, exist_ok = True)
+    main()
+    '''    if args.totalmaskPath:
+        os.makedirs(args.totalmaskPath, exist_ok = True)
+    for img_name in tqdm.tqdm(sorted(os.listdir(args.depthPath))):
+        img_path = os.path.join(args.depthPath, img_name)
+        depth = cv2.imread(img_path, -1) / 1000.0
+        normal, nan_mask = get_surface_normal_by_depth(depth)
+        
+        vis_normal = lambda normal: np.uint8((normal + 1) / 2 * 255)[..., ::-1]
+        normal = vis_normal(normal)
+        if args.maskPath:
+            mask_path = os.path.join(args.maskPath, img_name[:-4] + '_mask' + img_name[-4:])
+            mask = cv2.imread(mask_path)
+            mask = cv2.rotate(mask, cv2.ROTATE_90_CLOCKWISE)
+            total_mask = mask[..., 0] * nan_mask
+            # cv2.imwrite(os.path.join(args.totalmaskPath, img_name), np.uint8(nan_mask*255))
+            # cv2.imwrite(os.path.join(args.totalmaskPath, img_name), total_mask)
+            kernel = np.ones((11, 11), np.uint8)
+            total_mask = cv2.erode(total_mask, kernel, iterations=1)
+            total_mask = cv2.dilate(total_mask, kernel, iterations=1)
+            # pdb.set_trace()
+            normal = np.uint8(total_mask[..., None]/255) * normal
+        
+        if args.totalmaskPath:
+            # cv2.imwrite(os.path.join(args.totalmaskPath, img_name), delete_holes(total_mask))
+            total_mask = cv2.rotate(total_mask, cv2.ROTATE_90_COUNTERCLOCKWISE)
+            cv2.imwrite(os.path.join(args.totalmaskPath, img_name), total_mask)
+            # pdb.set_trace()
+
+        normal_path = os.path.join(args.normalPath, img_name)
+        normal = cv2.rotate(normal, cv2.ROTATE_90_COUNTERCLOCKWISE)
+        cv2.imwrite(normal_path, normal)
+  
+    '''
+

get_smpl_rec_camera.py

@@ -0,0 +1,84 @@
+'''
+@Desc: From camera.pkl and reconstructed_poses.hdf5, get the camera.npz and smpl_rec.npz
+Example: python xxx.py --root /home/zjp/DeepDynamicFashion/Data_depth/xinyu_a --save_root /home/zjp/DeepDynamicFashion/Data_depth/xinyu_a --gender female
+'''
+import h5py
+import pickle
+import numpy as np
+import torch
+import os
+import os.path as osp
+import cv2
+from tqdm import tqdm
+from glob import glob
+import shutil
+import argparse
+parser = argparse.ArgumentParser(description='neu video body rec')
+parser.add_argument('--root',default=None,metavar='M',
+                        help='data root')
+parser.add_argument('--sid',default=0,type=int,metavar='IDs',
+					help='start frame index')
+parser.add_argument('--save_root',default=None,metavar='M',
+	help='save data root')
+parser.add_argument('--gender', type=str, default='female')
+args = parser.parse_args()
+
+root=args.root
+sid=args.sid
+gender=args.gender
+save_root=args.save_root
+os.makedirs(save_root,exist_ok=True)
+
+#rgb_root=osp.join(save_root,'imgs')
+#if not osp.isdir(rgb_root):
+#	os.makedirs(rgb_root)
+#
+img_files = sorted(glob(os.path.join(root,'imgs/*.jpg')))
+frame_num = len(img_files)
+
+#for ind in tqdm(range(len(img_files)),desc='rgbs'):
+#    src_img = img_files[ind]
+#    target_img = osp.join(rgb_root,'%06d.jpg'%(ind-sid))
+#    shutil.copy2(src_img, target_img)
+
+
+with h5py.File(osp.join(root,'reconstructed_poses.hdf5'),'r') as ff:
+    shape=ff['betas'][:].reshape(10)
+    poses=ff['pose'][:].reshape(-1,24,3)[sid:,:,:]
+    trans=ff['trans'][:].reshape(-1,3)[sid:,:]
+    assert(poses.shape[0]>=frame_num-sid and trans.shape[0]>=frame_num-sid)
+    np.savez(osp.join(save_root,'smpl_rec.npz'),poses=poses,shape=shape,trans=trans,gender=gender)
+
+#with h5py.File(osp.join(root,'masks.hdf5'),'r') as ff:
+#	fnum=ff['masks'].shape[0]
+#	assert fnum>sid
+#	mask_root=osp.join(save_root,'masks')
+#	os.makedirs(mask_root,exist_ok=True)
+#	for ind in tqdm(range(sid,fnum),desc='masks'):
+#		cv2.imwrite(osp.join(mask_root,'%06d.png'%(ind-sid)),ff['masks'][ind]*255)
+
+
+with open(osp.join(root,'camera.pkl'),'rb') as ff:
+    cam_data=pickle.load(ff,encoding='latin1')
+    ps=cam_data['camera_c']
+    fs=cam_data['camera_f']
+    trans=cam_data['camera_t']
+    rt=cam_data['camera_rt']
+    assert(np.linalg.norm(rt)<0.0001) # The cameras of snapshot dataset seems no rotation and translation
+    H=cam_data['height']
+    W=cam_data['width']
+
+    quat=np.array([np.cos(np.pi/2.),0.,0.,np.sin(np.pi/2.)])
+    T=trans
+    fx=fs[0]
+    fy=fs[1]
+    cx=ps[0]
+    cy=ps[1]
+    print(fx,fy,cx,cy,quat,T)
+
+    np.savez(osp.join(save_root,'camera.npz'),fx=fx,fy=fy,cx=cx,cy=cy,quat=quat,T=T)
+
+
+
+
+

inference.py

@@ -0,0 +1,31 @@
+'''
+This file is written to finish the preprocess of REC-MV:
+- mask
+- normal
+- smpl params
+- parse masks
+'''
+
+import json, os, os.path as osp, sys, shutil, glob, pdb, argparse
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--root', type=str)
+    parser.add_argument('--avatar_dir', type=str)
+    args = parser.parse_args()
+    return args
+
+def main():
+    args = parse_args()
+    root = args.root
+    # TODO: get mask
+
+    # TODO: get normal
+    os.system('cd ./pifuhd && python generate_normals.py --imgpath {}'.format(osp.join(root, 'imgs')))
+    # get smpl_rec.npz
+    avatar_dir = osp.join(args.root, args.avatar_dir)
+    os.system('cd ./videoavatars && python get_reconstructed_poses.py --root {} --out {}'.format(args.root, avatar_dir))
+    os.system('cd ../ && python get_smpl_rec_camera.py --root {} --save-root {}'.format(args.root, args.root))
+
+if __name__ == '__main__':
+    main()

mv_featurelines.py

@@ -0,0 +1,42 @@
+'''
+@File    :  mv_featurelines.py
+@Author  :  Jiapeng Zhou
+@Desc    :  move part of featurelines to another annotation labelme json files (bottom_curve are good, but left_cuff arenot)
+'''
+
+import os, os.path as osp, sys, pdb, json, shutil, argparse
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--src-dir', type=str)
+    parser.add_argument('--dst-dir', type=str)
+    args = parser.parse_args()
+    return args
+
+def main():
+    args = parse_args()
+    src_dir = args.src_dir
+    dst_dir = args.dst_dir
+    src_files = sorted([osp.join(src_dir, f) for f in os.listdir(src_dir) if f.endswith('.json')])
+    dst_files = sorted([osp.join(dst_dir, f) for f in os.listdir(dst_dir) if f.endswith('.json')])
+    assert len(src_files) == len(dst_files), 'src_files and dst_files should have same length'
+    for idx, (src_file, dst_file) in enumerate(zip(src_files, dst_files)):
+        with open(src_file) as fp:
+            src_json = json.load(fp)
+        with open(dst_file) as fp:
+            dst_json = json.load(fp)
+        src_shapes = src_json['shapes']
+        dst_shapes = dst_json['shapes']
+
+        for src_shape in src_shapes:
+            if src_shape['label'] == 'bottom_curve':
+                dst_shapes.append(src_shape)
+        dst_json['shapes'] = dst_shapes
+
+        with open(dst_file, 'w') as fp:
+            json.dump(dst_json, fp)
+        print('finish {}/{}'.format(idx+1, len(src_files)))
+        
+
+if __name__ == '__main__':
+    main()

normal_test.py

@@ -0,0 +1,34 @@
+'''
+@Description: The script is to transfer the normal map from world coordinate to camera coordinate
+'''
+import os, os.path as osp, numpy as np, cv2, argparse, tqdm, pdb
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--root', type=str)
+    parser.add_argument('--out_dir', type=str, default='normal_test')
+    return parser.parse_args()
+
+def convert_normal_map():
+    args = parse_args()
+    normal_dir = osp.join(args.root, 'normals')
+    normal_paths = sorted([osp.join(normal_dir, name) for name in os.listdir(normal_dir)])
+    out_dir = osp.join(args.root, args.out_dir)
+    os.makedirs(out_dir, exist_ok=True) 
+    
+    for idx, norm_f in enumerate(normal_paths):
+        normals = cv2.imread(norm_f)[:, :, ::-1]
+        normals = 2.* normals.astype(np.float32)/255. - 1. # [0, 255] -> [-1, 1]
+        normals = 
+        cv2.imwrite(osp.join(out_dir, f'{idx:05d}.png'), normals)
+        pdb.set_trace()
+        
+
+
+
+
+def main():
+    convert_normal_map()
+    
+if __name__ == '__main__':
+    main()

parsing_mask_to_fl.py

@@ -0,0 +1,388 @@
+"""
+@File: parsing_mask_to_fl.py
+@Author: Lingteng Qiu
+@Email: qiulingteng@link.cuhk.edu.cn
+@Date: 2022-10-19
+@Desc: parsing mask to polygons, given a series of mask infos
+"""
+import sys
+sys.path.extend('./')
+import argparse
+import os
+import glob
+import os.path as osp
+import numpy as np
+import cv2
+import pdb
+import cv2
+import json
+from pytorch3d.ops.knn import knn_points
+import torch
+from utils.constant import FL_EXTRACT, TEMPLATE_GARMENT
+'''
+关于如何从parsing_mask提取featureline：
+需要 parse_mask，标的两个点的json文件，但是如果出现了手遮挡住腰间的情况(或者头发遮挡neck)，那么就要标注六个点绕过去
+'''
+
+FL_COLOR = {
+    'neck':(0, 0, 255),
+    'right_cuff': (0, 255, 0),
+    'left_cuff':(255, 0, 0),
+    'left_pant': (127, 127, 0),
+    'right_pant':(0, 127, 127),
+    'upper_bottom': (127, 0, 127),
+    'bottom_curve':(0, 127, 127),
+}
+
+def draw_lines(pts, color, img=None):
+    #pdb.set_trace()
+    if img is None:
+        img = np.zeros((1080, 1080, 3), np.uint8)
+    for i in range(len(pts)-1):
+        cv2.line(img, (int(pts[i][0]), int(pts[i][1])), (int(pts[i+1][0]), int(pts[i+1][1])), color, 2)
+    return img
+
+def draw_pts(pts, color, img=None):
+    #pdb.set_trace()
+    if img is None:
+        img = np.zeros((1080, 1080, 3), np.uint8)
+    for i, pt in enumerate(pts):
+        cv2.circle(img, (int(pt[0]), int(pt[1])), 2, color, -1)
+    return img
+        
+    
+class PolyMask(object):
+    def __init__(self, mask):
+        self.mask = mask
+
+    def query(self,query_sets ,labels, garment_key):
+        '''
+        query_sets 必须要偶数个 why?
+        1、计算featureline和mask的交点
+        2、如果交点数 > 2，找到一个交点对（两个交点），线段在特征线上并且在mask中的部分最长
+        3、通过这个交点对来获得featureline: 交点对 + 两点之间的mask边界
+        Args:
+            labels: only cloth?
+        '''
+
+        mask = np.zeros_like(self.mask, dtype= np.bool)
+        #pdb.set_trace()
+
+        for label in labels:
+            label_mask = np.zeros_like(self.mask, dtype =np.bool)
+            #pdb.set_trace()
+            i,j = np.where(self.mask == label)
+            label_mask[i,j] = True
+
+            mask |= label_mask
+
+        # [0, 255]
+        mask = mask.astype(np.uint8)*255
+        mask = self.smooth_noise(mask)
+
+        mask_polygons, mask_area = self.mask2polygon(mask)
+#        img_org = cv2.imread('./debug/多边形.png', -1)
+#        img=draw_lines(query_sets['neck'], (0, 255, 0), img_org)
+        length_dp = []
+        for mask_polygon in mask_polygons:
+            #pdb.set_trace()
+            dis = [0]
+            dis.extend([abs(mask_polygon[p_i][0]- mask_polygon[p_i+1][0]) + abs(mask_polygon[p_i][1]- mask_polygon[p_i+1][1]) for p_i in range(mask_polygon.shape[0]-1)])
+            dis.append(abs(mask_polygon[0][0]- mask_polygon[-1][0]) + abs(mask_polygon[0][1]- mask_polygon[-1][1]))
+            # 累计距离
+            dp = np.cumsum(dis)
+            length_dp.append(dp)
+        new_query_sets = {}
+        reply_pts = np.concatenate(mask_polygons, axis=0)
+        reply_pts = torch.from_numpy(reply_pts).float().cuda()
+
+        #pdb.set_trace()
+
+        for key in query_sets.keys():
+            polygon = query_sets[key]
+            # len(featureline points) % 2 == 0
+            assert polygon.shape[0] % 2 == 0
+            # 两两组合
+            polygons = polygon.reshape(-1, 2, 2)
+
+            group = []
+            for group_id, mask_polygon in enumerate(mask_polygons):
+                group.extend([group_id for i in range(mask_polygon.shape[0])])
+            group =  torch.tensor(group).long()
+            new_polygons=[]
+            pre_polygon = None
+            # 循环每个顶点对
+            for polygon in polygons:
+
+                polygon = torch.from_numpy(polygon).float().cuda()
+                if pre_polygon is not None:
+                    dis = torch.sqrt(((polygon[0] - pre_polygon[-1]) **2).sum())
+                    # if two pts are close, directly add the polygon the new_polygons, avoid the situation that the hands or hair block the mask
+                    if dis < 10:
+                        new_polygons.append(polygon.detach().cpu().numpy())
+                        pre_polygon = None
+                        continue
+                pre_polygon = polygon.detach().clone()
+
+                # find the nearest edge in mask of the featureline
+                dist = knn_points(polygon[None], reply_pts[None])
+                idx = dist.idx[0, ...,0]
+                group_id = group[idx]
+
+                if dist.dists.max()>1000:
+                    new_polygons.append(polygon.detach().cpu().numpy())
+                    continue
+
+
+                # pick the id which is in a larger mask area => pick which the mask area
+                prefer_id = group_id[0] if mask_area[group_id[0]] > mask_area[group_id[1]] else group_id[1]
+                prefer_pts = torch.from_numpy(mask_polygons[prefer_id]).float().cuda()
+                # find the nearest edge in mask of the featureline two points
+                dist = knn_points(polygon[None], prefer_pts[None])
+                idx = dist.idx[0, ...,0].sort()
+                polygon= polygon[idx.indices]
+                idx=idx.values
+
+                reverse_flag = (not idx[0] == dist.idx[0, 0, 0])
+
+
+                # obtain slice_curve
+
+                dp = length_dp[prefer_id]
+                # compute the length of the two points in mask edge
+                # find the shortest path
+                slice_a = dp[idx[1]] - dp[idx[0]]
+                slice_b = dp[-1] - slice_a
+
+                #obtain slice_b
+                if slice_a>slice_b:
+                    # 找最短的路径，当前这个edge的后一个点
+                    segment = torch.cat([polygon[1:],prefer_pts[idx[1]:], prefer_pts[:idx[0]+1], polygon[0:1]], dim = 0)
+                    reverse_flag = (not reverse_flag)
+
+                else:
+                    segment = torch.cat([polygon[0:1], prefer_pts[idx[0]:idx[1]+1], polygon[1:]], dim=0)
+
+                segment = segment.detach().cpu().numpy()
+                if reverse_flag:
+                    segment = segment[::-1]
+
+                new_polygons.append(segment)
+
+
+            new_polygons = np.concatenate(new_polygons, axis = 0)
+            new_query_sets[key] = new_polygons
+            #pdb.set_trace()
+        return new_query_sets, mask
+
+    def smooth_noise(self, mask):
+        kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(5, 5))
+        mask = cv2.erode(mask, kernel, iterations=2)
+        mask = cv2.dilate(mask, kernel, iterations=2)
+
+        return mask
+
+    def mask2polygon(self, mask):
+        contours, hierarchy = cv2.findContours((mask).astype(np.uint8), cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
+        # mask_new, contours, hierarchy = cv2.findContours((mask).astype(np.uint8), cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
+        segmentation = []
+        polygon_size = []
+        for contour in contours:
+            contour_list = contour.flatten().tolist()
+            if len(contour_list) > 4:# and cv2.contourArea(contour)>10000
+
+                area = self.polygons_to_mask(mask.shape, contour_list).sum()
+                polygon_size.append(area)
+
+                contour_numpy = np.asarray(contour_list).reshape(-1, 2)
+                segmentation.append(contour_numpy)
+
+
+        return segmentation, polygon_size
+
+    def polygons_to_mask(self, img_shape, polygons):
+        mask = np.zeros(img_shape, dtype=np.uint8)
+
+        polygons = np.asarray(polygons, np.int32) # 这里必须是int32，其他类型使用fillPoly会报错
+        shape=polygons.shape
+
+        polygons=polygons.reshape(-1,2)
+        cv2.fillPoly(mask, [polygons],color=1) # 非int32 会报错
+        return mask
+
+
+
+def get_upper_bttom_type(parsing_type, key):
+
+    # 'ATR': ['Background', 'Hat', 'Hair', 'Sunglasses', 'Upper-clothes', 'Skirt', 'Pants', 'Dress', 'Belt',
+    #               'Left-shoe', 'Right-shoe', 'Face', 'Left-leg', 'Right-leg', 'Left-arm', 'Right-arm', 'Bag', 'Scarf'],
+    ATR_PARSING = {
+        'upper':[4, 16, 17], # 4: upper-clothes, 16: Bag, 17: Scarf
+        #'upper':[4], # 4: upper-clothes, 16: Bag, 17: Scarf
+        #without head
+        #  'upper':[1, 2, 3, 4, 11, 16, 17],
+        'bottom':[5, 6, 8],
+        #'bottom':[5, 6 ], # 5: skirt, 6: pants, 8: belt
+        #  with head and hand
+        #'upper_bottom':[4, 5, 6, 7 ]
+        'upper_bottom':[4, 5, 6, 7, 8, 16, 17]
+    }
+    CLO_PARSING = {
+        # with head and hand
+        'upper':[1,2,3],
+        #without head
+        #  'upper':[1, 2, 3, 4, 11, 16, 17],
+        'bottom':[1,2,3],
+        #  with head and hand
+        'upper_bottom':[1,2,3]
+        # w/o hand
+        # 'upper_bottom':[4, 5, 7, 16, 17]
+    }
+
+    if parsing_type =='ATR':
+        return ATR_PARSING[key]
+    else:
+        return CLO_PARSING[key]
+
+
+def get_parsing_label(parsing_type):
+    parsing_table ={
+        'ATR': ['Background', 'Hat', 'Hair', 'Sunglasses', 'Upper-clothes', 'Skirt', 'Pants', 'Dress', 'Belt',
+                  'Left-shoe', 'Right-shoe', 'Face', 'Left-leg', 'Right-leg', 'Left-arm', 'Right-arm', 'Bag', 'Scarf'],
+        'CLO':['background', 'upper', 'bottom', 'upper-bottom']
+    }
+
+    return parsing_table[parsing_type]
+
+def get_parse():
+    parser = argparse.ArgumentParser(description='')
+    parser.add_argument('--parsing_type', default='ATR', help='garment_parsing type', choices=['ATR', 'CLO'])
+    parser.add_argument('--input_path', default='', help='select model')
+    parser.add_argument('--output_path', default='', help='polygons output')
+
+    args = parser.parse_args()
+    return args
+
+def parsing_curve(query_file, parsing_file, parsing_type,  class_type, debug_path, name):
+
+    query_sets = {}
+    with open(query_file) as reader:
+        fl_infos = json.load(reader)
+        shapes = fl_infos['shapes']
+        for fl in shapes:
+            query_sets[fl['label']] = np.asarray(fl['points']).astype(np.float32)
+
+    class_table = dict(
+        female_outfit3=['upper_bottom'],
+        female_outfit1=['upper_bottom'],
+        anran_run = ['short_sleeve_upper', 'skirt'],
+        anran_tic = ['short_sleeve_upper', 'skirt'],
+        leyang_jump = ['dress'],
+        leyang_steps = ['dress'],
+    )
+
+    garment_table = dict(
+            short_sleeve_upper='upper',
+            skirt='bottom',
+            dress='upper_bottom',
+            long_sleeve_upper='upper',
+            long_pants='bottom',
+            short_pants='bottom',
+            )
+
+    masks = np.load(parsing_file, allow_pickle= True) # [H, W]
+    parsing_name = parsing_file.split('/')[-1]
+
+    poly_mask = PolyMask(masks) 
+    new_query_sets = {}
+
+    for garment_key in  TEMPLATE_GARMENT[class_type]:
+        pdb.set_trace()
+        garment_class = get_upper_bttom_type(parsing_type, garment_table[garment_key])
+        fl_names = 'bottom_curve' #FL_EXTRACT[garment_key]
+        fl_query_sets = {}
+
+        for fl_name in fl_names:
+            if fl_name in query_sets.keys():
+                fl_query_sets[fl_name] = query_sets[fl_name]
+
+        #pdb.set_trace()
+        new_fl_query_sets, mask = poly_mask.query(fl_query_sets, garment_class, garment_key)
+        new_query_sets.update(new_fl_query_sets)
+
+        cv2.imwrite(osp.join(debug_path, 'mask_{}_'.format(garment_key)+name), mask)
+
+    return new_query_sets, mask
+
+
+def main(args):
+    # ATR, CLO
+    parsing_type = args.parsing_type
+    parsing_label = get_parsing_label(parsing_type)
+    parsing_dir = osp.join(args.input_path, 'parsing_SCH_{}'.format(parsing_type))
+    img_dir = osp.join(args.input_path, 'imgs/')
+    #json_files = sorted(glob.glob(osp.join(args.input_path, 'featurelines/*.json')))
+    json_files = sorted(glob.glob(osp.join(args.input_path, 'json_hand_label_no_bottom_curve/*.json')))
+    img_files = sorted(glob.glob(osp.join(img_dir, '*.jpg')))
+    img_files += sorted(glob.glob(osp.join(img_dir, '*.png')))
+    # get the id: 000342
+    json_key = [json_file.split('/')[-1][:-5] for json_file in json_files]
+
+    parsing_files = sorted(glob.glob(osp.join(parsing_dir,'*.npy')))
+    # given the small json files (less than no.imgs), find the corresponding parsing files and img files
+    filter_parsing_files = list(filter(lambda x: x.split('/')[-1].split('_')[-1][:-4] in json_key, parsing_files))
+    filter_img_files = list(filter(lambda x: x.split('/')[-1][:-4] in json_key, img_files))
+
+    if args.input_path[-1] =='/':
+        input_path = args.input_path[:-1]
+    else:
+        input_path = args.input_path
+
+    class_type = input_path.split('/')[-1]
+    debug_path = osp.join('./debug/{}/polymask'.format(class_type))
+    output_path = args.output_path
+    os.makedirs(output_path, exist_ok = True)
+    os.makedirs(debug_path, exist_ok= True)
+
+    for idx, (parsing_file, json_file, filter_img_file) in enumerate(zip(filter_parsing_files, json_files, filter_img_files)):
+        pdb.set_trace()
+        print('processing: {}'.format(filter_img_file))
+        img = cv2.imread(filter_img_file)
+        name = filter_img_file.split('/')[-1]
+#        if idx == 5:
+#            pdb.set_trace()
+
+        new_query_sets, mask = parsing_curve(json_file, parsing_file, args.parsing_type, class_type, debug_path, name)
+
+        with open(json_file) as reader:
+            fl_infos = json.load(reader)
+            shapes = fl_infos['shapes']
+            for fl in shapes:
+                # query_sets[fl['label']] = np.asarray(fl['points']).astype(np.float32)
+                fl['points']= new_query_sets[fl['label']].tolist()
+
+
+        json_name = json_file.split('/')[-1]
+        new_json_file = os.path.join(output_path, json_name)
+        with open(new_json_file, 'w') as writer:
+            json.dump(fl_infos, writer)
+
+
+        for key in new_query_sets.keys():
+            color = FL_COLOR[key]
+            pt_list = new_query_sets[key].astype(np.int)
+            for pt in new_query_sets[key].astype(np.int):
+                img = cv2.circle(img, (pt[0], pt[1]),2, color,2)
+
+            for pt_idx in range(pt_list.shape[0]-1):
+                img = cv2.line(img, (pt_list[pt_idx][0],pt_list[pt_idx][1]), (pt_list[pt_idx+1][0],pt_list[pt_idx+1][1]), color, 2)
+
+
+        cv2.imwrite(osp.join(debug_path, name), img)
+
+if __name__ == '__main__':
+
+    args = get_parse()
+    main(args)
+
+

process_data_all.py

@@ -0,0 +1,149 @@
+'''
+@Author: Jiapeng Zhou
+@Email: jiapengzhou@link.cuhk.edu.cn
+@Desc: script to process all data of RECMV. 
+Before run this bash, what you only need to do is :
+- run openpose to get keypoints.json file in the dir: (self.root, openpose)
+- have a conda environment of videoavatar, named: "videoavatar"
+Usage: python process_data_all.py --root  ~/DeepDxxx/xinyu_a/ --gid 0 --gender female
+'''
+
+import pdb, os, os.path as osp, sys, argparse
+from typing import Any
+import numpy as np, cv2
+
+class RECMVDataProcessor():
+    def __init__(self, args) -> None:
+        self.args = args
+        self.gender = args.gender
+
+        self.root = args.root
+        #out = osp.join(self.root, args.out)
+        #os.makedirs(out, exist_ok=True)
+        self.img_dir = osp.join(self.root, 'imgs')
+        assert osp.exists(self.img_dir) and len(os.listdir(self.img_dir)) > 0, 'img file does not exist'
+        self.gid = args.gid
+    
+    def __len__(self):
+        return len(os.listdir(self.img_dir))
+    
+    def __call__(self):
+        '''get normals, ATR-parsing, masks, camera, smpl_params, depth, featurelines'''
+
+        # get ATR_parsing 
+        self.get_ATR_parsing()
+        
+        # get masks
+        self.get_masks()
+
+        # get normal from pifuhd
+        self.get_normals()
+
+        '''cannot directly ca videoavatar
+        # get reconstructed_poses.hdf5 from videoavatar
+        self.get_poses()
+        
+        # get camera.npz and smpl_rec.npz
+        self.get_camera_smpl_rec()
+
+        '''
+        
+        # get depth
+        #self.get_depth()
+        
+        # get featurelines
+        #self.get_featurelines()
+
+    def get_featurelines(self):
+        fl_dir = osp.join(self.root, 'featurelines')
+        if osp.exists(fl_dir) and len(os.listdir(fl_dir)) >= self.__len__():
+            print('featurelines files exists')
+        else:
+            print('featurelines file does not exist')
+    
+    def get_depth(self):
+        depth_dir = osp.join(self.root, 'depth')
+        if osp.exists(depth_dir) and len(os.listdir(depth_dir)) >= self.__len__():
+            print('depth files exists')
+        else:
+            print('depth file does not exist')
+    
+    def get_masks(self):
+        mask_dir = osp.join(self.root, 'masks')
+        if osp.exists(mask_dir) and len(os.listdir(mask_dir)) >= self.__len__():
+            print('mask files exists')
+            return
+        os.makedirs(mask_dir, exist_ok=True)
+        # mask是否需要按照单通道保存？
+        print('\n-----------------Getting Masks-------------------------')
+        os.system(f'cd ./RobustVideoMatting && python inference_itw_rotate.py \
+                  --input_pth {self.img_dir} --output_pth {mask_dir} --device {self.gid}')
+
+    
+    def get_normals(self):
+        normal_dir = osp.join(self.root, 'normals')
+        if osp.exists(normal_dir) and len(os.listdir(normal_dir)) >= self.__len__():
+            print('normal files exists')
+            return
+
+        print('\n-------------------Getting Normals----------------------')
+        os.makedirs(normal_dir, exist_ok=True)
+        os.system('cd ./pifuhd && python ./generate_normals.py --gid {} --imgpath {}'.format(self.gid, self.img_dir))
+
+    def get_ATR_parsing(self):
+        input_dir = osp.join(self.root, 'imgs')
+        output_dir = osp.join(self.root, 'parsing_SCH_ATR')
+        if osp.exists(output_dir) and len(os.listdir(output_dir)) >= self.__len__():
+            print('ATR parsing files exists')
+            return
+        print('\n--------------------Getting ATR_Parsing------------------')
+        os.makedirs(output_dir, exist_ok=True)
+
+        os.system(f'cd ./Self-Correction-Human-Parsing && python simple_extractor.py \
+                  --dataset atr --model-restore exp-schp-201908301523-atr.pth --gpu {self.gid} \
+                  --input-dir {self.img_dir} --output-dir {output_dir} --logits')
+
+
+    def get_poses(self):
+        openpose_p = osp.join(self.root, 'openpose')
+        assert osp.exists(openpose_p) and len(os.listdir(openpose_p)) >= self.__len__(), 'openpose keypoint folder doesnot exist or it is emtpy'
+
+        output_dir = osp.join(self.root, 'videoavatars')
+        if osp.exists(output_dir) and osp.exists(osp.join(output_dir, 'reconstructed_poses.hdf5')):
+            print('reconstructed_poses.hdf5 files exists')
+            return
+
+        print('\n------------------Getting Poses---------------------------')
+        os.makedirs(output_dir, exist_ok=True)
+        # Note: Here needs to conda actiavte the environment of videoavatar
+        os.system(f'cd ./videoavatars && bash get_reconstructed_poses.sh {self.root} {output_dir} {self.gender}')
+
+
+    def get_camera_smpl_rec(self):
+        if osp.exists(osp.join(self.root, 'camera.npz')) and osp.exists(osp.join(self.root, 'smpl_rec.npz')):
+            print('camera.npz and smpl_rec.npz files exists')
+            return
+
+        print('\n---------------------Getting camera and smpl_rec--------------------')
+        os.system(' python get_smpl_rec_camera.py --root {} --save_root {} --gender {}'.\
+                      format(osp.join(self.root, 'videoavatars'), self.root, self.gender))
+
+
+        
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--gid', type=int, default=0)
+    parser.add_argument('--root', type=str, required=True)
+    parser.add_argument('--gender', type=str, choices=['male', 'female'], required=True)
+    args = parser.parse_args()
+    return args
+
+def main():
+    args = parse_args()
+    processor = RECMVDataProcessor(args)
+    processor()
+    
+if __name__ == '__main__':
+    main()
+    

rename.py

@@ -0,0 +1,18 @@
+import os, os.path as osp, sys, shutil, argparse, re, glob, time, argparse, pdb
+
+def rename(dir):
+    for root, dirs, files in os.walk(dir):
+        pdb.set_trace()
+        for file in files:
+            if file.endswith('.npy'):
+                new_name = file.split('_')[-1]
+                new_name = osp.join(root, new_name)
+
+                old_name = os.path.join(root, file)
+                os.rename(old_name, new_name)
+                print('Renamed {} to {}'.format(old_name, new_name))
+            
+
+if __name__ == '__main__':
+    dir = '/home/zjp/DeepDynamicFashion/REC-MV/data/yanzhi_a/parsing'
+    rename(dir)

requirements.txt

@@ -0,0 +1,266 @@
+absl-py==1.4.0
+addict==2.4.0
+aiohttp==3.8.1
+aioice==0.7.6
+aiortc==1.3.2
+aiosignal==1.3.1
+alabaster==0.7.13
+anyio==3.6.2
+appdirs==1.4.4
+argon2-cffi==21.3.0
+argon2-cffi-bindings==21.2.0
+asttokens==2.2.1
+async-timeout==4.0.2
+attrs==22.2.0
+aux==0.0.2
+av==8.0.3
+Babel==2.11.0
+backcall==0.2.0
+bcrypt==4.0.1
+beautifulsoup4==4.11.2
+bidict==0.22.1
+bleach==6.0.0
+blessed==1.20.0
+cachetools==5.3.0
+certifi==2022.12.7
+cffi==1.15.1
+chardet==4.0.0
+charset-normalizer==2.0.12
+chumpy==0.70
+click==8.1.3
+colorama==0.4.6
+comm==0.1.2
+commonmark==0.9.1
+ConfigArgParse==1.5.3
+cppcuda-tutorial @ file:///home/zjp/Learning/pytorch_cppcuda_tutorial
+cryptography==39.0.0
+cycler==0.11.0
+d2l==0.17.6
+dash==2.8.1
+dash-core-components==2.0.0
+dash-html-components==2.0.0
+dash-table==5.0.0
+datasets==2.12.0
+debugpy==1.6.6
+decorator==5.1.1
+defusedxml==0.7.1
+descartes==1.1.0
+dill==0.3.6
+dnspython==2.3.0
+docker-pycreds==0.4.0
+docstring-parser==0.14.1
+docutils==0.19
+einops==0.6.0
+exceptiongroup==1.1.1
+executing==1.2.0
+fabric==3.0.0
+fastjsonschema==2.16.2
+FastMinv==0.0.0
+filelock==3.9.0
+filterpy==1.4.5
+fire==0.5.0
+Flask==2.2.2
+fonttools==4.38.0
+freetype-py==2.3.0
+frozendict==2.3.4
+frozenlist==1.3.3
+fsspec==2023.5.0
+fvcore==0.1.5.post20221221
+gdown==4.5.1
+gitdb==4.0.10
+GitPython==3.1.30
+google-auth==2.16.0
+google-auth-oauthlib==1.0.0
+google-crc32c==1.5.0
+gpustat==1.0.0
+grpcio==1.51.1
+h5py==3.8.0
+happytransformer==2.4.1
+huggingface-hub==0.14.1
+idna==2.10
+imageio==2.21.1
+imagesize==1.4.1
+importlib-metadata==6.0.0
+importlib-resources==5.10.2
+iniconfig==2.0.0
+interplate==0.0.0
+invoke==2.0.0
+iopath==0.1.10
+ipykernel==6.21.1
+ipython==8.9.0
+ipython-genutils==0.2.0
+ipywidgets==8.0.4
+itsdangerous==2.1.2
+jedi==0.18.2
+Jinja2==3.1.2
+joblib==1.2.0
+json5==0.9.11
+jsonschema==4.17.3
+jupyter==1.0.0
+jupyter-console==6.4.4
+jupyter-server==1.23.5
+jupyter_client==8.0.2
+jupyter_core==5.2.0
+jupyterlab==3.3.4
+jupyterlab-pygments==0.2.2
+jupyterlab-widgets==3.0.5
+kiwisolver==1.4.4
+linecache2==1.0.0
+lpips==0.1.4
+lxml==4.9.2
+Markdown==3.4.1
+MarkupSafe==2.1.2
+matplotlib==3.5.1
+matplotlib-inline==0.1.6
+MCGpu==0.0.0
+mediapy==1.1.0
+mistune==2.0.4
+msgpack==1.0.4
+msgpack-numpy==0.4.8
+multidict==6.0.4
+multiprocess==0.70.14
+nbclassic==0.5.1
+nbclient==0.7.2
+nbconvert==7.2.9
+nbformat==5.5.0
+nerfacc==0.3.4
+nest-asyncio==1.5.6
+netifaces==0.11.0
+networkx==3.0
+ninja==1.11.1
+nose==1.3.7
+notebook==6.5.2
+notebook_shim==0.2.2
+numpy==1.21.5
+nuscenes-devkit==1.1.9
+nvidia-ml-py==11.495.46
+oauthlib==3.2.2
+open3d==0.16.0
+opencv-python==4.6.0.66
+openmesh==1.2.1
+packaging==23.0
+pandas==1.2.4
+pandocfilters==1.5.0
+paramiko==3.1.0
+parso==0.8.3
+pathtools==0.1.2
+pexpect==4.8.0
+pickleshare==0.7.5
+Pillow==9.4.0
+PIMS==0.5
+pkgutil_resolve_name==1.3.10
+platformdirs==2.6.2
+plotly==5.7.0
+pluggy==1.0.0
+portalocker==2.7.0
+POT==0.9.0
+prometheus-client==0.16.0
+prompt-toolkit==3.0.36
+protobuf==3.20.0
+psutil==5.9.4
+ptyprocess==0.7.0
+pure-eval==0.2.2
+pyarrow==12.0.0
+pyasn1==0.4.8
+pyasn1-modules==0.2.8
+pycocotools==2.0.6
+pycparser==2.21
+pyee==9.0.4
+pyglet==2.0.5
+Pygments==2.14.0
+pyhocon==0.3.60
+pylibsrtp==0.8.0
+pymeshlab==2022.2.post2
+PyNaCl==1.5.0
+pyngrok==5.1.0
+PyOpenGL==3.1.0
+pyparsing==3.0.9
+pyquaternion==0.9.9
+pyrender==0.1.45
+pyrsistent==0.19.3
+PySocks==1.7.1
+pytest==7.3.1
+python-dateutil==2.8.2
+python-engineio==4.3.4
+python-socketio==5.7.1
+pytorch3d==0.4.0
+pytz==2022.7.1
+PyWavelets==1.4.1
+PyYAML==6.0
+pyzmq==25.0.0
+qtconsole==5.4.0
+QtPy==2.3.0
+regex==2023.5.5
+requests==2.25.1
+requests-oauthlib==1.3.1
+responses==0.18.0
+rich==12.5.1
+rsa==4.9
+scikit-image==0.19.3
+scikit-learn==1.2.1
+scikit-sparse==0.4.8
+scipy==1.10.0
+seaborn==0.12.2
+Send2Trash==1.8.0
+sentencepiece==0.1.99
+sentry-sdk==1.14.0
+setproctitle==1.3.2
+shapely==2.0.1
+shtab==1.5.8
+six==1.16.0
+slicerator==1.1.0
+smmap==5.0.0
+smplx==0.1.28
+sniffio==1.3.0
+snowballstemmer==2.2.0
+soupsieve==2.3.2.post1
+Sphinx==6.1.3
+sphinxcontrib-applehelp==1.0.4
+sphinxcontrib-devhelp==1.0.2
+sphinxcontrib-htmlhelp==2.0.1
+sphinxcontrib-jsmath==1.0.1
+sphinxcontrib-qthelp==1.0.3
+sphinxcontrib-serializinghtml==1.1.5
+stack-data==0.6.2
+tabulate==0.9.0
+tenacity==8.1.0
+tensorboard==2.12.1
+tensorboard-data-server==0.7.0
+tensorboard-plugin-wit==1.8.1
+termcolor==2.2.0
+terminado==0.17.1
+threadpoolctl==3.1.0
+tifffile==2023.2.3
+tinycss2==1.2.1
+tinycudann==1.7
+tokenizers==0.13.3
+tomli==2.0.1
+torch==1.10.2+cu113
+torch-fidelity==0.3.0
+torch-scatter==2.0.9
+torchmetrics==0.11.1
+torchtyping==0.1.4
+torchvision==0.11.3+cu113
+tornado==6.2
+tqdm==4.65.0
+traceback2==1.4.0
+traitlets==5.9.0
+transformers==4.28.1
+trimesh==3.18.3
+typeguard==2.13.3
+typing_extensions==4.4.0
+tyro==0.3.38
+u-msgpack-python==2.7.2
+unittest2==1.1.0
+urllib3==1.26.14
+wandb==0.13.9
+wcwidth==0.2.6
+webencodings==0.5.1
+websocket-client==1.5.1
+Werkzeug==2.2.2
+widgetsnbextension==4.0.5
+xatlas==0.0.7
+xxhash==3.2.0
+yacs==0.1.8
+yarl==1.8.2
+zipp==3.12.1

smpl_process.py

@@ -0,0 +1,40 @@
+'''
+@Desc: This file is used to process the smpl: convert rotation matrix to axis-angle
+'''
+
+import numpy as np
+import os, os.path as osp, sys, pdb, argparse
+from scipy.spatial.transform import Rotation
+
+def convert_rotmat_to_axis_angle(rotmat):
+    '''
+    Args: rotmat: (N, 3, 3)
+    Return: axis_angle: (N, 3)
+    '''
+    rotation = Rotation.from_matrix(rotmat)
+    axis_angle = rotation.as_rotvec()
+    return axis_angle
+
+def parse_args():
+    argparser = argparse.ArgumentParser()
+    argparser.add_argument('--root', help='the root dir of an identity')
+    argparser.add_argument('--smpl_file')
+    return argparser.parse_args()
+
+def main():
+    args = parse_args()    
+    root = args.root
+    smpl_file = osp.join(root, args.smpl_file)
+    npz = np.load(smpl_file, allow_pickle=True)
+    smpl_params = {}
+    for key in npz.keys():
+        smpl_params[key] = npz[key]
+
+    pdb.set_trace()
+    rotmat_batch = smpl_params['poses'].reshape(-1, 3, 3)
+    smpl_params['poses'] = convert_rotmat_to_axis_angle(rotmat_batch).reshape(-1, 24, 3)
+    np.savez(smpl_file, **smpl_params)
+    return
+
+if __name__ == '__main__':
+    main()