code/3dSAGER/alignment.py

"""
alignment.py

Two-stage rigid 3D alignment of candidate buildings onto the index coordinate frame.

Stage 1 — Estimate transform (Arun et al. 1987):
    Selects high-confidence matched pairs as anchors, estimates rotation R and
    translation t via SVD least-squares, then validates the result by computing
    per-anchor residuals.  If the mean residual exceeds the configured threshold
    the alignment is rejected and the pipeline continues with geometric scores only.

Stage 2 — Re-score and output:
    Applies (R, t) to all cand centroids and re-scores every pair as:
        final_score = alpha * geometric_score + (1 - alpha) * spatial_score
    where spatial_score = 1 / (1 + distance_after_alignment).
    Then applies (R, t) to all cand geometry and writes an aligned CityJSON file.

Reference:
    K. S. Arun, T. S. Huang, and S. D. Blostein. 1987.
    Least-Squares Fitting of Two 3-D Point Sets.
    IEEE TPAMI 9(5):698-700. doi:10.1109/TPAMI.1987.4767965

Usage:
    from alignment import RigidAligner
    import config

    aligner = RigidAligner(config.Alignment, logger=logger)
    rescored_pairs = aligner.run(
        object_dict,
        scored_pairs,          # list of (cand_id, index_id, geometric_score)
        suffix="seed1",
        ground_truth_R=simulator.R_crs,   # optional, for evaluation only
        ground_truth_t=simulator.t_crs,
    )
    # rescored_pairs: list of (cand_id, index_id, final_score)
    # results/aligned_candidates_seed1.json written if alignment succeeded
"""

import json
import os
import logging
import numpy as np
from typing import List, Tuple, Optional
import config as cfg


class RigidAligner:
    """
    Estimates a rigid 3D transform from anchor pairs and re-scores all matches.

    Parameters
    ----------
    align_config : config.Alignment (class reference)
    logger : logging.Logger  (optional)
    """

    def __init__(self, align_config=None, logger=None):
        if align_config is None:
            align_config = cfg.Alignment
        self.enabled = align_config.enabled
        self.min_anchor_pairs = align_config.min_anchor_pairs
        self.confidence_threshold = align_config.confidence_threshold
        self.max_residual_threshold = align_config.max_residual_threshold
        self.alpha = align_config.alpha
        self.output_crs = align_config.output_crs
        self.use_ransac = getattr(align_config, 'use_ransac', True)
        self.ransac_iterations = getattr(align_config, 'ransac_iterations', 1000)
        self.ransac_inlier_threshold = getattr(align_config, 'ransac_inlier_threshold', 10.0)
        self.spatial_sigma = getattr(align_config, 'spatial_sigma', 3.0)
        self.logger = logger or logging.getLogger(__name__)

        # Set after a successful alignment
        self.R: Optional[np.ndarray] = None
        self.t: Optional[np.ndarray] = None
        self.mean_residual: Optional[float] = None
        self.n_anchors: int = 0
        self.alignment_succeeded: bool = False

    # ------------------------------------------------------------------ #
    # Public API
    # ------------------------------------------------------------------ #

    def run(
        self,
        object_dict: dict,
        scored_pairs: List[Tuple[str, str, float]],
        suffix: str = "",
        ground_truth_R: Optional[np.ndarray] = None,
        ground_truth_t: Optional[np.ndarray] = None,
    ) -> List[Tuple[str, str, float]]:
        """
        Full alignment pipeline: estimate transform → validate → re-score → output.

        Parameters
        ----------
        object_dict : dict
            Full object dict with 'cands' and 'index'.
        scored_pairs : list of (cand_id, index_id, geometric_score)
            All test pairs with their classifier probability scores.
        suffix : str
            Appended to the output filename.
        ground_truth_R, ground_truth_t : np.ndarray, optional
            If provided (from DisasterSimulator), the alignment error is logged
            for evaluation purposes.  Not used in the alignment itself.

        Returns
        -------
        list of (cand_id, index_id, final_score)
            If alignment succeeded: final_score = alpha*geometric + (1-alpha)*spatial.
            If alignment failed/skipped: final_score = geometric_score unchanged.
        """
        if not self.enabled:
            self.logger.info("[RigidAligner] Disabled — returning geometric scores.")
            return scored_pairs

        # --- Stage 1: Estimate transform ---
        anchors = self._select_anchors(scored_pairs, object_dict)
        self.n_anchors = len(anchors)

        if self.n_anchors < self.min_anchor_pairs:
            self.logger.warning(
                f"[RigidAligner] Only {self.n_anchors} anchor pairs found "
                f"(need {self.min_anchor_pairs}, threshold={self.confidence_threshold}). "
                f"Skipping alignment — returning geometric scores."
            )
            return scored_pairs

        P, Q = self._build_point_sets(anchors, object_dict)
        if self.use_ransac:
            R, t, n_inliers, inlier_mask = self._estimate_rigid_transform_ransac(P, Q)
            # Validate using INLIER mean residual when RANSAC found enough inliers.
            # The all-anchor mean is dominated by false-positive anchors (look-alike
            # buildings the classifier scored high) and unfairly rejects a correct
            # transform whenever anchor-pool precision is low.
            if n_inliers >= self.min_anchor_pairs and inlier_mask.any():
                self.mean_residual = self._compute_residual(P[inlier_mask], Q[inlier_mask], R, t)
                all_anchor_mean = self._compute_residual(P, Q, R, t)
                self.logger.info(
                    f"[RigidAligner] RANSAC: {self.n_anchors} anchors | "
                    f"{n_inliers} inliers | inlier mean residual = {self.mean_residual:.2f} m "
                    f"(all-anchor mean = {all_anchor_mean:.2f} m)"
                )
            else:
                self.mean_residual = self._compute_residual(P, Q, R, t)
                self.logger.info(
                    f"[RigidAligner] RANSAC: {self.n_anchors} anchors | "
                    f"only {n_inliers} inliers (< {self.min_anchor_pairs}) | "
                    f"all-anchor mean residual = {self.mean_residual:.2f} m"
                )
        else:
            R, t = self._estimate_rigid_transform(P, Q)
            self.mean_residual = self._compute_residual(P, Q, R, t)
            self.logger.info(
                f"[RigidAligner] {self.n_anchors} anchors | "
                f"mean residual = {self.mean_residual:.2f} m"
            )

        if self.mean_residual > self.max_residual_threshold:
            self.logger.warning(
                f"[RigidAligner] Mean residual {self.mean_residual:.2f} m exceeds "
                f"threshold {self.max_residual_threshold} m. "
                f"Alignment rejected — returning geometric scores."
            )
            return scored_pairs

        self.R, self.t = R, t
        self.alignment_succeeded = True

        # Optional: log error vs ground-truth transform
        if ground_truth_R is not None and ground_truth_t is not None:
            self._log_ground_truth_error(ground_truth_R, ground_truth_t)

        # --- Stage 2: Re-score using aligned positions ---
        rescored = self._rescore_pairs(scored_pairs, object_dict)

        # Apply transform to full cand geometry and write output
        self._apply_transform_to_geometry(object_dict['cands'])
        self._write_cityjson(object_dict['cands'], suffix)

        return rescored

    # ------------------------------------------------------------------ #
    # Stage 1 helpers
    # ------------------------------------------------------------------ #

    def _select_anchors(
        self,
        scored_pairs: List[Tuple[str, str, float]],
        object_dict: dict,
    ) -> List[Tuple[str, str]]:
        """Return (cand_id, index_id) pairs with score >= confidence_threshold."""
        cands_keys = set(object_dict['cands'].keys())
        index_keys = set(object_dict['index'].keys())
        return [
            (cid, iid)
            for cid, iid, score in scored_pairs
            if score >= self.confidence_threshold
            and cid in cands_keys
            and iid in index_keys
        ]

    @staticmethod
    def _build_point_sets(
        anchors: List[Tuple[str, str]],
        object_dict: dict,
    ) -> Tuple[np.ndarray, np.ndarray]:
        """
        Build point sets from anchor centroids.
        P = index centroids (target), Q = cand centroids (source).
        Goal: find R, t such that P_i ≈ R @ Q_i + t.
        """
        P = np.array([object_dict['index'][iid]['centroid'] for _, iid in anchors], dtype=np.float64)
        Q = np.array([object_dict['cands'][cid]['centroid'] for cid, _ in anchors], dtype=np.float64)
        return P, Q

    @staticmethod
    def _estimate_rigid_transform(
        P: np.ndarray,
        Q: np.ndarray,
    ) -> Tuple[np.ndarray, np.ndarray]:
        """
        Arun et al. 1987 SVD least-squares rigid transform.

        Returns R (3x3) and t (3,) such that P_i ≈ R @ Q_i + t.
        """
        p_bar = P.mean(axis=0)   # (3,)
        q_bar = Q.mean(axis=0)   # (3,)
        P_prime = P - p_bar      # (N, 3) centered
        Q_prime = Q - q_bar      # (N, 3) centered

        H = Q_prime.T @ P_prime  # (3, 3) cross-covariance
        U, _, Vt = np.linalg.svd(H)
        V = Vt.T

        R = V @ U.T

        # Fix reflection (degenerate / coplanar case)
        if np.linalg.det(R) < 0:
            V[:, 2] *= -1
            R = V @ U.T

        t = p_bar - R @ q_bar
        return R, t

    def _estimate_rigid_transform_ransac(
        self,
        P: np.ndarray,
        Q: np.ndarray,
    ):
        """
        RANSAC-based rigid transform estimation.

        Each iteration samples 3 anchor pairs, estimates R and t via SVD,
        then counts how many of all anchors are consistent (inliers) under
        that transform.  The best transform (most inliers) is refitted on
        all its inliers via SVD for a final least-squares solution.

        Parameters
        ----------
        P : (N, 3) index centroids
        Q : (N, 3) cand centroids

        Returns
        -------
        R : (3, 3) rotation matrix
        t : (3,) translation vector
        n_inliers : int
        """
        n = len(P)
        best_inlier_mask = np.zeros(n, dtype=bool)
        best_n_inliers = 0
        best_R, best_t = self._estimate_rigid_transform(P, Q)  # fallback

        rng = np.random.default_rng(42)

        for _ in range(self.ransac_iterations):
            # Sample 3 unique anchor pairs
            idx = rng.choice(n, size=3, replace=False)
            P_sample, Q_sample = P[idx], Q[idx]

            # Skip degenerate (collinear) samples
            if np.linalg.matrix_rank(P_sample - P_sample.mean(axis=0)) < 2:
                continue

            R_cand, t_cand = self._estimate_rigid_transform(P_sample, Q_sample)

            # Count inliers: anchors whose residual < threshold under this transform
            P_hat = (R_cand @ Q.T).T + t_cand
            residuals = np.linalg.norm(P_hat - P, axis=1)
            inlier_mask = residuals < self.ransac_inlier_threshold
            n_inliers = inlier_mask.sum()

            if n_inliers > best_n_inliers:
                best_n_inliers = n_inliers
                best_inlier_mask = inlier_mask
                best_R, best_t = R_cand, t_cand

        # Refit on all inliers of the best solution
        if best_n_inliers >= 3:
            best_R, best_t = self._estimate_rigid_transform(
                P[best_inlier_mask], Q[best_inlier_mask]
            )
            # Recompute inlier mask under the refit transform so it reflects the
            # final R, t rather than the 3-sample one used to score iterations.
            P_hat = (best_R @ Q.T).T + best_t
            residuals = np.linalg.norm(P_hat - P, axis=1)
            best_inlier_mask = residuals < self.ransac_inlier_threshold
            best_n_inliers = int(best_inlier_mask.sum())
            self.logger.info(
                f"[RigidAligner] RANSAC refit on {best_n_inliers}/{n} inliers "
                f"(threshold={self.ransac_inlier_threshold} m, "
                f"iterations={self.ransac_iterations})"
            )
        else:
            self.logger.warning(
                f"[RigidAligner] RANSAC found only {best_n_inliers} inliers — "
                f"falling back to full SVD"
            )

        return best_R, best_t, best_n_inliers, best_inlier_mask

    @staticmethod
    def _compute_residual(
        P: np.ndarray,
        Q: np.ndarray,
        R: np.ndarray,
        t: np.ndarray,
    ) -> float:
        """Mean Euclidean residual ||R @ q_i + t - p_i|| over all anchor pairs."""
        P_hat = (R @ Q.T).T + t   # (N, 3)
        residuals = np.linalg.norm(P_hat - P, axis=1)
        return float(residuals.mean())

    def _log_ground_truth_error(
        self,
        gt_R: np.ndarray,
        gt_t: np.ndarray,
    ) -> None:
        """
        Log rotation and translation error vs the ground-truth CRS transform.

        The disaster simulator applies:  cand = R_crs @ original + t_crs
        So the aligner should recover the INVERSE transform:
            self.R ≈ R_crs^T   (so that R_crs^T @ R_crs = I)
            self.t ≈ -R_crs^T @ t_crs

        Rotation check: self.R @ gt_R should be close to I.
        Translation check: self.t should be close to -gt_R^T @ gt_t.
        """
        # Rotation error: R_recovered @ R_gt should equal I if perfect
        R_check = self.R @ gt_R
        angle_err = np.degrees(np.arccos(
            np.clip((np.trace(R_check) - 1.0) / 2.0, -1.0, 1.0)
        ))
        # Translation error: compare recovered t to the expected inverse translation
        expected_t = -gt_R.T @ gt_t
        t_err = np.linalg.norm(self.t - expected_t)
        self.logger.info(
            f"[RigidAligner] Ground-truth comparison: "
            f"rotation error = {angle_err:.2f}°, "
            f"translation error = {t_err:.1f} m"
        )

    # ------------------------------------------------------------------ #
    # Stage 2 helpers
    # ------------------------------------------------------------------ #

    def _rescore_pairs(
        self,
        scored_pairs: List[Tuple[str, str, float]],
        object_dict: dict,
    ) -> List[Tuple[str, str, float]]:
        """
        Re-score pairs combining geometric score with spatial proximity
        after aligning cand centroids to the index frame.

        final_score = alpha * geometric_score + (1 - alpha) * spatial_score
        spatial_score = exp(- d² / (2 · spatial_sigma²))     # Gaussian, σ default 3 m
        """
        # Apply R, t to cand centroids only (fast; full geometry updated later)
        aligned_cand_centroids = {
            bid: self.R @ np.asarray(data['centroid'], dtype=np.float64) + self.t
            for bid, data in object_dict['cands'].items()
        }
        index_centroids = {
            bid: np.asarray(data['centroid'], dtype=np.float64)
            for bid, data in object_dict['index'].items()
        }

        rescored = []
        for cid, iid, geo_score in scored_pairs:
            if cid in aligned_cand_centroids and iid in index_centroids:
                dist = float(np.linalg.norm(aligned_cand_centroids[cid] - index_centroids[iid]))
                # Gaussian decay with σ = spatial_sigma (default 3 m, ≈ median true-match
                # residual). Sharply suppresses look-alikes that land 5–10 m away while
                # giving high scores to genuine matches at d ≤ σ.
                spatial_score = float(np.exp(-(dist * dist) / (2.0 * self.spatial_sigma ** 2)))
                final_score = self.alpha * geo_score + (1.0 - self.alpha) * spatial_score
            else:
                final_score = geo_score   # fallback if ID missing
            rescored.append((cid, iid, final_score))

        # Log score distribution summary
        geo_scores = [s for _, _, s in scored_pairs]
        final_scores = [s for _, _, s in rescored]
        self.logger.info(
            f"[RigidAligner] Score re-scaling: "
            f"geometric mean={np.mean(geo_scores):.3f} → "
            f"final mean={np.mean(final_scores):.3f} "
            f"(alpha={self.alpha})"
        )
        return rescored

    def _apply_transform_to_geometry(self, cands: dict) -> None:
        """Apply (R, t) to all cand vertices, centroids, and polygon_mesh."""
        for building in cands.values():
            verts = building['vertices']
            building['vertices'] = (self.R @ verts.T).T + self.t
            building['centroid'] = self.R @ np.asarray(building['centroid'], dtype=np.float64) + self.t
            new_mesh = []
            for surface in building['polygon_mesh']:
                new_surface = [(self.R @ np.array(c, dtype=np.float64) + self.t).tolist() for c in surface]
                new_mesh.append(new_surface)
            building['polygon_mesh'] = new_mesh

    # ------------------------------------------------------------------ #
    # CityJSON output
    # ------------------------------------------------------------------ #

    def _write_cityjson(self, cands: dict, suffix: str) -> None:
        """
        Write aligned candidates to a CityJSON 1.1 file in the index CRS.

        Vertices are stored as floating-point world coordinates (no re-quantization).
        Each building is written as a Solid LOD2 geometry preserving the original
        surface structure.
        """
        results_dir = cfg.FilePaths.results_path
        os.makedirs(results_dir, exist_ok=True)
        out_path = os.path.join(results_dir, f"aligned_candidates_{suffix}.json")

        city_objects = {}
        all_vertices = []
        vertex_index = {}   # (x, y, z) rounded → global index

        epsg_code = self.output_crs.split(":")[-1]

        for bid, building in cands.items():
            verts = building['vertices']   # (N, 3) already aligned

            # Build local vertex index
            local_idx = {}
            for v in verts:
                key = (round(float(v[0]), 6), round(float(v[1]), 6), round(float(v[2]), 6))
                if key not in vertex_index:
                    vertex_index[key] = len(all_vertices)
                    all_vertices.append(list(key))
                local_idx[key] = vertex_index[key]

            # Encode polygon_mesh as surface boundary index lists
            boundaries = []
            for surface in building['polygon_mesh']:
                ring = []
                for coord in surface:
                    key = (round(float(coord[0]), 6), round(float(coord[1]), 6), round(float(coord[2]), 6))
                    # Find the nearest stored key (handles float drift)
                    if key not in vertex_index:
                        key = min(
                            local_idx.keys(),
                            key=lambda k: (k[0]-key[0])**2 + (k[1]-key[1])**2 + (k[2]-key[2])**2
                        )
                    ring.append(vertex_index[key])
                boundaries.append([ring])

            city_objects[f"bag_{bid}"] = {
                "type": "Building",
                "geometry": [{
                    "type": "Solid",
                    "lod": "2",
                    "boundaries": [boundaries]
                }],
                "attributes": building.get("attributes", {})
            }

        cityjson = {
            "type": "CityJSON",
            "version": "1.1",
            "metadata": {
                "referenceSystem": f"https://www.opengis.net/def/crs/EPSG/0/{epsg_code}"
            },
            "CityObjects": city_objects,
            "vertices": all_vertices,
            "alignment_info": {
                "mean_residual_m": round(self.mean_residual, 3),
                "n_anchor_pairs": self.n_anchors,
                "alpha": self.alpha
            }
        }

        with open(out_path, 'w', encoding='utf-8') as f:
            json.dump(cityjson, f, indent=2)

        size_mb = os.path.getsize(out_path) / 1e6
        self.logger.info(
            f"[RigidAligner] Aligned CityJSON written: {out_path} "
            f"({len(city_objects)} buildings, {size_mb:.1f} MB)"
        )