Function generate_camera_spiral_path

plib/utils.py:2292–2407

Generate a spiral camera path that looks at the world origin Args: num_poses: number of camera poses sampled on the spiral num_circle: number of circle the spiral made in xy plane init_phi: initial phi (angle between xy plane) of t

(
        num_poses: int,
        num_circle: int,
        init_phi: float,
        center_angles: T.Union[torch.Tensor, np.ndarray, T.List[float]],
        r_max: float = 1,
        r_min: float = 1,
        r_freq: float = 1,
        invert_yz: bool = True,
)

def generate_camera_spiral_path(
        num_poses: int,
        num_circle: int,
        init_phi: float,
        center_angles: T.Union[torch.Tensor, np.ndarray, T.List[float]],
        r_max: float = 1,
        r_min: float = 1,
        r_freq: float = 1,
        invert_yz: bool = True,
) -> T.Union[torch.Tensor, np.ndarray]:
    """
    Generate a spiral camera path that looks at the world origin
    Args:
        num_poses:
            number of camera poses sampled on the spiral
        num_circle:
            number of circle the spiral made in xy plane
        init_phi:
            initial phi (angle between xy plane) of the path, the path will go from phi to -phi
        r_circle:
            radius of the spiral
        center_direction:
            (2,) theta (angle between x-axis), phi (angle between xy plane),
            the viewing direction of the center of the circle.  All in degree.
            The angles are given in the final coordinate (after yz is inverted)
        invert_yz:
            whether to invert the direction of y axis and z axis (since images y coord is flipped)
            This is to account for the difference in the image coordinate (x to right, y to down, z to far)
            and the world/opengl coordinate (x to right, y to up, z to us)

    Returns:
        (num_poses, 4, 4) camera poses (that converts camera coord to world coords)
    """

    if isinstance(center_angles, np.ndarray):
        center_angles = torch.from_numpy(center_angles).float()
    elif isinstance(center_angles, (list, tuple)):
        center_angles = torch.tensor(center_angles).float()

    center_angles = center_angles.float()

    if num_poses % 2 != 0:
        print('Warning: automatically change num_poses to be even')
        num_poses = num_poses + 1

    if invert_yz:
        # the coordinate is currently pre-yz-inverted
        # but center_angles are given after yz-inverted
        center_angles = -1 * center_angles

    # generate a circle on the xy plane (i.e., on the plane z = d_to_origin)
    thetas = torch.linspace(0, torch.pi * 2 * num_circle, num_poses) + torch.pi  # (n,)

    # uniformly sample along phi by cosine weighted sample
    # https://alexanderameye.github.io/notes/sampling-the-hemisphere/

    # calculate complementary phi: angle between z axis and camara position
    init_z = torch.cos(torch.pi / 2 - torch.tensor(init_phi))