Robust global multi-view pose recovery

Improve a weak Python solver that recovers camera-to-world poses from noisy relative-pose graphs. Your objective is globally consistent relative geometry on unseen scenes; the submitted source is re-run on sealed hidden data for scoring.

Hard Constraints

• Edit only /app/methods/main/solver.py and retain predict(observation_dir) as the entry point.
• Use the installed Python environment, including NumPy. The solver must not access the network, start external programs, or read files outside the supplied observation directory.
• Return exactly one pose for every camera in every scene listed by the supplied manifest. Do not assume scene identifiers, camera identifiers, scene counts, camera counts, or edge order.
• Every pose must contain exactly quat_c2w_wxyz and center. The quaternion must be a finite, non-zero list of four numbers in [w, x, y, z] order; the center must be a finite list of three numbers.
• The output must be deterministic for identical input, and the solver must not modify any input file.

What You Have

The visible observations are under /app/public/observations. Its manifest lists opaque scenes and the JSON file for each scene. Every scene contains scene_id, camera_ids, and a list of pairwise edges.

Each edge contains:

• source and target: opaque camera identifiers.
• relative_rotation_wxyz: a noisy unit quaternion relating the target orientation to the source orientation.
• relative_translation_local: a noisy displacement from source center to target center, expressed in the source camera frame.
• confidence, support, and reprojection_residual: finite observation diagnostics.

Camera poses use camera-to-world quaternions and world-frame centers. For an ideal edge from camera a to camera b, the relative quaternion is conjugate(q_a) * q_b, and the local translation is R(q_a)^T * (center_b - center_a). Measurements may be noisy or incorrect.

The editable starter is /app/methods/main/solver.py. Run python /app/selfcheck.py to validate the contract and request one aggregate visible raw metric. The evaluator reports no poses, per-scene values, family labels, sealed data, or scoring calibration.

What You Submit

Submit the edited file at /app/methods/main/solver.py. It must expose:

def predict(observation_dir: str) -> dict:
    ...

Return a document with schema_version = "anonymous_pose_graph_predictions_v1" and a predictions list. Each list item contains exactly scene_id and poses; poses maps every camera identifier in that scene to:

{
    "quat_c2w_wxyz": [1.0, 0.0, 0.0, 0.0],
    "center": [0.0, 0.0, 0.0]
}

The example documents shape only. Keys and coverage must follow the supplied manifest and scene files.

How It Is Judged

The sealed evaluator invokes predict on private scenes with the same schema and validates exact coverage, finite values, determinism, and input immutability. For every unordered camera pair, it compares relative rotation and local translation direction, uses the larger angular error, converts errors to average accuracy over thresholds from 1 through 10 degrees, and averages equally across hidden scenario families. Higher raw relative-pose accuracy is better.

The visible self-check uses the same raw metric on a separate development split. Its aggregate result is feedback for iteration, not a prediction of sealed performance.

Common Pitfalls

• Hard-coding visible scene or camera identifiers instead of reading the manifest.
• Returning missing or extra scenes, cameras, or fields.
• Emitting a zero, malformed, non-finite, or differently ordered quaternion.
• Reversing the camera-to-world convention or the direction of a relative edge.
• Modifying visible inputs or depending on files outside the observation directory.
• Exhausting the visible evaluation budget on unchanged source.