reduced-3dgs 1.10.2__tar.gz → 1.10.4__tar.gz

{reduced_3dgs-1.10.2 → reduced_3dgs-1.10.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reduced_3dgs
-Version: 1.10.2
+Version: 1.10.4
 Summary: Refactored code for the paper "Reducing the Memory Footprint of 3D Gaussian Splatting"
 Home-page: https://github.com/yindaheng98/reduced-3dgs
 Author: yindaheng98

{reduced_3dgs-1.10.2 → reduced_3dgs-1.10.4}/reduced_3dgs/quantization/quantizer.py

@@ -206,8 +206,7 @@ class VectorQuantizer(AbstractQuantizer):
             ids_dict = self.find_nearest_cluster_id(model, self._codebook_dict)
         return ids_dict, codebook_dict
 
-    def save_quantized(self, model: GaussianModel, ply_path: str):
-        ids_dict, codebook_dict = self.quantize(model, update_codebook=False)
+    def ply_dtype(self, max_sh_degree: int):
         dtype_full = [
             ('x', 'f4'), ('y', 'f4'), ('z', 'f4'),
             ('nx', 'f4'), ('ny', 'f4'), ('nz', 'f4'),
@@ -217,13 +216,16 @@ class VectorQuantizer(AbstractQuantizer):
             ('scale', self.force_code_dtype or compute_uint_dtype(self.num_clusters_scaling)),
             ('f_dc', self.force_code_dtype or compute_uint_dtype(self.num_clusters_features_dc)),
         ]
-        for sh_degree in range(model.max_sh_degree):
+        for sh_degree in range(max_sh_degree):
             force_code_dtype = self.force_code_dtype or compute_uint_dtype(self.num_clusters_features_rest[sh_degree])
             dtype_full.extend([
                 (f'f_rest_{sh_degree}_0', force_code_dtype),
                 (f'f_rest_{sh_degree}_1', force_code_dtype),
                 (f'f_rest_{sh_degree}_2', force_code_dtype),
             ])
+        return dtype_full
+
+    def ply_data(self, model: GaussianModel, ids_dict: Dict[str, torch.Tensor]):
         data_full = [
             *np.array_split(model._xyz.detach().cpu().numpy(), 3, axis=1),
             *np.array_split(torch.zeros_like(model._xyz).detach().cpu().numpy(), 3, axis=1),
@@ -236,6 +238,12 @@ class VectorQuantizer(AbstractQuantizer):
         for sh_degree in range(model.max_sh_degree):
             features_rest = ids_dict[f'features_rest_{sh_degree}'].cpu().numpy()
             data_full.extend(np.array_split(features_rest, 3, axis=1))
+        return data_full
+
+    def save_quantized(self, model: GaussianModel, ply_path: str):
+        ids_dict, codebook_dict = self.quantize(model, update_codebook=False)
+        dtype_full = self.ply_dtype(model.max_sh_degree)
+        data_full = self.ply_data(model, ids_dict)
 
         elements = np.rec.fromarrays([data.squeeze(-1) for data in data_full], dtype=dtype_full)
         el = PlyElement.describe(elements, 'vertex')
@@ -254,36 +262,46 @@ class VectorQuantizer(AbstractQuantizer):
 
         PlyData([el, *cb]).write(ply_path)
 
-    def load_quantized(self, model: GaussianModel, ply_path: str) -> GaussianModel:
-        plydata = PlyData.read(ply_path)
-
+    def parse_ids(self, plydata: PlyData, max_sh_degree: int, device: torch.device) -> Dict[str, torch.Tensor]:
         ids_dict = {}
         elements = plydata['vertex']
-        kwargs = dict(dtype=torch.long, device=model._xyz.device)
+        kwargs = dict(dtype=torch.long, device=device)
         ids_dict["rotation_re"] = torch.tensor(elements["rot_re"].copy(), **kwargs)
         ids_dict["rotation_im"] = torch.tensor(elements["rot_im"].copy(), **kwargs)
         ids_dict["opacity"] = torch.tensor(elements["opacity"].copy(), **kwargs)
         ids_dict["scaling"] = torch.tensor(elements["scale"].copy(), **kwargs)
         ids_dict["features_dc"] = torch.tensor(elements["f_dc"].copy(), **kwargs).unsqueeze(-1)
-        for sh_degree in range(model.max_sh_degree):
+        for sh_degree in range(max_sh_degree):
             ids_dict[f'features_rest_{sh_degree}'] = torch.tensor(np.stack([elements[f'f_rest_{sh_degree}_{ch}'] for ch in range(3)], axis=1), **kwargs)
+        return ids_dict
 
+    def parse_codebook(self, plydata: PlyData, max_sh_degree: int, device: torch.device) -> Dict[str, torch.Tensor]:
         codebook_dict = {}
-        kwargs = dict(dtype=torch.float32, device=model._xyz.device)
+        kwargs = dict(dtype=torch.float32, device=device)
         codebook_dict["rotation_re"] = torch.tensor(plydata["codebook_rot_re"]["rot_re"], **kwargs).unsqueeze(-1)
         codebook_dict["rotation_im"] = torch.tensor(np.stack([plydata["codebook_rot_im"][f'rot_im_{ch}'] for ch in range(3)], axis=1), **kwargs)
         codebook_dict["opacity"] = torch.tensor(plydata["codebook_opacity"]["opacity"], **kwargs).unsqueeze(-1)
         codebook_dict["scaling"] = torch.tensor(np.stack([plydata["codebook_scaling"][f'scaling_{ch}'] for ch in range(3)], axis=1), **kwargs)
         codebook_dict["features_dc"] = torch.tensor(np.stack([plydata["codebook_f_dc"][f'f_dc_{ch}'] for ch in range(3)], axis=1), **kwargs)
-        for sh_degree in range(model.max_sh_degree):
+        for sh_degree in range(max_sh_degree):
             n_channels = (sh_degree + 2) ** 2 - (sh_degree + 1) ** 2
             codebook_dict[f'features_rest_{sh_degree}'] = torch.tensor(np.stack([plydata[f"codebook_f_rest_{sh_degree}"][f'f_rest_{sh_degree}_{ch}'] for ch in range(n_channels)], axis=1), **kwargs)
+        return codebook_dict
 
-        self._codebook_dict = codebook_dict
-
+    def parse_xyz(self, plydata: PlyData, device: torch.device) -> torch.Tensor:
+        elements = plydata['vertex']
+        kwargs = dict(dtype=torch.float32, device=device)
         xyz = torch.stack([
             torch.tensor(elements["x"].copy(), **kwargs),
             torch.tensor(elements["y"].copy(), **kwargs),
             torch.tensor(elements["z"].copy(), **kwargs),
         ], dim=1)
+        return xyz
+
+    def load_quantized(self, model: GaussianModel, ply_path: str) -> GaussianModel:
+        plydata = PlyData.read(ply_path)
+        ids_dict = self.parse_ids(plydata, model.max_sh_degree, model._xyz.device)
+        codebook_dict = self.parse_codebook(plydata, model.max_sh_degree, model._xyz.device)
+        xyz = self.parse_xyz(plydata, model._xyz.device)
+        self._codebook_dict = codebook_dict
         return self.dequantize(model, ids_dict, codebook_dict, xyz=xyz, replace=True)

{reduced_3dgs-1.10.2 → reduced_3dgs-1.10.4}/reduced_3dgs/quantize.py

@@ -13,6 +13,7 @@ def copy_not_exists(source, destination):
 
 
 def quantize(source, destination, iteration, sh_degree, device, **kwargs):
+    os.makedirs(destination, exist_ok=True)
     copy_not_exists(os.path.join(source, "cfg_args"), os.path.join(destination, "cfg_args"))
     copy_not_exists(os.path.join(source, "cameras.json"), os.path.join(destination, "cameras.json"))
 

{reduced_3dgs-1.10.2 → reduced_3dgs-1.10.4}/reduced_3dgs.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reduced_3dgs
-Version: 1.10.2
+Version: 1.10.4
 Summary: Refactored code for the paper "Reducing the Memory Footprint of 3D Gaussian Splatting"
 Home-page: https://github.com/yindaheng98/reduced-3dgs
 Author: yindaheng98

{reduced_3dgs-1.10.2 → reduced_3dgs-1.10.4}/setup.py

@@ -60,7 +60,7 @@ if os.name == 'nt':
 
 setup(
     name="reduced_3dgs",
-    version='1.10.2',
+    version='1.10.4',
     author='yindaheng98',
     author_email='yindaheng98@gmail.com',
     url='https://github.com/yindaheng98/reduced-3dgs',