.

.gitattributes

@@ -56,3 +56,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+*.ply filter=lfs diff=lfs merge=lfs -text

LICENSE.md

@@ -0,0 +1,83 @@
+Gaussian-Splatting License  
+===========================  
+
+**Inria** and **the Max Planck Institut for Informatik (MPII)** hold all the ownership rights on the *Software* named **gaussian-splatting**.  
+The *Software* is in the process of being registered with the Agence pour la Protection des  
+Programmes (APP).  
+
+The *Software* is still being developed by the *Licensor*.  
+
+*Licensor*'s goal is to allow the research community to use, test and evaluate  
+the *Software*.  
+
+## 1.  Definitions  
+
+*Licensee* means any person or entity that uses the *Software* and distributes  
+its *Work*.  
+
+*Licensor* means the owners of the *Software*, i.e Inria and MPII  
+
+*Software* means the original work of authorship made available under this  
+License ie gaussian-splatting.  
+
+*Work* means the *Software* and any additions to or derivative works of the  
+*Software* that are made available under this License.  
+
+
+## 2.  Purpose  
+This license is intended to define the rights granted to the *Licensee* by  
+Licensors under the *Software*.  
+
+## 3.  Rights granted  
+
+For the above reasons Licensors have decided to distribute the *Software*.  
+Licensors grant non-exclusive rights to use the *Software* for research purposes  
+to research users (both academic and industrial), free of charge, without right  
+to sublicense.. The *Software* may be used "non-commercially", i.e., for research  
+and/or evaluation purposes only.  
+
+Subject to the terms and conditions of this License, you are granted a  
+non-exclusive, royalty-free, license to reproduce, prepare derivative works of,  
+publicly display, publicly perform and distribute its *Work* and any resulting  
+derivative works in any form.  
+
+## 4.  Limitations  
+
+**4.1 Redistribution.** You may reproduce or distribute the *Work* only if (a) you do  
+so under this License, (b) you include a complete copy of this License with  
+your distribution, and (c) you retain without modification any copyright,  
+patent, trademark, or attribution notices that are present in the *Work*.  
+
+**4.2 Derivative Works.** You may specify that additional or different terms apply  
+to the use, reproduction, and distribution of your derivative works of the *Work*  
+("Your Terms") only if (a) Your Terms provide that the use limitation in  
+Section 2 applies to your derivative works, and (b) you identify the specific  
+derivative works that are subject to Your Terms. Notwithstanding Your Terms,  
+this License (including the redistribution requirements in Section 3.1) will  
+continue to apply to the *Work* itself.  
+
+**4.3** Any other use without of prior consent of Licensors is prohibited. Research  
+users explicitly acknowledge having received from Licensors all information  
+allowing to appreciate the adequacy between of the *Software* and their needs and  
+to undertake all necessary precautions for its execution and use.  
+
+**4.4** The *Software* is provided both as a compiled library file and as source  
+code. In case of using the *Software* for a publication or other results obtained  
+through the use of the *Software*, users are strongly encouraged to cite the  
+corresponding publications as explained in the documentation of the *Software*.  
+
+## 5.  Disclaimer  
+
+THE USER CANNOT USE, EXPLOIT OR DISTRIBUTE THE *SOFTWARE* FOR COMMERCIAL PURPOSES  
+WITHOUT PRIOR AND EXPLICIT CONSENT OF LICENSORS. YOU MUST CONTACT INRIA FOR ANY  
+UNAUTHORIZED USE: stip-sophia.transfert@inria.fr . ANY SUCH ACTION WILL  
+CONSTITUTE A FORGERY. THIS *SOFTWARE* IS PROVIDED "AS IS" WITHOUT ANY WARRANTIES  
+OF ANY NATURE AND ANY EXPRESS OR IMPLIED WARRANTIES, WITH REGARDS TO COMMERCIAL  
+USE, PROFESSIONNAL USE, LEGAL OR NOT, OR OTHER, OR COMMERCIALISATION OR  
+ADAPTATION. UNLESS EXPLICITLY PROVIDED BY LAW, IN NO EVENT, SHALL INRIA OR THE  
+AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR  
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE  
+GOODS OR SERVICES, LOSS OF USE, DATA, OR PROFITS OR BUSINESS INTERRUPTION)  
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT  
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING FROM, OUT OF OR  
+IN CONNECTION WITH THE *SOFTWARE* OR THE USE OR OTHER DEALINGS IN THE *SOFTWARE*.  

dtu.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4caf0a4523494dea748c514f718cd3d187956e3ccb511703829e25caa9846da7
+size 3561809006

dtu_results/mesh/scan105.ply

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b75c868c3b0d41f039855e7d67768f5e7edd184942db3e1a54d9a1de09eeb804
+size 5945211

dtu_results/mesh/scan106.ply

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c4ac08899eeedae1da6c25141d04a1594c8cef37df33446336bcf0311462e32
+size 6466761

dtu_results/mesh/scan110.ply

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4f70861339f38b7d1e59d717e022c6d6fc6f803e22515485ad258bafc6e8b40
+size 4840368

dtu_results/mesh/scan114.ply

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dac7f6ff3f799534d9a1d929d9af06a22726a0535bdaeebc0eb4650508cea2a4
+size 3780667

dtu_results/mesh/scan118.ply

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1ed9e578ac04d8b5adca51b62a8074fa2c2840cf7d2c588e785a97f95bba8f1e
+size 5759764

dtu_results/mesh/scan122.ply

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3254a5c678e16154cc6f931a3e8e207823aac55c68404e34ffc650a7afb1802a
+size 5703021

dtu_results/mesh/scan24.ply

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7269dac27860efc610d33cfd23b27f0eff3a3c441c54fceff63f8c5e831a791f
+size 10548798

dtu_results/mesh/scan37.ply

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:deca83c23fcb3f8885138e6d7189690f3f3f4d5965649727e86a411abc5b7246
+size 13370975

dtu_results/mesh/scan40.ply

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d70f35437d16054f4be4a5147c08d356a541bce9716a09941200ecda631819c
+size 9288623

dtu_results/mesh/scan55.ply

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:505c626094e3ac5217a233a7caca44f427d1133b25ddb670c6f1bb957577bc1a
+size 7592924

dtu_results/mesh/scan63.ply

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d07d00caa8eab3aadbdba0abb92f288e1f00669c1df02e6cded797e69501361
+size 7510769

dtu_results/mesh/scan65.ply

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c0815d074fb98f7b9b922775a8d5dcca0cebd8b4e9b4fdea88586fb1cd93386
+size 10142310

dtu_results/mesh/scan69.ply

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ecf0eceb175285a5aa6eeaa0d39b25ad08d993a65312e0c18398f5b95a669812
+size 8369756

dtu_results/mesh/scan83.ply

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3da9869c2e36b48b48ce65bd21824abfbf15fab3ff99d59b42741e681abaab46
+size 5809035

dtu_results/mesh/scan97.ply

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c7e703cfc1ef8fc9bd454942285af547673d0e9be98868ad680dfbeeec21b8a4
+size 5216954

eval_dtu/eval.py

@@ -0,0 +1,166 @@
+# adapted from https://github.com/jzhangbs/DTUeval-python
+import numpy as np
+import open3d as o3d
+import sklearn.neighbors as skln
+from tqdm import tqdm
+from scipy.io import loadmat
+import multiprocessing as mp
+import argparse
+
+def sample_single_tri(input_):
+    n1, n2, v1, v2, tri_vert = input_
+    c = np.mgrid[:n1+1, :n2+1]
+    c += 0.5
+    c[0] /= max(n1, 1e-7)
+    c[1] /= max(n2, 1e-7)
+    c = np.transpose(c, (1,2,0))
+    k = c[c.sum(axis=-1) < 1]  # m2
+    q = v1 * k[:,:1] + v2 * k[:,1:] + tri_vert
+    return q
+
+def write_vis_pcd(file, points, colors):
+    pcd = o3d.geometry.PointCloud()
+    pcd.points = o3d.utility.Vector3dVector(points)
+    pcd.colors = o3d.utility.Vector3dVector(colors)
+    o3d.io.write_point_cloud(file, pcd)
+
+if __name__ == '__main__':
+    mp.freeze_support()
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--data', type=str, default='data_in.ply')
+    parser.add_argument('--scan', type=int, default=1)
+    parser.add_argument('--mode', type=str, default='mesh', choices=['mesh', 'pcd'])
+    parser.add_argument('--dataset_dir', type=str, default='.')
+    parser.add_argument('--vis_out_dir', type=str, default='.')
+    parser.add_argument('--downsample_density', type=float, default=0.2)
+    parser.add_argument('--patch_size', type=float, default=60)
+    parser.add_argument('--max_dist', type=float, default=20)
+    parser.add_argument('--visualize_threshold', type=float, default=10)
+    args = parser.parse_args()
+
+    thresh = args.downsample_density
+    if args.mode == 'mesh':
+        pbar = tqdm(total=9)
+        pbar.set_description('read data mesh')
+        data_mesh = o3d.io.read_triangle_mesh(args.data)
+
+        vertices = np.asarray(data_mesh.vertices)
+        triangles = np.asarray(data_mesh.triangles)
+        tri_vert = vertices[triangles]
+
+        pbar.update(1)
+        pbar.set_description('sample pcd from mesh')
+        v1 = tri_vert[:,1] - tri_vert[:,0]
+        v2 = tri_vert[:,2] - tri_vert[:,0]
+        l1 = np.linalg.norm(v1, axis=-1, keepdims=True)
+        l2 = np.linalg.norm(v2, axis=-1, keepdims=True)
+        area2 = np.linalg.norm(np.cross(v1, v2), axis=-1, keepdims=True)
+        non_zero_area = (area2 > 0)[:,0]
+        l1, l2, area2, v1, v2, tri_vert = [
+            arr[non_zero_area] for arr in [l1, l2, area2, v1, v2, tri_vert]
+        ]
+        thr = thresh * np.sqrt(l1 * l2 / area2)
+        n1 = np.floor(l1 / thr)
+        n2 = np.floor(l2 / thr)
+
+        with mp.Pool() as mp_pool:
+            new_pts = mp_pool.map(sample_single_tri, ((n1[i,0], n2[i,0], v1[i:i+1], v2[i:i+1], tri_vert[i:i+1,0]) for i in range(len(n1))), chunksize=1024)
+
+        new_pts = np.concatenate(new_pts, axis=0)
+        data_pcd = np.concatenate([vertices, new_pts], axis=0)
+    
+    elif args.mode == 'pcd':
+        pbar = tqdm(total=8)
+        pbar.set_description('read data pcd')
+        data_pcd_o3d = o3d.io.read_point_cloud(args.data)
+        data_pcd = np.asarray(data_pcd_o3d.points)
+
+    pbar.update(1)
+    pbar.set_description('random shuffle pcd index')
+    shuffle_rng = np.random.default_rng()
+    shuffle_rng.shuffle(data_pcd, axis=0)
+
+    pbar.update(1)
+    pbar.set_description('downsample pcd')
+    nn_engine = skln.NearestNeighbors(n_neighbors=1, radius=thresh, algorithm='kd_tree', n_jobs=-1)
+    nn_engine.fit(data_pcd)
+    rnn_idxs = nn_engine.radius_neighbors(data_pcd, radius=thresh, return_distance=False)
+    mask = np.ones(data_pcd.shape[0], dtype=np.bool_)
+    for curr, idxs in enumerate(rnn_idxs):
+        if mask[curr]:
+            mask[idxs] = 0
+            mask[curr] = 1
+    data_down = data_pcd[mask]
+
+    pbar.update(1)
+    pbar.set_description('masking data pcd')
+    obs_mask_file = loadmat(f'{args.dataset_dir}/ObsMask/ObsMask{args.scan}_10.mat')
+    ObsMask, BB, Res = [obs_mask_file[attr] for attr in ['ObsMask', 'BB', 'Res']]
+    BB = BB.astype(np.float32)
+
+    patch = args.patch_size
+    inbound = ((data_down >= BB[:1]-patch) & (data_down < BB[1:]+patch*2)).sum(axis=-1) ==3
+    data_in = data_down[inbound]
+
+    data_grid = np.around((data_in - BB[:1]) / Res).astype(np.int32)
+    grid_inbound = ((data_grid >= 0) & (data_grid < np.expand_dims(ObsMask.shape, 0))).sum(axis=-1) ==3
+    data_grid_in = data_grid[grid_inbound]
+    in_obs = ObsMask[data_grid_in[:,0], data_grid_in[:,1], data_grid_in[:,2]].astype(np.bool_)
+    data_in_obs = data_in[grid_inbound][in_obs]
+
+    pbar.update(1)
+    pbar.set_description('read STL pcd')
+    stl_pcd = o3d.io.read_point_cloud(f'{args.dataset_dir}/Points/stl/stl{args.scan:03}_total.ply')
+    stl = np.asarray(stl_pcd.points)
+
+    pbar.update(1)
+    pbar.set_description('compute data2stl')
+    nn_engine.fit(stl)
+    dist_d2s, idx_d2s = nn_engine.kneighbors(data_in_obs, n_neighbors=1, return_distance=True)
+    max_dist = args.max_dist
+    mean_d2s = dist_d2s[dist_d2s < max_dist].mean()
+
+    pbar.update(1)
+    pbar.set_description('compute stl2data')
+    ground_plane = loadmat(f'{args.dataset_dir}/ObsMask/Plane{args.scan}.mat')['P']
+
+    stl_hom = np.concatenate([stl, np.ones_like(stl[:,:1])], -1)
+    above = (ground_plane.reshape((1,4)) * stl_hom).sum(-1) > 0
+    stl_above = stl[above]
+
+    nn_engine.fit(data_in)
+    dist_s2d, idx_s2d = nn_engine.kneighbors(stl_above, n_neighbors=1, return_distance=True)
+    mean_s2d = dist_s2d[dist_s2d < max_dist].mean()
+
+    pbar.update(1)
+    pbar.set_description('visualize error')
+    vis_dist = args.visualize_threshold
+    R = np.array([[1,0,0]], dtype=np.float64)
+    G = np.array([[0,1,0]], dtype=np.float64)
+    B = np.array([[0,0,1]], dtype=np.float64)
+    W = np.array([[1,1,1]], dtype=np.float64)
+    data_color = np.tile(B, (data_down.shape[0], 1))
+    data_alpha = dist_d2s.clip(max=vis_dist) / vis_dist
+    data_color[ np.where(inbound)[0][grid_inbound][in_obs] ] = R * data_alpha + W * (1-data_alpha)
+    data_color[ np.where(inbound)[0][grid_inbound][in_obs][dist_d2s[:,0] >= max_dist] ] = G
+    write_vis_pcd(f'{args.vis_out_dir}/vis_{args.scan:03}_d2s.ply', data_down, data_color)
+    stl_color = np.tile(B, (stl.shape[0], 1))
+    stl_alpha = dist_s2d.clip(max=vis_dist) / vis_dist
+    stl_color[ np.where(above)[0] ] = R * stl_alpha + W * (1-stl_alpha)
+    stl_color[ np.where(above)[0][dist_s2d[:,0] >= max_dist] ] = G
+    write_vis_pcd(f'{args.vis_out_dir}/vis_{args.scan:03}_s2d.ply', stl, stl_color)
+
+    pbar.update(1)
+    pbar.set_description('done')
+    pbar.close()
+    over_all = (mean_d2s + mean_s2d) / 2
+    print(mean_d2s, mean_s2d, over_all)
+    
+    import json
+    with open(f'{args.vis_out_dir}/results.json', 'w') as fp:
+        json.dump({
+            'mean_d2s': mean_d2s,
+            'mean_s2d': mean_s2d,
+            'overall': over_all,
+        }, fp, indent=True)

eval_dtu/evaluate.py

@@ -0,0 +1,62 @@
+from logging import root
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import cv2
+import numpy as np
+import os
+import glob
+from skimage.morphology import binary_dilation, disk
+import argparse
+import trimesh
+from pathlib import Path
+import subprocess
+
+from evaluate_single_scene import cull_scan
+
+
+# Ground truth DTU point cloud path
+Offical_DTU_Dataset = "./Offical_DTU_Dataset"
+scans = [24, 37, 40, 55, 63, 65, 69, 83, 97, 105, 106, 110, 114, 118, 122]
+
+out_dir_prefix = "evaluation/"
+Path(out_dir_prefix).mkdir(parents=True, exist_ok=True)
+
+# output file to save quantitative results
+evaluation_txt_file = "evaluation/DTU.csv"
+evaluation_txt_file = open(evaluation_txt_file, 'w')
+
+root_dir = '../exps/'
+exp_names =["dtu_3views"]
+
+for exp in exp_names:    
+    for scan in scans:
+        out_dir = os.path.join(out_dir_prefix, str(scan))
+        Path(out_dir).mkdir(parents=True, exist_ok=True)
+        vis_out_dir = os.path.join(out_dir_prefix, exp)
+        Path(vis_out_dir).mkdir(parents=True, exist_ok=True)
+        
+        cur_root = os.path.join(root_dir, f"{exp}_{scan}")
+        
+        files = list(filter(os.path.isfile, glob.glob(os.path.join(cur_root, "*/plots/*.ply"))))
+        files.sort(key=lambda x:os.path.getmtime(x))
+        
+        for ply_file in files[-1:]:    
+            iter_num = Path(ply_file).stem
+            cur_vis_out_dir = os.path.join(out_dir_prefix, exp)
+            Path(cur_vis_out_dir).mkdir(parents=True, exist_ok=True)
+        
+            print(ply_file)
+
+            # delete mesh by mask
+            result_mesh_file = os.path.join(out_dir, f"{exp}_{iter_num}.ply")
+            cull_scan(scan, ply_file, result_mesh_file)
+            
+            cmd = f"python eval.py --data {result_mesh_file} --scan {scan} --mode mesh --dataset_dir {Offical_DTU_Dataset} --vis_out_dir {cur_vis_out_dir}"
+            print(cmd)
+            #acc, comp, overall 
+            output = subprocess.check_output(cmd, shell=True).decode("utf-8")
+            output = output.replace(" ", ",")
+            
+            evaluation_txt_file.write(f"{exp},{scan},{iter_num},{output}")
+            evaluation_txt_file.flush()

eval_dtu/evaluate_single_scene.py

@@ -0,0 +1,148 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import cv2
+import numpy as np
+import os
+import glob
+from skimage.morphology import binary_dilation, disk
+import argparse
+
+import trimesh
+from pathlib import Path
+import subprocess
+
+import sys
+sys.path.append("../code")
+import render_utils as rend_util
+
+
+def cull_scan(scan, mesh_path, result_mesh_file):
+    
+    # load poses
+    instance_dir = os.path.join('/p300/wangchy/huangbb/anti-alising-gaussian-splatting/data/DTU_dense', 'scan{0}'.format(scan))
+    image_dir = '{0}/images'.format(instance_dir)
+    image_paths = sorted(glob.glob(os.path.join(image_dir, "*.png")))
+    n_images = len(image_paths)
+    cam_file = '{0}/cameras.npz'.format(instance_dir)
+    camera_dict = np.load(cam_file)
+    scale_mats = [camera_dict['scale_mat_%d' % idx].astype(np.float32) for idx in range(n_images)]
+    world_mats = [camera_dict['world_mat_%d' % idx].astype(np.float32) for idx in range(n_images)]
+
+    intrinsics_all = []
+    pose_all = []
+    for scale_mat, world_mat in zip(scale_mats, world_mats):
+        P = world_mat @ scale_mat
+        P = P[:3, :4]
+        intrinsics, pose = rend_util.load_K_Rt_from_P(None, P)
+        intrinsics_all.append(torch.from_numpy(intrinsics).float())
+        pose_all.append(torch.from_numpy(pose).float())
+    
+    # load mask
+    mask_dir = '{0}/mask'.format(instance_dir)
+    mask_paths = sorted(glob.glob(os.path.join(mask_dir, "*.png")))
+    masks = []
+    for p in mask_paths:
+        mask = cv2.imread(p)
+        masks.append(mask)
+
+    # hard-coded image shape
+    W, H = 1600, 1200
+
+    # load mesh
+    mesh = trimesh.load(mesh_path)
+    
+    # load transformation matrix
+
+    vertices = mesh.vertices
+
+    # project and filter
+    vertices = torch.from_numpy(vertices).cuda()
+    vertices = torch.cat((vertices, torch.ones_like(vertices[:, :1])), dim=-1)
+    vertices = vertices.permute(1, 0)
+    vertices = vertices.float()
+
+    sampled_masks = []
+    for i in range(n_images):
+        pose = pose_all[i]
+        w2c = torch.inverse(pose).cuda()
+        intrinsic = intrinsics_all[i].cuda()
+
+        with torch.no_grad():
+            # transform and project
+            cam_points = intrinsic @ w2c @ vertices
+            pix_coords = cam_points[:2, :] / (cam_points[2, :].unsqueeze(0) + 1e-6)
+            pix_coords = pix_coords.permute(1, 0)
+            pix_coords[..., 0] /= W - 1
+            pix_coords[..., 1] /= H - 1
+            pix_coords = (pix_coords - 0.5) * 2
+            valid = ((pix_coords > -1. ) & (pix_coords < 1.)).all(dim=-1).float()
+            
+            # dialate mask similar to unisurf
+            maski = masks[i][:, :, 0].astype(np.float32) / 256.
+            maski = torch.from_numpy(binary_dilation(maski, disk(24))).float()[None, None].cuda()
+            
+            # # if scan == '83': 
+            # import matplotlib.pyplot as plt
+            # plt.imshow(maski.cpu().numpy()[0,0])
+            # points = (cam_points[:2, :] / (cam_points[2, :].unsqueeze(0) + 1e-6)).permute(1,0)[valid==1].cpu().numpy()
+            # scatters = points[np.random.permutation(len(points))[:10000]]
+            # plt.scatter(scatters[:,0], scatters[:,1], color='r')
+            # plt.savefig(f'test{i}')
+            # plt.clf()
+            # plt.close()
+
+            sampled_mask = F.grid_sample(maski, pix_coords[None, None], mode='nearest', padding_mode='zeros', align_corners=True)[0, -1, 0]
+            # print(f'culling {i}')
+            sampled_mask = sampled_mask + (1. - valid)
+            sampled_masks.append(sampled_mask)
+
+    sampled_masks = torch.stack(sampled_masks, -1)
+    # filter
+    
+    mask = (sampled_masks > 0.).all(dim=-1).cpu().numpy()
+    face_mask = mask[mesh.faces].all(axis=1)
+
+    mesh.update_vertices(mask)
+    mesh.update_faces(face_mask)
+    
+    # with o3d.utility.VerbosityContextManager(o3d.utility.VerbosityLevel.Debug) as cm:
+    #     triangle_clusters, cluster_n_triangles, cluster_area = (mesh.cluster_connected_triangles())
+    # triangle_clusters = np.asarray(triangle_clusters)
+    # cluster_n_triangles = np.asarray(cluster_n_triangles)
+    # cluster_area = np.asarray(cluster_area)
+    # largest_cluster_idx = cluster_n_triangles.argmax()
+    # triangles_to_remove = (triangle_clusters != largest_cluster_idx)
+    
+    # transform vertices to world 
+    scale_mat = scale_mats[0]
+    mesh.vertices = mesh.vertices * scale_mat[0, 0] + scale_mat[:3, 3][None]
+    mesh.export(result_mesh_file)
+    del mesh
+    
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser(
+        description='Arguments to evaluate the mesh.'
+    )
+
+    parser.add_argument('--input_mesh', type=str,  help='path to the mesh to be evaluated')
+    parser.add_argument('--scan_id', type=str,  help='scan id of the input mesh')
+    parser.add_argument('--output_dir', type=str, default='evaluation_results_single', help='path to the output folder')
+    parser.add_argument('--DTU', type=str,  default='Offical_DTU_Dataset', help='path to the GT DTU point clouds')
+    args = parser.parse_args()
+
+
+    Offical_DTU_Dataset = args.DTU
+    out_dir = args.output_dir
+    Path(out_dir).mkdir(parents=True, exist_ok=True)
+
+    scan = args.scan_id
+    ply_file = args.input_mesh
+    
+    result_mesh_file = os.path.join(out_dir, "culled_mesh.ply")
+    cull_scan(scan, ply_file, result_mesh_file)
+
+    cmd = f"python eval.py --data {result_mesh_file} --scan {scan} --mode mesh --dataset_dir {Offical_DTU_Dataset} --vis_out_dir {out_dir}"
+    os.system(cmd)

eval_dtu/render_utils.py

@@ -0,0 +1,169 @@
+import numpy as np
+import imageio
+import skimage
+import cv2
+import torch
+from torch.nn import functional as F
+
+
+def get_psnr(img1, img2, normalize_rgb=False):
+    if normalize_rgb: # [-1,1] --> [0,1]
+        img1 = (img1 + 1.) / 2.
+        img2 = (img2 + 1. ) / 2.
+
+    mse = torch.mean((img1 - img2) ** 2)
+    psnr = -10. * torch.log(mse) / torch.log(torch.Tensor([10.]).cuda())
+
+    return psnr
+
+
+def load_rgb(path, normalize_rgb = False):
+    img = imageio.imread(path)
+    img = skimage.img_as_float32(img)
+
+    if normalize_rgb: # [-1,1] --> [0,1]
+        img -= 0.5
+        img *= 2.
+    img = img.transpose(2, 0, 1)
+    return img
+
+
+def load_K_Rt_from_P(filename, P=None):
+    if P is None:
+        lines = open(filename).read().splitlines()
+        if len(lines) == 4:
+            lines = lines[1:]
+        lines = [[x[0], x[1], x[2], x[3]] for x in (x.split(" ") for x in lines)]
+        P = np.asarray(lines).astype(np.float32).squeeze()
+
+    out = cv2.decomposeProjectionMatrix(P)
+    K = out[0]
+    R = out[1]
+    t = out[2]
+
+    K = K/K[2,2]
+    intrinsics = np.eye(4)
+    intrinsics[:3, :3] = K
+
+    pose = np.eye(4, dtype=np.float32)
+    pose[:3, :3] = R.transpose()
+    pose[:3,3] = (t[:3] / t[3])[:,0]
+
+    return intrinsics, pose
+
+
+def get_camera_params(uv, pose, intrinsics):
+    if pose.shape[1] == 7: #In case of quaternion vector representation
+        cam_loc = pose[:, 4:]
+        R = quat_to_rot(pose[:,:4])
+        p = torch.eye(4).repeat(pose.shape[0],1,1).cuda().float()
+        p[:, :3, :3] = R
+        p[:, :3, 3] = cam_loc
+    else: # In case of pose matrix representation
+        cam_loc = pose[:, :3, 3]
+        p = pose
+
+    batch_size, num_samples, _ = uv.shape
+
+    depth = torch.ones((batch_size, num_samples)).cuda()
+    x_cam = uv[:, :, 0].view(batch_size, -1)
+    y_cam = uv[:, :, 1].view(batch_size, -1)
+    z_cam = depth.view(batch_size, -1)
+
+    pixel_points_cam = lift(x_cam, y_cam, z_cam, intrinsics=intrinsics)
+
+    # permute for batch matrix product
+    pixel_points_cam = pixel_points_cam.permute(0, 2, 1)
+
+    world_coords = torch.bmm(p, pixel_points_cam).permute(0, 2, 1)[:, :, :3]
+    ray_dirs = world_coords - cam_loc[:, None, :]
+    ray_dirs = F.normalize(ray_dirs, dim=2)
+
+    return ray_dirs, cam_loc
+
+
+def get_camera_for_plot(pose):
+    if pose.shape[1] == 7: #In case of quaternion vector representation
+        cam_loc = pose[:, 4:].detach()
+        R = quat_to_rot(pose[:,:4].detach())
+    else: # In case of pose matrix representation
+        cam_loc = pose[:, :3, 3]
+        R = pose[:, :3, :3]
+    cam_dir = R[:, :3, 2]
+    return cam_loc, cam_dir
+
+
+def lift(x, y, z, intrinsics):
+    # parse intrinsics
+    intrinsics = intrinsics.cuda()
+    fx = intrinsics[:, 0, 0]
+    fy = intrinsics[:, 1, 1]
+    cx = intrinsics[:, 0, 2]
+    cy = intrinsics[:, 1, 2]
+    sk = intrinsics[:, 0, 1]
+
+    x_lift = (x - cx.unsqueeze(-1) + cy.unsqueeze(-1)*sk.unsqueeze(-1)/fy.unsqueeze(-1) - sk.unsqueeze(-1)*y/fy.unsqueeze(-1)) / fx.unsqueeze(-1) * z
+    y_lift = (y - cy.unsqueeze(-1)) / fy.unsqueeze(-1) * z
+
+    # homogeneous
+    return torch.stack((x_lift, y_lift, z, torch.ones_like(z).cuda()), dim=-1)
+
+
+def quat_to_rot(q):
+    batch_size, _ = q.shape
+    q = F.normalize(q, dim=1)
+    R = torch.ones((batch_size, 3,3)).cuda()
+    qr=q[:,0]
+    qi = q[:, 1]
+    qj = q[:, 2]
+    qk = q[:, 3]
+    R[:, 0, 0]=1-2 * (qj**2 + qk**2)
+    R[:, 0, 1] = 2 * (qj *qi -qk*qr)
+    R[:, 0, 2] = 2 * (qi * qk + qr * qj)
+    R[:, 1, 0] = 2 * (qj * qi + qk * qr)
+    R[:, 1, 1] = 1-2 * (qi**2 + qk**2)
+    R[:, 1, 2] = 2*(qj*qk - qi*qr)
+    R[:, 2, 0] = 2 * (qk * qi-qj * qr)
+    R[:, 2, 1] = 2 * (qj*qk + qi*qr)
+    R[:, 2, 2] = 1-2 * (qi**2 + qj**2)
+    return R
+
+
+def rot_to_quat(R):
+    batch_size, _,_ = R.shape
+    q = torch.ones((batch_size, 4)).cuda()
+
+    R00 = R[:, 0,0]
+    R01 = R[:, 0, 1]
+    R02 = R[:, 0, 2]
+    R10 = R[:, 1, 0]
+    R11 = R[:, 1, 1]
+    R12 = R[:, 1, 2]
+    R20 = R[:, 2, 0]
+    R21 = R[:, 2, 1]
+    R22 = R[:, 2, 2]
+
+    q[:,0]=torch.sqrt(1.0+R00+R11+R22)/2
+    q[:, 1]=(R21-R12)/(4*q[:,0])
+    q[:, 2] = (R02 - R20) / (4 * q[:, 0])
+    q[:, 3] = (R10 - R01) / (4 * q[:, 0])
+    return q
+
+
+def get_sphere_intersections(cam_loc, ray_directions, r = 1.0):
+    # Input: n_rays x 3 ; n_rays x 3
+    # Output: n_rays x 1, n_rays x 1 (close and far)
+
+    ray_cam_dot = torch.bmm(ray_directions.view(-1, 1, 3),
+                            cam_loc.view(-1, 3, 1)).squeeze(-1)
+    under_sqrt = ray_cam_dot ** 2 - (cam_loc.norm(2, 1, keepdim=True) ** 2 - r ** 2)
+
+    # sanity check
+    if (under_sqrt <= 0).sum() > 0:
+        print('BOUNDING SPHERE PROBLEM!')
+        exit()
+
+    sphere_intersections = torch.sqrt(under_sqrt) * torch.Tensor([-1, 1]).cuda().float() - ray_cam_dot
+    sphere_intersections = sphere_intersections.clamp_min(0.0)
+
+    return sphere_intersections