Skip to content

[SIGGRAPH Asia 2026] 4DAnyone: Create Anyone in 4D from a Casual Monocular Video

5.3 KB
Raw Blame
"""Map canonical target cameras onto cyclic denoising groups."""

from __future__ import annotations

from collections.abc import Sequence
from typing import TYPE_CHECKING

from fdanyone.views import VIEWS_PER_GROUP

if TYPE_CHECKING:
    from fdanyone.views import ViewPlan

CameraOrder = tuple[int, ...]
CameraGroup = tuple[int, ...]
StepGroups = tuple[CameraGroup, ...]
Routes = tuple[StepGroups, ...]


def denoising_camera_order(view_plan: ViewPlan) -> CameraOrder:
    """Return one deterministic cycle over the plan's canonical camera IDs.

    A single row or column keeps its angular order. A two-dimensional layout
    forms a Hamiltonian cycle in the open pitch-by-yaw grid, so partial yaw
    layouts do not need a false edge between their horizontal endpoints.
    """

    views_per_layer = view_plan.views_per_layer
    num_layers = view_plan.num_layers
    if views_per_layer <= 0 or num_layers <= 0:
        raise ValueError("A denoising camera order requires a non-empty resolved view plan.")
    if len(set(view_plan.layer_pitches)) != num_layers:
        raise ValueError("A denoising camera order requires distinct pitch layers.")
    if num_layers == 1:
        return tuple(range(views_per_layer))
    if views_per_layer > 1 and views_per_layer % 2 and num_layers % 2:
        raise ValueError("A multi-layer camera grid requires an even number of cameras.")

    # Public IDs follow input layer order. Physical vertical neighbors follow
    # pitch order, so this mapping changes traversal without changing identity.
    layers_by_pitch = tuple(sorted(range(num_layers), key=view_plan.layer_pitches.__getitem__))
    if views_per_layer == 1:
        return layers_by_pitch

    # Keep the released traversal when yaw is even. Odd yaw counts have an even
    # layer count, so transposing the grid gives the same adjacent-cycle construction.
    transpose = views_per_layer % 2 == 1
    rows, columns = (views_per_layer, num_layers) if transpose else (num_layers, views_per_layer)

    def camera_id(row: int, column: int) -> int:
        pitch_rank, yaw_index = (column, row) if transpose else (row, column)
        return layers_by_pitch[pitch_rank] * views_per_layer + yaw_index

    # Reserve the first row as the return lane, then snake through the other rows.
    order = [camera_id(row, 0) for row in range(rows)]
    for column in range(1, columns):
        row_order = range(rows - 1, 0, -1) if column % 2 else range(1, rows)
        order.extend(camera_id(row, column) for row in row_order)
    order.extend(camera_id(0, column) for column in range(columns - 1, 0, -1))

    return tuple(order)


def cyclic_groups(
    camera_order: Sequence[int],
    group_size: int,
    offset: int = 0,
) -> StepGroups:
    """Partition a cyclic camera order into equally sized consecutive groups."""

    order = tuple(camera_order)
    num_views = len(order)
    if num_views <= 0 or group_size <= 0 or num_views % group_size:
        raise ValueError(f"{num_views} cameras must be divisible by positive group_size={group_size}.")
    return tuple(
        tuple(order[(group_start + offset + local_index) % num_views] for local_index in range(group_size))
        for group_start in range(0, num_views, group_size)
    )


def routing_steps(
    *,
    view_plan: ViewPlan,
    num_steps: int,
    tcr_stride: int = 1,
    freeze_after_one_cycle: bool = False,
) -> Routes:
    """Return fixed or TCR-shifted partitions of one global camera ring."""

    if num_steps <= 0:
        raise ValueError(f"num_steps must be positive, got {num_steps}.")
    if tcr_stride <= 0:
        raise ValueError(f"tcr_stride must be positive, got {tcr_stride}.")
    camera_order = denoising_camera_order(view_plan)

    def step_offset(step_index: int) -> int:
        if not view_plan.enable_tcr:
            return 0
        offset = step_index * tcr_stride
        if freeze_after_one_cycle and offset >= VIEWS_PER_GROUP:
            return 0
        return offset

    return tuple(
        cyclic_groups(
            camera_order,
            VIEWS_PER_GROUP,
            step_offset(step_index),
        )
        for step_index in range(num_steps)
    )


def validate_routes(routes: Routes, num_views: int) -> None:
    """Require every routing step to be an equal partition of canonical IDs."""

    if num_views <= 0:
        raise ValueError(f"Target denoising requires a positive camera count, got {num_views}.")
    if not routes:
        raise ValueError("Target denoising requires at least one routing step.")
    if not routes[0] or not routes[0][0]:
        raise ValueError("Target denoising requires non-empty camera groups.")

    num_groups = len(routes[0])
    group_size = len(routes[0][0])
    expected_ids = list(range(num_views))
    for step_index, groups in enumerate(routes):
        if len(groups) != num_groups:
            raise ValueError(f"Routing step {step_index} has {len(groups)} groups; every step must have {num_groups}.")
        if any(len(group) != group_size for group in groups):
            raise ValueError(f"Routing step {step_index} contains camera groups with inconsistent sizes.")
        camera_ids = sorted(camera_id for group in groups for camera_id in group)
        if camera_ids != expected_ids:
            raise ValueError(
                f"Routing step {step_index} is not a disjoint partition of cameras 0..{num_views - 1}: {groups}."
            )