Full Code of florinshen/FlashSplat for AI

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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