Delete utils/.ipynb_checkpoints

utils/.ipynb_checkpoints/camera-checkpoint.py

@@ -1,120 +0,0 @@
-#
-# 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 json
-
-import numpy as np
-import torch
-
-from scene.cameras import Camera, MiniCam
-from utils.general import PILtoTorch
-from utils.graphics import fov2focal, focal2fov, getWorld2View, getProjectionMatrix
-
-
-WARNED = False
-
-
-def load_json(path, H, W):
-    cams = []
-    with open(path) as json_file:
-        contents = json.load(json_file)
-        FoVx = contents["camera_angle_x"]
-        FoVy = focal2fov(fov2focal(FoVx, W), H)
-        zfar = 100.0
-        znear = 0.01
-
-        frames = contents["frames"]
-        for idx, frame in enumerate(frames):
-            # 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
-            if c2w.shape[0] == 3:
-                one = np.zeros((1, 4))
-                one[0, -1] = 1
-                c2w = np.concatenate((c2w, one), axis=0)
-
-            # 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]
-
-            w2c = torch.as_tensor(getWorld2View(R, T)).T.cuda()
-            proj = getProjectionMatrix(znear, zfar, FoVx, FoVy).T.cuda()
-            cams.append(MiniCam(W, H, FoVx, FoVy, znear, zfar, w2c, w2c @ proj))
-    return cams
-
-
-def loadCam(args, id, cam_info, resolution_scale):
-    orig_w, orig_h = cam_info.image.size
-
-    if args.resolution in [1, 2, 4, 8]:
-        resolution = round(orig_w/(resolution_scale * args.resolution)), round(orig_h/(resolution_scale * args.resolution))
-    else:  # should be a type that converts to float
-        if args.resolution == -1:
-            if orig_w > 1600:
-                global WARNED
-                if not WARNED:
-                    print("[ INFO ] Encountered quite large input images (>1.6K pixels width), rescaling to 1.6K.\n "
-                        "If this is not desired, please explicitly specify '--resolution/-r' as 1")
-                    WARNED = True
-                global_down = orig_w / 1600
-            else:
-                global_down = 1
-        else:
-            global_down = orig_w / args.resolution
-
-        scale = float(global_down) * float(resolution_scale)
-        resolution = (int(orig_w / scale), int(orig_h / scale))
-
-    resized_image_rgb = PILtoTorch(cam_info.image, resolution)
-
-    gt_image = resized_image_rgb[:3, ...]
-    loaded_mask = None
-
-    if resized_image_rgb.shape[1] == 4:
-        loaded_mask = resized_image_rgb[3:4, ...]
-
-    return Camera(colmap_id=cam_info.uid, R=cam_info.R, T=cam_info.T, 
-                  FoVx=cam_info.FovX, FoVy=cam_info.FovY, 
-                  image=gt_image, gt_alpha_mask=loaded_mask,
-                  image_name=cam_info.image_name, uid=id, data_device=args.data_device)
-
-
-def cameraList_from_camInfos(cam_infos, resolution_scale, args):
-    camera_list = []
-
-    for id, c in enumerate(cam_infos):
-        camera_list.append(loadCam(args, id, c, resolution_scale))
-
-    return camera_list
-
-
-def camera_to_JSON(id, camera : Camera):
-    Rt = np.zeros((4, 4))
-    Rt[:3, :3] = camera.R.transpose()
-    Rt[:3, 3] = camera.T
-    Rt[3, 3] = 1.0
-
-    W2C = np.linalg.inv(Rt)
-    pos = W2C[:3, 3]
-    rot = W2C[:3, :3]
-    serializable_array_2d = [x.tolist() for x in rot]
-    camera_entry = {
-        'id' : id,
-        'img_name' : camera.image_name,
-        'width' : camera.width,
-        'height' : camera.height,
-        'position': pos.tolist(),
-        'rotation': serializable_array_2d,
-        'fy' : fov2focal(camera.FovY, camera.height),
-        'fx' : fov2focal(camera.FovX, camera.width)
-    }
-    return camera_entry

utils/.ipynb_checkpoints/depth-checkpoint.py

@@ -1,62 +0,0 @@
-import matplotlib
-import matplotlib.cm
-import numpy as np
-import torch
-
-
-def colorize(value, vmin=None, vmax=None, cmap='jet', invalid_val=-99, invalid_mask=None, background_color=(128, 128, 128, 255), gamma_corrected=False, value_transform=None):
-    """Converts a depth map to a color image.
-
-    Args:
-        value (torch.Tensor, numpy.ndarry): Input depth map. Shape: (H, W) or (1, H, W) or (1, 1, H, W). All singular dimensions are squeezed
-        vmin (float, optional): vmin-valued entries are mapped to start color of cmap. If None, value.min() is used. Defaults to None.
-        vmax (float, optional):  vmax-valued entries are mapped to end color of cmap. If None, value.max() is used. Defaults to None.
-        cmap (str, optional): matplotlib colormap to use. Defaults to 'magma_r'.
-        invalid_val (int, optional): Specifies value of invalid pixels that should be colored as 'background_color'. Defaults to -99.
-        invalid_mask (numpy.ndarray, optional): Boolean mask for invalid regions. Defaults to None.
-        background_color (tuple[int], optional): 4-tuple RGB color to give to invalid pixels. Defaults to (128, 128, 128, 255).
-        gamma_corrected (bool, optional): Apply gamma correction to colored image. Defaults to False.
-        value_transform (Callable, optional): Apply transform function to valid pixels before coloring. Defaults to None.
-
-    Returns:
-        numpy.ndarray, dtype - uint8: Colored depth map. Shape: (H, W, 4)
-    """
-    if isinstance(value, torch.Tensor):
-        value = value.detach().cpu().numpy()
-
-    value = value.squeeze()
-    if invalid_mask is None:
-        invalid_mask = value == invalid_val
-    mask = np.logical_not(invalid_mask)
-
-    # normalize
-    vmin = np.percentile(value[mask],2) if vmin is None else vmin
-    vmax = np.percentile(value[mask],98) if vmax is None else vmax
-    if vmin != vmax:
-        value = (value - vmin) / (vmax - vmin)  # vmin..vmax
-    else:
-        # Avoid 0-division
-        value = value * 0.
-
-    # squeeze last dim if it exists
-    # grey out the invalid values
-
-    value[invalid_mask] = np.nan
-    cmapper = matplotlib.cm.get_cmap(cmap)
-    if value_transform:
-        value = value_transform(value)
-        # value = value / value.max()
-    value = cmapper(value, bytes=True)  # (nxmx4)
-
-    # img = value[:, :, :]
-    img = value[...]
-    img[invalid_mask] = background_color
-
-    #     return img.transpose((2, 0, 1))
-    if gamma_corrected:
-        # gamma correction
-        img = img / 255
-        img = np.power(img, 2.2)
-        img = img * 255
-        img = img.astype(np.uint8)
-    return img

utils/.ipynb_checkpoints/general-checkpoint.py

@@ -1,140 +0,0 @@
-#
-# 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 sys
-import random
-from datetime import datetime
-import numpy as np
-import torch
-
-
-def inverse_sigmoid(x):
-    return torch.log(x/(1-x))
-
-
-def PILtoTorch(pil_image, resolution):
-    resized_image_PIL = pil_image.resize(resolution)
-    resized_image = torch.from_numpy(np.array(resized_image_PIL)) / 255.0
-    if len(resized_image.shape) == 3:
-        return resized_image.permute(2, 0, 1)
-    else:
-        return resized_image.unsqueeze(dim=-1).permute(2, 0, 1)
-
-    
-def get_expon_lr_func(
-    lr_init, lr_final, lr_delay_steps=0, lr_delay_mult=1.0, max_steps=1000000
-):
-    """
-    Copied from Plenoxels
-
-    Continuous learning rate decay function. Adapted from JaxNeRF
-    The returned rate is lr_init when step=0 and lr_final when step=max_steps, and
-    is log-linearly interpolated elsewhere (equivalent to exponential decay).
-    If lr_delay_steps>0 then the learning rate will be scaled by some smooth
-    function of lr_delay_mult, such that the initial learning rate is
-    lr_init*lr_delay_mult at the beginning of optimization but will be eased back
-    to the normal learning rate when steps>lr_delay_steps.
-    :param conf: config subtree 'lr' or similar
-    :param max_steps: int, the number of steps during optimization.
-    :return HoF which takes step as input
-    """
-
-    def helper(step):
-        if step < 0 or (lr_init == 0.0 and lr_final == 0.0):
-            # Disable this parameter
-            return 0.0
-        if lr_delay_steps > 0:
-            # A kind of reverse cosine decay.
-            delay_rate = lr_delay_mult + (1 - lr_delay_mult) * np.sin(
-                0.5 * np.pi * np.clip(step / lr_delay_steps, 0, 1)
-            )
-        else:
-            delay_rate = 1.0
-        t = np.clip(step / max_steps, 0, 1)
-        log_lerp = np.exp(np.log(lr_init) * (1 - t) + np.log(lr_final) * t)
-        return delay_rate * log_lerp
-
-    return helper
-
-
-def strip_lowerdiag(L):
-    uncertainty = torch.zeros((L.shape[0], 6), dtype=torch.float, device="cuda")
-
-    uncertainty[:, 0] = L[:, 0, 0]
-    uncertainty[:, 1] = L[:, 0, 1]
-    uncertainty[:, 2] = L[:, 0, 2]
-    uncertainty[:, 3] = L[:, 1, 1]
-    uncertainty[:, 4] = L[:, 1, 2]
-    uncertainty[:, 5] = L[:, 2, 2]
-    return uncertainty
-
-
-def strip_symmetric(sym):
-    return strip_lowerdiag(sym)
-
-
-def build_rotation(r):
-    norm = torch.sqrt(r[:,0]*r[:,0] + r[:,1]*r[:,1] + r[:,2]*r[:,2] + r[:,3]*r[:,3])
-
-    q = r / norm[:, None]
-
-    R = torch.zeros((q.size(0), 3, 3), device='cuda')
-
-    r = q[:, 0]
-    x = q[:, 1]
-    y = q[:, 2]
-    z = q[:, 3]
-
-    R[:, 0, 0] = 1 - 2 * (y*y + z*z)
-    R[:, 0, 1] = 2 * (x*y - r*z)
-    R[:, 0, 2] = 2 * (x*z + r*y)
-    R[:, 1, 0] = 2 * (x*y + r*z)
-    R[:, 1, 1] = 1 - 2 * (x*x + z*z)
-    R[:, 1, 2] = 2 * (y*z - r*x)
-    R[:, 2, 0] = 2 * (x*z - r*y)
-    R[:, 2, 1] = 2 * (y*z + r*x)
-    R[:, 2, 2] = 1 - 2 * (x*x + y*y)
-    return R
-
-
-def build_scaling_rotation(s, r):
-    L = torch.zeros((s.shape[0], 3, 3), dtype=torch.float, device="cuda")
-    R = build_rotation(r)
-
-    L[:,0,0] = s[:,0]
-    L[:,1,1] = s[:,1]
-    L[:,2,2] = s[:,2]
-
-    L = R @ L
-    return L
-
-
-def safe_state(silent):
-    old_f = sys.stdout
-    class F:
-        def __init__(self, silent):
-            self.silent = silent
-
-        def write(self, x):
-            if not self.silent:
-                if x.endswith("\n"):
-                    old_f.write(x.replace("\n", " [{}]\n".format(str(datetime.now().strftime("%d/%m %H:%M:%S")))))
-                else:
-                    old_f.write(x)
-
-        def flush(self):
-            old_f.flush()
-
-    sys.stdout = F(silent)
-
-    random.seed(0)
-    np.random.seed(0)
-    torch.manual_seed(0)
-    torch.cuda.set_device(torch.device("cuda:0"))

utils/.ipynb_checkpoints/graphics-checkpoint.py

@@ -1,83 +0,0 @@
-#
-# 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 math
-from typing import NamedTuple
-import numpy as np
-import torch
-
-
-class BasicPointCloud(NamedTuple):
-    points : np.array
-    colors : np.array
-    normals : np.array
-
-    
-def geom_transform_points(points, transf_matrix):
-    P, _ = points.shape
-    ones = torch.ones(P, 1, dtype=points.dtype, device=points.device)
-    points_hom = torch.cat([points, ones], dim=1)
-    points_out = torch.matmul(points_hom, transf_matrix.unsqueeze(0))
-
-    denom = points_out[..., 3:] + 0.0000001
-    return (points_out[..., :3] / denom).squeeze(dim=0)
-
-
-def getWorld2View(R, t):
-    Rt = np.zeros((4, 4))
-    Rt[:3, :3] = R.transpose()
-    Rt[:3, 3] = t
-    Rt[3, 3] = 1.0
-    return np.float32(Rt)
-
-
-def getWorld2View2(R, t, translate=np.array([.0, .0, .0]), scale=1.0):
-    Rt = np.zeros((4, 4))
-    Rt[:3, :3] = R.transpose()
-    Rt[:3, 3] = t
-    Rt[3, 3] = 1.0
-
-    C2W = np.linalg.inv(Rt)
-    cam_center = C2W[:3, 3]
-    cam_center = (cam_center + translate) * scale
-    C2W[:3, 3] = cam_center
-    Rt = np.linalg.inv(C2W)
-    return np.float32(Rt)
-
-
-def getProjectionMatrix(znear, zfar, fovX, fovY):
-    tanHalfFovY = math.tan((fovY / 2))
-    tanHalfFovX = math.tan((fovX / 2))
-
-    top = tanHalfFovY * znear
-    bottom = -top
-    right = tanHalfFovX * znear
-    left = -right
-
-    P = torch.zeros(4, 4)
-
-    z_sign = 1.0
-
-    P[0, 0] = 2.0 * znear / (right - left)
-    P[1, 1] = 2.0 * znear / (top - bottom)
-    P[0, 2] = (right + left) / (right - left)
-    P[1, 2] = (top + bottom) / (top - bottom)
-    P[3, 2] = z_sign
-    P[2, 2] = z_sign * zfar / (zfar - znear)
-    P[2, 3] = -(zfar * znear) / (zfar - znear)
-    return P
-
-
-def fov2focal(fov, pixels):
-    return pixels / (2 * math.tan(fov / 2))
-
-
-def focal2fov(focal, pixels):
-    return 2*math.atan(pixels/(2*focal))

utils/.ipynb_checkpoints/image-checkpoint.py

@@ -1,20 +0,0 @@
-#
-# 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
-
-
-def mse(img1, img2):
-    return (((img1 - img2)) ** 2).view(img1.shape[0], -1).mean(1, keepdim=True)
-
-
-def psnr(img1, img2):
-    mse = (((img1 - img2)) ** 2).view(img1.shape[0], -1).mean(1, keepdim=True)
-    return 20 * torch.log10(1.0 / torch.sqrt(mse))

utils/.ipynb_checkpoints/loss-checkpoint.py

@@ -1,99 +0,0 @@
-#
-# 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 math import exp
-
-import torch
-import torch.nn.functional as F
-from torch.autograd import Variable
-
-
-def l1_loss(network_output, gt):
-    return torch.abs((network_output - gt)).mean()
-
-
-def l2_loss(network_output, gt):
-    return ((network_output - gt) ** 2).mean()
-
-
-def gaussian(window_size, sigma):
-    gauss = torch.Tensor([exp(-(x - window_size // 2) ** 2 / float(2 * sigma ** 2)) for x in range(window_size)])
-    return gauss / gauss.sum()
-
-
-def create_window(window_size, channel):
-    _1D_window = gaussian(window_size, 1.5).unsqueeze(1)
-    _2D_window = _1D_window.mm(_1D_window.t()).float().unsqueeze(0).unsqueeze(0)
-    window = Variable(_2D_window.expand(channel, 1, window_size, window_size).contiguous())
-    return window
-
-
-def ssim(img1, img2, window_size=11, size_average=True):
-    channel = img1.size(-3)
-    window = create_window(window_size, channel)
-
-    if img1.is_cuda:
-        window = window.cuda(img1.get_device())
-    window = window.type_as(img1)
-
-    return _ssim(img1, img2, window, window_size, channel, size_average)
-
-
-def _ssim(img1, img2, window, window_size, channel, size_average=True):
-    mu1 = F.conv2d(img1, window, padding=window_size // 2, groups=channel)
-    mu2 = F.conv2d(img2, window, padding=window_size // 2, groups=channel)
-
-    mu1_sq = mu1.pow(2)
-    mu2_sq = mu2.pow(2)
-    mu1_mu2 = mu1 * mu2
-
-    sigma1_sq = F.conv2d(img1 * img1, window, padding=window_size // 2, groups=channel) - mu1_sq
-    sigma2_sq = F.conv2d(img2 * img2, window, padding=window_size // 2, groups=channel) - mu2_sq
-    sigma12 = F.conv2d(img1 * img2, window, padding=window_size // 2, groups=channel) - mu1_mu2
-
-    C1 = 0.01 ** 2
-    C2 = 0.03 ** 2
-
-    ssim_map = ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) * (sigma1_sq + sigma2_sq + C2))
-
-    if size_average:
-        return ssim_map.mean()
-    else:
-        return ssim_map.mean(1).mean(1).mean(1)
-
-
-import numpy as np
-import cv2
-def image2canny(image, thres1, thres2, isEdge1=True):
-    """ image: (H, W, 3)"""
-    canny_mask = torch.from_numpy(cv2.Canny((image.detach().cpu().numpy()*255.).astype(np.uint8), thres1, thres2)/255.)
-    if not isEdge1:
-        canny_mask = 1. - canny_mask
-    return canny_mask.float()
-
-with torch.no_grad():
-    kernelsize=3
-    conv = torch.nn.Conv2d(1, 1, kernel_size=kernelsize, padding=(kernelsize//2))
-    kernel = torch.tensor([[0.,1.,0.],[1.,0.,1.],[0.,1.,0.]]).reshape(1,1,kernelsize,kernelsize)
-    conv.weight.data = kernel #torch.ones((1,1,kernelsize,kernelsize))
-    conv.bias.data = torch.tensor([0.])
-    conv.requires_grad_(False)
-    conv = conv.cuda()
-
-
-def nearMean_map(array, mask, kernelsize=3):
-    """ array: (H,W) / mask: (H,W) """
-    cnt_map = torch.ones_like(array)
-
-    nearMean_map = conv((array * mask)[None,None])
-    cnt_map = conv((cnt_map * mask)[None,None])
-    nearMean_map = (nearMean_map / (cnt_map+1e-8)).squeeze()
-        
-    return nearMean_map

utils/.ipynb_checkpoints/sh-checkpoint.py

@@ -1,120 +0,0 @@
-#  Copyright 2021 The PlenOctree Authors.
-#  Redistribution and use in source and binary forms, with or without
-#  modification, are permitted provided that the following conditions are met:
-#
-#  1. Redistributions of source code must retain the above copyright notice,
-#  this list of conditions and the following disclaimer.
-#
-#  2. Redistributions in binary form must reproduce the above copyright notice,
-#  this list of conditions and the following disclaimer in the documentation
-#  and/or other materials provided with the distribution.
-#
-#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-#  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-#  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-#  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS 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 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-#  POSSIBILITY OF SUCH DAMAGE.
-import torch
-
-
-C0 = 0.28209479177387814
-C1 = 0.4886025119029199
-C2 = [
-    1.0925484305920792,
-    -1.0925484305920792,
-    0.31539156525252005,
-    -1.0925484305920792,
-    0.5462742152960396
-]
-C3 = [
-    -0.5900435899266435,
-    2.890611442640554,
-    -0.4570457994644658,
-    0.3731763325901154,
-    -0.4570457994644658,
-    1.445305721320277,
-    -0.5900435899266435
-]
-C4 = [
-    2.5033429417967046,
-    -1.7701307697799304,
-    0.9461746957575601,
-    -0.6690465435572892,
-    0.10578554691520431,
-    -0.6690465435572892,
-    0.47308734787878004,
-    -1.7701307697799304,
-    0.6258357354491761,
-]   
-
-
-def eval_sh(deg, sh, dirs):
-    """
-    Evaluate spherical harmonics at unit directions
-    using hardcoded SH polynomials.
-    Works with torch/np/jnp.
-    ... Can be 0 or more batch dimensions.
-    Args:
-        deg: int SH deg. Currently, 0-3 supported
-        sh: jnp.ndarray SH coeffs [..., C, (deg + 1) ** 2]
-        dirs: jnp.ndarray unit directions [..., 3]
-    Returns:
-        [..., C]
-    """
-    assert deg <= 4 and deg >= 0
-    coeff = (deg + 1) ** 2
-    assert sh.shape[-1] >= coeff
-
-    result = C0 * sh[..., 0]
-    if deg > 0:
-        x, y, z = dirs[..., 0:1], dirs[..., 1:2], dirs[..., 2:3]
-        result = (result -
-                C1 * y * sh[..., 1] +
-                C1 * z * sh[..., 2] -
-                C1 * x * sh[..., 3])
-
-        if deg > 1:
-            xx, yy, zz = x * x, y * y, z * z
-            xy, yz, xz = x * y, y * z, x * z
-            result = (result +
-                    C2[0] * xy * sh[..., 4] +
-                    C2[1] * yz * sh[..., 5] +
-                    C2[2] * (2.0 * zz - xx - yy) * sh[..., 6] +
-                    C2[3] * xz * sh[..., 7] +
-                    C2[4] * (xx - yy) * sh[..., 8])
-
-            if deg > 2:
-                result = (result +
-                C3[0] * y * (3 * xx - yy) * sh[..., 9] +
-                C3[1] * xy * z * sh[..., 10] +
-                C3[2] * y * (4 * zz - xx - yy)* sh[..., 11] +
-                C3[3] * z * (2 * zz - 3 * xx - 3 * yy) * sh[..., 12] +
-                C3[4] * x * (4 * zz - xx - yy) * sh[..., 13] +
-                C3[5] * z * (xx - yy) * sh[..., 14] +
-                C3[6] * x * (xx - 3 * yy) * sh[..., 15])
-
-                if deg > 3:
-                    result = (result + C4[0] * xy * (xx - yy) * sh[..., 16] +
-                            C4[1] * yz * (3 * xx - yy) * sh[..., 17] +
-                            C4[2] * xy * (7 * zz - 1) * sh[..., 18] +
-                            C4[3] * yz * (7 * zz - 3) * sh[..., 19] +
-                            C4[4] * (zz * (35 * zz - 30) + 3) * sh[..., 20] +
-                            C4[5] * xz * (7 * zz - 3) * sh[..., 21] +
-                            C4[6] * (xx - yy) * (7 * zz - 1) * sh[..., 22] +
-                            C4[7] * xz * (xx - 3 * yy) * sh[..., 23] +
-                            C4[8] * (xx * (xx - 3 * yy) - yy * (3 * xx - yy)) * sh[..., 24])
-    return result
-
-
-def RGB2SH(rgb):
-    return (rgb - 0.5) / C0
-
-
-def SH2RGB(sh):
-    return sh * C0 + 0.5

utils/.ipynb_checkpoints/system-checkpoint.py

@@ -1,29 +0,0 @@
-#
-# 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 errno import EEXIST
-from os import makedirs, path
-import os
-
-
-def mkdir_p(folder_path):
-    # Creates a directory. equivalent to using mkdir -p on the command line
-    try:
-        makedirs(folder_path)
-    except OSError as exc: # Python >2.5
-        if exc.errno == EEXIST and path.isdir(folder_path):
-            pass
-        else:
-            raise
-
-
-def searchForMaxIteration(folder):
-    saved_iters = [int(fname.split("_")[-1]) for fname in os.listdir(folder)]
-    return max(saved_iters)

utils/.ipynb_checkpoints/trajectory-checkpoint.py

@@ -1,621 +0,0 @@
-# Copyright (C) 2023, Computer Vision Lab, Seoul National University, https://cv.snu.ac.kr
-#
-# Copyright 2023 LucidDreamer Authors
-#
-# Computer Vision Lab, SNU, its affiliates and licensors retain all intellectual
-# property and proprietary rights in and to this material, related
-# documentation and any modifications thereto. Any use, reproduction,
-# disclosure or distribution of this material and related documentation
-# without an express license agreement from the Computer Vision Lab, SNU or
-# its affiliates is strictly prohibited.
-#
-# For permission requests, please contact robot0321@snu.ac.kr, esw0116@snu.ac.kr, namhj28@gmail.com, jarin.lee@gmail.com.
-import os
-import numpy as np
-import torch
-
-
-def generate_seed(scale, viewangle):
-    # World 2 Camera
-    #### rotate x,y
-    render_poses = [np.array([[1,0,0,0],[0,1,0,0],[0,0,1,0]])]
-    ang = 5
-    for i,j in zip([ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,ang,2*ang,3*ang,2*ang,ang,0], [0,0,0,ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,0,0,0]): 
-        th, phi = i/180*np.pi, j/180*np.pi
-        posetemp = np.zeros((3, 4))
-        posetemp[:3,:3] = np.matmul(np.eye(3),
-                                    np.matmul(np.array([[np.cos(th), 0, np.sin(th)], [0, 1, 0], [-np.sin(th), 0, np.cos(th)]]), np.array([[1, 0, 0], [0, np.cos(phi), -np.sin(phi)], [0, np.sin(phi), np.cos(phi)]]))) # Turn left
-        posetemp[:3,3:4] = np.array([0,0,0]).reshape(3,1) # * scale # Transition vector   
-        render_poses.append(posetemp)
-    
-    for i,j in zip([-ang,-2*ang,-3*ang,-2*ang,-ang,0,ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0], [0,0,0,ang,ang,ang,ang,ang,0,-ang,-ang,-ang,-ang,-ang,0,0,0,0]): 
-        th, phi = i/180*np.pi, j/180*np.pi
-        posetemp = np.zeros((3, 4))
-        posetemp[:3,:3] = np.matmul(np.array([[np.cos(-3*ang/180*np.pi), 0, np.sin(-3*ang/180*np.pi)], [0, 1, 0], [-np.sin(-3*ang/180*np.pi), 0, np.cos(-3*ang/180*np.pi)]]),
-                                    np.matmul(np.array([[np.cos(th), 0, np.sin(th)], [0, 1, 0], [-np.sin(th), 0, np.cos(th)]]), np.array([[1, 0, 0], [0, np.cos(phi), -np.sin(phi)], [0, np.sin(phi), np.cos(phi)]])))
-        posetemp[:3,3:4] = np.array([1,0,0]).reshape(3,1) # * scale # Transition vector   
-        render_poses.append(posetemp)
-    
-    for i,j in zip([ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,ang,2*ang,3*ang,2*ang,ang,0], [0,0,0,ang,ang,ang,ang,ang,0,-ang,-ang,-ang,-ang,-ang,0,0,0,0]): 
-        th, phi = i/180*np.pi, j/180*np.pi
-        posetemp = np.zeros((3, 4))
-        posetemp[:3,:3] = np.matmul(np.array([[np.cos(3*ang/180*np.pi), 0, np.sin(3*ang/180*np.pi)], [0, 1, 0], [-np.sin(3*ang/180*np.pi), 0, np.cos(3*ang/180*np.pi)]]), 
-                                    np.matmul(np.array([[np.cos(th), 0, np.sin(th)], [0, 1, 0], [-np.sin(th), 0, np.cos(th)]]), np.array([[1, 0, 0], [0, np.cos(phi), -np.sin(phi)], [0, np.sin(phi), np.cos(phi)]])))
-        posetemp[:3,3:4] = np.array([-1,0,0]).reshape(3,1) # * scale # Transition vector   
-        render_poses.append(posetemp)
-    
-    # for i,j in zip([ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,ang,2*ang,3*ang,2*ang,ang,0], [0,0,0,ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,0,0,0]): 
-    #     th, phi = i/180*np.pi, j/180*np.pi
-    #     posetemp = np.zeros((3, 4))
-    #     posetemp[:3,:3] = np.matmul(np.eye(3), 
-    #                                 np.matmul(np.array([[np.cos(th), 0, np.sin(th)], [0, 1, 0], [-np.sin(th), 0, np.cos(th)]]), np.array([[1, 0, 0], [0, np.cos(phi), -np.sin(phi)], [0, np.sin(phi), np.cos(phi)]])))
-    #     posetemp[:3,3:4] = np.array([0,0,1]).reshape(3,1) # * scale # Transition vector   
-    #     render_poses.append(posetemp)
-
-
-    rot_cam=viewangle/3
-    for i,j in zip([ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,ang,2*ang,3*ang,2*ang,ang,0], [0,0,0,ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,0,0,0]): 
-        th, phi = i/180*np.pi, j/180*np.pi
-        posetemp = np.zeros((3, 4))
-        posetemp[:3,:3] = np.matmul(np.array([[np.cos(rot_cam/180*np.pi), 0, np.sin(rot_cam/180*np.pi)], [0, 1, 0], [-np.sin(rot_cam/180*np.pi), 0, np.cos(rot_cam/180*np.pi)]]),
-                                    np.matmul(np.array([[np.cos(th), 0, np.sin(th)], [0, 1, 0], [-np.sin(th), 0, np.cos(th)]]), np.array([[1, 0, 0], [0, np.cos(phi), -np.sin(phi)], [0, np.sin(phi), np.cos(phi)]]))) # Turn left
-        posetemp[:3,3:4] = np.array([0,0,0]).reshape(3,1) # * scale # Transition vector   
-        render_poses.append(posetemp)
-
-    for i,j in zip([-ang,-2*ang,-3*ang,-2*ang,-ang,0,ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0], [0,0,0,ang,ang,ang,ang,ang,0,-ang,-ang,-ang,-ang,-ang,0,0,0,0]): 
-        th, phi = i/180*np.pi, j/180*np.pi
-        posetemp = np.zeros((3, 4))
-        posetemp[:3,:3] = np.matmul(np.array([[np.cos(rot_cam/180*np.pi), 0, np.sin(rot_cam/180*np.pi)], [0, 1, 0], [-np.sin(rot_cam/180*np.pi), 0, np.cos(rot_cam/180*np.pi)]]),
-                                    np.matmul(np.array([[np.cos(-3*ang/180*np.pi), 0, np.sin(-3*ang/180*np.pi)], [0, 1, 0], [-np.sin(-3*ang/180*np.pi), 0, np.cos(-3*ang/180*np.pi)]]),
-                                    np.matmul(np.array([[np.cos(th), 0, np.sin(th)], [0, 1, 0], [-np.sin(th), 0, np.cos(th)]]), np.array([[1, 0, 0], [0, np.cos(phi), -np.sin(phi)], [0, np.sin(phi), np.cos(phi)]]))))
-        posetemp[:3,3:4] = np.array([0,0,1]).reshape(3,1) # * scale # Transition vector   
-        render_poses.append(posetemp)
-    
-    for i,j in zip([ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,ang,2*ang,3*ang,2*ang,ang,0], [0,0,0,ang,ang,ang,ang,ang,0,-ang,-ang,-ang,-ang,-ang,0,0,0,0]): 
-        th, phi = i/180*np.pi, j/180*np.pi
-        posetemp = np.zeros((3, 4))
-        posetemp[:3,:3] = np.matmul(np.array([[np.cos(rot_cam/180*np.pi), 0, np.sin(rot_cam/180*np.pi)], [0, 1, 0], [-np.sin(rot_cam/180*np.pi), 0, np.cos(rot_cam/180*np.pi)]]),
-                                    np.matmul(np.array([[np.cos(3*ang/180*np.pi), 0, np.sin(3*ang/180*np.pi)], [0, 1, 0], [-np.sin(3*ang/180*np.pi), 0, np.cos(3*ang/180*np.pi)]]), 
-                                    np.matmul(np.array([[np.cos(th), 0, np.sin(th)], [0, 1, 0], [-np.sin(th), 0, np.cos(th)]]), np.array([[1, 0, 0], [0, np.cos(phi), -np.sin(phi)], [0, np.sin(phi), np.cos(phi)]]))))
-        posetemp[:3,3:4] = np.array([0,0,-1]).reshape(3,1) # * scale # Transition vector   
-        render_poses.append(posetemp)
-    
-    # for i,j in zip([ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,ang,2*ang,3*ang,2*ang,ang,0], [0,0,0,ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,0,0,0]): 
-    #     th, phi = i/180*np.pi, j/180*np.pi
-    #     posetemp = np.zeros((3, 4))
-    #     posetemp[:3,:3] = np.matmul(np.array([[np.cos(rot_cam/180*np.pi), 0, np.sin(rot_cam/180*np.pi)], [0, 1, 0], [-np.sin(rot_cam/180*np.pi), 0, np.cos(rot_cam/180*np.pi)]]),
-    #                                 np.matmul(np.array([[np.cos(th), 0, np.sin(th)], [0, 1, 0], [-np.sin(th), 0, np.cos(th)]]), np.array([[1, 0, 0], [0, np.cos(phi), -np.sin(phi)], [0, np.sin(phi), np.cos(phi)]])))
-    #     posetemp[:3,3:4] = np.array([1,0,0]).reshape(3,1) # * scale # Transition vector   
-    #     render_poses.append(posetemp)
-
-
-    rot_cam=viewangle*2/3
-    for i,j in zip([ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,ang,2*ang,3*ang,2*ang,ang,0], [0,0,0,ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,0,0,0]): 
-        th, phi = i/180*np.pi, j/180*np.pi
-        posetemp = np.zeros((3, 4))
-        posetemp[:3,:3] = np.matmul(np.array([[np.cos(rot_cam/180*np.pi), 0, np.sin(rot_cam/180*np.pi)], [0, 1, 0], [-np.sin(rot_cam/180*np.pi), 0, np.cos(rot_cam/180*np.pi)]]),
-                                    np.matmul(np.array([[np.cos(th), 0, np.sin(th)], [0, 1, 0], [-np.sin(th), 0, np.cos(th)]]), np.array([[1, 0, 0], [0, np.cos(phi), -np.sin(phi)], [0, np.sin(phi), np.cos(phi)]]))) # Turn left
-        posetemp[:3,3:4] = np.array([0,0,0]).reshape(3,1) # * scale # Transition vector   
-        render_poses.append(posetemp)
-
-    for i,j in zip([-ang,-2*ang,-3*ang,-2*ang,-ang,0,ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0], [0,0,0,ang,ang,ang,ang,ang,0,-ang,-ang,-ang,-ang,-ang,0,0,0,0]): 
-        th, phi = i/180*np.pi, j/180*np.pi
-        posetemp = np.zeros((3, 4))
-        posetemp[:3,:3] = np.matmul(np.array([[np.cos(rot_cam/180*np.pi), 0, np.sin(rot_cam/180*np.pi)], [0, 1, 0], [-np.sin(rot_cam/180*np.pi), 0, np.cos(rot_cam/180*np.pi)]]),
-                                    np.matmul(np.array([[np.cos(-3*ang/180*np.pi), 0, np.sin(-3*ang/180*np.pi)], [0, 1, 0], [-np.sin(-3*ang/180*np.pi), 0, np.cos(-3*ang/180*np.pi)]]),
-                                    np.matmul(np.array([[np.cos(th), 0, np.sin(th)], [0, 1, 0], [-np.sin(th), 0, np.cos(th)]]), np.array([[1, 0, 0], [0, np.cos(phi), -np.sin(phi)], [0, np.sin(phi), np.cos(phi)]]))))
-        posetemp[:3,3:4] = np.array([-1,0,0]).reshape(3,1) # * scale # Transition vector   
-        render_poses.append(posetemp)
-    
-    for i,j in zip([ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,ang,2*ang,3*ang,2*ang,ang,0], [0,0,0,ang,ang,ang,ang,ang,0,-ang,-ang,-ang,-ang,-ang,0,0,0,0]): 
-        th, phi = i/180*np.pi, j/180*np.pi
-        posetemp = np.zeros((3, 4))
-        posetemp[:3,:3] = np.matmul(np.array([[np.cos(rot_cam/180*np.pi), 0, np.sin(rot_cam/180*np.pi)], [0, 1, 0], [-np.sin(rot_cam/180*np.pi), 0, np.cos(rot_cam/180*np.pi)]]),
-                                    np.matmul(np.array([[np.cos(3*ang/180*np.pi), 0, np.sin(3*ang/180*np.pi)], [0, 1, 0], [-np.sin(3*ang/180*np.pi), 0, np.cos(3*ang/180*np.pi)]]), 
-                                    np.matmul(np.array([[np.cos(th), 0, np.sin(th)], [0, 1, 0], [-np.sin(th), 0, np.cos(th)]]), np.array([[1, 0, 0], [0, np.cos(phi), -np.sin(phi)], [0, np.sin(phi), np.cos(phi)]]))))
-        posetemp[:3,3:4] = np.array([1,0,0]).reshape(3,1) # * scale # Transition vector   
-        render_poses.append(posetemp)
-    
-    # for i,j in zip([ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,ang,2*ang,3*ang,2*ang,ang,0], [0,0,0,ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,0,0,0]): 
-    #     th, phi = i/180*np.pi, j/180*np.pi
-    #     posetemp = np.zeros((3, 4))
-    #     posetemp[:3,:3] = np.matmul(np.array([[np.cos(rot_cam/180*np.pi), 0, np.sin(rot_cam/180*np.pi)], [0, 1, 0], [-np.sin(rot_cam/180*np.pi), 0, np.cos(rot_cam/180*np.pi)]]),
-    #                                 np.matmul(np.array([[np.cos(th), 0, np.sin(th)], [0, 1, 0], [-np.sin(th), 0, np.cos(th)]]), np.array([[1, 0, 0], [0, np.cos(phi), -np.sin(phi)], [0, np.sin(phi), np.cos(phi)]])))
-    #     posetemp[:3,3:4] = np.array([0,0,-1]).reshape(3,1) # * scale # Transition vector   
-    #     render_poses.append(posetemp)
-
-    rot_cam=viewangle
-    for i,j in zip([ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,ang,2*ang,3*ang,2*ang,ang,0], [0,0,0,ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,0,0,0]): 
-        th, phi = i/180*np.pi, j/180*np.pi
-        posetemp = np.zeros((3, 4))
-        posetemp[:3,:3] = np.matmul(np.array([[np.cos(rot_cam/180*np.pi), 0, np.sin(rot_cam/180*np.pi)], [0, 1, 0], [-np.sin(rot_cam/180*np.pi), 0, np.cos(rot_cam/180*np.pi)]]),
-                                    np.matmul(np.array([[np.cos(th), 0, np.sin(th)], [0, 1, 0], [-np.sin(th), 0, np.cos(th)]]), np.array([[1, 0, 0], [0, np.cos(phi), -np.sin(phi)], [0, np.sin(phi), np.cos(phi)]]))) # Turn left
-        posetemp[:3,3:4] = np.array([0,0,0]).reshape(3,1) # * scale # Transition vector   
-        render_poses.append(posetemp)
-
-    for i,j in zip([-ang,-2*ang,-3*ang,-2*ang,-ang,0,ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0], [0,0,0,ang,ang,ang,ang,ang,0,-ang,-ang,-ang,-ang,-ang,0,0,0,0]): 
-        th, phi = i/180*np.pi, j/180*np.pi
-        posetemp = np.zeros((3, 4))
-        posetemp[:3,:3] = np.matmul(np.array([[np.cos(rot_cam/180*np.pi), 0, np.sin(rot_cam/180*np.pi)], [0, 1, 0], [-np.sin(rot_cam/180*np.pi), 0, np.cos(rot_cam/180*np.pi)]]),
-                                    np.matmul(np.array([[np.cos(-3*ang/180*np.pi), 0, np.sin(-3*ang/180*np.pi)], [0, 1, 0], [-np.sin(-3*ang/180*np.pi), 0, np.cos(-3*ang/180*np.pi)]]),
-                                    np.matmul(np.array([[np.cos(th), 0, np.sin(th)], [0, 1, 0], [-np.sin(th), 0, np.cos(th)]]), np.array([[1, 0, 0], [0, np.cos(phi), -np.sin(phi)], [0, np.sin(phi), np.cos(phi)]]))))
-        posetemp[:3,3:4] = np.array([0,0,-1]).reshape(3,1) # * scale # Transition vector   
-        render_poses.append(posetemp)
-    
-    for i,j in zip([ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,ang,2*ang,3*ang,2*ang,ang,0], [0,0,0,ang,ang,ang,ang,ang,0,-ang,-ang,-ang,-ang,-ang,0,0,0,0]): 
-        th, phi = i/180*np.pi, j/180*np.pi
-        posetemp = np.zeros((3, 4))
-        posetemp[:3,:3] = np.matmul(np.array([[np.cos(rot_cam/180*np.pi), 0, np.sin(rot_cam/180*np.pi)], [0, 1, 0], [-np.sin(rot_cam/180*np.pi), 0, np.cos(rot_cam/180*np.pi)]]),
-                                    np.matmul(np.array([[np.cos(3*ang/180*np.pi), 0, np.sin(3*ang/180*np.pi)], [0, 1, 0], [-np.sin(3*ang/180*np.pi), 0, np.cos(3*ang/180*np.pi)]]), 
-                                    np.matmul(np.array([[np.cos(th), 0, np.sin(th)], [0, 1, 0], [-np.sin(th), 0, np.cos(th)]]), np.array([[1, 0, 0], [0, np.cos(phi), -np.sin(phi)], [0, np.sin(phi), np.cos(phi)]]))))
-        posetemp[:3,3:4] = np.array([0,0,1]).reshape(3,1) # * scale # Transition vector   
-        render_poses.append(posetemp)
-    
-    # for i,j in zip([ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,ang,2*ang,3*ang,2*ang,ang,0], [0,0,0,ang,2*ang,3*ang,2*ang,ang,0,-ang,-2*ang,-3*ang,-2*ang,-ang,0,0,0,0]): 
-    #     th, phi = i/180*np.pi, j/180*np.pi
-    #     posetemp = np.zeros((3, 4))
-    #     posetemp[:3,:3] = np.matmul(np.array([[np.cos(rot_cam/180*np.pi), 0, np.sin(rot_cam/180*np.pi)], [0, 1, 0], [-np.sin(rot_cam/180*np.pi), 0, np.cos(rot_cam/180*np.pi)]]),
-    #                                 np.matmul(np.array([[np.cos(th), 0, np.sin(th)], [0, 1, 0], [-np.sin(th), 0, np.cos(th)]]), np.array([[1, 0, 0], [0, np.cos(phi), -np.sin(phi)], [0, np.sin(phi), np.cos(phi)]])))
-    #     posetemp[:3,3:4] = np.array([-1,0,0]).reshape(3,1) # * scale # Transition vector   
-    #     render_poses.append(posetemp)
-
-    render_poses.append(np.array([[1,0,0,0],[0,1,0,0],[0,0,1,0]]))
-    render_poses = np.stack(render_poses, axis=0)
-
-    return render_poses
-
-
-def generate_seed_360(viewangle, n_views):
-    N = n_views
-    render_poses = np.zeros((N, 3, 4))
-    for i in range(N):
-        th = (viewangle/N)*i/180*np.pi
-        render_poses[i,:3,:3] = np.array([[np.cos(th), 0, np.sin(th)], [0, 1, 0], [-np.sin(th), 0, np.cos(th)]])
-        render_poses[i,:3,3:4] = np.random.randn(3,1)*0.0 # Transition vector
-
-    return render_poses
-
-
-def generate_seed_360_half(viewangle, n_views):
-    N = n_views // 2
-    halfangle = viewangle / 2
-    render_poses = np.zeros((N*2, 3, 4))
-    for i in range(N): 
-        th = (halfangle/N)*i/180*np.pi
-        render_poses[i,:3,:3] = np.array([[np.cos(th), 0, np.sin(th)], [0, 1, 0], [-np.sin(th), 0, np.cos(th)]])
-        render_poses[i,:3,3:4] = np.random.randn(3,1)*0.0 # Transition vector
-    for i in range(N):
-        th = -(halfangle/N)*i/180*np.pi
-        render_poses[i+N,:3,:3] = np.array([[np.cos(th), 0, np.sin(th)], [0, 1, 0], [-np.sin(th), 0, np.cos(th)]])
-        render_poses[i+N,:3,3:4] = np.random.randn(3,1)*0.0 # Transition vector
-    return render_poses
-
-
-def generate_seed_preset():
-    degsum = 60 
-    thlist = np.concatenate((np.linspace(0, degsum, 4), np.linspace(0, -degsum, 4)[1:], np.linspace(0, degsum, 4), np.linspace(0, -degsum, 4)[1:], np.linspace(0, degsum, 4), np.linspace(0, -degsum, 4)[1:]))
-    philist = np.concatenate((np.linspace(0,0,7), np.linspace(-22.5,-22.5,7), np.linspace(22.5,22.5,7)))
-    assert len(thlist) == len(philist)
-
-    render_poses = np.zeros((len(thlist), 3, 4))
-    for i in range(len(thlist)):
-        th = thlist[i]
-        phi = philist[i]
-        
-        render_poses[i,:3,:3] = np.matmul(np.array([[np.cos(th/180*np.pi), 0, -np.sin(th/180*np.pi)], [0, 1, 0], [np.sin(th/180*np.pi), 0, np.cos(th/180*np.pi)]]), np.array([[1, 0, 0], [0, np.cos(phi/180*np.pi), -np.sin(phi/180*np.pi)], [0, np.sin(phi/180*np.pi), np.cos(phi/180*np.pi)]]))
-        render_poses[i,:3,3:4] = np.zeros((3,1))
-
-    return render_poses
-
-
-def generate_seed_newpreset():
-    degsum = 60 
-    thlist = np.concatenate((np.linspace(0, degsum, 4), np.linspace(0, -degsum, 4)[1:], np.linspace(0, degsum, 4), np.linspace(0, -degsum, 4)[1:]))
-    philist = np.concatenate((np.linspace(0,0,7), np.linspace(22.5,22.5,7)))
-    assert len(thlist) == len(philist)
-
-    render_poses = np.zeros((len(thlist), 3, 4))
-    for i in range(len(thlist)):
-        th = thlist[i]
-        phi = philist[i]
-        
-        render_poses[i,:3,:3] = np.matmul(np.array([[np.cos(th/180*np.pi), 0, -np.sin(th/180*np.pi)], [0, 1, 0], [np.sin(th/180*np.pi), 0, np.cos(th/180*np.pi)]]), np.array([[1, 0, 0], [0, np.cos(phi/180*np.pi), -np.sin(phi/180*np.pi)], [0, np.sin(phi/180*np.pi), np.cos(phi/180*np.pi)]]))
-        render_poses[i,:3,3:4] = np.zeros((3,1))
-
-    return render_poses
-
-
-def generate_seed_horizon():
-    movement = np.linspace(0, 5, 11)
-    render_poses = np.zeros((len(movement), 3, 4))
-    for i in range(len(movement)):
-        
-        render_poses[i,:3,:3] = np.eye(3)
-        render_poses[i,:3,3:4] = np.array([[-movement[i]], [0], [0]])
-
-    return render_poses
-
-
-def generate_seed_backward():
-    movement = np.linspace(0, 5, 11)
-    render_poses = np.zeros((len(movement), 3, 4))
-    for i in range(len(movement)):
-        render_poses[i,:3,:3] = np.eye(3)
-        render_poses[i,:3,3:4] = np.array([[0], [0], [movement[i]]])
-    return render_poses
-
-
-def generate_seed_arc():
-    degree = 5
-    # thlist = np.array([degree, 0, 0, 0, -degree])
-    thlist = np.arange(0, degree, 5) + np.arange(0, -degree, 5)[1:]
-    phi = 0
-
-    render_poses = np.zeros((len(thlist), 3, 4))
-    for i in range(len(thlist)):
-        th = thlist[i]
-        d = 4.3 # 얘를 조절하면 초기 자세 기준으로 앞으로 d만큼 떨어진 점을 기준으로 도는 자세가 만들어짐
-        
-        render_poses[i,:3,:3] = np.matmul(np.array([[np.cos(th/180*np.pi), 0, -np.sin(th/180*np.pi)], [0, 1, 0], [np.sin(th/180*np.pi), 0, np.cos(th/180*np.pi)]]), np.array([[1, 0, 0], [0, np.cos(phi/180*np.pi), -np.sin(phi/180*np.pi)], [0, np.sin(phi/180*np.pi), np.cos(phi/180*np.pi)]]))
-        render_poses[0,:3,3:4] = np.array([d*np.sin(th/180*np.pi), 0, d-d*np.cos(th/180*np.pi)]).reshape(3,1) + np.array([0, d*np.sin(phi/180*np.pi), d-d*np.cos(phi/180*np.pi)]).reshape(3,1)# Transition vector
-        # render_poses[i,:3,3:4] = np.zeros((3,1))
-
-    return render_poses
-
-
-def generate_seed_hemisphere(center_depth, degree=5):
-    degree = 5
-    thlist = np.array([degree, 0, 0, 0, -degree])
-    philist = np.array([0, -degree, 0, degree, 0])
-    assert len(thlist) == len(philist)
-
-    render_poses = np.zeros((len(thlist), 3, 4))
-    for i in range(len(thlist)):
-        th = thlist[i]
-        phi = philist[i]
-        # curr_pose = np.zeros((1, 3, 4))
-        d = center_depth # 얘를 조절하면 초기 자세 기준으로 앞으로 d만큼 떨어진 점을 기준으로 도는 자세가 만들어짐
-        
-        render_poses[i,:3,:3] = np.matmul(np.array([[np.cos(th/180*np.pi), 0, -np.sin(th/180*np.pi)], [0, 1, 0], [np.sin(th/180*np.pi), 0, np.cos(th/180*np.pi)]]), np.array([[1, 0, 0], [0, np.cos(phi/180*np.pi), -np.sin(phi/180*np.pi)], [0, np.sin(phi/180*np.pi), np.cos(phi/180*np.pi)]]))
-        render_poses[0,:3,3:4] = np.array([d*np.sin(th/180*np.pi), 0, d-d*np.cos(th/180*np.pi)]).reshape(3,1) + np.array([0, d*np.sin(phi/180*np.pi), d-d*np.cos(phi/180*np.pi)]).reshape(3,1)# Transition vector
-        # render_poses[i,:3,3:4] = np.zeros((3,1))
-
-    return render_poses
-
-
-def generate_seed_hemisphere_(degree, nviews):
-    # thlist = np.array([degree, 0, 0, 0, -degree])
-    # philist = np.array([0, -degree, 0, degree, 0])
-    thlist = degree * np.sin(np.linspace(0, 2*np.pi, nviews))
-    philist = degree * np.cos(np.linspace(0, 2*np.pi, nviews))
-    assert len(thlist) == len(philist)
-
-    render_poses = np.zeros((len(thlist), 3, 4))
-    for i in range(len(thlist)):
-        th = thlist[i]
-        phi = philist[i]
-        # curr_pose = np.zeros((1, 3, 4))
-        d = 4.3 # 얘를 조절하면 초기 자세 기준으로 앞으로 d만큼 떨어진 점을 기준으로 도는 자세가 만들어짐
-        
-        render_poses[i,:3,:3] = np.matmul(np.array([[np.cos(th/180*np.pi), 0, -np.sin(th/180*np.pi)], [0, 1, 0], [np.sin(th/180*np.pi), 0, np.cos(th/180*np.pi)]]), np.array([[1, 0, 0], [0, np.cos(phi/180*np.pi), -np.sin(phi/180*np.pi)], [0, np.sin(phi/180*np.pi), np.cos(phi/180*np.pi)]]))
-        render_poses[0,:3,3:4] = np.array([d*np.sin(th/180*np.pi), 0, d-d*np.cos(th/180*np.pi)]).reshape(3,1) + np.array([0, d*np.sin(phi/180*np.pi), d-d*np.cos(phi/180*np.pi)]).reshape(3,1)# Transition vector
-    return render_poses
-
-
-def generate_seed_nothing():
-    degree = 5
-    thlist = np.array([0])
-    philist = np.array([0])
-    assert len(thlist) == len(philist)
-
-    render_poses = np.zeros((len(thlist), 3, 4))
-    for i in range(len(thlist)):
-        th = thlist[i]
-        phi = philist[i]
-        # curr_pose = np.zeros((1, 3, 4))
-        d = 4.3 # 얘를 조절하면 초기 자세 기준으로 앞으로 d만큼 떨어진 점을 기준으로 도는 자세가 만들어짐
-        
-        render_poses[i,:3,:3] = np.matmul(np.array([[np.cos(th/180*np.pi), 0, -np.sin(th/180*np.pi)], [0, 1, 0], [np.sin(th/180*np.pi), 0, np.cos(th/180*np.pi)]]), np.array([[1, 0, 0], [0, np.cos(phi/180*np.pi), -np.sin(phi/180*np.pi)], [0, np.sin(phi/180*np.pi), np.cos(phi/180*np.pi)]]))
-        render_poses[0,:3,3:4] = np.array([d*np.sin(th/180*np.pi), 0, d-d*np.cos(th/180*np.pi)]).reshape(3,1) + np.array([0, d*np.sin(phi/180*np.pi), d-d*np.cos(phi/180*np.pi)]).reshape(3,1)# Transition vector
-        # render_poses[i,:3,3:4] = np.zeros((3,1))
-
-    return render_poses
-
-
-def generate_seed_lookaround():
-    degsum = 60 
-    thlist = np.concatenate((np.linspace(0, degsum, 4), np.linspace(0, -degsum, 4)[1:], np.linspace(0, degsum, 4), np.linspace(0, -degsum, 4)[1:], np.linspace(0, degsum, 4), np.linspace(0, -degsum, 4)[1:]))
-    philist = np.concatenate((np.linspace(0,0,7), np.linspace(22.5,22.5,7), np.linspace(-22.5,-22.5,7)))
-    assert len(thlist) == len(philist)
-
-    render_poses = []
-    # up / left --> right
-    thlist = np.linspace(-degsum, degsum, 2*degsum+1)
-    for i in range(len(thlist)):
-        render_pose = np.zeros((3,4))
-        th = thlist[i]
-        phi = 22.5
-        
-        render_pose[:3,:3] = np.matmul(np.array([[np.cos(th/180*np.pi), 0, -np.sin(th/180*np.pi)], [0, 1, 0], [np.sin(th/180*np.pi), 0, np.cos(th/180*np.pi)]]), np.array([[1, 0, 0], [0, np.cos(phi/180*np.pi), -np.sin(phi/180*np.pi)], [0, np.sin(phi/180*np.pi), np.cos(phi/180*np.pi)]]))
-        render_pose[:3,3:4] = np.zeros((3,1))
-        render_poses.append(render_pose)
-    
-    # right / up --> center
-    phlist = np.linspace(22.5, 0, 23)
-    # Exclude first frame (same as last frame before)
-    phlist = phlist[1:]
-    for i in range(len(phlist)):
-        render_pose = np.zeros((3,4))
-        th = degsum
-        phi = phlist[i]
-        
-        render_pose[:3,:3] = np.matmul(np.array([[np.cos(th/180*np.pi), 0, -np.sin(th/180*np.pi)], [0, 1, 0], [np.sin(th/180*np.pi), 0, np.cos(th/180*np.pi)]]), np.array([[1, 0, 0], [0, np.cos(phi/180*np.pi), -np.sin(phi/180*np.pi)], [0, np.sin(phi/180*np.pi), np.cos(phi/180*np.pi)]]))
-        render_pose[:3,3:4] = np.zeros((3,1))
-        render_poses.append(render_pose)
-
-    # center / right --> left
-    thlist = np.linspace(degsum, -degsum, 2*degsum+1)
-    thlist = thlist[1:]
-    for i in range(len(thlist)):
-        render_pose = np.zeros((3,4))
-        th = thlist[i]
-        phi = 0
-        
-        render_pose[:3,:3] = np.matmul(np.array([[np.cos(th/180*np.pi), 0, -np.sin(th/180*np.pi)], [0, 1, 0], [np.sin(th/180*np.pi), 0, np.cos(th/180*np.pi)]]), np.array([[1, 0, 0], [0, np.cos(phi/180*np.pi), -np.sin(phi/180*np.pi)], [0, np.sin(phi/180*np.pi), np.cos(phi/180*np.pi)]]))
-        render_pose[:3,3:4] = np.zeros((3,1))
-        render_poses.append(render_pose)
-
-    # left / center --> down
-    phlist = np.linspace(0, -22.5, 23)
-    phlist = phlist[1:]
-    for i in range(len(phlist)):
-        render_pose = np.zeros((3,4))
-        th = -degsum
-        phi = phlist[i]
-        
-        render_pose[:3,:3] = np.matmul(np.array([[np.cos(th/180*np.pi), 0, -np.sin(th/180*np.pi)], [0, 1, 0], [np.sin(th/180*np.pi), 0, np.cos(th/180*np.pi)]]), np.array([[1, 0, 0], [0, np.cos(phi/180*np.pi), -np.sin(phi/180*np.pi)], [0, np.sin(phi/180*np.pi), np.cos(phi/180*np.pi)]]))
-        render_pose[:3,3:4] = np.zeros((3,1))
-        render_poses.append(render_pose)
-
-
-    thlist = np.linspace(-degsum, degsum, 2*degsum+1)
-    for i in range(len(thlist)):
-        render_pose = np.zeros((3,4))
-        th = thlist[i]
-        phi = -22.5
-        
-        render_pose[:3,:3] = np.matmul(np.array([[np.cos(th/180*np.pi), 0, -np.sin(th/180*np.pi)], [0, 1, 0], [np.sin(th/180*np.pi), 0, np.cos(th/180*np.pi)]]), np.array([[1, 0, 0], [0, np.cos(phi/180*np.pi), -np.sin(phi/180*np.pi)], [0, np.sin(phi/180*np.pi), np.cos(phi/180*np.pi)]]))
-        render_pose[:3,3:4] = np.zeros((3,1))
-        render_poses.append(render_pose)
-
-    return render_poses
-
-
-def generate_seed_lookdown():
-    degsum = 60 
-    thlist = np.concatenate((np.linspace(0, degsum, 4), np.linspace(0, -degsum, 4)[1:], np.linspace(0, degsum, 4), np.linspace(0, -degsum, 4)[1:]))
-    philist = np.concatenate((np.linspace(0,0,7), np.linspace(-22.5,-22.5,7)))
-    assert len(thlist) == len(philist)
-
-    render_poses = np.zeros((len(thlist), 3, 4))
-    for i in range(len(thlist)):
-        th = thlist[i]
-        phi = philist[i]
-        
-        render_poses[i,:3,:3] = np.matmul(np.array([[np.cos(th/180*np.pi), 0, -np.sin(th/180*np.pi)], [0, 1, 0], [np.sin(th/180*np.pi), 0, np.cos(th/180*np.pi)]]), np.array([[1, 0, 0], [0, np.cos(phi/180*np.pi), -np.sin(phi/180*np.pi)], [0, np.sin(phi/180*np.pi), np.cos(phi/180*np.pi)]]))
-        render_poses[i,:3,3:4] = np.zeros((3,1))
-
-    return render_poses
-
-
-def generate_seed_back():
-    movement = np.linspace(0, 5, 101)
-    render_poses = [] # np.zeros((len(movement), 3, 4))
-    for i in range(len(movement)):
-        render_pose = np.zeros((3,4))
-        render_pose[:3,:3] = np.eye(3)
-        render_pose[:3,3:4] = np.array([[0], [0], [movement[i]]])
-        render_poses.append(render_pose)
-
-    movement = np.linspace(5, 0, 101)
-    movement = movement[1:]
-    for i in range(len(movement)):
-        render_pose = np.zeros((3,4))
-        render_pose[:3,:3] = np.eye(3)
-        render_pose[:3,3:4] = np.array([[0], [0], [movement[i]]])
-        render_poses.append(render_pose)
-
-    return render_poses
-
-
-def generate_seed_llff(degree, nviews, round=4, d=2.3):
-    assert round%4==0
-    # thlist = np.array([degree, 0, 0, 0, -degree])
-    # philist = np.array([0, -degree, 0, degree, 0])
-    # d = 2.3
-    thlist = degree * np.sin(np.linspace(0, 2*np.pi*round, nviews))
-    philist = degree * np.cos(np.linspace(0, 2*np.pi*round, nviews))
-    zlist = d/15 * np.sin(np.linspace(0, 2*np.pi*round//4, nviews))
-    assert len(thlist) == len(philist)
-
-    render_poses = np.zeros((len(thlist), 3, 4))
-    for i in range(len(thlist)):
-        th = thlist[i]
-        phi = philist[i]
-        z = zlist[i]
-        # curr_pose = np.zeros((1, 3, 4))
-        # d = 4.3 # 얘를 조절하면 초기 자세 기준으로 앞으로 d만큼 떨어진 점을 기준으로 도는 자세가 만들어짐
-        
-        render_poses[i,:3,:3] = np.matmul(np.array([[np.cos(th/180*np.pi), 0, -np.sin(th/180*np.pi)], [0, 1, 0], [np.sin(th/180*np.pi), 0, np.cos(th/180*np.pi)]]), np.array([[1, 0, 0], [0, np.cos(phi/180*np.pi), -np.sin(phi/180*np.pi)], [0, np.sin(phi/180*np.pi), np.cos(phi/180*np.pi)]]))
-        render_poses[i,:3,3:4] = np.array([d*np.sin(th/180*np.pi), 0, -z+d-d*np.cos(th/180*np.pi)]).reshape(3,1) + np.array([0, d*np.sin(phi/180*np.pi), -z+d-d*np.cos(phi/180*np.pi)]).reshape(3,1)# Transition vector
-    return render_poses
-
-
-def generate_seed_headbanging(maxdeg, nviews_per_round, round=3, fullround=1):
-    radius = np.concatenate((np.linspace(0, maxdeg, nviews_per_round*round), maxdeg*np.ones(nviews_per_round*fullround), np.linspace(maxdeg, 0, nviews_per_round*round)))
-    thlist  = 2.66*radius * np.sin(np.linspace(0, 2*np.pi*(round+fullround+round), nviews_per_round*(round+fullround+round)))
-    philist = radius * np.cos(np.linspace(0, 2*np.pi*(round+fullround+round), nviews_per_round*(round+fullround+round)))
-    assert len(thlist) == len(philist)
-
-    render_poses = np.zeros((len(thlist), 3, 4))
-    for i in range(len(thlist)):
-        th = thlist[i]
-        phi = philist[i]
-        
-        render_poses[i,:3,:3] = np.matmul(np.array([[np.cos(th/180*np.pi), 0, -np.sin(th/180*np.pi)], [0, 1, 0], [np.sin(th/180*np.pi), 0, np.cos(th/180*np.pi)]]), np.array([[1, 0, 0], [0, np.cos(phi/180*np.pi), -np.sin(phi/180*np.pi)], [0, np.sin(phi/180*np.pi), np.cos(phi/180*np.pi)]]))
-        render_poses[i,:3,3:4] = np.zeros((3,1))
-
-    return render_poses
-
-
-def generate_seed_headbanging_circle(maxdeg, nviews_per_round, round=3, fullround=1):
-    radius = np.concatenate((np.linspace(0, maxdeg, nviews_per_round*round), maxdeg*np.ones(nviews_per_round*fullround), np.linspace(maxdeg, 0, nviews_per_round*round)))
-    thlist  = 2.66*radius * np.sin(np.linspace(0, 2*np.pi*(round+fullround+round), nviews_per_round*(round+fullround+round)))
-    philist = radius * np.cos(np.linspace(0, 2*np.pi*(round+fullround+round), nviews_per_round*(round+fullround+round)))
-    assert len(thlist) == len(philist)
-
-    render_poses = np.zeros((len(thlist), 3, 4))
-    for i in range(len(thlist)):
-        th = thlist[i]
-        phi = philist[i]
-        
-        render_poses[i,:3,:3] = np.matmul(np.array([[np.cos(th/180*np.pi), 0, -np.sin(th/180*np.pi)], [0, 1, 0], [np.sin(th/180*np.pi), 0, np.cos(th/180*np.pi)]]), np.array([[1, 0, 0], [0, np.cos(phi/180*np.pi), -np.sin(phi/180*np.pi)], [0, np.sin(phi/180*np.pi), np.cos(phi/180*np.pi)]]))
-        render_poses[i,:3,3:4] = np.zeros((3,1))
-
-    return render_poses
-
-
-def get_pcdGenPoses(pcdgenpath, argdict={}):
-    if pcdgenpath == 'rotate360':
-        render_poses = generate_seed_360(360, 10)
-    elif pcdgenpath == 'lookaround':
-        render_poses = generate_seed_preset()
-    elif pcdgenpath == 'moveright':
-        render_poses = generate_seed_horizon()
-    elif pcdgenpath == 'moveback':
-        render_poses = generate_seed_backward()
-    elif pcdgenpath == 'arc':
-        render_poses = generate_seed_arc()
-    elif pcdgenpath == 'lookdown':
-        render_poses = generate_seed_newpreset()
-    elif pcdgenpath == 'hemisphere':
-        render_poses = generate_seed_hemisphere(argdict['center_depth'])
-    else:
-        raise("Invalid pcdgenpath")
-    return render_poses
-
-
-def get_camerapaths():
-    preset_json = {}
-    for cam_path in ["back_and_forth", "llff", "headbanging"]:
-        if cam_path == 'back_and_forth':
-            render_poses = generate_seed_back()
-        elif cam_path == 'llff':
-            render_poses = generate_seed_llff(5, 400, round=4, d=2)
-        elif cam_path == 'headbanging':
-            render_poses = generate_seed_headbanging(maxdeg=15, nviews_per_round=180, round=2, fullround=0)
-        else:
-            raise("Unknown pass")
-            
-        yz_reverse = np.array([[1,0,0], [0,-1,0], [0,0,-1]])
-        blender_train_json = {"frames": []}
-        for render_pose in render_poses:
-            curr_frame = {}
-            ### Transform world to pixel
-            Rw2i = render_pose[:3,:3]
-            Tw2i = render_pose[:3,3:4]
-
-            # Transfrom cam2 to world + change sign of yz axis
-            Ri2w = np.matmul(yz_reverse, Rw2i).T
-            Ti2w = -np.matmul(Ri2w, np.matmul(yz_reverse, Tw2i))
-            Pc2w = np.concatenate((Ri2w, Ti2w), axis=1)
-            Pc2w = np.concatenate((Pc2w, np.array([0,0,0,1]).reshape((1,4))), axis=0)
-
-            curr_frame["transform_matrix"] = Pc2w.tolist()
-            blender_train_json["frames"].append(curr_frame)
-
-        preset_json[cam_path] = blender_train_json
-
-    return preset_json
-
-
-def main():
-    cam_path = 'headbanging_circle'
-    os.makedirs("poses_supplementary", exist_ok=True)
-
-    if cam_path == 'lookaround':
-        render_poses = generate_seed_lookaround()
-    elif cam_path == 'back':
-        render_poses = generate_seed_back()
-    elif cam_path == '360':
-        render_poses = generate_seed_360(360, 360)
-    elif cam_path == '1440':
-        render_poses = generate_seed_360(360, 1440)
-    elif cam_path == 'llff':
-        d = 8
-        render_poses = generate_seed_llff(5, 400, round=4, d=d)
-    elif cam_path == 'headbanging':
-        round=3
-        render_poses = generate_seed_headbanging_(maxdeg=15, nviews_per_round=180, round=round, fullround=0)
-    elif cam_path == 'headbanging_circle':
-        round=2
-        render_poses = generate_seed_headbanging_circle(maxdeg=5, nviews_per_round=180, round=round, fullround=0)
-        
-
-    yz_reverse = np.array([[1,0,0], [0,-1,0], [0,0,-1]])
-
-    c2w_poses = []
-    for render_pose in render_poses:
-        ### Transform world to pixel
-        Rw2i = render_pose[:3,:3]
-        Tw2i = render_pose[:3,3:4]
-
-        # Transfrom cam2 to world + change sign of yz axis
-        Ri2w = np.matmul(yz_reverse, Rw2i).T
-        Ti2w = -np.matmul(Ri2w, np.matmul(yz_reverse, Tw2i))
-        Pc2w = np.concatenate((Ri2w, Ti2w), axis=1)
-        # Pc2w = np.concatenate((Pc2w, np.array([[0,0,0,1]])), axis=0)
-
-        c2w_poses.append(Pc2w)
-
-    c2w_poses = np.stack(c2w_poses, axis=0)
-
-    # np.save(f'poses_supplementary/{cam_path}.npy', c2w_poses)
-
-    FX = 5.8269e+02
-    W = 512
-    fov_x = 2*np.arctan(W / (2*FX))
-    if cam_path in ['360', '1440', 'llff', 'headbanging']:
-        fov_x = fov_x * 1.2
-    blender_train_json = {}
-    blender_train_json["camera_angle_x"] = fov_x
-    blender_train_json["frames"] = []
-
-    for render_pose in render_poses:
-        curr_frame = {}
-        ### Transform world to pixel
-        Rw2i = render_pose[:3,:3]
-        Tw2i = render_pose[:3,3:4]
-
-        # Transfrom cam2 to world + change sign of yz axis
-        Ri2w = np.matmul(yz_reverse, Rw2i).T
-        Ti2w = -np.matmul(Ri2w, np.matmul(yz_reverse, Tw2i))
-        Pc2w = np.concatenate((Ri2w, Ti2w), axis=1)
-
-        curr_frame["transform_matrix"] = Pc2w.tolist()
-        (blender_train_json["frames"]).append(curr_frame)
-
-    import json
-    if cam_path=='llff':
-        train_json_path = f"poses_supplementary/{cam_path}_d{d}.json"
-    elif cam_path=='headbanging':
-        train_json_path = f"poses_supplementary/{cam_path}_r{round}.json"
-    else:
-        train_json_path = f"poses_supplementary/{cam_path}.json"
-    
-    with open(train_json_path, 'w') as outfile:
-        json.dump(blender_train_json, outfile, indent=4)
-
-
-if __name__ == '__main__':
-    main()