Repository: florinshen/FlashSplat Branch: master Commit: 3e3b14786333 Files: 67 Total size: 775.7 KB Directory structure: gitextract_alyweq7y/ ├── .gitignore ├── .gitmodules ├── LICENSE.md ├── arguments/ │ └── __init__.py ├── colormask.py ├── convert.py ├── edit_object_inpaint.py ├── find_points.ipynb ├── full360_render.py ├── full_eval.py ├── gaussian_renderer/ │ ├── __init__.py │ └── network_gui.py ├── generate_mask.py ├── lpipsPyTorch/ │ ├── __init__.py │ └── modules/ │ ├── lpips.py │ ├── networks.py │ └── utils.py ├── metrics.py ├── objremoval.py ├── readme.md ├── render.py ├── scene/ │ ├── __init__.py │ ├── cameras.py │ ├── colmap_loader.py │ ├── dataset_readers.py │ └── gaussian_model.py ├── scripts/ │ ├── bear_color.sh │ ├── bear_inpaint.sh │ ├── bear_removal.sh │ ├── bear_seg.sh │ ├── counter_color.sh │ ├── counter_remove.sh │ ├── counter_seg.sh │ ├── figurines_color.sh │ ├── figurines_remove.sh │ ├── figurines_seg.sh │ ├── figurines_train.sh │ ├── garden_train.sh │ ├── genmask_truck.sh │ ├── horns_remove.sh │ ├── horns_seg.sh │ ├── kitchen_color.sh │ ├── kitchen_inpaint.sh │ ├── kitchen_seg.sh │ ├── kitchen_train.sh │ ├── lego_train.sh │ ├── llff/ │ │ └── fern_train.sh │ ├── ramen_train.sh │ ├── teatime_color.sh │ ├── teatime_removal.sh │ ├── teatime_seg.sh │ ├── teatime_train.sh │ ├── test_teatime.sh │ ├── train_train.sh │ ├── truck_color.sh │ ├── truck_removal.sh │ ├── truck_seg.sh │ ├── truck_train.sh │ └── waldo_train.sh ├── train.py └── utils/ ├── camera_utils.py ├── general_utils.py ├── graphics_utils.py ├── image_utils.py ├── loss_utils.py ├── sh_utils.py └── system_utils.py ================================================ FILE CONTENTS ================================================ ================================================ FILE: .gitignore ================================================ *.pyc .vscode output build diff_rasterization/diff_rast.egg-info diff_rasterization/dist tensorboard_3d screenshots *.egg-info */build/* ================================================ FILE: .gitmodules ================================================ [submodule "submodules/simple-knn"] path = submodules/simple-knn url = https://gitlab.inria.fr/bkerbl/simple-knn.git [submodule "submodules/diff-gaussian-rasterization"] path = submodules/diff-gaussian-rasterization url = https://github.com/ashawkey/diff-gaussian-rasterization.git [submodule "submodules/flashsplat-rasterization"] path = submodules/flashsplat-rasterization url = https://github.com/florinshen/flashsplat-rasterization.git ================================================ FILE: LICENSE.md ================================================ 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*. ================================================ FILE: arguments/__init__.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # from argparse import ArgumentParser, Namespace import sys import os class GroupParams: pass class ParamGroup: def __init__(self, parser: ArgumentParser, name : str, fill_none = False): group = parser.add_argument_group(name) for key, value in vars(self).items(): shorthand = False if key.startswith("_"): shorthand = True key = key[1:] t = type(value) value = value if not fill_none else None if shorthand: if t == bool: group.add_argument("--" + key, ("-" + key[0:1]), default=value, action="store_true") else: group.add_argument("--" + key, ("-" + key[0:1]), default=value, type=t) else: if t == bool: group.add_argument("--" + key, default=value, action="store_true") else: group.add_argument("--" + key, default=value, type=t) def extract(self, args): group = GroupParams() for arg in vars(args).items(): if arg[0] in vars(self) or ("_" + arg[0]) in vars(self): setattr(group, arg[0], arg[1]) return group class ModelParams(ParamGroup): def __init__(self, parser, sentinel=False): self.sh_degree = 3 self._source_path = "" self._model_path = "" self._images = "images" self._resolution = -1 self._white_background = False self.data_device = "cuda" self.eval = False self._object_path = "object_mask" super().__init__(parser, "Loading Parameters", sentinel) def extract(self, args): g = super().extract(args) g.source_path = os.path.abspath(g.source_path) return g class PipelineParams(ParamGroup): def __init__(self, parser): self.convert_SHs_python = False self.compute_cov3D_python = False self.debug = False super().__init__(parser, "Pipeline Parameters") class OptimizationParams(ParamGroup): def __init__(self, parser): self.iterations = 30_000 self.position_lr_init = 0.00016 self.position_lr_final = 0.0000016 self.position_lr_delay_mult = 0.01 self.position_lr_max_steps = 30_000 self.feature_lr = 0.0025 self.opacity_lr = 0.05 self.scaling_lr = 0.005 self.rotation_lr = 0.001 self.percent_dense = 0.01 self.lambda_dssim = 0.2 self.densification_interval = 100 self.opacity_reset_interval = 3000 self.densify_from_iter = 500 self.densify_until_iter = 15_000 self.densify_grad_threshold = 0.0002 self.limit_num = -1 super().__init__(parser, "Optimization Parameters") def get_combined_args(parser : ArgumentParser): cmdlne_string = sys.argv[1:] cfgfile_string = "Namespace()" args_cmdline = parser.parse_args(cmdlne_string) try: cfgfilepath = os.path.join(args_cmdline.model_path, "cfg_args") print("Looking for config file in", cfgfilepath) with open(cfgfilepath) as cfg_file: print("Config file found: {}".format(cfgfilepath)) cfgfile_string = cfg_file.read() except TypeError: print("Config file not found at") pass args_cfgfile = eval(cfgfile_string) merged_dict = vars(args_cfgfile).copy() for k,v in vars(args_cmdline).items(): if v != None: merged_dict[k] = v return Namespace(**merged_dict) ================================================ FILE: colormask.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import torch from scene import Scene import os from os import path as osp from tqdm import tqdm from os import makedirs # import imageio import cv2 from gaussian_renderer import render from gaussian_renderer import flashsplat_render import torchvision from utils.general_utils import safe_state from argparse import ArgumentParser from arguments import ModelParams, PipelineParams, get_combined_args from gaussian_renderer import GaussianModel from PIL import Image import numpy as np import colorsys import pdb import torch import torch.nn.functional as F def mean_neighborhood(input_img, N): pad = (N - 1) // 2 padded_img = F.pad(input_img, (pad, pad, pad, pad), mode='constant', value=0) patches = padded_img.unfold(1, N, 1).unfold(2, N, 1) mean_patches = patches.mean(dim=-1).mean(dim=-1) return mean_patches def save_mp4(dir, fps): imgpath = dir frames = [] fourcc = cv2.VideoWriter.fourcc(*'mp4v') fps = float(fps) for name in sorted(os.listdir(imgpath)): img = osp.join(imgpath, name) img = cv2.imread(img) frames.append(img) height, width = frames[0].shape[:2] writer = cv2.VideoWriter(os.path.join(dir,'eval.mp4'), fourcc, fps, (width, height)) for frame in frames: writer.write(frame) writer.release() # def multi_instance_opt(all_counts, slackness=0.): # all_counts = torch.nn.functional.normalize(all_counts, dim=0) # all_counts_sum = all_counts.sum(dim=0) # all_obj_labels = torch.zeros_like(all_counts) # obj_num = all_counts.size(0) # for obj_idx, obj_counts in enumerate(tqdm(all_counts, desc="multi-view optimize")): # if obj_counts.sum().item() == 0: # continue # # other_idx = list(range(obj_idx)) + list(range(obj_idx + 1, obj_num)) # # other_counts = all_counts[other_idx, :].sum(dim=0) # # obj_counts = torch.stack([other_counts, obj_counts], dim=0) # # dynamic programming # obj_counts = torch.stack([all_counts_sum - obj_counts, obj_counts], dim=0) # if slackness != 0: # obj_counts = torch.nn.functional.normalize(obj_counts, dim=0) # obj_counts[0, :] += slackness # obj_label = obj_counts.max(dim=0)[1] # all_obj_labels[obj_idx] = obj_label # return all_obj_labels import torch.nn.functional as F def multi_instance_opt(all_contrib, gamma=0.): """ Input: all_contrib: A_{e} with shape (obj_num, gs_num) gamma: softening factor range from [-1, 1] Output: all_obj_labels: results S with shape (obj_num, gs_num) where S_{i,j} denotes j-th gaussian belong i-th object """ all_contrib_sum = all_contrib.sum(dim=0) all_obj_labels = torch.zeros_like(all_contrib).bool() for obj_idx, obj_contrib in enumerate(all_contrib, desc="multi-view optimize"): obj_contrib = torch.stack([all_contrib_sum - obj_contrib, obj_contrib], dim=0) obj_contrib = F.normalize(obj_contrib, dim=0) obj_contrib[0, :] += gamma obj_label = torch.argmax(obj_contrib, dim=0) all_obj_labels[obj_idx] = obj_label return all_obj_labels def id2rgb(id, max_num_obj=256): if not 0 <= id <= max_num_obj: raise ValueError("ID should be in range(0, max_num_obj)") # Convert the ID into a hue value golden_ratio = 1.6180339887 h = ((id * golden_ratio) % 1) # Ensure value is between 0 and 1 s = 0.5 + (id % 2) * 0.5 # Alternate between 0.5 and 1.0 l = 0.5 # Use colorsys to convert HSL to RGB rgb = np.zeros((3, ), dtype=np.uint8) if id==0: #invalid region return rgb r, g, b = colorsys.hls_to_rgb(h, l, s) rgb[0], rgb[1], rgb[2] = int(r*255), int(g*255), int(b*255) return rgb # for visualize color mask def visualize_obj(objects): rgb_mask = np.zeros((*objects.shape[-2:], 3), dtype=np.uint8) all_obj_ids = np.unique(objects) for id in all_obj_ids: colored_mask = id2rgb(id) rgb_mask[objects == id] = colored_mask return rgb_mask def render_set(model_path, name, iteration, views, gaussians, pipeline, background, slackness=0, view_num=-1, obj_num=256, obj_id=-1): render_path = os.path.join(model_path, name, "ours_{}".format(iteration), "renders") gts_path = os.path.join(model_path, name, "ours_{}".format(iteration), "gt") makedirs(render_path, exist_ok=True) makedirs(gts_path, exist_ok=True) if view_num > 0: view_idx = np.linspace(0, len(views) - 1, view_num, dtype=int).tolist() views_used = [views[idx] for idx in view_idx] else: view_num = len(views) views_used = views all_counts = None stats_counts_path = os.path.join(model_path, name, "ours_{}".format(iteration), "used_count") makedirs(stats_counts_path, exist_ok=True) cur_count_dir = os.path.join(stats_counts_path, "view_num_{:03d}_objnum_{:03d}.pth".format(view_num, obj_num)) if os.path.exists(cur_count_dir): print(f"find {cur_count_dir}") all_counts = torch.load(cur_count_dir).cuda() else: for idx, view in enumerate(tqdm(views_used, desc="Rendering progress")): if obj_num == 1: gt_mask = view.objects.to(torch.float32) / 255. else: gt_mask = view.objects.to(torch.float32) assert torch.any(torch.max(gt_mask) < obj_num), f"max_obj {int(torch.max(gt_mask).item())}" # set(tuple(gt_mask.cpu().tolist())[0]) render_pkg = flashsplat_render(view, gaussians, pipeline, background, gt_mask=gt_mask, obj_num=obj_num) rendering = render_pkg["render"] used_count = render_pkg["used_count"] if all_counts is None: all_counts = torch.zeros_like(used_count) gt = view.original_image[0:3, :, :] torchvision.utils.save_image(rendering, os.path.join(render_path, '{0:05d}'.format(idx) + ".png")) torchvision.utils.save_image(gt, os.path.join(gts_path, '{0:05d}'.format(idx) + ".png")) all_counts += used_count save_mp4(render_path, 15) torch.save(all_counts, cur_count_dir) if all_counts is not None: # pdb.set_trace() # cup_counts = all_counts[39:40, :] # all_counts = torch.cat([all_counts.sum(dim=0, keepdim=True) - cup_counts, cup_counts], dim=0) all_obj_labels = multi_instance_opt(all_counts, slackness) render_num = all_counts.size(0) # view_interval = (len(views) // view_num + 1) # views = views[::view_interval] # _view_num = 10 # view_idx = np.linspace(0, len(views) - 1, _view_num, dtype=int).tolist() # views_used = [views[idx] for idx in view_idx] # another option, render as color mask color_mask_path = os.path.join(model_path, name, "ours_{}".format(iteration), "color_mask") makedirs(color_mask_path, exist_ok=True) for idx, view in enumerate(tqdm(views, desc="Rendering color mask")): pred_mask = None max_alpha = None min_depth = None for obj_idx in range(render_num): obj_used_mask = (all_obj_labels[obj_idx]).bool() if obj_used_mask.sum().item() == 0: continue render_pkg = flashsplat_render(view, gaussians, pipeline, background, used_mask=obj_used_mask) render_alpha = render_pkg["alpha"] render_depth = render_pkg["depth"] if pred_mask is None: pred_mask = torch.zeros_like(render_alpha) max_alpha = torch.zeros_like(render_alpha) min_depth = torch.ones_like(render_alpha) # pix_mask = (render_alpha > max_alpha) # pred_mask[pix_mask] = obj_idx _pix_mask = (render_alpha > 0.5) pix_mask = _pix_mask.clone() overlap_mask = (_pix_mask & (pred_mask > 0)) # shape (1, h, w) if overlap_mask.sum().item() > 0: # may use more accurate ctrl here, 3dgs depth acc is limited, deprecated. # if min_depth[overlap_mask].mean() < render_depth[overlap_mask].mean(): # tmp = (min_depth[overlap_mask] < render_depth[overlap_mask]) # pix_mask[overlap_mask] = ~tmp # set pixel already has label as False, # if min_depth[overlap_mask].mean() < render_depth[overlap_mask].mean(): if (min_depth[overlap_mask].mean() < render_depth[overlap_mask].mean()): # if render_alpha[overlap_mask].mean() > max_alpha[overlap_mask].mean(): pix_mask[_pix_mask] = (~(pred_mask[_pix_mask] > 0)) # set pixel already has label as False, # pix_mask[overlap_mask] = False pred_mask[pix_mask] = obj_idx # record current depth and alpha min_depth[pix_mask] = render_depth[pix_mask] max_alpha[pix_mask] = render_alpha[pix_mask] # color_mask = visualize_obj(pred_mask[0].cpu().numpy().astype(np.uint8)) vis_mask = pred_mask.repeat(3, 1, 1) gt = view.original_image[0:3, :, :] gt_mask = vis_mask dummy_gt_mask = torch.zeros_like(gt) dummy_gt_mask[0] = 1. gt[gt_mask.bool()] = 0.7 * gt[gt_mask.bool()] + 0.3 * dummy_gt_mask[gt_mask.bool()] torchvision.utils.save_image(gt, os.path.join(color_mask_path, '{0:05d}'.format(idx) + ".png")) # pdb.set_trace() # Image.fromarray(color_mask).save(os.path.join(color_mask_path, '{0:05d}'.format(idx) + ".png")) def render_sets(dataset : ModelParams, iteration : int, pipeline : PipelineParams, skip_train : bool, skip_test : bool, slackness : float, view_num : int, obj_num : int, obj_id: int): with torch.no_grad(): gaussians = GaussianModel(dataset.sh_degree) scene = Scene(dataset, gaussians, load_iteration=iteration, shuffle=False) bg_color = [1,1,1] if dataset.white_background else [0, 0, 0] background = torch.tensor(bg_color, dtype=torch.float32, device="cuda") if not skip_train: render_set(dataset.model_path, "train", scene.loaded_iter, scene.getTrainCameras(), gaussians, pipeline, background, slackness, view_num, obj_num, obj_id) if not skip_test: render_set(dataset.model_path, "test", scene.loaded_iter, scene.getTestCameras(), gaussians, pipeline, background, slackness, view_num, obj_num, obj_id) if __name__ == "__main__": # Set up command line argument parser parser = ArgumentParser(description="Testing script parameters") model = ModelParams(parser, sentinel=True) pipeline = PipelineParams(parser) parser.add_argument("--iteration", default=-1, type=int) parser.add_argument("--skip_train", action="store_true") parser.add_argument("--skip_test", action="store_true") parser.add_argument("--quiet", action="store_true") parser.add_argument("--slackness", default=0.0, type=float) parser.add_argument("--view_num", default=10.0, type=int) parser.add_argument("--obj_num", default=1, type=int) parser.add_argument("--obj_id", default=-1, type=int) # parser.add_argument("--object_path", default="inpaint_object_mask_255", type=str) args = get_combined_args(parser) print("Rendering " + args.model_path) # Initialize system state (RNG) safe_state(args.quiet) # args.object_path = args.object_mask render_sets(model.extract(args), args.iteration, pipeline.extract(args), args.skip_train, args.skip_test, args.slackness, args.view_num, args.obj_num, args.obj_id) ================================================ FILE: convert.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import os import logging from argparse import ArgumentParser import shutil # This Python script is based on the shell converter script provided in the MipNerF 360 repository. parser = ArgumentParser("Colmap converter") parser.add_argument("--no_gpu", action='store_true') parser.add_argument("--skip_matching", action='store_true') parser.add_argument("--source_path", "-s", required=True, type=str) parser.add_argument("--camera", default="OPENCV", type=str) parser.add_argument("--colmap_executable", default="", type=str) parser.add_argument("--resize", action="store_true") parser.add_argument("--magick_executable", default="", type=str) args = parser.parse_args() colmap_command = '"{}"'.format(args.colmap_executable) if len(args.colmap_executable) > 0 else "colmap" magick_command = '"{}"'.format(args.magick_executable) if len(args.magick_executable) > 0 else "magick" use_gpu = 1 if not args.no_gpu else 0 if not args.skip_matching: os.makedirs(args.source_path + "/distorted/sparse", exist_ok=True) ## Feature extraction feat_extracton_cmd = colmap_command + " feature_extractor "\ "--database_path " + args.source_path + "/distorted/database.db \ --image_path " + args.source_path + "/input \ --ImageReader.single_camera 1 \ --ImageReader.camera_model " + args.camera + " \ --SiftExtraction.use_gpu " + str(use_gpu) exit_code = os.system(feat_extracton_cmd) if exit_code != 0: logging.error(f"Feature extraction failed with code {exit_code}. Exiting.") exit(exit_code) ## Feature matching feat_matching_cmd = colmap_command + " exhaustive_matcher \ --database_path " + args.source_path + "/distorted/database.db \ --SiftMatching.use_gpu " + str(use_gpu) exit_code = os.system(feat_matching_cmd) if exit_code != 0: logging.error(f"Feature matching failed with code {exit_code}. Exiting.") exit(exit_code) ### Bundle adjustment # The default Mapper tolerance is unnecessarily large, # decreasing it speeds up bundle adjustment steps. mapper_cmd = (colmap_command + " mapper \ --database_path " + args.source_path + "/distorted/database.db \ --image_path " + args.source_path + "/input \ --output_path " + args.source_path + "/distorted/sparse \ --Mapper.ba_global_function_tolerance=0.000001") exit_code = os.system(mapper_cmd) if exit_code != 0: logging.error(f"Mapper failed with code {exit_code}. Exiting.") exit(exit_code) ### Image undistortion ## We need to undistort our images into ideal pinhole intrinsics. img_undist_cmd = (colmap_command + " image_undistorter \ --image_path " + args.source_path + "/input \ --input_path " + args.source_path + "/distorted/sparse/0 \ --output_path " + args.source_path + "\ --output_type COLMAP") exit_code = os.system(img_undist_cmd) if exit_code != 0: logging.error(f"Mapper failed with code {exit_code}. Exiting.") exit(exit_code) files = os.listdir(args.source_path + "/sparse") os.makedirs(args.source_path + "/sparse/0", exist_ok=True) # Copy each file from the source directory to the destination directory for file in files: if file == '0': continue source_file = os.path.join(args.source_path, "sparse", file) destination_file = os.path.join(args.source_path, "sparse", "0", file) shutil.move(source_file, destination_file) if(args.resize): print("Copying and resizing...") # Resize images. os.makedirs(args.source_path + "/images_2", exist_ok=True) os.makedirs(args.source_path + "/images_4", exist_ok=True) os.makedirs(args.source_path + "/images_8", exist_ok=True) # Get the list of files in the source directory files = os.listdir(args.source_path + "/images") # Copy each file from the source directory to the destination directory for file in files: source_file = os.path.join(args.source_path, "images", file) destination_file = os.path.join(args.source_path, "images_2", file) shutil.copy2(source_file, destination_file) exit_code = os.system(magick_command + " mogrify -resize 50% " + destination_file) if exit_code != 0: logging.error(f"50% resize failed with code {exit_code}. Exiting.") exit(exit_code) destination_file = os.path.join(args.source_path, "images_4", file) shutil.copy2(source_file, destination_file) exit_code = os.system(magick_command + " mogrify -resize 25% " + destination_file) if exit_code != 0: logging.error(f"25% resize failed with code {exit_code}. Exiting.") exit(exit_code) destination_file = os.path.join(args.source_path, "images_8", file) shutil.copy2(source_file, destination_file) exit_code = os.system(magick_command + " mogrify -resize 12.5% " + destination_file) if exit_code != 0: logging.error(f"12.5% resize failed with code {exit_code}. Exiting.") exit(exit_code) print("Done.") ================================================ FILE: edit_object_inpaint.py ================================================ # Copyright (C) 2023, Gaussian-Grouping # Gaussian-Grouping research group, https://github.com/lkeab/gaussian-grouping # All rights reserved. # # ------------------------------------------------------------------------ # Modified from codes in Gaussian-Splatting # GRAPHDECO research group, https://team.inria.fr/graphdeco import torch from scene import Scene import os from tqdm import tqdm from os import makedirs from gaussian_renderer import render import torchvision from utils.general_utils import safe_state from argparse import ArgumentParser from arguments import ModelParams, PipelineParams, OptimizationParams, get_combined_args from gaussian_renderer import GaussianModel import numpy as np from PIL import Image import cv2 from utils.loss_utils import masked_l1_loss from random import randint import lpips import json import pdb def mask_to_bbox(mask): # Find the rows and columns where the mask is non-zero rows = torch.any(mask, dim=1) cols = torch.any(mask, dim=0) ymin, ymax = torch.where(rows)[0][[0, -1]] xmin, xmax = torch.where(cols)[0][[0, -1]] return xmin, ymin, xmax, ymax def crop_using_bbox(image, bbox): xmin, ymin, xmax, ymax = bbox return image[:, ymin:ymax+1, xmin:xmax+1] # Function to divide image into K x K patches def divide_into_patches(image, K): B, C, H, W = image.shape patch_h, patch_w = H // K, W // K patches = torch.nn.functional.unfold(image, (patch_h, patch_w), stride=(patch_h, patch_w)) patches = patches.view(B, C, patch_h, patch_w, -1) return patches.permute(0, 4, 1, 2, 3) def finetune_inpaint(opt, model_path, iteration, views, gaussians, pipeline, background, selected_obj_ids, cameras_extent, finetune_iteration, view_num, obj_num): stats_counts_path = os.path.join(model_path, 'train', "ours_{}".format(iteration), "used_count") makedirs(stats_counts_path, exist_ok=True) if view_num < 0: view_num = len(views) cur_count_dir = os.path.join(stats_counts_path, "view_num_{:03d}_objnum_{:03d}.pth".format(view_num, obj_num)) from render import multi_instance_opt all_counts = torch.load(cur_count_dir).cuda() all_obj_labels = multi_instance_opt(all_counts, -0.4) mask3d = (all_obj_labels[selected_obj_ids].bool()) # remained gs, as true # pdb.set_trace() # fix some gaussians gaussians.inpaint_setup(opt, mask3d) print() iterations = finetune_iteration progress_bar = tqdm(range(iterations), desc="Finetuning progress") LPIPS = lpips.LPIPS(net='vgg') for param in LPIPS.parameters(): param.requires_grad = False LPIPS.cuda() for iteration in range(iterations): viewpoint_stack = views.copy() viewpoint_cam = viewpoint_stack.pop(randint(0, len(viewpoint_stack)-1)) render_pkg = render(viewpoint_cam, gaussians, pipeline, background) image, viewspace_point_tensor, visibility_filter, radii = render_pkg["render"], render_pkg["viewspace_points"], render_pkg["visibility_filter"], render_pkg["radii"] mask2d = viewpoint_cam.objects > 128 gt_image = viewpoint_cam.original_image.cuda() Ll1 = masked_l1_loss(image, gt_image, ~mask2d) bbox = mask_to_bbox(mask2d) cropped_image = crop_using_bbox(image, bbox) cropped_gt_image = crop_using_bbox(gt_image, bbox) K = 2 rendering_patches = divide_into_patches(cropped_image[None, ...], K) gt_patches = divide_into_patches(cropped_gt_image[None, ...], K) lpips_loss = LPIPS(rendering_patches.squeeze()*2-1,gt_patches.squeeze()*2-1).mean() loss = (1.0 - opt.lambda_dssim) * Ll1 + opt.lambda_dssim * lpips_loss loss.backward() with torch.no_grad(): if iteration < 5000 : # Keep track of max radii in image-space for pruning gaussians.max_radii2D[visibility_filter] = torch.max(gaussians.max_radii2D[visibility_filter], radii[visibility_filter]) gaussians.add_densification_stats(viewspace_point_tensor, visibility_filter) if iteration % 300 == 0: size_threshold = 20 gaussians.densify_and_prune(opt.densify_grad_threshold, 0.005, cameras_extent, size_threshold) gaussians.optimizer.step() gaussians.optimizer.zero_grad(set_to_none = True) if iteration % 10 == 0: progress_bar.set_postfix({"Loss": f"{loss:.{7}f}"}) progress_bar.update(10) progress_bar.close() # save gaussians point_cloud_path = os.path.join(model_path, "point_cloud_object_inpaint/iteration_{}".format(iteration)) gaussians.save_ply(os.path.join(point_cloud_path, "point_cloud.ply")) return gaussians def render_set(model_path, name, iteration, views, gaussians, pipeline, background): render_path = os.path.join(model_path, name, "ours{}".format(iteration), "renders") gts_path = os.path.join(model_path, name, "ours{}".format(iteration), "gt") colormask_path = os.path.join(model_path, name, "ours{}".format(iteration), "objects_feature16") gt_colormask_path = os.path.join(model_path, name, "ours{}".format(iteration), "gt_objects_color") pred_obj_path = os.path.join(model_path, name, "ours{}".format(iteration), "objects_pred") makedirs(render_path, exist_ok=True) makedirs(gts_path, exist_ok=True) makedirs(colormask_path, exist_ok=True) makedirs(gt_colormask_path, exist_ok=True) makedirs(pred_obj_path, exist_ok=True) for idx, view in enumerate(tqdm(views, desc="Rendering progress")): results = render(view, gaussians, pipeline, background) rendering = results["render"] gt = view.original_image[0:3, :, :] torchvision.utils.save_image(rendering, os.path.join(render_path, '{0:05d}'.format(idx) + ".png")) torchvision.utils.save_image(gt, os.path.join(gts_path, '{0:05d}'.format(idx) + ".png")) from render import save_mp4 save_mp4(render_path, 15) def inpaint(dataset : ModelParams, iteration : int, pipeline : PipelineParams, skip_train : bool, skip_test : bool, opt : OptimizationParams, select_obj_id : int, finetune_iteration: int, view_num : int, obj_num : int): # 1. load gaussian checkpoint gaussians = GaussianModel(dataset.sh_degree) # scene = Scene(dataset, gaussians, load_iteration=iteration, shuffle=False) bg_color = [1,1,1] if dataset.white_background else [0, 0, 0] background = torch.tensor(bg_color, dtype=torch.float32, device="cuda") # # # 2. inpaint selected object # gaussians = finetune_inpaint(opt, dataset.model_path, scene.loaded_iter, scene.getTrainCameras(), gaussians, pipeline, background, select_obj_id, scene.cameras_extent, finetune_iteration, # view_num, obj_num) # 3. render new result dataset.object_path = 'object_mask' dataset.images = 'images' scene = Scene(dataset, gaussians, load_iteration='_object_inpaint/iteration_'+str(finetune_iteration-1), shuffle=False) with torch.no_grad(): if not skip_train: render_set(dataset.model_path, "train", scene.loaded_iter, scene.getTrainCameras(), gaussians, pipeline, background) if not skip_test: render_set(dataset.model_path, "test", scene.loaded_iter, scene.getTestCameras(), gaussians, pipeline, background) if __name__ == "__main__": # Set up command line argument parser parser = ArgumentParser(description="Testing script parameters") model = ModelParams(parser, sentinel=True) opt = OptimizationParams(parser) pipeline = PipelineParams(parser) parser.add_argument("--iteration", default=-1, type=int) parser.add_argument("--skip_train", action="store_true") parser.add_argument("--skip_test", action="store_true") parser.add_argument("--quiet", action="store_true") parser.add_argument("--config_file", type=str, default="config/object_removal/bear.json", help="Path to the configuration file") parser.add_argument("--slackness", default=0.0, type=float) parser.add_argument("--view_num", default=10.0, type=int) parser.add_argument("--obj_num", default=1, type=int) parser.add_argument("--obj_id", default=-1, type=int) parser.add_argument("--finetune_iteration", default=10_000, type=int) args = get_combined_args(parser) print("Rendering " + args.model_path) # args.num_classes = config.get("num_classes", 200) # args.removal_thresh = config.get("removal_thresh", 0.3) # args.select_obj_id = config.get("select_obj_id", [34]) # args.images = config.get("images", "images") # args.object_path = config.get("object_path", "object_mask") # args.resolution = config.get("r", 1) # args.lambda_dssim = config.get("lambda_dlpips", 0.5) # args.finetune_iteration = config.get("finetune_iteration", 10_000) assert args.obj_id > 0 select_obj_id = args.obj_id # Initialize system state (RNG) safe_state(args.quiet) inpaint(model.extract(args), args.iteration, pipeline.extract(args), args.skip_train, args.skip_test, opt.extract(args), select_obj_id, args.finetune_iteration, args.view_num, args.obj_num) ================================================ FILE: find_points.ipynb ================================================ { "cells": [ { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import torch\n", "import matplotlib.pyplot as plt\n", "import cv2\n", "\n", "def show_points(coords, labels, ax, marker_size=375):\n", " pos_points = coords[labels==1]\n", " neg_points = coords[labels==0]\n", " ax.scatter(pos_points[:, 0], pos_points[:, 1], color='green', marker='*', s=marker_size, edgecolor='white', linewidth=1.25)\n", " ax.scatter(neg_points[:, 0], neg_points[:, 1], color='red', marker='*', s=marker_size, edgecolor='white', linewidth=1.25) \n", "\n", "# image_path = \"/home/shenqiuhong/Downloads/Gaussian-Grouping/data/lerf_mask/teatime/images/frame_00001.jpg\"\n", "\n", "# image_path = \"/home/shenqiuhong/Downloads/tandt/tandt/truck/images/000001.jpg\"\n", "# image_path = \"/home/shenqiuhong/Downloads/Gaussian-Grouping/data/mipnerf360/counter/images_2/DSCF5861.JPG\"\n", "image_path = \"/home/shenqiuhong/Downloads/llff-gs/horns/images_4/DJI_20200223_163016_842.png\"\n", "image = cv2.imread(image_path)\n", "image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Pixel position to visualize (x, y)\n", "plt.figure(figsize=(10,10))\n", "plt.imshow(image)\n", "# (500, 500)\n", "# for truck, (200, 280), (700, 300)\n", "input_point = np.array([[550, 500], [300, 300], [500, 200], [600, 300], [420, 250], [600, 240], [620, 600], [630, 420]])\n", "input_label = np.array([1] * input_point.shape[0])\n", "show_points(input_point, input_label, plt.gca())\n", "plt.axis('on')\n", "plt.show() " ] } ], "metadata": { "kernelspec": { "display_name": "pt12", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.13" }, "orig_nbformat": 4 }, "nbformat": 4, "nbformat_minor": 2 } ================================================ FILE: full360_render.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import torch from scene import Scene import os from os import path as osp import cv2 from tqdm import tqdm from os import makedirs from gaussian_renderer import render import torchvision from utils.general_utils import safe_state from argparse import ArgumentParser from arguments import ModelParams, PipelineParams, get_combined_args from gaussian_renderer import GaussianModel from scene.cameras import Camera import numpy as np import pdb def dot(x, y): if isinstance(x, np.ndarray): return np.sum(x * y, -1, keepdims=True) else: return torch.sum(x * y, -1, keepdim=True) def length(x, eps=1e-20): if isinstance(x, np.ndarray): return np.sqrt(np.maximum(np.sum(x * x, axis=-1, keepdims=True), eps)) else: return torch.sqrt(torch.clamp(dot(x, x), min=eps)) def safe_normalize(x, eps=1e-20): return x / length(x, eps) def look_at(campos, target): forward_vector = safe_normalize(campos - target) world_up = np.array([0, -1, 0], dtype=np.float32) # right_vector = safe_normalize(np.cross(up_vector, forward_vector)) right_vector = safe_normalize(np.cross(world_up, forward_vector)) up_vector = safe_normalize(np.cross(forward_vector, right_vector)) R = np.stack([right_vector, up_vector, forward_vector], axis=1) return R def pose_spherical(elevation, azimuth, radius=4.031, opengl=False): elevation = np.deg2rad(elevation) azimuth = np.deg2rad(azimuth) x = radius * np.cos(elevation) * np.cos(azimuth) y = -radius * np.sin(elevation) z = radius * np.cos(elevation) * np.sin(azimuth) campos = np.array([x, y, z]) c2w = np.eye(4, dtype=np.float32) target = np.zeros([3], dtype=np.float32) c2w[:3, :3] = look_at(campos, target) c2w[:3, 3] = campos # raw format of c2w in transform.json # change from OpenGL/Blender camera axes (Y up, Z back) to COLMAP (Y down, Z forward) # c2w[:3, 1:3] *= -1 w2c = np.linalg.inv(c2w) R = np.transpose(w2c[:3,:3]) # R is stored transposed due to 'glm' in CUDA code T = w2c[:3, 3] return R, T def save_mp4(dir, fps): imgpath = dir frames = [] fourcc = cv2.VideoWriter.fourcc(*'mp4v') fps = float(fps) for name in sorted(os.listdir(imgpath)): img = osp.join(imgpath, name) img = cv2.imread(img) frames.append(img) height, width = frames[0].shape[:2] writer = cv2.VideoWriter(os.path.join(dir,'eval.mp4'), fourcc, fps, (width, height)) for frame in frames: writer.write(frame) writer.release() def adjust_pose(view): R, T = view.R.copy(), view.T.copy() w2c = np.eye(4) w2c[:3, :3] = R w2c[:3, -1] = T c2w = np.linalg.inv(w2c) cam_T = c2w[:3, -1].copy() cam_R = c2w[:3, :3].copy() # cam_T[2] += 15 cam_T[1] += 15 c2w = np.eye(4) c2w[:3, :3] = cam_R c2w[:3, -1] = cam_T new_w2c = np.linalg.inv(c2w) new_R = new_w2c[:3, :3] new_T = new_w2c[:3, -1] view.R = new_R view.T = new_T pdb.set_trace() return view def render_set(model_path, name, iteration, views, gaussians, pipeline, background): render_path = os.path.join(model_path, 'webpage', name, "ours_{}".format(iteration), "renders") gts_path = os.path.join(model_path, 'webpage', name, "ours_{}".format(iteration), "gt") makedirs(render_path, exist_ok=True) makedirs(gts_path, exist_ok=True) positions = gaussians.get_xyz.mean(dim=0) render_poses = [pose_spherical(azimuth=angle, elevation=0., radius=15.0) for angle in np.linspace(-180,180,120+1)[:-1]] render_cams = [] background = torch.tensor([1, 1, 1], dtype=torch.float32, device="cuda") train_viewpoint = views.pop(0) # for idx, pose in enumerate(tqdm(render_poses, desc="Rendering progress")): # R, T = pose # cam = Camera(colmap_id=idx, R=R, T=T, # FoVx=train_viewpoint.FoVx, FoVy=train_viewpoint.FoVy, # image=train_viewpoint.original_image, gt_alpha_mask=None, gt_depth=None, # image_name="", uid=0, data_device=train_viewpoint.data_device) # rendering = render(cam, gaussians, pipeline, background)["render"] # torchvision.utils.save_image(rendering, os.path.join(render_path, '{0:05d}'.format(idx) + ".png")) for idx, view in enumerate(tqdm(views, desc="Rendering progress")): # R, T = pose # cam = Camera(colmap_id=idx, R=R, T=T, # FoVx=train_viewpoint.FoVx, FoVy=train_viewpoint.FoVy, # image=train_viewpoint.original_image, gt_alpha_mask=None, gt_depth=None, # image_name="", uid=0, data_device=train_viewpoint.data_device) view = adjust_pose(view) rendering = render(view, gaussians, pipeline, background)["render"] pdb.set_trace() torchvision.utils.save_image(rendering, os.path.join(render_path, '{0:05d}'.format(idx) + ".png")) save_mp4(render_path, 15) def render_sets(dataset : ModelParams, iteration : int, pipeline : PipelineParams, skip_train : bool, skip_test : bool): with torch.no_grad(): gaussians = GaussianModel(dataset.sh_degree) scene = Scene(dataset, gaussians, load_iteration=iteration, shuffle=False) bg_color = [1,1,1] if dataset.white_background else [0, 0, 0] background = torch.tensor(bg_color, dtype=torch.float32, device="cuda") if not skip_train: render_set(dataset.model_path, "train", scene.loaded_iter, scene.getTrainCameras(), gaussians, pipeline, background) if not skip_test: render_set(dataset.model_path, "test", scene.loaded_iter, scene.getTestCameras(), gaussians, pipeline, background) if __name__ == "__main__": # Set up command line argument parser parser = ArgumentParser(description="Testing script parameters") model = ModelParams(parser, sentinel=True) pipeline = PipelineParams(parser) parser.add_argument("--iteration", default=-1, type=int) parser.add_argument("--skip_train", action="store_true") parser.add_argument("--skip_test", action="store_true") parser.add_argument("--quiet", action="store_true") args = get_combined_args(parser) print("Rendering " + args.model_path) # Initialize system state (RNG) safe_state(args.quiet) render_sets(model.extract(args), args.iteration, pipeline.extract(args), args.skip_train, args.skip_test) ================================================ FILE: full_eval.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import os from argparse import ArgumentParser mipnerf360_outdoor_scenes = ["bicycle", "flowers", "garden", "stump", "treehill"] mipnerf360_indoor_scenes = ["room", "counter", "kitchen", "bonsai"] tanks_and_temples_scenes = ["truck", "train"] deep_blending_scenes = ["drjohnson", "playroom"] parser = ArgumentParser(description="Full evaluation script parameters") parser.add_argument("--skip_training", action="store_true") parser.add_argument("--skip_rendering", action="store_true") parser.add_argument("--skip_metrics", action="store_true") parser.add_argument("--output_path", default="./eval") args, _ = parser.parse_known_args() all_scenes = [] all_scenes.extend(mipnerf360_outdoor_scenes) all_scenes.extend(mipnerf360_indoor_scenes) all_scenes.extend(tanks_and_temples_scenes) all_scenes.extend(deep_blending_scenes) if not args.skip_training or not args.skip_rendering: parser.add_argument('--mipnerf360', "-m360", required=True, type=str) parser.add_argument("--tanksandtemples", "-tat", required=True, type=str) parser.add_argument("--deepblending", "-db", required=True, type=str) args = parser.parse_args() if not args.skip_training: common_args = " --quiet --eval --test_iterations -1 " for scene in mipnerf360_outdoor_scenes: source = args.mipnerf360 + "/" + scene os.system("python train.py -s " + source + " -i images_4 -m " + args.output_path + "/" + scene + common_args) for scene in mipnerf360_indoor_scenes: source = args.mipnerf360 + "/" + scene os.system("python train.py -s " + source + " -i images_2 -m " + args.output_path + "/" + scene + common_args) for scene in tanks_and_temples_scenes: source = args.tanksandtemples + "/" + scene os.system("python train.py -s " + source + " -m " + args.output_path + "/" + scene + common_args) for scene in deep_blending_scenes: source = args.deepblending + "/" + scene os.system("python train.py -s " + source + " -m " + args.output_path + "/" + scene + common_args) if not args.skip_rendering: all_sources = [] for scene in mipnerf360_outdoor_scenes: all_sources.append(args.mipnerf360 + "/" + scene) for scene in mipnerf360_indoor_scenes: all_sources.append(args.mipnerf360 + "/" + scene) for scene in tanks_and_temples_scenes: all_sources.append(args.tanksandtemples + "/" + scene) for scene in deep_blending_scenes: all_sources.append(args.deepblending + "/" + scene) common_args = " --quiet --eval --skip_train" for scene, source in zip(all_scenes, all_sources): os.system("python render.py --iteration 7000 -s " + source + " -m " + args.output_path + "/" + scene + common_args) os.system("python render.py --iteration 30000 -s " + source + " -m " + args.output_path + "/" + scene + common_args) if not args.skip_metrics: scenes_string = "" for scene in all_scenes: scenes_string += "\"" + args.output_path + "/" + scene + "\" " os.system("python metrics.py -m " + scenes_string) ================================================ FILE: gaussian_renderer/__init__.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import torch import math from diff_gaussian_rasterization import GaussianRasterizationSettings, GaussianRasterizer from scene.gaussian_model import GaussianModel from utils.sh_utils import eval_sh from flashsplat_rasterization import GaussianRasterizationSettings as FlashSplat_GaussianRasterizationSettings from flashsplat_rasterization import GaussianRasterizer as FlashSplat_GaussianRasterizer import pdb def render(viewpoint_camera, pc : GaussianModel, pipe, bg_color : torch.Tensor, scaling_modifier = 1.0, override_color = None): """ Render the scene. Background tensor (bg_color) must be on GPU! """ # Create zero tensor. We will use it to make pytorch return gradients of the 2D (screen-space) means screenspace_points = torch.zeros_like(pc.get_xyz, dtype=pc.get_xyz.dtype, requires_grad=True, device="cuda") + 0 try: screenspace_points.retain_grad() except: pass # Set up rasterization configuration tanfovx = math.tan(viewpoint_camera.FoVx * 0.5) tanfovy = math.tan(viewpoint_camera.FoVy * 0.5) raster_settings = GaussianRasterizationSettings( image_height=int(viewpoint_camera.image_height), image_width=int(viewpoint_camera.image_width), tanfovx=tanfovx, tanfovy=tanfovy, bg=bg_color, scale_modifier=scaling_modifier, viewmatrix=viewpoint_camera.world_view_transform, projmatrix=viewpoint_camera.full_proj_transform, sh_degree=pc.active_sh_degree, campos=viewpoint_camera.camera_center, prefiltered=False, debug=pipe.debug ) rasterizer = GaussianRasterizer(raster_settings=raster_settings) means3D = pc.get_xyz means2D = screenspace_points opacity = pc.get_opacity # If precomputed 3d covariance is provided, use it. If not, then it will be computed from # scaling / rotation by the rasterizer. scales = None rotations = None cov3D_precomp = None if pipe.compute_cov3D_python: cov3D_precomp = pc.get_covariance(scaling_modifier) else: scales = pc.get_scaling rotations = pc.get_rotation # If precomputed colors are provided, use them. Otherwise, if it is desired to precompute colors # from SHs in Python, do it. If not, then SH -> RGB conversion will be done by rasterizer. shs = None colors_precomp = None if override_color is None: if pipe.convert_SHs_python: shs_view = pc.get_features.transpose(1, 2).view(-1, 3, (pc.max_sh_degree+1)**2) dir_pp = (pc.get_xyz - viewpoint_camera.camera_center.repeat(pc.get_features.shape[0], 1)) dir_pp_normalized = dir_pp/dir_pp.norm(dim=1, keepdim=True) sh2rgb = eval_sh(pc.active_sh_degree, shs_view, dir_pp_normalized) colors_precomp = torch.clamp_min(sh2rgb + 0.5, 0.0) else: shs = pc.get_features else: colors_precomp = override_color # Rasterize visible Gaussians to image, obtain their radii (on screen). rendered_image, radii = rasterizer( means3D = means3D, means2D = means2D, shs = shs, colors_precomp = colors_precomp, opacities = opacity, scales = scales, rotations = rotations, cov3D_precomp = cov3D_precomp) rendered_depth, rendered_alpha = None, None # Those Gaussians that were frustum culled or had a radius of 0 were not visible. # They will be excluded from value updates used in the splitting criteria. return {"render": rendered_image, "viewspace_points": screenspace_points, "visibility_filter" : radii > 0, "radii": radii, "alpha": rendered_alpha, "depth": rendered_depth} def flashsplat_render(viewpoint_camera, pc : GaussianModel, pipe, bg_color : torch.Tensor, scaling_modifier = 1.0, override_color = None, gt_mask = None, used_mask = None, unique_label = None, setpdb=False, obj_num = 2,): """ Render the scene. Background tensor (bg_color) must be on GPU! """ # Create zero tensor. We will use it to make pytorch return gradients of the 2D (screen-space) means screenspace_points = torch.zeros_like(pc.get_xyz, dtype=pc.get_xyz.dtype, requires_grad=True, device="cuda") + 0 try: screenspace_points.retain_grad() except: pass # if unique_label is not None: # pdb.set_trace() # Set up rasterization configuration tanfovx = math.tan(viewpoint_camera.FoVx * 0.5) tanfovy = math.tan(viewpoint_camera.FoVy * 0.5) raster_settings = FlashSplat_GaussianRasterizationSettings( image_height=int(viewpoint_camera.image_height), image_width=int(viewpoint_camera.image_width), tanfovx=tanfovx, tanfovy=tanfovy, bg=bg_color, scale_modifier=scaling_modifier, viewmatrix=viewpoint_camera.world_view_transform, projmatrix=viewpoint_camera.full_proj_transform, sh_degree=pc.active_sh_degree, campos=viewpoint_camera.camera_center, prefiltered=False, debug=pipe.debug, mask_grad=False, num_obj=obj_num, ) rasterizer = FlashSplat_GaussianRasterizer(raster_settings=raster_settings) means2D = screenspace_points means3D = pc.get_xyz opacity = pc.get_opacity if used_mask is not None: means3D = means3D[used_mask] opacity = opacity[used_mask] # If precomputed 3d covariance is provided, use it. If not, then it will be computed from # scaling / rotation by the rasterizer. scales = None rotations = None cov3D_precomp = None if pipe.compute_cov3D_python: cov3D_precomp = pc.get_covariance(scaling_modifier) else: scales = pc.get_scaling rotations = pc.get_rotation if used_mask is not None: scales = scales[used_mask] rotations = rotations[used_mask] # If precomputed colors are provided, use them. Otherwise, if it is desired to precompute colors # from SHs in Python, do it. If not, then SH -> RGB conversion will be done by rasterizer. shs = None colors_precomp = None if override_color is None: if pipe.convert_SHs_python: shs_view = pc.get_features.transpose(1, 2).view(-1, 3, (pc.max_sh_degree+1)**2) dir_pp = (pc.get_xyz - viewpoint_camera.camera_center.repeat(pc.get_features.shape[0], 1)) dir_pp_normalized = dir_pp/dir_pp.norm(dim=1, keepdim=True) sh2rgb = eval_sh(pc.active_sh_degree, shs_view, dir_pp_normalized) colors_precomp = torch.clamp_min(sh2rgb + 0.5, 0.0) else: # pdb.set_trace() shs = pc.get_features if used_mask is not None: shs = shs[used_mask] else: colors_precomp = override_color # Rasterize visible Gaussians to image, obtain their radii (on screen). if setpdb: pdb.set_trace() rendered_image, radii, depth, alpha, contrib_num, used_count, proj_xy, gs_depth = rasterizer( gt_mask = gt_mask, unique_label = unique_label, means3D = means3D, means2D = means2D, shs = shs, colors_precomp = colors_precomp, opacities = opacity, scales = scales, rotations = rotations, cov3D_precomp = cov3D_precomp) # Those Gaussians that were frustum culled or had a radius of 0 were not visible. # They will be excluded from value updates used in the splitting criteria. return {"render": rendered_image, "viewspace_points": screenspace_points, "visibility_filter" : radii > 0, "radii": radii, "alpha": alpha, "depth": depth, "contrib_num": contrib_num, "used_count": used_count, "proj_xy": proj_xy, "gs_depth": gs_depth} ================================================ FILE: gaussian_renderer/network_gui.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import torch import traceback import socket import json from scene.cameras import MiniCam host = "127.0.0.1" port = 6009 conn = None addr = None listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM) def init(wish_host, wish_port): global host, port, listener host = wish_host port = wish_port listener.bind((host, port)) listener.listen() listener.settimeout(0) def try_connect(): global conn, addr, listener try: conn, addr = listener.accept() print(f"\nConnected by {addr}") conn.settimeout(None) except Exception as inst: pass def read(): global conn messageLength = conn.recv(4) messageLength = int.from_bytes(messageLength, 'little') message = conn.recv(messageLength) return json.loads(message.decode("utf-8")) def send(message_bytes, verify): global conn if message_bytes != None: conn.sendall(message_bytes) conn.sendall(len(verify).to_bytes(4, 'little')) conn.sendall(bytes(verify, 'ascii')) def receive(): message = read() width = message["resolution_x"] height = message["resolution_y"] if width != 0 and height != 0: try: do_training = bool(message["train"]) fovy = message["fov_y"] fovx = message["fov_x"] znear = message["z_near"] zfar = message["z_far"] do_shs_python = bool(message["shs_python"]) do_rot_scale_python = bool(message["rot_scale_python"]) keep_alive = bool(message["keep_alive"]) scaling_modifier = message["scaling_modifier"] world_view_transform = torch.reshape(torch.tensor(message["view_matrix"]), (4, 4)).cuda() world_view_transform[:,1] = -world_view_transform[:,1] world_view_transform[:,2] = -world_view_transform[:,2] full_proj_transform = torch.reshape(torch.tensor(message["view_projection_matrix"]), (4, 4)).cuda() full_proj_transform[:,1] = -full_proj_transform[:,1] custom_cam = MiniCam(width, height, fovy, fovx, znear, zfar, world_view_transform, full_proj_transform) except Exception as e: print("") traceback.print_exc() raise e return custom_cam, do_training, do_shs_python, do_rot_scale_python, keep_alive, scaling_modifier else: return None, None, None, None, None, None ================================================ FILE: generate_mask.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import torch from scene import Scene import os from os import path as osp from tqdm import tqdm from os import makedirs # import imageio import cv2 from gaussian_renderer import render from gaussian_renderer import flashsplat_render import torchvision from utils.general_utils import safe_state from argparse import ArgumentParser from arguments import ModelParams, PipelineParams, get_combined_args from gaussian_renderer import GaussianModel from PIL import Image import numpy as np import colorsys import pdb import torch import torch.nn.functional as F from segment_anything import sam_model_registry, SamPredictor import cv2 def save_mp4(dir, fps): imgpath = dir frames = [] fourcc = cv2.VideoWriter.fourcc(*'mp4v') fps = float(fps) for name in sorted(os.listdir(imgpath)): img = osp.join(imgpath, name) img = cv2.imread(img) frames.append(img) height, width = frames[0].shape[:2] writer = cv2.VideoWriter(os.path.join(dir,'eval.mp4'), fourcc, fps, (width, height)) for frame in frames: writer.write(frame) writer.release() def render_set(model_path, name, iteration, views, gaussians, pipeline, background, slackness=0, view_num=-1, obj_num=256, obj_ids=[]): render_path = os.path.join(model_path, name, "ours_{}".format(iteration), "renders") gts_path = os.path.join(model_path, name, "ours_{}".format(iteration), "gt") sam_ckpt_path = "/home/shenqiuhong/Research/segment-anything/notebooks/checkpoint/sam_vit_h_4b8939.pth" sam_model = sam_model_registry['vit_h'](checkpoint=sam_ckpt_path).cuda() predictor = SamPredictor(sam_model) makedirs(render_path, exist_ok=True) makedirs(gts_path, exist_ok=True) if view_num > 0: view_idx = np.linspace(0, len(views) - 1, view_num, dtype=int).tolist() views_used = [views[idx] for idx in view_idx] else: view_num = len(views) views_used = views # _view_num = 10 # view_idx = np.linspace(0, len(views) - 1, _view_num, dtype=int).tolist() # views_used = [views[idx] for idx in view_idx] # pos_list = [(150, 150), (200, 200), (300, 350)] # pos_list = [(100, 300), (80, 180)] # the sheep # for the teatime # pos_list = [(100, 300), (80, 180), (150, 230), (140, 390), (100, 450)] # pos_labels = [1, 1, 1, 1, 1] pos_list = [[550, 500], [300, 300], [500, 200], [600, 300], [420, 250], [600, 240], [620, 600], [630, 420]] pos_labels = [1] * len(pos_list) def get_nearest_point(proj_xy, pos, gs_depth): cur_pos = torch.zeros_like(proj_xy) cur_pos[0, :], cur_pos[1, :] = pos[0], pos[1] distance = (((proj_xy - cur_pos)) ** 2).sum(dim=0) near_gsidx = distance.sort()[1][:100] gs_depth[gs_depth <= 0] = 1000. # set invalid depth as extra far. selected = gs_depth[near_gsidx].argmin() nearest_gsidx = near_gsidx[selected] return nearest_gsidx with torch.no_grad(): for idx, view in enumerate(tqdm(views_used, desc="Rendering removal")): render_pkg = flashsplat_render(view, gaussians, pipeline, background) proj_xy = render_pkg["proj_xy"] gs_depth = render_pkg["gs_depth"] # for a selected view nearest_gidx = [get_nearest_point(proj_xy, pos, gs_depth) for pos in pos_list] nearest_gidx = torch.stack(nearest_gidx) break remain_mask = torch.zeros(gaussians.get_xyz.shape[0], dtype=torch.bool, device=gaussians.get_xyz.device) remain_mask[nearest_gidx] = True obj_removal_path = os.path.join(model_path, name, "ours_{}".format(iteration), "test_xyz") os.makedirs(obj_removal_path, exist_ok=True) view_prompt_points = [] rec_idx = nearest_gidx.argsort() for idx, view in enumerate(tqdm(views_used, desc="find corresponding points")): render_pkg = flashsplat_render(view, gaussians, pipeline, background, used_mask=remain_mask) proj_xy = render_pkg["proj_xy"].permute(1, 0)[rec_idx, :] view_prompt_points.append(proj_xy) def check_bound(val, bound): if val <= 0 or val > bound: return True else: return False def check_prompts(input_point, input_label, height, width): _points = [] _labels = [] for point, label in zip(input_point, input_label): if check_bound(point[0], width) or check_bound(point[1], height): continue else: _points.append(point) _labels.append(label) return np.array(_points), np.array(_labels) mask_dir = "/home/shenqiuhong/Downloads/llff-gs/horns/inpaint_object_mask_255" makedirs(mask_dir, exist_ok=True) for idx, view in enumerate(tqdm(views_used, desc="SAM all views")): prompt_points = view_prompt_points[idx] gt_image = (view.original_image[0:3, :, :].detach() * 255).permute(1, 2, 0).cpu().numpy().astype(np.uint8) predictor.set_image(gt_image) input_point = prompt_points.cpu().numpy() input_label = np.array(pos_labels) input_point, input_label = check_prompts(input_point, input_label, view.image_height, view.image_width) if input_label.shape[0] > 0: masks, scores, logits = predictor.predict( point_coords=input_point, point_labels=input_label, multimask_output=True, ) mask = masks[np.argmax(scores)][:, :, None].astype(np.uint8) * 255 else: mask = np.zeros((view.image_height, view.image_width, 1)).astype(np.uint8) # view.image_name mask_path = os.path.join(mask_dir, '{}.png'.format(view.image_name)) cv2.imwrite(mask_path, mask) def render_sets(dataset : ModelParams, iteration : int, pipeline : PipelineParams, skip_train : bool, skip_test : bool, slackness : float, view_num : int, obj_num : int): with torch.no_grad(): gaussians = GaussianModel(dataset.sh_degree) scene = Scene(dataset, gaussians, load_iteration=iteration, shuffle=False) bg_color = [1,1,1] if dataset.white_background else [0, 0, 0] background = torch.tensor(bg_color, dtype=torch.float32, device="cuda") if not skip_train: render_set(dataset.model_path, "train", scene.loaded_iter, scene.getTrainCameras(), gaussians, pipeline, background, slackness, view_num, obj_num) if not skip_test: render_set(dataset.model_path, "test", scene.loaded_iter, scene.getTestCameras(), gaussians, pipeline, background, slackness, view_num, obj_num) if __name__ == "__main__": # Set up command line argument parser parser = ArgumentParser(description="Testing script parameters") model = ModelParams(parser, sentinel=True) pipeline = PipelineParams(parser) parser.add_argument("--iteration", default=-1, type=int) parser.add_argument("--skip_train", action="store_true") parser.add_argument("--skip_test", action="store_true") parser.add_argument("--quiet", action="store_true") parser.add_argument("--slackness", default=0.0, type=float) parser.add_argument("--view_num", default=10.0, type=int) parser.add_argument("--obj_num", default=1, type=int) args = get_combined_args(parser) print("Generating mask for: " + args.model_path) # Initialize system state (RNG) safe_state(args.quiet) # args.object_path = args.object_mask render_sets(model.extract(args), args.iteration, pipeline.extract(args), args.skip_train, args.skip_test, args.slackness, args.view_num, args.obj_num) ================================================ FILE: lpipsPyTorch/__init__.py ================================================ import torch from .modules.lpips import LPIPS def lpips(x: torch.Tensor, y: torch.Tensor, net_type: str = 'alex', version: str = '0.1'): r"""Function that measures Learned Perceptual Image Patch Similarity (LPIPS). Arguments: x, y (torch.Tensor): the input tensors to compare. net_type (str): the network type to compare the features: 'alex' | 'squeeze' | 'vgg'. Default: 'alex'. version (str): the version of LPIPS. Default: 0.1. """ device = x.device criterion = LPIPS(net_type, version).to(device) return criterion(x, y) ================================================ FILE: lpipsPyTorch/modules/lpips.py ================================================ import torch import torch.nn as nn from .networks import get_network, LinLayers from .utils import get_state_dict class LPIPS(nn.Module): r"""Creates a criterion that measures Learned Perceptual Image Patch Similarity (LPIPS). Arguments: net_type (str): the network type to compare the features: 'alex' | 'squeeze' | 'vgg'. Default: 'alex'. version (str): the version of LPIPS. Default: 0.1. """ def __init__(self, net_type: str = 'alex', version: str = '0.1'): assert version in ['0.1'], 'v0.1 is only supported now' super(LPIPS, self).__init__() # pretrained network self.net = get_network(net_type) # linear layers self.lin = LinLayers(self.net.n_channels_list) self.lin.load_state_dict(get_state_dict(net_type, version)) def forward(self, x: torch.Tensor, y: torch.Tensor): feat_x, feat_y = self.net(x), self.net(y) diff = [(fx - fy) ** 2 for fx, fy in zip(feat_x, feat_y)] res = [l(d).mean((2, 3), True) for d, l in zip(diff, self.lin)] return torch.sum(torch.cat(res, 0), 0, True) ================================================ FILE: lpipsPyTorch/modules/networks.py ================================================ from typing import Sequence from itertools import chain import torch import torch.nn as nn from torchvision import models from .utils import normalize_activation def get_network(net_type: str): if net_type == 'alex': return AlexNet() elif net_type == 'squeeze': return SqueezeNet() elif net_type == 'vgg': return VGG16() else: raise NotImplementedError('choose net_type from [alex, squeeze, vgg].') class LinLayers(nn.ModuleList): def __init__(self, n_channels_list: Sequence[int]): super(LinLayers, self).__init__([ nn.Sequential( nn.Identity(), nn.Conv2d(nc, 1, 1, 1, 0, bias=False) ) for nc in n_channels_list ]) for param in self.parameters(): param.requires_grad = False class BaseNet(nn.Module): def __init__(self): super(BaseNet, self).__init__() # register buffer self.register_buffer( 'mean', torch.Tensor([-.030, -.088, -.188])[None, :, None, None]) self.register_buffer( 'std', torch.Tensor([.458, .448, .450])[None, :, None, None]) def set_requires_grad(self, state: bool): for param in chain(self.parameters(), self.buffers()): param.requires_grad = state def z_score(self, x: torch.Tensor): return (x - self.mean) / self.std def forward(self, x: torch.Tensor): x = self.z_score(x) output = [] for i, (_, layer) in enumerate(self.layers._modules.items(), 1): x = layer(x) if i in self.target_layers: output.append(normalize_activation(x)) if len(output) == len(self.target_layers): break return output class SqueezeNet(BaseNet): def __init__(self): super(SqueezeNet, self).__init__() self.layers = models.squeezenet1_1(True).features self.target_layers = [2, 5, 8, 10, 11, 12, 13] self.n_channels_list = [64, 128, 256, 384, 384, 512, 512] self.set_requires_grad(False) class AlexNet(BaseNet): def __init__(self): super(AlexNet, self).__init__() self.layers = models.alexnet(True).features self.target_layers = [2, 5, 8, 10, 12] self.n_channels_list = [64, 192, 384, 256, 256] self.set_requires_grad(False) class VGG16(BaseNet): def __init__(self): super(VGG16, self).__init__() self.layers = models.vgg16(weights=models.VGG16_Weights.IMAGENET1K_V1).features self.target_layers = [4, 9, 16, 23, 30] self.n_channels_list = [64, 128, 256, 512, 512] self.set_requires_grad(False) ================================================ FILE: lpipsPyTorch/modules/utils.py ================================================ from collections import OrderedDict import torch def normalize_activation(x, eps=1e-10): norm_factor = torch.sqrt(torch.sum(x ** 2, dim=1, keepdim=True)) return x / (norm_factor + eps) def get_state_dict(net_type: str = 'alex', version: str = '0.1'): # build url url = 'https://raw.githubusercontent.com/richzhang/PerceptualSimilarity/' \ + f'master/lpips/weights/v{version}/{net_type}.pth' # download old_state_dict = torch.hub.load_state_dict_from_url( url, progress=True, map_location=None if torch.cuda.is_available() else torch.device('cpu') ) # rename keys new_state_dict = OrderedDict() for key, val in old_state_dict.items(): new_key = key new_key = new_key.replace('lin', '') new_key = new_key.replace('model.', '') new_state_dict[new_key] = val return new_state_dict ================================================ FILE: metrics.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # from pathlib import Path import os from PIL import Image import torch import torchvision.transforms.functional as tf from utils.loss_utils import ssim from lpipsPyTorch import lpips import json from tqdm import tqdm from utils.image_utils import psnr from argparse import ArgumentParser def readImages(renders_dir, gt_dir): renders = [] gts = [] image_names = [] for fname in os.listdir(renders_dir): render = Image.open(renders_dir / fname) gt = Image.open(gt_dir / fname) renders.append(tf.to_tensor(render).unsqueeze(0)[:, :3, :, :].cuda()) gts.append(tf.to_tensor(gt).unsqueeze(0)[:, :3, :, :].cuda()) image_names.append(fname) return renders, gts, image_names def evaluate(model_paths): full_dict = {} per_view_dict = {} full_dict_polytopeonly = {} per_view_dict_polytopeonly = {} print("") for scene_dir in model_paths: try: print("Scene:", scene_dir) full_dict[scene_dir] = {} per_view_dict[scene_dir] = {} full_dict_polytopeonly[scene_dir] = {} per_view_dict_polytopeonly[scene_dir] = {} test_dir = Path(scene_dir) / "test" for method in os.listdir(test_dir): print("Method:", method) full_dict[scene_dir][method] = {} per_view_dict[scene_dir][method] = {} full_dict_polytopeonly[scene_dir][method] = {} per_view_dict_polytopeonly[scene_dir][method] = {} method_dir = test_dir / method gt_dir = method_dir/ "gt" renders_dir = method_dir / "renders" renders, gts, image_names = readImages(renders_dir, gt_dir) ssims = [] psnrs = [] lpipss = [] for idx in tqdm(range(len(renders)), desc="Metric evaluation progress"): ssims.append(ssim(renders[idx], gts[idx])) psnrs.append(psnr(renders[idx], gts[idx])) lpipss.append(lpips(renders[idx], gts[idx], net_type='vgg')) print(" SSIM : {:>12.7f}".format(torch.tensor(ssims).mean(), ".5")) print(" PSNR : {:>12.7f}".format(torch.tensor(psnrs).mean(), ".5")) print(" LPIPS: {:>12.7f}".format(torch.tensor(lpipss).mean(), ".5")) print("") full_dict[scene_dir][method].update({"SSIM": torch.tensor(ssims).mean().item(), "PSNR": torch.tensor(psnrs).mean().item(), "LPIPS": torch.tensor(lpipss).mean().item()}) per_view_dict[scene_dir][method].update({"SSIM": {name: ssim for ssim, name in zip(torch.tensor(ssims).tolist(), image_names)}, "PSNR": {name: psnr for psnr, name in zip(torch.tensor(psnrs).tolist(), image_names)}, "LPIPS": {name: lp for lp, name in zip(torch.tensor(lpipss).tolist(), image_names)}}) with open(scene_dir + "/results.json", 'w') as fp: json.dump(full_dict[scene_dir], fp, indent=True) with open(scene_dir + "/per_view.json", 'w') as fp: json.dump(per_view_dict[scene_dir], fp, indent=True) except: print("Unable to compute metrics for model", scene_dir) if __name__ == "__main__": device = torch.device("cuda:0") torch.cuda.set_device(device) # Set up command line argument parser parser = ArgumentParser(description="Training script parameters") parser.add_argument('--model_paths', '-m', required=True, nargs="+", type=str, default=[]) args = parser.parse_args() evaluate(args.model_paths) ================================================ FILE: objremoval.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import torch from scene import Scene import os from os import path as osp from tqdm import tqdm from os import makedirs # import imageio import cv2 from gaussian_renderer import render from gaussian_renderer import flashsplat_render import torchvision from utils.general_utils import safe_state from argparse import ArgumentParser from arguments import ModelParams, PipelineParams, get_combined_args from gaussian_renderer import GaussianModel from PIL import Image import numpy as np import colorsys import pdb import torch import torch.nn.functional as F def mean_neighborhood(input_img, N): pad = (N - 1) // 2 padded_img = F.pad(input_img, (pad, pad, pad, pad), mode='constant', value=0) patches = padded_img.unfold(1, N, 1).unfold(2, N, 1) mean_patches = patches.mean(dim=-1).mean(dim=-1) return mean_patches def save_mp4(dir, fps): imgpath = dir frames = [] fourcc = cv2.VideoWriter.fourcc(*'mp4v') fps = float(fps) for name in sorted(os.listdir(imgpath)): img = osp.join(imgpath, name) img = cv2.imread(img) frames.append(img) height, width = frames[0].shape[:2] writer = cv2.VideoWriter(os.path.join(dir,'eval.mp4'), fourcc, fps, (width, height)) for frame in frames: writer.write(frame) writer.release() # def multi_instance_opt(all_counts, slackness=0.): # all_counts = torch.nn.functional.normalize(all_counts, dim=0) # all_counts[0, :] += slackness # slackness # all_obj_labels = torch.zeros_like(all_counts) # obj_num = all_counts.size(0) # for obj_idx, obj_counts in enumerate(tqdm(all_counts, desc="multi-view optimize")): # if obj_counts.sum().item() == 0: # continue # other_idx = list(range(obj_idx)) + list(range(obj_idx + 1, obj_num)) # other_counts = all_counts[other_idx, :].sum(dim=0) # obj_counts = torch.stack([other_counts, obj_counts], dim=0) # if slackness > 0: # obj_counts = torch.nn.functional.normalize(all_counts, dim=0) # all_counts[0, :] += slackness # obj_label = obj_counts.max(dim=0)[1] # all_obj_labels[obj_idx] = obj_label # return all_obj_labels def multi_instance_opt(all_counts, slackness=0.): all_counts = torch.nn.functional.normalize(all_counts, dim=0) all_counts_sum = all_counts.sum(dim=0) all_obj_labels = torch.zeros_like(all_counts) obj_num = all_counts.size(0) for obj_idx, obj_counts in enumerate(tqdm(all_counts, desc="multi-view optimize")): if obj_counts.sum().item() == 0: continue # other_idx = list(range(obj_idx)) + list(range(obj_idx + 1, obj_num)) # other_counts = all_counts[other_idx, :].sum(dim=0) # obj_counts = torch.stack([other_counts, obj_counts], dim=0) # dynamic programming obj_counts = torch.stack([all_counts_sum - obj_counts, obj_counts], dim=0) if slackness != 0: obj_counts = torch.nn.functional.normalize(obj_counts, dim=0) obj_counts[0, :] += slackness obj_label = obj_counts.max(dim=0)[1] all_obj_labels[obj_idx] = obj_label return all_obj_labels def id2rgb(id, max_num_obj=256): if not 0 <= id <= max_num_obj: raise ValueError("ID should be in range(0, max_num_obj)") # Convert the ID into a hue value golden_ratio = 1.6180339887 h = ((id * golden_ratio) % 1) # Ensure value is between 0 and 1 s = 0.5 + (id % 2) * 0.5 # Alternate between 0.5 and 1.0 l = 0.5 # Use colorsys to convert HSL to RGB rgb = np.zeros((3, ), dtype=np.uint8) if id==0: #invalid region return rgb r, g, b = colorsys.hls_to_rgb(h, l, s) rgb[0], rgb[1], rgb[2] = int(r*255), int(g*255), int(b*255) return rgb # for visualize color mask def visualize_obj(objects): rgb_mask = np.zeros((*objects.shape[-2:], 3), dtype=np.uint8) all_obj_ids = np.unique(objects) for id in all_obj_ids: colored_mask = id2rgb(id) rgb_mask[objects == id] = colored_mask return rgb_mask def render_set(model_path, name, iteration, views, gaussians, pipeline, background, slackness=0, view_num=-1, obj_num=256, obj_ids=[]): render_path = os.path.join(model_path, name, "ours_{}".format(iteration), "renders") gts_path = os.path.join(model_path, name, "ours_{}".format(iteration), "gt") makedirs(render_path, exist_ok=True) makedirs(gts_path, exist_ok=True) if view_num > 0: # view_interval = (len(views) // view_num + 1) # views = views[::view_interval] view_idx = np.linspace(0, len(views) - 1, view_num, dtype=int).tolist() views_used = [views[idx] for idx in view_idx] else: view_num = len(views) views_used = views all_counts = None stats_counts_path = os.path.join(model_path, name, "ours_{}".format(iteration), "used_count") makedirs(stats_counts_path, exist_ok=True) cur_count_dir = os.path.join(stats_counts_path, "view_num_{:03d}_objnum_{:03d}.pth".format(view_num, obj_num)) if os.path.exists(cur_count_dir): print(f"find {cur_count_dir}") all_counts = torch.load(cur_count_dir).cuda() else: for idx, view in enumerate(tqdm(views_used, desc="Rendering progress")): if obj_num == 1: gt_mask = view.objects.to(torch.float32) / 255. else: gt_mask = view.objects.to(torch.float32) assert torch.any(torch.max(gt_mask) < obj_num), f"max_obj {int(torch.max(gt_mask).item())}" # set(tuple(gt_mask.cpu().tolist())[0]) render_pkg = flashsplat_render(view, gaussians, pipeline, background, gt_mask=gt_mask, obj_num=obj_num) rendering = render_pkg["render"] used_count = render_pkg["used_count"] if all_counts is None: all_counts = torch.zeros_like(used_count) gt = view.original_image[0:3, :, :] torchvision.utils.save_image(rendering, os.path.join(render_path, '{0:05d}'.format(idx) + ".png")) torchvision.utils.save_image(gt, os.path.join(gts_path, '{0:05d}'.format(idx) + ".png")) all_counts += used_count save_mp4(render_path, 3) torch.save(all_counts, cur_count_dir) if all_counts is not None: # used_mask = (all_counts.sum(dim=0) > 0) # reduced_render_path = os.path.join(model_path, name, "ours_{}".format(iteration), "reduced_renders") # os.makedirs(reduced_render_path, exist_ok=True) # for idx, view in enumerate(tqdm(views, desc="Rendering progress")): # gt_mask = view.objects.to(torch.float32) # # set(tuple(gt_mask.cpu().tolist())[0]) # render_pkg = flashsplat_render(view, gaussians, pipeline, background, used_mask=used_mask) # rendering = render_pkg["render"] # gt = view.original_image[0:3, :, :] # torchvision.utils.save_image(rendering, os.path.join(reduced_render_path, '{0:05d}'.format(idx) + ".png")) # if obj_num == 1: # # for binary seg, # all_counts = torch.nn.functional.normalize(all_counts, dim=0) # all_counts[0, :] += slackness # slackness # unique_label = all_counts.max(dim=0)[1] # else: all_obj_labels = multi_instance_opt(all_counts, slackness) # view_interval = (len(views) // view_num + 1) # views = views[::view_interval] # _view_num = 50 # view_idx = np.linspace(0, len(views) - 1, _view_num, dtype=int).tolist() # views_used = [views[idx] for idx in view_idx] views_used = views # find 3d gaussians id to be removed assert isinstance(obj_ids, list), "the type of obj_id shall be list." removal_mask = torch.zeros(all_obj_labels.shape[1], dtype=torch.bool, device=all_obj_labels.device) removal_name = "" for obj_idx in obj_ids: removal_mask[all_obj_labels[obj_idx].bool()] = True removal_name += "_{:03d}".format(obj_idx) remain_mask = ~removal_mask obj_removal_path = os.path.join(model_path, name, "ours_{}".format(iteration), "removal{}".format(removal_name)) os.makedirs(obj_removal_path, exist_ok=True) for idx, view in enumerate(tqdm(views_used, desc="Rendering removal")): render_pkg = flashsplat_render(view, gaussians, pipeline, background, used_mask=remain_mask) rendering = render_pkg["render"] torchvision.utils.save_image(rendering, os.path.join(obj_removal_path, '{0:05d}'.format(idx) + ".png")) # save gts gt = view.original_image[0:3, :, :] torchvision.utils.save_image(gt, os.path.join(gts_path, '{0:05d}'.format(idx) + ".png")) save_mp4(obj_removal_path, 3) def render_sets(dataset : ModelParams, iteration : int, pipeline : PipelineParams, skip_train : bool, skip_test : bool, slackness : float, view_num : int, obj_num : int, obj_id: int): with torch.no_grad(): gaussians = GaussianModel(dataset.sh_degree) scene = Scene(dataset, gaussians, load_iteration=iteration, shuffle=False) bg_color = [1,1,1] if dataset.white_background else [0, 0, 0] background = torch.tensor(bg_color, dtype=torch.float32, device="cuda") if not skip_train: render_set(dataset.model_path, "train", scene.loaded_iter, scene.getTrainCameras(), gaussians, pipeline, background, slackness, view_num, obj_num, obj_id) if not skip_test: render_set(dataset.model_path, "test", scene.loaded_iter, scene.getTestCameras(), gaussians, pipeline, background, slackness, view_num, obj_num, obj_id) if __name__ == "__main__": # Set up command line argument parser parser = ArgumentParser(description="Testing script parameters") model = ModelParams(parser, sentinel=True) pipeline = PipelineParams(parser) parser.add_argument("--iteration", default=-1, type=int) parser.add_argument("--skip_train", action="store_true") parser.add_argument("--skip_test", action="store_true") parser.add_argument("--quiet", action="store_true") parser.add_argument("--slackness", default=0.0, type=float) parser.add_argument("--view_num", default=10.0, type=int) parser.add_argument("--obj_num", default=1, type=int) parser.add_argument('--obj_id', nargs='+', type=int, help='A list of integers') # parser.add_argument("--object_path", default="inpaint_object_mask_255", type=str) args = get_combined_args(parser) print("Rendering " + args.model_path) # Initialize system state (RNG) safe_state(args.quiet) # args.object_path = args.object_mask render_sets(model.extract(args), args.iteration, pipeline.extract(args), args.skip_train, args.skip_test, args.slackness, args.view_num, args.obj_num, args.obj_id) ================================================ FILE: readme.md ================================================ ## FlashSplat: 2D to 3D Gaussian Splatting Segmentation Solved Optimally teaser [Qiuhong Shen](https://florinshen.github.io), [Xingyi Yang](https://adamdad.github.io/), [Xinchao Wang](https://sites.google.com/site/sitexinchaowang/) National University of Singapore [Arxiv](https://arxiv.org/abs/2409.08270) | [Demo]() ### Overview > This study addresses the challenge of accurately segmenting 3D Gaussian Splatting from 2D masks. Conventional methods often rely on iterative gradient descent to assign each Gaussian a unique label, leading to lengthy optimization and sub-optimal solutions. Instead, we propose a straightforward yet globally optimal solver for 3D-GS segmentation. The core insight of our method is that, with a reconstructed 3D-GS scene , the rendering of the 2D masks is essentially a linear function with respect to the labels of each Gaussian. As such, the optimal label assignment can be solved via linear programming in closed form. This solution capitalizes on the alpha blending characteristic of the splatting process for single step optimization. By incorporating the background bias in our objective function, our method shows superior robustness in 3D segmentation against noises. Remarkably, our optimization completes within 30 seconds, about 50x faster than the best existing methods. ### News **[2024.09.13]** FlashSplat's paper and code are released. **[2024.07.01]** FlashSplat is accepted by **ECCV 2024**! ### Installation ### TODO List - [ ] Update detailed tutorial for using FlashSplat. - [ ] Support multi-view mask association with SAM2 model. - [ ] Extend FlashSplat for variants of orignal 3DGS. ### Acknowledgement This work is built on many amazing research works and open-source projects, thanks a lot to all the authors for sharing! - [gaussian-splatting](https://github.com/graphdeco-inria/gaussian-splatting) - [gaussian-grouping](https://github.com/lkeab/gaussian-grouping) - [diff-gaussian-rasterization](https://github.com/graphdeco-inria/diff-gaussian-rasterization) - [diff-gaussian-rasterization-kiui](https://github.com/ashawkey/diff-gaussian-rasterization.git) ### Citation ```bibtex @article{flashsplat, title={FlashSplat: 2D to 3D Gaussian Splatting Segmentation Solved Optimally}, author={Shen, Qiuhong and Yang, Xingyi and Wang, Xinchao}, journal={European Conference of Computer Vision}, year={2024} } ``` ================================================ FILE: render.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import torch from scene import Scene import os from os import path as osp from tqdm import tqdm from os import makedirs # import imageio import cv2 from gaussian_renderer import render from gaussian_renderer import flashsplat_render import torchvision from utils.general_utils import safe_state from argparse import ArgumentParser from arguments import ModelParams, PipelineParams, get_combined_args from gaussian_renderer import GaussianModel from PIL import Image import numpy as np import colorsys import pdb import torch import torch.nn.functional as F def mean_neighborhood(input_img, N): pad = (N - 1) // 2 padded_img = F.pad(input_img, (pad, pad, pad, pad), mode='constant', value=0) patches = padded_img.unfold(1, N, 1).unfold(2, N, 1) mean_patches = patches.mean(dim=-1).mean(dim=-1) return mean_patches def save_mp4(dir, fps): imgpath = dir frames = [] fourcc = cv2.VideoWriter.fourcc(*'mp4v') fps = float(fps) for name in sorted(os.listdir(imgpath)): img = osp.join(imgpath, name) img = cv2.imread(img) frames.append(img) height, width = frames[0].shape[:2] writer = cv2.VideoWriter(os.path.join(dir,'eval.mp4'), fourcc, fps, (width, height)) for frame in frames: writer.write(frame) writer.release() # def multi_instance_opt(all_counts, slackness=0.): # all_counts = torch.nn.functional.normalize(all_counts, dim=0) # all_counts[0, :] += slackness # slackness # all_obj_labels = torch.zeros_like(all_counts) # obj_num = all_counts.size(0) # for obj_idx, obj_counts in enumerate(tqdm(all_counts, desc="multi-view optimize")): # if obj_counts.sum().item() == 0: # continue # other_idx = list(range(obj_idx)) + list(range(obj_idx + 1, obj_num)) # other_counts = all_counts[other_idx, :].sum(dim=0) # obj_counts = torch.stack([other_counts, obj_counts], dim=0) # if slackness > 0: # obj_counts = torch.nn.functional.normalize(all_counts, dim=0) # all_counts[0, :] += slackness # obj_label = obj_counts.max(dim=0)[1] # all_obj_labels[obj_idx] = obj_label # return all_obj_labels def multi_instance_opt(all_counts, slackness=0.): all_counts = torch.nn.functional.normalize(all_counts, dim=0, p=1) # default p = 2 all_counts_sum = all_counts.sum(dim=0) all_obj_labels = torch.zeros_like(all_counts) obj_num = all_counts.size(0) for obj_idx, obj_counts in enumerate(tqdm(all_counts, desc="multi-view optimize")): if obj_counts.sum().item() == 0: continue # other_idx = list(range(obj_idx)) + list(range(obj_idx + 1, obj_num)) # other_counts = all_counts[other_idx, :].sum(dim=0) # obj_counts = torch.stack([other_counts, obj_counts], dim=0) # dynamic programming obj_counts = torch.stack([all_counts_sum - obj_counts, obj_counts], dim=0) if slackness != 0: obj_counts = torch.nn.functional.normalize(obj_counts, dim=0) obj_counts[0, :] += slackness obj_label = obj_counts.max(dim=0)[1] all_obj_labels[obj_idx] = obj_label return all_obj_labels def id2rgb(id, max_num_obj=256): if not 0 <= id <= max_num_obj: raise ValueError("ID should be in range(0, max_num_obj)") # Convert the ID into a hue value golden_ratio = 1.6180339887 h = ((id * golden_ratio) % 1) # Ensure value is between 0 and 1 s = 0.5 + (id % 2) * 0.5 # Alternate between 0.5 and 1.0 l = 0.5 # Use colorsys to convert HSL to RGB rgb = np.zeros((3, ), dtype=np.uint8) if id==0: #invalid region return rgb r, g, b = colorsys.hls_to_rgb(h, l, s) rgb[0], rgb[1], rgb[2] = int(r*255), int(g*255), int(b*255) return rgb # for visualize color mask def visualize_obj(objects): rgb_mask = np.zeros((*objects.shape[-2:], 3), dtype=np.uint8) all_obj_ids = np.unique(objects) for id in all_obj_ids: colored_mask = id2rgb(id) rgb_mask[objects == id] = colored_mask return rgb_mask def render_set(model_path, name, iteration, views, gaussians, pipeline, background, slackness=0, view_num=-1, obj_num=256, obj_id=-1): render_path = os.path.join(model_path, name, "ours_{}".format(iteration), "renders") gts_path = os.path.join(model_path, name, "ours_{}".format(iteration), "gt") makedirs(render_path, exist_ok=True) makedirs(gts_path, exist_ok=True) if view_num > 0: # view_interval = (len(views) // view_num + 1) # views = views[::view_interval] view_idx = np.linspace(0, len(views) - 1, view_num, dtype=int).tolist() views_used = [views[idx] for idx in view_idx] else: view_num = len(views) views_used = views all_counts = None stats_counts_path = os.path.join(model_path, name, "ours_{}".format(iteration), "used_count") makedirs(stats_counts_path, exist_ok=True) cur_count_dir = os.path.join(stats_counts_path, "view_num_{:03d}_objnum_{:03d}.pth".format(view_num, obj_num)) if os.path.exists(cur_count_dir): print(f"find {cur_count_dir}") all_counts = torch.load(cur_count_dir).cuda() else: for idx, view in enumerate(tqdm(views_used, desc="Rendering progress")): if obj_num == 1: gt_mask = view.objects.to(torch.float32) / 255. else: gt_mask = view.objects.to(torch.float32) assert torch.any(torch.max(gt_mask) < obj_num), f"max_obj {int(torch.max(gt_mask).item())}" # set(tuple(gt_mask.cpu().tolist())[0]) render_pkg = flashsplat_render(view, gaussians, pipeline, background, gt_mask=gt_mask, obj_num=obj_num) rendering = render_pkg["render"] used_count = render_pkg["used_count"] if all_counts is None: all_counts = torch.zeros_like(used_count) gt = view.original_image[0:3, :, :] torchvision.utils.save_image(rendering, os.path.join(render_path, '{0:05d}'.format(idx) + ".png")) torchvision.utils.save_image(gt, os.path.join(gts_path, '{0:05d}'.format(idx) + ".png")) all_counts += used_count save_mp4(render_path, 15) torch.save(all_counts, cur_count_dir) if all_counts is not None: # used_mask = (all_counts.sum(dim=0) > 0) # reduced_render_path = os.path.join(model_path, name, "ours_{}".format(iteration), "reduced_renders") # os.makedirs(reduced_render_path, exist_ok=True) # for idx, view in enumerate(tqdm(views, desc="Rendering progress")): # gt_mask = view.objects.to(torch.float32) # # set(tuple(gt_mask.cpu().tolist())[0]) # render_pkg = flashsplat_render(view, gaussians, pipeline, background, used_mask=used_mask) # rendering = render_pkg["render"] # gt = view.original_image[0:3, :, :] # torchvision.utils.save_image(rendering, os.path.join(reduced_render_path, '{0:05d}'.format(idx) + ".png")) if obj_num == 1: # for binary seg, all_counts = torch.nn.functional.normalize(all_counts, dim=0) all_counts[0, :] += slackness # slackness unique_label = all_counts.max(dim=0)[1] else: all_obj_labels = multi_instance_opt(all_counts, slackness) render_num = all_counts.size(0) # view_interval = (len(views) // view_num + 1) # views = views[::view_interval] _view_num = 10 # view_num only used to render the object view_idx = np.linspace(0, len(views) - 1, _view_num, dtype=int).tolist() views_used = [views[idx] for idx in view_idx] # render each instance early_stop = False for obj_idx in range(render_num): if obj_id > 0: obj_idx = obj_id early_stop = True if obj_num == 1: obj_used_mask = (unique_label == obj_idx) else: obj_used_mask = (all_obj_labels[obj_idx]).bool() if obj_used_mask.sum().item() == 0: continue # obj_used_mask = ~obj_used_mask obj_render_path = os.path.join(model_path, name, "ours_{}".format(iteration), "obj_{:03d}".format(obj_idx)) os.makedirs(obj_render_path, exist_ok=True) for idx, view in enumerate(tqdm(views_used, desc="Rendering object {:03d}".format(obj_idx))): render_pkg = flashsplat_render(view, gaussians, pipeline, background, used_mask=obj_used_mask) rendering = render_pkg["render"] gt = view.original_image[0:3, :, :] torchvision.utils.save_image(rendering, os.path.join(obj_render_path, '{0:05d}'.format(idx) + ".png")) # gt_mask = (view.objects / 255.).bool()[None, ].repeat(3, 1, 1) # dummy_gt_mask = torch.zeros_like(gt) # dummy_gt_mask[0] = 1. # gt[gt_mask.bool()] = 0.7 * gt[gt_mask.bool()] + 0.3 * dummy_gt_mask[gt_mask.bool()] torchvision.utils.save_image(gt, os.path.join(gts_path, '{0:05d}'.format(idx) + ".png")) save_mp4(obj_render_path, 15) if early_stop: break # # render full view with selective tile, test the selective forward only here # sfwd_path = os.path.join(model_path, name, "ours_{}".format(iteration), "selective_fwd") # os.makedirs(sfwd_path, exist_ok=True) # for idx, view in enumerate(tqdm(views, desc="Rendering progress")): # gt_mask = view.objects.to(torch.float32) / 255. # render_pkg = flashsplat_render(view, gaussians, pipeline, background, gt_mask=gt_mask, unique_label=unique_label.to(torch.int)) # rendering = render_pkg["render"] # torchvision.utils.save_image(rendering, os.path.join(sfwd_path, '{0:05d}'.format(idx) + ".png")) # save_mp4(sfwd_path, 15) def render_sets(dataset : ModelParams, iteration : int, pipeline : PipelineParams, skip_train : bool, skip_test : bool, slackness : float, view_num : int, obj_num : int, obj_id: int): with torch.no_grad(): gaussians = GaussianModel(dataset.sh_degree) scene = Scene(dataset, gaussians, load_iteration=iteration, shuffle=False) bg_color = [1,1,1] if dataset.white_background else [0, 0, 0] background = torch.tensor(bg_color, dtype=torch.float32, device="cuda") if not skip_train: render_set(dataset.model_path, "train", scene.loaded_iter, scene.getTrainCameras(), gaussians, pipeline, background, slackness, view_num, obj_num, obj_id) if not skip_test: render_set(dataset.model_path, "test", scene.loaded_iter, scene.getTestCameras(), gaussians, pipeline, background, slackness, view_num, obj_num, obj_id) if __name__ == "__main__": # Set up command line argument parser parser = ArgumentParser(description="Testing script parameters") model = ModelParams(parser, sentinel=True) pipeline = PipelineParams(parser) parser.add_argument("--iteration", default=-1, type=int) parser.add_argument("--skip_train", action="store_true") parser.add_argument("--skip_test", action="store_true") parser.add_argument("--quiet", action="store_true") parser.add_argument("--slackness", default=0.0, type=float) parser.add_argument("--view_num", default=10.0, type=int) parser.add_argument("--obj_num", default=1, type=int) parser.add_argument("--obj_id", default=-1, type=int) # parser.add_argument("--object_path", default="inpaint_object_mask_255", type=str) args = get_combined_args(parser) print("Rendering " + args.model_path) # Initialize system state (RNG) safe_state(args.quiet) # args.object_path = args.object_mask render_sets(model.extract(args), args.iteration, pipeline.extract(args), args.skip_train, args.skip_test, args.slackness, args.view_num, args.obj_num, args.obj_id) ================================================ FILE: scene/__init__.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import os import random import json from utils.system_utils import searchForMaxIteration from scene.dataset_readers import sceneLoadTypeCallbacks from scene.gaussian_model import GaussianModel from arguments import ModelParams from utils.camera_utils import cameraList_from_camInfos, camera_to_JSON class Scene: gaussians : GaussianModel def __init__(self, args : ModelParams, gaussians : GaussianModel, load_iteration=None, shuffle=True, resolution_scales=[1.0]): """b :param path: Path to colmap scene main folder. """ self.model_path = args.model_path self.loaded_iter = None self.gaussians = gaussians if load_iteration: if load_iteration == -1: self.loaded_iter = searchForMaxIteration(os.path.join(self.model_path, "point_cloud")) else: self.loaded_iter = load_iteration print("Loading trained model at iteration {}".format(self.loaded_iter)) self.train_cameras = {} self.test_cameras = {} if os.path.exists(os.path.join(args.source_path, "sparse")): scene_info = sceneLoadTypeCallbacks["Colmap"](args.source_path, args.images, args.eval, args.object_path) elif os.path.exists(os.path.join(args.source_path, "transforms_train.json")): # print("Found transforms_train.json file, assuming Blender data set!") scene_info = sceneLoadTypeCallbacks["Blender"](args.source_path, args.white_background, args.eval) else: assert False, "Could not recognize scene type!" if not self.loaded_iter: with open(scene_info.ply_path, 'rb') as src_file, open(os.path.join(self.model_path, "input.ply") , 'wb') as dest_file: dest_file.write(src_file.read()) json_cams = [] camlist = [] if scene_info.test_cameras: camlist.extend(scene_info.test_cameras) if scene_info.train_cameras: camlist.extend(scene_info.train_cameras) for id, cam in enumerate(camlist): json_cams.append(camera_to_JSON(id, cam)) with open(os.path.join(self.model_path, "cameras.json"), 'w') as file: json.dump(json_cams, file) if shuffle: random.shuffle(scene_info.train_cameras) # Multi-res consistent random shuffling random.shuffle(scene_info.test_cameras) # Multi-res consistent random shuffling self.cameras_extent = scene_info.nerf_normalization["radius"] for resolution_scale in resolution_scales: # print("Loading Training Cameras") self.train_cameras[resolution_scale] = cameraList_from_camInfos(scene_info.train_cameras, resolution_scale, args) # print("Loading Test Cameras") self.test_cameras[resolution_scale] = cameraList_from_camInfos(scene_info.test_cameras, resolution_scale, args) if self.loaded_iter: if isinstance(self.loaded_iter,str): print("edit load path", self.loaded_iter) self.gaussians.load_ply(os.path.join(self.model_path, "point_cloud"+self.loaded_iter, "point_cloud.ply")) else: self.gaussians.load_ply(os.path.join(self.model_path, "point_cloud", "iteration_" + str(self.loaded_iter), "point_cloud.ply")) else: self.gaussians.create_from_pcd(scene_info.point_cloud, self.cameras_extent) def save(self, iteration): point_cloud_path = os.path.join(self.model_path, "point_cloud/iteration_{}".format(iteration)) self.gaussians.save_ply(os.path.join(point_cloud_path, "point_cloud.ply")) def getTrainCameras(self, scale=1.0): return self.train_cameras[scale] def getTestCameras(self, scale=1.0): return self.test_cameras[scale] ================================================ FILE: scene/cameras.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import torch from torch import nn import numpy as np from utils.graphics_utils import getWorld2View2, getProjectionMatrix import pdb class Camera(nn.Module): def __init__(self, colmap_id, R, T, FoVx, FoVy, image, gt_alpha_mask, image_name, uid, gt_depth, trans=np.array([0.0, 0.0, 0.0]), scale=1.0, data_device = "cuda", objects=None, c2w=None, ): super(Camera, self).__init__() self.uid = uid self.colmap_id = colmap_id self.R = R self.T = T self.FoVx = FoVx self.FoVy = FoVy self.image_name = image_name self.c2w = c2w try: self.data_device = torch.device(data_device) except Exception as e: print(e) print(f"[Warning] Custom device {data_device} failed, fallback to default cuda device" ) self.data_device = torch.device("cuda") self.original_image = image.clamp(0.0, 1.0).to(self.data_device) self.image_width = self.original_image.shape[2] self.image_height = self.original_image.shape[1] if gt_alpha_mask is not None and isinstance(gt_alpha_mask, np.ndarray): gt_alpha_mask = torch.from_numpy(gt_alpha_mask).to(self.data_device) gt_depth = torch.from_numpy(gt_depth).to(self.data_device) self.gt_alpha_mask = gt_alpha_mask self.gt_depth = gt_depth if gt_alpha_mask is not None: self.original_image *= gt_alpha_mask.to(self.data_device) else: self.original_image *= torch.ones((1, self.image_height, self.image_width), device=self.data_device) self.zfar = 100.0 self.znear = 0.01 self.trans = trans self.scale = scale self.world_view_transform = torch.tensor(getWorld2View2(R, T, trans, scale)).transpose(0, 1).cuda() self.projection_matrix = getProjectionMatrix(znear=self.znear, zfar=self.zfar, fovX=self.FoVx, fovY=self.FoVy).transpose(0,1).cuda() self.full_proj_transform = (self.world_view_transform.unsqueeze(0).bmm(self.projection_matrix.unsqueeze(0))).squeeze(0) self.camera_center = self.world_view_transform.inverse()[3, :3] if objects is not None: self.objects = objects.to(self.data_device) else: self.objects = None class MiniCam: def __init__(self, width, height, fovy, fovx, znear, zfar, world_view_transform, full_proj_transform): self.image_width = width self.image_height = height self.FoVy = fovy self.FoVx = fovx self.znear = znear self.zfar = zfar self.world_view_transform = world_view_transform self.full_proj_transform = full_proj_transform view_inv = torch.inverse(self.world_view_transform) self.camera_center = view_inv[3][:3] ================================================ FILE: scene/colmap_loader.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import numpy as np import collections import struct CameraModel = collections.namedtuple( "CameraModel", ["model_id", "model_name", "num_params"]) Camera = collections.namedtuple( "Camera", ["id", "model", "width", "height", "params"]) BaseImage = collections.namedtuple( "Image", ["id", "qvec", "tvec", "camera_id", "name", "xys", "point3D_ids"]) Point3D = collections.namedtuple( "Point3D", ["id", "xyz", "rgb", "error", "image_ids", "point2D_idxs"]) CAMERA_MODELS = { CameraModel(model_id=0, model_name="SIMPLE_PINHOLE", num_params=3), CameraModel(model_id=1, model_name="PINHOLE", num_params=4), CameraModel(model_id=2, model_name="SIMPLE_RADIAL", num_params=4), CameraModel(model_id=3, model_name="RADIAL", num_params=5), CameraModel(model_id=4, model_name="OPENCV", num_params=8), CameraModel(model_id=5, model_name="OPENCV_FISHEYE", num_params=8), CameraModel(model_id=6, model_name="FULL_OPENCV", num_params=12), CameraModel(model_id=7, model_name="FOV", num_params=5), CameraModel(model_id=8, model_name="SIMPLE_RADIAL_FISHEYE", num_params=4), CameraModel(model_id=9, model_name="RADIAL_FISHEYE", num_params=5), CameraModel(model_id=10, model_name="THIN_PRISM_FISHEYE", num_params=12) } CAMERA_MODEL_IDS = dict([(camera_model.model_id, camera_model) for camera_model in CAMERA_MODELS]) CAMERA_MODEL_NAMES = dict([(camera_model.model_name, camera_model) for camera_model in CAMERA_MODELS]) def qvec2rotmat(qvec): return np.array([ [1 - 2 * qvec[2]**2 - 2 * qvec[3]**2, 2 * qvec[1] * qvec[2] - 2 * qvec[0] * qvec[3], 2 * qvec[3] * qvec[1] + 2 * qvec[0] * qvec[2]], [2 * qvec[1] * qvec[2] + 2 * qvec[0] * qvec[3], 1 - 2 * qvec[1]**2 - 2 * qvec[3]**2, 2 * qvec[2] * qvec[3] - 2 * qvec[0] * qvec[1]], [2 * qvec[3] * qvec[1] - 2 * qvec[0] * qvec[2], 2 * qvec[2] * qvec[3] + 2 * qvec[0] * qvec[1], 1 - 2 * qvec[1]**2 - 2 * qvec[2]**2]]) def rotmat2qvec(R): Rxx, Ryx, Rzx, Rxy, Ryy, Rzy, Rxz, Ryz, Rzz = R.flat K = np.array([ [Rxx - Ryy - Rzz, 0, 0, 0], [Ryx + Rxy, Ryy - Rxx - Rzz, 0, 0], [Rzx + Rxz, Rzy + Ryz, Rzz - Rxx - Ryy, 0], [Ryz - Rzy, Rzx - Rxz, Rxy - Ryx, Rxx + Ryy + Rzz]]) / 3.0 eigvals, eigvecs = np.linalg.eigh(K) qvec = eigvecs[[3, 0, 1, 2], np.argmax(eigvals)] if qvec[0] < 0: qvec *= -1 return qvec class Image(BaseImage): def qvec2rotmat(self): return qvec2rotmat(self.qvec) def read_next_bytes(fid, num_bytes, format_char_sequence, endian_character="<"): """Read and unpack the next bytes from a binary file. :param fid: :param num_bytes: Sum of combination of {2, 4, 8}, e.g. 2, 6, 16, 30, etc. :param format_char_sequence: List of {c, e, f, d, h, H, i, I, l, L, q, Q}. :param endian_character: Any of {@, =, <, >, !} :return: Tuple of read and unpacked values. """ data = fid.read(num_bytes) return struct.unpack(endian_character + format_char_sequence, data) def read_points3D_text(path): """ see: src/base/reconstruction.cc void Reconstruction::ReadPoints3DText(const std::string& path) void Reconstruction::WritePoints3DText(const std::string& path) """ xyzs = None rgbs = None errors = None num_points = 0 with open(path, "r") as fid: while True: line = fid.readline() if not line: break line = line.strip() if len(line) > 0 and line[0] != "#": num_points += 1 xyzs = np.empty((num_points, 3)) rgbs = np.empty((num_points, 3)) errors = np.empty((num_points, 1)) count = 0 with open(path, "r") as fid: while True: line = fid.readline() if not line: break line = line.strip() if len(line) > 0 and line[0] != "#": elems = line.split() xyz = np.array(tuple(map(float, elems[1:4]))) rgb = np.array(tuple(map(int, elems[4:7]))) error = np.array(float(elems[7])) xyzs[count] = xyz rgbs[count] = rgb errors[count] = error count += 1 return xyzs, rgbs, errors def read_points3D_binary(path_to_model_file): """ see: src/base/reconstruction.cc void Reconstruction::ReadPoints3DBinary(const std::string& path) void Reconstruction::WritePoints3DBinary(const std::string& path) """ with open(path_to_model_file, "rb") as fid: num_points = read_next_bytes(fid, 8, "Q")[0] xyzs = np.empty((num_points, 3)) rgbs = np.empty((num_points, 3)) errors = np.empty((num_points, 1)) for p_id in range(num_points): binary_point_line_properties = read_next_bytes( fid, num_bytes=43, format_char_sequence="QdddBBBd") xyz = np.array(binary_point_line_properties[1:4]) rgb = np.array(binary_point_line_properties[4:7]) error = np.array(binary_point_line_properties[7]) track_length = read_next_bytes( fid, num_bytes=8, format_char_sequence="Q")[0] track_elems = read_next_bytes( fid, num_bytes=8*track_length, format_char_sequence="ii"*track_length) xyzs[p_id] = xyz rgbs[p_id] = rgb errors[p_id] = error return xyzs, rgbs, errors def read_intrinsics_text(path): """ Taken from https://github.com/colmap/colmap/blob/dev/scripts/python/read_write_model.py """ cameras = {} with open(path, "r") as fid: while True: line = fid.readline() if not line: break line = line.strip() if len(line) > 0 and line[0] != "#": elems = line.split() camera_id = int(elems[0]) model = elems[1] assert model == "PINHOLE", "While the loader support other types, the rest of the code assumes PINHOLE" width = int(elems[2]) height = int(elems[3]) params = np.array(tuple(map(float, elems[4:]))) cameras[camera_id] = Camera(id=camera_id, model=model, width=width, height=height, params=params) return cameras def read_extrinsics_binary(path_to_model_file): """ see: src/base/reconstruction.cc void Reconstruction::ReadImagesBinary(const std::string& path) void Reconstruction::WriteImagesBinary(const std::string& path) """ images = {} with open(path_to_model_file, "rb") as fid: num_reg_images = read_next_bytes(fid, 8, "Q")[0] for _ in range(num_reg_images): binary_image_properties = read_next_bytes( fid, num_bytes=64, format_char_sequence="idddddddi") image_id = binary_image_properties[0] qvec = np.array(binary_image_properties[1:5]) tvec = np.array(binary_image_properties[5:8]) camera_id = binary_image_properties[8] image_name = "" current_char = read_next_bytes(fid, 1, "c")[0] while current_char != b"\x00": # look for the ASCII 0 entry image_name += current_char.decode("utf-8") current_char = read_next_bytes(fid, 1, "c")[0] num_points2D = read_next_bytes(fid, num_bytes=8, format_char_sequence="Q")[0] x_y_id_s = read_next_bytes(fid, num_bytes=24*num_points2D, format_char_sequence="ddq"*num_points2D) xys = np.column_stack([tuple(map(float, x_y_id_s[0::3])), tuple(map(float, x_y_id_s[1::3]))]) point3D_ids = np.array(tuple(map(int, x_y_id_s[2::3]))) images[image_id] = Image( id=image_id, qvec=qvec, tvec=tvec, camera_id=camera_id, name=image_name, xys=xys, point3D_ids=point3D_ids) return images def read_intrinsics_binary(path_to_model_file): """ see: src/base/reconstruction.cc void Reconstruction::WriteCamerasBinary(const std::string& path) void Reconstruction::ReadCamerasBinary(const std::string& path) """ cameras = {} with open(path_to_model_file, "rb") as fid: num_cameras = read_next_bytes(fid, 8, "Q")[0] for _ in range(num_cameras): camera_properties = read_next_bytes( fid, num_bytes=24, format_char_sequence="iiQQ") camera_id = camera_properties[0] model_id = camera_properties[1] model_name = CAMERA_MODEL_IDS[camera_properties[1]].model_name width = camera_properties[2] height = camera_properties[3] num_params = CAMERA_MODEL_IDS[model_id].num_params params = read_next_bytes(fid, num_bytes=8*num_params, format_char_sequence="d"*num_params) cameras[camera_id] = Camera(id=camera_id, model=model_name, width=width, height=height, params=np.array(params)) assert len(cameras) == num_cameras return cameras def read_extrinsics_text(path): """ Taken from https://github.com/colmap/colmap/blob/dev/scripts/python/read_write_model.py """ images = {} with open(path, "r") as fid: while True: line = fid.readline() if not line: break line = line.strip() if len(line) > 0 and line[0] != "#": elems = line.split() image_id = int(elems[0]) qvec = np.array(tuple(map(float, elems[1:5]))) tvec = np.array(tuple(map(float, elems[5:8]))) camera_id = int(elems[8]) image_name = elems[9] elems = fid.readline().split() xys = np.column_stack([tuple(map(float, elems[0::3])), tuple(map(float, elems[1::3]))]) point3D_ids = np.array(tuple(map(int, elems[2::3]))) images[image_id] = Image( id=image_id, qvec=qvec, tvec=tvec, camera_id=camera_id, name=image_name, xys=xys, point3D_ids=point3D_ids) return images def read_colmap_bin_array(path): """ Taken from https://github.com/colmap/colmap/blob/dev/scripts/python/read_dense.py :param path: path to the colmap binary file. :return: nd array with the floating point values in the value """ with open(path, "rb") as fid: width, height, channels = np.genfromtxt(fid, delimiter="&", max_rows=1, usecols=(0, 1, 2), dtype=int) fid.seek(0) num_delimiter = 0 byte = fid.read(1) while True: if byte == b"&": num_delimiter += 1 if num_delimiter >= 3: break byte = fid.read(1) array = np.fromfile(fid, np.float32) array = array.reshape((width, height, channels), order="F") return np.transpose(array, (1, 0, 2)).squeeze() ================================================ FILE: scene/dataset_readers.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import os import sys from PIL import Image from typing import NamedTuple from scene.colmap_loader import read_extrinsics_text, read_intrinsics_text, qvec2rotmat, \ read_extrinsics_binary, read_intrinsics_binary, read_points3D_binary, read_points3D_text from utils.graphics_utils import getWorld2View2, focal2fov, fov2focal import numpy as np import json from pathlib import Path from plyfile import PlyData, PlyElement from utils.sh_utils import SH2RGB from scene.gaussian_model import BasicPointCloud import pdb class CameraInfo(NamedTuple): uid: int R: np.array T: np.array FovY: np.array FovX: np.array image: np.array image_path: str image_name: str width: int height: int objects: np.array class SceneInfo(NamedTuple): point_cloud: BasicPointCloud train_cameras: list test_cameras: list nerf_normalization: dict ply_path: str def getNerfppNorm(cam_info): def get_center_and_diag(cam_centers): cam_centers = np.hstack(cam_centers) avg_cam_center = np.mean(cam_centers, axis=1, keepdims=True) center = avg_cam_center dist = np.linalg.norm(cam_centers - center, axis=0, keepdims=True) diagonal = np.max(dist) return center.flatten(), diagonal cam_centers = [] for cam in cam_info: W2C = getWorld2View2(cam.R, cam.T) C2W = np.linalg.inv(W2C) cam_centers.append(C2W[:3, 3:4]) center, diagonal = get_center_and_diag(cam_centers) radius = diagonal * 1.1 translate = -center return {"translate": translate, "radius": radius} def readColmapCameras(cam_extrinsics, cam_intrinsics, images_folder, objects_folder): cam_infos = [] for idx, key in enumerate(cam_extrinsics): sys.stdout.write('\r') # the exact output you're looking for: sys.stdout.write("Reading camera {}/{}".format(idx+1, len(cam_extrinsics))) sys.stdout.flush() extr = cam_extrinsics[key] intr = cam_intrinsics[extr.camera_id] height = intr.height width = intr.width uid = intr.id R = np.transpose(qvec2rotmat(extr.qvec)) T = np.array(extr.tvec) # pdb.set_trace() if intr.model=="SIMPLE_PINHOLE": focal_length_x = intr.params[0] FovY = focal2fov(focal_length_x, height) FovX = focal2fov(focal_length_x, width) elif intr.model=="PINHOLE": focal_length_x = intr.params[0] focal_length_y = intr.params[1] FovY = focal2fov(focal_length_y, height) FovX = focal2fov(focal_length_x, width) elif intr.model == "SIMPLE_RADIAL": focal_length = intr.params[0] FovY = focal2fov(focal_length, height) FovX = focal2fov(focal_length, width) else: assert False, "Colmap camera model not handled: only undistorted datasets (PINHOLE or SIMPLE_PINHOLE cameras) supported!" image_path = os.path.join(images_folder, os.path.basename(extr.name)) image_name = os.path.basename(image_path).split(".")[0] image = Image.open(image_path) object_path = os.path.join(objects_folder, image_name + '.png') objects = Image.open(object_path) if os.path.exists(object_path) else None # here both R and T, are w2c. --- convert to --> c2w cam_info = CameraInfo(uid=uid, R=R, T=T, FovY=FovY, FovX=FovX, image=image, image_path=image_path, image_name=image_name, width=width, height=height, objects=objects) cam_infos.append(cam_info) sys.stdout.write('\n') return cam_infos def fetchPly(path): plydata = PlyData.read(path) vertices = plydata['vertex'] positions = np.vstack([vertices['x'], vertices['y'], vertices['z']]).T colors = np.vstack([vertices['red'], vertices['green'], vertices['blue']]).T / 255.0 normals = np.vstack([vertices['nx'], vertices['ny'], vertices['nz']]).T return BasicPointCloud(points=positions, colors=colors, normals=normals) def storePly(path, xyz, rgb): # Define the dtype for the structured array dtype = [('x', 'f4'), ('y', 'f4'), ('z', 'f4'), ('nx', 'f4'), ('ny', 'f4'), ('nz', 'f4'), ('red', 'u1'), ('green', 'u1'), ('blue', 'u1')] normals = np.zeros_like(xyz) elements = np.empty(xyz.shape[0], dtype=dtype) attributes = np.concatenate((xyz, normals, rgb), axis=1) elements[:] = list(map(tuple, attributes)) # Create the PlyData object and write to file vertex_element = PlyElement.describe(elements, 'vertex') ply_data = PlyData([vertex_element]) ply_data.write(path) def readColmapSceneInfo(path, images, eval, object_path, llffhold=8): try: cameras_extrinsic_file = os.path.join(path, "sparse/0", "images.bin") cameras_intrinsic_file = os.path.join(path, "sparse/0", "cameras.bin") cam_extrinsics = read_extrinsics_binary(cameras_extrinsic_file) cam_intrinsics = read_intrinsics_binary(cameras_intrinsic_file) except: cameras_extrinsic_file = os.path.join(path, "sparse/0", "images.txt") cameras_intrinsic_file = os.path.join(path, "sparse/0", "cameras.txt") cam_extrinsics = read_extrinsics_text(cameras_extrinsic_file) cam_intrinsics = read_intrinsics_text(cameras_intrinsic_file) reading_dir = "images" if images == None else images object_dir = 'object_mask' if object_path == None else object_path cam_infos_unsorted = readColmapCameras(cam_extrinsics=cam_extrinsics, cam_intrinsics=cam_intrinsics, images_folder=os.path.join(path, reading_dir), objects_folder=os.path.join(path, object_dir)) cam_infos = sorted(cam_infos_unsorted.copy(), key = lambda x : x.image_name) if eval: train_cam_infos = [c for idx, c in enumerate(cam_infos) if idx % llffhold != 0] test_cam_infos = [c for idx, c in enumerate(cam_infos) if idx % llffhold == 0] else: train_cam_infos = cam_infos test_cam_infos = [] nerf_normalization = getNerfppNorm(train_cam_infos) ply_path = os.path.join(path, "sparse/0/points3D.ply") bin_path = os.path.join(path, "sparse/0/points3D.bin") txt_path = os.path.join(path, "sparse/0/points3D.txt") if not os.path.exists(ply_path): print("Converting point3d.bin to .ply, will happen only the first time you open the scene.") try: xyz, rgb, _ = read_points3D_binary(bin_path) except: xyz, rgb, _ = read_points3D_text(txt_path) storePly(ply_path, xyz, rgb) try: pcd = fetchPly(ply_path) except: pcd = None scene_info = SceneInfo(point_cloud=pcd, train_cameras=train_cam_infos, test_cameras=test_cam_infos, nerf_normalization=nerf_normalization, ply_path=ply_path) return scene_info def readCamerasFromTransforms(path, transformsfile, white_background, extension=".png"): cam_infos = [] with open(os.path.join(path, transformsfile)) as json_file: contents = json.load(json_file) fovx = contents["camera_angle_x"] frames = contents["frames"] for idx, frame in enumerate(frames): cam_name = os.path.join(path, frame["file_path"] + extension) # NeRF 'transform_matrix' is a camera-to-world transform c2w = np.array(frame["transform_matrix"]) # change from OpenGL/Blender camera axes (Y up, Z back) to COLMAP (Y down, Z forward) c2w[:3, 1:3] *= -1 # get the world-to-camera transform and set R, T w2c = np.linalg.inv(c2w) R = np.transpose(w2c[:3,:3]) # R is stored transposed due to 'glm' in CUDA code T = w2c[:3, 3] image_path = os.path.join(path, cam_name) if not os.path.isfile(image_path): image_path = os.path.join(path, "images", frame["file_path"] + extension) image_name = Path(cam_name).stem image = Image.open(image_path) im_data = np.array(image.convert("RGBA")) bg = np.array([1,1,1]) if white_background else np.array([0, 0, 0]) norm_data = im_data / 255.0 arr = norm_data[:,:,:3] * norm_data[:, :, 3:4] + bg * (1 - norm_data[:, :, 3:4]) image = Image.fromarray(np.array(arr*255.0, dtype=np.byte), "RGB") fovy = focal2fov(fov2focal(fovx, image.size[0]), image.size[1]) FovY = fovy FovX = fovx cam_infos.append(CameraInfo(uid=idx, R=R, T=T, FovY=FovY, FovX=FovX, image=image, objects=None, image_path=image_path, image_name=image_name, width=image.size[0], height=image.size[1])) return cam_infos def readNerfSyntheticInfo(path, white_background, eval, extension=".png"): # print("Reading Training Transforms") train_cam_infos = readCamerasFromTransforms(path, "transforms_train.json", white_background, extension) # print("Reading Test Transforms") test_cam_infos = readCamerasFromTransforms(path, "transforms_test.json", white_background, extension) if not eval: train_cam_infos.extend(test_cam_infos) test_cam_infos = [] nerf_normalization = getNerfppNorm(train_cam_infos) ply_path = os.path.join(path, "points3d.ply") if not os.path.exists(ply_path): # Since this data set has no colmap data, we start with random points # num_pts = 100_000 num_pts = 5000 print(f"Generating random point cloud ({num_pts})...") # We create random points inside the bounds of the synthetic Blender scenes xyz = np.random.random((num_pts, 3)) * 2.6 - 1.3 shs = np.random.random((num_pts, 3)) / 255.0 pcd = BasicPointCloud(points=xyz, colors=SH2RGB(shs), normals=np.zeros((num_pts, 3))) storePly(ply_path, xyz, SH2RGB(shs) * 255) try: pcd = fetchPly(ply_path) except: pcd = None scene_info = SceneInfo(point_cloud=pcd, train_cameras=train_cam_infos, test_cameras=test_cam_infos, nerf_normalization=nerf_normalization, ply_path=ply_path) return scene_info sceneLoadTypeCallbacks = { "Colmap": readColmapSceneInfo, "Blender" : readNerfSyntheticInfo } ================================================ FILE: scene/gaussian_model.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import torch import numpy as np from utils.general_utils import inverse_sigmoid, get_expon_lr_func, build_rotation from torch import nn import os from utils.system_utils import mkdir_p from plyfile import PlyData, PlyElement from utils.sh_utils import RGB2SH from simple_knn._C import distCUDA2 from utils.graphics_utils import BasicPointCloud from utils.general_utils import strip_symmetric, build_scaling_rotation import pdb import random class GaussianModel: def setup_functions(self): def build_covariance_from_scaling_rotation(scaling, scaling_modifier, rotation): L = build_scaling_rotation(scaling_modifier * scaling, rotation) actual_covariance = L @ L.transpose(1, 2) symm = strip_symmetric(actual_covariance) return symm self.scaling_activation = torch.exp self.scaling_inverse_activation = torch.log self.covariance_activation = build_covariance_from_scaling_rotation self.opacity_activation = torch.sigmoid self.inverse_opacity_activation = inverse_sigmoid self.rotation_activation = torch.nn.functional.normalize def __init__(self, sh_degree : int): self.active_sh_degree = 0 self.max_sh_degree = sh_degree self._xyz = torch.empty(0) self._features_dc = torch.empty(0) self._features_rest = torch.empty(0) self._scaling = torch.empty(0) self._rotation = torch.empty(0) self._opacity = torch.empty(0) self.max_radii2D = torch.empty(0) self.xyz_gradient_accum = torch.empty(0) self.denom = torch.empty(0) self.optimizer = None self.percent_dense = 0 self.spatial_lr_scale = 0 self.setup_functions() def capture(self): return ( self.active_sh_degree, self._xyz, self._features_dc, self._features_rest, self._scaling, self._rotation, self._opacity, self.max_radii2D, self.xyz_gradient_accum, self.denom, self.optimizer.state_dict(), self.spatial_lr_scale, ) def restore(self, model_args, training_args): (self.active_sh_degree, self._xyz, self._features_dc, self._features_rest, self._scaling, self._rotation, self._opacity, self.max_radii2D, xyz_gradient_accum, denom, opt_dict, self.spatial_lr_scale) = model_args self.training_setup(training_args) self.xyz_gradient_accum = xyz_gradient_accum self.denom = denom self.optimizer.load_state_dict(opt_dict) @property def get_scaling(self): return self.scaling_activation(self._scaling) @property def get_rotation(self): return self.rotation_activation(self._rotation) @property def get_xyz(self): return self._xyz @property def get_features(self): features_dc = self._features_dc features_rest = self._features_rest return torch.cat((features_dc, features_rest), dim=1) @property def get_opacity(self): return self.opacity_activation(self._opacity) def get_covariance(self, scaling_modifier = 1): return self.covariance_activation(self.get_scaling, scaling_modifier, self._rotation) def oneupSHdegree(self): if self.active_sh_degree < self.max_sh_degree: self.active_sh_degree += 1 def create_from_pcd(self, pcd : BasicPointCloud, spatial_lr_scale : float): self.spatial_lr_scale = spatial_lr_scale fused_point_cloud = torch.tensor(np.asarray(pcd.points)).float().cuda() fused_color = RGB2SH(torch.tensor(np.asarray(pcd.colors)).float().cuda()) features = torch.zeros((fused_color.shape[0], 3, (self.max_sh_degree + 1) ** 2)).float().cuda() features[:, :3, 0 ] = fused_color features[:, 3:, 1:] = 0.0 print("Number of points at initialisation : ", fused_point_cloud.shape[0]) dist2 = torch.clamp_min(distCUDA2(torch.from_numpy(np.asarray(pcd.points)).float().cuda()), 0.0000001) scales = torch.log(torch.sqrt(dist2))[...,None].repeat(1, 3) rots = torch.zeros((fused_point_cloud.shape[0], 4), device="cuda") rots[:, 0] = 1 opacities = inverse_sigmoid(0.1 * torch.ones((fused_point_cloud.shape[0], 1), dtype=torch.float, device="cuda")) self._xyz = nn.Parameter(fused_point_cloud.requires_grad_(True)) self._features_dc = nn.Parameter(features[:,:,0:1].transpose(1, 2).contiguous().requires_grad_(True)) self._features_rest = nn.Parameter(features[:,:,1:].transpose(1, 2).contiguous().requires_grad_(True)) self._scaling = nn.Parameter(scales.requires_grad_(True)) self._rotation = nn.Parameter(rots.requires_grad_(True)) self._opacity = nn.Parameter(opacities.requires_grad_(True)) self.max_radii2D = torch.zeros((self.get_xyz.shape[0]), device="cuda") def training_setup(self, training_args): self.percent_dense = training_args.percent_dense self.xyz_gradient_accum = torch.zeros((self.get_xyz.shape[0], 1), device="cuda") self.denom = torch.zeros((self.get_xyz.shape[0], 1), device="cuda") l = [ {'params': [self._xyz], 'lr': training_args.position_lr_init * self.spatial_lr_scale, "name": "xyz"}, {'params': [self._features_dc], 'lr': training_args.feature_lr, "name": "f_dc"}, {'params': [self._features_rest], 'lr': training_args.feature_lr / 20.0, "name": "f_rest"}, {'params': [self._opacity], 'lr': training_args.opacity_lr, "name": "opacity"}, {'params': [self._scaling], 'lr': training_args.scaling_lr, "name": "scaling"}, {'params': [self._rotation], 'lr': training_args.rotation_lr, "name": "rotation"} ] self.optimizer = torch.optim.Adam(l, lr=0.0, eps=1e-15) self.xyz_scheduler_args = get_expon_lr_func(lr_init=training_args.position_lr_init*self.spatial_lr_scale, lr_final=training_args.position_lr_final*self.spatial_lr_scale, lr_delay_mult=training_args.position_lr_delay_mult, max_steps=training_args.position_lr_max_steps) def inpaint_setup(self, training_args, mask3d): def initialize_new_features(features, num_new_points, mask_xyz_values, distance_threshold=0.25, max_distance_threshold=1, k=5): """Initialize new points for multiple features based on neighbouring points in the remaining area.""" new_features = {} if num_new_points == 0: for key in features: new_features[key] = torch.empty((0, *features[key].shape[1:]), device=features[key].device) return new_features # Get remaining points from features remaining_xyz_values = features["xyz"] remaining_xyz_values_np = remaining_xyz_values.cpu().numpy() # Build a KD-Tree for fast nearest-neighbor lookup from scipy.spatial import KDTree kdtree = KDTree(remaining_xyz_values_np) # Sample random points from mask_xyz_values as query points mask_xyz_values_np = mask_xyz_values.cpu().numpy() query_points = mask_xyz_values_np # Find the k nearest neighbors in the remaining points for each query point distances, indices = kdtree.query(query_points, k=k) selected_indices = indices # Initialize new points for each feature for key, feature in features.items(): # Convert feature to numpy array feature_np = feature.cpu().numpy() # If we have valid neighbors, calculate the mean of neighbor points if feature_np.ndim == 2: neighbor_points = feature_np[selected_indices] elif feature_np.ndim == 3: neighbor_points = feature_np[selected_indices, :, :] else: raise ValueError(f"Unsupported feature dimension: {feature_np.ndim}") new_points_np = np.mean(neighbor_points, axis=1) # Convert back to tensor new_features[key] = torch.tensor(new_points_np, device=feature.device, dtype=feature.dtype) return new_features['xyz'], new_features['features_dc'], new_features['scaling'], new_features['features_rest'], new_features['opacity'], new_features['rotation'] mask3d = ~mask3d.squeeze() # True -> False mask_xyz_values = self._xyz[~mask3d] # False -> True # Extracting subsets using the mask xyz_sub = self._xyz[mask3d].detach() features_dc_sub = self._features_dc[mask3d].detach() features_rest_sub = self._features_rest[mask3d].detach() opacity_sub = self._opacity[mask3d].detach() scaling_sub = self._scaling[mask3d].detach() rotation_sub = self._rotation[mask3d].detach() # Add new points with random initialization sub_features = { 'xyz': xyz_sub, 'features_dc': features_dc_sub, 'scaling': scaling_sub, 'features_rest': features_rest_sub, 'opacity': opacity_sub, 'rotation': rotation_sub, } num_new_points = len(mask_xyz_values) with torch.no_grad(): new_xyz, new_features_dc, new_scaling, new_features_rest, new_opacity, new_rotation = initialize_new_features(sub_features, num_new_points, mask_xyz_values) def set_requires_grad(tensor, requires_grad): """Returns a new tensor with the specified requires_grad setting.""" return tensor.detach().clone().requires_grad_(requires_grad) # Construct nn.Parameters with specified gradients self._xyz = nn.Parameter(torch.cat([set_requires_grad(xyz_sub, False), set_requires_grad(new_xyz, True)])) self._features_dc = nn.Parameter(torch.cat([set_requires_grad(features_dc_sub, False), set_requires_grad(new_features_dc, True)])) self._features_rest = nn.Parameter(torch.cat([set_requires_grad(features_rest_sub, False), set_requires_grad(new_features_rest, True)])) self._opacity = nn.Parameter(torch.cat([set_requires_grad(opacity_sub, False), set_requires_grad(new_opacity, True)])) self._scaling = nn.Parameter(torch.cat([set_requires_grad(scaling_sub, False), set_requires_grad(new_scaling, True)])) self._rotation = nn.Parameter(torch.cat([set_requires_grad(rotation_sub, False), set_requires_grad(new_rotation, True)])) # for optimize self.max_radii2D = torch.zeros((self.get_xyz.shape[0]), device="cuda") self.percent_dense = training_args.percent_dense self.xyz_gradient_accum = torch.zeros((self.get_xyz.shape[0], 1), device="cuda") self.denom = torch.zeros((self.get_xyz.shape[0], 1), device="cuda") # Setup optimizer. Only the new points will have gradients. l = [ {'params': [self._xyz], 'lr': training_args.position_lr_init * self.spatial_lr_scale, "name": "xyz"}, {'params': [self._features_dc], 'lr': training_args.feature_lr, "name": "f_dc"}, {'params': [self._features_rest], 'lr': training_args.feature_lr / 20.0, "name": "f_rest"}, {'params': [self._opacity], 'lr': training_args.opacity_lr, "name": "opacity"}, {'params': [self._scaling], 'lr': training_args.scaling_lr, "name": "scaling"}, {'params': [self._rotation], 'lr': training_args.rotation_lr, "name": "rotation"}, ] self.optimizer = torch.optim.Adam(l, lr=0.0, eps=1e-15) def update_learning_rate(self, iteration): ''' Learning rate scheduling per step ''' for param_group in self.optimizer.param_groups: if param_group["name"] == "xyz": lr = self.xyz_scheduler_args(iteration) param_group['lr'] = lr return lr def construct_list_of_attributes(self): l = ['x', 'y', 'z', 'nx', 'ny', 'nz'] # All channels except the 3 DC for i in range(self._features_dc.shape[1]*self._features_dc.shape[2]): l.append('f_dc_{}'.format(i)) for i in range(self._features_rest.shape[1]*self._features_rest.shape[2]): l.append('f_rest_{}'.format(i)) l.append('opacity') for i in range(self._scaling.shape[1]): l.append('scale_{}'.format(i)) for i in range(self._rotation.shape[1]): l.append('rot_{}'.format(i)) return l def save_ply(self, path): mkdir_p(os.path.dirname(path)) xyz = self._xyz.detach().cpu().numpy() normals = np.zeros_like(xyz) f_dc = self._features_dc.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu().numpy() f_rest = self._features_rest.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu().numpy() opacities = self._opacity.detach().cpu().numpy() scale = self._scaling.detach().cpu().numpy() rotation = self._rotation.detach().cpu().numpy() dtype_full = [(attribute, 'f4') for attribute in self.construct_list_of_attributes()] elements = np.empty(xyz.shape[0], dtype=dtype_full) attributes = np.concatenate((xyz, normals, f_dc, f_rest, opacities, scale, rotation), axis=1) elements[:] = list(map(tuple, attributes)) el = PlyElement.describe(elements, 'vertex') PlyData([el]).write(path) def reset_opacity(self): opacities_new = inverse_sigmoid(torch.min(self.get_opacity, torch.ones_like(self.get_opacity)*0.01)) optimizable_tensors = self.replace_tensor_to_optimizer(opacities_new, "opacity") self._opacity = optimizable_tensors["opacity"] def load_ply(self, path): plydata = PlyData.read(path) xyz = np.stack((np.asarray(plydata.elements[0]["x"]), np.asarray(plydata.elements[0]["y"]), np.asarray(plydata.elements[0]["z"])), axis=1) opacities = np.asarray(plydata.elements[0]["opacity"])[..., np.newaxis] features_dc = np.zeros((xyz.shape[0], 3, 1)) features_dc[:, 0, 0] = np.asarray(plydata.elements[0]["f_dc_0"]) features_dc[:, 1, 0] = np.asarray(plydata.elements[0]["f_dc_1"]) features_dc[:, 2, 0] = np.asarray(plydata.elements[0]["f_dc_2"]) extra_f_names = [p.name for p in plydata.elements[0].properties if p.name.startswith("f_rest_")] extra_f_names = sorted(extra_f_names, key = lambda x: int(x.split('_')[-1])) assert len(extra_f_names)==3*(self.max_sh_degree + 1) ** 2 - 3 features_extra = np.zeros((xyz.shape[0], len(extra_f_names))) for idx, attr_name in enumerate(extra_f_names): features_extra[:, idx] = np.asarray(plydata.elements[0][attr_name]) # Reshape (P,F*SH_coeffs) to (P, F, SH_coeffs except DC) features_extra = features_extra.reshape((features_extra.shape[0], 3, (self.max_sh_degree + 1) ** 2 - 1)) scale_names = [p.name for p in plydata.elements[0].properties if p.name.startswith("scale_")] scale_names = sorted(scale_names, key = lambda x: int(x.split('_')[-1])) scales = np.zeros((xyz.shape[0], len(scale_names))) for idx, attr_name in enumerate(scale_names): scales[:, idx] = np.asarray(plydata.elements[0][attr_name]) rot_names = [p.name for p in plydata.elements[0].properties if p.name.startswith("rot")] rot_names = sorted(rot_names, key = lambda x: int(x.split('_')[-1])) rots = np.zeros((xyz.shape[0], len(rot_names))) for idx, attr_name in enumerate(rot_names): rots[:, idx] = np.asarray(plydata.elements[0][attr_name]) self._xyz = nn.Parameter(torch.tensor(xyz, dtype=torch.float, device="cuda").requires_grad_(True)) self._features_dc = nn.Parameter(torch.tensor(features_dc, dtype=torch.float, device="cuda").transpose(1, 2).contiguous().requires_grad_(True)) self._features_rest = nn.Parameter(torch.tensor(features_extra, dtype=torch.float, device="cuda").transpose(1, 2).contiguous().requires_grad_(True)) self._opacity = nn.Parameter(torch.tensor(opacities, dtype=torch.float, device="cuda").requires_grad_(True)) self._scaling = nn.Parameter(torch.tensor(scales, dtype=torch.float, device="cuda").requires_grad_(True)) self._rotation = nn.Parameter(torch.tensor(rots, dtype=torch.float, device="cuda").requires_grad_(True)) self.active_sh_degree = self.max_sh_degree def replace_tensor_to_optimizer(self, tensor, name): optimizable_tensors = {} for group in self.optimizer.param_groups: if group["name"] == name: stored_state = self.optimizer.state.get(group['params'][0], None) stored_state["exp_avg"] = torch.zeros_like(tensor) stored_state["exp_avg_sq"] = torch.zeros_like(tensor) del self.optimizer.state[group['params'][0]] group["params"][0] = nn.Parameter(tensor.requires_grad_(True)) self.optimizer.state[group['params'][0]] = stored_state optimizable_tensors[group["name"]] = group["params"][0] return optimizable_tensors def _prune_optimizer(self, mask): optimizable_tensors = {} for group in self.optimizer.param_groups: stored_state = self.optimizer.state.get(group['params'][0], None) if stored_state is not None: stored_state["exp_avg"] = stored_state["exp_avg"][mask] stored_state["exp_avg_sq"] = stored_state["exp_avg_sq"][mask] del self.optimizer.state[group['params'][0]] group["params"][0] = nn.Parameter((group["params"][0][mask].requires_grad_(True))) self.optimizer.state[group['params'][0]] = stored_state optimizable_tensors[group["name"]] = group["params"][0] else: group["params"][0] = nn.Parameter(group["params"][0][mask].requires_grad_(True)) optimizable_tensors[group["name"]] = group["params"][0] return optimizable_tensors def prune_points(self, mask): valid_points_mask = ~mask optimizable_tensors = self._prune_optimizer(valid_points_mask) self._xyz = optimizable_tensors["xyz"] self._features_dc = optimizable_tensors["f_dc"] self._features_rest = optimizable_tensors["f_rest"] self._opacity = optimizable_tensors["opacity"] self._scaling = optimizable_tensors["scaling"] self._rotation = optimizable_tensors["rotation"] self.xyz_gradient_accum = self.xyz_gradient_accum[valid_points_mask] self.denom = self.denom[valid_points_mask] self.max_radii2D = self.max_radii2D[valid_points_mask] def cat_tensors_to_optimizer(self, tensors_dict): optimizable_tensors = {} for group in self.optimizer.param_groups: assert len(group["params"]) == 1 extension_tensor = tensors_dict[group["name"]] stored_state = self.optimizer.state.get(group['params'][0], None) if stored_state is not None: stored_state["exp_avg"] = torch.cat((stored_state["exp_avg"], torch.zeros_like(extension_tensor)), dim=0) stored_state["exp_avg_sq"] = torch.cat((stored_state["exp_avg_sq"], torch.zeros_like(extension_tensor)), dim=0) del self.optimizer.state[group['params'][0]] group["params"][0] = nn.Parameter(torch.cat((group["params"][0], extension_tensor), dim=0).requires_grad_(True)) self.optimizer.state[group['params'][0]] = stored_state optimizable_tensors[group["name"]] = group["params"][0] else: group["params"][0] = nn.Parameter(torch.cat((group["params"][0], extension_tensor), dim=0).requires_grad_(True)) optimizable_tensors[group["name"]] = group["params"][0] return optimizable_tensors def densification_postfix(self, new_xyz, new_features_dc, new_features_rest, new_opacities, new_scaling, new_rotation): d = {"xyz": new_xyz, "f_dc": new_features_dc, "f_rest": new_features_rest, "opacity": new_opacities, "scaling" : new_scaling, "rotation" : new_rotation} optimizable_tensors = self.cat_tensors_to_optimizer(d) self._xyz = optimizable_tensors["xyz"] self._features_dc = optimizable_tensors["f_dc"] self._features_rest = optimizable_tensors["f_rest"] self._opacity = optimizable_tensors["opacity"] self._scaling = optimizable_tensors["scaling"] self._rotation = optimizable_tensors["rotation"] self.xyz_gradient_accum = torch.zeros((self.get_xyz.shape[0], 1), device="cuda") self.denom = torch.zeros((self.get_xyz.shape[0], 1), device="cuda") self.max_radii2D = torch.zeros((self.get_xyz.shape[0]), device="cuda") def densify_and_split(self, grads, grad_threshold, scene_extent, N=2, limit_num=-1): n_init_points = self.get_xyz.shape[0] # Extract points that satisfy the gradient condition padded_grad = torch.zeros((n_init_points), device="cuda") padded_grad[:grads.shape[0]] = grads.squeeze() selected_pts_mask = torch.where(padded_grad >= grad_threshold, True, False) selected_pts_mask = torch.logical_and(selected_pts_mask, torch.max(self.get_scaling, dim=1).values > self.percent_dense*scene_extent) if limit_num > 0: idx = padded_grad.argsort(dim=0, descending=True) sorted_pts_mask = torch.zeros(padded_grad.size(0), dtype=torch.bool, device=grads.device) inc_num = limit_num - self.get_num_pts if inc_num <= 0: return inc_num = min(inc_num, selected_pts_mask.sum().item()) # inc_num = int(inc_num * random.random()) sorted_pts_mask[idx[:inc_num]] = 1 selected_pts_mask = torch.logical_and(selected_pts_mask, sorted_pts_mask) stds = self.get_scaling[selected_pts_mask].repeat(N,1) means =torch.zeros((stds.size(0), 3),device="cuda") samples = torch.normal(mean=means, std=stds) rots = build_rotation(self._rotation[selected_pts_mask]).repeat(N,1,1) new_xyz = torch.bmm(rots, samples.unsqueeze(-1)).squeeze(-1) + self.get_xyz[selected_pts_mask].repeat(N, 1) new_scaling = self.scaling_inverse_activation(self.get_scaling[selected_pts_mask].repeat(N,1) / (0.8*N)) new_rotation = self._rotation[selected_pts_mask].repeat(N,1) new_features_dc = self._features_dc[selected_pts_mask].repeat(N,1,1) new_features_rest = self._features_rest[selected_pts_mask].repeat(N,1,1) new_opacity = self._opacity[selected_pts_mask].repeat(N,1) self.densification_postfix(new_xyz, new_features_dc, new_features_rest, new_opacity, new_scaling, new_rotation) prune_filter = torch.cat((selected_pts_mask, torch.zeros(N * selected_pts_mask.sum(), device="cuda", dtype=bool))) self.prune_points(prune_filter) def densify_and_clone(self, grads, grad_threshold, scene_extent, limit_num): # Extract points that satisfy the gradient condition selected_pts_mask = torch.where(torch.norm(grads, dim=-1) >= grad_threshold, True, False) selected_pts_mask = torch.logical_and(selected_pts_mask, torch.max(self.get_scaling, dim=1).values <= self.percent_dense*scene_extent) if limit_num > 0: idx = grads.argsort(dim=0, descending=True) sorted_pts_mask = torch.zeros(grads.size(0), dtype=torch.bool, device=grads.device) inc_num = limit_num - self.get_num_pts if inc_num <= 0: return inc_num = min(inc_num, selected_pts_mask.sum().item()) # inc_num = int(inc_num * random.random()) sorted_pts_mask[idx[:inc_num]] = 1 selected_pts_mask = torch.logical_and(selected_pts_mask, sorted_pts_mask) new_xyz = self._xyz[selected_pts_mask] new_features_dc = self._features_dc[selected_pts_mask] new_features_rest = self._features_rest[selected_pts_mask] new_opacities = self._opacity[selected_pts_mask] new_scaling = self._scaling[selected_pts_mask] new_rotation = self._rotation[selected_pts_mask] self.densification_postfix(new_xyz, new_features_dc, new_features_rest, new_opacities, new_scaling, new_rotation) def densify_and_prune(self, max_grad, min_opacity, extent, max_screen_size, limit_num=-1): grads = self.xyz_gradient_accum / self.denom grads[grads.isnan()] = 0.0 if ((limit_num > 0) and (self.get_num_pts < limit_num)) or (limit_num < 0): self.densify_and_clone(grads, max_grad, extent, limit_num=limit_num) self.densify_and_split(grads, max_grad, extent, limit_num=limit_num) prune_mask = (self.get_opacity < min_opacity).squeeze() if max_screen_size: big_points_vs = self.max_radii2D > max_screen_size big_points_ws = self.get_scaling.max(dim=1).values > 0.1 * extent prune_mask = torch.logical_or(torch.logical_or(prune_mask, big_points_vs), big_points_ws) self.prune_points(prune_mask) # elif (limit_num > 0) and (self.get_num_pts >= limit_num): # prune_mask = (self.get_opacity < min_opacity).squeeze() # if max_screen_size: # big_points_vs = self.max_radii2D > max_screen_size # big_points_ws = self.get_scaling.max(dim=1).values > 0.1 * extent # prune_mask = torch.logical_or(torch.logical_or(prune_mask, big_points_vs), big_points_ws) # self.prune_points(prune_mask) # self.densify_and_clone(grads[~prune_mask], max_grad, extent, limit_num=limit_num) # self.densify_and_split(grads[~prune_mask], max_grad, extent, limit_num=limit_num) torch.cuda.empty_cache() def add_densification_stats(self, viewspace_point_tensor, update_filter): self.xyz_gradient_accum[update_filter] += torch.norm(viewspace_point_tensor.grad[update_filter,:2], dim=-1, keepdim=True) self.denom[update_filter] += 1 @property def get_num_pts(self): return self._xyz.size(0) ================================================ FILE: scripts/bear_color.sh ================================================ #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=0 python colormask.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/bear/ \ -m ./output/bear-recon-only/ \ --skip_test \ --slackness 0.8 \ --view_num -1 \ --obj_num 1 \ --white_background \ -r 2 # --object_path inpaint_object_mask_255 \ ================================================ FILE: scripts/bear_inpaint.sh ================================================ export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=0 python edit_object_inpaint.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/bear/ \ --image images_inpaint_unseen \ -m ./output/bear-recon-only/ \ --skip_test \ --view_num -1 \ --obj_num 1 \ --white_background \ --object_path inpaint_object_mask_255 \ --finetune_iteration 10000 \ --obj_id 1 \ ================================================ FILE: scripts/bear_removal.sh ================================================ python objremoval.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/bear/ \ -m ./output/bear-recon-only/ \ --skip_test \ --slackness -0.8 \ --view_num -1 \ --obj_num 256 \ --white_background \ --obj_id 34 \ ================================================ FILE: scripts/bear_seg.sh ================================================ python render.py --iteration 30000 \ -s /data/Downloads/Gaussian-Grouping/data/bear/ \ -m ./output/bear-recon-only/ \ --skip_test \ --slackness -0.7 \ --view_num -1 \ --obj_num 1 \ --obj_id -1 \ --white_background \ --object_path inpaint_object_mask_255 \ ================================================ FILE: scripts/counter_color.sh ================================================ python colormask.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/mipnerf360/counter \ -m ./output/counter-recon-only/ \ --skip_test \ --slackness 0.88 \ --view_num -1 \ --obj_num 256 \ --white_background \ -r 2 # --object_path inpaint_object_mask_255 \ ================================================ FILE: scripts/counter_remove.sh ================================================ #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=0 python objremoval.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/mipnerf360/counter \ -m ./output/counter-recon-only/ \ --skip_test \ --slackness -0.9 \ --view_num -1 \ --obj_num 256 \ --obj_id 4 39 45 54 102 \ -r 2 \ # --white_background \ ================================================ FILE: scripts/counter_seg.sh ================================================ #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=0 python render.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/mipnerf360/counter/ \ -m ./output/counter-recon-only \ --skip_test \ --slackness 0.4 \ --view_num 1 \ --obj_num 256 \ --white_background \ --obj_id 4 \ # --object_path inpaint_object_mask_255 \ ================================================ FILE: scripts/figurines_color.sh ================================================ #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=0 python colormask.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/lerf_mask/figurines \ -m ./output/figurines-recon-only2/ \ --skip_test \ --slackness 0.8 \ --view_num -1 \ --obj_num 256 \ --white_background \ # --object_path inpaint_object_mask_255 \ ================================================ FILE: scripts/figurines_remove.sh ================================================ python objremoval.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/lerf_mask/figurines/ \ -m ./output/figurines-recon-only2/ \ --skip_test \ --slackness -0.9 \ --view_num -1 \ --obj_num 256 \ --white_background \ --obj_id 36 49 55 63 65 43\ ================================================ FILE: scripts/figurines_seg.sh ================================================ python render.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/lerf_mask/figurines/ \ -m ./output/figurines-recon-only2/ \ --skip_test \ --slackness 0.75 \ --view_num -1 \ --obj_num 256 \ --white_background \ --obj_id 47 \ ================================================ FILE: scripts/figurines_train.sh ================================================ #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=0 python train.py -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/lerf_mask/figurines/ \ --model_path ./output/figurines-recon-only2 \ --limit_num -1 --port 20001 \ --densify_until_iter 10000 \ ================================================ FILE: scripts/garden_train.sh ================================================ #! /bin/bash # export OPENCV_IO_ENABLE_OPENEXR=1 # export CUDA_VISIBLE_DEVICES=0 # python train.py -s /home/shenqiuhong/Downloads/mip360/garden \ # --model_path ./output/garden-recon-only \ # --limit_num -1 --port 20001 \ # --densify_until_iter 10000 \ # -r 4 # export OPENCV_IO_ENABLE_OPENEXR=1 # export CUDA_VISIBLE_DEVICES=0 # python train.py -s /home/shenqiuhong/Downloads/mip360/room/ \ # --model_path ./output/room-recon-only \ # --limit_num -1 --port 20001 \ # --densify_until_iter 10000 \ # -r 4 export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=0 python train.py -s /home/shenqiuhong/Downloads/mip360/bonsai/ \ --model_path ./output/bonsai-recon-only \ --limit_num -1 --port 20001 \ --densify_until_iter 10000 \ -r 4 ================================================ FILE: scripts/genmask_truck.sh ================================================ #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=1 python generate_mask.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/tandt/tandt/truck \ -m ./output/truck-recon-only \ --skip_test \ --slackness 0 \ --view_num -1 \ --obj_num 256 \ --white_background \ ================================================ FILE: scripts/horns_remove.sh ================================================ python objremoval.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/llff-gs/horns/ \ -m ./output/horns-recon-only/ \ --skip_test \ --slackness -0.98 \ --view_num -1 \ --obj_num 1 \ --obj_id 1 \ -r 4 \ # --white_background \ ================================================ FILE: scripts/horns_seg.sh ================================================ python render.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/llff-gs/horns/ \ -m ./output/horns-recon-only/ \ --skip_test \ --slackness 0.4 \ --view_num -1 \ --obj_num 1 \ --white_background \ --object_path inpaint_object_mask_255 \ --obj_id 1 \ -r 4 ================================================ FILE: scripts/kitchen_color.sh ================================================ python colormask.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/mipnerf360/kitchen/ \ -m ./output/kitchen-recon-only \ --skip_test \ --slackness 0.6 \ --view_num -1 \ --obj_num 256 \ --white_background \ -r 2 # --object_path inpaint_object_mask_255 \ ================================================ FILE: scripts/kitchen_inpaint.sh ================================================ export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=0 python edit_object_inpaint.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/mipnerf360/kitchen/ \ --image images_inpaint_unseen \ -m ./output/kitchen-recon-only \ --skip_test \ --view_num -1 \ --obj_num 1 \ --white_background \ --object_path inpaint_object_mask_255 \ --finetune_iteration 10000 \ --obj_id 1 \ -r 4 \ ================================================ FILE: scripts/kitchen_seg.sh ================================================ #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=0 python render.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/mipnerf360/kitchen/ \ -m ./output/kitchen-recon-only \ --skip_test \ --slackness -0.8 \ --obj_id 0 \ --view_num -1 \ --obj_num 1 \ --object_path inpaint_object_mask_255 \ # #! /bin/bash # export OPENCV_IO_ENABLE_OPENEXR=1 # export CUDA_VISIBLE_DEVICES=0 # python render.py --iteration 30000 \ # -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/mipnerf360/kitchen/ \ # -m ./output/kitchen-recon-only \ # --skip_test \ # --slackness 0.6 \ # --view_num -1 \ # --obj_num 256 \ # --white_background \ # # --object_path inpaint_object_mask_255 \ ================================================ FILE: scripts/kitchen_train.sh ================================================ #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=0 python train.py -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/mipnerf360/kitchen/ \ --model_path ./output/kitchen-recon-only \ --limit_num -1 --port 20009 \ --densify_until_iter 10000 \ -r 2 ================================================ FILE: scripts/lego_train.sh ================================================ #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=1 python train.py -s /home/shenqiuhong/dataset/nerf_data/nerf_synthetic/lego \ --model_path ./output/lego-recon-only \ --limit_num -1 --port 20009 \ -r 1 ================================================ FILE: scripts/llff/fern_train.sh ================================================ #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=1 python train.py -s /home/shenqiuhong/Downloads/llff-gs/flower \ --model_path ./output/flower-recon-only \ --limit_num -1 --port 20009 \ --densify_until_iter 10000 \ -r 4 #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=1 python train.py -s /home/shenqiuhong/Downloads/llff-gs/fortress \ --model_path ./output/fortress-recon-only \ --limit_num -1 --port 20009 \ --densify_until_iter 10000 \ -r 4 #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=1 python train.py -s /home/shenqiuhong/Downloads/llff-gs/trex \ --model_path ./output/trex-recon-only \ --limit_num -1 --port 20009 \ --densify_until_iter 10000 \ -r 4 ================================================ FILE: scripts/ramen_train.sh ================================================ #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=1 python train.py -s /home/shenqiuhong/Downloads/lerf_dataset/ramen \ --model_path ./output/ramen-recon-only \ --limit_num -1 --port 20002 \ --densify_until_iter 10000 \ ================================================ FILE: scripts/teatime_color.sh ================================================ python colormask.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/lerf_mask/teatime/ \ -m ./output/teatime-recon-only/ \ --skip_test \ --slackness 0.3 \ --view_num -1 \ --obj_num 256 \ --white_background \ ================================================ FILE: scripts/teatime_removal.sh ================================================ python objremoval.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/lerf_mask/teatime/ \ -m ./output/teatime-recon-only/ \ --skip_test \ --slackness -0.95 \ --view_num -1 \ --obj_num 256 \ --white_background \ --obj_id 103 \ ================================================ FILE: scripts/teatime_seg.sh ================================================ python render.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/lerf_mask/teatime/ \ -m ./output/teatime-recon-only/ \ --skip_test \ --slackness -0.9 \ --view_num -1 \ --obj_num 1 \ --white_background \ --obj_id 1 \ --object_path inpaint_object_mask_255 # python render.py --iteration 30000 \ # -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/bear/ \ # -m ./output/bear-recon-only/ \ # --skip_test \ # --slackness -0.6 \ # --view_num -1 \ # --obj_num 1 \ # --white_background \ # # --object_path inpaint_object_mask_255 \ ================================================ FILE: scripts/teatime_train.sh ================================================ #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=0 python train.py -s /home/shenqiuhong/Downloads/lerf_dataset/teatime \ --model_path ./output/teatime-recon-only \ --limit_num -1 --port 20003 \ --densify_until_iter 10000 \ ================================================ FILE: scripts/test_teatime.sh ================================================ python generate_mask.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/Gaussian-Grouping/data/lerf_mask/teatime/ \ -m ./output/teatime-recon-only/ \ --skip_test \ --slackness -0.95 \ --view_num -1 \ --obj_num 256 \ --white_background \ --obj_id 103 \ ================================================ FILE: scripts/train_train.sh ================================================ #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=1 python train.py -s /home/shenqiuhong/Downloads/tandt/tandt/train \ --model_path ./output/train-recon-only \ --limit_num -1 --port 20009 \ --densify_until_iter 10000 \ ================================================ FILE: scripts/truck_color.sh ================================================ #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=1 python colormask.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/tandt/tandt/truck \ -m ./output/truck-recon-only/ \ --skip_test \ --slackness 0.6 \ --view_num -1 \ --obj_num 1 \ --white_background \ -r 2 ================================================ FILE: scripts/truck_removal.sh ================================================ #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=1 python objremoval.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/tandt/tandt/truck \ -m ./output/truck-recon-only/ \ --skip_test \ --slackness -0.88 \ --view_num -1 \ --obj_num 1 \ --white_background \ --obj_id 1 \ ================================================ FILE: scripts/truck_seg.sh ================================================ #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=1 python render.py --iteration 30000 \ -s /home/shenqiuhong/Downloads/tandt/tandt/truck \ -m ./output/truck-recon-only/ \ --skip_test \ --slackness 0.7 \ --view_num -1 \ --obj_num 1 \ --white_background \ --object_path inpaint_object_mask_255 \ ================================================ FILE: scripts/truck_train.sh ================================================ #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=1 python train.py -s /home/shenqiuhong/Downloads/tandt/tandt/truck \ --model_path ./output/truck-recon-only \ --limit_num -1 --port 20009 \ --densify_until_iter 10000 \ ================================================ FILE: scripts/waldo_train.sh ================================================ #! /bin/bash export OPENCV_IO_ENABLE_OPENEXR=1 export CUDA_VISIBLE_DEVICES=1 python train.py -s /home/shenqiuhong/Downloads/lerf_dataset/waldo_kitchen \ --model_path ./output/waldo_kitchen-recon-only \ --limit_num -1 --port 20004 \ --densify_until_iter 10000 \ ================================================ FILE: train.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import os import os.path as osp import torch import torch.nn.functional as F from random import randint from utils.loss_utils import l1_loss, ssim from gaussian_renderer import render, network_gui import sys from scene import Scene, GaussianModel from utils.general_utils import safe_state import uuid from tqdm import tqdm from utils.image_utils import psnr from argparse import ArgumentParser, Namespace from arguments import ModelParams, PipelineParams, OptimizationParams try: from torch.utils.tensorboard import SummaryWriter TENSORBOARD_FOUND = True except ImportError: TENSORBOARD_FOUND = False import torch import numpy as np import copy import imageio from PIL import Image import pdb import glob import random from scene.cameras import Camera def dot(x, y): if isinstance(x, np.ndarray): return np.sum(x * y, -1, keepdims=True) else: return torch.sum(x * y, -1, keepdim=True) def length(x, eps=1e-20): if isinstance(x, np.ndarray): return np.sqrt(np.maximum(np.sum(x * x, axis=-1, keepdims=True), eps)) else: return torch.sqrt(torch.clamp(dot(x, x), min=eps)) def safe_normalize(x, eps=1e-20): return x / length(x, eps) def look_at(campos, target): forward_vector = safe_normalize(campos - target) up_vector = np.array([0, 0, 1], dtype=np.float32) right_vector = safe_normalize(np.cross(up_vector, forward_vector)) up_vector = safe_normalize(np.cross(forward_vector, right_vector)) R = np.stack([right_vector, up_vector, forward_vector], axis=1) return R def pose_spherical(elevation, azimuth, radius=4.031, opengl=False): elevation = np.deg2rad(elevation) azimuth = np.deg2rad(azimuth) x = - radius * np.cos(elevation) * np.sin(azimuth) y = radius * np.cos(elevation) * np.cos(azimuth) z = radius * np.sin(elevation) campos = np.array([x, y, z]) c2w = np.eye(4, dtype=np.float32) target = np.zeros([3], dtype=np.float32) c2w[:3, :3] = look_at(campos, target) c2w[:3, 3] = campos # raw format of c2w in transform.json # change from OpenGL/Blender camera axes (Y up, Z back) to COLMAP (Y down, Z forward) c2w[:3, 1:3] *= -1 w2c = np.linalg.inv(c2w) R = np.transpose(w2c[:3,:3]) # R is stored transposed due to 'glm' in CUDA code T = w2c[:3, 3] return R, T def save_image(fn, x : np.ndarray): try: if os.path.splitext(fn)[1] == ".png": imageio.imwrite(fn, np.clip(np.rint(x * 255.0), 0, 255).astype(np.uint8), compress_level=3) # Low compression for faster saving else: imageio.imwrite(fn, np.clip(np.rint(x * 255.0), 0, 255).astype(np.uint8)) except: print("WARNING: FAILED to save image %s" % fn) def save_mask(fn, x: np.ndarray): max_val, min_val = x.max(), x.min() x = (x - min_val) / (max_val - min_val) x = x.repeat(3, axis=-1) try: if os.path.splitext(fn)[1] == ".png": imageio.imwrite(fn, np.clip(np.rint(x * 255.0), 0, 255).astype(np.uint8), compress_level=3) # Low compression for faster saving else: imageio.imwrite(fn, np.clip(np.rint(x * 255.0), 0, 255).astype(np.uint8)) except: print("WARNING: FAILED to save image %s" % fn) def _resize(image_array, size=(512, 512)): image = Image.fromarray(image_array) resized_image = image.resize(size) resized_image_array = np.array(resized_image) return resized_image_array def save_gif(dir, fps): imgpath = dir frames = [] for idx in sorted(os.listdir(imgpath)): img = osp.join(imgpath,idx) img = imageio.imread(img) resized_img = _resize(img, (512, 512)) frames.append(resized_img) imageio.mimsave(os.path.join(dir, 'eval.gif'),frames,'GIF',duration=1/fps) def save_mp4(dir, fps): imgpath = dir frames = [] frames_depth = [] frames_mask = [] for name in sorted(os.listdir(imgpath)): img = osp.join(imgpath, name) img = imageio.v2.imread(img) # resized_img = _resize(img, (512, 512)) resized_img = img if 'depth' in name: frames_depth.append(resized_img) elif 'mask' in name: frames_mask.append(resized_img) else: frames.append(resized_img) imageio.mimsave(os.path.join(dir, 'eval.mp4'), frames,fps=fps) imageio.mimsave(os.path.join(dir, 'eval_depth.mp4'), frames_depth,fps=fps) imageio.mimsave(os.path.join(dir, 'eval_mask.mp4'), frames_mask,fps=fps) def training(dataset, opt, pipe, testing_iterations, saving_iterations, checkpoint_iterations, checkpoint, debug_from): first_iter = 0 tb_writer = prepare_output_and_logger(dataset) gaussians = GaussianModel(dataset.sh_degree) scene = Scene(dataset, gaussians) stat_scene = Scene(dataset, gaussians, shuffle=False) gaussians.training_setup(opt) if checkpoint: (model_params, first_iter) = torch.load(checkpoint) gaussians.restore(model_params, opt) bg_color = [1, 1, 1] if dataset.white_background else [0, 0, 0] background = torch.tensor(bg_color, dtype=torch.float32, device="cuda") iter_start = torch.cuda.Event(enable_timing = True) iter_end = torch.cuda.Event(enable_timing = True) viewpoint_stack = None ema_loss_for_log = 0.0 progress_bar = tqdm(range(first_iter, opt.iterations), desc="Training progress") first_iter += 1 for iteration in range(first_iter, opt.iterations + 1): if network_gui.conn == None: network_gui.try_connect() while network_gui.conn != None: try: net_image_bytes = None custom_cam, do_training, pipe.convert_SHs_python, pipe.compute_cov3D_python, keep_alive, scaling_modifer = network_gui.receive() if custom_cam != None: net_image = render(custom_cam, gaussians, pipe, background, scaling_modifer)["render"] net_image_bytes = memoryview((torch.clamp(net_image, min=0, max=1.0) * 255).byte().permute(1, 2, 0).contiguous().cpu().numpy()) network_gui.send(net_image_bytes, dataset.source_path) if do_training and ((iteration < int(opt.iterations)) or not keep_alive): break except Exception as e: network_gui.conn = None iter_start.record() gaussians.update_learning_rate(iteration) # Every 1000 its we increase the levels of SH up to a maximum degree if iteration % 1000 == 0: gaussians.oneupSHdegree() # Pick a random Camera if not viewpoint_stack: viewpoint_stack = scene.getTrainCameras().copy() # getTestCameras viewpoint_cam = viewpoint_stack.pop(randint(0, len(viewpoint_stack)-1)) # Render if (iteration - 1) == debug_from: pipe.debug = True render_pkg = render(viewpoint_cam, gaussians, pipe, background) image, viewspace_point_tensor, visibility_filter, radii = render_pkg["render"], render_pkg["viewspace_points"], render_pkg["visibility_filter"], render_pkg["radii"] # pred_depth, pred_mask = render_pkg["depth"], render_pkg["alpha"] # Loss loss = 0 # gt_mask = viewpoint_cam.gt_alpha_mask.cuda()[None].repeat(3, 1, 1) # mask_loss = F.mse_loss(gt_mask.float(), pred_mask) # mask_loss = F.mse_loss(gt_mask.float()[gt_mask], pred_mask[gt_mask]) # loss += mask_loss * 0.1 # gt_depth = viewpoint_cam.gt_depth.cuda() gt_image = viewpoint_cam.original_image.cuda() Ll1 = l1_loss(image, gt_image) rgb_loss = (1.0 - opt.lambda_dssim) * Ll1 + opt.lambda_dssim * (1.0 - ssim(image, gt_image)) loss += rgb_loss loss.backward() iter_end.record() with torch.no_grad(): # Progress bar ema_loss_for_log = 0.4 * loss.item() + 0.6 * ema_loss_for_log if iteration % 10 == 0: progress_bar.set_postfix({"Loss": f"{ema_loss_for_log:.{7}f}", "num_pts": "{:06d}".format(gaussians.get_num_pts),}) progress_bar.update(10) if iteration == opt.iterations: progress_bar.close() # Log and save psnr_test = training_report(tb_writer, iteration, Ll1, loss, l1_loss, iter_start.elapsed_time(iter_end), testing_iterations, scene, render, (pipe, background)) if psnr_test > 0: with open(osp.join(dataset.model_path, "psnr_{:.2f}.txt".format(psnr_test)), "w") as fp: fp.writelines("psnr: {:.5f}\n".format(psnr_test)) fp.writelines("num_pts: {:d}\n".format(gaussians.get_num_pts)) if (iteration in saving_iterations): # print("\n[ITER {}] Saving Gaussians".format(iteration)) scene.save(iteration) # Densification if iteration < opt.densify_until_iter: # Keep track of max radii in image-space for pruning gaussians.max_radii2D[visibility_filter] = torch.max(gaussians.max_radii2D[visibility_filter], radii[visibility_filter]) gaussians.add_densification_stats(viewspace_point_tensor, visibility_filter) if iteration > opt.densify_from_iter and iteration % opt.densification_interval == 0: size_threshold = 20 if iteration > opt.opacity_reset_interval else None # if gaussians.get_num_pts < 20000: limit_num = opt.limit_num # 0.005 gaussians.densify_and_prune(opt.densify_grad_threshold, 0.005, scene.cameras_extent, size_threshold, limit_num=limit_num) if iteration % opt.opacity_reset_interval == 0 or (dataset.white_background and iteration == opt.densify_from_iter): gaussians.reset_opacity() # Optimizer step if iteration < opt.iterations: gaussians.optimizer.step() gaussians.optimizer.zero_grad(set_to_none = True) if (iteration in checkpoint_iterations): # print("\n[ITER {}] Saving Checkpoint".format(iteration)) torch.save((gaussians.capture(), iteration), scene.model_path + "/chkpnt" + str(iteration) + ".pth") # print("render a video after training.") background = torch.tensor([1, 1, 1], dtype=torch.float32, device="cuda") vis_path = osp.join(dataset.model_path, "render_vis") os.makedirs(vis_path, exist_ok=True) vis_scene = Scene(dataset, gaussians, load_iteration=-1, shuffle=False) training_visualization(vis_path, vis_scene, gaussians, render, (pipe, background)) def prepare_output_and_logger(args): if not args.model_path: if os.getenv('OAR_JOB_ID'): unique_str=os.getenv('OAR_JOB_ID') else: unique_str = str(uuid.uuid4()) args.model_path = os.path.join("./output/", unique_str[0:10]) # Set up output folder # print("Output folder: {}".format(args.model_path)) os.makedirs(args.model_path, exist_ok = True) with open(os.path.join(args.model_path, "cfg_args"), 'w') as cfg_log_f: cfg_log_f.write(str(Namespace(**vars(args)))) # Create Tensorboard writer tb_writer = None if TENSORBOARD_FOUND: tb_writer = SummaryWriter(args.model_path) else: pass # print("Tensorboard not available: not logging progress") return tb_writer def training_report(tb_writer, iteration, Ll1, loss, l1_loss, elapsed, testing_iterations, scene : Scene, renderFunc, renderArgs): if tb_writer: tb_writer.add_scalar('train_loss_patches/l1_loss', Ll1.item(), iteration) tb_writer.add_scalar('train_loss_patches/total_loss', loss.item(), iteration) tb_writer.add_scalar('iter_time', elapsed, iteration) psnr_test = 0.0 # Report test and samples of training set if iteration in testing_iterations: torch.cuda.empty_cache() validation_configs = ({'name': 'test', 'cameras' : scene.getTestCameras()}, {'name': 'train', 'cameras' : [scene.getTrainCameras()[idx % len(scene.getTrainCameras())] for idx in range(5, 30, 5)]}) for config in validation_configs: if config['cameras'] and len(config['cameras']) > 0: l1_test = 0.0 psnr_test = 0.0 for idx, viewpoint in enumerate(config['cameras']): image = torch.clamp(renderFunc(viewpoint, scene.gaussians, *renderArgs)["render"], 0.0, 1.0) gt_image = torch.clamp(viewpoint.original_image.to("cuda"), 0.0, 1.0) if tb_writer and (idx < 5): tb_writer.add_images(config['name'] + "_view_{}/render".format(viewpoint.image_name), image[None], global_step=iteration) if iteration == testing_iterations[0]: tb_writer.add_images(config['name'] + "_view_{}/ground_truth".format(viewpoint.image_name), gt_image[None], global_step=iteration) l1_test += l1_loss(image, gt_image).mean().double() psnr_test += psnr(image, gt_image).mean().double() psnr_test /= len(config['cameras']) l1_test /= len(config['cameras']) # print("\n[ITER {}] Evaluating {}: L1 {} PSNR {}, with num_pts {}".format(iteration, config['name'], l1_test, psnr_test, scene.gaussians.get_num_pts)) if tb_writer: tb_writer.add_scalar(config['name'] + '/loss_viewpoint - l1_loss', l1_test, iteration) tb_writer.add_scalar(config['name'] + '/loss_viewpoint - psnr', psnr_test, iteration) if tb_writer: # bug from numpy-tensorboard version dismatch # tb_writer.add_histogram("scene/opacity_histogram", scene.gaussians.get_opacity.cpu().detach().numpy().astype(np.float32), iteration) tb_writer.add_scalar('total_points', scene.gaussians.get_xyz.shape[0], iteration) torch.cuda.empty_cache() return psnr_test def training_visualization(vis_path, scene : Scene, gaussians, renderFunc, renderArgs): validation_configs = ({'name': 'test', 'cameras' : scene.getTestCameras()}, {'name': 'train', 'cameras' : scene.getTrainCameras()}) for config in validation_configs: if config['cameras'] and len(config['cameras']) > 0: cur_vis_path = osp.join(vis_path, config['name']) os.makedirs(cur_vis_path, exist_ok=True) for idx, viewpoint in enumerate(config['cameras']): image = torch.clamp(renderFunc(viewpoint, gaussians, *renderArgs)["render"], 0.0, 1.0) save_image(osp.join(cur_vis_path, "render_{:04d}.png".format(idx)), image.permute(1, 2, 0).detach().cpu().numpy()) save_mp4(cur_vis_path, 15) torch.cuda.empty_cache() if __name__ == "__main__": # Set up command line argument parser parser = ArgumentParser(description="Training script parameters") lp = ModelParams(parser) op = OptimizationParams(parser) pp = PipelineParams(parser) parser.add_argument('--ip', type=str, default="127.0.0.1") parser.add_argument('--port', type=int, default=6009) parser.add_argument('--debug_from', type=int, default=-1) parser.add_argument('--detect_anomaly', action='store_true', default=False) parser.add_argument("--test_iterations", nargs="+", type=int, default=[7_000, 30_000]) parser.add_argument("--save_iterations", nargs="+", type=int, default=[7_000, 30_000]) parser.add_argument("--quiet", action="store_true") parser.add_argument("--checkpoint_iterations", nargs="+", type=int, default=[]) parser.add_argument("--start_checkpoint", type=str, default = None) args = parser.parse_args(sys.argv[1:]) args.save_iterations.append(args.iterations) # print("Optimizing " + args.model_path) # Initialize system state (RNG) safe_state(args.quiet) # Start GUI server, configure and run training network_gui.init(args.ip, args.port) torch.autograd.set_detect_anomaly(args.detect_anomaly) training(lp.extract(args), op.extract(args), pp.extract(args), args.test_iterations, args.save_iterations, args.checkpoint_iterations, args.start_checkpoint, args.debug_from) # All done # print("\nTraining complete.") ================================================ FILE: utils/camera_utils.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import os import cv2 import torch from scene.cameras import Camera import numpy as np from utils.general_utils import PILtoTorch from utils.graphics_utils import fov2focal import pdb WARNED = False def read_depth(filename): depth = cv2.imread(filename ,cv2.IMREAD_UNCHANGED)[...,-1] depth[depth==65504.] = 0. # depth = cv2.resize(depth_h, None, fx=self.downSample, fy=self.downSample, interpolation=cv2.INTER_NEAREST) mask = depth > 0 return depth, mask def loadCam(args, id, cam_info, resolution_scale): orig_w, orig_h = cam_info.image.size if args.resolution in [1, 2, 4, 8]: resolution = round(orig_w/(resolution_scale * args.resolution)), round(orig_h/(resolution_scale * args.resolution)) else: # should be a type that converts to float if args.resolution == -1: if orig_w > 1600: global WARNED if not WARNED: print("[ INFO ] Encountered quite large input images (>1.6K pixels width), rescaling to 1.6K.\n " "If this is not desired, please explicitly specify '--resolution/-r' as 1") WARNED = True global_down = orig_w / 1600 else: global_down = 1 else: global_down = orig_w / args.resolution scale = float(global_down) * float(resolution_scale) resolution = (int(orig_w / scale), int(orig_h / scale)) resized_image_rgb = PILtoTorch(cam_info.image, resolution) gt_image = resized_image_rgb[:3, ...] loaded_mask = None if resized_image_rgb.shape[1] == 4: loaded_mask = resized_image_rgb[3:4, ...] depth_dir = "/".join(cam_info.image_path.split("/")[:-2] + ["depths"]) if os.path.exists(depth_dir): img_name = os.path.splitext(os.path.basename(cam_info.image_path))[0] depth_dir = os.path.join(depth_dir, f"{img_name}_depth.exr") loaded_depth, loaded_mask = read_depth(depth_dir) else: loaded_depth = loaded_mask = None # check depth exist or not if cam_info.objects is not None: objects = torch.from_numpy(np.array(cam_info.objects)) else: objects = None return Camera(colmap_id=cam_info.uid, R=cam_info.R, T=cam_info.T, FoVx=cam_info.FovX, FoVy=cam_info.FovY, image=gt_image, gt_alpha_mask=loaded_mask, gt_depth=loaded_depth, image_name=cam_info.image_name, uid=id, data_device=args.data_device, objects=objects) def cameraList_from_camInfos(cam_infos, resolution_scale, args): camera_list = [] for id, c in enumerate(cam_infos): camera_list.append(loadCam(args, id, c, resolution_scale)) return camera_list def camera_to_JSON(id, camera : Camera): Rt = np.zeros((4, 4)) Rt[:3, :3] = camera.R.transpose() Rt[:3, 3] = camera.T Rt[3, 3] = 1.0 W2C = np.linalg.inv(Rt) pos = W2C[:3, 3] rot = W2C[:3, :3] serializable_array_2d = [x.tolist() for x in rot] camera_entry = { 'id' : id, 'img_name' : camera.image_name, 'width' : camera.width, 'height' : camera.height, 'position': pos.tolist(), 'rotation': serializable_array_2d, 'fy' : fov2focal(camera.FovY, camera.height), 'fx' : fov2focal(camera.FovX, camera.width) } return camera_entry ================================================ FILE: utils/general_utils.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import torch import sys from datetime import datetime import numpy as np import random def inverse_sigmoid(x): return torch.log(x/(1-x)) def PILtoTorch(pil_image, resolution): resized_image_PIL = pil_image.resize(resolution) resized_image = torch.from_numpy(np.array(resized_image_PIL)) / 255.0 if len(resized_image.shape) == 3: return resized_image.permute(2, 0, 1) else: return resized_image.unsqueeze(dim=-1).permute(2, 0, 1) def get_expon_lr_func( lr_init, lr_final, lr_delay_steps=0, lr_delay_mult=1.0, max_steps=1000000 ): """ Copied from Plenoxels Continuous learning rate decay function. Adapted from JaxNeRF The returned rate is lr_init when step=0 and lr_final when step=max_steps, and is log-linearly interpolated elsewhere (equivalent to exponential decay). If lr_delay_steps>0 then the learning rate will be scaled by some smooth function of lr_delay_mult, such that the initial learning rate is lr_init*lr_delay_mult at the beginning of optimization but will be eased back to the normal learning rate when steps>lr_delay_steps. :param conf: config subtree 'lr' or similar :param max_steps: int, the number of steps during optimization. :return HoF which takes step as input """ def helper(step): if step < 0 or (lr_init == 0.0 and lr_final == 0.0): # Disable this parameter return 0.0 if lr_delay_steps > 0: # A kind of reverse cosine decay. delay_rate = lr_delay_mult + (1 - lr_delay_mult) * np.sin( 0.5 * np.pi * np.clip(step / lr_delay_steps, 0, 1) ) else: delay_rate = 1.0 t = np.clip(step / max_steps, 0, 1) log_lerp = np.exp(np.log(lr_init) * (1 - t) + np.log(lr_final) * t) return delay_rate * log_lerp return helper def strip_lowerdiag(L): uncertainty = torch.zeros((L.shape[0], 6), dtype=torch.float, device="cuda") uncertainty[:, 0] = L[:, 0, 0] uncertainty[:, 1] = L[:, 0, 1] uncertainty[:, 2] = L[:, 0, 2] uncertainty[:, 3] = L[:, 1, 1] uncertainty[:, 4] = L[:, 1, 2] uncertainty[:, 5] = L[:, 2, 2] return uncertainty def strip_symmetric(sym): return strip_lowerdiag(sym) def build_rotation(r): norm = torch.sqrt(r[:,0]*r[:,0] + r[:,1]*r[:,1] + r[:,2]*r[:,2] + r[:,3]*r[:,3]) q = r / norm[:, None] R = torch.zeros((q.size(0), 3, 3), device='cuda') r = q[:, 0] x = q[:, 1] y = q[:, 2] z = q[:, 3] R[:, 0, 0] = 1 - 2 * (y*y + z*z) R[:, 0, 1] = 2 * (x*y - r*z) R[:, 0, 2] = 2 * (x*z + r*y) R[:, 1, 0] = 2 * (x*y + r*z) R[:, 1, 1] = 1 - 2 * (x*x + z*z) R[:, 1, 2] = 2 * (y*z - r*x) R[:, 2, 0] = 2 * (x*z - r*y) R[:, 2, 1] = 2 * (y*z + r*x) R[:, 2, 2] = 1 - 2 * (x*x + y*y) return R def build_scaling_rotation(s, r): L = torch.zeros((s.shape[0], 3, 3), dtype=torch.float, device="cuda") R = build_rotation(r) L[:,0,0] = s[:,0] L[:,1,1] = s[:,1] L[:,2,2] = s[:,2] L = R @ L return L def safe_state(silent): old_f = sys.stdout class F: def __init__(self, silent): self.silent = silent def write(self, x): if not self.silent: if x.endswith("\n"): old_f.write(x.replace("\n", " [{}]\n".format(str(datetime.now().strftime("%d/%m %H:%M:%S"))))) else: old_f.write(x) def flush(self): old_f.flush() sys.stdout = F(silent) random.seed(0) np.random.seed(0) torch.manual_seed(0) torch.cuda.set_device(torch.device("cuda:0")) ================================================ FILE: utils/graphics_utils.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import torch import math import numpy as np from typing import NamedTuple class BasicPointCloud(NamedTuple): points : np.array colors : np.array normals : np.array def geom_transform_points(points, transf_matrix): P, _ = points.shape ones = torch.ones(P, 1, dtype=points.dtype, device=points.device) points_hom = torch.cat([points, ones], dim=1) points_out = torch.matmul(points_hom, transf_matrix.unsqueeze(0)) denom = points_out[..., 3:] + 0.0000001 return (points_out[..., :3] / denom).squeeze(dim=0) def getWorld2View(R, t): Rt = np.zeros((4, 4)) Rt[:3, :3] = R.transpose() Rt[:3, 3] = t Rt[3, 3] = 1.0 return np.float32(Rt) def getWorld2View2(R, t, translate=np.array([.0, .0, .0]), scale=1.0): Rt = np.zeros((4, 4)) Rt[:3, :3] = R.transpose() Rt[:3, 3] = t Rt[3, 3] = 1.0 C2W = np.linalg.inv(Rt) cam_center = C2W[:3, 3] cam_center = (cam_center + translate) * scale C2W[:3, 3] = cam_center Rt = np.linalg.inv(C2W) return np.float32(Rt) def getProjectionMatrix(znear, zfar, fovX, fovY): tanHalfFovY = math.tan((fovY / 2)) tanHalfFovX = math.tan((fovX / 2)) top = tanHalfFovY * znear bottom = -top right = tanHalfFovX * znear left = -right P = torch.zeros(4, 4) z_sign = 1.0 P[0, 0] = 2.0 * znear / (right - left) P[1, 1] = 2.0 * znear / (top - bottom) P[0, 2] = (right + left) / (right - left) P[1, 2] = (top + bottom) / (top - bottom) P[3, 2] = z_sign P[2, 2] = z_sign * zfar / (zfar - znear) P[2, 3] = -(zfar * znear) / (zfar - znear) return P def fov2focal(fov, pixels): return pixels / (2 * math.tan(fov / 2)) def focal2fov(focal, pixels): return 2*math.atan(pixels/(2*focal)) ================================================ FILE: utils/image_utils.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import torch def mse(img1, img2): return (((img1 - img2)) ** 2).view(img1.shape[0], -1).mean(1, keepdim=True) def psnr(img1, img2): mse = (((img1 - img2)) ** 2).view(img1.shape[0], -1).mean(1, keepdim=True) return 20 * torch.log10(1.0 / torch.sqrt(mse)) ================================================ FILE: utils/loss_utils.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # import torch import torch.nn.functional as F from torch.autograd import Variable from math import exp def l1_loss(network_output, gt): return torch.abs((network_output - gt)).mean() def masked_l1_loss(network_output, gt, mask): mask = mask.float()[None,:,:].repeat(gt.shape[0],1,1) loss = torch.abs((network_output - gt)) * mask loss = loss.sum() / mask.sum() return loss def l2_loss(network_output, gt): return ((network_output - gt) ** 2).mean() def gaussian(window_size, sigma): gauss = torch.Tensor([exp(-(x - window_size // 2) ** 2 / float(2 * sigma ** 2)) for x in range(window_size)]) return gauss / gauss.sum() def create_window(window_size, channel): _1D_window = gaussian(window_size, 1.5).unsqueeze(1) _2D_window = _1D_window.mm(_1D_window.t()).float().unsqueeze(0).unsqueeze(0) window = Variable(_2D_window.expand(channel, 1, window_size, window_size).contiguous()) return window def ssim(img1, img2, window_size=11, size_average=True): channel = img1.size(-3) window = create_window(window_size, channel) if img1.is_cuda: window = window.cuda(img1.get_device()) window = window.type_as(img1) return _ssim(img1, img2, window, window_size, channel, size_average) def _ssim(img1, img2, window, window_size, channel, size_average=True): mu1 = F.conv2d(img1, window, padding=window_size // 2, groups=channel) mu2 = F.conv2d(img2, window, padding=window_size // 2, groups=channel) mu1_sq = mu1.pow(2) mu2_sq = mu2.pow(2) mu1_mu2 = mu1 * mu2 sigma1_sq = F.conv2d(img1 * img1, window, padding=window_size // 2, groups=channel) - mu1_sq sigma2_sq = F.conv2d(img2 * img2, window, padding=window_size // 2, groups=channel) - mu2_sq sigma12 = F.conv2d(img1 * img2, window, padding=window_size // 2, groups=channel) - mu1_mu2 C1 = 0.01 ** 2 C2 = 0.03 ** 2 ssim_map = ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) * (sigma1_sq + sigma2_sq + C2)) if size_average: return ssim_map.mean() else: return ssim_map.mean(1).mean(1).mean(1) ================================================ FILE: utils/sh_utils.py ================================================ # Copyright 2021 The PlenOctree Authors. # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # 1. Redistributions of source code must retain the above copyright notice, # this list of conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright notice, # this list of conditions and the following disclaimer in the documentation # and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS 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 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. import torch C0 = 0.28209479177387814 C1 = 0.4886025119029199 C2 = [ 1.0925484305920792, -1.0925484305920792, 0.31539156525252005, -1.0925484305920792, 0.5462742152960396 ] C3 = [ -0.5900435899266435, 2.890611442640554, -0.4570457994644658, 0.3731763325901154, -0.4570457994644658, 1.445305721320277, -0.5900435899266435 ] C4 = [ 2.5033429417967046, -1.7701307697799304, 0.9461746957575601, -0.6690465435572892, 0.10578554691520431, -0.6690465435572892, 0.47308734787878004, -1.7701307697799304, 0.6258357354491761, ] def eval_sh(deg, sh, dirs): """ Evaluate spherical harmonics at unit directions using hardcoded SH polynomials. Works with torch/np/jnp. ... Can be 0 or more batch dimensions. Args: deg: int SH deg. Currently, 0-3 supported sh: jnp.ndarray SH coeffs [..., C, (deg + 1) ** 2] dirs: jnp.ndarray unit directions [..., 3] Returns: [..., C] """ assert deg <= 4 and deg >= 0 coeff = (deg + 1) ** 2 assert sh.shape[-1] >= coeff result = C0 * sh[..., 0] if deg > 0: x, y, z = dirs[..., 0:1], dirs[..., 1:2], dirs[..., 2:3] result = (result - C1 * y * sh[..., 1] + C1 * z * sh[..., 2] - C1 * x * sh[..., 3]) if deg > 1: xx, yy, zz = x * x, y * y, z * z xy, yz, xz = x * y, y * z, x * z result = (result + C2[0] * xy * sh[..., 4] + C2[1] * yz * sh[..., 5] + C2[2] * (2.0 * zz - xx - yy) * sh[..., 6] + C2[3] * xz * sh[..., 7] + C2[4] * (xx - yy) * sh[..., 8]) if deg > 2: result = (result + C3[0] * y * (3 * xx - yy) * sh[..., 9] + C3[1] * xy * z * sh[..., 10] + C3[2] * y * (4 * zz - xx - yy)* sh[..., 11] + C3[3] * z * (2 * zz - 3 * xx - 3 * yy) * sh[..., 12] + C3[4] * x * (4 * zz - xx - yy) * sh[..., 13] + C3[5] * z * (xx - yy) * sh[..., 14] + C3[6] * x * (xx - 3 * yy) * sh[..., 15]) if deg > 3: result = (result + C4[0] * xy * (xx - yy) * sh[..., 16] + C4[1] * yz * (3 * xx - yy) * sh[..., 17] + C4[2] * xy * (7 * zz - 1) * sh[..., 18] + C4[3] * yz * (7 * zz - 3) * sh[..., 19] + C4[4] * (zz * (35 * zz - 30) + 3) * sh[..., 20] + C4[5] * xz * (7 * zz - 3) * sh[..., 21] + C4[6] * (xx - yy) * (7 * zz - 1) * sh[..., 22] + C4[7] * xz * (xx - 3 * yy) * sh[..., 23] + C4[8] * (xx * (xx - 3 * yy) - yy * (3 * xx - yy)) * sh[..., 24]) return result def RGB2SH(rgb): return (rgb - 0.5) / C0 def SH2RGB(sh): return sh * C0 + 0.5 ================================================ FILE: utils/system_utils.py ================================================ # # Copyright (C) 2023, Inria # GRAPHDECO research group, https://team.inria.fr/graphdeco # All rights reserved. # # This software is free for non-commercial, research and evaluation use # under the terms of the LICENSE.md file. # # For inquiries contact george.drettakis@inria.fr # from errno import EEXIST from os import makedirs, path import os def mkdir_p(folder_path): # Creates a directory. equivalent to using mkdir -p on the command line try: makedirs(folder_path) except OSError as exc: # Python >2.5 if exc.errno == EEXIST and path.isdir(folder_path): pass else: raise def searchForMaxIteration(folder): saved_iters = [int(fname.split("_")[-1]) for fname in os.listdir(folder)] return max(saved_iters)