first commit

.gitattributes

@@ -9,7 +9,6 @@
 *.joblib filter=lfs diff=lfs merge=lfs -text
 *.lfs.* filter=lfs diff=lfs merge=lfs -text
 *.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
 *.mlmodel filter=lfs diff=lfs merge=lfs -text
 *.model filter=lfs diff=lfs merge=lfs -text
 *.msgpack filter=lfs diff=lfs merge=lfs -text
@@ -22,7 +21,6 @@
 *.pickle filter=lfs diff=lfs merge=lfs -text
 *.pkl filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
 *.rar filter=lfs diff=lfs merge=lfs -text
 *.safetensors filter=lfs diff=lfs merge=lfs -text
 saved_model/**/* filter=lfs diff=lfs merge=lfs -text
@@ -54,6 +52,19 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
+# 3dgs files
+
+## We do have
+*.pth filter=lfs diff=lfs merge=lfs -text
+## We do have
+*.ply filter=lfs diff=lfs merge=lfs -text
+## We do have
+cameras.json filter=lfs diff=lfs merge=lfs -text
+# ## We do have
+# multi-coords filter=lfs diff=lfs merge=lfs -text
+# ## We do have
+# coord filter=lfs diff=lfs merge=lfs -text
+
+*.splat filter=lfs diff=lfs merge=lfs -text
+*.splatv filter=lfs diff=lfs merge=lfs -text
+*.pdf filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+*/object_mask/
+*/train/
+point_cloud.ply
+*.pyc
+__pycache__/

gaussian-grouping/.gitignore

@@ -0,0 +1,8 @@
+data/*
+output/*
+Tracking-Anything-with-DEVA/example/*
+submodules/diff-gaussian-rasterization-cp/*
+*.pyc
+*.pth
+*.jpg
+*.png

gaussian-grouping/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

gaussian-grouping/README.md

@@ -0,0 +1,82 @@
+# Gaussian Grouping
+
+> [**Gaussian Grouping: Segment and Edit Anything in 3D Scenes**](https://arxiv.org/abs/2312.00732)           
+> [[Project Page]](https://ymq2017.github.io/gaussian-grouping)           
+> arXiv 2023  
+> ETH Zurich
+
+We propose Gaussian Grouping, which extends Gaussian Splatting to jointly **reconstruct** and **segment** anything in open-world 3D scenes via **lifting 2D SAM**. It also efficiently supports versatile 3D scene **editing** tasks. Refer to our [paper](https://arxiv.org/abs/2312.00732) for more details.
+
+<img width="1000" alt="image" src='media/teaser_github_demo.gif'>
+
+Updates
+-----------------
+:fire::fire: 2024/01/16: We released the [LERF-Mask dataset](docs/dataset.md) and evaluation code.
+
+2024/01/06: We released the [3D Object Removal & Inpainting](docs/edit_removal_inpaint.md) code.
+
+2023/12/20: We released the [Install Notes](docs/install.md) and [Training & Rendering](docs/train.md) code.
+
+
+# Introduction
+The recent Gaussian Splatting achieves high-quality and real-time novel-view synthesis of the 3D scenes. However, it is solely concentrated on the appearance and geometry modeling, while lacking in fine-grained object-level scene understanding. To address this issue, we propose Gaussian Grouping, which extends Gaussian Splatting to jointly reconstruct and segment anything in open-world 3D scenes. We augment each Gaussian with a compact Identity Encoding, allowing the Gaussians to be grouped according to their object instance or stuff membership in the 3D scene. Instead of resorting to expensive 3D labels, we supervise the Identity Encodings during the differentiable rendering by leveraging the 2D mask predictions by SAM, along with introduced 3D spatial consistency regularization. Comparing to the implicit NeRF representation, we show that the discrete and grouped 3D Gaussians can reconstruct, segment and edit anything in 3D with high visual quality, fine granularity and efficiency. Based on Gaussian Grouping, we further propose a local Gaussian Editing scheme, which shows efficacy in versatile scene editing applications, including 3D object removal, inpainting, colorization and scene recomposition.
+
+<img width="1096" alt="image" src='media/github_method.png'>
+
+# Application Overview
+**Local Gaussian Editing scheme**: Grouped Gaussians after training. Each group represents a specific instance / stuff of the 3D scene and can be fully decoupled.
+<img width="1096" alt="image" src='media/editing_operation.png'>
+
+## 3D Object Removal
+Our Gaussian Grouping can remove the large-scale objects on the Tanks & Temples dataset, from the whole 3D scene with greatly reduced artifacts. Zoom for better view.
+
+https://github.com/lkeab/gaussian-grouping/assets/17427852/f3b0f964-a610-49ab-8332-f2caa64fbf45
+
+## 3D Object Inpainting
+Comparison on 3D object inpainting cases, where SPIn-NeRF requires 5h training while our method with better inpainting quality only needs 1 hour training and 20 minutes tuning.
+
+https://github.com/lkeab/gaussian-grouping/assets/17427852/9f5050da-6a50-4a5f-a755-3bdc55eab1bc
+
+https://github.com/lkeab/gaussian-grouping/assets/17427852/3ed0203c-0047-4333-8bf0-0c10f5a078d1
+
+## 3D Object Style Transfer
+Comparison on 3D object style transfer cases, Our Gaussian Grouping produces more coherent and natural transfer results across views, with faithfully preserved background.
+
+https://github.com/lkeab/gaussian-grouping/assets/17427852/2f00eab5-590b-4295-bb1c-2076acc63d4a
+
+## 3D Open-world Segmentation
+Our Gaussian Grouping approach jointly reconstructs and segments anything in full open-world 3D scenes. The masks predicted by Gaussian Grouping contains much sharp and accurate boundary than LERF.
+
+https://github.com/lkeab/gaussian-grouping/assets/60028943/38241b99-1497-4a7c-bd22-5b018b85548c
+
+
+
+## 3D Multi-Object Editing
+Our Gaussian Grouping approach jointly reconstructs and segments anything in full open-world 3D scenes. Then we concurrently perform 3D object editing for several objects.
+
+https://github.com/lkeab/gaussian-grouping/assets/17427852/d9638a1c-1569-4c72-91b9-ee68e9e017e5
+
+# Installation
+You can refer to the [install document](./docs/install.md) to build the Python environment.
+
+# Training and Masks Rendering
+Then refer to the [train document](./docs/train.md) to train your own scene.
+
+# Open-Vocabulary Segmentation
+For evaluation on the **LERF-Mask dataset** proposed in our paper, you can refer to the [dataset document](./docs/dataset.md).
+
+# 3D Object Removal and Inpainting
+You can select the 3D object for removal and inpainting after training. Details are in the [edit removal inpaint document](./docs/edit_removal_inpaint.md).
+
+
+Citation
+---------------
+If you find Gaussian Grouping useful in your research or refer to the provided baseline results, please star :star: this repository and consider citing :pencil::
+```
+@article{gaussian_grouping,
+  title={Gaussian Grouping: Segment and Edit Anything in 3D Scenes},
+  author={Ye, Mingqiao and Danelljan, Martin and Yu, Fisher and Ke, Lei},
+  journal={arXiv preprint arXiv:2312.00732},
+  year={2023}
+}
+```

gaussian-grouping/arguments/__init__.py

@@ -0,0 +1,120 @@
+# 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
+
+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.n_views = 100 
+        self.random_init = False
+        self.train_split = False
+        self._object_path = "object_mask"
+        self.num_classes = 200
+        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 = 90_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 = 90_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 = 90_000 #
+        self.densify_grad_threshold = 0.0002
+
+        self.reg3d_interval = 2
+        self.reg3d_k = 5
+        self.reg3d_lambda_val = 2
+        self.reg3d_max_points = 300000
+        self.reg3d_sample_size = 1000
+
+        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 merged_dict.get(k) == None or v != None: # nt
+            merged_dict[k] = v  
+    return Namespace(**merged_dict)

gaussian-grouping/config/gaussian_dataset/train.json

@@ -0,0 +1,9 @@
+{
+    "densify_until_iter": 10000 , 
+    "num_classes": 256,
+    "reg3d_interval": 5,
+    "reg3d_k": 5,
+    "reg3d_lambda_val": 2,
+    "reg3d_max_points": 500000,
+    "reg3d_sample_size": 2000
+}

gaussian-grouping/config/object_inpaint/bear.json

@@ -0,0 +1,10 @@
+{
+    "num_classes": 256,
+    "removal_thresh": 0.3,
+    "select_obj_id" : [34],
+    "images": "images_inpaint_unseen",
+    "object_path" : "inpaint_object_mask_255",
+    "r" : 1,
+    "lambda_dlpips" : 0.5,
+    "finetune_iteration": 10000
+}

gaussian-grouping/config/object_inpaint/mipnerf360/kitchen.json

@@ -0,0 +1,10 @@
+{
+    "num_classes": 256,
+    "removal_thresh": 0.3,
+    "select_obj_id" : [49],
+    "images": "images_inpaint_unseen",
+    "object_path" : "inpaint_object_mask_255",
+    "r" : 1,
+    "lambda_dlpips" : 0.5,
+    "finetune_iteration": 10000
+}

gaussian-grouping/config/object_removal/bear.json

@@ -0,0 +1,5 @@
+{
+    "num_classes": 256,
+    "removal_thresh": 0.3,
+    "select_obj_id" : [34]
+}

gaussian-grouping/config/object_removal/mipnerf360/kitchen.json

@@ -0,0 +1,5 @@
+{
+    "num_classes": 256,
+    "removal_thresh": 0.3,
+    "select_obj_id" : [49]
+}

gaussian-grouping/convert.py

@@ -0,0 +1,124 @@
+#
+# 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.")

gaussian-grouping/docs/dataset.md

@@ -0,0 +1,54 @@
+# Gaussian Grouping: Segment and Edit Anything in 3D Scenes
+
+We provide dataset format and custom dataset preparation in the [training doc](./train.md). Here we introduce the LERF-Mask dataset proposed in our paper and its evaluation.
+
+
+## 1. LERF-Mask dataset
+You can download LERF-Mask dataset from [this hugging-face link](https://huggingface.co/mqye/Gaussian-Grouping/tree/main/data/lerf_mask). Test set of LERF-Mask dataset includes 2-4 novel view images. The mask annotations are saved in `test_mask` folder. The name of each mask image corresponds to the input text-prompt.
+
+```
+lerf_mask
+|____figurines
+| |____distorted
+| |____images
+| |____images_train
+| |____object_mask
+| |____sparse
+| |____stereo
+| |____test_mask
+|   |____<novel view 0>
+|   | |____<text prompt 0>.png
+|   | |____...
+|   |____<novel view 1>
+|   | |____<text prompt 0>.png
+|   | |____...
+|____ramen
+| |____...
+|____teatime
+| |____...
+```
+
+## 2. Render mask with text-prompt
+For semantic information of each mask output, since SAM masks are class-agnostic, we can use a vision-language detector's mask output, for example [grounded-sam](https://github.com/IDEA-Research/Grounded-Segment-Anything), to match our mask to give semantic information.
+
+We test our segmentation with a simple strategy using grounded-sam on the first frame for text-prompt. You can use the following command with the provided checkpoints on [hugging face](https://huggingface.co/mqye/Gaussian-Grouping/tree/main/checkpoint) or your own training result. In the future we can also explore better detectors and prompt formats.
+
+```
+python render_lerf_mask.py -m output/lerf_pretrain/figurines --skip_train
+python render_lerf_mask.py -m output/lerf_pretrain/ramen --skip_train
+python render_lerf_mask.py -m output/lerf_pretrain/teatime --skip_train
+```
+
+
+
+
+## 3. LERF-Mask evaluation
+We provide our result on [hugging face](https://huggingface.co/mqye/Gaussian-Grouping/tree/main/result). We also provide a script for evaluating IoU and Boundary-IoU. You can change the output path to your output folder and run the script.
+
+For example,
+```
+python script/eval_lerf_mask.py figurines
+python script/eval_lerf_mask.py ramen
+python script/eval_lerf_mask.py teatime
+```
+

gaussian-grouping/docs/edit_removal_inpaint.md

@@ -0,0 +1,97 @@
+# Gaussian Grouping: Segment and Edit Anything in 3D Scenes
+
+## 1. 3D Object Removal
+
+### 1.1 Training
+
+First finish training as described in [training doc](./train.md). Save the output file then we can edit on it.
+
+
+### 1.2 Remove the selected object
+
+You can choose one or more object id(s) for removal and indicate it in the config file.
+
+
+Example1. Bear dataset
+```
+bash script/edit_object_removal.sh output/bear config/object_removal/bear.json
+```
+
+Example2. Kitchen dataset
+```
+bash script/edit_object_removal.sh output/mipnerf360/kitchen config/object_removal/mipnerf360/kitchen.json
+```
+
+
+## 2. 3D Object inpainting
+
+For 3D object inpainting, our pipeline includes three steps.
+
+1. Remove the object
+
+2. Inpaint the unseen region (always invisible due to occlusion) in 2D
+
+3. Use 2D inpainting as pseudo label, finetune 3D Gaussians
+
+For your custom datasets, you can follow these three steps to inpaint the object.
+
+For our example datasets, we provide the pseudo labels on [hugging face](https://huggingface.co/mqye/Gaussian-Grouping/tree/main/data) and you can skip the first two steps below and directly finetune 3D Gaussians in **2.3 3D inpaint**. 
+
+### 2.1 (Optional) Unseen mask preparation
+
+First finish training and remove the object you want to inpaint. After removal, we can get the **unseen region mask** for inpainting.
+
+Unseen region mask is the empty region left after removing the object, and we can perform 2D inpainting on it. An example is shown in the bottom of fig8 in our paper. We can obtain the unseen region mask with DEVA. For example,
+
+```bash
+#!/bin/bash
+
+cd Tracking-Anything-with-DEVA/
+
+img_path=../output/mipnerf360/kitchen/train/ours_object_removal/iteration_30000/renders
+mask_path=./output_2d_inpaint_mask/mipnerf360/kitchen
+lama_path=../lama/LaMa_test_images/mipnerf360/kitchen
+
+python demo/demo_with_text.py   --chunk_size 4    --img_path $img_path  --amp \
+  --temporal_setting semionline --size 480   --output $mask_path  \
+  --prompt "black blurry hole"
+
+python prepare_lama_input.py $img_path $mask_path $lama_path
+cd ..
+```
+
+You can also try other prompts like "black region" and change the mask score threshold to get the best unseen region mask result.
+
+
+
+### 2.2 (Optional) 2D inpaint
+
+We follow [SPIN-NeRF](https://github.com/SamsungLabs/SPIn-NeRF) pipeline of 2D guidance for inpainting. We use LaMa to inpaint on 2D images rendered after removing the object with unseen region mask. We only need 2D inpainting on RGB and do not need inpainting on depth map.
+
+Now, make sure to follow the [LaMa](https://github.com/advimman/lama) instructions for downloading the big-lama model.
+
+```bash
+#!/bin/bash
+
+cd lama
+export TORCH_HOME=$(pwd) && export PYTHONPATH=$(pwd)
+
+dataset=mipnerf360/kitchen
+img_dir=../data/$dataset
+
+python bin/predict.py refine=True model.path=$(pwd)/big-lama indir=$(pwd)/LaMa_test_images/$dataset outdir=$(pwd)/output/$dataset
+python prepare_pseudo_label.py $(pwd)/output/$dataset $img_dir
+
+```
+
+
+### 2.3 3D inpaint
+Example1. Bear dataset
+```
+bash script/edit_object_inpaint.sh output/bear config/object_inpaint/bear.json
+```
+
+Example2. Kitchen dataset
+```
+bash script/edit_object_inpaint.sh output/mipnerf360/kitchen config/object_inpaint/mipnerf360/kitchen.json
+```

gaussian-grouping/docs/install.md

@@ -0,0 +1,46 @@
+### **Standard Installation**
+
+
+Clone the repository locally
+```
+git clone https://github.com/lkeab/gaussian-grouping.git
+cd gaussian-grouping
+```
+
+Our default, provided install method is based on Conda package and environment management:
+```bash
+conda create -n gaussian_grouping python=3.8 -y
+conda activate gaussian_grouping 
+
+conda install pytorch==1.12.1 torchvision==0.13.1 torchaudio==0.12.1 cudatoolkit=11.3 -c pytorch
+pip install plyfile==0.8.1
+pip install tqdm scipy wandb opencv-python scikit-learn lpips
+
+pip install submodules/diff-gaussian-rasterization
+pip install submodules/simple-knn
+```
+
+(Optional) If you want to prepare masks on your own dataset, you will also need to prepare [DEVA](https://github.com/hkchengrex/Tracking-Anything-with-DEVA) environment.
+
+```bash
+cd Tracking-Anything-with-DEVA
+pip install -e .
+bash scripts/download_models.sh     # Download the pretrained models
+
+git clone https://github.com/hkchengrex/Grounded-Segment-Anything.git
+cd Grounded-Segment-Anything
+export AM_I_DOCKER=False
+export BUILD_WITH_CUDA=True
+python -m pip install -e segment_anything
+python -m pip install -e GroundingDINO
+
+cd ../..
+```
+
+(Optional) If you want to inpaint on your own dataset, you will also need to prepare [LaMa](https://github.com/advimman/lama) environment.
+
+```bash
+cd lama
+pip install -r requirements.txt
+cd ..
+```

gaussian-grouping/docs/train.md

@@ -0,0 +1,69 @@
+# Gaussian Grouping: Segment and Edit Anything in 3D Scenes
+
+## 1. Prepare associated SAM masks
+
+### 1.1 Pre-converted datasets
+We provide converted datasets in our paper, You can use directly train on datasets from [hugging face link](https://huggingface.co/mqye/Gaussian-Grouping/tree/main)
+
+```
+data
+|____bear
+|____lerf
+| |____figurines
+|____mipnerf360
+| |____counter
+```
+
+
+### 1.2 (Optional) Prepare your own datasets
+For your custom dataset, you can follow this step to create masks for training. If you want to prepare masks on your own dataset, you will need [DEVA](../Tracking-Anything-with-DEVA/README.md) python environment and checkpoints.
+
+
+```
+<location>
+|---input
+    |---<image 0>
+    |---<image 1>
+    |---...
+```
+Firstly, convert initial camera pose and point cloud with colmap
+```
+python convert.py -s <location>
+```
+
+Then, convert SAM associated object masks. Note that the quality of converted-mask will largely affect the results of 3D segmentation and editing. And getting the mask is very fast. So it is best to adjust the parameters of anything segment first to make the mask as consistent and reasonable as possible from multiple views.
+
+Example1. Bear dataset
+```
+bash script/prepare_pseudo_label.sh bear 1
+```
+
+Example2. figurines dataset
+```
+bash script/prepare_pseudo_label.sh lerf/figurines 1
+```
+
+Example3. counter dataset
+```
+bash script/prepare_pseudo_label.sh mipnerf360/counter 2
+```
+
+## 2. Training and Masks Rendering
+
+For Gaussian Grouping training and segmentation rendering of trained 3D Gaussian Grouping model:
+
+Example1. Bear dataset
+```
+bash script/train.sh bear 1
+```
+
+Example2. figurines dataset
+```
+bash script/train_lerf.sh lerf/figurines 1
+```
+
+Example3. counter dataset
+```
+bash script/train.sh mipnerf360/counter 2
+```
+

gaussian-grouping/edit_object_inpaint.py

@@ -0,0 +1,246 @@
+# 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
+
+from render import feature_to_rgb, visualize_obj
+from edit_object_removal import points_inside_convex_hull
+
+
+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, classifier, selected_obj_ids, cameras_extent, removal_thresh, finetune_iteration):
+
+    # get 3d gaussians idx corresponding to select obj id
+    with torch.no_grad():
+        logits3d = classifier(gaussians._objects_dc.permute(2,0,1))
+        prob_obj3d = torch.softmax(logits3d,dim=0)
+        mask = prob_obj3d[selected_obj_ids, :, :] > removal_thresh
+        mask3d = mask.any(dim=0).squeeze()
+
+        mask3d_convex = points_inside_convex_hull(gaussians._xyz.detach(),mask3d,outlier_factor=1.0)
+        mask3d = torch.logical_or(mask3d,mask3d_convex)
+        mask3d = mask3d.float()[:,None,None]
+
+    # fix some gaussians
+    gaussians.inpaint_setup(opt,mask3d)
+    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, objects = render_pkg["render"], render_pkg["viewspace_points"], render_pkg["visibility_filter"], render_pkg["radii"], render_pkg["render_object"]
+
+        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, classifier):
+    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"]
+        rendering_obj = results["render_object"]
+        logits = classifier(rendering_obj)
+        pred_obj = torch.argmax(logits,dim=0)
+        pred_obj_mask = visualize_obj(pred_obj.cpu().numpy().astype(np.uint8))
+
+        gt_objects = view.objects
+        gt_rgb_mask = visualize_obj(gt_objects.cpu().numpy().astype(np.uint8))
+
+        rgb_mask = feature_to_rgb(rendering_obj)
+        Image.fromarray(rgb_mask).save(os.path.join(colormask_path, '{0:05d}'.format(idx) + ".png"))
+        Image.fromarray(gt_rgb_mask).save(os.path.join(gt_colormask_path, '{0:05d}'.format(idx) + ".png"))
+        Image.fromarray(pred_obj_mask).save(os.path.join(pred_obj_path, '{0:05d}'.format(idx) + ".png"))
+        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"))
+
+    out_path = os.path.join(render_path[:-8],'concat')
+    makedirs(out_path,exist_ok=True)
+    fourcc = cv2.VideoWriter.fourcc(*'DIVX') 
+    size = (gt.shape[-1]*5,gt.shape[-2])
+    fps = float(5) if 'train' in out_path else float(1)
+    writer = cv2.VideoWriter(os.path.join(out_path,'result.mp4'), fourcc, fps, size)
+
+    for file_name in sorted(os.listdir(gts_path)):
+        gt = np.array(Image.open(os.path.join(gts_path,file_name)))
+        rgb = np.array(Image.open(os.path.join(render_path,file_name)))
+        gt_obj = np.array(Image.open(os.path.join(gt_colormask_path,file_name)))
+        render_obj = np.array(Image.open(os.path.join(colormask_path,file_name)))
+        pred_obj = np.array(Image.open(os.path.join(pred_obj_path,file_name)))
+
+        result = np.hstack([gt,rgb,gt_obj,pred_obj,render_obj])
+        result = result.astype('uint8')
+
+        Image.fromarray(result).save(os.path.join(out_path,file_name))
+        writer.write(result[:,:,::-1])
+
+    writer.release()
+
+
+def inpaint(dataset : ModelParams, iteration : int, pipeline : PipelineParams, skip_train : bool, skip_test : bool, opt : OptimizationParams, select_obj_id : int, removal_thresh : float,  finetune_iteration: int):
+    # 1. load gaussian checkpoint
+    gaussians = GaussianModel(dataset.sh_degree)
+    scene = Scene(dataset, gaussians, load_iteration=iteration, shuffle=False)
+    num_classes = dataset.num_classes
+    print("Num classes: ",num_classes)
+    classifier = torch.nn.Conv2d(gaussians.num_objects, num_classes, kernel_size=1)
+    classifier.cuda()
+    classifier.load_state_dict(torch.load(os.path.join(dataset.model_path,"point_cloud","iteration_"+str(scene.loaded_iter),"classifier.pth")))
+    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, classifier, select_obj_id, scene.cameras_extent, removal_thresh, finetune_iteration)
+
+    # 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, classifier)
+
+        if not skip_test:
+             render_set(dataset.model_path, "test", scene.loaded_iter, scene.getTestCameras(), gaussians, pipeline, background, classifier)
+
+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")
+
+
+    args = get_combined_args(parser)
+    print("Rendering " + args.model_path)
+
+    # Read and parse the configuration file
+    try:
+        with open(args.config_file, 'r') as file:
+            config = json.load(file)
+    except FileNotFoundError:
+        print(f"Error: Configuration file '{args.config_file}' not found.")
+        exit(1)
+    except json.JSONDecodeError as e:
+        print(f"Error: Failed to parse the JSON configuration file: {e}")
+        exit(1)
+
+    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)
+
+    
+    # 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), args.select_obj_id, args.removal_thresh, args.finetune_iteration)

gaussian-grouping/edit_object_removal.py

@@ -0,0 +1,901 @@
+# 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 json
+
+import cv2
+
+from scipy.spatial import Delaunay
+
+from sklearn.cluster import DBSCAN
+from collections import Counter
+
+def points_inside_convex_hull(point_cloud, mask, remove_outliers=True, outlier_factor=1.0):
+
+    masked_points = point_cloud[mask].cpu().numpy()
+
+
+    if remove_outliers:
+        Q1 = np.percentile(masked_points, 25, axis=0)
+        Q3 = np.percentile(masked_points, 75, axis=0)
+        IQR = Q3 - Q1
+        outlier_mask = (masked_points < (Q1 - outlier_factor * IQR)) | (masked_points > (Q3 + outlier_factor * IQR))
+        filtered_masked_points = masked_points[~np.any(outlier_mask, axis=1)]
+    else:
+        filtered_masked_points = masked_points
+
+    if filtered_masked_points.shape[0] < 5:
+        return mask
+
+    delaunay = Delaunay(filtered_masked_points)
+
+    points_inside_hull_mask = delaunay.find_simplex(point_cloud.cpu().numpy()) >= 0
+
+    inside_hull_tensor_mask = torch.tensor(points_inside_hull_mask, device='cuda')
+
+    return inside_hull_tensor_mask
+
+def get_center(point_cloud, mask):
+
+    selected_points = point_cloud[mask.bool().squeeze()]
+
+    selected_points_np = selected_points.cpu().numpy()
+    Q1 = np.percentile(selected_points_np, 1, axis=0)
+    Q3 = np.percentile(selected_points_np, 99, axis=0)
+    outlier_mask = (selected_points_np < Q1) | (selected_points_np > Q3)
+    filtered_selected_points = torch.Tensor(selected_points_np[~np.any(outlier_mask, axis=1)]).cuda()
+
+    min_coor, _tmp = torch.min(filtered_selected_points, dim=0)
+    max_coor, _tmp = torch.max(filtered_selected_points, dim=0)
+
+    shrink_rate = 0.02
+    delta = (max_coor - min_coor) * shrink_rate
+    min_coor += delta
+    max_coor -= delta
+
+    center = (min_coor + max_coor) / 2
+
+    return center
+
+def get_pixel_coord(viewpoint_camera, point):
+    point_coord = list(point)
+    point_coord.append(1)
+    quad_coord = np.array([point_coord], dtype=np.float32)
+    proj_coord = (np.dot(viewpoint_camera.full_proj_transform.cpu().numpy().T, quad_coord.T)).T
+
+    proj_coord[:, :2] /= proj_coord[:, 3, np.newaxis]
+    proj_coord = proj_coord[:, :2]
+    pixel_coord = ((proj_coord + 1) / 2 * np.array([viewpoint_camera.image_width, viewpoint_camera.image_height])).astype(np.int32)
+    return np.array(pixel_coord).squeeze()
+
+def check_pos(mask, left_up, right_down):
+    l,u = left_up
+    r,d = right_down
+    rect = mask[u:d+1, l:r+1]  
+
+    white_pixels = np.sum(rect == 255)  
+    total_pixels = rect.size  
+
+    ratio = white_pixels / total_pixels  
+    if ratio < 0.8:
+        return 0
+    else:
+        rect[:] = 0
+        return 1
+
+def crop_image_to_size(image, target_width, target_height):
+    original_width, original_height = image.size
+    crop_left = (original_width - target_width) // 2
+    crop_right = original_width - crop_left
+    crop_top = (original_height - target_height) // 2
+    crop_bottom = original_height - crop_top
+    cropped_image = image.crop((crop_left, crop_top, crop_right, crop_bottom))
+    return cropped_image
+
+
+def find_clusters(vertices: np.ndarray):
+
+    dbscan = DBSCAN(eps=0.05, min_samples=15)
+    labels = dbscan.fit_predict(vertices)
+
+    label_counts = Counter(labels)
+
+    most_common_label, most_common_count = label_counts.most_common(1)[0]
+
+    members = vertices[labels == most_common_label]
+    centroid = np.mean(members, axis=0)
+
+    sx = np.max(members[:, 0]) - np.min(members[:, 0])
+    sy = np.max(members[:, 1]) - np.min(members[:, 1])
+    sz = np.max(members[:, 2]) - np.min(members[:, 2])
+
+    extend = (sx, sy, sz)
+
+    return centroid, extend
+
+def get_bb(point_cloud, mask, bb):
+
+    selected_points = point_cloud[mask.bool().squeeze()]
+    selected_points_np = selected_points.cpu().numpy()
+
+    centroid, extend = find_clusters(selected_points_np)
+
+    bb['size'] = [float(extend[i] / 2) for i in range(3)]
+    bb['centroid'] = [float(centroid[i]) for i in range(3)]
+
+
+def compute_camera_extrinsics(center, size, fov_x, fov_y, theta):
+    Cx, Cy, Cz = center
+    maxl = 2 * max(size)
+
+    r_x = 2 * maxl / (2 * np.tan(fov_x / 2))
+    r_y = 2 * maxl / (2 * np.tan(fov_y / 2))
+    r = max(r_x, r_y)
+    
+    Px = Cx + r * np.cos(theta)
+    Py = Cy + r * np.sin(theta)
+    Pz = Cz + size[2] * 2 
+    
+    P_cam = np.array([Px, Py, Pz])
+    d = np.array([Cx - Px, Cy - Py, Cz - Pz])
+    d = d / np.linalg.norm(d)  
+    
+    up = np.array([0, 0, 1])
+    
+    right = -np.cross(up, d)
+    right = right / np.linalg.norm(right)
+    
+    up = np.cross(d, right)
+    
+    R = np.vstack([right, up, d]).T
+    T = -np.linalg.inv(R) @ P_cam
+    
+    return R, T, r
+
+def cal_dis(point_cloud, T_init, threshold_xy = 0.1):
+
+    points = point_cloud.cpu().numpy()
+    filtered_points = points[
+        (np.abs(points[:, 0] - T_init[0]) < threshold_xy) & 
+        (np.abs(points[:, 1] - T_init[1]) < threshold_xy) &
+        (points[:, 2] < T_init[2])
+    ]
+
+    print(len(filtered_points), np.percentile(filtered_points, 85, axis=0)[2], np.percentile(filtered_points, 90, axis=0)[2], np.percentile(filtered_points, 95, axis=0)[2])
+
+    upper_center = np.percentile(filtered_points, 95, axis=0)
+    return T_init[2] - upper_center[2]
+
+def generate_spiral_path(T_init, radius, num_frames=180):
+    
+    theta = np.linspace(0, 2 * np.pi * 5, num_frames) 
+    
+    z = np.linspace(T_init[2], T_init[2] - radius / 2, num_frames)  
+    
+    r = np.sqrt(radius ** 2 - (z - (T_init[2] - radius)) ** 2) 
+    r[0] += 1e-5
+
+    x = T_init[0] + r * np.cos(theta)
+    y = T_init[1] + r * np.sin(theta)
+    
+    return np.vstack((x, y, z)).T
+
+def generate_circle_path(T_init, T_obj, num_frames=60):
+    
+    init_theta = np.arctan2(T_init[1]-T_obj[1], T_init[0]-T_obj[0])
+    theta = np.linspace(0, 2 * np.pi, num_frames) + init_theta 
+
+
+    r = np.sqrt((T_init[0] - T_obj[0]) ** 2 + (T_init[1] - T_obj[1]) ** 2)    
+    x = T_obj[0] + r * np.cos(theta)
+    y = T_obj[1] + r * np.sin(theta)
+    z = np.full(x.shape, T_init[2])
+
+    return np.vstack((x, y, z)).T
+
+
+def look_at(camera_position, target_position):
+    forward = target_position - camera_position
+    forward = forward / np.linalg.norm(forward)
+    
+    up = np.array([0.0, 0.0, 1.0]) 
+    
+    if np.allclose(up, forward):
+        return np.array([[1,0,0],[0,1,0],[0,0,1]])
+    if np.allclose(-up, forward):
+        return np.array([[1,0,0],[0,-1,0],[0,0,-1]])
+
+    right = np.cross(forward, up)
+    right = right / np.linalg.norm(right)
+    
+    up = np.cross(right, forward)
+    
+    rotation_matrix = np.vstack((right, -up, forward)).T
+    return rotation_matrix
+
+def find_first_intersection(ray_origin, ray_direction, points, tolerance=0.1):
+    ray_direction = ray_direction / np.linalg.norm(ray_direction)
+
+    intersections = []
+
+    for point in points:
+        vec_to_point = point - ray_origin
+        projection_length = np.dot(vec_to_point, ray_direction)
+
+        if projection_length < 0:
+            continue
+        projection_point = ray_origin + projection_length * ray_direction
+        distance_to_ray = np.linalg.norm(point - projection_point)
+        if distance_to_ray < tolerance:
+            distance_from_origin = np.linalg.norm(point - ray_origin)
+            intersections.append((point, distance_from_origin))
+    
+    if intersections:
+        intersections.sort(key=lambda x: x[1]) 
+        count_to_take = max(1, len(intersections) * 5 // 100) 
+        return intersections[count_to_take - 1][0]
+    
+    else:
+        print('find intersection failed!')
+        return find_first_intersection(ray_origin, ray_direction, points, tolerance=tolerance + 0.05)
+        raise
+
+
+def editing_setup(opt, model_path, iteration, views, gaussians, pipeline, background, cameras_extent, removal_thresh, args):
+
+    selected_obj_ids = torch.tensor(args.select_obj_id).cuda()
+
+    parameter = args.dst_center if args.operation == "translate" else args.euler_angle if args.operation == "rotate" else ""
+    print(f"Editing: {args.operation} {selected_obj_ids.item()} {parameter}")
+
+    if selected_obj_ids == -1:
+        mask3d = torch.ones(gaussians._xyz.shape[0])
+        masked_center = torch.zeros(3).cuda()
+
+    elif selected_obj_ids == -2:
+        mask3d = torch.zeros(gaussians._xyz.shape[0])
+        masked_center = torch.zeros(3).cuda()
+
+    else:
+        with torch.no_grad():
+            mask3d = gaussians._objects_dc[:,0,0] == selected_obj_ids
+            mask3d = mask3d.float()[:,None,None]
+
+        masked_center = get_center(gaussians._xyz.detach(), mask3d)
+    
+    if args.operation == 'translate':
+        dst_center = np.array(args.dst_center, dtype=float)
+
+        if dst_center[2] > 98:
+            import pickle
+            with open('config/cam_info.pkl', 'rb') as f:
+                cam_info_0 = pickle.load(f)
+                fx_color = cam_info_0.FovX
+                fy_color = cam_info_0.FovY
+                        
+            points = gaussians._xyz.detach().cpu().numpy()
+            z_avg = np.average(points[:,2], axis=0)
+
+            if args.render_coord is None:
+                x_min = np.percentile(points[:,0], 1, axis=0)
+                x_max = np.percentile(points[:,0], 99, axis=0)
+                y_min = np.percentile(points[:,1], 1, axis=0)
+                y_max = np.percentile(points[:,1], 99, axis=0)
+
+            else:
+                x_min, x_max, y_min, y_max = args.render_coord
+
+            pixels_per_unit = 1200 / max((x_max - x_min), (y_max - y_min))
+            
+            z_cam = z_avg + fx_color / pixels_per_unit
+            T_real = np.array([(x_min + x_max) / 2, (y_min + y_max) / 2, z_cam])
+            dst_center[2] = z_avg
+
+            if not mask3d.any():
+                
+                new_dst_center = find_first_intersection(T_real, dst_center-T_real, points)
+                new_dst_center[2] += 0.1
+                print(dst_center) 
+
+                dataset = args.model_path.split('/')[-1]
+                with open(f"data/{dataset}/coord", 'w') as file:
+                    file.write(f"{new_dst_center[0]} {new_dst_center[1]} {new_dst_center[2]}\n")
+
+                point_cloud_path = os.path.join(model_path, "point_cloud"+"/iteration_{}".format(iteration))
+                gaussians.save_ply(os.path.join(point_cloud_path, "point_cloud.ply"))
+
+                return gaussians
+
+            else:
+                points = gaussians._xyz.detach()
+                obj_bb = {}
+                get_bb(points, mask3d, obj_bb)
+                other_points = points[~(mask3d.bool().squeeze())]
+                new_dst_center = find_first_intersection(T_real, dst_center-T_real, other_points.cpu().numpy())
+                new_dst_center[2] += obj_bb["size"][2] / 2
+                print(obj_bb["size"], ' | ', dst_center, ' | ', new_dst_center) 
+
+                dataset = args.model_path.split('/')[-1]
+                with open(f"data/{dataset}/coord", 'w') as file:
+                    file.write(f"{new_dst_center[0]} {new_dst_center[1]} {new_dst_center[2]}\n")
+
+                for i in range(3):
+                    args.dst_center[i] = new_dst_center[i]
+
+
+    if args.operation == 'removal':
+        gaussians.removal_setup(opt, mask3d)
+    elif args.operation == 'translate':
+        
+        dst_center = torch.FloatTensor(args.dst_center).cuda()
+
+        gaussians.translate_setup(opt, mask3d, masked_center, dst_center)
+
+    elif args.operation == 'rotate':
+
+        from scipy.spatial.transform import Rotation
+        rotate_matrix = Rotation.from_euler('xyz', args.euler_angle, degrees=True).as_matrix()
+        gaussians.rotate_setup(opt, mask3d, masked_center, rotate_matrix)
+
+    point_cloud_path = os.path.join(model_path, "point_cloud"+"/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, args):
+
+    render_path = os.path.join(model_path, name, "ours{}".format(iteration), "renders")
+    render_path_with_axis = os.path.join(model_path, name, "ours{}".format(iteration), "renders_with_axis")
+    render_path_with_labels = os.path.join(model_path, name, "ours{}".format(iteration), "renders_with_labels")
+    render_path_with_highlights = os.path.join(model_path, name, "ours{}".format(iteration), "renders_with_highlights")
+    makedirs(render_path, exist_ok=True)
+    makedirs(render_path_with_axis, exist_ok=True)
+    makedirs(render_path_with_labels, exist_ok=True)
+    makedirs(render_path_with_highlights, exist_ok=True)
+
+    for idx, view in enumerate(tqdm(views, desc="Rendering progress")):
+        results = render(view, gaussians, pipeline, background)
+        rendering = results["render"]
+        
+        torchvision.utils.save_image(rendering, os.path.join(render_path, '{0:05d}'.format(idx) + ".png"))
+
+        if args.render_highlights:
+            
+            rendering_with_highlights = rendering.permute(1,2,0).cpu().numpy()
+            rendering_with_highlights = np.clip(rendering_with_highlights * 255, 0, 255).astype(np.uint8)
+            # rendering_with_highlights = (rendering_with_highlights * 255).astype(np.uint8)
+            rendering_with_highlights = cv2.cvtColor(rendering_with_highlights.astype(np.uint8), cv2.COLOR_RGB2BGR)
+
+            color_list = [
+                ("black", (0, 0, 0)),
+                ("Red", (0, 0, 255)),
+                ("Green", (0, 255, 0)),
+                ("Blue", (255, 0, 0)),
+                ("Yellow", (0, 255, 255)),
+                ("Gray", (128, 128, 128)),
+                ("Cyan", (255, 255, 0)),
+                ("Orange", (0, 165, 255)),
+                ("Purple", (128, 0, 128)),
+                ("Pink", (203, 192, 255)),
+                ("Brown", (42, 42, 165)),
+            ]
+            dir_list = np.array([[1,1,1],[1,1,-1],[1,-1,1],[1,-1,-1],[-1,1,1],[-1,1,-1],[-1,-1,1],[-1,-1,-1]])
+
+            if args.render_highlights[0] == -1:
+                obj_list = range(1,256)
+            else:
+                obj_list = args.render_highlights
+
+
+            for obj_id in obj_list:
+                with torch.no_grad():
+                    mask3d = gaussians._objects_dc[:,0,0] == obj_id
+                    if torch.count_nonzero(mask3d) < 5:
+                        break
+                    mask3d = mask3d.float()[:,None,None]
+                    
+                bb = {}
+                get_bb(gaussians._xyz.detach(), mask3d, bb)
+
+                pixel_coord = []
+                for i in range(8):
+                    point_coord = np.array(bb["centroid"]) + np.array(bb["size"]) * dir_list[i]
+                    pixel_coord.append(get_pixel_coord(view, point_coord))
+                
+                min_coord = tuple(np.min(pixel_coord, axis=0))
+                max_coord = tuple(np.max(pixel_coord, axis=0))
+                
+                cv2.rectangle(rendering_with_highlights, min_coord, max_coord, color_list[obj_id][1], 2)
+
+            cv2.imwrite(os.path.join(render_path_with_highlights, '{0:05d}'.format(idx) + ".png"), rendering_with_highlights)
+
+        if args.get_bbox_2d:
+            dir_list = np.array([[1,1,1],[1,1,-1],[1,-1,1],[1,-1,-1],[-1,1,1],[-1,1,-1],[-1,-1,1],[-1,-1,-1]])
+            centroid = [(args.get_bbox_2d[0]+args.get_bbox_2d[1])/2, (args.get_bbox_2d[2]+args.get_bbox_2d[3])/2, (args.get_bbox_2d[4]+args.get_bbox_2d[5])/2]
+            size = [(args.get_bbox_2d[1]-args.get_bbox_2d[0])/2, (args.get_bbox_2d[3]-args.get_bbox_2d[2])/2, (args.get_bbox_2d[5]-args.get_bbox_2d[4])/2] 
+            
+            pixel_coord = []
+            for i in range(8):
+                point_coord = np.array(centroid) + np.array(size) * dir_list[i]
+                pixel_coord.append(get_pixel_coord(view, point_coord))
+            
+            min_coord = tuple(np.min(pixel_coord, axis=0))
+            max_coord = tuple(np.max(pixel_coord, axis=0))
+
+            output = {}
+            output['x_min'] = min_coord[0].item()
+            output['x_max'] = max_coord[0].item()
+            output['y_min'] = min_coord[1].item()
+            output['y_max'] = max_coord[1].item()
+            
+            with open(args.model_path + '/bbox_2d.json', 'w') as f:  
+                json.dump(output, f, indent=4) 
+            
+            print("bbox_2d saved.")
+
+
+def editing(args):
+    gaussians = GaussianModel(args.sh_degree)
+    scene = Scene(args, gaussians, load_iteration=args.iteration, shuffle=False, only_gaussians=args.scanrefer)
+
+    num_classes = args.num_classes
+    print("Num classes: ",num_classes)
+    bg_color = [1,1,1] if args.white_background else [0, 0, 0]
+    background = torch.tensor(bg_color, dtype=torch.float32, device="cuda")
+
+    if args.operation == "skip":
+        point_cloud_path = os.path.join(args.model_path, "point_cloud", "iteration_{}".format(scene.loaded_iter))
+        gaussians.save_ply(os.path.join(point_cloud_path, "point_cloud.ply"))
+    
+    elif args.operation == 'crop':
+
+        objects_dc = gaussians._objects_dc.detach()
+        objects_dc[:,0,0] = 0
+        gaussians._objects_dc = objects_dc
+
+        if args.crop_coord is None:
+            points = gaussians._xyz.cpu().numpy()
+            x_min = np.percentile(points[:,0], 5, axis=0)
+            x_max = np.percentile(points[:,0], 95, axis=0)
+            y_min = np.percentile(points[:,1], 5, axis=0)
+            y_max = np.percentile(points[:,1], 95, axis=0)
+            z_min = np.percentile(points[:,2], 5, axis=0)
+            z_max = np.percentile(points[:,2], 95, axis=0)
+        else:
+            x_min, x_max, y_min, y_max, z_min, z_max = args.crop_coord
+
+        mask = (gaussians._xyz[:, 0] >= x_min) & (gaussians._xyz[:, 0] <= x_max) & (gaussians._xyz[:, 1] >= y_min) & (gaussians._xyz[:, 1] <= y_max) & (gaussians._xyz[:, 2] >= z_min) & (gaussians._xyz[:, 2] <= z_max)
+
+        gaussians._xyz = gaussians._xyz[mask].detach()
+        gaussians._features_dc = gaussians._features_dc[mask].detach()
+        gaussians._features_rest = gaussians._features_rest[mask].detach()
+        gaussians._opacity = gaussians._opacity[mask].detach()
+        gaussians._scaling = gaussians._scaling[mask].detach()
+        gaussians._rotation = gaussians._rotation[mask].detach()
+        gaussians._objects_dc = gaussians._objects_dc[mask].detach()
+        
+        point_cloud_path = os.path.join(args.model_path, "point_cloud", "iteration_{}".format(scene.loaded_iter))
+        gaussians.save_ply(os.path.join(point_cloud_path, "point_cloud.ply"))
+
+    elif args.operation == 'multi-editing':
+        for i in range(len(args.operation_list)):
+            args.operation = args.operation_list[i]
+            args.select_obj_id = args.select_obj_id_list[i]
+            args.dst_center = args.parameter_list[i]
+            args.euler_angle = args.parameter_list[i]
+            gaussians = editing_setup(opt, args.model_path, scene.loaded_iter, scene.getTrainCameras(), gaussians, pipeline, background, scene.cameras_extent, args.removal_thresh, args)
+
+    else:
+        gaussians = editing_setup(opt, args.model_path, scene.loaded_iter, scene.getTrainCameras(), gaussians, pipeline, background, scene.cameras_extent, args.removal_thresh, args)
+
+    print(args.model_path)
+    scene = Scene(args, gaussians, load_iteration='/iteration_'+str(scene.loaded_iter), shuffle=False, only_gaussians=args.scanrefer)
+    if args.scanrefer:
+        scene.loaded_iter = f'/iteration_{scene.loaded_iter}'
+
+    with torch.no_grad():
+
+        if args.render_obj != 256:
+
+            mask3d = gaussians._objects_dc[:,0,0] == abs(args.render_obj)
+            if not mask3d.any():
+                raise ValueError("Non-existent object!")
+
+            if args.render_obj < 0:
+                mask3d = ~mask3d
+
+            mask3d = mask3d.bool().squeeze()
+            gaussians._xyz = gaussians._xyz[mask3d].detach()
+            gaussians._features_dc = gaussians._features_dc[mask3d].detach()
+            gaussians._features_rest = gaussians._features_rest[mask3d].detach()
+            gaussians._opacity = gaussians._opacity[mask3d].detach()
+            gaussians._scaling = gaussians._scaling[mask3d].detach()
+            gaussians._rotation = gaussians._rotation[mask3d].detach()
+            gaussians._objects_dc = gaussians._objects_dc[mask3d].detach()
+
+
+        if args.render_ori:
+            render_set(args.model_path, "train", scene.loaded_iter, scene.getTrainCameras(), gaussians, pipeline, background, args)
+
+        elif args.render_all:
+
+            if args.scanrefer:
+                scene_id = args.model_path.split('/')[1]
+                fovfile_path = f'/media/shared_space/data/scannet/scans/{scene_id}/{scene_id}.txt' 
+                with open(fovfile_path, 'r') as file:
+                    for line in file:
+                        if line.startswith('fx_color'):
+                            fx_color = float(line.split('=')[1].strip())
+                        elif line.startswith('fy_color'):
+                            fy_color = float(line.split('=')[1].strip())
+                
+            else:
+                import pickle
+                with open('config/cam_info.pkl', 'rb') as f:
+                    cam_info_0 = pickle.load(f)
+                    fx_color = cam_info_0.FovX
+                    fy_color = cam_info_0.FovY
+                    
+            R_list = [[[1,0,0],[0,0,-1],[0,1,0]], [[1,0,0],[0,0,1],[0,-1,0]], [[0,0,1],[0,1,0],[-1,0,0]], [[0,0,-1],[0,1,0],[1,0,0]], [[1,0,0],[0,1,0],[0,0,1]], [[1,0,0],[0,-1,0],[0,0,-1]]]
+            T_list = [[0,0,0], [0,0,0], [0,0,0], [0,0,0], [0,0,0], [0,0,6]] 
+
+            from scene.dataset_readers import CameraInfo    
+            from utils.camera_utils import cameraList_from_camInfos
+            from utils.graphics_utils import focal2fov
+
+            cam_infos = []
+            
+            if args.render_angle:
+        
+                points = gaussians._xyz.cpu().numpy()
+                x_min = np.percentile(points[:,0], 1, axis=0)
+                x_max = np.percentile(points[:,0], 99, axis=0)
+                y_min = np.percentile(points[:,1], 1, axis=0)
+                y_max = np.percentile(points[:,1], 99, axis=0)
+                z_min = np.percentile(points[:,2], 1, axis=0)
+                z_max = np.percentile(points[:,2], 99, axis=0)
+
+                view_point_init = np.array( [(x_min + x_max) / 2, (y_min + y_max) / 2, z_max + (z_max - z_min) * 0.1] )
+                view_point_shift =  np.array( [args.render_angle[3], args.render_angle[4], args.render_angle[5]] )
+                view_point = view_point_init + view_point_shift
+                dst_point = view_point + np.array( [args.render_angle[0], args.render_angle[1], args.render_angle[2]] )
+
+                R = look_at(view_point, dst_point)
+                T = np.array(view_point)
+                T = -np.linalg.inv(R) @ T
+
+                new_height = 2400
+                new_width = 2400
+                
+                new_fovy = focal2fov(fy_color, new_height)
+                new_fovx = focal2fov(fx_color, new_width)
+                tmp_img = Image.new('RGB', (int(new_width), int(new_height)), (0, 0, 0))
+                cam_info = CameraInfo(5, R, T, new_fovy, new_fovx, \
+                            tmp_img, " ", " ", \
+                            new_width, new_height, tmp_img)
+                cam_infos.append(cam_info)
+
+
+            else:
+                points = gaussians._xyz.cpu().numpy()
+                z_avg = np.average(points[:,2], axis=0)
+
+                if args.render_coord is None:
+                    x_min = np.percentile(points[:,0], 1, axis=0)
+                    x_max = np.percentile(points[:,0], 99, axis=0)
+                    y_min = np.percentile(points[:,1], 1, axis=0)
+                    y_max = np.percentile(points[:,1], 99, axis=0)
+
+                else:
+                    x_min, x_max, y_min, y_max = args.render_coord
+
+                print(x_min, x_max, y_min, y_max, z_avg)
+
+                for i in [5]: 
+                
+                    pixels_per_unit = 1200 / max((x_max - x_min), (y_max - y_min))
+                    new_width = 1200 
+                    new_height = 1200 
+
+                    z_cam = z_avg + fx_color / pixels_per_unit
+                    T_real = [(x_min + x_max) / 2, (y_min + y_max) / 2, z_cam]
+
+                    R = np.array(R_list[i])
+                    T = np.array(T_real)
+                    T = -np.linalg.inv(R) @ T
+
+                    print(T_real)
+
+                    new_fovy = focal2fov(fy_color, new_height)
+                    new_fovx = focal2fov(fx_color, new_width)
+                    tmp_img = Image.new('RGB', (int(new_width), int(new_height)), (0, 0, 0))
+                    cam_info = CameraInfo(i, R, T, new_fovy, new_fovx, \
+                                tmp_img, " ", " ", \
+                                new_width, new_height, tmp_img)
+                    cam_infos.append(cam_info)
+
+            views = cameraList_from_camInfos(cam_infos, 1.0, args)
+
+            render_set(args.model_path, "train", scene.loaded_iter, views, gaussians, pipeline, background, args)
+
+        elif args.render_video:
+
+            import pickle
+            if args.scanrefer:
+                scene_id = args.model_path.split('/')[1]
+                fovfile_path = f'/media/shared_space/data/scannet/scans/{scene_id}/{scene_id}.txt' 
+                with open(fovfile_path, 'r') as file:
+                    for line in file:
+                        if line.startswith('fx_color'):
+                            fx_color = float(line.split('=')[1].strip())
+                        elif line.startswith('fy_color'):
+                            fy_color = float(line.split('=')[1].strip())
+                
+            else:
+                with open('config/cam_info.pkl', 'rb') as f:
+                    cam_info_0 = pickle.load(f)
+                    fx_color = cam_info_0.FovX
+                    fy_color = cam_info_0.FovY
+                    
+            from scene.dataset_readers import CameraInfo    
+            from utils.camera_utils import cameraList_from_camInfos
+            from utils.graphics_utils import focal2fov
+
+            cam_infos = []
+            
+            if args.render_coord is None and args.render_angle is None:
+                print("Invalid coord/angle!")
+                exit(0)
+
+            elif args.render_coord:
+                
+                x_min, x_max, y_min, y_max = args.render_coord
+                
+                points = gaussians._xyz.cpu().numpy()
+                z_avg = np.average(points[:,2], axis=0)
+                
+                print(x_min, x_max, y_min, y_max, z_avg)
+
+                new_width = 1200
+                new_height = 1200
+                pixels_per_unit = min(new_width / (x_max - x_min), new_height / (y_max - y_min))
+                
+                z_cam = z_avg + fx_color / pixels_per_unit
+                T_real = np.array([(x_min + x_max) / 2, (y_min + y_max) / 2, z_cam])
+
+                dis = cal_dis(gaussians._xyz, T_real)
+                obj_center = np.array([T_real[0], T_real[1], T_real[2] - dis])
+
+                camera_positions = generate_spiral_path(T_real, dis)
+                
+                camera_orientations = []
+
+                for pos in camera_positions:
+                    camera_orientations.append(look_at(pos, obj_center))
+                
+                camera_orientations = np.array(camera_orientations)
+
+            elif args.render_angle:
+
+                new_width = 2400
+                new_height = 2400
+
+                points = gaussians._xyz.cpu().numpy()
+                x_min = np.percentile(points[:,0], 1, axis=0)
+                x_max = np.percentile(points[:,0], 99, axis=0)
+                y_min = np.percentile(points[:,1], 1, axis=0)
+                y_max = np.percentile(points[:,1], 99, axis=0)
+                z_min = np.percentile(points[:,2], 1, axis=0)
+                z_max = np.percentile(points[:,2], 99, axis=0)
+
+                view_point_init = np.array( [(x_min + x_max) / 2, (y_min + y_max) / 2, z_max + (z_max - z_min) * 0.1] )
+                view_point_shift =  np.array( [args.render_angle[3], args.render_angle[4], args.render_angle[5]] )
+                view_point = view_point_init + view_point_shift
+                direction = np.array( [args.render_angle[0], args.render_angle[1], args.render_angle[2]] )
+                dst_point = view_point + direction
+
+                obj_center = find_first_intersection(view_point, direction, gaussians._xyz.detach().cpu().numpy())
+
+                camera_positions = generate_circle_path(view_point, obj_center)
+
+                camera_orientations = []
+
+                for pos in camera_positions:
+                    camera_orientations.append(look_at(pos, obj_center))
+                camera_orientations[0] = look_at(view_point, dst_point) # nt
+                
+                camera_orientations = np.array(camera_orientations)
+
+            for i in range(len(camera_positions)):
+
+                R = np.array(camera_orientations[i])
+                T = np.array(camera_positions[i])
+                T = -np.linalg.inv(R) @ T
+
+                new_fovy = focal2fov(fy_color, new_height)
+                new_fovx = focal2fov(fx_color, new_width)
+                tmp_img = Image.new('RGB', (int(new_width), int(new_height)), (0, 0, 0))
+                cam_info = CameraInfo(i, R, T, new_fovy, new_fovx, \
+                            tmp_img, " ", " ", \
+                            new_width, new_height, tmp_img)
+                cam_infos.append(cam_info)
+
+            camera_path = os.path.join(args.model_path, "train", "ours{}".format(scene.loaded_iter), 'cam_infos.pkl')
+            with open(camera_path, 'wb') as f:
+                pickle.dump(cam_infos, f)
+
+            views = cameraList_from_camInfos(cam_infos, 1.0, args)
+
+            render_set(args.model_path, "train", scene.loaded_iter, views, gaussians, pipeline, background, args)
+
+        elif args.render_obj_theta:
+
+            import pickle
+            with open('config/cam_info.pkl', 'rb') as f:
+                cam_info_0 = pickle.load(f)
+            
+            from scene.dataset_readers import CameraInfo    
+            from utils.camera_utils import cameraList_from_camInfos
+            from utils.graphics_utils import focal2fov
+
+            mask3d = torch.ones(gaussians._xyz.shape[0], dtype=torch.bool)
+            bb = {}
+            get_bb(gaussians._xyz.detach(), torch.tensor, bb)
+
+
+            new_width = cam_info_0.height + 60
+            new_height = cam_info_0.height + 40
+            new_fovy = focal2fov(cam_info_0.FovY, new_height)
+            new_fovx = focal2fov(cam_info_0.FovX, new_width)
+
+            R_list = []
+            T_list = []
+
+            for theta in args.render_obj_theta:
+                R, T, r = compute_camera_extrinsics(bb['centroid'], bb['size'], new_fovx, new_fovy, theta / 180 * np.pi)
+                R_list.append(R)
+                T_list.append(T)
+
+            cam_infos = []
+            
+            for i in range(len(R_list)):
+
+                cam_info = CameraInfo(i, np.array(R_list[i]), np.array(T_list[i]), new_fovy, new_fovx, \
+                            crop_image_to_size(cam_info_0.image, new_width, new_height), cam_info_0.image_path, cam_info_0.image_name+f'{i}', \
+                            new_width, new_height, crop_image_to_size(cam_info_0.objects, new_width, new_height))
+                cam_infos.append(cam_info)
+
+            views = cameraList_from_camInfos(cam_infos, 1.0, args)
+
+
+            render_set(args.model_path, "train", scene.loaded_iter, views, gaussians, pipeline, background, args)
+
+
+def get_bounding_box(args):
+    gaussians = GaussianModel(args.sh_degree)
+    scene = Scene(args, gaussians, load_iteration=args.iteration, shuffle=False,only_gaussians=args.scanrefer)
+    num_classes = args.num_classes
+    print("Num classes: ",num_classes)
+    bg_color = [1,1,1] if args.white_background else [0, 0, 0]
+    background = torch.tensor(bg_color, dtype=torch.float32, device="cuda")
+
+    bb_list = []
+
+    for obj_id in range(1, 256):
+
+        with torch.no_grad():
+            mask3d = gaussians._objects_dc[:,0,0] == obj_id
+            if torch.count_nonzero(mask3d) < 5:
+                break
+            mask3d = mask3d.float()[:,None,None]
+            
+        bb = {}
+        bb["id"] = obj_id
+        get_bb(gaussians._xyz.detach(), mask3d, bb)
+        bb_list.append(bb)
+        
+    output = {}
+    output["Scene configurations"] = bb_list
+
+    with open(args.model_path + '/bounding_boxes.json', 'w') as f:  
+        json.dump(output, f, indent=4) 
+    
+    print("Bounding box saved.")
+
+
+if __name__ == "__main__":
+    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("--quiet", action="store_true")
+
+    parser.add_argument("--config_file", type=str, help="Path to the configuration file")
+    parser.add_argument("--operation", type=str, default="skip", help="removal/translate/rotate/skip/crop/multi-editing")
+    parser.add_argument("--crop_coord", type=float, nargs='+')
+    parser.add_argument("--select_obj_id", type=int, nargs='+')
+    parser.add_argument("--dst_center", type=float, nargs='+')
+    parser.add_argument("--euler_angle", type=float, nargs='+')
+
+    parser.add_argument("--render_obj", type=int, default=256)
+
+    parser.add_argument("--render_ori", action="store_true")
+    parser.add_argument("--render_all", action="store_true")
+    parser.add_argument("--render_video", action="store_true")
+    parser.add_argument("--render_coord", type=float, nargs='+', default=None)
+    parser.add_argument("--render_angle", type=float, nargs='+', default=None)
+    parser.add_argument("--render_obj_theta", type=float, nargs='+', default=None)
+
+    parser.add_argument("--render_highlights", type=int, nargs='+')
+    parser.add_argument("--render_labels", action="store_true")
+
+    parser.add_argument("--get_bbox_2d", type=float, nargs='+', default=None)
+    parser.add_argument("--get_bounding_box", action="store_true")
+
+    parser.add_argument("--scanrefer", action="store_true")
+
+    args = parser.parse_args()
+    # print(args)
+    
+    if not args.scanrefer:
+        args = get_combined_args(parser)
+    else:
+        args.sh_degree = 0
+        args.iteration = 1
+        args.resolution = 1
+        args.data_device="cuda"
+
+    print("Rendering " + args.model_path)
+
+    args.num_classes = 256
+    args.removal_thresh = 0.3
+
+    if hasattr(args, 'select_obj_id') and args.select_obj_id != None:
+        args.select_obj_id = [ [args.select_obj_id[i]] for i in range(len(args.select_obj_id)) ]
+
+
+    if args.operation == 'multi-editing':
+
+        try:
+            with open(args.config_file, 'r') as file:
+                config = json.load(file)
+        except FileNotFoundError:
+            print(f"Error: Configuration file '{args.config_file}' not found.")
+            exit(1)
+        except json.JSONDecodeError as e:
+            print(f"Error: Failed to parse the JSON configuration file: {e}")
+            exit(1)
+
+        args.operation_list = config.get("operation_list", ["removal"])
+        args.select_obj_id_list = config.get("select_obj_id_list", [1])
+        args.parameter_list = config.get("parameter_list", [[]])
+
+    safe_state(args.quiet)
+
+    if args.get_bounding_box:
+        get_bounding_box(args)
+    else:
+        editing(args)
+
+

gaussian-grouping/ext/grounded_sam.py

@@ -0,0 +1,117 @@
+import argparse
+import os
+import sys
+import copy
+
+
+import numpy as np
+import torch
+from PIL import Image
+
+# Grounding DINO
+import groundingdino.datasets.transforms as T
+from groundingdino.models import build_model
+from groundingdino.util import box_ops
+from groundingdino.util.slconfig import SLConfig
+from groundingdino.util.utils import clean_state_dict, get_phrases_from_posmap
+from groundingdino.util.inference import annotate, load_image, predict
+
+# segment anything
+from segment_anything import build_sam, SamPredictor 
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+from huggingface_hub import hf_hub_download
+
+def load_model_hf(repo_id, filename, ckpt_config_filename, device='cpu'):
+    cache_config_file = hf_hub_download(repo_id=repo_id, filename=ckpt_config_filename)
+
+    args = SLConfig.fromfile(cache_config_file) 
+    model = build_model(args)
+    args.device = device
+
+    cache_file = hf_hub_download(repo_id=repo_id, filename=filename)
+    checkpoint = torch.load(cache_file, map_location='cpu')
+    log = model.load_state_dict(clean_state_dict(checkpoint['model']), strict=False)
+    print("Model loaded from {} \n => {}".format(cache_file, log))
+    _ = model.eval()
+    return model   
+
+def show_mask(mask, image, random_color=True):
+    if random_color:
+        color = np.concatenate([np.random.random(3), np.array([0.8])], axis=0)
+    else:
+        color = np.array([30/255, 144/255, 255/255, 0.6])
+    h, w = mask.shape[-2:]
+    mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, -1)
+    
+    annotated_frame_pil = Image.fromarray(image).convert("RGBA")
+    mask_image_pil = Image.fromarray((mask_image * 255).astype(np.uint8)).convert("RGBA")
+
+    return np.array(Image.alpha_composite(annotated_frame_pil, mask_image_pil))
+
+
+
+
+def grouned_sam_output(groundingdino_model, sam_predictor, TEXT_PROMPT, image, BOX_TRESHOLD = 0.3, TEXT_TRESHOLD = 0.45, device='cuda' ):
+    image_source = image
+    transform = T.Compose(
+        [
+            T.RandomResize([800], max_size=1333),
+            T.ToTensor(),
+            T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+        ]
+    )
+    image, _ = transform(Image.fromarray(image_source), None)
+
+    boxes, logits, phrases = predict(
+        model=groundingdino_model, 
+        image=image, 
+        caption=TEXT_PROMPT, 
+        box_threshold=BOX_TRESHOLD, 
+        text_threshold=TEXT_TRESHOLD
+    )
+    annotated_frame = annotate(image_source=image_source, boxes=boxes, logits=logits, phrases=phrases)
+    annotated_frame = annotated_frame[...,::-1] # BGR to RGB
+
+    # set image
+    sam_predictor.set_image(image_source)
+    # box: normalized box xywh -> unnormalized xyxy
+    H, W, _ = image_source.shape
+    boxes_xyxy = box_ops.box_cxcywh_to_xyxy(boxes) * torch.Tensor([W, H, W, H])
+
+    if len(boxes_xyxy) > 0:
+        transformed_boxes = sam_predictor.transform.apply_boxes_torch(boxes_xyxy, image_source.shape[:2]).to(device)
+        masks, _, _ = sam_predictor.predict_torch(
+                    point_coords = None,
+                    point_labels = None,
+                    boxes = transformed_boxes,
+                    multimask_output = False,
+                )
+    else:
+        masks = torch.zeros((1,1,H,W)).cuda()
+
+    for i in range(len(masks)):
+        annotated_frame_with_mask = show_mask(masks[i][0].cpu().numpy(), annotated_frame)
+    
+    return torch.sum(masks,dim=0).squeeze().bool(), annotated_frame_with_mask
+
+
+def select_obj_ioa(classification_maps, mask, ioa_thresh=0.7):
+    unique_classes = classification_maps.unique()
+    classes_above_threshold = []
+
+    for class_id in unique_classes:
+        class_mask = (classification_maps == class_id).byte()
+        class_area = class_mask.sum()
+        intersection = torch.sum(class_mask * mask)
+        ioa = intersection / class_area if class_area != 0 else 0  # Avoid division by zero
+        
+        if ioa > ioa_thresh:
+            classes_above_threshold.append(class_id)
+
+    return torch.tensor(classes_above_threshold).cuda()
+
+

gaussian-grouping/gaussian_renderer/__init__.py

@@ -0,0 +1,111 @@
+#
+# 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
+
+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)
+
+    # print(int(viewpoint_camera.image_height), int(viewpoint_camera.image_width))
+
+    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
+            sh_objs = pc.get_objects
+    else:
+        colors_precomp = override_color
+
+    alpha_mask = viewpoint_camera.objects.cuda().float()
+    # print(int(viewpoint_camera.image_height), int(viewpoint_camera.image_width))
+    # print(alpha_mask.shape)
+
+    # Rasterize visible Gaussians to image, obtain their radii (on screen). 
+    rendered_image, radii, rendered_objects, max_opacity = rasterizer(
+        means3D = means3D,
+        means2D = means2D,
+        alpha = alpha_mask,
+        shs = shs,
+        sh_objs = sh_objs,
+        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,
+            "render_object": rendered_objects,
+            "max_opacity": max_opacity}

gaussian-grouping/gaussian_renderer/network_gui.py

@@ -0,0 +1,86 @@
+#
+# 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

gaussian-grouping/labelling.sh

@@ -0,0 +1,44 @@
+dataset='dining-table'
+iteration=15000
+
+# Get the parent directory of the script
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PARENT_FOLDER="$(dirname "$SCRIPT_DIR")"
+
+data_path="${PARENT_FOLDER}/gaussian-grouping/data/${dataset}"
+# output_path="${PARENT_FOLDER}/gaussian-grouping/output/${dataset}" # deprecated
+
+zooming_file="${PARENT_FOLDER}/llm/tracking/searcher-zooming/output.txt"
+loc_coord=$(head -n 1 "$zooming_file")
+
+cd "${PARENT_FOLDER}/gaussian-grouping"
+
+locating_file="${PARENT_FOLDER}/llm/tracking/searcher-locating/output.txt"
+obj_coord=$(tail -n 1 "$locating_file")
+
+log_and_run() {
+  echo "[ $(basename "$0") ] -> $*"
+  "$@"
+}
+
+# echo "$(basename "$0")"; python edit_object_removal.py -m output/${dataset} --iteration ${iteration} --operation skip --render_video --render_coord ${obj_coord}
+
+cd "${PARENT_FOLDER}/segment-anything-2/notebooks/"
+
+
+python get_mask.py --dataset ${dataset}
+
+# test
+python render.py --dataset ${dataset}
+
+cp outputs/${dataset}/* ${data_path}/object_mask/
+cp ${data_path}/train/ours/iteration_${iteration}/cam_infos.pkl ${data_path}/
+
+cd "${PARENT_FOLDER}/gaussian-grouping"
+python train.py -s data/${dataset} -r 1 -m output/${dataset} --config_file config/gaussian_dataset/train.json --train_split --train_labels --iteration ${iteration}
+
+# test
+log_and_run python edit_object_removal.py -m output/${dataset} --iteration ${iteration} --operation skip --render_all --render_obj 1 --render_coord ${loc_coord}
+cp ${data_path}/train/ours/iteration_${iteration}/renders/00000.png ${PARENT_FOLDER}/llm/tracking/find-to-seg-obj.png
+log_and_run python edit_object_removal.py -m output/${dataset} --iteration ${iteration} --operation skip --render_all --render_obj 0 --render_coord ${loc_coord}
+cp ${data_path}/train/ours/iteration_${iteration}/renders/00000.png ${PARENT_FOLDER}/llm/tracking/find-to-seg-woobj.png

gaussian-grouping/metrics.py

@@ -0,0 +1,103 @@
+#
+# 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)

gaussian-grouping/render.py

@@ -0,0 +1,172 @@
+# 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, get_combined_args
+from gaussian_renderer import GaussianModel
+import numpy as np
+from PIL import Image
+import colorsys
+import cv2
+from sklearn.decomposition import PCA
+
+def feature_to_rgb(features):
+    # Input features shape: (16, H, W)
+    
+    # Reshape features for PCA
+    H, W = features.shape[1], features.shape[2]
+    features_reshaped = features.view(features.shape[0], -1).T
+
+    # Apply PCA and get the first 3 components
+    pca = PCA(n_components=3)
+    pca_result = pca.fit_transform(features_reshaped.cpu().numpy())
+
+    # Reshape back to (H, W, 3)
+    pca_result = pca_result.reshape(H, W, 3)
+
+    # Normalize to [0, 255]
+    pca_normalized = 255 * (pca_result - pca_result.min()) / (pca_result.max() - pca_result.min())
+
+    rgb_array = pca_normalized.astype('uint8')
+
+    return rgb_array
+
+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
+
+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, classifier):
+    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")):
+        # if idx < 540 or idx > 640:
+            # continue
+        results = render(view, gaussians, pipeline, background)
+        rendering = results["render"]
+        rendering_obj = results["render_object"]
+        
+        # logits = classifier(rendering_obj)
+        # pred_obj = torch.argmax(logits,dim=0)
+        # pred_obj_mask = visualize_obj(pred_obj.cpu().numpy().astype(np.uint8))
+        
+
+        gt_objects = view.objects
+        gt_rgb_mask = visualize_obj(gt_objects.cpu().numpy().astype(np.uint8))
+
+        rgb_mask = feature_to_rgb(rendering_obj)
+        Image.fromarray(rgb_mask).save(os.path.join(colormask_path, '{0:05d}'.format(idx) + ".png"))
+        Image.fromarray(gt_rgb_mask).save(os.path.join(gt_colormask_path, '{0:05d}'.format(idx) + ".png"))
+        # Image.fromarray(pred_obj_mask).save(os.path.join(pred_obj_path, '{0:05d}'.format(idx) + ".png"))
+        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"))
+
+    '''
+    out_path = os.path.join(render_path[:-8],'concat')
+    makedirs(out_path,exist_ok=True)
+    fourcc = cv2.VideoWriter.fourcc(*'mp4v') 
+    # fourcc = cv2.VideoWriter.fourcc(*'DIVX') 
+    size = (gt.shape[-1]*5,gt.shape[-2])
+    fps = float(5) if 'train' in out_path else float(1)
+    writer = cv2.VideoWriter(os.path.join(out_path,'result.mp4'), fourcc, fps, size)
+    
+    for file_name in sorted(os.listdir(gts_path)):
+        gt = np.array(Image.open(os.path.join(gts_path,file_name)))
+        rgb = np.array(Image.open(os.path.join(render_path,file_name)))
+        gt_obj = np.array(Image.open(os.path.join(gt_colormask_path,file_name)))
+        render_obj = np.array(Image.open(os.path.join(colormask_path,file_name)))
+        # pred_obj = np.array(Image.open(os.path.join(pred_obj_path,file_name)))
+
+        result = np.hstack([gt,rgb,gt_obj,pred_obj,render_obj])
+        result = result.astype('uint8')
+
+        Image.fromarray(result).save(os.path.join(out_path,file_name))
+        writer.write(result[:,:,::-1])
+    writer.release()
+    '''
+
+
+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)
+        
+        num_classes = dataset.num_classes
+        print("Num classes: ",num_classes)
+
+        classifier = torch.nn.Conv2d(gaussians.num_objects, num_classes, kernel_size=1)
+        classifier.cuda()
+        # classifier.load_state_dict(torch.load(os.path.join(dataset.model_path,"point_cloud","iteration_"+str(scene.loaded_iter),"classifier.pth")))
+
+        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, classifier)
+
+        if (not skip_test) and (len(scene.getTestCameras()) > 0):
+             render_set(dataset.model_path, "test", scene.loaded_iter, scene.getTestCameras(), gaussians, pipeline, background, classifier)
+
+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)

gaussian-grouping/render_lerf_mask.py

@@ -0,0 +1,150 @@
+# 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, get_combined_args
+from gaussian_renderer import GaussianModel
+import numpy as np
+from PIL import Image
+import cv2
+
+from ext.grounded_sam import grouned_sam_output, load_model_hf, select_obj_ioa
+from segment_anything import sam_model_registry, SamPredictor
+
+from render import feature_to_rgb, visualize_obj
+
+
+def render_set(model_path, name, iteration, views, gaussians, pipeline, background, classifier, groundingdino_model, sam_predictor, TEXT_PROMPT, threshold=0.2):
+    render_path = os.path.join(model_path, name, "ours_{}_text".format(iteration), "renders")
+    gts_path = os.path.join(model_path, name, "ours_{}_text".format(iteration), "gt")
+    colormask_path = os.path.join(model_path, name, "ours_{}_text".format(iteration), "objects_feature16")
+    pred_obj_path = os.path.join(model_path, name, "ours_{}_text".format(iteration), "test_mask")
+    makedirs(render_path, exist_ok=True)
+    makedirs(gts_path, exist_ok=True)
+    makedirs(colormask_path, exist_ok=True)
+    makedirs(pred_obj_path, exist_ok=True)
+
+    # Use Grounded-SAM on the first frame
+    results0 = render(views[0], gaussians, pipeline, background)
+    rendering0 = results0["render"]
+    rendering_obj0 = results0["render_object"]
+    logits = classifier(rendering_obj0)
+    pred_obj = torch.argmax(logits,dim=0)
+
+    image = (rendering0.permute(1,2,0) * 255).cpu().numpy().astype('uint8')
+    text_mask, annotated_frame_with_mask = grouned_sam_output(groundingdino_model, sam_predictor, TEXT_PROMPT, image)
+    Image.fromarray(annotated_frame_with_mask).save(os.path.join(render_path[:-8],'grounded-sam---'+TEXT_PROMPT+'.png'))
+    selected_obj_ids = select_obj_ioa(pred_obj, text_mask)
+
+    for idx, view in enumerate(tqdm(views, desc="Rendering progress")):
+        pred_obj_img_path = os.path.join(pred_obj_path,str(idx))
+        makedirs(pred_obj_img_path, exist_ok=True)
+
+        results = render(view, gaussians, pipeline, background)
+        rendering = results["render"]
+        rendering_obj = results["render_object"]
+        logits = classifier(rendering_obj)
+
+        if len(selected_obj_ids) > 0:
+            prob = torch.softmax(logits,dim=0)
+
+            pred_obj_mask = prob[selected_obj_ids, :, :] > threshold
+            pred_obj_mask = pred_obj_mask.any(dim=0)
+            pred_obj_mask = (pred_obj_mask.squeeze().cpu().numpy() * 255).astype(np.uint8)
+        else:
+            pred_obj_mask = torch.zeros_like(view.objects).cpu().numpy()
+
+        gt_objects = view.objects
+        gt_rgb_mask = visualize_obj(gt_objects.cpu().numpy().astype(np.uint8))
+
+        rgb_mask = feature_to_rgb(rendering_obj)
+        Image.fromarray(rgb_mask).save(os.path.join(colormask_path, '{0:05d}'.format(idx) + ".png"))
+        Image.fromarray(pred_obj_mask).save(os.path.join(pred_obj_img_path, TEXT_PROMPT + ".png"))
+        print(os.path.join(pred_obj_img_path, TEXT_PROMPT + ".png"))
+        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"))
+
+
+
+def render_sets(dataset : ModelParams, iteration : int, pipeline : PipelineParams, skip_train : bool, skip_test : bool):
+    with torch.no_grad():
+        dataset.eval = True
+        gaussians = GaussianModel(dataset.sh_degree)
+        scene = Scene(dataset, gaussians, load_iteration=iteration, shuffle=False)
+        
+        num_classes = dataset.num_classes
+        print("Num classes: ",num_classes)
+
+        classifier = torch.nn.Conv2d(gaussians.num_objects, num_classes, kernel_size=1)
+        classifier.cuda()
+        classifier.load_state_dict(torch.load(os.path.join(dataset.model_path,"point_cloud","iteration_"+str(scene.loaded_iter),"classifier.pth")))
+
+        bg_color = [1,1,1] if dataset.white_background else [0, 0, 0]
+        background = torch.tensor(bg_color, dtype=torch.float32, device="cuda")
+
+        # grounding-dino
+        # Use this command for evaluate the Grounding DINO model
+        # Or you can download the model by yourself
+        ckpt_repo_id = "ShilongLiu/GroundingDINO"
+        ckpt_filenmae = "groundingdino_swinb_cogcoor.pth"
+        ckpt_config_filename = "GroundingDINO_SwinB.cfg.py"
+        groundingdino_model = load_model_hf(ckpt_repo_id, ckpt_filenmae, ckpt_config_filename)
+
+        # sam-hq
+        sam_checkpoint = 'Tracking-Anything-with-DEVA/saves/sam_vit_h_4b8939.pth'
+        sam = sam_model_registry["vit_h"](checkpoint=sam_checkpoint)
+        sam.to(device='cuda')
+        sam_predictor = SamPredictor(sam)
+
+        # Text prompt
+        if 'figurines' in dataset.model_path:
+            positive_input = "green apple;green toy chair;old camera;porcelain hand;red apple;red toy chair;rubber duck with red hat"
+        elif 'ramen' in dataset.model_path:
+            positive_input = "chopsticks;egg;glass of water;pork belly;wavy noodles in bowl;yellow bowl"
+        elif 'teatime' in dataset.model_path:
+            positive_input = "apple;bag of cookies;coffee mug;cookies on a plate;paper napkin;plate;sheep;spoon handle;stuffed bear;tea in a glass"
+        else:
+            raise NotImplementedError   # You can provide your text prompt here
+        
+        positives = positive_input.split(";")
+        print("Text prompts:    ", positives)
+
+        for TEXT_PROMPT in positives:
+            if not skip_train:
+                render_set(dataset.model_path, "train", scene.loaded_iter, scene.getTrainCameras(), gaussians, pipeline, background, classifier, groundingdino_model, sam_predictor, TEXT_PROMPT)
+            if not skip_test:
+                render_set(dataset.model_path, "test", scene.loaded_iter, scene.getTestCameras(), gaussians, pipeline, background, classifier, groundingdino_model, sam_predictor, TEXT_PROMPT)
+
+
+             
+
+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)

gaussian-grouping/run.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+# Get the parent directory of the script
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PARENT_FOLDER="$(dirname "$SCRIPT_DIR")"
+
+for num in {1..5}
+do 
+    cd "${PARENT_FOLDER}/clevr-dataset-gen/image_generation/"
+    bash gen.sh ${num}
+    cd "${PARENT_FOLDER}/gaussian-grouping/"
+    bash cal.sh clevr-${num}    
+done

gaussian-grouping/scene/__init__.py

@@ -0,0 +1,220 @@
+#
+# 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
+from PIL import Image
+import numpy as np
+from scene.dataset_readers import CameraInfo, getNerfppNorm
+from utils.graphics_utils import focal2fov
+
+class Scene:
+
+    gaussians : GaussianModel
+
+    def __init__(self, args : ModelParams, gaussians : GaussianModel, load_iteration=None, shuffle=True, resolution_scales=[1.0], only_gaussians=False):
+        """b
+        :param path: Path to colmap scene main folder.
+        """
+        self.model_path = args.model_path
+        self.loaded_iter = None
+        self.gaussians = gaussians
+
+        # --- mtd ---
+        only_gaussians = True # 在我的实验中，我们不从头生成，而是使用预生成的 gaussian 模型，来进行 editing
+        # --- mtd ---
+
+        if only_gaussians:
+
+            self.loaded_iter = 1
+            # self.loaded_iter = load_iteration
+            # --- mtd ---
+            self.loaded_iter = load_iteration # 我们这里用 load_iteration
+
+            # import pdb; pdb.set_trace()
+            # --- mtd ---
+            if isinstance(self.loaded_iter,str):
+                ply_path = os.path.join(self.model_path, "point_cloud" + self.loaded_iter, "point_cloud.ply")
+            else:
+                ply_path = os.path.join(self.model_path, "point_cloud", "iteration_" + str(self.loaded_iter), "point_cloud.ply")
+  
+            # print(self.model_path)
+            # print(self.loaded_iter)
+            # print(isinstance(self.loaded_iter,str))
+            # if isinstance(self.loaded_iter,str):
+            #     print(os.path.join(self.model_path, "point_cloud", self.loaded_iter, "point_cloud.ply"))
+            # print(ply_path)
+
+            # if os.path.exists(ply_path) and False:
+            if os.path.exists(ply_path):
+                # print(123456)
+                self.gaussians.load_ply(ply_path)
+            else:
+                import open3d as o3d
+                scene_id = self.model_path.split('/')[1]
+                file_path = f'/media/shared_space/data/scannet/scans/{scene_id}/{scene_id}_vh_clean.ply'  # DO NOT UST NT xxx_clean_2.ply !
+                pcd = o3d.io.read_point_cloud(file_path)
+            
+                self.gaussians.create_from_pcd(pcd, 1.0)
+
+            # --- mtd ---
+            # ------------------ 新增：尝试读取摄像机信息 ------------------
+            self.train_cameras = {}
+            self.test_cameras = {}
+
+            cam_infos = []
+            cam_json_path = os.path.join(self.model_path, "cameras.json")
+            if os.path.exists(cam_json_path):
+                with open(cam_json_path, 'r') as f:
+                    json_cams = json.load(f)
+                for entry in json_cams:
+                    try:
+                        width  = entry.get('width', 800)
+                        height = entry.get('height', 600)
+                        rot    = np.array(entry['rotation'])  # shape (3,3)
+                        pos    = np.array(entry['position'])  # shape (3,)
+                        # 将 camera->world 转为 world->camera
+                        R_wc = rot.T
+                        T_wc = -R_wc @ pos
+                        fy = entry.get('fy', 500.0)
+                        fx = entry.get('fx', 500.0)
+                        FovY = focal2fov(fy, height)
+                        FovX = focal2fov(fx,  width)
+                        blank_img = Image.new('RGB', (width, height))
+                        dummy_objects = np.empty((0,), dtype=np.float32)
+                        cam_infos.append(CameraInfo(uid=entry['id'], R=R_wc, T=T_wc,
+                                                     FovY=FovY, FovX=FovX, image=blank_img,
+                                                     image_path='', image_name=str(entry['id']),
+                                                     width=width, height=height, objects=dummy_objects))
+                    except Exception as e:
+                        print(f"[Scene] Warning: skip camera entry due to {e}")
+            else:
+                # fallback：基于 correct.json 生成一个顶视虚拟相机
+                correct_json_path = os.path.join(self.model_path, "correct.json")
+                if os.path.exists(correct_json_path):
+                    width, height = 800, 800
+                    # 顶视方向：Z 轴朝相机，Y 轴向下
+                    R_cw = np.array([[1, 0, 0],
+                                     [0, 0, -1],
+                                     [0, 1, 0]])  # camera->world
+                    pos = np.array([0.0, 0.0, 10.0])
+                    R_wc = R_cw.T
+                    T_wc = -R_wc @ pos
+                    FovX = FovY = np.radians(60.0)
+                    blank_img = Image.new('RGB', (width, height))
+                    dummy_objects = np.empty((0,), dtype=np.float32)
+                    cam_infos.append(CameraInfo(uid=0, R=R_wc, T=T_wc, FovY=FovY,
+                                                 FovX=FovX, image=blank_img, image_path='',
+                                                 image_name='virtual_top', width=width,
+                                                 height=height, objects=dummy_objects))
+
+            # 若仍然没有可用相机，则继续但给出提示
+            if not cam_infos:
+                print("[Scene] Warning: no camera information found; train/test camera lists will be empty.")
+                self.cameras_extent = 1.0
+                for resolution_scale in resolution_scales:
+                    self.train_cameras[resolution_scale] = []
+                    self.test_cameras[resolution_scale] = []
+            else:
+                # 计算 nerf 归一化半径
+                nerf_norm = getNerfppNorm(cam_infos)
+                self.cameras_extent = nerf_norm["radius"]
+                for resolution_scale in resolution_scales:
+                    self.train_cameras[resolution_scale] = cameraList_from_camInfos(cam_infos, resolution_scale, args)
+                    self.test_cameras[resolution_scale] = []
+            # ------------------ 新增结束 ------------------
+            # --- mtd ---
+
+            # 保证高斯模型已加载
+            if os.path.exists(ply_path):
+                pass  # 前面已 load_ply
+            else:
+                # 若之前 create_from_pcd 已进行，这里不重复
+                pass
+
+            # 注意：不要提前 return，后续代码可能还需使用 self.train_cameras
+            return
+
+        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 = {}
+
+        # print(os.path.join(args.source_path, "sparse"))
+
+        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, n_views=args.n_views, random_init=args.random_init, train_split=args.train_split)
+        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] 

gaussian-grouping/scene/cameras.py

@@ -0,0 +1,81 @@
+#
+# 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
+from scipy.spatial.transform import Rotation as R
+
+class Camera(nn.Module):
+    def __init__(self, colmap_id, R, T, FoVx, FoVy, image, gt_alpha_mask,
+                 image_name, uid,
+                 trans=np.array([0.0, 0.0, 0.0]), scale=1.0, data_device = "cuda", objects=None, style_transfer=False
+                 ):
+        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
+
+        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:
+            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
+        
+        if style_transfer:
+            self.transfer_image = self.original_image.clone()
+
+
+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]
+

gaussian-grouping/scene/colmap_loader.py

@@ -0,0 +1,294 @@
+#
+# 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()

gaussian-grouping/scene/dataset_readers.py

@@ -0,0 +1,388 @@
+# 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 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
+
+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)
+
+        # print(R)
+        # print(T)
+
+        from scipy.spatial.transform import Rotation
+        import math
+
+       
+        file_path = f'config/camera_rotation.json'  
+        with open(file_path, 'r') as file:  
+            camera_config = json.load(file) 
+        euler_angles = camera_config['gvec_rotate_euler']
+        R_euler = Rotation.from_euler('xyz', euler_angles, degrees=True).as_matrix()
+        R = R_euler @ R
+
+        transform = np.array(camera_config['transform'])
+        T = -R @ T
+        T += transform
+        T = -np.linalg.inv(R) @ T
+
+        rotation = camera_config['rotation']
+        rotation_radians = np.radians(rotation)
+        R_z = np.array([
+            [np.cos(rotation_radians), -np.sin(rotation_radians), 0],
+            [np.sin(rotation_radians),  np.cos(rotation_radians), 0],
+            [0, 0, 1]
+        ])
+        R = R_z @ R
+
+        # T = -R @ T
+        # print(f"{T[0]} {T[1]} {T[2]}")
+
+        # if idx == 0:
+            # print(R_euler)
+
+        # print(R_rotated)
+        # print(T_rotated)
+
+        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]
+            # print(focal_length_x, focal_length_y)
+            FovY = focal2fov(focal_length_y, height)
+            FovX = focal2fov(focal_length_x, 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) if os.path.exists(image_path) else None
+        object_path = os.path.join(objects_folder, image_name + '.png')
+        objects = Image.open(object_path) if os.path.exists(object_path) else None
+
+        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)
+
+        if idx == 0:
+            new_cam_info = CameraInfo(uid=uid, R=R, T=T, FovY=intr.params[0], FovX=intr.params[1], image=image,
+                                      image_path=image_path, image_name=image_name, width=width, height=height, objects=objects)
+            import pickle
+            with open('config/cam_info.pkl', 'wb') as f:
+                pickle.dump(new_cam_info, f)
+
+    sys.stdout.write('\n')
+    return cam_infos
+
+def fetchPly(path): ###Rotate
+    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
+    
+    from scipy.spatial.transform import Rotation
+    import math
+
+    file_path = f'config/camera_rotation.json'  
+    with open(file_path, 'r') as file:  
+        camera_config = json.load(file) 
+    euler_angles = camera_config['gvec_rotate_euler']
+    R_euler = Rotation.from_euler('xyz', euler_angles, degrees=True).as_matrix()
+    positions = R_euler @ np.expand_dims(positions, -1)
+    positions = positions.squeeze(-1)
+
+
+    transform = np.array(camera_config['transform'])
+    positions += transform
+
+    rotation = camera_config['rotation']
+    rotation_radians = np.radians(rotation)
+    R_z = np.array([
+        [np.cos(rotation_radians), -np.sin(rotation_radians), 0],
+        [np.sin(rotation_radians),  np.cos(rotation_radians), 0],
+        [0, 0, 1]
+    ])
+    positions = R_z @ np.expand_dims(positions, -1)
+    positions = positions.squeeze(-1)
+
+
+    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, n_views=100, random_init=False, train_split=False):
+    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:
+        if train_split:
+            train_dir = os.path.join(path, "images_train")
+            train_names = sorted(os.listdir(train_dir))
+            train_names = [train_name.split('.')[0] for train_name in train_names]
+            train_cam_infos = []
+            test_cam_infos = []
+            for cam_info in cam_infos:
+                if cam_info.image_name in train_names:
+                    train_cam_infos.append(cam_info)
+                else:
+                    test_cam_infos.append(cam_info)
+
+        else:
+            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]
+
+            if n_views == 100:
+                pass 
+            elif n_views == 50:
+                idx_sub = np.linspace(0, len(train_cam_infos)-1, round(len(train_cam_infos)*0.5)) # 50% views
+                idx_sub = [round(i) for i in idx_sub]
+                train_cam_infos = [train_cam_infos[i_sub] for i_sub in idx_sub]
+            elif isinstance(n_views,int):
+                idx_sub = np.linspace(0, len(train_cam_infos)-1, n_views) # 3views
+                idx_sub = [round(i) for i in idx_sub]
+                train_cam_infos = [train_cam_infos[i_sub] for i_sub in idx_sub]
+                print(train_cam_infos)
+            else:
+                raise NotImplementedError
+        print("Training images:     ", len(train_cam_infos))
+        print("Testing images:     ", len(test_cam_infos))
+
+    else:
+        if train_split:
+            train_dir = os.path.join(path, "images_train")
+            train_names = sorted(os.listdir(train_dir))
+            train_names = [train_name.split('.')[0] for train_name in train_names]
+            train_cam_infos = []
+            for cam_info in cam_infos:
+                if cam_info.image_name in train_names:
+                    train_cam_infos.append(cam_info)
+            test_cam_infos = []
+        else:
+            train_cam_infos = cam_infos
+            test_cam_infos = []
+
+    nerf_normalization = getNerfppNorm(train_cam_infos)
+
+    if random_init:
+        # Since this data set has no colmap data, we start with random points
+        num_pts = 100_000
+        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)))
+        
+        ply_path = os.path.join(path, "sparse/0/points3D_randinit.ply")
+        storePly(ply_path, xyz, SH2RGB(shs) * 255)
+
+    else:
+        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)
+            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,
+                            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
+        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
+}

gaussian-grouping/scene/gaussian_model.py

@@ -0,0 +1,663 @@
+# 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
+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
+from scipy.spatial import KDTree
+
+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
+        
+        # vars def here
+
+        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._objects_dc = torch.empty(0)
+        self.num_objects = 16
+        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._objects_dc,
+            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._objects_dc,
+        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_objects(self):
+        return self._objects_dc
+    
+    @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): # use this plz!
+        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
+
+        # random init obj_id now
+        fused_objects = RGB2SH(torch.rand((fused_point_cloud.shape[0],self.num_objects), device="cuda")) # ?
+        fused_objects = fused_objects[:,:,None]
+
+        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)
+        # dist2 = dist2 / 0.05
+        # scales = torch.log(dist2)[...,None].repeat(1, 3)
+        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.99 * 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))   # save as log
+        self._rotation = nn.Parameter(rots.requires_grad_(True))    # save as inv_sigmoid
+        self._opacity = nn.Parameter(opacities.requires_grad_(True))
+        self.max_radii2D = torch.zeros((self.get_xyz.shape[0]), device="cuda")
+        self._objects_dc = nn.Parameter(fused_objects.transpose(1, 2).contiguous().requires_grad_(True))
+
+    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"},
+            {'params': [self._objects_dc], 'lr': training_args.feature_lr, "name": "obj_dc"},
+        ]
+
+        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 finetune_setup(self, training_args, mask3d):
+        # Define a function that applies the mask to the gradients
+        def mask_hook(grad):
+            return grad * mask3d
+        def mask_hook2(grad):
+            return grad * mask3d.squeeze(-1)
+        
+
+        # Register the hook to the parameter (only once!)
+        hook_xyz = self._xyz.register_hook(mask_hook2)
+        hook_dc = self._features_dc.register_hook(mask_hook)
+        hook_rest = self._features_rest.register_hook(mask_hook)
+        hook_opacity = self._opacity.register_hook(mask_hook2)
+        hook_scaling = self._scaling.register_hook(mask_hook2)
+        hook_rotation = self._rotation.register_hook(mask_hook2)
+
+        self._objects_dc.requires_grad = False
+
+        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")
+        
+        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"},
+            {'params': [self._objects_dc], 'lr': training_args.feature_lr, "name": "obj_dc"},
+        ]
+
+        self.optimizer = torch.optim.Adam(l, lr=0.0, eps=1e-15)
+
+    def removal_setup(self, training_args, mask3d):  #
+
+        mask3d = ~mask3d.bool().squeeze()
+        # print(mask3d.shape)
+        # print(self._xyz.shape)
+        # print(mask3d[0])
+
+        # 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()
+        objects_dc_sub = self._objects_dc[mask3d].detach()
+
+        # print(xyz_sub.shape)
+        # print(rotation_sub.shape)
+
+        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(set_requires_grad(xyz_sub, False))
+        self._features_dc = nn.Parameter(set_requires_grad(features_dc_sub, False))
+        self._features_rest = nn.Parameter(set_requires_grad(features_rest_sub, False))
+        self._opacity = nn.Parameter(set_requires_grad(opacity_sub, False))
+        self._scaling = nn.Parameter(set_requires_grad(scaling_sub, False))
+        self._rotation = nn.Parameter(set_requires_grad(rotation_sub, False))
+        self._objects_dc = nn.Parameter(set_requires_grad(objects_dc_sub, False))
+
+    def translate_setup(self, training_args, mask3d, ori_center, dst_center):
+
+        mask3d = mask3d.bool().squeeze()
+
+        with torch.no_grad():
+            xyz_sub = self._xyz[mask3d].detach()
+            xyz_sub += dst_center - ori_center
+            self._xyz[mask3d] = xyz_sub
+
+        '''
+        xyz_sub = self._xyz[mask3d].detach()
+
+        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)
+        
+        self._xyz = nn.Parameter(set_requires_grad(xyz_sub, False))
+        '''
+
+
+    def rotate_setup(self, training_args, mask3d, ori_center, rotate_matrix):
+        
+        mask3d = mask3d.bool().squeeze()
+        coor_ori = torch.zeros(3).cuda()
+
+        self.translate_setup(self, mask3d, ori_center, coor_ori)
+
+        with torch.no_grad():
+            xyz_sub = self._xyz[mask3d]
+            xyz_sub = (rotate_matrix @ xyz_sub.unsqueeze(-1)).squeeze(-1)
+            self._xyz[mask3d] = xyz_sub
+
+        self.translate_setup(self, mask3d, coor_ori, ori_center)
+
+        from scipy.spatial.transform import Rotation as R
+        rotation = R.from_matrix(rotate_matrix.cpu())
+        quat_last = torch.FloatTensor(rotation.as_quat()).cuda()
+        idx = torch.IntTensor([3,0,1,2]).cuda()
+        quat = quat_last.index_select(dim=-1, index=idx)
+
+        with torch.no_grad():
+            rot_sub = self._rotation[mask3d]
+            
+            w1, x1, y1, z1 = quat.split(1,dim=-1)  
+            w2, x2, y2, z2 = rot_sub.split(1,dim=-1)
+        
+            w = w1*w2 - x1*x2 - y1*y2 - z1*z2  
+            x = w1*x2 + x1*w2 + y1*z2 - z1*y2  
+            y = w1*y2 + y1*w2 + z1*x2 - x1*z2  
+            z = w1*z2 + z1*w2 + x1*y2 - y1*x2  
+        
+            rot_sub = torch.cat((w,x,y,z),dim=1)
+            self._rotation[mask3d] = rot_sub
+
+
+    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
+            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['objects_dc'], new_features['features_rest'], new_features['opacity'], new_features['rotation']
+        
+        mask3d = ~mask3d.bool().squeeze()
+        mask_xyz_values = self._xyz[~mask3d]
+
+        # 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()
+        objects_dc_sub = self._objects_dc[mask3d].detach()
+
+        # Add new points with random initialization
+        sub_features = {
+            'xyz': xyz_sub,
+            'features_dc': features_dc_sub,
+            'scaling': scaling_sub,
+            'objects_dc': objects_dc_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_objects_dc, 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)]))
+        self._objects_dc = nn.Parameter(torch.cat([set_requires_grad(objects_dc_sub, False), set_requires_grad(new_objects_dc, 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"},
+            {'params': [self._objects_dc], 'lr': training_args.feature_lr, "name": "obj_dc"}  # Assuming there's a learning rate for objects_dc in training_args
+        ]
+
+        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))
+        for i in range(self._objects_dc.shape[1]*self._objects_dc.shape[2]):
+            l.append('obj_dc_{}'.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()
+        obj_dc = self._objects_dc.detach().transpose(1, 2).flatten(start_dim=1).contiguous().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, obj_dc), 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])
+
+        objects_dc = np.zeros((xyz.shape[0], self.num_objects, 1))
+        for idx in range(self.num_objects):
+            objects_dc[:,idx,0] = np.asarray(plydata.elements[0]["obj_dc_"+str(idx)])
+
+        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._objects_dc = nn.Parameter(torch.tensor(objects_dc, dtype=torch.float, device="cuda").transpose(1, 2).contiguous().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._objects_dc = optimizable_tensors["obj_dc"]
+
+        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, new_objects_dc):
+        d = {"xyz": new_xyz,
+        "f_dc": new_features_dc,
+        "f_rest": new_features_rest,
+        "opacity": new_opacities,
+        "scaling" : new_scaling,
+        "rotation" : new_rotation,
+        "obj_dc": new_objects_dc}
+
+        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._objects_dc = optimizable_tensors["obj_dc"]
+
+        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):
+        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)
+
+        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)
+        new_objects_dc = self._objects_dc[selected_pts_mask].repeat(N,1,1)
+
+        self.densification_postfix(new_xyz, new_features_dc, new_features_rest, new_opacity, new_scaling, new_rotation, new_objects_dc)
+
+        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):
+        # 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)
+        
+        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]
+        new_objects_dc = self._objects_dc[selected_pts_mask]
+
+        self.densification_postfix(new_xyz, new_features_dc, new_features_rest, new_opacities, new_scaling, new_rotation, new_objects_dc)
+
+    def densify_and_prune(self, max_grad, min_opacity, extent, max_screen_size):
+        grads = self.xyz_gradient_accum / self.denom
+        grads[grads.isnan()] = 0.0
+
+        self.densify_and_clone(grads, max_grad, extent)
+        self.densify_and_split(grads, max_grad, extent)
+
+        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)
+
+        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

gaussian-grouping/script/edit_object_inpaint.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+# Check if the user provided an argument
+if [ "$#" -ne 2 ]; then
+    echo "Usage: $0 <output_folder> <config_file> "
+    exit 1
+fi
+
+
+output_folder="$1"
+config_file="$2"
+
+if [ ! -d "$output_folder" ]; then
+    echo "Error: Folder '$output_folder' does not exist."
+    exit 2
+fi
+
+
+
+# Remove the selected object
+python edit_object_inpaint.py  -m ${output_folder} --config_file ${config_file}
+

gaussian-grouping/script/edit_object_removal.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+
+# Check if the user provided an argument
+if [ "$#" -ne 2 ]; then
+    echo "Usage: $0 <output_folder> <config_file> "
+    exit 1
+fi
+
+
+output_folder="$1"
+config_file="$2"
+
+if [ ! -d "$output_folder" ]; then
+    echo "Error: Folder '$output_folder' does not exist."
+    exit 2
+fi
+
+
+
+# Remove the selected object
+python edit_object_removal.py -m ${output_folder} --config_file ${config_file} --iteration 15000 --skip_test

gaussian-grouping/script/eval_lerf_mask.py

@@ -0,0 +1,121 @@
+import os
+import numpy as np
+from PIL import Image
+import cv2
+import sys
+
+dataset_name = sys.argv[1]
+
+gt_folder_path = os.path.join('data/lerf_mask',dataset_name,'test_mask')
+# You can change pred_folder_path to your output
+pred_folder_path = os.path.join('result/lerf_mask',dataset_name)
+
+# General util function to get the boundary of a binary mask.
+# https://gist.github.com/bowenc0221/71f7a02afee92646ca05efeeb14d687d
+def mask_to_boundary(mask, dilation_ratio=0.02):
+    """
+    Convert binary mask to boundary mask.
+    :param mask (numpy array, uint8): binary mask
+    :param dilation_ratio (float): ratio to calculate dilation = dilation_ratio * image_diagonal
+    :return: boundary mask (numpy array)
+    """
+    h, w = mask.shape
+    img_diag = np.sqrt(h ** 2 + w ** 2)
+    dilation = int(round(dilation_ratio * img_diag))
+    if dilation < 1:
+        dilation = 1
+    # Pad image so mask truncated by the image border is also considered as boundary.
+    new_mask = cv2.copyMakeBorder(mask, 1, 1, 1, 1, cv2.BORDER_CONSTANT, value=0)
+    kernel = np.ones((3, 3), dtype=np.uint8)
+    new_mask_erode = cv2.erode(new_mask, kernel, iterations=dilation)
+    mask_erode = new_mask_erode[1 : h + 1, 1 : w + 1]
+    # G_d intersects G in the paper.
+    return mask - mask_erode
+
+
+def boundary_iou(gt, dt, dilation_ratio=0.02):
+    """
+    Compute boundary iou between two binary masks.
+    :param gt (numpy array, uint8): binary mask
+    :param dt (numpy array, uint8): binary mask
+    :param dilation_ratio (float): ratio to calculate dilation = dilation_ratio * image_diagonal
+    :return: boundary iou (float)
+    """
+    dt = (dt>128).astype('uint8')
+    gt = (gt>128).astype('uint8')
+    
+
+    gt_boundary = mask_to_boundary(gt, dilation_ratio)
+    dt_boundary = mask_to_boundary(dt, dilation_ratio)
+    intersection = ((gt_boundary * dt_boundary) > 0).sum()
+    union = ((gt_boundary + dt_boundary) > 0).sum()
+    boundary_iou = intersection / union
+    return boundary_iou
+
+
+def load_mask(mask_path):
+    """Load the mask from the given path."""
+    if os.path.exists(mask_path):
+        return np.array(Image.open(mask_path).convert('L'))  # Convert to grayscale
+    return None
+
+def resize_mask(mask, target_shape):
+    """Resize the mask to the target shape."""
+    return np.array(Image.fromarray(mask).resize((target_shape[1], target_shape[0]), resample=Image.NEAREST))
+
+def calculate_iou(mask1, mask2):
+    """Calculate IoU between two boolean masks."""
+    mask1_bool = mask1 > 128
+    mask2_bool = mask2 > 128
+    intersection = np.logical_and(mask1_bool, mask2_bool)
+    union = np.logical_or(mask1_bool, mask2_bool)
+    iou = np.sum(intersection) / np.sum(union)
+    return iou
+
+iou_scores = {}  # Store IoU scores for each class
+biou_scores = {}
+class_counts = {}  # Count the number of times each class appears
+
+# Iterate over each image and category in the GT dataset
+for image_name in os.listdir(gt_folder_path):
+    gt_image_path = os.path.join(gt_folder_path, image_name)
+    pred_image_path = os.path.join(pred_folder_path, image_name)
+    
+    if os.path.isdir(gt_image_path):
+        for cat_file in os.listdir(gt_image_path):
+            cat_id = cat_file.split('.')[0]  # Assuming cat_file format is "cat_id.png"
+            gt_mask_path = os.path.join(gt_image_path, cat_file)
+            pred_mask_path = os.path.join(pred_image_path, cat_file)
+
+            gt_mask = load_mask(gt_mask_path)
+            pred_mask = load_mask(pred_mask_path)
+            print("GT:  ",gt_mask_path)
+            print("Pred:  ",pred_mask_path)
+
+            if gt_mask is not None and pred_mask is not None:
+                # Resize prediction mask to match GT mask shape if they are different
+                if pred_mask.shape != gt_mask.shape:
+                    pred_mask = resize_mask(pred_mask, gt_mask.shape)
+
+                iou = calculate_iou(gt_mask, pred_mask)
+                biou = boundary_iou(gt_mask, pred_mask)
+                print("IoU: ",iou," BIoU:   ",biou)
+                if cat_id not in iou_scores:
+                    iou_scores[cat_id] = []
+                    biou_scores[cat_id] = []
+                iou_scores[cat_id].append(iou)
+                biou_scores[cat_id].append(biou)
+                class_counts[cat_id] = class_counts.get(cat_id, 0) + 1
+
+# Calculate mean IoU for each class
+mean_iou_per_class = {cat_id: np.mean(iou_scores[cat_id]) for cat_id in iou_scores}
+mean_biou_per_class = {cat_id: np.mean(biou_scores[cat_id]) for cat_id in biou_scores}
+
+# Calculate overall mean IoU
+overall_mean_iou = np.mean(list(mean_iou_per_class.values()))
+overall_mean_biou = np.mean(list(mean_biou_per_class.values()))
+
+print("Mean IoU per class:", mean_iou_per_class)
+print("Mean Boundary IoU per class:", mean_biou_per_class)
+print("Overall Mean IoU:", overall_mean_iou)
+print("Overall Boundary Mean IoU:", overall_mean_biou)

gaussian-grouping/script/prepare_pseudo_label.sh

@@ -0,0 +1,63 @@
+#!/bin/bash
+
+
+# Check if the user provided an argument
+if [ "$#" -ne 2 ]; then
+    echo "Usage: $0 <dataset_name>"
+    exit 1
+fi
+
+
+dataset_name="$1"
+scale="$2"
+dataset_folder="data/$dataset_name"
+
+if [ ! -d "$dataset_folder" ]; then
+    echo "Error: Folder '$dataset_folder' does not exist."
+    exit 2
+fi
+
+
+
+# 1. DEVA anything mask
+cd Tracking-Anything-with-DEVA/
+
+if [ "$scale" = "1" ]; then
+    img_path="../data/${dataset_name}/images"
+else
+    img_path="../data/${dataset_name}/images_${scale}"
+fi
+
+# colored mask for visualization check
+# ori: --size 480 \
+# SAM_NUM_POINTS_PER_BATCH=1, chunk_size=1, SAM_NUM_POINTS_PER_SIDE=32
+python demo/demo_automatic.py \
+  --chunk_size 4 \
+  --img_path "$img_path" \
+  --amp \
+  --temporal_setting semionline \
+  --SAM_NUM_POINTS_PER_BATCH 4 \
+  --size 480 \
+  --output "./example/output_gaussian_dataset/${dataset_name}" \
+  --suppress_small_objects  \
+  --SAM_PRED_IOU_THRESHOLD 0.7 \
+
+
+mv ./example/output_gaussian_dataset/${dataset_name}/Annotations ./example/output_gaussian_dataset/${dataset_name}/Annotations_color
+
+# gray mask for training
+python demo/demo_automatic.py \
+  --chunk_size 4 \
+  --img_path "$img_path" \
+  --amp \
+  --temporal_setting semionline \
+  --SAM_NUM_POINTS_PER_BATCH 4 \
+  --size 480 \
+  --output "./example/output_gaussian_dataset/${dataset_name}" \
+  --use_short_id  \
+  --suppress_small_objects  \
+  --SAM_PRED_IOU_THRESHOLD 0.7 \
+  
+# 2. copy gray mask to the correponding data path
+cp -r ./example/output_gaussian_dataset/${dataset_name}/Annotations ../data/${dataset_name}/object_mask
+cd ..

gaussian-grouping/script/prepare_pseudo_label_with_text.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+
+
+# Check if the user provided an argument
+if [ "$#" -ne 2 ]; then
+    echo "Usage: $0 <dataset_name>"
+    exit 1
+fi
+
+
+dataset_name="$1"
+prompt="$2"
+
+scale=1
+dataset_folder="data/$dataset_name"
+
+if [ ! -d "$dataset_folder" ]; then
+    echo "Error: Folder '$dataset_folder' does not exist."
+    exit 2
+fi
+
+
+
+# 1. DEVA anything mask
+cd Tracking-Anything-with-DEVA/
+
+if [ "$scale" = "1" ]; then
+    img_path="../data/${dataset_name}/images"
+else
+    img_path="../data/${dataset_name}/images_${scale}"
+fi
+
+# colored mask for visualization check
+# ori: --size 480 \
+# SAM_NUM_POINTS_PER_BATCH=1, chunk_size=1, SAM_NUM_POINTS_PER_SIDE=32
+python demo/demo_with_text.py \
+  --chunk_size 4 \
+  --img_path "$img_path" \
+  --amp \
+  --temporal_setting semionline \
+  --SAM_NUM_POINTS_PER_BATCH 4 \
+  --size 480 \
+  --output "./example/output_gaussian_dataset/${dataset_name}" \
+  --DINO_THRESHOLD 0.40 \
+  --max_missed_detection_count 0 \
+  --prompt ${prompt} 
+
+  
+# 2. copy gray mask to the correponding data path
+rm ./example/output_gaussian_dataset/${dataset_name}/object_mask -r
+
+cp -r ./example/output_gaussian_dataset/${dataset_name}/Annotations ./example/output_gaussian_dataset/${dataset_name}/object_mask
+
+python get_gray_image.py --path ./example/output_gaussian_dataset/${dataset_name} --prompt ${prompt}
+
+cp -r ./example/output_gaussian_dataset/${dataset_name}/object_mask ../data/${dataset_name}/
+cd ..

gaussian-grouping/script/train.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+# Check if the user provided an argument
+if [ "$#" -ne 2 ]; then
+    echo "Usage: $0 <dataset_name>"
+    exit 1
+fi
+
+
+dataset_name="$1"
+scale="$2"
+dataset_folder="data/$dataset_name"
+
+if [ ! -d "$dataset_folder" ]; then
+    echo "Error: Folder '$dataset_folder' does not exist."
+    exit 2
+fi
+
+
+# Gaussian Grouping training
+python train.py    -s $dataset_folder -r ${scale}  -m output/${dataset_name} --config_file config/gaussian_dataset/train.json
+
+# Segmentation rendering using trained model
+python render.py -m output/${dataset_name} --num_classes 256

gaussian-grouping/script/train_lerf.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+# Check if the user provided an argument
+if [ "$#" -ne 2 ]; then
+    echo "Usage: $0 <dataset_name>"
+    exit 1
+fi
+
+
+dataset_name="$1"
+scale="$2"
+dataset_folder="data/$dataset_name"
+
+if [ ! -d "$dataset_folder" ]; then
+    echo "Error: Folder '$dataset_folder' does not exist."
+    exit 2
+fi
+
+
+# Gaussian Grouping training
+python train.py    -s $dataset_folder -r ${scale}  -m output/${dataset_name} --config_file config/gaussian_dataset/train.json --train_split
+
+# Segmentation rendering using trained model
+python render.py -m output/${dataset_name} --num_classes 256 --images images

gaussian-grouping/script/train_lerf_randominit.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+# Check if the user provided an argument
+if [ "$#" -ne 2 ]; then
+    echo "Usage: $0 <dataset_name>"
+    exit 1
+fi
+
+
+dataset_name="$1"
+scale="$2"
+dataset_folder="data/$dataset_name"
+
+if [ ! -d "$dataset_folder" ]; then
+    echo "Error: Folder '$dataset_folder' does not exist."
+    exit 2
+fi
+
+
+# Gaussian Grouping training
+python train.py    -s $dataset_folder -r ${scale}  -m output/${dataset_name} --config_file config/gaussian_dataset/train.json --train_split --random_init
+
+# Segmentation rendering using trained model
+python render.py -m output/${dataset_name} --num_classes 256 --images images

gaussian-grouping/submodules/diff-gaussian-rasterization/CMakeLists.txt

@@ -0,0 +1,36 @@
+#
+# 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
+#
+
+cmake_minimum_required(VERSION 3.20)
+
+project(DiffRast LANGUAGES CUDA CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_CUDA_STANDARD 17)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+
+add_library(CudaRasterizer
+	cuda_rasterizer/backward.h
+	cuda_rasterizer/backward.cu
+	cuda_rasterizer/forward.h
+	cuda_rasterizer/forward.cu
+	cuda_rasterizer/auxiliary.h
+	cuda_rasterizer/rasterizer_impl.cu
+	cuda_rasterizer/rasterizer_impl.h
+	cuda_rasterizer/rasterizer.h
+)
+
+set_target_properties(CudaRasterizer PROPERTIES CUDA_ARCHITECTURES "70;75;86")
+
+target_include_directories(CudaRasterizer PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/cuda_rasterizer)
+target_include_directories(CudaRasterizer PRIVATE third_party/glm ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES})

gaussian-grouping/submodules/diff-gaussian-rasterization/LICENSE.md

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

gaussian-grouping/submodules/diff-gaussian-rasterization/README.md

@@ -0,0 +1,21 @@
+# Differential Gaussian Rasterization
+
+Modified by Gaussian-Grouping https://github.com/lkeab/gaussian-grouping
+
+Used as the rasterization engine for the paper "3D Gaussian Splatting for Real-Time Rendering of Radiance Fields". If you can make use of it in your own research, please be so kind to cite us.
+
+<section class="section" id="BibTeX">
+  <div class="container is-max-desktop content">
+    <h2 class="title">BibTeX</h2>
+    <pre><code>@Article{kerbl3Dgaussians,
+      author       = {Kerbl, Bernhard and Kopanas, Georgios and Leimk{\"u}hler, Thomas and Drettakis, George},
+      title        = {3D Gaussian Splatting for Real-Time Radiance Field Rendering},
+      journal      = {ACM Transactions on Graphics},
+      number       = {4},
+      volume       = {42},
+      month        = {July},
+      year         = {2023},
+      url          = {https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/}
+}</code></pre>
+  </div>
+</section>

gaussian-grouping/submodules/diff-gaussian-rasterization/cuda_rasterizer/auxiliary.h

@@ -0,0 +1,175 @@
+/*
+ * 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
+ */
+
+#ifndef CUDA_RASTERIZER_AUXILIARY_H_INCLUDED
+#define CUDA_RASTERIZER_AUXILIARY_H_INCLUDED
+
+#include "config.h"
+#include "stdio.h"
+
+#define BLOCK_SIZE (BLOCK_X * BLOCK_Y)
+#define NUM_WARPS (BLOCK_SIZE/32)
+
+// Spherical harmonics coefficients
+__device__ const float SH_C0 = 0.28209479177387814f;
+__device__ const float SH_C1 = 0.4886025119029199f;
+__device__ const float SH_C2[] = {
+	1.0925484305920792f,
+	-1.0925484305920792f,
+	0.31539156525252005f,
+	-1.0925484305920792f,
+	0.5462742152960396f
+};
+__device__ const float SH_C3[] = {
+	-0.5900435899266435f,
+	2.890611442640554f,
+	-0.4570457994644658f,
+	0.3731763325901154f,
+	-0.4570457994644658f,
+	1.445305721320277f,
+	-0.5900435899266435f
+};
+
+__forceinline__ __device__ float ndc2Pix(float v, int S)
+{
+	return ((v + 1.0) * S - 1.0) * 0.5;
+}
+
+__forceinline__ __device__ void getRect(const float2 p, int max_radius, uint2& rect_min, uint2& rect_max, dim3 grid)
+{
+	rect_min = {
+		min(grid.x, max((int)0, (int)((p.x - max_radius) / BLOCK_X))),
+		min(grid.y, max((int)0, (int)((p.y - max_radius) / BLOCK_Y)))
+	};
+	rect_max = {
+		min(grid.x, max((int)0, (int)((p.x + max_radius + BLOCK_X - 1) / BLOCK_X))),
+		min(grid.y, max((int)0, (int)((p.y + max_radius + BLOCK_Y - 1) / BLOCK_Y)))
+	};
+}
+
+__forceinline__ __device__ float3 transformPoint4x3(const float3& p, const float* matrix)
+{
+	float3 transformed = {
+		matrix[0] * p.x + matrix[4] * p.y + matrix[8] * p.z + matrix[12],
+		matrix[1] * p.x + matrix[5] * p.y + matrix[9] * p.z + matrix[13],
+		matrix[2] * p.x + matrix[6] * p.y + matrix[10] * p.z + matrix[14],
+	};
+	return transformed;
+}
+
+__forceinline__ __device__ float4 transformPoint4x4(const float3& p, const float* matrix)
+{
+	float4 transformed = {
+		matrix[0] * p.x + matrix[4] * p.y + matrix[8] * p.z + matrix[12],
+		matrix[1] * p.x + matrix[5] * p.y + matrix[9] * p.z + matrix[13],
+		matrix[2] * p.x + matrix[6] * p.y + matrix[10] * p.z + matrix[14],
+		matrix[3] * p.x + matrix[7] * p.y + matrix[11] * p.z + matrix[15]
+	};
+	return transformed;
+}
+
+__forceinline__ __device__ float3 transformVec4x3(const float3& p, const float* matrix)
+{
+	float3 transformed = {
+		matrix[0] * p.x + matrix[4] * p.y + matrix[8] * p.z,
+		matrix[1] * p.x + matrix[5] * p.y + matrix[9] * p.z,
+		matrix[2] * p.x + matrix[6] * p.y + matrix[10] * p.z,
+	};
+	return transformed;
+}
+
+__forceinline__ __device__ float3 transformVec4x3Transpose(const float3& p, const float* matrix)
+{
+	float3 transformed = {
+		matrix[0] * p.x + matrix[1] * p.y + matrix[2] * p.z,
+		matrix[4] * p.x + matrix[5] * p.y + matrix[6] * p.z,
+		matrix[8] * p.x + matrix[9] * p.y + matrix[10] * p.z,
+	};
+	return transformed;
+}
+
+__forceinline__ __device__ float dnormvdz(float3 v, float3 dv)
+{
+	float sum2 = v.x * v.x + v.y * v.y + v.z * v.z;
+	float invsum32 = 1.0f / sqrt(sum2 * sum2 * sum2);
+	float dnormvdz = (-v.x * v.z * dv.x - v.y * v.z * dv.y + (sum2 - v.z * v.z) * dv.z) * invsum32;
+	return dnormvdz;
+}
+
+__forceinline__ __device__ float3 dnormvdv(float3 v, float3 dv)
+{
+	float sum2 = v.x * v.x + v.y * v.y + v.z * v.z;
+	float invsum32 = 1.0f / sqrt(sum2 * sum2 * sum2);
+
+	float3 dnormvdv;
+	dnormvdv.x = ((+sum2 - v.x * v.x) * dv.x - v.y * v.x * dv.y - v.z * v.x * dv.z) * invsum32;
+	dnormvdv.y = (-v.x * v.y * dv.x + (sum2 - v.y * v.y) * dv.y - v.z * v.y * dv.z) * invsum32;
+	dnormvdv.z = (-v.x * v.z * dv.x - v.y * v.z * dv.y + (sum2 - v.z * v.z) * dv.z) * invsum32;
+	return dnormvdv;
+}
+
+__forceinline__ __device__ float4 dnormvdv(float4 v, float4 dv)
+{
+	float sum2 = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w;
+	float invsum32 = 1.0f / sqrt(sum2 * sum2 * sum2);
+
+	float4 vdv = { v.x * dv.x, v.y * dv.y, v.z * dv.z, v.w * dv.w };
+	float vdv_sum = vdv.x + vdv.y + vdv.z + vdv.w;
+	float4 dnormvdv;
+	dnormvdv.x = ((sum2 - v.x * v.x) * dv.x - v.x * (vdv_sum - vdv.x)) * invsum32;
+	dnormvdv.y = ((sum2 - v.y * v.y) * dv.y - v.y * (vdv_sum - vdv.y)) * invsum32;
+	dnormvdv.z = ((sum2 - v.z * v.z) * dv.z - v.z * (vdv_sum - vdv.z)) * invsum32;
+	dnormvdv.w = ((sum2 - v.w * v.w) * dv.w - v.w * (vdv_sum - vdv.w)) * invsum32;
+	return dnormvdv;
+}
+
+__forceinline__ __device__ float sigmoid(float x)
+{
+	return 1.0f / (1.0f + expf(-x));
+}
+
+__forceinline__ __device__ bool in_frustum(int idx,
+	const float* orig_points,
+	const float* viewmatrix,
+	const float* projmatrix,
+	bool prefiltered,
+	float3& p_view)
+{
+	float3 p_orig = { orig_points[3 * idx], orig_points[3 * idx + 1], orig_points[3 * idx + 2] };
+
+	// Bring points to screen space
+	float4 p_hom = transformPoint4x4(p_orig, projmatrix);
+	float p_w = 1.0f / (p_hom.w + 0.0000001f);
+	float3 p_proj = { p_hom.x * p_w, p_hom.y * p_w, p_hom.z * p_w };
+	p_view = transformPoint4x3(p_orig, viewmatrix);
+
+	if (p_view.z <= 0.2f)// || ((p_proj.x < -1.3 || p_proj.x > 1.3 || p_proj.y < -1.3 || p_proj.y > 1.3)))
+	{
+		if (prefiltered)
+		{
+			printf("Point is filtered although prefiltered is set. This shouldn't happen!");
+			__trap();
+		}
+		return false;
+	}
+	return true;
+}
+
+#define CHECK_CUDA(A, debug) \
+A; if(debug) { \
+auto ret = cudaDeviceSynchronize(); \
+if (ret != cudaSuccess) { \
+std::cerr << "\n[CUDA ERROR] in " << __FILE__ << "\nLine " << __LINE__ << ": " << cudaGetErrorString(ret); \
+throw std::runtime_error(cudaGetErrorString(ret)); \
+} \
+}
+
+#endif

gaussian-grouping/submodules/diff-gaussian-rasterization/cuda_rasterizer/backward.cu

@@ -0,0 +1,686 @@
+/*
+ * 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
+ */
+
+#include "backward.h"
+#include "auxiliary.h"
+#include <cooperative_groups.h>
+#include <cooperative_groups/reduce.h>
+namespace cg = cooperative_groups;
+
+// Backward pass for conversion of spherical harmonics to RGB for
+// each Gaussian.
+__device__ void computeColorFromSH(int idx, int deg, int max_coeffs, const glm::vec3* means, glm::vec3 campos, const float* shs, const bool* clamped, const glm::vec3* dL_dcolor, glm::vec3* dL_dmeans, glm::vec3* dL_dshs)
+{
+	// Compute intermediate values, as it is done during forward
+	glm::vec3 pos = means[idx];
+	glm::vec3 dir_orig = pos - campos;
+	glm::vec3 dir = dir_orig / glm::length(dir_orig);
+
+	glm::vec3* sh = ((glm::vec3*)shs) + idx * max_coeffs;
+
+	// Use PyTorch rule for clamping: if clamping was applied,
+	// gradient becomes 0.
+	glm::vec3 dL_dRGB = dL_dcolor[idx];
+	dL_dRGB.x *= clamped[3 * idx + 0] ? 0 : 1;
+	dL_dRGB.y *= clamped[3 * idx + 1] ? 0 : 1;
+	dL_dRGB.z *= clamped[3 * idx + 2] ? 0 : 1;
+
+	glm::vec3 dRGBdx(0, 0, 0);
+	glm::vec3 dRGBdy(0, 0, 0);
+	glm::vec3 dRGBdz(0, 0, 0);
+	float x = dir.x;
+	float y = dir.y;
+	float z = dir.z;
+
+	// Target location for this Gaussian to write SH gradients to
+	glm::vec3* dL_dsh = dL_dshs + idx * max_coeffs;
+
+	// No tricks here, just high school-level calculus.
+	float dRGBdsh0 = SH_C0;
+	dL_dsh[0] = dRGBdsh0 * dL_dRGB;
+	if (deg > 0)
+	{
+		float dRGBdsh1 = -SH_C1 * y;
+		float dRGBdsh2 = SH_C1 * z;
+		float dRGBdsh3 = -SH_C1 * x;
+		dL_dsh[1] = dRGBdsh1 * dL_dRGB;
+		dL_dsh[2] = dRGBdsh2 * dL_dRGB;
+		dL_dsh[3] = dRGBdsh3 * dL_dRGB;
+
+		dRGBdx = -SH_C1 * sh[3];
+		dRGBdy = -SH_C1 * sh[1];
+		dRGBdz = SH_C1 * sh[2];
+
+		if (deg > 1)
+		{
+			float xx = x * x, yy = y * y, zz = z * z;
+			float xy = x * y, yz = y * z, xz = x * z;
+
+			float dRGBdsh4 = SH_C2[0] * xy;
+			float dRGBdsh5 = SH_C2[1] * yz;
+			float dRGBdsh6 = SH_C2[2] * (2.f * zz - xx - yy);
+			float dRGBdsh7 = SH_C2[3] * xz;
+			float dRGBdsh8 = SH_C2[4] * (xx - yy);
+			dL_dsh[4] = dRGBdsh4 * dL_dRGB;
+			dL_dsh[5] = dRGBdsh5 * dL_dRGB;
+			dL_dsh[6] = dRGBdsh6 * dL_dRGB;
+			dL_dsh[7] = dRGBdsh7 * dL_dRGB;
+			dL_dsh[8] = dRGBdsh8 * dL_dRGB;
+
+			dRGBdx += SH_C2[0] * y * sh[4] + SH_C2[2] * 2.f * -x * sh[6] + SH_C2[3] * z * sh[7] + SH_C2[4] * 2.f * x * sh[8];
+			dRGBdy += SH_C2[0] * x * sh[4] + SH_C2[1] * z * sh[5] + SH_C2[2] * 2.f * -y * sh[6] + SH_C2[4] * 2.f * -y * sh[8];
+			dRGBdz += SH_C2[1] * y * sh[5] + SH_C2[2] * 2.f * 2.f * z * sh[6] + SH_C2[3] * x * sh[7];
+
+			if (deg > 2)
+			{
+				float dRGBdsh9 = SH_C3[0] * y * (3.f * xx - yy);
+				float dRGBdsh10 = SH_C3[1] * xy * z;
+				float dRGBdsh11 = SH_C3[2] * y * (4.f * zz - xx - yy);
+				float dRGBdsh12 = SH_C3[3] * z * (2.f * zz - 3.f * xx - 3.f * yy);
+				float dRGBdsh13 = SH_C3[4] * x * (4.f * zz - xx - yy);
+				float dRGBdsh14 = SH_C3[5] * z * (xx - yy);
+				float dRGBdsh15 = SH_C3[6] * x * (xx - 3.f * yy);
+				dL_dsh[9] = dRGBdsh9 * dL_dRGB;
+				dL_dsh[10] = dRGBdsh10 * dL_dRGB;
+				dL_dsh[11] = dRGBdsh11 * dL_dRGB;
+				dL_dsh[12] = dRGBdsh12 * dL_dRGB;
+				dL_dsh[13] = dRGBdsh13 * dL_dRGB;
+				dL_dsh[14] = dRGBdsh14 * dL_dRGB;
+				dL_dsh[15] = dRGBdsh15 * dL_dRGB;
+
+				dRGBdx += (
+					SH_C3[0] * sh[9] * 3.f * 2.f * xy +
+					SH_C3[1] * sh[10] * yz +
+					SH_C3[2] * sh[11] * -2.f * xy +
+					SH_C3[3] * sh[12] * -3.f * 2.f * xz +
+					SH_C3[4] * sh[13] * (-3.f * xx + 4.f * zz - yy) +
+					SH_C3[5] * sh[14] * 2.f * xz +
+					SH_C3[6] * sh[15] * 3.f * (xx - yy));
+
+				dRGBdy += (
+					SH_C3[0] * sh[9] * 3.f * (xx - yy) +
+					SH_C3[1] * sh[10] * xz +
+					SH_C3[2] * sh[11] * (-3.f * yy + 4.f * zz - xx) +
+					SH_C3[3] * sh[12] * -3.f * 2.f * yz +
+					SH_C3[4] * sh[13] * -2.f * xy +
+					SH_C3[5] * sh[14] * -2.f * yz +
+					SH_C3[6] * sh[15] * -3.f * 2.f * xy);
+
+				dRGBdz += (
+					SH_C3[1] * sh[10] * xy +
+					SH_C3[2] * sh[11] * 4.f * 2.f * yz +
+					SH_C3[3] * sh[12] * 3.f * (2.f * zz - xx - yy) +
+					SH_C3[4] * sh[13] * 4.f * 2.f * xz +
+					SH_C3[5] * sh[14] * (xx - yy));
+			}
+		}
+	}
+
+	// The view direction is an input to the computation. View direction
+	// is influenced by the Gaussian's mean, so SHs gradients
+	// must propagate back into 3D position.
+	glm::vec3 dL_ddir(glm::dot(dRGBdx, dL_dRGB), glm::dot(dRGBdy, dL_dRGB), glm::dot(dRGBdz, dL_dRGB));
+
+	// Account for normalization of direction
+	float3 dL_dmean = dnormvdv(float3{ dir_orig.x, dir_orig.y, dir_orig.z }, float3{ dL_ddir.x, dL_ddir.y, dL_ddir.z });
+
+	// Gradients of loss w.r.t. Gaussian means, but only the portion 
+	// that is caused because the mean affects the view-dependent color.
+	// Additional mean gradient is accumulated in below methods.
+	dL_dmeans[idx] += glm::vec3(dL_dmean.x, dL_dmean.y, dL_dmean.z);
+}
+
+// Backward version of INVERSE 2D covariance matrix computation
+// (due to length launched as separate kernel before other 
+// backward steps contained in preprocess)
+__global__ void computeCov2DCUDA(int P,
+	const float3* means,
+	const int* radii,
+	const float* cov3Ds,
+	const float h_x, float h_y,
+	const float tan_fovx, float tan_fovy,
+	const float* view_matrix,
+	const float* dL_dconics,
+	float3* dL_dmeans,
+	float* dL_dcov)
+{
+	auto idx = cg::this_grid().thread_rank();
+	if (idx >= P || !(radii[idx] > 0))
+		return;
+
+	// Reading location of 3D covariance for this Gaussian
+	const float* cov3D = cov3Ds + 6 * idx;
+
+	// Fetch gradients, recompute 2D covariance and relevant 
+	// intermediate forward results needed in the backward.
+	float3 mean = means[idx];
+	float3 dL_dconic = { dL_dconics[4 * idx], dL_dconics[4 * idx + 1], dL_dconics[4 * idx + 3] };
+	float3 t = transformPoint4x3(mean, view_matrix);
+	
+	const float limx = 1.3f * tan_fovx;
+	const float limy = 1.3f * tan_fovy;
+	const float txtz = t.x / t.z;
+	const float tytz = t.y / t.z;
+	t.x = min(limx, max(-limx, txtz)) * t.z;
+	t.y = min(limy, max(-limy, tytz)) * t.z;
+	
+	const float x_grad_mul = txtz < -limx || txtz > limx ? 0 : 1;
+	const float y_grad_mul = tytz < -limy || tytz > limy ? 0 : 1;
+
+	glm::mat3 J = glm::mat3(h_x / t.z, 0.0f, -(h_x * t.x) / (t.z * t.z),
+		0.0f, h_y / t.z, -(h_y * t.y) / (t.z * t.z),
+		0, 0, 0);
+
+	glm::mat3 W = glm::mat3(
+		view_matrix[0], view_matrix[4], view_matrix[8],
+		view_matrix[1], view_matrix[5], view_matrix[9],
+		view_matrix[2], view_matrix[6], view_matrix[10]);
+
+	glm::mat3 Vrk = glm::mat3(
+		cov3D[0], cov3D[1], cov3D[2],
+		cov3D[1], cov3D[3], cov3D[4],
+		cov3D[2], cov3D[4], cov3D[5]);
+
+	glm::mat3 T = W * J;
+
+	glm::mat3 cov2D = glm::transpose(T) * glm::transpose(Vrk) * T;
+
+	// Use helper variables for 2D covariance entries. More compact.
+	float a = cov2D[0][0] += 0.3f;
+	float b = cov2D[0][1];
+	float c = cov2D[1][1] += 0.3f;
+
+	float denom = a * c - b * b;
+	float dL_da = 0, dL_db = 0, dL_dc = 0;
+	float denom2inv = 1.0f / ((denom * denom) + 0.0000001f);
+
+	if (denom2inv != 0)
+	{
+		// Gradients of loss w.r.t. entries of 2D covariance matrix,
+		// given gradients of loss w.r.t. conic matrix (inverse covariance matrix).
+		// e.g., dL / da = dL / d_conic_a * d_conic_a / d_a
+		dL_da = denom2inv * (-c * c * dL_dconic.x + 2 * b * c * dL_dconic.y + (denom - a * c) * dL_dconic.z);
+		dL_dc = denom2inv * (-a * a * dL_dconic.z + 2 * a * b * dL_dconic.y + (denom - a * c) * dL_dconic.x);
+		dL_db = denom2inv * 2 * (b * c * dL_dconic.x - (denom + 2 * b * b) * dL_dconic.y + a * b * dL_dconic.z);
+
+		// Gradients of loss L w.r.t. each 3D covariance matrix (Vrk) entry, 
+		// given gradients w.r.t. 2D covariance matrix (diagonal).
+		// cov2D = transpose(T) * transpose(Vrk) * T;
+		dL_dcov[6 * idx + 0] = (T[0][0] * T[0][0] * dL_da + T[0][0] * T[1][0] * dL_db + T[1][0] * T[1][0] * dL_dc);
+		dL_dcov[6 * idx + 3] = (T[0][1] * T[0][1] * dL_da + T[0][1] * T[1][1] * dL_db + T[1][1] * T[1][1] * dL_dc);
+		dL_dcov[6 * idx + 5] = (T[0][2] * T[0][2] * dL_da + T[0][2] * T[1][2] * dL_db + T[1][2] * T[1][2] * dL_dc);
+
+		// Gradients of loss L w.r.t. each 3D covariance matrix (Vrk) entry, 
+		// given gradients w.r.t. 2D covariance matrix (off-diagonal).
+		// Off-diagonal elements appear twice --> double the gradient.
+		// cov2D = transpose(T) * transpose(Vrk) * T;
+		dL_dcov[6 * idx + 1] = 2 * T[0][0] * T[0][1] * dL_da + (T[0][0] * T[1][1] + T[0][1] * T[1][0]) * dL_db + 2 * T[1][0] * T[1][1] * dL_dc;
+		dL_dcov[6 * idx + 2] = 2 * T[0][0] * T[0][2] * dL_da + (T[0][0] * T[1][2] + T[0][2] * T[1][0]) * dL_db + 2 * T[1][0] * T[1][2] * dL_dc;
+		dL_dcov[6 * idx + 4] = 2 * T[0][2] * T[0][1] * dL_da + (T[0][1] * T[1][2] + T[0][2] * T[1][1]) * dL_db + 2 * T[1][1] * T[1][2] * dL_dc;
+	}
+	else
+	{
+		for (int i = 0; i < 6; i++)
+			dL_dcov[6 * idx + i] = 0;
+	}
+
+	// Gradients of loss w.r.t. upper 2x3 portion of intermediate matrix T
+	// cov2D = transpose(T) * transpose(Vrk) * T;
+	float dL_dT00 = 2 * (T[0][0] * Vrk[0][0] + T[0][1] * Vrk[0][1] + T[0][2] * Vrk[0][2]) * dL_da +
+		(T[1][0] * Vrk[0][0] + T[1][1] * Vrk[0][1] + T[1][2] * Vrk[0][2]) * dL_db;
+	float dL_dT01 = 2 * (T[0][0] * Vrk[1][0] + T[0][1] * Vrk[1][1] + T[0][2] * Vrk[1][2]) * dL_da +
+		(T[1][0] * Vrk[1][0] + T[1][1] * Vrk[1][1] + T[1][2] * Vrk[1][2]) * dL_db;
+	float dL_dT02 = 2 * (T[0][0] * Vrk[2][0] + T[0][1] * Vrk[2][1] + T[0][2] * Vrk[2][2]) * dL_da +
+		(T[1][0] * Vrk[2][0] + T[1][1] * Vrk[2][1] + T[1][2] * Vrk[2][2]) * dL_db;
+	float dL_dT10 = 2 * (T[1][0] * Vrk[0][0] + T[1][1] * Vrk[0][1] + T[1][2] * Vrk[0][2]) * dL_dc +
+		(T[0][0] * Vrk[0][0] + T[0][1] * Vrk[0][1] + T[0][2] * Vrk[0][2]) * dL_db;
+	float dL_dT11 = 2 * (T[1][0] * Vrk[1][0] + T[1][1] * Vrk[1][1] + T[1][2] * Vrk[1][2]) * dL_dc +
+		(T[0][0] * Vrk[1][0] + T[0][1] * Vrk[1][1] + T[0][2] * Vrk[1][2]) * dL_db;
+	float dL_dT12 = 2 * (T[1][0] * Vrk[2][0] + T[1][1] * Vrk[2][1] + T[1][2] * Vrk[2][2]) * dL_dc +
+		(T[0][0] * Vrk[2][0] + T[0][1] * Vrk[2][1] + T[0][2] * Vrk[2][2]) * dL_db;
+
+	// Gradients of loss w.r.t. upper 3x2 non-zero entries of Jacobian matrix
+	// T = W * J
+	float dL_dJ00 = W[0][0] * dL_dT00 + W[0][1] * dL_dT01 + W[0][2] * dL_dT02;
+	float dL_dJ02 = W[2][0] * dL_dT00 + W[2][1] * dL_dT01 + W[2][2] * dL_dT02;
+	float dL_dJ11 = W[1][0] * dL_dT10 + W[1][1] * dL_dT11 + W[1][2] * dL_dT12;
+	float dL_dJ12 = W[2][0] * dL_dT10 + W[2][1] * dL_dT11 + W[2][2] * dL_dT12;
+
+	float tz = 1.f / t.z;
+	float tz2 = tz * tz;
+	float tz3 = tz2 * tz;
+
+	// Gradients of loss w.r.t. transformed Gaussian mean t
+	float dL_dtx = x_grad_mul * -h_x * tz2 * dL_dJ02;
+	float dL_dty = y_grad_mul * -h_y * tz2 * dL_dJ12;
+	float dL_dtz = -h_x * tz2 * dL_dJ00 - h_y * tz2 * dL_dJ11 + (2 * h_x * t.x) * tz3 * dL_dJ02 + (2 * h_y * t.y) * tz3 * dL_dJ12;
+
+	// Account for transformation of mean to t
+	// t = transformPoint4x3(mean, view_matrix);
+	float3 dL_dmean = transformVec4x3Transpose({ dL_dtx, dL_dty, dL_dtz }, view_matrix);
+
+	// Gradients of loss w.r.t. Gaussian means, but only the portion 
+	// that is caused because the mean affects the covariance matrix.
+	// Additional mean gradient is accumulated in BACKWARD::preprocess.
+	dL_dmeans[idx] = dL_dmean;
+}
+
+// Backward pass for the conversion of scale and rotation to a 
+// 3D covariance matrix for each Gaussian. 
+__device__ void computeCov3D(int idx, const glm::vec3 scale, float mod, const glm::vec4 rot, const float* dL_dcov3Ds, glm::vec3* dL_dscales, glm::vec4* dL_drots)
+{
+	// Recompute (intermediate) results for the 3D covariance computation.
+	glm::vec4 q = rot;// / glm::length(rot);
+	float r = q.x;
+	float x = q.y;
+	float y = q.z;
+	float z = q.w;
+
+	glm::mat3 R = glm::mat3(
+		1.f - 2.f * (y * y + z * z), 2.f * (x * y - r * z), 2.f * (x * z + r * y),
+		2.f * (x * y + r * z), 1.f - 2.f * (x * x + z * z), 2.f * (y * z - r * x),
+		2.f * (x * z - r * y), 2.f * (y * z + r * x), 1.f - 2.f * (x * x + y * y)
+	);
+
+	glm::mat3 S = glm::mat3(1.0f);
+
+	glm::vec3 s = mod * scale;
+	S[0][0] = s.x;
+	S[1][1] = s.y;
+	S[2][2] = s.z;
+
+	glm::mat3 M = S * R;
+
+	const float* dL_dcov3D = dL_dcov3Ds + 6 * idx;
+
+	glm::vec3 dunc(dL_dcov3D[0], dL_dcov3D[3], dL_dcov3D[5]);
+	glm::vec3 ounc = 0.5f * glm::vec3(dL_dcov3D[1], dL_dcov3D[2], dL_dcov3D[4]);
+
+	// Convert per-element covariance loss gradients to matrix form
+	glm::mat3 dL_dSigma = glm::mat3(
+		dL_dcov3D[0], 0.5f * dL_dcov3D[1], 0.5f * dL_dcov3D[2],
+		0.5f * dL_dcov3D[1], dL_dcov3D[3], 0.5f * dL_dcov3D[4],
+		0.5f * dL_dcov3D[2], 0.5f * dL_dcov3D[4], dL_dcov3D[5]
+	);
+
+	// Compute loss gradient w.r.t. matrix M
+	// dSigma_dM = 2 * M
+	glm::mat3 dL_dM = 2.0f * M * dL_dSigma;
+
+	glm::mat3 Rt = glm::transpose(R);
+	glm::mat3 dL_dMt = glm::transpose(dL_dM);
+
+	// Gradients of loss w.r.t. scale
+	glm::vec3* dL_dscale = dL_dscales + idx;
+	dL_dscale->x = glm::dot(Rt[0], dL_dMt[0]);
+	dL_dscale->y = glm::dot(Rt[1], dL_dMt[1]);
+	dL_dscale->z = glm::dot(Rt[2], dL_dMt[2]);
+
+	dL_dMt[0] *= s.x;
+	dL_dMt[1] *= s.y;
+	dL_dMt[2] *= s.z;
+
+	// Gradients of loss w.r.t. normalized quaternion
+	glm::vec4 dL_dq;
+	dL_dq.x = 2 * z * (dL_dMt[0][1] - dL_dMt[1][0]) + 2 * y * (dL_dMt[2][0] - dL_dMt[0][2]) + 2 * x * (dL_dMt[1][2] - dL_dMt[2][1]);
+	dL_dq.y = 2 * y * (dL_dMt[1][0] + dL_dMt[0][1]) + 2 * z * (dL_dMt[2][0] + dL_dMt[0][2]) + 2 * r * (dL_dMt[1][2] - dL_dMt[2][1]) - 4 * x * (dL_dMt[2][2] + dL_dMt[1][1]);
+	dL_dq.z = 2 * x * (dL_dMt[1][0] + dL_dMt[0][1]) + 2 * r * (dL_dMt[2][0] - dL_dMt[0][2]) + 2 * z * (dL_dMt[1][2] + dL_dMt[2][1]) - 4 * y * (dL_dMt[2][2] + dL_dMt[0][0]);
+	dL_dq.w = 2 * r * (dL_dMt[0][1] - dL_dMt[1][0]) + 2 * x * (dL_dMt[2][0] + dL_dMt[0][2]) + 2 * y * (dL_dMt[1][2] + dL_dMt[2][1]) - 4 * z * (dL_dMt[1][1] + dL_dMt[0][0]);
+
+	// Gradients of loss w.r.t. unnormalized quaternion
+	float4* dL_drot = (float4*)(dL_drots + idx);
+	*dL_drot = float4{ dL_dq.x, dL_dq.y, dL_dq.z, dL_dq.w };//dnormvdv(float4{ rot.x, rot.y, rot.z, rot.w }, float4{ dL_dq.x, dL_dq.y, dL_dq.z, dL_dq.w });
+}
+
+// Backward pass of the preprocessing steps, except
+// for the covariance computation and inversion
+// (those are handled by a previous kernel call)
+template<int C>
+__global__ void preprocessCUDA(
+	int P, int D, int M,
+	const float3* means,
+	const int* radii,
+	const float* shs,
+	const bool* clamped,
+	const glm::vec3* scales,
+	const glm::vec4* rotations,
+	const float scale_modifier,
+	const float* proj,
+	const glm::vec3* campos,
+	const float3* dL_dmean2D,
+	glm::vec3* dL_dmeans,
+	float* dL_dcolor,
+	float* dL_dcov3D,
+	float* dL_dsh,
+	glm::vec3* dL_dscale,
+	glm::vec4* dL_drot)
+{
+	auto idx = cg::this_grid().thread_rank();
+	if (idx >= P || !(radii[idx] > 0))
+		return;
+
+	float3 m = means[idx];
+
+	// Taking care of gradients from the screenspace points
+	float4 m_hom = transformPoint4x4(m, proj);
+	float m_w = 1.0f / (m_hom.w + 0.0000001f);
+
+	// Compute loss gradient w.r.t. 3D means due to gradients of 2D means
+	// from rendering procedure
+	glm::vec3 dL_dmean;
+	float mul1 = (proj[0] * m.x + proj[4] * m.y + proj[8] * m.z + proj[12]) * m_w * m_w;
+	float mul2 = (proj[1] * m.x + proj[5] * m.y + proj[9] * m.z + proj[13]) * m_w * m_w;
+	dL_dmean.x = (proj[0] * m_w - proj[3] * mul1) * dL_dmean2D[idx].x + (proj[1] * m_w - proj[3] * mul2) * dL_dmean2D[idx].y;
+	dL_dmean.y = (proj[4] * m_w - proj[7] * mul1) * dL_dmean2D[idx].x + (proj[5] * m_w - proj[7] * mul2) * dL_dmean2D[idx].y;
+	dL_dmean.z = (proj[8] * m_w - proj[11] * mul1) * dL_dmean2D[idx].x + (proj[9] * m_w - proj[11] * mul2) * dL_dmean2D[idx].y;
+
+	// That's the second part of the mean gradient. Previous computation
+	// of cov2D and following SH conversion also affects it.
+	dL_dmeans[idx] += dL_dmean;
+
+	// Compute gradient updates due to computing colors from SHs
+	if (shs)
+		computeColorFromSH(idx, D, M, (glm::vec3*)means, *campos, shs, clamped, (glm::vec3*)dL_dcolor, (glm::vec3*)dL_dmeans, (glm::vec3*)dL_dsh);
+
+	// Compute gradient updates due to computing covariance from scale/rotation
+	if (scales)
+		computeCov3D(idx, scales[idx], scale_modifier, rotations[idx], dL_dcov3D, dL_dscale, dL_drot);
+}
+
+// Backward version of the rendering procedure.
+template <uint32_t C, uint32_t O>
+__global__ void __launch_bounds__(BLOCK_X * BLOCK_Y)
+renderCUDA(
+	const uint2* __restrict__ ranges,
+	const uint32_t* __restrict__ point_list,
+	int W, int H,
+	const float* __restrict__ bg_color,
+	const float2* __restrict__ points_xy_image,
+	const float4* __restrict__ conic_opacity,
+	const float* __restrict__ colors,
+	const float* __restrict__ objects,
+	const float* __restrict__ final_Ts,
+	const uint32_t* __restrict__ n_contrib,
+	const float* __restrict__ dL_dpixels,
+	const float* __restrict__ dL_dpixels_objs,
+	float3* __restrict__ dL_dmean2D,
+	float4* __restrict__ dL_dconic2D,
+	float* __restrict__ dL_dopacity,
+	float* __restrict__ dL_dcolors,
+	float* __restrict__ dL_dobjects)
+{
+	// We rasterize again. Compute necessary block info.
+	auto block = cg::this_thread_block();
+	const uint32_t horizontal_blocks = (W + BLOCK_X - 1) / BLOCK_X;
+	const uint2 pix_min = { block.group_index().x * BLOCK_X, block.group_index().y * BLOCK_Y };
+	const uint2 pix_max = { min(pix_min.x + BLOCK_X, W), min(pix_min.y + BLOCK_Y , H) };
+	const uint2 pix = { pix_min.x + block.thread_index().x, pix_min.y + block.thread_index().y };
+	const uint32_t pix_id = W * pix.y + pix.x;
+	const float2 pixf = { (float)pix.x, (float)pix.y };
+
+	const bool inside = pix.x < W&& pix.y < H;
+	const uint2 range = ranges[block.group_index().y * horizontal_blocks + block.group_index().x];
+
+	const int rounds = ((range.y - range.x + BLOCK_SIZE - 1) / BLOCK_SIZE);
+
+	bool done = !inside;
+	int toDo = range.y - range.x;
+
+	__shared__ int collected_id[BLOCK_SIZE];
+	__shared__ float2 collected_xy[BLOCK_SIZE];
+	__shared__ float4 collected_conic_opacity[BLOCK_SIZE];
+	__shared__ float collected_colors[C * BLOCK_SIZE];
+	__shared__ float collected_objects[O * BLOCK_SIZE];
+
+	// In the forward, we stored the final value for T, the
+	// product of all (1 - alpha) factors. 
+	const float T_final = inside ? final_Ts[pix_id] : 0;
+	float T = T_final;
+
+	// We start from the back. The ID of the last contributing
+	// Gaussian is known from each pixel from the forward.
+	uint32_t contributor = toDo;
+	const int last_contributor = inside ? n_contrib[pix_id] : 0;
+
+	float accum_rec[C] = { 0 };
+	float accum_rec_obj[O] = { 0 };
+	float dL_dpixel[C];
+	float dL_dpixel_obj[O];
+	if (inside)
+	{
+		for (int i = 0; i < C; i++)
+			dL_dpixel[i] = dL_dpixels[i * H * W + pix_id];
+		for (int i = 0; i < O; i++)
+			dL_dpixel_obj[i] = dL_dpixels_objs[i * H * W + pix_id];
+	}
+
+	float last_alpha = 0;
+	float last_color[C] = { 0 };
+	float last_object[O] = { 0 };
+
+	// Gradient of pixel coordinate w.r.t. normalized 
+	// screen-space viewport corrdinates (-1 to 1)
+	const float ddelx_dx = 0.5 * W;
+	const float ddely_dy = 0.5 * H;
+
+	// Traverse all Gaussians
+	for (int i = 0; i < rounds; i++, toDo -= BLOCK_SIZE)
+	{
+		// Load auxiliary data into shared memory, start in the BACK
+		// and load them in revers order.
+		block.sync();
+		const int progress = i * BLOCK_SIZE + block.thread_rank();
+		if (range.x + progress < range.y)
+		{
+			const int coll_id = point_list[range.y - progress - 1];
+			collected_id[block.thread_rank()] = coll_id;
+			collected_xy[block.thread_rank()] = points_xy_image[coll_id];
+			collected_conic_opacity[block.thread_rank()] = conic_opacity[coll_id];
+			for (int i = 0; i < C; i++)
+				collected_colors[i * BLOCK_SIZE + block.thread_rank()] = colors[coll_id * C + i];
+			for (int i = 0; i < O; i++)
+				collected_objects[i * BLOCK_SIZE + block.thread_rank()] = objects[coll_id * O + i];
+		}
+		block.sync();
+
+		// Iterate over Gaussians
+		for (int j = 0; !done && j < min(BLOCK_SIZE, toDo); j++)
+		{
+			// Keep track of current Gaussian ID. Skip, if this one
+			// is behind the last contributor for this pixel.
+			contributor--;
+			if (contributor >= last_contributor)
+				continue;
+
+			// Compute blending values, as before.
+			const float2 xy = collected_xy[j];
+			const float2 d = { xy.x - pixf.x, xy.y - pixf.y };
+			const float4 con_o = collected_conic_opacity[j];
+			const float power = -0.5f * (con_o.x * d.x * d.x + con_o.z * d.y * d.y) - con_o.y * d.x * d.y;
+			if (power > 0.0f)
+				continue;
+
+			const float G = exp(power);
+			const float alpha = min(0.99f, con_o.w * G);
+			if (alpha < 1.0f / 255.0f)
+				continue;
+
+			T = T / (1.f - alpha);
+			const float dchannel_dcolor = alpha * T;
+
+			// Propagate gradients to per-Gaussian colors and keep
+			// gradients w.r.t. alpha (blending factor for a Gaussian/pixel
+			// pair).
+			float dL_dalpha = 0.0f;
+			const int global_id = collected_id[j];
+			for (int ch = 0; ch < C; ch++)
+			{
+				const float c = collected_colors[ch * BLOCK_SIZE + j];
+				// Update last color (to be used in the next iteration)
+				accum_rec[ch] = last_alpha * last_color[ch] + (1.f - last_alpha) * accum_rec[ch];
+				last_color[ch] = c;
+
+				const float dL_dchannel = dL_dpixel[ch];
+				dL_dalpha += (c - accum_rec[ch]) * dL_dchannel;
+				// Update the gradients w.r.t. color of the Gaussian. 
+				// Atomic, since this pixel is just one of potentially
+				// many that were affected by this Gaussian.
+				atomicAdd(&(dL_dcolors[global_id * C + ch]), dchannel_dcolor * dL_dchannel);
+			}
+
+			for (int ch = 0; ch < O; ch++)
+			{
+				const float o = collected_objects[ch * BLOCK_SIZE + j];
+				accum_rec_obj[ch] = last_alpha * last_object[ch] + (1.f - last_alpha) * accum_rec_obj[ch];
+				last_object[ch] = o;
+
+				const float dL_dchannel_obj = dL_dpixel_obj[ch];
+				dL_dalpha += (o - accum_rec_obj[ch]) * dL_dchannel_obj;
+
+				atomicAdd(&(dL_dobjects[global_id * O + ch]), dchannel_dcolor * dL_dchannel_obj);
+			}
+			dL_dalpha *= T;
+			// Update last alpha (to be used in the next iteration)
+			last_alpha = alpha;
+
+			// Account for fact that alpha also influences how much of
+			// the background color is added if nothing left to blend
+			float bg_dot_dpixel = 0;
+			for (int i = 0; i < C; i++)
+				bg_dot_dpixel += bg_color[i] * dL_dpixel[i];
+			dL_dalpha += (-T_final / (1.f - alpha)) * bg_dot_dpixel;
+
+
+			// Helpful reusable temporary variables
+			const float dL_dG = con_o.w * dL_dalpha;
+			const float gdx = G * d.x;
+			const float gdy = G * d.y;
+			const float dG_ddelx = -gdx * con_o.x - gdy * con_o.y;
+			const float dG_ddely = -gdy * con_o.z - gdx * con_o.y;
+
+			// Update gradients w.r.t. 2D mean position of the Gaussian
+			atomicAdd(&dL_dmean2D[global_id].x, dL_dG * dG_ddelx * ddelx_dx);
+			atomicAdd(&dL_dmean2D[global_id].y, dL_dG * dG_ddely * ddely_dy);
+
+			// Update gradients w.r.t. 2D covariance (2x2 matrix, symmetric)
+			atomicAdd(&dL_dconic2D[global_id].x, -0.5f * gdx * d.x * dL_dG);
+			atomicAdd(&dL_dconic2D[global_id].y, -0.5f * gdx * d.y * dL_dG);
+			atomicAdd(&dL_dconic2D[global_id].w, -0.5f * gdy * d.y * dL_dG);
+
+			// Update gradients w.r.t. opacity of the Gaussian
+			atomicAdd(&(dL_dopacity[global_id]), G * dL_dalpha);
+		}
+	}
+}
+
+void BACKWARD::preprocess(
+	int P, int D, int M,
+	const float3* means3D,
+	const int* radii,
+	const float* shs,
+	const bool* clamped,
+	const glm::vec3* scales,
+	const glm::vec4* rotations,
+	const float scale_modifier,
+	const float* cov3Ds,
+	const float* viewmatrix,
+	const float* projmatrix,
+	const float focal_x, float focal_y,
+	const float tan_fovx, float tan_fovy,
+	const glm::vec3* campos,
+	const float3* dL_dmean2D,
+	const float* dL_dconic,
+	glm::vec3* dL_dmean3D,
+	float* dL_dcolor,
+	float* dL_dcov3D,
+	float* dL_dsh,
+	glm::vec3* dL_dscale,
+	glm::vec4* dL_drot)
+{
+	// Propagate gradients for the path of 2D conic matrix computation. 
+	// Somewhat long, thus it is its own kernel rather than being part of 
+	// "preprocess". When done, loss gradient w.r.t. 3D means has been
+	// modified and gradient w.r.t. 3D covariance matrix has been computed.	
+	computeCov2DCUDA << <(P + 255) / 256, 256 >> > (
+		P,
+		means3D,
+		radii,
+		cov3Ds,
+		focal_x,
+		focal_y,
+		tan_fovx,
+		tan_fovy,
+		viewmatrix,
+		dL_dconic,
+		(float3*)dL_dmean3D,
+		dL_dcov3D);
+
+	// Propagate gradients for remaining steps: finish 3D mean gradients,
+	// propagate color gradients to SH (if desireD), propagate 3D covariance
+	// matrix gradients to scale and rotation.
+	preprocessCUDA<NUM_CHANNELS> << < (P + 255) / 256, 256 >> > (
+		P, D, M,
+		(float3*)means3D,
+		radii,
+		shs,
+		clamped,
+		(glm::vec3*)scales,
+		(glm::vec4*)rotations,
+		scale_modifier,
+		projmatrix,
+		campos,
+		(float3*)dL_dmean2D,
+		(glm::vec3*)dL_dmean3D,
+		dL_dcolor,
+		dL_dcov3D,
+		dL_dsh,
+		dL_dscale,
+		dL_drot);
+}
+
+void BACKWARD::render(
+	const dim3 grid, const dim3 block,
+	const uint2* ranges,
+	const uint32_t* point_list,
+	int W, int H,
+	const float* bg_color,
+	const float2* means2D,
+	const float4* conic_opacity,
+	const float* colors,
+	const float* objects,
+	const float* final_Ts,
+	const uint32_t* n_contrib,
+	const float* dL_dpixels,
+	const float* dL_dpixels_objs,
+	float3* dL_dmean2D,
+	float4* dL_dconic2D,
+	float* dL_dopacity,
+	float* dL_dcolors,
+	float* dL_dobjects)
+{
+	renderCUDA<NUM_CHANNELS, NUM_OBJECTS> << <grid, block >> >(
+		ranges,
+		point_list,
+		W, H,
+		bg_color,
+		means2D,
+		conic_opacity,
+		colors,
+		objects,
+		final_Ts,
+		n_contrib,
+		dL_dpixels,
+		dL_dpixels_objs,
+		dL_dmean2D,
+		dL_dconic2D,
+		dL_dopacity,
+		dL_dcolors,
+		dL_dobjects
+		);
+}

gaussian-grouping/submodules/diff-gaussian-rasterization/cuda_rasterizer/backward.h

@@ -0,0 +1,66 @@
+/*
+ * 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
+ */
+
+#ifndef CUDA_RASTERIZER_BACKWARD_H_INCLUDED
+#define CUDA_RASTERIZER_BACKWARD_H_INCLUDED
+
+#include <cuda.h>
+#include "cuda_runtime.h"
+#include "device_launch_parameters.h"
+#define GLM_FORCE_CUDA
+#include <glm/glm.hpp>
+
+namespace BACKWARD
+{
+	void render(
+		const dim3 grid, dim3 block,
+		const uint2* ranges,
+		const uint32_t* point_list,
+		int W, int H,
+		const float* bg_color,
+		const float2* means2D,
+		const float4* conic_opacity,
+		const float* colors,
+		const float* objects,
+		const float* final_Ts,
+		const uint32_t* n_contrib,
+		const float* dL_dpixels,
+		const float* dL_dpixels_objs,
+		float3* dL_dmean2D,
+		float4* dL_dconic2D,
+		float* dL_dopacity,
+		float* dL_dcolors,
+		float* dL_dobjects);
+
+	void preprocess(
+		int P, int D, int M,
+		const float3* means,
+		const int* radii,
+		const float* shs,
+		const bool* clamped,
+		const glm::vec3* scales,
+		const glm::vec4* rotations,
+		const float scale_modifier,
+		const float* cov3Ds,
+		const float* view,
+		const float* proj,
+		const float focal_x, float focal_y,
+		const float tan_fovx, float tan_fovy,
+		const glm::vec3* campos,
+		const float3* dL_dmean2D,
+		const float* dL_dconics,
+		glm::vec3* dL_dmeans,
+		float* dL_dcolor,
+		float* dL_dcov3D,
+		float* dL_dsh,
+		glm::vec3* dL_dscale,
+		glm::vec4* dL_drot);
+}
+
+#endif

gaussian-grouping/submodules/diff-gaussian-rasterization/cuda_rasterizer/config.h

@@ -0,0 +1,18 @@
+/*
+ * 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
+ */
+
+#ifndef CUDA_RASTERIZER_CONFIG_H_INCLUDED
+#define CUDA_RASTERIZER_CONFIG_H_INCLUDED
+
+#define NUM_CHANNELS 3 // Default 3, RGB
+#define NUM_OBJECTS 16 // Default 16, identity encoding
+#define BLOCK_X 16
+#define BLOCK_Y 16
+
+#endif

gaussian-grouping/submodules/diff-gaussian-rasterization/cuda_rasterizer/forward.cu

@@ -0,0 +1,489 @@
+/*
+ * 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
+ */
+
+#include "forward.h"
+#include "auxiliary.h"
+#include <cooperative_groups.h>
+#include <cooperative_groups/reduce.h>
+namespace cg = cooperative_groups;
+
+// Forward method for converting the input spherical harmonics
+// coefficients of each Gaussian to a simple RGB color.
+__device__ glm::vec3 computeColorFromSH(int idx, int deg, int max_coeffs, const glm::vec3* means, glm::vec3 campos, const float* shs, bool* clamped)
+{
+	// The implementation is loosely based on code for 
+	// "Differentiable Point-Based Radiance Fields for 
+	// Efficient View Synthesis" by Zhang et al. (2022)
+	glm::vec3 pos = means[idx];
+	glm::vec3 dir = pos - campos;
+	dir = dir / glm::length(dir);
+
+	glm::vec3* sh = ((glm::vec3*)shs) + idx * max_coeffs;
+	glm::vec3 result = SH_C0 * sh[0];
+
+	if (deg > 0)
+	{
+		float x = dir.x;
+		float y = dir.y;
+		float z = dir.z;
+		result = result - SH_C1 * y * sh[1] + SH_C1 * z * sh[2] - SH_C1 * x * sh[3];
+
+		if (deg > 1)
+		{
+			float xx = x * x, yy = y * y, zz = z * z;
+			float xy = x * y, yz = y * z, xz = x * z;
+			result = result +
+				SH_C2[0] * xy * sh[4] +
+				SH_C2[1] * yz * sh[5] +
+				SH_C2[2] * (2.0f * zz - xx - yy) * sh[6] +
+				SH_C2[3] * xz * sh[7] +
+				SH_C2[4] * (xx - yy) * sh[8];
+
+			if (deg > 2)
+			{
+				result = result +
+					SH_C3[0] * y * (3.0f * xx - yy) * sh[9] +
+					SH_C3[1] * xy * z * sh[10] +
+					SH_C3[2] * y * (4.0f * zz - xx - yy) * sh[11] +
+					SH_C3[3] * z * (2.0f * zz - 3.0f * xx - 3.0f * yy) * sh[12] +
+					SH_C3[4] * x * (4.0f * zz - xx - yy) * sh[13] +
+					SH_C3[5] * z * (xx - yy) * sh[14] +
+					SH_C3[6] * x * (xx - 3.0f * yy) * sh[15];
+			}
+		}
+	}
+	result += 0.5f;
+
+	// RGB colors are clamped to positive values. If values are
+	// clamped, we need to keep track of this for the backward pass.
+	clamped[3 * idx + 0] = (result.x < 0);
+	clamped[3 * idx + 1] = (result.y < 0);
+	clamped[3 * idx + 2] = (result.z < 0);
+	return glm::max(result, 0.0f);
+}
+
+// Forward version of 2D covariance matrix computation
+__device__ float3 computeCov2D(const float3& mean, float focal_x, float focal_y, float tan_fovx, float tan_fovy, const float* cov3D, const float* viewmatrix)
+{
+	// The following models the steps outlined by equations 29
+	// and 31 in "EWA Splatting" (Zwicker et al., 2002). 
+	// Additionally considers aspect / scaling of viewport.
+	// Transposes used to account for row-/column-major conventions.
+	float3 t = transformPoint4x3(mean, viewmatrix);
+
+	const float limx = 1.3f * tan_fovx;
+	const float limy = 1.3f * tan_fovy;
+	const float txtz = t.x / t.z;
+	const float tytz = t.y / t.z;
+	t.x = min(limx, max(-limx, txtz)) * t.z;
+	t.y = min(limy, max(-limy, tytz)) * t.z;
+
+	glm::mat3 J = glm::mat3(
+		focal_x / t.z, 0.0f, -(focal_x * t.x) / (t.z * t.z),
+		0.0f, focal_y / t.z, -(focal_y * t.y) / (t.z * t.z),
+		0, 0, 0);
+
+	glm::mat3 W = glm::mat3(
+		viewmatrix[0], viewmatrix[4], viewmatrix[8],
+		viewmatrix[1], viewmatrix[5], viewmatrix[9],
+		viewmatrix[2], viewmatrix[6], viewmatrix[10]);
+
+	glm::mat3 T = W * J;
+
+	glm::mat3 Vrk = glm::mat3(
+		cov3D[0], cov3D[1], cov3D[2],
+		cov3D[1], cov3D[3], cov3D[4],
+		cov3D[2], cov3D[4], cov3D[5]);
+
+	glm::mat3 cov = glm::transpose(T) * glm::transpose(Vrk) * T;
+
+	// Apply low-pass filter: every Gaussian should be at least
+	// one pixel wide/high. Discard 3rd row and column.
+	cov[0][0] += 0.3f;
+	cov[1][1] += 0.3f;
+	return { float(cov[0][0]), float(cov[0][1]), float(cov[1][1]) };
+}
+
+// Forward method for converting scale and rotation properties of each
+// Gaussian to a 3D covariance matrix in world space. Also takes care
+// of quaternion normalization.
+__device__ void computeCov3D(const glm::vec3 scale, float mod, const glm::vec4 rot, float* cov3D)
+{
+	// Create scaling matrix
+	glm::mat3 S = glm::mat3(1.0f);
+	S[0][0] = mod * scale.x;
+	S[1][1] = mod * scale.y;
+	S[2][2] = mod * scale.z;
+
+	// Normalize quaternion to get valid rotation
+	glm::vec4 q = rot;// / glm::length(rot);
+	float r = q.x;
+	float x = q.y;
+	float y = q.z;
+	float z = q.w;
+
+	// Compute rotation matrix from quaternion
+	glm::mat3 R = glm::mat3(
+		1.f - 2.f * (y * y + z * z), 2.f * (x * y - r * z), 2.f * (x * z + r * y),
+		2.f * (x * y + r * z), 1.f - 2.f * (x * x + z * z), 2.f * (y * z - r * x),
+		2.f * (x * z - r * y), 2.f * (y * z + r * x), 1.f - 2.f * (x * x + y * y)
+	);
+
+	glm::mat3 M = S * R;
+
+	// Compute 3D world covariance matrix Sigma
+	glm::mat3 Sigma = glm::transpose(M) * M;
+
+	// Covariance is symmetric, only store upper right
+	cov3D[0] = Sigma[0][0];
+	cov3D[1] = Sigma[0][1];
+	cov3D[2] = Sigma[0][2];
+	cov3D[3] = Sigma[1][1];
+	cov3D[4] = Sigma[1][2];
+	cov3D[5] = Sigma[2][2];
+}
+
+// Perform initial steps for each Gaussian prior to rasterization.
+template<int C, int O>
+__global__ void preprocessCUDA(int P, int D, int M,
+	const float* orig_points,
+	const glm::vec3* scales,
+	const float scale_modifier,
+	const glm::vec4* rotations,
+	const float* opacities,
+	const float* shs,
+	const float* sh_objs,
+	bool* clamped,
+	const float* cov3D_precomp,
+	const float* colors_precomp,
+	const float* viewmatrix,
+	const float* projmatrix,
+	const glm::vec3* cam_pos,
+	const int W, int H,
+	const float tan_fovx, float tan_fovy,
+	const float focal_x, float focal_y,
+	int* radii,
+	float2* points_xy_image,
+	float* depths,
+	float* cov3Ds,
+	float* rgb,
+	float4* conic_opacity,
+	const dim3 grid,
+	uint32_t* tiles_touched,
+	bool prefiltered)
+{
+	auto idx = cg::this_grid().thread_rank();
+	if (idx >= P)
+		return;
+
+	// Initialize radius and touched tiles to 0. If this isn't changed,
+	// this Gaussian will not be processed further.
+	radii[idx] = 0;
+	tiles_touched[idx] = 0;
+
+	// Perform near culling, quit if outside.
+	float3 p_view;
+	if (!in_frustum(idx, orig_points, viewmatrix, projmatrix, prefiltered, p_view))
+		return;
+
+	// Transform point by projecting
+	float3 p_orig = { orig_points[3 * idx], orig_points[3 * idx + 1], orig_points[3 * idx + 2] };
+	float4 p_hom = transformPoint4x4(p_orig, projmatrix);
+	float p_w = 1.0f / (p_hom.w + 0.0000001f);
+	float3 p_proj = { p_hom.x * p_w, p_hom.y * p_w, p_hom.z * p_w };
+
+	// If 3D covariance matrix is precomputed, use it, otherwise compute
+	// from scaling and rotation parameters. 
+	const float* cov3D;
+	if (cov3D_precomp != nullptr)
+	{
+		cov3D = cov3D_precomp + idx * 6;
+	}
+	else
+	{
+		computeCov3D(scales[idx], scale_modifier, rotations[idx], cov3Ds + idx * 6);
+		cov3D = cov3Ds + idx * 6;
+	}
+
+	// Compute 2D screen-space covariance matrix
+	float3 cov = computeCov2D(p_orig, focal_x, focal_y, tan_fovx, tan_fovy, cov3D, viewmatrix);
+
+	// Invert covariance (EWA algorithm)
+	float det = (cov.x * cov.z - cov.y * cov.y);
+	if (det == 0.0f)
+		return;
+	float det_inv = 1.f / det;
+	float3 conic = { cov.z * det_inv, -cov.y * det_inv, cov.x * det_inv };
+
+	// Compute extent in screen space (by finding eigenvalues of
+	// 2D covariance matrix). Use extent to compute a bounding rectangle
+	// of screen-space tiles that this Gaussian overlaps with. Quit if
+	// rectangle covers 0 tiles. 
+	float mid = 0.5f * (cov.x + cov.z);
+	float lambda1 = mid + sqrt(max(0.1f, mid * mid - det));
+	float lambda2 = mid - sqrt(max(0.1f, mid * mid - det));
+	float my_radius = ceil(3.f * sqrt(max(lambda1, lambda2)));
+	float2 point_image = { ndc2Pix(p_proj.x, W), ndc2Pix(p_proj.y, H) };
+	uint2 rect_min, rect_max;
+	getRect(point_image, my_radius, rect_min, rect_max, grid);
+	if ((rect_max.x - rect_min.x) * (rect_max.y - rect_min.y) == 0)
+		return;
+
+	// If colors have been precomputed, use them, otherwise convert
+	// spherical harmonics coefficients to RGB color.
+	if (colors_precomp == nullptr)
+	{
+		glm::vec3 result = computeColorFromSH(idx, D, M, (glm::vec3*)orig_points, *cam_pos, shs, clamped);
+		rgb[idx * C + 0] = result.x;
+		rgb[idx * C + 1] = result.y;
+		rgb[idx * C + 2] = result.z;
+	}
+
+	// Store some useful helper data for the next steps.
+	depths[idx] = p_view.z;
+	radii[idx] = my_radius;
+	points_xy_image[idx] = point_image;
+	// Inverse 2D covariance and opacity neatly pack into one float4
+	conic_opacity[idx] = { conic.x, conic.y, conic.z, opacities[idx] };
+	tiles_touched[idx] = (rect_max.y - rect_min.y) * (rect_max.x - rect_min.x);
+}
+
+__device__ static float atomicMax(float* address, float val)
+{
+    int* address_as_i = (int*) address;
+    int old = *address_as_i, assumed;
+    do {
+        assumed = old;
+        old = ::atomicCAS(address_as_i, assumed,
+            __float_as_int(::fmaxf(val, __int_as_float(assumed))));
+    } while (assumed != old);
+    return __int_as_float(old);
+}
+
+// Main rasterization method. Collaboratively works on one tile per
+// block, each thread treats one pixel. Alternates between fetching 
+// and rasterizing data.
+template <uint32_t CHANNELS, uint32_t OBJECTS>
+__global__ void __launch_bounds__(BLOCK_X * BLOCK_Y)
+renderCUDA(
+	const uint2* __restrict__ ranges,
+	const uint32_t* __restrict__ point_list,
+	int W, int H,
+	const float2* __restrict__ points_xy_image,
+	const float* __restrict__ features,
+	const float* __restrict__ obj_features,
+	const float4* __restrict__ conic_opacity,
+	const float* __restrict__ alpha_mask,
+	float* __restrict__ final_T,
+	uint32_t* __restrict__ n_contrib,
+	const float* __restrict__ bg_color,
+	float* __restrict__ out_color,
+	float* __restrict__ out_objects,
+	float* __restrict__ out_max_trans)
+{
+	// Identify current tile and associated min/max pixel range.
+	auto block = cg::this_thread_block();
+	uint32_t horizontal_blocks = (W + BLOCK_X - 1) / BLOCK_X;
+	uint2 pix_min = { block.group_index().x * BLOCK_X, block.group_index().y * BLOCK_Y };
+	uint2 pix_max = { min(pix_min.x + BLOCK_X, W), min(pix_min.y + BLOCK_Y , H) };
+	uint2 pix = { pix_min.x + block.thread_index().x, pix_min.y + block.thread_index().y };
+	uint32_t pix_id = W * pix.y + pix.x;
+	float2 pixf = { (float)pix.x, (float)pix.y };
+
+	// Check if this thread is associated with a valid pixel or outside.
+	bool inside = pix.x < W&& pix.y < H;
+	// Done threads can help with fetching, but don't rasterize
+	bool done = !inside;
+
+	// Load start/end range of IDs to process in bit sorted list.
+	uint2 range = ranges[block.group_index().y * horizontal_blocks + block.group_index().x];
+	const int rounds = ((range.y - range.x + BLOCK_SIZE - 1) / BLOCK_SIZE);
+	int toDo = range.y - range.x;
+
+	// Allocate storage for batches of collectively fetched data.
+	__shared__ int collected_id[BLOCK_SIZE];
+	__shared__ float2 collected_xy[BLOCK_SIZE];
+	__shared__ float4 collected_conic_opacity[BLOCK_SIZE];
+
+	// Initialize helper variables
+	float T = 1.0f;
+	uint32_t contributor = 0;
+	uint32_t last_contributor = 0;
+	float C[CHANNELS] = { 0 };
+	float O[OBJECTS] = { 0 };	//rendered object
+
+	// Iterate over batches until all done or range is complete
+	for (int i = 0; i < rounds; i++, toDo -= BLOCK_SIZE)
+	{
+		// End if entire block votes that it is done rasterizing
+		int num_done = __syncthreads_count(done);
+		if (num_done == BLOCK_SIZE)
+			break;
+
+		// Collectively fetch per-Gaussian data from global to shared
+		int progress = i * BLOCK_SIZE + block.thread_rank();
+		if (range.x + progress < range.y)
+		{
+			int coll_id = point_list[range.x + progress];
+			collected_id[block.thread_rank()] = coll_id;
+			collected_xy[block.thread_rank()] = points_xy_image[coll_id];
+			collected_conic_opacity[block.thread_rank()] = conic_opacity[coll_id];
+		}
+		block.sync();
+		float mask = alpha_mask[pix_id];
+		// Iterate over current batch
+		for (int j = 0; !done && j < min(BLOCK_SIZE, toDo); j++)
+		{
+			// Keep track of current position in range
+			contributor++;
+
+			// Resample using conic matrix (cf. "Surface 
+			// Splatting" by Zwicker et al., 2001)
+			float2 xy = collected_xy[j];
+			float2 d = { xy.x - pixf.x, xy.y - pixf.y };
+			float4 con_o = collected_conic_opacity[j];
+			float power = -0.5f * (con_o.x * d.x * d.x + con_o.z * d.y * d.y) - con_o.y * d.x * d.y;
+			if (power > 0.0f)
+				continue;
+
+			// Eq. (2) from 3D Gaussian splatting paper.
+			// Obtain alpha by multiplying with Gaussian opacity
+			// and its exponential falloff from mean.
+			// Avoid numerical instabilities (see paper appendix). 
+			float alpha = min(0.99f, con_o.w * exp(power));
+			if (alpha < 1.0f / 255.0f)
+				continue;
+			float test_T = T * (1 - alpha);
+			if (test_T < 0.0001f)
+			{
+				done = true;
+				continue;
+			}
+
+			// Eq. (3) from 3D Gaussian splatting paper.
+			for (int ch = 0; ch < CHANNELS; ch++){
+				C[ch] += features[collected_id[j] * CHANNELS + ch] * alpha * T;}
+			for (int ch = 0; ch < OBJECTS; ch++){
+				O[ch] += obj_features[collected_id[j] * OBJECTS + ch] * alpha * T;}
+
+			if (mask > 0.95f){
+				atomicMax(out_max_trans + collected_id[j], T);
+			}
+
+			T = test_T;
+
+			// Keep track of last range entry to update this
+			// pixel.
+			last_contributor = contributor;
+		}
+	}
+
+	// All threads that treat valid pixel write out their final
+	// rendering data to the frame and auxiliary buffers.
+	if (inside)
+	{
+		final_T[pix_id] = T;
+		n_contrib[pix_id] = last_contributor;
+		for (int ch = 0; ch < CHANNELS; ch++){
+			out_color[ch * H * W + pix_id] = C[ch] + T * bg_color[ch];}
+		for (int ch = 0; ch < OBJECTS; ch++){
+			out_objects[ch * H * W + pix_id] = O[ch];}
+	}
+}
+
+void FORWARD::render(
+	const dim3 grid, dim3 block,
+	const uint2* ranges,
+	const uint32_t* point_list,
+	int W, int H,
+	const float2* means2D,
+	const float* colors,
+	const float* objects,
+	const float4* conic_opacity,
+	const float* alpha,
+	float* final_T,
+	uint32_t* n_contrib,
+	const float* bg_color,
+	float* out_color,
+	float* out_objects,
+	float* out_max_trans)
+{
+	renderCUDA<NUM_CHANNELS, NUM_OBJECTS> << <grid, block >> > (
+		ranges,
+		point_list,
+		W, H,
+		means2D,
+		colors,
+		objects,
+		conic_opacity,
+		alpha,
+		final_T,
+		n_contrib,
+		bg_color,
+		out_color,
+		out_objects,
+		out_max_trans);
+}
+
+void FORWARD::preprocess(int P, int D, int M,
+	const float* means3D,
+	const glm::vec3* scales,
+	const float scale_modifier,
+	const glm::vec4* rotations,
+	const float* opacities,
+	const float* shs,
+	const float* sh_objs,
+	bool* clamped,
+	const float* cov3D_precomp,
+	const float* colors_precomp,
+	const float* viewmatrix,
+	const float* projmatrix,
+	const glm::vec3* cam_pos,
+	const int W, int H,
+	const float focal_x, float focal_y,
+	const float tan_fovx, float tan_fovy,
+	int* radii,
+	float2* means2D,
+	float* depths,
+	float* cov3Ds,
+	float* rgb,
+	float4* conic_opacity,
+	const dim3 grid,
+	uint32_t* tiles_touched,
+	bool prefiltered)
+{
+	preprocessCUDA<NUM_CHANNELS, NUM_OBJECTS> << <(P + 255) / 256, 256 >> > (
+		P, D, M,
+		means3D,
+		scales,
+		scale_modifier,
+		rotations,
+		opacities,
+		shs,
+		sh_objs,
+		clamped,
+		cov3D_precomp,
+		colors_precomp,
+		viewmatrix, 
+		projmatrix,
+		cam_pos,
+		W, H,
+		tan_fovx, tan_fovy,
+		focal_x, focal_y,
+		radii,
+		means2D,
+		depths,
+		cov3Ds,
+		rgb,
+		conic_opacity,
+		grid,
+		tiles_touched,
+		prefiltered
+		);
+}

gaussian-grouping/submodules/diff-gaussian-rasterization/cuda_rasterizer/forward.h

@@ -0,0 +1,69 @@
+/*
+ * 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
+ */
+
+#ifndef CUDA_RASTERIZER_FORWARD_H_INCLUDED
+#define CUDA_RASTERIZER_FORWARD_H_INCLUDED
+
+#include <cuda.h>
+#include "cuda_runtime.h"
+#include "device_launch_parameters.h"
+#define GLM_FORCE_CUDA
+#include <glm/glm.hpp>
+
+namespace FORWARD
+{
+	// Perform initial steps for each Gaussian prior to rasterization.
+	void preprocess(int P, int D, int M,
+		const float* orig_points,
+		const glm::vec3* scales,
+		const float scale_modifier,
+		const glm::vec4* rotations,
+		const float* opacities,
+		const float* shs,
+		const float* sh_objs,
+		bool* clamped,
+		const float* cov3D_precomp,
+		const float* colors_precomp,
+		const float* viewmatrix,
+		const float* projmatrix,
+		const glm::vec3* cam_pos,
+		const int W, int H,
+		const float focal_x, float focal_y,
+		const float tan_fovx, float tan_fovy,
+		int* radii,
+		float2* points_xy_image,
+		float* depths,
+		float* cov3Ds,
+		float* colors,
+		float4* conic_opacity,
+		const dim3 grid,
+		uint32_t* tiles_touched,
+		bool prefiltered);
+
+	// Main rasterization method.
+	void render(
+		const dim3 grid, dim3 block,
+		const uint2* ranges,
+		const uint32_t* point_list,
+		int W, int H,
+		const float2* points_xy_image,
+		const float* features,
+		const float* obj_features,
+		const float4* conic_opacity,
+		const float* alpha,
+		float* final_T,
+		uint32_t* n_contrib,
+		const float* bg_color,
+		float* out_color,
+		float* out_objects,
+		float* out_max_trans);
+}
+
+
+#endif

gaussian-grouping/submodules/diff-gaussian-rasterization/cuda_rasterizer/rasterizer.h

@@ -0,0 +1,93 @@
+/*
+ * 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
+ */
+
+#ifndef CUDA_RASTERIZER_H_INCLUDED
+#define CUDA_RASTERIZER_H_INCLUDED
+
+#include <vector>
+#include <functional>
+
+namespace CudaRasterizer
+{
+	class Rasterizer
+	{
+	public:
+
+		static void markVisible(
+			int P,
+			float* means3D,
+			float* viewmatrix,
+			float* projmatrix,
+			bool* present);
+
+		static int forward(
+			std::function<char* (size_t)> geometryBuffer,
+			std::function<char* (size_t)> binningBuffer,
+			std::function<char* (size_t)> imageBuffer,
+			const int P, int D, int M,
+			const float* background,
+			const int width, int height,
+			const float* means3D,
+			const float* shs,
+			const float* sh_objs,
+			const float* colors_precomp,
+			const float* opacities,
+			const float* scales,
+			const float scale_modifier,
+			const float* rotations,
+			const float* cov3D_precomp,
+			const float* alpha,
+			const float* viewmatrix,
+			const float* projmatrix,
+			const float* cam_pos,
+			const float tan_fovx, float tan_fovy,
+			const bool prefiltered,
+			float* out_color,
+			float* out_objects,
+			float* out_max_trans,
+			int* radii = nullptr,
+			bool debug = false);
+
+		static void backward(
+			const int P, int D, int M, int R,
+			const float* background,
+			const int width, int height,
+			const float* means3D,
+			const float* shs,
+			const float* sh_objs,
+			const float* colors_precomp,
+			const float* scales,
+			const float scale_modifier,
+			const float* rotations,
+			const float* cov3D_precomp,
+			const float* viewmatrix,
+			const float* projmatrix,
+			const float* campos,
+			const float tan_fovx, float tan_fovy,
+			const int* radii,
+			char* geom_buffer,
+			char* binning_buffer,
+			char* image_buffer,
+			const float* dL_dpix,
+			const float* dL_dpix_obj,
+			float* dL_dmean2D,
+			float* dL_dconic,
+			float* dL_dopacity,
+			float* dL_dcolor,
+			float* dL_dobjects,
+			float* dL_dmean3D,
+			float* dL_dcov3D,
+			float* dL_dsh,
+			float* dL_dscale,
+			float* dL_drot,
+			bool debug);
+	};
+};
+
+#endif

gaussian-grouping/submodules/diff-gaussian-rasterization/cuda_rasterizer/rasterizer_impl.cu

@@ -0,0 +1,448 @@
+/*
+ * 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
+ */
+
+#include "rasterizer_impl.h"
+#include <iostream>
+#include <fstream>
+#include <algorithm>
+#include <numeric>
+#include <cuda.h>
+#include "cuda_runtime.h"
+#include "device_launch_parameters.h"
+#include <cub/cub.cuh>
+#include <cub/device/device_radix_sort.cuh>
+#define GLM_FORCE_CUDA
+#include <glm/glm.hpp>
+
+#include <cooperative_groups.h>
+#include <cooperative_groups/reduce.h>
+namespace cg = cooperative_groups;
+
+#include "auxiliary.h"
+#include "forward.h"
+#include "backward.h"
+
+// Helper function to find the next-highest bit of the MSB
+// on the CPU.
+uint32_t getHigherMsb(uint32_t n)
+{
+	uint32_t msb = sizeof(n) * 4;
+	uint32_t step = msb;
+	while (step > 1)
+	{
+		step /= 2;
+		if (n >> msb)
+			msb += step;
+		else
+			msb -= step;
+	}
+	if (n >> msb)
+		msb++;
+	return msb;
+}
+
+// Wrapper method to call auxiliary coarse frustum containment test.
+// Mark all Gaussians that pass it.
+__global__ void checkFrustum(int P,
+	const float* orig_points,
+	const float* viewmatrix,
+	const float* projmatrix,
+	bool* present)
+{
+	auto idx = cg::this_grid().thread_rank();
+	if (idx >= P)
+		return;
+
+	float3 p_view;
+	present[idx] = in_frustum(idx, orig_points, viewmatrix, projmatrix, false, p_view);
+}
+
+// Generates one key/value pair for all Gaussian / tile overlaps. 
+// Run once per Gaussian (1:N mapping).
+__global__ void duplicateWithKeys(
+	int P,
+	const float2* points_xy,
+	const float* depths,
+	const uint32_t* offsets,
+	uint64_t* gaussian_keys_unsorted,
+	uint32_t* gaussian_values_unsorted,
+	int* radii,
+	dim3 grid)
+{
+	auto idx = cg::this_grid().thread_rank();
+	if (idx >= P)
+		return;
+
+	// Generate no key/value pair for invisible Gaussians
+	if (radii[idx] > 0)
+	{
+		// Find this Gaussian's offset in buffer for writing keys/values.
+		uint32_t off = (idx == 0) ? 0 : offsets[idx - 1];
+		uint2 rect_min, rect_max;
+
+		getRect(points_xy[idx], radii[idx], rect_min, rect_max, grid);
+
+		// For each tile that the bounding rect overlaps, emit a 
+		// key/value pair. The key is |  tile ID  |      depth      |,
+		// and the value is the ID of the Gaussian. Sorting the values 
+		// with this key yields Gaussian IDs in a list, such that they
+		// are first sorted by tile and then by depth. 
+		for (int y = rect_min.y; y < rect_max.y; y++)
+		{
+			for (int x = rect_min.x; x < rect_max.x; x++)
+			{
+				uint64_t key = y * grid.x + x;
+				key <<= 32;
+				key |= *((uint32_t*)&depths[idx]);
+				gaussian_keys_unsorted[off] = key;
+				gaussian_values_unsorted[off] = idx;
+				off++;
+			}
+		}
+	}
+}
+
+// Check keys to see if it is at the start/end of one tile's range in 
+// the full sorted list. If yes, write start/end of this tile. 
+// Run once per instanced (duplicated) Gaussian ID.
+__global__ void identifyTileRanges(int L, uint64_t* point_list_keys, uint2* ranges)
+{
+	auto idx = cg::this_grid().thread_rank();
+	if (idx >= L)
+		return;
+
+	// Read tile ID from key. Update start/end of tile range if at limit.
+	uint64_t key = point_list_keys[idx];
+	uint32_t currtile = key >> 32;
+	if (idx == 0)
+		ranges[currtile].x = 0;
+	else
+	{
+		uint32_t prevtile = point_list_keys[idx - 1] >> 32;
+		if (currtile != prevtile)
+		{
+			ranges[prevtile].y = idx;
+			ranges[currtile].x = idx;
+		}
+	}
+	if (idx == L - 1)
+		ranges[currtile].y = L;
+}
+
+// Mark Gaussians as visible/invisible, based on view frustum testing
+void CudaRasterizer::Rasterizer::markVisible(
+	int P,
+	float* means3D,
+	float* viewmatrix,
+	float* projmatrix,
+	bool* present)
+{
+	checkFrustum << <(P + 255) / 256, 256 >> > (
+		P,
+		means3D,
+		viewmatrix, projmatrix,
+		present);
+}
+
+CudaRasterizer::GeometryState CudaRasterizer::GeometryState::fromChunk(char*& chunk, size_t P)
+{
+	GeometryState geom;
+	obtain(chunk, geom.depths, P, 128);
+	obtain(chunk, geom.clamped, P * 3, 128);
+	obtain(chunk, geom.internal_radii, P, 128);
+	obtain(chunk, geom.means2D, P, 128);
+	obtain(chunk, geom.cov3D, P * 6, 128);
+	obtain(chunk, geom.conic_opacity, P, 128);
+	obtain(chunk, geom.rgb, P * 3, 128);
+	obtain(chunk, geom.tiles_touched, P, 128);
+	cub::DeviceScan::InclusiveSum(nullptr, geom.scan_size, geom.tiles_touched, geom.tiles_touched, P);
+	obtain(chunk, geom.scanning_space, geom.scan_size, 128);
+	obtain(chunk, geom.point_offsets, P, 128);
+	return geom;
+}
+
+CudaRasterizer::ImageState CudaRasterizer::ImageState::fromChunk(char*& chunk, size_t N)
+{
+	ImageState img;
+	obtain(chunk, img.accum_alpha, N, 128);
+	obtain(chunk, img.n_contrib, N, 128);
+	obtain(chunk, img.ranges, N, 128);
+	return img;
+}
+
+CudaRasterizer::BinningState CudaRasterizer::BinningState::fromChunk(char*& chunk, size_t P)
+{
+	BinningState binning;
+	obtain(chunk, binning.point_list, P, 128);
+	obtain(chunk, binning.point_list_unsorted, P, 128);
+	obtain(chunk, binning.point_list_keys, P, 128);
+	obtain(chunk, binning.point_list_keys_unsorted, P, 128);
+	cub::DeviceRadixSort::SortPairs(
+		nullptr, binning.sorting_size,
+		binning.point_list_keys_unsorted, binning.point_list_keys,
+		binning.point_list_unsorted, binning.point_list, P);
+	obtain(chunk, binning.list_sorting_space, binning.sorting_size, 128);
+	return binning;
+}
+
+// Forward rendering procedure for differentiable rasterization
+// of Gaussians.
+int CudaRasterizer::Rasterizer::forward(
+	std::function<char* (size_t)> geometryBuffer,
+	std::function<char* (size_t)> binningBuffer,
+	std::function<char* (size_t)> imageBuffer,
+	const int P, int D, int M,
+	const float* background,
+	const int width, int height,
+	const float* means3D,
+	const float* shs,
+	const float* sh_objs,
+	const float* colors_precomp,
+	const float* opacities,
+	const float* scales,
+	const float scale_modifier,
+	const float* rotations,
+	const float* cov3D_precomp,
+	const float* alpha,
+	const float* viewmatrix,
+	const float* projmatrix,
+	const float* cam_pos,
+	const float tan_fovx, float tan_fovy,
+	const bool prefiltered,
+	float* out_color,
+	float* out_objects,
+	float* out_max_trans,
+	int* radii,
+	bool debug)
+{
+	const float focal_y = height / (2.0f * tan_fovy);
+	const float focal_x = width / (2.0f * tan_fovx);
+
+	size_t chunk_size = required<GeometryState>(P);
+	char* chunkptr = geometryBuffer(chunk_size);
+	GeometryState geomState = GeometryState::fromChunk(chunkptr, P);
+
+	if (radii == nullptr)
+	{
+		radii = geomState.internal_radii;
+	}
+
+	dim3 tile_grid((width + BLOCK_X - 1) / BLOCK_X, (height + BLOCK_Y - 1) / BLOCK_Y, 1);
+	dim3 block(BLOCK_X, BLOCK_Y, 1);
+
+	// Dynamically resize image-based auxiliary buffers during training
+	size_t img_chunk_size = required<ImageState>(width * height);
+	char* img_chunkptr = imageBuffer(img_chunk_size);
+	ImageState imgState = ImageState::fromChunk(img_chunkptr, width * height);
+
+	if (NUM_CHANNELS != 3 && colors_precomp == nullptr)
+	{
+		throw std::runtime_error("For non-RGB, provide precomputed Gaussian colors!");
+	}
+
+	// Run preprocessing per-Gaussian (transformation, bounding, conversion of SHs to RGB)
+	CHECK_CUDA(FORWARD::preprocess(
+		P, D, M,
+		means3D,
+		(glm::vec3*)scales,
+		scale_modifier,
+		(glm::vec4*)rotations,
+		opacities,
+		shs,
+		sh_objs,
+		geomState.clamped,
+		cov3D_precomp,
+		colors_precomp,
+		viewmatrix, projmatrix,
+		(glm::vec3*)cam_pos,
+		width, height,
+		focal_x, focal_y,
+		tan_fovx, tan_fovy,
+		radii,
+		geomState.means2D,
+		geomState.depths,
+		geomState.cov3D,
+		geomState.rgb,
+		geomState.conic_opacity,
+		tile_grid,
+		geomState.tiles_touched,
+		prefiltered
+	), debug)
+
+	// Compute prefix sum over full list of touched tile counts by Gaussians
+	// E.g., [2, 3, 0, 2, 1] -> [2, 5, 5, 7, 8]
+	CHECK_CUDA(cub::DeviceScan::InclusiveSum(geomState.scanning_space, geomState.scan_size, geomState.tiles_touched, geomState.point_offsets, P), debug)
+
+	// Retrieve total number of Gaussian instances to launch and resize aux buffers
+	int num_rendered;
+	CHECK_CUDA(cudaMemcpy(&num_rendered, geomState.point_offsets + P - 1, sizeof(int), cudaMemcpyDeviceToHost), debug);
+
+	size_t binning_chunk_size = required<BinningState>(num_rendered);
+	char* binning_chunkptr = binningBuffer(binning_chunk_size);
+	BinningState binningState = BinningState::fromChunk(binning_chunkptr, num_rendered);
+
+	// For each instance to be rendered, produce adequate [ tile | depth ] key 
+	// and corresponding dublicated Gaussian indices to be sorted
+	duplicateWithKeys << <(P + 255) / 256, 256 >> > (
+		P,
+		geomState.means2D,
+		geomState.depths,
+		geomState.point_offsets,
+		binningState.point_list_keys_unsorted,
+		binningState.point_list_unsorted,
+		radii,
+		tile_grid)
+	CHECK_CUDA(, debug)
+
+	int bit = getHigherMsb(tile_grid.x * tile_grid.y);
+
+	// Sort complete list of (duplicated) Gaussian indices by keys
+	CHECK_CUDA(cub::DeviceRadixSort::SortPairs(
+		binningState.list_sorting_space,
+		binningState.sorting_size,
+		binningState.point_list_keys_unsorted, binningState.point_list_keys,
+		binningState.point_list_unsorted, binningState.point_list,
+		num_rendered, 0, 32 + bit), debug)
+
+	CHECK_CUDA(cudaMemset(imgState.ranges, 0, tile_grid.x * tile_grid.y * sizeof(uint2)), debug);
+
+	// Identify start and end of per-tile workloads in sorted list
+	if (num_rendered > 0)
+		identifyTileRanges << <(num_rendered + 255) / 256, 256 >> > (
+			num_rendered,
+			binningState.point_list_keys,
+			imgState.ranges);
+	CHECK_CUDA(, debug)
+
+	// Let each tile blend its range of Gaussians independently in parallel
+	const float* feature_ptr = colors_precomp != nullptr ? colors_precomp : geomState.rgb;
+	CHECK_CUDA(FORWARD::render(
+		tile_grid, block,
+		imgState.ranges,
+		binningState.point_list,
+		width, height,
+		geomState.means2D,
+		feature_ptr,
+		sh_objs,
+		geomState.conic_opacity,
+		alpha,
+		imgState.accum_alpha,
+		imgState.n_contrib,
+		background,
+		out_color,
+		out_objects,
+		out_max_trans), debug)
+
+	return num_rendered;
+}
+
+// Produce necessary gradients for optimization, corresponding
+// to forward render pass
+void CudaRasterizer::Rasterizer::backward(
+	const int P, int D, int M, int R,
+	const float* background,
+	const int width, int height,
+	const float* means3D,
+	const float* shs,
+	const float* sh_objs,
+	const float* colors_precomp,
+	const float* scales,
+	const float scale_modifier,
+	const float* rotations,
+	const float* cov3D_precomp,
+	const float* viewmatrix,
+	const float* projmatrix,
+	const float* campos,
+	const float tan_fovx, float tan_fovy,
+	const int* radii,
+	char* geom_buffer,
+	char* binning_buffer,
+	char* img_buffer,
+	const float* dL_dpix,
+	const float* dL_dpix_obj,
+	float* dL_dmean2D,
+	float* dL_dconic,
+	float* dL_dopacity,
+	float* dL_dcolor,
+	float* dL_dobjects,
+	float* dL_dmean3D,
+	float* dL_dcov3D,
+	float* dL_dsh,
+	float* dL_dscale,
+	float* dL_drot,
+	bool debug)
+{
+	GeometryState geomState = GeometryState::fromChunk(geom_buffer, P);
+	BinningState binningState = BinningState::fromChunk(binning_buffer, R);
+	ImageState imgState = ImageState::fromChunk(img_buffer, width * height);
+
+	if (radii == nullptr)
+	{
+		radii = geomState.internal_radii;
+	}
+
+	const float focal_y = height / (2.0f * tan_fovy);
+	const float focal_x = width / (2.0f * tan_fovx);
+
+	const dim3 tile_grid((width + BLOCK_X - 1) / BLOCK_X, (height + BLOCK_Y - 1) / BLOCK_Y, 1);
+	const dim3 block(BLOCK_X, BLOCK_Y, 1);
+
+	// Compute loss gradients w.r.t. 2D mean position, conic matrix,
+	// opacity and RGB of Gaussians from per-pixel loss gradients.
+	// If we were given precomputed colors and not SHs, use them.
+	const float* color_ptr = (colors_precomp != nullptr) ? colors_precomp : geomState.rgb;
+	const float* obj_ptr = sh_objs;
+	CHECK_CUDA(BACKWARD::render(
+		tile_grid,
+		block,
+		imgState.ranges,
+		binningState.point_list,
+		width, height,
+		background,
+		geomState.means2D,
+		geomState.conic_opacity,
+		color_ptr,
+		obj_ptr,
+		imgState.accum_alpha,
+		imgState.n_contrib,
+		dL_dpix,
+		dL_dpix_obj,
+		(float3*)dL_dmean2D,
+		(float4*)dL_dconic,
+		dL_dopacity,
+		dL_dcolor,
+		dL_dobjects), debug)
+
+	// Take care of the rest of preprocessing. Was the precomputed covariance
+	// given to us or a scales/rot pair? If precomputed, pass that. If not,
+	// use the one we computed ourselves.
+	const float* cov3D_ptr = (cov3D_precomp != nullptr) ? cov3D_precomp : geomState.cov3D;
+	CHECK_CUDA(BACKWARD::preprocess(P, D, M,
+		(float3*)means3D,
+		radii,
+		shs,
+		geomState.clamped,
+		(glm::vec3*)scales,
+		(glm::vec4*)rotations,
+		scale_modifier,
+		cov3D_ptr,
+		viewmatrix,
+		projmatrix,
+		focal_x, focal_y,
+		tan_fovx, tan_fovy,
+		(glm::vec3*)campos,
+		(float3*)dL_dmean2D,
+		dL_dconic,
+		(glm::vec3*)dL_dmean3D,
+		dL_dcolor,
+		dL_dcov3D,
+		dL_dsh,
+		(glm::vec3*)dL_dscale,
+		(glm::vec4*)dL_drot), debug)
+}