extrinterp 1.1.2__py3-none-any.whl

extrinterp/__init__.py

@@ -0,0 +1,3 @@
+from .abc import Extrinsic, ExtrinsicDataset, Extrinsic2CameraDataset
+from .interp import interpolation, smooth_interpolation
+from .dataset import ExtrinsicInterpolator, ExtrinsicInterpolationDataset

extrinterp/abc.py

@@ -0,0 +1,86 @@
+from abc import abstractmethod
+from typing import NamedTuple
+
+import torch
+from torch.utils.data import Dataset
+
+from gaussian_splatting import Camera
+from gaussian_splatting.dataset import CameraDataset
+from gaussian_splatting.camera import build_camera
+
+
+class Extrinsic(NamedTuple):
+    R: torch.Tensor
+    T: torch.Tensor
+
+    @classmethod
+    def from_camera(cls, camera: Camera) -> 'Extrinsic':
+        return cls(
+            R=camera.R,
+            T=camera.T,
+        )
+
+    def to_camera(
+        self,
+        image_height: int, image_width: int,
+        FoVx: float, FoVy: float,
+        *args, **kwargs
+    ) -> Camera:
+        return build_camera(
+            image_width=image_width,
+            image_height=image_height,
+            FoVx=FoVx,
+            FoVy=FoVy,
+            R=self.R,
+            T=self.T,
+            *args, **kwargs
+        )
+
+    def to(self, device):
+        return Extrinsic(
+            R=self.R.to(device),
+            T=self.T.to(device),
+        )
+
+
+class ExtrinsicDataset(Dataset):
+    @abstractmethod
+    def to(self, device) -> 'ExtrinsicDataset':
+        return self
+
+    @abstractmethod
+    def __len__(self) -> int:
+        raise NotImplementedError
+
+    @abstractmethod
+    def __getitem__(self, idx) -> Extrinsic:
+        raise NotImplementedError
+
+
+class Extrinsic2CameraDataset(CameraDataset):
+    def __init__(
+        self,
+            dataset: ExtrinsicDataset,
+            image_height: int = 1000, image_width: int = 1000,
+            FoVx: float = 90.0*torch.pi/180, FoVy: float = 90.0*torch.pi/180):
+        self.cameras = dataset
+        self.image_height = image_height
+        self.image_width = image_width
+        self.FoVx = FoVx
+        self.FoVy = FoVy
+
+    def __len__(self):
+        return len(self.cameras)
+
+    def __getitem__(self, idx) -> Camera:
+        return self.cameras[idx].to_camera(
+            image_height=self.image_height,
+            image_width=self.image_width,
+            FoVx=self.FoVx,
+            FoVy=self.FoVy,
+            device=self.cameras[idx].R.device
+        )
+
+    def to(self, device):
+        self.cameras = self.cameras.to(device)
+        return self

extrinterp/dataset.py

@@ -0,0 +1,26 @@
+from gaussian_splatting.dataset import CameraDataset
+from .abc import Extrinsic, ExtrinsicDataset, Extrinsic2CameraDataset
+from .interp import smooth_interpolation
+
+
+class ExtrinsicInterpolator(ExtrinsicDataset):
+
+    def __init__(self, dataset: CameraDataset, n: int, window_size: int = 3):
+        self.cameras = smooth_interpolation(dataset=dataset, n=n, window_size=window_size)
+
+    def __len__(self):
+        return len(self.cameras)
+
+    def __getitem__(self, idx) -> Extrinsic:
+        return self.cameras[idx]
+
+    def to(self, device):
+        self.cameras = [camera.to(device) for camera in self.cameras]
+        return self
+
+
+def ExtrinsicInterpolationDataset(dataset: CameraDataset, n: int, *args, window_size: int = 3, **kwargs) -> Extrinsic2CameraDataset:
+    return Extrinsic2CameraDataset(
+        dataset=ExtrinsicInterpolator(dataset=dataset, n=n, window_size=window_size),
+        *args, **kwargs
+    )

extrinterp/interp.py

@@ -0,0 +1,64 @@
+from typing import List
+import torch
+from gaussian_splatting.utils import matrix_to_quaternion, quaternion_to_matrix
+from .abc import Extrinsic
+
+
+def linspace_cameras(start: Extrinsic, end: Extrinsic, n: int) -> List[Extrinsic]:
+    ratio = torch.linspace(0, 1, n, device=start.R.device).unsqueeze(-1)
+    Ts = start.T.unsqueeze(0) + ratio * (end.T.unsqueeze(0) - start.T.unsqueeze(0))
+    q_start, q_end = matrix_to_quaternion(start.R), matrix_to_quaternion(end.R)
+    qs = q_start.unsqueeze(0) + ratio * (q_end.unsqueeze(0) - q_start.unsqueeze(0))
+    Rs = quaternion_to_matrix(qs)
+    return [Extrinsic(R=R, T=T) for R, T in zip(Rs, Ts)]
+
+
+def sort_cameras(cameras: List[Extrinsic]) -> List[Extrinsic]:
+    Ts = torch.stack([camera.T for camera in cameras])
+    distances = torch.cdist(Ts, Ts)
+    next_idx = distances.mean(0).argmax()
+    sorted_cameras = [cameras.pop(next_idx)]
+    while cameras:
+        distances = torch.cdist(sorted_cameras[-1].T.unsqueeze(0), torch.stack([camera.T for camera in cameras])).squeeze(0)
+        next_idx = distances.argmin()
+        sorted_cameras.append(cameras.pop(next_idx))
+    return sorted_cameras
+
+
+def interpolation(cameras: List[Extrinsic], n: int) -> List[Extrinsic]:
+    cameras = sort_cameras(cameras)
+    new_cameras = []
+    for i in range(len(cameras) - 1):
+        k = round((n - 1) / (len(cameras) - 1 - i))
+        new_cameras.extend(linspace_cameras(cameras[i], cameras[i + 1], k + 1)[:-1])
+        n -= k
+    new_cameras.append(cameras[-1])
+    return new_cameras
+
+
+def smooth_1d(inputs: torch.Tensor, window_size: int = 3) -> torch.Tensor:
+    shape = inputs.shape
+    inputs = inputs.view(shape[0], -1).T.unsqueeze(1)
+    if window_size % 2 == 0:
+        raise ValueError("Window size must be odd.")
+    kernel = torch.ones((1, 1, window_size), device=inputs.device) / window_size
+    outputs = torch.nn.functional.conv1d(inputs, kernel, stride=1, padding=0)
+    return outputs.squeeze(1).T.view(shape[0] - window_size//2*2, *shape[1:]).contiguous()
+
+
+def smooth(cameras: List[Extrinsic], window_size: int = 3) -> List[Extrinsic]:
+    Ts = smooth_1d(torch.stack([camera.T for camera in cameras]), window_size=window_size)
+    Rs = quaternion_to_matrix(smooth_1d(matrix_to_quaternion(torch.stack([camera.R for camera in cameras])), window_size=window_size))
+    return [
+        cameras[i]._replace(R=R, T=T)
+        for i, (R, T) in enumerate(zip(Rs, Ts))
+    ]
+
+
+def smooth_interpolation(dataset: List[Extrinsic], n: int, window_size: int = 3) -> List[Extrinsic]:
+    if window_size % 2 == 0:
+        raise ValueError("Window size must be odd.")
+    cameras = [Extrinsic.from_camera(camera) for camera in dataset]
+    if len(cameras) == (n + window_size // 2 * 2):
+        return smooth(cameras, window_size=window_size)
+    return smooth(interpolation(cameras, n + window_size // 2 * 2), window_size=window_size)

extrinterp/render.py

@@ -0,0 +1,70 @@
+from typing import Tuple
+import torch
+import os
+from tqdm import tqdm
+from os import makedirs
+import torchvision
+import tifffile
+from gaussian_splatting import GaussianModel
+from gaussian_splatting.dataset import CameraDataset
+from gaussian_splatting.prepare import prepare_dataset, prepare_gaussians
+from extrinterp import ExtrinsicInterpolationDataset
+
+
+def prepare_rendering(
+        sh_degree: int, source: str, device: str, n: int, window_size: int,
+        trainable_camera: bool = False, load_ply: str = None, load_camera: str = None,
+        use_intrinsics: int | dict = 0
+) -> Tuple[CameraDataset, GaussianModel]:
+    dataset = prepare_dataset(source=source, device=device, trainable_camera=trainable_camera, load_camera=load_camera, load_depth=False)
+    if isinstance(use_intrinsics, int):
+        i = use_intrinsics
+        use_intrinsics = dict(
+            image_height=dataset[i].image_height, image_width=dataset[i].image_width,
+            FoVx=dataset[i].FoVx, FoVy=dataset[i].FoVy)
+    elif not isinstance(use_intrinsics, dict):
+        raise ValueError("Invalid use_intrinsics format")
+    dataset = ExtrinsicInterpolationDataset(dataset=dataset, n=n, window_size=window_size, **use_intrinsics)
+    gaussians = prepare_gaussians(sh_degree=sh_degree, source=source, device=device, trainable_camera=trainable_camera, load_ply=load_ply)
+    return dataset, gaussians
+
+
+def rendering(dataset: CameraDataset, gaussians: GaussianModel, save: str) -> None:
+    os.makedirs(save, exist_ok=True)
+    dataset.save_cameras(os.path.join(save, "cameras.json"))
+    render_path = os.path.join(save, "renders")
+    makedirs(render_path, exist_ok=True)
+    pbar = tqdm(dataset, desc="Rendering progress")
+    for idx, camera in enumerate(pbar):
+        out = gaussians(camera)
+        rendering = out["render"]
+        torchvision.utils.save_image(rendering, os.path.join(render_path, '{0:05d}'.format(idx) + ".png"))
+        depth = out["depth"].squeeze(0)
+        tifffile.imwrite(os.path.join(render_path, '{0:05d}'.format(idx) + "_depth.tiff"), depth.cpu().numpy())
+
+
+if __name__ == "__main__":
+    from argparse import ArgumentParser
+    parser = ArgumentParser()
+    parser.add_argument("--sh_degree", default=3, type=int)
+    parser.add_argument("-s", "--source", required=True, type=str)
+    parser.add_argument("-d", "--destination", required=True, type=str)
+    parser.add_argument("-i", "--iteration", required=True, type=int)
+    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("--interp_n", required=True, type=int)
+    parser.add_argument("--interp_window_size", type=int, default=3)
+    parser.add_argument("--use_intrinsics", type=str, default="0", help="Use intrinsics for rendering, can be an integer index or a dict with keys: image_height, image_width, FoVx, FoVy")
+    args = parser.parse_args()
+    load_ply = os.path.join(args.destination, "point_cloud", "iteration_" + str(args.iteration), "point_cloud.ply")
+    save = os.path.join(args.destination, "ours_{}".format(args.iteration))
+    with torch.no_grad():
+        dataset, gaussians = prepare_rendering(
+            sh_degree=args.sh_degree, source=args.source, device=args.device,
+            n=args.interp_n, window_size=args.interp_window_size,
+            trainable_camera=args.mode == "camera",
+            load_ply=load_ply, load_camera=args.load_camera,
+            use_intrinsics=eval(args.use_intrinsics)
+        )
+        rendering(dataset, gaussians, save)

extrinterp-1.1.2.dist-info/METADATA

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: extrinterp
+Version: 1.1.2
+Summary: Just a simple camera interpolator for Gaussian Splatting framework.
+Author-email: yindaheng98 <yindaheng98@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2024 Project VVStreams
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/yindaheng98/ExtrinsicInterpolator
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: gaussian-splatting
+Dynamic: license-file
+
+# Extrinsic Interpolator
+
+Just a simple camera interpolator for [Gaussian Splatting](https://github.com/yindaheng98/gaussian-splatting) framework.
+
+```sh
+pip install --upgrade --target . --no-deps git+https://github.com/yindaheng98/gaussian-splatting.git@master
+pip install --upgrade --target . --no-deps .
+python -m extrinterp.render -s data/truck -d output/truck -i 30000 --load_camera output/truck/cameras.json --interp_n 300 --interp_window_size 3 --use_intrinsics dict(image_width=1600,FoVx=1.4749,image_height=1200,FoVy=1.1990)
+```

extrinterp-1.1.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+extrinterp/__init__.py,sha256=ShIep0YB1E-tWyRaUZ_IlQ1Ye1APVshEiNE9vrN49kY,200
+extrinterp/abc.py,sha256=UNMEtUCjPHmRR7a0fBlL6hfy0yKLOkIY7GPkANjm82c,2161
+extrinterp/dataset.py,sha256=_sJsAIB_sYEKoKBAsoYSB0KdrmuSs22VG9nDeMDbLF4,923
+extrinterp/interp.py,sha256=byj6-8NnUAoJJPqCJaYFwP3PSHWdUxjjHE_A5yOQnpU,2878
+extrinterp/render.py,sha256=Huw1E55AjGJi6TME-sPoM7qIgCGTzOqT2aaXjQparaQ,3628
+extrinterp-1.1.2.dist-info/licenses/LICENSE,sha256=mMREImYT8k6UlMUEljpDQbd1WwJXRikZPYkknaRf-Vw,1074
+extrinterp-1.1.2.dist-info/METADATA,sha256=ZKYTOjJbLhHNZUsBYWiIEGmT4WjP4f7dGhIub3YD1FM,2235
+extrinterp-1.1.2.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+extrinterp-1.1.2.dist-info/top_level.txt,sha256=DIbpXDRMsq8slCQwd9C1R-lEAP2LvIy9mtOahxe-b78,11
+extrinterp-1.1.2.dist-info/RECORD,,

extrinterp-1.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

extrinterp-1.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Project VVStreams
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

extrinterp-1.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+extrinterp