Function generate_camera_circle_path

plib/utils.py:2033–2136

Generate a camera path that looks at the world origin Args: num_poses: number of camera poses sampled on the circle d_to_origin: distance to the origin r_circle: radius of the circle center_direction: (2,) theta

(
        num_poses: int,
        d_to_origin: float,
        r_circle: float,
        center_angles: T.Union[torch.Tensor, np.ndarray, T.List[float]],
        invert_yz: bool = True,
        alt_yaxis: bool = False,
)

def generate_camera_circle_path(
        num_poses: int,
        d_to_origin: float,
        r_circle: float,
        center_angles: T.Union[torch.Tensor, np.ndarray, T.List[float]],
        invert_yz: bool = True,
        alt_yaxis: bool = False,
) -> T.Union[torch.Tensor, np.ndarray]:
    """
    Generate a camera path that looks at the world origin
    Args:
        num_poses:
            number of camera poses sampled on the circle
        d_to_origin:
            distance to the origin
        r_circle:
            radius of the circle
        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)
        alt_yaxis:
            an option to use an alternative definition of yaxis and makes a more stable circular path
    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 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_poses) + torch.pi  # (n,)
    cam_positions_c = torch.stack(
        [
            torch.cos(thetas) * float(r_circle),
            torch.sin(thetas) * float(r_circle),
            torch.ones(num_poses) * float(d_to_origin),
        ], dim=1)  # (n, 3)

    # print(f'cam_positions_c.shape = {cam_positions_c.shape}')

    # rotate the camera positions
    v1 = torch.tensor([0, 0, 1], dtype=torch.float)
    v2 = torch.stack(
        [