testing

README.md

@@ -89,6 +89,7 @@ ECON is designed for "Human digitization from a color image", which combines the
 - See [installion doc for Windows](docs/installation-windows.md) to install all the required packages and setup the models on _Windows_
 - See [installion doc for Ubuntu](docs/installation-ubuntu.md) to install all the required packages and setup the models on _Ubuntu_
 - See [magic tricks](docs/tricks.md) to know a few technical tricks to further improve and accelerate ECON
+- See [testing](docs/testing.md) to prepare the testing data and evaluate ECON
 
 ## Demo
 

apps/avatarizer.py

@@ -143,7 +143,7 @@ if not osp.exists(f"{prefix}_econ_da.obj") or not osp.exists(f"{prefix}_smpl_da.
     smpl_da_body.remove_unreferenced_vertices()
 
     smpl_hand = smpl_da.copy()
-    smpl_hand.update_faces(smplx_container.mano_vertex_mask.numpy()[smpl_hand.faces].all(axis=1))
+    smpl_hand.update_faces(smplx_container.smplx_mano_vertex_mask.numpy()[smpl_hand.faces].all(axis=1))
     smpl_hand.remove_unreferenced_vertices()
     econ_da = sum([smpl_hand, smpl_da_body, econ_da_body])
     econ_da = poisson(econ_da, f"{prefix}_econ_da.obj", depth=10, decimation=False)

apps/benchmark.py

@@ -0,0 +1,316 @@
+# -*- coding: utf-8 -*-
+
+# Max-Planck-Gesellschaft zur Förderung der Wissenschaften e.V. (MPG) is
+# holder of all proprietary rights on this computer program.
+# You can only use this computer program if you have closed
+# a license agreement with MPG or you get the right to use the computer
+# program from someone who is authorized to grant you that right.
+# Any use of the computer program without a valid license is prohibited and
+# liable to prosecution.
+#
+# Copyright©2019 Max-Planck-Gesellschaft zur Förderung
+# der Wissenschaften e.V. (MPG). acting on behalf of its Max Planck Institute
+# for Intelligent Systems. All rights reserved.
+#
+# Contact: [email protected]
+
+import warnings
+import logging
+
+warnings.filterwarnings("ignore")
+logging.getLogger("lightning").setLevel(logging.ERROR)
+logging.getLogger("trimesh").setLevel(logging.ERROR)
+
+import torch
+import argparse
+import os
+
+from termcolor import colored
+from tqdm.auto import tqdm
+from apps.Normal import Normal
+from apps.IFGeo import IFGeo
+from lib.common.config import cfg
+from lib.common.BNI import BNI
+from lib.common.BNI_utils import save_normal_tensor
+from lib.dataset.EvalDataset import EvalDataset
+from lib.dataset.Evaluator import Evaluator
+from lib.dataset.mesh_util import *
+from lib.common.voxelize import VoxelGrid
+
+torch.backends.cudnn.benchmark = True
+speed_analysis = False
+
+if __name__ == "__main__":
+
+    if speed_analysis:
+        import cProfile
+        import pstats
+        profiler = cProfile.Profile()
+        profiler.enable()
+
+    # loading cfg file
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("-gpu", "--gpu_device", type=int, default=0)
+    parser.add_argument("-ifnet", action="store_true")
+    parser.add_argument("-cfg", "--config", type=str, default="./configs/econ.yaml")
+
+    args = parser.parse_args()
+
+    # cfg read and merge
+    cfg.merge_from_file(args.config)
+    device = torch.device("cuda:0")
+
+    cfg_test_list = [
+        "dataset.rotation_num", 3, "bni.use_smpl", ["hand"], "bni.use_ifnet", args.ifnet,
+        "bni.cut_intersection", True,
+    ]
+
+    # # if w/ RenderPeople+CAPE
+    # cfg_test_list += ["dataset.types", ["cape", "renderpeople"], "dataset.scales", [100.0, 1.0]]
+
+    # if only w/ CAPE
+    cfg_test_list += ["dataset.types", ["cape"], "dataset.scales", [100.0]]
+
+    cfg.merge_from_list(cfg_test_list)
+    cfg.freeze()
+
+    # load normal model
+    normal_net = Normal.load_from_checkpoint(
+        cfg=cfg, checkpoint_path=cfg.normal_path, map_location=device, strict=False
+    )
+    normal_net = normal_net.to(device)
+    normal_net.netG.eval()
+    print(
+        colored(
+            f"Resume Normal Estimator from {Format.start} {cfg.normal_path} {Format.end}", "green"
+        )
+    )
+
+    # SMPLX object
+    SMPLX_object = SMPLX()
+
+    dataset = EvalDataset(cfg=cfg, device=device)
+    evaluator = Evaluator(device=device)
+    export_dir = osp.join(cfg.results_path, cfg.name, "IF-Net+" if cfg.bni.use_ifnet else "SMPL-X")
+    print(colored(f"Dataset Size: {len(dataset)}", "green"))
+
+    if cfg.bni.use_ifnet:
+        # load IFGeo model
+        ifnet = IFGeo.load_from_checkpoint(
+            cfg=cfg, checkpoint_path=cfg.ifnet_path, map_location=device, strict=False
+        )
+        ifnet = ifnet.to(device)
+        ifnet.netG.eval()
+
+        print(colored(f"Resume IF-Net+ from {Format.start} {cfg.ifnet_path} {Format.end}", "green"))
+        print(colored(f"Complete with {Format.start} IF-Nets+ (Implicit) {Format.end}", "green"))
+    else:
+        print(colored(f"Complete with {Format.start} SMPL-X (Explicit) {Format.end}", "green"))
+
+    pbar = tqdm(dataset)
+    benchmark = {}
+
+    for data in pbar:
+
+        for key in data.keys():
+            if torch.is_tensor(data[key]):
+                data[key] = data[key].unsqueeze(0).to(device)
+
+        is_smplx = True if 'smplx_path' in data.keys() else False
+
+        # filenames and makedirs
+        current_name = f"{data['dataset']}-{data['subject']}-{data['rotation']:03d}"
+        current_dir = osp.join(export_dir, data['dataset'], data['subject'])
+        os.makedirs(current_dir, exist_ok=True)
+        final_path = osp.join(current_dir, f"{current_name}_final.obj")
+
+        if not osp.exists(final_path):
+
+            in_tensor = data.copy()
+
+            batch_smpl_verts = in_tensor["smpl_verts"].detach()
+            batch_smpl_verts *= torch.tensor([1.0, -1.0, 1.0]).to(device)
+            batch_smpl_faces = in_tensor["smpl_faces"].detach()
+
+            in_tensor["depth_F"], in_tensor["depth_B"] = dataset.render_depth(
+                batch_smpl_verts, batch_smpl_faces
+            )
+
+            with torch.no_grad():
+                in_tensor["normal_F"], in_tensor["normal_B"] = normal_net.netG(in_tensor)
+
+            smpl_mesh = trimesh.Trimesh(
+                batch_smpl_verts.cpu().numpy()[0],
+                batch_smpl_faces.cpu().numpy()[0]
+            )
+
+            side_mesh = smpl_mesh.copy()
+            face_mesh = smpl_mesh.copy()
+            hand_mesh = smpl_mesh.copy()
+            smplx_mesh = smpl_mesh.copy()
+
+            # save normals, depths and masks
+            BNI_dict = save_normal_tensor(
+                in_tensor,
+                0,
+                osp.join(current_dir, "BNI/param_dict"),
+                cfg.bni.thickness if data['dataset'] == 'renderpeople' else 0.0,
+            )
+
+            # BNI process
+            BNI_object = BNI(
+                dir_path=osp.join(current_dir, "BNI"),
+                name=current_name,
+                BNI_dict=BNI_dict,
+                cfg=cfg.bni,
+                device=device
+            )
+
+            BNI_object.extract_surface(False)
+
+            if is_smplx:
+                side_mesh = apply_face_mask(side_mesh, ~SMPLX_object.smplx_eyeball_fid_mask)
+
+            if cfg.bni.use_ifnet:
+
+                # mesh completion via IF-net
+                in_tensor.update(
+                    dataset.depth_to_voxel(
+                        {
+                            "depth_F": BNI_object.F_depth.unsqueeze(0).to(device),
+                            "depth_B": BNI_object.B_depth.unsqueeze(0).to(device)
+                        }
+                    )
+                )
+
+                occupancies = VoxelGrid.from_mesh(side_mesh, cfg.vol_res, loc=[
+                    0,
+                ] * 3, scale=2.0).data.transpose(2, 1, 0)
+                occupancies = np.flip(occupancies, axis=1)
+
+                in_tensor["body_voxels"] = torch.tensor(occupancies.copy()
+                                                       ).float().unsqueeze(0).to(device)
+
+                with torch.no_grad():
+                    sdf = ifnet.reconEngine(netG=ifnet.netG, batch=in_tensor)
+                    verts_IF, faces_IF = ifnet.reconEngine.export_mesh(sdf)
+
+                if ifnet.clean_mesh_flag:
+                    verts_IF, faces_IF = clean_mesh(verts_IF, faces_IF)
+
+                side_mesh_path = osp.join(current_dir, f"{current_name}_IF.obj")
+                side_mesh = remesh_laplacian(trimesh.Trimesh(verts_IF, faces_IF), side_mesh_path)
+
+            full_lst = []
+
+            if "hand" in cfg.bni.use_smpl:
+
+                # only hands
+                if is_smplx:
+                    hand_mesh = apply_vertex_mask(hand_mesh, SMPLX_object.smplx_mano_vertex_mask)
+                else:
+                    hand_mesh = apply_vertex_mask(hand_mesh, SMPLX_object.smpl_mano_vertex_mask)
+
+                # remove hand neighbor triangles
+                BNI_object.F_B_trimesh = part_removal(
+                    BNI_object.F_B_trimesh,
+                    hand_mesh,
+                    cfg.bni.hand_thres,
+                    device,
+                    smplx_mesh,
+                    region="hand"
+                )
+                side_mesh = part_removal(
+                    side_mesh, hand_mesh, cfg.bni.hand_thres, device, smplx_mesh, region="hand"
+                )
+                # hand_mesh.export(osp.join(current_dir, f"{current_name}_hands.obj"))
+                full_lst += [hand_mesh]
+
+            full_lst += [BNI_object.F_B_trimesh]
+
+            # initial side_mesh could be SMPLX or IF-net
+            side_mesh = part_removal(
+                side_mesh, sum(full_lst), 2e-2, device, smplx_mesh, region="", clean=False
+            )
+
+            full_lst += [side_mesh]
+
+            if cfg.bni.use_poisson:
+                final_mesh = poisson(
+                    sum(full_lst),
+                    final_path,
+                    cfg.bni.poisson_depth,
+                )
+            else:
+                final_mesh = sum(full_lst)
+                final_mesh.export(final_path)
+        else:
+            final_mesh = trimesh.load(final_path)
+
+        # evaluation
+        metric_path = osp.join(export_dir, "metric.npy")
+
+        if osp.exists(metric_path):
+            benchmark = np.load(metric_path, allow_pickle=True).item()
+
+        if benchmark == {} or data["dataset"] not in benchmark.keys(
+        ) or f"{data['subject']}-{data['rotation']}" not in benchmark[data["dataset"]]["subject"]:
+
+            result_eval = {
+                "verts_gt": data["verts"][0],
+                "faces_gt": data["faces"][0],
+                "verts_pr": final_mesh.vertices,
+                "faces_pr": final_mesh.faces,
+                "calib": data["calib"][0],
+            }
+
+            evaluator.set_mesh(result_eval, scale=False)
+            chamfer, p2s = evaluator.calculate_chamfer_p2s(num_samples=1000)
+            nc = evaluator.calculate_normal_consist(osp.join(current_dir, f"{current_name}_nc.png"))
+
+            if data["dataset"] not in benchmark.keys():
+                benchmark[data["dataset"]] = {
+                    "chamfer": [chamfer.item()],
+                    "p2s": [p2s.item()],
+                    "nc": [nc.item()],
+                    "subject": [f"{data['subject']}-{data['rotation']}"],
+                    "total": 1,
+                }
+            else:
+                benchmark[data["dataset"]]["chamfer"] += [chamfer.item()]
+                benchmark[data["dataset"]]["p2s"] += [p2s.item()]
+                benchmark[data["dataset"]]["nc"] += [nc.item()]
+                benchmark[data["dataset"]]["subject"] += [f"{data['subject']}-{data['rotation']}"]
+                benchmark[data["dataset"]]["total"] += 1
+
+            np.save(metric_path, benchmark, allow_pickle=True)
+
+        else:
+
+            subject_idx = benchmark[data["dataset"]
+                                   ]["subject"].index(f"{data['subject']}-{data['rotation']}")
+            chamfer = torch.tensor(benchmark[data["dataset"]]["chamfer"][subject_idx])
+            p2s = torch.tensor(benchmark[data["dataset"]]["p2s"][subject_idx])
+            nc = torch.tensor(benchmark[data["dataset"]]["nc"][subject_idx])
+
+        pbar.set_description(
+            f"{current_name} | {chamfer.item():.3f} | {p2s.item():.3f} | {nc.item():.4f}"
+        )
+
+    for dataset in benchmark.keys():
+        for metric in ["chamfer", "p2s", "nc"]:
+            print(
+                f"{dataset}-{metric}: {sum(benchmark[dataset][metric])/benchmark[dataset]['total']:.4f}"
+            )
+
+    if cfg.bni.use_ifnet:
+        print(colored("Finish evaluating on ECON_IF", "green"))
+    else:
+        print(colored("Finish evaluating of ECON_EX", "green"))
+
+    if speed_analysis:
+        profiler.disable()
+        profiler.dump_stats(osp.join(export_dir, "econ.stats"))
+        stats = pstats.Stats(osp.join(export_dir, "econ.stats"))
+        stats.sort_stats("cumtime").print_stats(10)

apps/infer.py

@@ -521,7 +521,7 @@ if __name__ == "__main__":
                 side_mesh = apply_vertex_mask(
                     side_mesh,
                     (
-                        SMPLX_object.front_flame_vertex_mask + SMPLX_object.mano_vertex_mask +
+                        SMPLX_object.front_flame_vertex_mask + SMPLX_object.smplx_mano_vertex_mask +
                         SMPLX_object.eyeball_vertex_mask
                     ).eq(0).float(),
                 )
@@ -620,6 +620,12 @@ if __name__ == "__main__":
                     final_path,
                     cfg.bni.poisson_depth,
                 )
+                print(
+                    colored(
+                        f"\n Poisson completion to {Format.start} {final_path} {Format.end}",
+                        "yellow"
+                    )
+                )
             else:
                 final_mesh = sum(full_lst)
                 final_mesh.export(final_path)

configs/econ.yaml

@@ -15,7 +15,7 @@ dataset:
   prior_type: "SMPL"
 
 vol_res: 256
-mcube_res: 128
+mcube_res: 256
 clean_mesh: True
 cloth_overlap_thres: 0.50
 body_overlap_thres: 0.00
@@ -36,3 +36,4 @@ bni:
   thickness: 0.02
   hps_type: "pixie"
   texture_src: "SD"
+  cut_intersection: True

docs/testing.md

@@ -0,0 +1,71 @@
+# Evaluation
+
+## Testing Data
+
+![dataset](../assets/dataset.png)
+
+- OOD pose (CAPE, [download](https://github.com/YuliangXiu/ICON/blob/master/docs/evaluation.md#cape-testset)): [`pose.txt`](../pose.txt)
+- OOD outfits (RenderPeople, [link](https://renderpeople.com/)): [`loose.txt`](../loose.txt)
+
+## Run the evaluation
+
+```bash
+# Benchmark of ECON_{IF}, which uses IF-Net+ for completion
+export CUDA_VISIBLE_DEVICES=0; python -m apps.benchmark -ifnet
+
+# Benchmark of ECON_{EX}, which uses registered SMPL for completion
+export CUDA_VISIBLE_DEVICES=1; python -m apps.benchmark
+
+```
+
+## Benchmark
+
+|   Method    |  $\text{ECON}_\text{IF}$  | $\text{ECON}_\text{EX}$ |
+| :---------: | :-----------------------: | :---------------------: |
+|             |     OOD poses (CAPE)      |                         |
+| Chamfer(cm) |           0.996           |        **0.926**        |
+|   P2S(cm)   |           0.967           |        **0.917**        |
+| Normal(L2)  |          0.0413           |       **0.0367**        |
+|             | OOD oufits (RenderPeople) |                         |
+| Chamfer(cm) |           1.401           |        **1.342**        |
+|   P2S(cm)   |         **1.422**         |          1.458          |
+| Normal(L2)  |          0.0516           |       **0.0478**        |
+
+**\*OOD: Out-of-Distribution**
+
+## Citation
+
+:+1: Please cite these CAPE-related papers
+
+```
+
+@inproceedings{xiu2022icon,
+  title     = {{ICON}: {I}mplicit {C}lothed humans {O}btained from {N}ormals},
+  author    = {Xiu, Yuliang and Yang, Jinlong and Tzionas, Dimitrios and Black, Michael J.},
+  booktitle = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
+  month     = {June},
+  year      = {2022},
+  pages     = {13296-13306}
+}
+
+@inproceedings{CAPE:CVPR:20,
+  title = {{Learning to Dress 3D People in Generative Clothing}},
+  author = {Ma, Qianli and Yang, Jinlong and Ranjan, Anurag and Pujades, Sergi and Pons-Moll, Gerard and Tang, Siyu and Black, Michael J.},
+  booktitle = {Computer Vision and Pattern Recognition (CVPR)},
+  month = June,
+  year = {2020},
+  month_numeric = {6}
+}
+
+@article{Pons-Moll:Siggraph2017,
+  title = {ClothCap: Seamless 4D Clothing Capture and Retargeting},
+  author = {Pons-Moll, Gerard and Pujades, Sergi and Hu, Sonny and Black, Michael},
+  journal = {ACM Transactions on Graphics, (Proc. SIGGRAPH)},
+  volume = {36},
+  number = {4},
+  year = {2017},
+  note = {Two first authors contributed equally},
+  crossref = {},
+  url = {http://dx.doi.org/10.1145/3072959.3073711}
+}
+```

lib/common/BNI.py

@@ -28,6 +28,7 @@ class BNI:
         self.k = self.cfg['k']
         self.lambda1 = self.cfg['lambda1']
         self.boundary_consist = self.cfg['boundary_consist']
+        self.cut_intersection = self.cfg['cut_intersection']
 
         self.F_B_surface = None
         self.F_B_trimesh = None
@@ -54,6 +55,7 @@ class BNI:
             lambda_depth_front=self.lambda1,
             lambda_depth_back=self.lambda1,
             lambda_boundary_consistency=self.boundary_consist,
+            cut_intersection=self.cut_intersection,
         )
 
         F_verts = verts_inverse_transform(bni_result["F_verts"], self.scale)
@@ -71,13 +73,13 @@ class BNI:
             F_B_verts.float(), F_B_faces.long(), process=False, maintain_order=True
         )
 
-        self.F_trimesh = trimesh.Trimesh(
-            F_verts.float(), bni_result["F_faces"].long(), process=False, maintain_order=True
-        )
+        # self.F_trimesh = trimesh.Trimesh(
+        #     F_verts.float(), bni_result["F_faces"].long(), process=False, maintain_order=True
+        # )
 
-        self.B_trimesh = trimesh.Trimesh(
-            B_verts.float(), bni_result["B_faces"].long(), process=False, maintain_order=True
-        )
+        # self.B_trimesh = trimesh.Trimesh(
+        #     B_verts.float(), bni_result["B_faces"].long(), process=False, maintain_order=True
+        # )
 
 
 if __name__ == "__main__":

lib/common/BNI_utils.py

@@ -435,7 +435,8 @@ def double_side_bilateral_normal_integration(
     max_iter=150,
     tol=1e-4,
     cg_max_iter=5000,
-    cg_tol=1e-3
+    cg_tol=1e-3,
+    cut_intersection=True,
 ):
 
     # To avoid confusion, we list the coordinate systems in this code as follows
@@ -538,6 +539,13 @@ def double_side_bilateral_normal_integration(
              lambda_depth_back * (z_back - z_prior_back).T @ M @ (z_back - z_prior_back) + \
              lambda_boundary_consistency * (z_back - z_front).T @ B @ (z_back - z_front)
 
+    depth_map_front_est = cp.ones_like(normal_mask, float) * cp.nan
+    depth_map_back_est = cp.ones_like(normal_mask, float) * cp.nan
+
+    facets_back = cp.asnumpy(construct_facets_from(normal_mask))
+    faces_back = np.concatenate((facets_back[:, [1, 4, 3]], facets_back[:, [1, 3, 2]]), axis=0)
+    faces_front = np.concatenate((facets_back[:, [1, 2, 3]], facets_back[:, [1, 3, 4]]), axis=0)
+
     for i in range(max_iter):
         A_mat_front = A_front_data.T @ W_front @ A_front_data
         b_vec_front = A_front_data.T @ W_front @ b_front
@@ -606,22 +614,61 @@ def double_side_bilateral_normal_integration(
 
         energy_list.append(energy)
         relative_energy = cp.abs(energy - energy_old) / energy_old
+        
         # print(f"step {i + 1}/{max_iter} energy: {energy:.3e}"
         #       f" relative energy: {relative_energy:.3e}")
+
+        if False:
+            # intermediate results
+            depth_map_front_est[normal_mask] = z_front
+            depth_map_back_est[normal_mask] = z_back
+            vertices_front = cp.asnumpy(
+                map_depth_map_to_point_clouds(
+                    depth_map_front_est, normal_mask, K=None, step_size=step_size
+                )
+            )
+            vertices_back = cp.asnumpy(
+                map_depth_map_to_point_clouds(
+                    depth_map_back_est, normal_mask, K=None, step_size=step_size
+                )
+            )
+
+            vertices_front, faces_front_ = remove_stretched_faces(vertices_front, faces_front)
+            vertices_back, faces_back_ = remove_stretched_faces(vertices_back, faces_back)
+
+            F_verts = verts_inverse_transform(torch.as_tensor(vertices_front).float(), 256.0)
+            B_verts = verts_inverse_transform(torch.as_tensor(vertices_back).float(), 256.0)
+
+            F_B_verts = torch.cat((F_verts, B_verts), dim=0)
+            F_B_faces = torch.cat(
+                (
+                    torch.as_tensor(faces_front_).long(),
+                    torch.as_tensor(faces_back_).long() + faces_front_.max() + 1
+                ),
+                dim=0
+            )
+
+            front_surf = trimesh.Trimesh(F_verts, faces_front_)
+            back_surf = trimesh.Trimesh(B_verts, faces_back_)
+            double_surf = trimesh.Trimesh(F_B_verts, F_B_faces)
+
+            bini_dir = "/home/yxiu/Code/ECON/log/bini/OBJ"
+            front_surf.export(osp.join(bini_dir, f"{i:04d}_F.obj"))
+            back_surf.export(osp.join(bini_dir, f"{i:04d}_B.obj"))
+            double_surf.export(osp.join(bini_dir, f"{i:04d}_FB.obj"))
+
         if relative_energy < tol:
             break
     # del A1, A2, A3, A4, nx, ny
 
-    depth_map_front_est = cp.ones_like(normal_mask, float) * cp.nan
     depth_map_front_est[normal_mask] = z_front
-
-    depth_map_back_est = cp.ones_like(normal_mask, float) * cp.nan
     depth_map_back_est[normal_mask] = z_back
 
-    # manually cut the intersection
-    normal_mask[depth_map_front_est >= depth_map_back_est] = False
-    depth_map_front_est[~normal_mask] = cp.nan
-    depth_map_back_est[~normal_mask] = cp.nan
+    if cut_intersection:
+        # manually cut the intersection
+        normal_mask[depth_map_front_est >= depth_map_back_est] = False
+        depth_map_front_est[~normal_mask] = cp.nan
+        depth_map_back_est[~normal_mask] = cp.nan
 
     vertices_front = cp.asnumpy(
         map_depth_map_to_point_clouds(
@@ -633,7 +680,6 @@ def double_side_bilateral_normal_integration(
     )
 
     facets_back = cp.asnumpy(construct_facets_from(normal_mask))
-
     faces_back = np.concatenate((facets_back[:, [1, 4, 3]], facets_back[:, [1, 3, 2]]), axis=0)
     faces_front = np.concatenate((facets_back[:, [1, 2, 3]], facets_back[:, [1, 3, 4]]), axis=0)
 

lib/common/config.py

@@ -101,6 +101,7 @@ _C.bni.hand_thres = 4e-2
 _C.bni.face_thres = 6e-2
 _C.bni.hps_type = "pixie"
 _C.bni.texture_src = "image"
+_C.bni.cut_intersection = True
 
 # kernel_size, stride, dilation, padding
 

lib/common/local_affine.py

@@ -73,7 +73,7 @@ def trimesh2meshes(mesh):
     return mesh
 
 
-def register(target_mesh, src_mesh, device):
+def register(target_mesh, src_mesh, device, verbose=True):
 
     # define local_affine deform verts
     tgt_mesh = trimesh2meshes(target_mesh).to(device)
@@ -100,8 +100,11 @@ def register(target_mesh, src_mesh, device):
 
     losses = init_loss()
 
-    loop_cloth = tqdm(range(100))
-
+    if verbose:
+        loop_cloth = tqdm(range(100))
+    else:
+        loop_cloth = range(100)
+    
     for i in loop_cloth:
 
         optimizer_cloth.zero_grad()
@@ -128,8 +131,9 @@ def register(target_mesh, src_mesh, device):
                     losses[k]["value"] * losses[k]["weight"]
                 pbar_desc += f"{k}:{losses[k]['value']* losses[k]['weight']:.3f} | "
 
-        pbar_desc += f"TOTAL: {cloth_loss:.3f}"
-        loop_cloth.set_description(pbar_desc)
+        if verbose:
+            pbar_desc += f"TOTAL: {cloth_loss:.3f}"
+            loop_cloth.set_description(pbar_desc)
 
         # update params
         cloth_loss.backward(retain_graph=True)

lib/dataset/EvalDataset.py

@@ -0,0 +1,307 @@
+# -*- coding: utf-8 -*-
+
+# Max-Planck-Gesellschaft zur Förderung der Wissenschaften e.V. (MPG) is
+# holder of all proprietary rights on this computer program.
+# You can only use this computer program if you have closed
+# a license agreement with MPG or you get the right to use the computer
+# program from someone who is authorized to grant you that right.
+# Any use of the computer program without a valid license is prohibited and
+# liable to prosecution.
+#
+# Copyright©2019 Max-Planck-Gesellschaft zur Förderung
+# der Wissenschaften e.V. (MPG). acting on behalf of its Max Planck Institute
+# for Intelligent Systems. All rights reserved.
+#
+# Contact: [email protected]
+
+import torch.nn.functional as F
+from lib.common.render import Render
+from lib.dataset.mesh_util import (SMPLX, projection, rescale_smpl, HoppeMesh)
+import os.path as osp
+import numpy as np
+from PIL import Image
+import os
+import cv2
+import trimesh
+import torch
+import torchvision.transforms as transforms
+
+cape_gender = {
+    "male":
+        ['00032', '00096', '00122', '00127', '00145', '00215', '02474', '03284', '03375', '03394'],
+    "female": ['00134', '00159', '03223', '03331', '03383']
+}
+
+
+class EvalDataset:
+    def __init__(self, cfg, device):
+
+        self.root = cfg.root
+        self.bsize = cfg.batch_size
+
+        self.opt = cfg.dataset
+        self.datasets = self.opt.types
+        self.input_size = self.opt.input_size
+        self.scales = self.opt.scales
+        self.vol_res = cfg.vol_res
+
+        # [(feat_name, channel_num),...]
+        self.in_geo = [item[0] for item in cfg.net.in_geo]
+        self.in_nml = [item[0] for item in cfg.net.in_nml]
+
+        self.in_geo_dim = [item[1] for item in cfg.net.in_geo]
+        self.in_nml_dim = [item[1] for item in cfg.net.in_nml]
+
+        self.in_total = self.in_geo + self.in_nml
+        self.in_total_dim = self.in_geo_dim + self.in_nml_dim
+
+        self.rotations = range(0, 360, 120)
+
+        self.datasets_dict = {}
+
+        for dataset_id, dataset in enumerate(self.datasets):
+
+            dataset_dir = osp.join(self.root, dataset)
+
+            mesh_dir = osp.join(dataset_dir, "scans")
+            smplx_dir = osp.join(dataset_dir, "smplx")
+            smpl_dir = osp.join(dataset_dir, "smpl")
+
+            self.datasets_dict[dataset] = {
+                "smplx_dir": smplx_dir,
+                "smpl_dir": smpl_dir,
+                "mesh_dir": mesh_dir,
+                "scale": self.scales[dataset_id],
+            }
+
+            self.datasets_dict[dataset].update(
+                {"subjects": np.loadtxt(osp.join(dataset_dir, "all.txt"), dtype=str)}
+            )
+
+        self.subject_list = self.get_subject_list()
+        self.smplx = SMPLX()
+
+        # PIL to tensor
+        self.image_to_tensor = transforms.Compose(
+            [
+                transforms.Resize(self.input_size),
+                transforms.ToTensor(),
+                transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
+            ]
+        )
+
+        # PIL to tensor
+        self.mask_to_tensor = transforms.Compose(
+            [
+                transforms.Resize(self.input_size),
+                transforms.ToTensor(),
+                transforms.Normalize((0.0, ), (1.0, )),
+            ]
+        )
+
+        self.device = device
+        self.render = Render(size=512, device=self.device)
+
+    def render_normal(self, verts, faces):
+
+        # render optimized mesh (normal, T_normal, image [-1,1])
+        self.render.load_meshes(verts, faces)
+        return self.render.get_image()
+
+    def get_subject_list(self):
+
+        subject_list = []
+
+        for dataset in self.datasets:
+
+            split_txt = ""
+
+            if dataset == 'renderpeople':
+                split_txt = osp.join(self.root, dataset, "loose.txt")
+            elif dataset == 'cape':
+                split_txt = osp.join(self.root, dataset, "pose.txt")
+
+            if osp.exists(split_txt) and osp.getsize(split_txt) > 0:
+                print(f"load from {split_txt}")
+                subject_list += np.loadtxt(split_txt, dtype=str).tolist()
+
+        return subject_list
+
+    def __len__(self):
+        return len(self.subject_list) * len(self.rotations)
+
+    def __getitem__(self, index):
+
+        rid = index % len(self.rotations)
+        mid = index // len(self.rotations)
+
+        rotation = self.rotations[rid]
+        subject = self.subject_list[mid].split("/")[1]
+        dataset = self.subject_list[mid].split("/")[0]
+        render_folder = "/".join([dataset + f"_{self.opt.rotation_num}views", subject])
+
+        if not osp.exists(osp.join(self.root, render_folder)):
+            render_folder = "/".join([dataset + "_36views", subject])
+
+        # setup paths
+        data_dict = {
+            "dataset": dataset,
+            "subject": subject,
+            "rotation": rotation,
+            "scale": self.datasets_dict[dataset]["scale"],
+            "calib_path": osp.join(self.root, render_folder, "calib", f"{rotation:03d}.txt"),
+            "image_path": osp.join(self.root, render_folder, "render", f"{rotation:03d}.png"),
+        }
+
+        if dataset == "cape":
+            data_dict.update(
+                {
+                    "mesh_path":
+                        osp.join(self.datasets_dict[dataset]["mesh_dir"], f"{subject}.obj"),
+                    "smpl_path":
+                        osp.join(self.datasets_dict[dataset]["smpl_dir"], f"{subject}.obj"),
+                }
+            )
+        else:
+
+            data_dict.update(
+                {
+                    "mesh_path":
+                        osp.join(
+                            self.datasets_dict[dataset]["mesh_dir"],
+                            f"{subject}.obj",
+                        ),
+                    "smplx_path":
+                        osp.join(self.datasets_dict[dataset]["smplx_dir"], f"{subject}.obj"),
+                }
+            )
+
+        # load training data
+        data_dict.update(self.load_calib(data_dict))
+
+        # image/normal/depth loader
+        for name, channel in zip(self.in_total, self.in_total_dim):
+
+            if f"{name}_path" not in data_dict.keys():
+                data_dict.update(
+                    {
+                        f"{name}_path":
+                            osp.join(self.root, render_folder, name, f"{rotation:03d}.png")
+                    }
+                )
+
+            # tensor update
+            if os.path.exists(data_dict[f"{name}_path"]):
+                data_dict.update(
+                    {name: self.imagepath2tensor(data_dict[f"{name}_path"], channel, inv=False)}
+                )
+
+        data_dict.update(self.load_mesh(data_dict))
+        data_dict.update(self.load_smpl(data_dict))
+
+        del data_dict["mesh"]
+
+        return data_dict
+
+    def imagepath2tensor(self, path, channel=3, inv=False):
+
+        rgba = Image.open(path).convert("RGBA")
+
+        # remove CAPE's noisy outliers using OpenCV's inpainting
+        if "cape" in path and "T_" not in path:
+            mask = cv2.imread(path.replace(path.split("/")[-2], "mask"), 0) > 1
+            img = np.asarray(rgba)[:, :, :3]
+            fill_mask = ((mask & (img.sum(axis=2) == 0))).astype(np.uint8)
+            image = Image.fromarray(
+                cv2.inpaint(img * mask[..., None], fill_mask, 3, cv2.INPAINT_TELEA)
+            )
+            mask = Image.fromarray(mask)
+        else:
+            mask = rgba.split()[-1]
+            image = rgba.convert("RGB")
+
+        image = self.image_to_tensor(image)
+        mask = self.mask_to_tensor(mask)
+        image = (image * mask)[:channel]
+
+        return (image * (0.5 - inv) * 2.0).float()
+
+    def load_calib(self, data_dict):
+        calib_data = np.loadtxt(data_dict["calib_path"], dtype=float)
+        extrinsic = calib_data[:4, :4]
+        intrinsic = calib_data[4:8, :4]
+        calib_mat = np.matmul(intrinsic, extrinsic)
+        calib_mat = torch.from_numpy(calib_mat).float()
+        return {"calib": calib_mat}
+
+    def load_mesh(self, data_dict):
+
+        mesh_path = data_dict["mesh_path"]
+        scale = data_dict["scale"]
+
+        # tinyobjloader has wired bug
+        scan_mesh = trimesh.load(mesh_path)
+        verts = scan_mesh.vertices
+        faces = scan_mesh.faces
+
+        # verts, faces = obj_loader(mesh_path, with_uv=False)
+
+        mesh = HoppeMesh(verts * scale, faces)
+
+        return {
+            "mesh": mesh,
+            "verts": torch.as_tensor(verts * scale).float(),
+            "faces": torch.as_tensor(faces).long(),
+        }
+
+    def load_smpl(self, data_dict):
+
+        smpl_type = ("smplx" if ("smplx_path" in data_dict.keys()) else "smpl")
+
+        smplx_verts = rescale_smpl(data_dict[f"{smpl_type}_path"], scale=100.0)
+        smplx_faces = torch.as_tensor(getattr(self.smplx, f"{smpl_type}_faces")).long()
+        smplx_verts = projection(smplx_verts, data_dict["calib"]).float()
+
+        return_dict = {
+            "smpl_verts": smplx_verts,
+            "smpl_faces": smplx_faces,
+        }
+
+        return return_dict
+
+    def depth_to_voxel(self, data_dict):
+
+        data_dict["depth_F"] = transforms.Resize(self.vol_res)(data_dict["depth_F"])
+        data_dict["depth_B"] = transforms.Resize(self.vol_res)(data_dict["depth_B"])
+
+        depth_mask = (~torch.isnan(data_dict['depth_F']))
+        depth_FB = torch.cat([data_dict['depth_F'], data_dict['depth_B']], dim=0)
+        depth_FB[:, ~depth_mask[0]] = 0.
+
+        # Important: index_long = depth_value - 1
+        index_z = (((depth_FB + 1.) * 0.5 * self.vol_res) - 1).clip(0, self.vol_res -
+                                                                    1).permute(1, 2, 0)
+        index_z_ceil = torch.ceil(index_z).long()
+        index_z_floor = torch.floor(index_z).long()
+        index_z_frac = torch.frac(index_z)
+
+        index_mask = index_z[..., 0] == torch.tensor(self.vol_res * 0.5 - 1).long()
+        voxels = F.one_hot(index_z_ceil[..., 0], self.vol_res) * index_z_frac[..., 0] + \
+            F.one_hot(index_z_floor[..., 0], self.vol_res) * (1.0-index_z_frac[..., 0]) + \
+            F.one_hot(index_z_ceil[..., 1], self.vol_res) * index_z_frac[..., 1]+ \
+            F.one_hot(index_z_floor[..., 1], self.vol_res) * (1.0 - index_z_frac[..., 1])
+
+        voxels[index_mask] *= 0
+        voxels = torch.flip(voxels, [2]).permute(2, 0, 1).float()    #[x-2, y-0, z-1]
+
+        return {
+            "depth_voxels": voxels.flip([
+                0,
+            ]).unsqueeze(0).to(self.device),
+        }
+
+    def render_depth(self, verts, faces):
+
+        # render optimized mesh (normal, T_normal, image [-1,1])
+        self.render.load_meshes(verts, faces)
+        return self.render.get_image(type="depth")

lib/dataset/Evaluator.py

@@ -296,8 +296,7 @@ class Evaluator:
         tgt_points = Pointclouds(samples_tgt)
         src_points = Pointclouds(samples_src)
 
-        p2s_dist_all, _ = point_mesh_distance(self.src_mesh, tgt_points) * 100.0
-        p2s_dist = p2s_dist_all.sum()
+        p2s_dist = point_mesh_distance(self.src_mesh, tgt_points)[0].sum() * 100.0
 
         chamfer_dist = (
             point_mesh_distance(self.tgt_mesh, src_points)[0].sum() * 100.0 + p2s_dist

lib/dataset/mesh_util.py

@@ -19,6 +19,7 @@ import numpy as np
 import torch
 import torchvision
 import trimesh
+import json
 import open3d as o3d
 import tinyobjloader
 import os.path as osp
@@ -59,6 +60,9 @@ class SMPLX:
             self.current_dir, "smpl_data/FLAME_SMPLX_vertex_ids.npy"
         )
         self.smplx_mano_vid_path = osp.join(self.current_dir, "smpl_data/MANO_SMPLX_vertex_ids.pkl")
+        self.smpl_vert_seg_path = osp.join(
+            osp.dirname(__file__), "../../lib/common/smpl_vert_segmentation.json"
+        )
         self.front_flame_path = osp.join(self.current_dir, "smpl_data/FLAME_face_mask_ids.npy")
         self.smplx_vertex_lmkid_path = osp.join(
             self.current_dir, "smpl_data/smplx_vertex_lmkid.npy"
@@ -70,6 +74,14 @@ class SMPLX:
         self.smpl_faces = np.load(self.smpl_faces_path)
         self.smplx_vertex_lmkid = np.load(self.smplx_vertex_lmkid_path)
 
+        self.smpl_vert_seg = json.load(open(self.smpl_vert_seg_path))
+        self.smpl_mano_vid = np.concatenate(
+            [
+                self.smpl_vert_seg["rightHand"], self.smpl_vert_seg["rightHandIndex1"],
+                self.smpl_vert_seg["leftHand"], self.smpl_vert_seg["leftHandIndex1"]
+            ]
+        )
+
         self.smplx_eyeball_fid_mask = np.load(self.smplx_eyeball_fid_path)
         self.smplx_mouth_fid = np.load(self.smplx_fill_mouth_fid_path)
         self.smplx_mano_vid_dict = np.load(self.smplx_mano_vid_path, allow_pickle=True)
@@ -80,9 +92,13 @@ class SMPLX:
         self.smplx_front_flame_vid = self.smplx_flame_vid[np.load(self.front_flame_path)]
 
         # hands
-        self.mano_vertex_mask = torch.zeros(self.smplx_verts.shape[0], ).index_fill_(
+        self.smplx_mano_vertex_mask = torch.zeros(self.smplx_verts.shape[0], ).index_fill_(
             0, torch.tensor(self.smplx_mano_vid), 1.0
         )
+        self.smpl_mano_vertex_mask = torch.zeros(self.smpl_verts.shape[0], ).index_fill_(
+            0, torch.tensor(self.smpl_mano_vid), 1.0
+        )
+
         # face
         self.front_flame_vertex_mask = torch.zeros(self.smplx_verts.shape[0], ).index_fill_(
             0, torch.tensor(self.smplx_front_flame_vid), 1.0
@@ -237,11 +253,20 @@ def part_removal(full_mesh, part_mesh, thres, device, smpl_obj, region, clean=Tr
 
     if region == "hand":
         _, idx = smpl_tree.query(full_mesh.vertices, k=1)
-        full_lmkid = SMPL_container.smplx_vertex_lmkid[idx]
-        remove_mask = torch.logical_and(
-            remove_mask,
-            torch.tensor(full_lmkid >= 20).type_as(remove_mask).unsqueeze(0)
-        )
+        if smpl_obj.vertices.shape[0] > 6890:
+            full_lmkid = SMPL_container.smplx_vertex_lmkid[idx]
+            remove_mask = torch.logical_and(
+                remove_mask,
+                torch.tensor(full_lmkid >= 20).type_as(remove_mask).unsqueeze(0)
+            )
+        else:
+            remove_mask = torch.logical_and(
+                remove_mask,
+                torch.isin(
+                    torch.tensor(idx).long(),
+                    torch.tensor(SMPL_container.smpl_mano_vid).long()
+                ).type_as(remove_mask).unsqueeze(0)
+            )
 
     elif region == "face":
         _, idx = smpl_tree.query(full_mesh.vertices, k=5)
@@ -386,15 +411,14 @@ def remesh_laplacian(mesh, obj_path):
 
 def poisson(mesh, obj_path, depth=10, decimation=True):
 
-    pcd_path = obj_path[:-4] + ".ply"
+    pcd_path = obj_path[:-4] + "_soups.ply"
     assert (mesh.vertex_normals.shape[1] == 3)
     mesh.export(pcd_path)
     pcl = o3d.io.read_point_cloud(pcd_path)
     with o3d.utility.VerbosityContextManager(o3d.utility.VerbosityLevel.Error) as cm:
         mesh, densities = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(
-            pcl, depth=depth, n_threads=-1
+            pcl, depth=depth, n_threads=6
         )
-    print(colored(f"\n Poisson completion to {Format.start} {obj_path} {Format.end}", "yellow"))
 
     # only keep the largest component
     largest_mesh = keep_largest(trimesh.Trimesh(np.array(mesh.vertices), np.array(mesh.triangles)))

loose.txt

@@ -0,0 +1,100 @@
+renderpeople/rp_yasmin_posed_007
+renderpeople/rp_victoria_posed_006
+renderpeople/rp_tilda_posed_005
+renderpeople/rp_tiffany_posed_015
+renderpeople/rp_tanja_posed_018
+renderpeople/rp_stephanie_posed_010
+renderpeople/rp_stacy_posed_002
+renderpeople/rp_serena_posed_027
+renderpeople/rp_serena_posed_024
+renderpeople/rp_seiko_posed_031
+renderpeople/rp_seiko_posed_015
+renderpeople/rp_saki_posed_033
+renderpeople/rp_rosy_posed_014
+renderpeople/rp_rosy_posed_001
+renderpeople/rp_roberta_posed_022
+renderpeople/rp_rick_posed_016
+renderpeople/rp_ray_posed_007
+renderpeople/rp_ramon_posed_002
+renderpeople/rp_ralph_posed_013
+renderpeople/rp_philip_posed_030
+renderpeople/rp_petra_posed_008
+renderpeople/rp_olivia_posed_014
+renderpeople/rp_olivia_posed_007
+renderpeople/rp_naomi_posed_034
+renderpeople/rp_naomi_posed_030
+renderpeople/rp_martha_posed_002
+renderpeople/rp_martha_posed_001
+renderpeople/rp_marleen_posed_002
+renderpeople/rp_lina_posed_004
+renderpeople/rp_kylie_posed_017
+renderpeople/rp_kylie_posed_006
+renderpeople/rp_kylie_posed_003
+renderpeople/rp_kent_posed_005
+renderpeople/rp_kent_posed_002
+renderpeople/rp_julia_posed_022
+renderpeople/rp_julia_posed_014
+renderpeople/rp_judy_posed_002
+renderpeople/rp_jessica_posed_058
+renderpeople/rp_jessica_posed_022
+renderpeople/rp_jennifer_posed_003
+renderpeople/rp_janna_posed_046
+renderpeople/rp_janna_posed_043
+renderpeople/rp_janna_posed_034
+renderpeople/rp_janna_posed_019
+renderpeople/rp_janett_posed_016
+renderpeople/rp_jamal_posed_012
+renderpeople/rp_helen_posed_037
+renderpeople/rp_fiona_posed_002
+renderpeople/rp_felice_posed_005
+renderpeople/rp_felice_posed_004
+renderpeople/rp_eve_posed_003
+renderpeople/rp_eve_posed_002
+renderpeople/rp_eve_posed_001
+renderpeople/rp_eric_posed_048
+renderpeople/rp_emma_posed_029
+renderpeople/rp_ellie_posed_015
+renderpeople/rp_ellie_posed_014
+renderpeople/rp_debra_posed_016
+renderpeople/rp_debra_posed_014
+renderpeople/rp_debra_posed_004
+renderpeople/rp_corey_posed_020
+renderpeople/rp_corey_posed_009
+renderpeople/rp_corey_posed_004
+renderpeople/rp_cody_posed_016
+renderpeople/rp_claudia_posed_034
+renderpeople/rp_claudia_posed_033
+renderpeople/rp_claudia_posed_024
+renderpeople/rp_claudia_posed_025
+renderpeople/rp_cindy_posed_020
+renderpeople/rp_christine_posed_023
+renderpeople/rp_christine_posed_022
+renderpeople/rp_christine_posed_020
+renderpeople/rp_christine_posed_010
+renderpeople/rp_carla_posed_016
+renderpeople/rp_caren_posed_009
+renderpeople/rp_caren_posed_008
+renderpeople/rp_brandon_posed_006
+renderpeople/rp_belle_posed_001
+renderpeople/rp_beatrice_posed_025
+renderpeople/rp_beatrice_posed_024
+renderpeople/rp_beatrice_posed_023
+renderpeople/rp_beatrice_posed_021
+renderpeople/rp_beatrice_posed_019
+renderpeople/rp_beatrice_posed_017
+renderpeople/rp_anna_posed_008
+renderpeople/rp_anna_posed_007
+renderpeople/rp_anna_posed_006
+renderpeople/rp_anna_posed_003
+renderpeople/rp_anna_posed_001
+renderpeople/rp_alvin_posed_016
+renderpeople/rp_alison_posed_028
+renderpeople/rp_alison_posed_024
+renderpeople/rp_alison_posed_017
+renderpeople/rp_alexandra_posed_022
+renderpeople/rp_alexandra_posed_023
+renderpeople/rp_alexandra_posed_019
+renderpeople/rp_alexandra_posed_018
+renderpeople/rp_alexandra_posed_013
+renderpeople/rp_alexandra_posed_012
+renderpeople/rp_alexandra_posed_011

pose.txt

@@ -0,0 +1,100 @@
+cape/00215-jerseyshort-pose_model-000200
+cape/00134-longlong-ballet4_trial2-000250
+cape/00134-longlong-badminton_trial1-000230
+cape/00134-longlong-frisbee_trial1-000190
+cape/03375-shortlong-ballet1_trial1-000210
+cape/03375-longlong-babysit_trial2-000110
+cape/00134-shortlong-stretch_trial1-000310
+cape/03375-shortshort-lean_trial1-000060
+cape/03375-shortshort-swim_trial2-000110
+cape/03375-longlong-box_trial1-000190
+cape/03375-longlong-row_trial2-000150
+cape/00134-shortlong-hockey_trial1-000140
+cape/00134-shortlong-hockey_trial1-000090
+cape/00134-longlong-ski_trial2-000200
+cape/00134-longlong-stretch_trial1-000450
+cape/00096-shirtshort-soccer-000160
+cape/03375-shortshort-hands_up_trial2-000270
+cape/03375-shortshort-ballet1_trial1-000110
+cape/03375-longlong-babysit_trial2-000150
+cape/03375-shortshort-fashion_trial1-000140
+cape/00134-shortlong-ballet2_trial1-000110
+cape/00134-longlong-ballet2_trial1-000120
+cape/00134-shortlong-ballet2_trial1-000120
+cape/00134-shortlong-ballet2_trial1-000090
+cape/00134-longlong-ballet2_trial2-000110
+cape/00134-longlong-volleyball_trial2-000050
+cape/00134-longlong-stretch_trial1-000500
+cape/00134-longlong-housework_trial1-000380
+cape/00134-shortlong-dig_trial1-000150
+cape/03375-longlong-catchpick_trial1-000110
+cape/03375-shortlong-ballet1_trial1-000250
+cape/03375-shortlong-shoulders_trial1-000360
+cape/03375-shortlong-slack_trial2-000070
+cape/03375-shortlong-shoulders_trial1-000220
+cape/03375-shortlong-stretch_trial1-000330
+cape/00127-shortlong-ballerina_spin-000080
+cape/00127-shortlong-ballerina_spin-000200
+cape/00096-shortshort-basketball-000100
+cape/00096-shortshort-ballerina_spin-000160
+cape/00134-longlong-stretch_trial2-000440
+cape/02474-longlong-ATUsquat-000100
+cape/03375-longlong-ATUsquat_trial1-000120
+cape/02474-longlong-ATUsquat-000110
+cape/00134-longlong-ballet1_trial1-000180
+cape/00096-shirtlong-ATUsquat-000130
+cape/00032-shortshort-pose_model-000030
+cape/00134-shortlong-athletics_trial2-000070
+cape/00032-longshort-pose_model-000060
+cape/00032-shortshort-shoulders_mill-000060
+cape/00127-shortlong-pose_model-000430
+cape/00122-shortshort-ATUsquat-000120
+cape/00032-shortshort-bend_back_and_front-000220
+cape/00096-shortshort-squats-000180
+cape/00032-shortlong-squats-000090
+cape/03375-shortlong-ATUsquat_trial2-000080
+cape/03375-shortshort-lean_trial1-000130
+cape/03375-blazerlong-music_trial1-000150
+cape/03284-longlong-hips-000170
+cape/03375-shortlong-shoulders_trial1-000370
+cape/03375-shortlong-ballet1_trial1-000290
+cape/00215-jerseyshort-shoulders_mill-000320
+cape/00215-poloshort-soccer-000110
+cape/00122-shortshort-punching-000170
+cape/00096-jerseyshort-shoulders_mill-000140
+cape/00032-longshort-flying_eagle-000240
+cape/00134-shortlong-swim_trial1-000160
+cape/03375-shortshort-music_trial1-000120
+cape/03375-shortshort-handball_trial1-000120
+cape/00215-longshort-punching-000060
+cape/00134-shortlong-swim_trial2-000120
+cape/03375-shortshort-hands_up_trial1-000140
+cape/03375-shortshort-hands_up_trial1-000270
+cape/03375-shortshort-volleyball_trial1-000110
+cape/03375-shortshort-swim_trial1-000270
+cape/03375-longlong-row_trial2-000190
+cape/00215-poloshort-flying_eagle-000120
+cape/03223-shortshort-flying_eagle-000280
+cape/00096-shirtlong-shoulders_mill-000110
+cape/00096-shirtshort-pose_model-000190
+cape/03375-shortshort-swim_trial1-000190
+cape/03375-shortlong-music_trial2-000040
+cape/03375-shortlong-babysit_trial2-000070
+cape/00215-jerseyshort-flying_eagle-000110
+cape/03375-blazerlong-music_trial1-000030
+cape/03375-longlong-volleyball_trial2-000230
+cape/03375-blazerlong-lean_trial2-000110
+cape/03375-longlong-box_trial2-000110
+cape/03375-longlong-drinkeat_trial2-000050
+cape/00134-shortlong-slack_trial1-000150
+cape/03375-shortshort-climb_trial1-000170
+cape/00032-longshort-tilt_twist_left-000060
+cape/00215-longshort-chicken_wings-000060
+cape/00215-poloshort-bend_back_and_front-000130
+cape/03223-longshort-flying_eagle-000480
+cape/00215-longshort-bend_back_and_front-000100
+cape/00215-longshort-tilt_twist_left-000130
+cape/00096-longshort-tilt_twist_left-000150
+cape/03284-longshort-twist_tilt_left-000080
+cape/03223-shortshort-flying_eagle-000270
+cape/02474-longshort-improvise-000080