gaussian-splatting 1.17.5__cp310-cp310-win_amd64.whl → 1.19.4__cp310-cp310-win_amd64.whl

gaussian_splatting/camera.py

@@ -52,6 +52,7 @@ def camera2dict(camera: Camera, id):
         'ground_truth_image_mask_path': camera.ground_truth_image_mask_path.replace("\\", "/") if camera.ground_truth_image_mask_path else None,
         'ground_truth_depth_path': camera.ground_truth_depth_path.replace("\\", "/") if camera.ground_truth_depth_path else None,
         'ground_truth_depth_mask_path': camera.ground_truth_depth_mask_path.replace("\\", "/") if camera.ground_truth_depth_mask_path else None,
+        "img_name": os.path.basename(camera.ground_truth_image_path),  # necessary for SIBR_gaussianViewer_app
     }
     return camera_entry
 
@@ -132,7 +133,7 @@ def build_camera(
     )
 
 
-def dict2camera(camera_dict, load_depth=False, device="cuda", custom_data: dict = {}):
+def dict2camera(camera_dict, load_mask=True, load_depth=True, device="cuda", custom_data: dict = {}):
     C2W = torch.zeros((4, 4), device=device)
     C2W[:3, 3] = torch.tensor(camera_dict['position'], dtype=torch.float, device=device)
     C2W[:3, :3] = torch.tensor(camera_dict['rotation'], dtype=torch.float, device=device)
@@ -140,6 +141,12 @@ def dict2camera(camera_dict, load_depth=False, device="cuda", custom_data: dict
     Rt = torch.linalg.inv(C2W)
     T = Rt[:3, 3]
     R = Rt[:3, :3]
+    if load_mask and ('ground_truth_image_mask_path' not in camera_dict or camera_dict['ground_truth_image_mask_path'] is None):
+        logging.warning(f"Value of key 'ground_truth_image_mask_path' is not a valid path, skipping mask loading.")
+    if load_depth and ('ground_truth_depth_path' not in camera_dict or camera_dict['ground_truth_depth_path'] is None):
+        logging.warning(f"Value of key 'ground_truth_depth_path' is not a valid path, skipping depth loading.")
+    if load_depth and ('ground_truth_depth_mask_path' not in camera_dict or camera_dict['ground_truth_depth_mask_path'] is None):
+        logging.warning(f"Value of key 'ground_truth_depth_mask_path' is not a valid path, skipping depth mask loading.")
     return build_camera(
         image_width=camera_dict['width'],
         image_height=camera_dict['height'],
@@ -148,7 +155,7 @@ def dict2camera(camera_dict, load_depth=False, device="cuda", custom_data: dict
         R=R,
         T=T,
         image_path=camera_dict['ground_truth_image_path'] if 'ground_truth_image_path' in camera_dict else None,
-        image_mask_path=camera_dict['ground_truth_image_mask_path'] if 'ground_truth_image_mask_path' in camera_dict else None,
+        image_mask_path=camera_dict['ground_truth_image_mask_path'] if (load_mask and 'ground_truth_image_mask_path' in camera_dict) else None,
         depth_path=camera_dict['ground_truth_depth_path'] if (load_depth and 'ground_truth_depth_path' in camera_dict) else None,
         depth_mask_path=camera_dict['ground_truth_depth_mask_path'] if (load_depth and 'ground_truth_depth_mask_path' in camera_dict) else None,
         device=device,

gaussian_splatting/dataset/camera_trainable.py

@@ -81,8 +81,8 @@ class TrainableCameraDataset(CameraDataset):
             json.dump(cameras, f, indent=2)
 
     @classmethod
-    def from_json(cls, path, load_depth=False):
-        cameras = JSONCameraDataset(path, load_depth=load_depth)
+    def from_json(cls, path, load_mask=True, load_depth=True):
+        cameras = JSONCameraDataset(path, load_mask=load_mask, load_depth=load_depth)
         exposures = [(torch.tensor(camera['exposure'], dtype=torch.float) if 'exposure' in camera else torch.eye(3, 4)) for camera in cameras.json_cameras]
         return cls(cameras, exposures)
 
@@ -91,8 +91,8 @@ class FixedTrainableCameraDataset(JSONCameraDataset):
     # Same as TrainableCameraDataset, but is fixed
     # Used for loading cameras saved by TrainableCameraDataset
 
-    def __init__(self, path, load_depth=False):
-        super().__init__(path, load_depth=load_depth)
+    def __init__(self, path, load_mask=True, load_depth=True):
+        super().__init__(path, load_mask=load_mask, load_depth=load_depth)
         self.load_exposures()
 
     def to(self, device):

gaussian_splatting/dataset/colmap/dataset.py

@@ -27,7 +27,7 @@ class ColmapCamera(NamedTuple):
     depth_mask_path: str
 
 
-def parse_colmap_camera(cameras, images, image_dir, depth_dir=None) -> List[ColmapCamera]:
+def parse_colmap_camera(cameras, images, image_dir, load_mask=True, depth_dir=None) -> List[ColmapCamera]:
     parsed_cameras = []
     for _, key in enumerate(cameras):
         extr = cameras[key]
@@ -49,9 +49,11 @@ def parse_colmap_camera(cameras, images, image_dir, depth_dir=None) -> List[Colm
             raise ValueError("Colmap camera model not handled: only undistorted datasets (PINHOLE or SIMPLE_PINHOLE cameras) supported!")
 
         image_path = os.path.join(image_dir, extr.name)
-        image_mask_path = os.path.join(image_dir, os.path.splitext(extr.name)[0] + '_mask.tiff')
-        if not os.path.exists(image_mask_path):
-            image_mask_path = os.path.splitext(image_mask_path)[0] + '.png'
+        image_mask_path = None
+        if load_mask:
+            image_mask_path = os.path.join(image_dir, os.path.splitext(extr.name)[0] + '_mask.tiff')
+            if not os.path.exists(image_mask_path):
+                image_mask_path = os.path.splitext(image_mask_path)[0] + '.png'
         depth_path, depth_mask_path = None, None
         if depth_dir is not None:
             depth_path = os.path.join(depth_dir, os.path.splitext(extr.name)[0] + '.tiff')
@@ -72,7 +74,7 @@ def parse_colmap_camera(cameras, images, image_dir, depth_dir=None) -> List[Colm
     return parsed_cameras
 
 
-def read_colmap_cameras(colmap_folder, load_depth=False) -> List[ColmapCamera]:
+def read_colmap_cameras(colmap_folder, load_mask=True, load_depth=True) -> List[ColmapCamera]:
     path = colmap_folder
     image_dir = os.path.join(path, "images")
     try:
@@ -86,13 +88,13 @@ def read_colmap_cameras(colmap_folder, load_depth=False) -> List[ColmapCamera]:
         cam_extrinsics = read_images_text(cameras_extrinsic_file)
         cam_intrinsics = read_cameras_text(cameras_intrinsic_file)
     depth_dir = os.path.join(path, "depths") if load_depth else None
-    return parse_colmap_camera(cam_extrinsics, cam_intrinsics, image_dir, depth_dir)
+    return parse_colmap_camera(cam_extrinsics, cam_intrinsics, image_dir, load_mask=load_mask, depth_dir=depth_dir)
 
 
 class ColmapCameraDataset(CameraDataset):
-    def __init__(self, colmap_folder, load_depth=False):
+    def __init__(self, colmap_folder, load_mask=True, load_depth=True):
         super().__init__()
-        self.raw_cameras = read_colmap_cameras(colmap_folder, load_depth=load_depth)
+        self.raw_cameras = read_colmap_cameras(colmap_folder, load_mask=load_mask, load_depth=load_depth)
         self.cameras = [build_camera(**cam._asdict()) for cam in self.raw_cameras]
 
     def to(self, device):
@@ -106,5 +108,5 @@ class ColmapCameraDataset(CameraDataset):
         return self.cameras[idx]
 
 
-def ColmapTrainableCameraDataset(colmap_folder, load_depth=False):
-    return TrainableCameraDataset(ColmapCameraDataset(colmap_folder, load_depth=load_depth))
+def ColmapTrainableCameraDataset(colmap_folder, load_mask=True, load_depth=True):
+    return TrainableCameraDataset(ColmapCameraDataset(colmap_folder, load_mask=load_mask, load_depth=load_depth))

gaussian_splatting/dataset/dataset.py

@@ -35,9 +35,10 @@ class CameraDataset:
 
 
 class JSONCameraDataset(CameraDataset):
-    def __init__(self, path, load_depth=False):
+    def __init__(self, path, load_mask=True, load_depth=True):
         with open(path, 'r') as f:
             self.json_cameras = json.load(f)
+        self.load_mask = load_mask
         self.load_depth = load_depth
         self.load_cameras()
 
@@ -51,7 +52,7 @@ class JSONCameraDataset(CameraDataset):
         return self.load_cameras(device=device)
 
     def load_cameras(self, device=None):
-        self.cameras = [dict2camera(camera, load_depth=self.load_depth, device=device) for camera in self.json_cameras]
+        self.cameras = [dict2camera(camera, load_mask=self.load_mask, load_depth=self.load_depth, device=device) for camera in self.json_cameras]
         return self
 
 

gaussian_splatting/prepare.py

@@ -6,11 +6,19 @@ from .trainer import *
 from .trainer.extensions import ScaleRegularizeTrainerWrapper
 
 
-def prepare_dataset(source: str, device: str, trainable_camera: bool = False, load_camera: str = None, load_depth=False) -> CameraDataset:
+def prepare_dataset(source: str, device: str, trainable_camera: bool = False, load_camera: str = None, load_mask=True, load_depth=True) -> CameraDataset:
     if trainable_camera:
-        dataset = (TrainableCameraDataset.from_json(load_camera, load_depth=load_depth) if load_camera else ColmapTrainableCameraDataset(source, load_depth=load_depth)).to(device)
+        dataset = (
+            TrainableCameraDataset.from_json(load_camera, load_mask=load_mask, load_depth=load_depth)
+            if load_camera else
+            ColmapTrainableCameraDataset(source, load_mask=load_mask, load_depth=load_depth)
+        ).to(device)
     else:
-        dataset = (FixedTrainableCameraDataset(load_camera, load_depth=load_depth) if load_camera else ColmapCameraDataset(source, load_depth=load_depth)).to(device)
+        dataset = (
+            FixedTrainableCameraDataset(load_camera, load_mask=load_mask, load_depth=load_depth)
+            if load_camera else
+            ColmapCameraDataset(source, load_mask=load_mask, load_depth=load_depth)
+        ).to(device)
     return dataset
 
 

gaussian_splatting/render.py

@@ -12,8 +12,11 @@ from gaussian_splatting.utils.lpipsPyTorch import lpips
 from gaussian_splatting.prepare import prepare_dataset, prepare_gaussians
 
 
-def prepare_rendering(sh_degree: int, source: str, device: str, trainable_camera: bool = False, load_ply: str = None, load_camera: str = None, load_depth=False) -> Tuple[CameraDataset, GaussianModel]:
-    dataset = prepare_dataset(source=source, device=device, trainable_camera=trainable_camera, load_camera=load_camera, load_depth=load_depth)
+def prepare_rendering(
+        sh_degree: int, source: str, device: str,
+        trainable_camera: bool = False, load_ply: str = None, load_camera: str = None,
+        load_mask=True, load_depth=True) -> Tuple[CameraDataset, GaussianModel]:
+    dataset = prepare_dataset(source=source, device=device, trainable_camera=trainable_camera, load_camera=load_camera, load_mask=load_mask, load_depth=load_depth)
     gaussians = prepare_gaussians(sh_degree=sh_degree, source=source, device=device, trainable_camera=trainable_camera, load_ply=load_ply)
     return dataset, gaussians
 
@@ -54,13 +57,16 @@ def rendering(
     gt_path = os.path.join(save, "gt")
     makedirs(render_path, exist_ok=True)
     makedirs(gt_path, exist_ok=True)
-    pbar = tqdm(dataset, desc="Rendering progress")
+    pbar = tqdm(dataset, dynamic_ncols=True, desc="Rendering")
     with open(os.path.join(save, "quality.csv"), "w") as f:
         f.write("name,psnr,ssim,lpips\n")
     for idx, camera in enumerate(pbar):
         out = gaussians(camera)
         rendering = out["render"]
         gt = camera.ground_truth_image
+        if camera.ground_truth_image_mask is not None:
+            gt *= camera.ground_truth_image_mask
+            rendering *= camera.ground_truth_image_mask
         psnr_value = psnr(rendering, gt).mean().item()
         ssim_value = ssim(rendering, gt).mean().item()
         lpips_value = lpips(rendering, gt).mean().item()
@@ -93,6 +99,7 @@ if __name__ == "__main__":
     parser.add_argument("--load_camera", default=None, type=str)
     parser.add_argument("--mode", choices=["base", "camera"], default="base")
     parser.add_argument("--device", default="cuda", type=str)
+    parser.add_argument("--no_image_mask", action="store_true")
     parser.add_argument("--no_rescale_depth_gt", action="store_true")
     parser.add_argument("--save_depth_pcd", action="store_true")
     args = parser.parse_args()
@@ -101,5 +108,6 @@ if __name__ == "__main__":
     with torch.no_grad():
         dataset, gaussians = prepare_rendering(
             sh_degree=args.sh_degree, source=args.source, device=args.device, trainable_camera=args.mode == "camera",
-            load_ply=load_ply, load_camera=args.load_camera, load_depth=True)
+            load_ply=load_ply, load_camera=args.load_camera,
+            load_mask=not args.no_image_mask, load_depth=args.save_depth_pcd)
         rendering(dataset, gaussians, save, save_pcd=args.save_depth_pcd, rescale_depth_gt=not args.no_rescale_depth_gt)

gaussian_splatting/train.py

@@ -12,8 +12,12 @@ from gaussian_splatting.trainer import AbstractTrainer
 from gaussian_splatting.prepare import basemodes, shliftmodes, prepare_dataset, prepare_gaussians, prepare_trainer
 
 
-def prepare_training(sh_degree: int, source: str, device: str, mode: str, trainable_camera: bool = False, load_ply: str = None, load_camera: str = None, load_depth=False, with_scale_reg=False, configs={}) -> Tuple[CameraDataset, GaussianModel, AbstractTrainer]:
-    dataset = prepare_dataset(source=source, device=device, trainable_camera=trainable_camera, load_camera=load_camera, load_depth=load_depth)
+def prepare_training(
+        sh_degree: int, source: str, device: str, mode: str,
+        trainable_camera: bool = False, load_ply: str = None, load_camera: str = None,
+        load_mask=True, load_depth=True,
+        with_scale_reg=False, configs={}) -> Tuple[CameraDataset, GaussianModel, AbstractTrainer]:
+    dataset = prepare_dataset(source=source, device=device, trainable_camera=trainable_camera, load_camera=load_camera, load_mask=load_mask, load_depth=load_depth)
     gaussians = prepare_gaussians(sh_degree=sh_degree, source=source, device=device, trainable_camera=trainable_camera, load_ply=load_ply)
     trainer = prepare_trainer(gaussians=gaussians, dataset=dataset, mode=mode, trainable_camera=trainable_camera, load_ply=load_ply, with_scale_reg=with_scale_reg, configs=configs)
     return dataset, gaussians, trainer
@@ -27,24 +31,37 @@ def save_cfg_args(destination: str, sh_degree: int, source: str):
 
 def training(dataset: CameraDataset, gaussians: GaussianModel, trainer: AbstractTrainer, destination: str, iteration: int, save_iterations: List[int], device: str):
     shutil.rmtree(os.path.join(destination, "point_cloud"), ignore_errors=True)  # remove the previous point cloud
-    pbar = tqdm(range(1, iteration+1))
+    pbar = tqdm(range(1, iteration+1), dynamic_ncols=True, desc="Training")
     epoch = list(range(len(dataset)))
     epoch_psnr = torch.empty(3, 0, device=device)
+    epoch_maskpsnr = torch.empty(3, 0, device=device)
     ema_loss_for_log = 0.0
     avg_psnr_for_log = 0.0
+    avg_maskpsnr_for_log = 0.0
     for step in pbar:
         epoch_idx = step % len(dataset)
         if epoch_idx == 0:
             avg_psnr_for_log = epoch_psnr.mean().item()
+            avg_maskpsnr_for_log = epoch_maskpsnr.mean().item()
             epoch_psnr = torch.empty(3, 0, device=device)
+            epoch_maskpsnr = torch.empty(3, 0, device=device)
             random.shuffle(epoch)
         idx = epoch[epoch_idx]
         loss, out = trainer.step(dataset[idx])
         with torch.no_grad():
+            ground_truth_image = dataset[idx].ground_truth_image
+            rendered_image = out["render"]
+            epoch_psnr = torch.concat([epoch_psnr, psnr(rendered_image, ground_truth_image)], dim=1)
+            if dataset[idx].ground_truth_image_mask is not None:
+                ground_truth_maskimage = ground_truth_image * dataset[idx].ground_truth_image_mask
+                rendered_maskimage = rendered_image * dataset[idx].ground_truth_image_mask
+                epoch_maskpsnr = torch.concat([epoch_maskpsnr, psnr(rendered_maskimage, ground_truth_maskimage)], dim=1)
             ema_loss_for_log = 0.4 * loss.item() + 0.6 * ema_loss_for_log
-            epoch_psnr = torch.concat([epoch_psnr, psnr(out["render"], dataset[idx].ground_truth_image)], dim=1)
             if step % 10 == 0:
-                pbar.set_postfix({'epoch': step // len(dataset), 'loss': ema_loss_for_log, 'psnr': avg_psnr_for_log, 'n': gaussians._xyz.shape[0]})
+                postfix = {'epoch': step // len(dataset), 'loss': ema_loss_for_log, 'psnr': avg_psnr_for_log, 'n': gaussians._xyz.shape[0]}
+                if avg_maskpsnr_for_log > 0:
+                    postfix['mask_psnr'] = avg_maskpsnr_for_log
+                pbar.set_postfix(postfix)
         if step in save_iterations:
             save_path = os.path.join(destination, "point_cloud", "iteration_" + str(step))
             os.makedirs(save_path, exist_ok=True)
@@ -65,6 +82,7 @@ if __name__ == "__main__":
     parser.add_argument("-i", "--iteration", default=30000, type=int)
     parser.add_argument("-l", "--load_ply", default=None, type=str)
     parser.add_argument("--load_camera", default=None, type=str)
+    parser.add_argument("--no_image_mask", action="store_true")
     parser.add_argument("--no_depth_data", action="store_true")
     parser.add_argument("--with_scale_reg", action="store_true")
     parser.add_argument("--mode", choices=sorted(list(set(list(basemodes.keys()) + list(shliftmodes.keys())))), default="base")
@@ -78,7 +96,9 @@ if __name__ == "__main__":
     configs = {o.split("=", 1)[0]: eval(o.split("=", 1)[1]) for o in args.option}
     dataset, gaussians, trainer = prepare_training(
         sh_degree=args.sh_degree, source=args.source, device=args.device, mode=args.mode, trainable_camera="camera" in args.mode,
-        load_ply=args.load_ply, load_camera=args.load_camera, load_depth=not args.no_depth_data, with_scale_reg=args.with_scale_reg, configs=configs)
+        load_ply=args.load_ply, load_camera=args.load_camera,
+        load_mask=not args.no_image_mask, load_depth=not args.no_depth_data,
+        with_scale_reg=args.with_scale_reg, configs=configs)
     dataset.save_cameras(os.path.join(args.destination, "cameras.json"))
     torch.cuda.empty_cache()
     training(

gaussian_splatting/trainer/abc.py

@@ -33,6 +33,10 @@ class AbstractTrainer(ABC):
     def schedulers(self) -> Dict[str, Callable[[int], float]]:
         raise ValueError("Schedulers is not set")
 
+    @abstractmethod
+    def preprocess(self, camera: Camera) -> Camera:
+        pass
+
     @abstractmethod
     def loss(self, out: dict, camera: Camera) -> torch.Tensor:
         pass
@@ -49,6 +53,7 @@ class AbstractTrainer(ABC):
 
     def step(self, camera: Camera):
         self.update_learning_rate()
+        camera = self.preprocess(camera)
         out = self.model(camera)
         loss = self.loss(out, camera)
         loss.backward()
@@ -100,6 +105,9 @@ class TrainerWrapper(AbstractTrainer):
     def schedulers(self) -> Dict[str, Callable[[int], float]]:
         return self.base_trainer.schedulers
 
+    def preprocess(self, camera: Camera) -> Camera:
+        return self.base_trainer.preprocess(camera)
+
     def loss(self, out: dict, camera: Camera) -> torch.Tensor:
         return self.base_trainer.loss(out, camera)
 

gaussian_splatting/trainer/base.py

@@ -22,13 +22,23 @@ class BaseTrainer(AbstractTrainer):
             opacity_lr=0.025,
             scaling_lr=0.005,
             rotation_lr=0.001,
-            ignore_out_of_mask_loss=False,  # whether to ignore loss for out-of-mask pixels, if True, these pixels will be ignored in loss computation
-            random_out_of_mask_color=False,  # if ignore_out_of_mask_loss is False, whether use random color or use camera.bg_color for out-of-mask pixels
+            mask_mode="none",
+            # "none"=do not use mask
+            # "ignore"=loss of the masked area will be set to 0
+            # "bg_color"=fill the masked area of ground truth with the bg_color for rendering
+            bg_color=None,
+            # None=do not change bg_color
+            # "random"=set bg_color to random color
+            # tuple(float, float, float)=set bg_color to the given color
     ):
         super().__init__()
         self.lambda_dssim = lambda_dssim
-        self.ignore_out_of_mask_loss = ignore_out_of_mask_loss
-        self.random_out_of_mask_color = random_out_of_mask_color
+        assert mask_mode in ["none", "ignore", "bg_color"], f"Unknown mask policy: {mask_mode}"
+        assert bg_color is None or bg_color == "random" or (
+            isinstance(bg_color, tuple) and len(bg_color) == 3 and all(isinstance(c, float) for c in bg_color)
+        ), f"bg_color must be 'random' or a RGB value tuple(float, float, float), got {bg_color}"
+        self.mask_mode = mask_mode
+        self.bg_color = bg_color
         params = [
             {'params': [model._xyz], 'lr': position_lr_init * scene_extent, "name": "xyz"},
             {'params': [model._features_dc], 'lr': feature_lr, "name": "f_dc"},
@@ -71,18 +81,35 @@ class BaseTrainer(AbstractTrainer):
     def schedulers(self) -> Dict[str, Callable[[int], float]]:
         return self._schedulers
 
+    def preprocess(self, camera: Camera) -> Camera:
+        if self.bg_color == "random":
+            camera = camera._replace(bg_color=torch.rand_like(camera.bg_color))
+        elif isinstance(self.bg_color, tuple):
+            camera = camera._replace(bg_color=torch.tensor(self.bg_color, device=camera.bg_color.device, dtype=camera.bg_color.dtype))
+        elif self.bg_color is None:
+            pass
+        else:
+            raise ValueError(f"bg_color must be 'random' or a tuple(int, int, int), got {self.bg_color}")
+        return camera
+
     def loss(self, out: dict, camera: Camera) -> torch.Tensor:
         render = out["render"]
         gt = camera.ground_truth_image
         mask = camera.ground_truth_image_mask
-        if mask is not None:
-            if self.ignore_out_of_mask_loss:
+        match self.mask_mode:
+            case "none":
+                pass
+            case "ignore":
+                assert mask is not None, "Mask is required for 'ignore' mask policy"
                 render = render * mask.unsqueeze(0)
                 gt = gt * mask.unsqueeze(0)
-            elif self.random_out_of_mask_color:
-                gt = gt * mask.unsqueeze(0) + (1 - mask.unsqueeze(0)) * torch.rand_like(gt)
-            else:
-                gt = gt * mask.unsqueeze(0) + (1 - mask.unsqueeze(0)) * camera.bg_color.unsqueeze(-1).unsqueeze(-1)
+            case "bg_color":
+                assert mask is not None, "Mask is required for 'bg_color' mask policy"
+                # bg_color after postprocess
+                bg_color = camera.postprocess(camera, camera.bg_color.unsqueeze(-1).unsqueeze(-1)).clamp(0.0, 1.0)
+                gt = gt * mask.unsqueeze(0) + (1 - mask.unsqueeze(0)) * bg_color
+            case _:
+                raise ValueError(f"Unknown mask policy: {self.mask_mode}")
         Ll1 = l1_loss(render, gt)
         ssim_value = ssim(render, gt)
         loss = (1.0 - self.lambda_dssim) * Ll1 + self.lambda_dssim * (1.0 - ssim_value)

gaussian_splatting/trainer/depth.py

@@ -75,10 +75,6 @@ class DepthTrainer(TrainerWrapper):
         invdepth = out["depth"].squeeze(0)
         invdepth_gt = camera.ground_truth_depth
         mask = camera.ground_truth_depth_mask
-        if mask is None:
-            mask = camera.ground_truth_image_mask
-        elif camera.ground_truth_image_mask is not None:
-            mask = mask * camera.ground_truth_image_mask
         assert invdepth.shape == invdepth_gt.shape, f"invdepth shape {invdepth.shape} does not match gt depth shape {invdepth_gt.shape}"
         if self.depth_resize is not None:
             height, width = invdepth.shape[-2:]

{gaussian_splatting-1.17.5.dist-info → gaussian_splatting-1.19.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gaussian_splatting
-Version: 1.17.5
+Version: 1.19.4
 Summary: Refactored python training and inference code for 3D Gaussian Splatting
 Home-page: https://github.com/yindaheng98/gaussian-splatting
 Author: yindaheng98
@@ -13,6 +13,8 @@ Requires-Dist: plyfile
 Requires-Dist: tifffile
 Requires-Dist: numpy
 Requires-Dist: opencv-python
+Requires-Dist: pillow
+Requires-Dist: open3d
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -46,15 +48,6 @@ We **refactored the original code following the standard Python package structur
 * [Pytorch](https://pytorch.org/) (>= v2.4 recommended)
 * [CUDA Toolkit](https://developer.nvidia.com/cuda-12-4-0-download-archive) (12.4 recommended, match with PyTorch version)
 
-### Local Install
-
-```shell
-git clone --recursive https://github.com/yindaheng98/gaussian-splatting
-cd gaussian-splatting
-pip install tqdm plyfile tifffile
-pip install --target . --upgrade . --no-deps
-```
-
 ### PyPI Install
 
 ```shell
@@ -63,7 +56,17 @@ pip install --upgrade gaussian-splatting
 or
 build latest from source:
 ```shell
-pip install --upgrade git+https://github.com/yindaheng98/gaussian-splatting.git@master
+pip install wheel setuptools
+pip install --upgrade git+https://github.com/yindaheng98/gaussian-splatting.git@master --no-build-isolation
+```
+
+### Development Install
+
+```shell
+git clone --recursive https://github.com/yindaheng98/gaussian-splatting
+cd gaussian-splatting
+pip install tqdm plyfile tifffile numpy opencv-python pillow open3d
+pip install --target . --upgrade . --no-deps
 ```
 
 ## Quick Start

{gaussian_splatting-1.17.5.dist-info → gaussian_splatting-1.19.4.dist-info}/RECORD

@@ -1,26 +1,26 @@
 gaussian_splatting/__init__.py,sha256=CiOZMcyPTAaKtEuMZUhEda_Ad4_RUhmIstB-A3iuOJY,131
-gaussian_splatting/camera.py,sha256=u-U99RW9dCPVqUZxVzrUW7nxHsXgKZ7NXHnSqCNOfKk,8365
+gaussian_splatting/camera.py,sha256=vo7mu6lyFpIhDqOAgNiJuPan8t_nDJn5cJkAYygLFcA,9243
 gaussian_splatting/camera_trainable.py,sha256=nI6hFFRV2ev7VwLlKUbzEdN9zUmngYZAANGLr1p1yBA,3841
 gaussian_splatting/gaussian_model.py,sha256=_Dy_dDa2prALhVgg428a-O8-8PODg3c_JPkOJJ8X4o8,13275
-gaussian_splatting/prepare.py,sha256=SdljFF2TU-ETkIY2ceHEz9tGA-o4HfHxGsFKIhyB1Ek,3042
-gaussian_splatting/render.py,sha256=2dP7Yr5e5uLJAs9MwRJSBY9eZQjaDtf9XB-HdtPmxPc,5930
-gaussian_splatting/train.py,sha256=VAFlPHB5ETH8BiYhe0LWY2UWXyB16tSRPKUaV5VPp5A,5196
+gaussian_splatting/prepare.py,sha256=rgwdDhPU-sS57ZgTLKwzognbS1hfR2JtjZqlC4FqPbI,3241
+gaussian_splatting/render.py,sha256=RhZoILWxtkuDEhiL2cQsvZWNBmkyDAROYdvrQaFhPkc,6295
+gaussian_splatting/train.py,sha256=JTKK9M0bfyr8d3UK-Fr2MxgiIYF0YheH0uOdPEACBnU,6262
 gaussian_splatting/dataset/__init__.py,sha256=-runuT-61P0YVpfV_WXqwUZM1oY0N012YH13Bt3rzSU,138
-gaussian_splatting/dataset/camera_trainable.py,sha256=D8bqeLVcnQ4qrsy3U1s6BVzdG4KCCPGR-Tygj6nLp-Q,4969
-gaussian_splatting/dataset/dataset.py,sha256=mlcIS0pJNdUIT-RObcQNYwgxxTOFJ0OYg3AlhoQ4Mww,2315
+gaussian_splatting/dataset/camera_trainable.py,sha256=Kd8v-_ZJ9dLIQ2QyVOXbmouYf5QjbgOgHNRHVpkgCms,5041
+gaussian_splatting/dataset/dataset.py,sha256=0tmIZ5P7kOEdABiEAXPznkRN91e5rcT5VsAzOLoOuEM,2392
 gaussian_splatting/dataset/colmap/__init__.py,sha256=YEYT2k2WJSqrkkZq4KAJYS9UMgqU6W6TJaeHLRc1CM4,213
-gaussian_splatting/dataset/colmap/dataset.py,sha256=Lq2b3hMdtOmdqPjvEjR6CLukAR7dZBEKMz8yzDD2Bgo,4519
+gaussian_splatting/dataset/colmap/dataset.py,sha256=0UBQ6ynOqElHZSphJ-MSbYQqCwwYZaAXl1y9AY5YKuY,4720
 gaussian_splatting/dataset/colmap/params_init.py,sha256=6_6gZ0Wl4aZrps2PJ_U234sxW5D-vOTfwioVa1FWC-E,1802
 gaussian_splatting/dataset/colmap/read_write_model.py,sha256=TenI7ai5UV7Ksg2vAXvJWnYFwOOo1tlS_633RfCLuQU,23137
-gaussian_splatting/diff_gaussian_rasterization/_C.cp310-win_amd64.pyd,sha256=LEyDJZQpNgMgbNdKeY4hdD6DvTOU6sdBQDxsqQMa2b8,1287680
+gaussian_splatting/diff_gaussian_rasterization/_C.cp310-win_amd64.pyd,sha256=Ty4zoYipuoG31tUALZawVhJk7m9kfNAFIrN9aPUoojs,1287680
 gaussian_splatting/diff_gaussian_rasterization/__init__.py,sha256=a9D0IZiPx-Mk1795hSq54T-NYT4MtEN_MZrxeMhw0Eo,6705
-gaussian_splatting/simple_knn/_C.cp310-win_amd64.pyd,sha256=Zq7CU8hroN6d5kmH8Apbbp5B77R4R3rzmAW4pW6pDx0,1156608
+gaussian_splatting/simple_knn/_C.cp310-win_amd64.pyd,sha256=m5AuAQx7PV2F9yyi-Gl7oTK8yQ8Uukg39UkFv7HmC98,1156608
 gaussian_splatting/trainer/__init__.py,sha256=962fEY8A0spSQn5de_d_LkPOjA1PYKrLbuAkxwZo7mI,940
-gaussian_splatting/trainer/abc.py,sha256=kpYnJjLOhsyhE-V2J79EC9nih6MYBcXkmK9cHUA-3ao,4022
-gaussian_splatting/trainer/base.py,sha256=7fe1nEnSvrvgAjTJ5Qx-oeXjtUhCxNmziZmvFa8F7n8,3565
+gaussian_splatting/trainer/abc.py,sha256=_gcqmEobhSOdZnMyNb2oKS6cZJ-Mg3oYL4xJ5Y3_oic,4262
+gaussian_splatting/trainer/base.py,sha256=fngLruQ9hMSNLFbc_5woG7jm6cidpoZ0dzk_zImRaE4,4851
 gaussian_splatting/trainer/camera_trainable.py,sha256=TBQXn2f578qeizPz6tgqFm-GRvttv9duuB1xx7_J9TQ,4567
 gaussian_splatting/trainer/combinations.py,sha256=7NX4fXdDOx8ri1_mgAaWNx-YVdo5XsqMlr9qy-Ll2MM,5329
-gaussian_splatting/trainer/depth.py,sha256=EkFfOKdTYUkm4yZwsa9mx0NUf3jYqM74xOYefQvESAA,7252
+gaussian_splatting/trainer/depth.py,sha256=PxWBSNxzoQcRfCFI_yJnJMS6s8qFWn81CXK6O6ffXL0,7059
 gaussian_splatting/trainer/opacity_reset.py,sha256=KfxDyWBNocETGcqCRTdE1n3t63HmjChaAuIP3OTIWtg,2615
 gaussian_splatting/trainer/sh_lift.py,sha256=Hwcn_cRzXZChESpTL83ZmR608ewCR2OzItt-wZtRpak,1220
 gaussian_splatting/trainer/densifier/__init__.py,sha256=cg4aGUolq5ayWtoqQP_BEmHE4NOD5ZuzCluRclJS61I,359
@@ -45,8 +45,8 @@ gaussian_splatting/utils/lpipsPyTorch/modules/__init__.py,sha256=47DEQpj8HBSa-_T
 gaussian_splatting/utils/lpipsPyTorch/modules/lpips.py,sha256=YScu0oXIEstCCjJVRItS_R_csUw70sBMFuP8Syl2UdI,1187
 gaussian_splatting/utils/lpipsPyTorch/modules/networks.py,sha256=kqIebq7dAhHypTXweFVEf_RDbN7_Zv7O3MlD-CfRvpg,2788
 gaussian_splatting/utils/lpipsPyTorch/modules/utils.py,sha256=TDcem3E3HqDNN2MT8qlOL_BKVHeO4HRE77JxF-kOWk8,915
-gaussian_splatting-1.17.5.dist-info/licenses/LICENSE.md,sha256=bMuRQKn0u485mx8JBBTJ5Simc-aWHaQsxmoB6jsg5oE,4752
-gaussian_splatting-1.17.5.dist-info/METADATA,sha256=geavPS-j9RiDlb-ylv5cm3m7CMjSaJWzdHP3BZ4xsX0,17046
-gaussian_splatting-1.17.5.dist-info/WHEEL,sha256=KUuBC6lxAbHCKilKua8R9W_TM71_-9Sg5uEP3uDWcoU,101
-gaussian_splatting-1.17.5.dist-info/top_level.txt,sha256=uaYrPYXRHhpybgCnsoazTcdhpzZGnLT_vd5eoRzBWWI,19
-gaussian_splatting-1.17.5.dist-info/RECORD,,
+gaussian_splatting-1.19.4.dist-info/licenses/LICENSE.md,sha256=bMuRQKn0u485mx8JBBTJ5Simc-aWHaQsxmoB6jsg5oE,4752
+gaussian_splatting-1.19.4.dist-info/METADATA,sha256=JyAP_8QWzwTb_H9KkJeTQnVpervcFxSFzJZwRu3YmgI,17183
+gaussian_splatting-1.19.4.dist-info/WHEEL,sha256=KUuBC6lxAbHCKilKua8R9W_TM71_-9Sg5uEP3uDWcoU,101
+gaussian_splatting-1.19.4.dist-info/top_level.txt,sha256=uaYrPYXRHhpybgCnsoazTcdhpzZGnLT_vd5eoRzBWWI,19
+gaussian_splatting-1.19.4.dist-info/RECORD,,