code/3dSAGER/disaster_simulation.py

"""
disaster_simulation.py

Simulates a post-disaster scenario on the candidate building set.

Two independent simulations are applied in order (CRS first, then damage):

  1. CRS simulation (global):
     All cand buildings are rotated by a random angle around the Z-axis and shifted
     by a large random translation, simulating a dataset with no absolute coordinate
     reference.  The internal geometry of each building is preserved exactly; only
     the global frame changes.  This forces the model to rely on rotation-invariant
     features (aligned BB, volume, area, compactness) rather than axis-aligned ones.

  2. Damage simulation (per-building):
     A random subset of cand buildings have their height reduced, simulating partial
     collapse.  Each damaged building keeps its ground footprint but loses height
     according to a random damage factor.

Only 'cands' are ever modified.  The 'index' (reference dataset) is never touched.

Usage:
    from disaster_simulation import DisasterSimulator
    import config

    simulator = DisasterSimulator(config.DisasterSimulation, seed=1)
    object_dict = simulator.apply(object_dict)
    # simulator.R_crs, simulator.t_crs  — ground-truth transform for evaluation
    # simulator.damage_log              — per-building damage factors for inspection
"""

import numpy as np
import config as cfg


class DisasterSimulator:
    """
    Applies CRS simulation and damage simulation to the candidate set.

    Parameters
    ----------
    sim_config : config.DisasterSimulation (class reference)
    seed : int
        Controls randomness for both simulations.  Different seeds per pipeline
        run ensure the model trains on varied scenarios.
    """

    _Z_EPSILON = 1e-4   # threshold to distinguish above-ground vertices from ground

    def __init__(self, sim_config=None, seed=42):
        if sim_config is None:
            sim_config = cfg.DisasterSimulation
        self.enabled = sim_config.enabled
        self.crs_simulation = sim_config.crs_simulation
        self.damage_probability = sim_config.damage_probability
        self.min_damage_factor = sim_config.min_damage_factor
        self.max_damage_factor = sim_config.max_damage_factor
        self._rng = np.random.default_rng(seed)

        # Set after apply() — expose for external evaluation
        self.R_crs = None      # (3,3) rotation matrix applied to all cands
        self.t_crs = None      # (3,) translation vector applied to all cands
        self.damage_log = {}   # {building_id: damage_factor}  (1.0 = undamaged)

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

    def apply(self, object_dict: dict) -> dict:
        """
        Apply CRS simulation then damage simulation to cands in-place.

        Parameters
        ----------
        object_dict : dict
            Full object dict with keys 'cands', 'index', 'mapping_dict', etc.

        Returns
        -------
        dict
            Same object_dict with modified cands.
        """
        if not self.enabled:
            return object_dict

        if self.crs_simulation:
            object_dict = self._apply_crs_simulation(object_dict)

        object_dict = self._apply_damage_simulation(object_dict)

        self._print_summary(object_dict)
        return object_dict

    # ------------------------------------------------------------------ #
    # CRS simulation
    # ------------------------------------------------------------------ #

    def _apply_crs_simulation(self, object_dict: dict) -> dict:
        """
        Apply a single random rotation (around Z) + large translation to ALL cands.

        The same (R_crs, t_crs) is applied to every building so internal
        relative geometry is preserved — only the global frame changes.
        """
        # Random rotation angle in [0, 2π)
        theta = self._rng.uniform(0.0, 2.0 * np.pi)
        cos_t, sin_t = np.cos(theta), np.sin(theta)
        self.R_crs = np.array([
            [ cos_t, -sin_t, 0.0],
            [ sin_t,  cos_t, 0.0],
            [   0.0,    0.0, 1.0]
        ])

        # Large random translation — no absolute reference
        tx = self._rng.uniform(-100_000.0, 100_000.0)
        ty = self._rng.uniform(-100_000.0, 100_000.0)
        self.t_crs = np.array([tx, ty, 0.0])

        for bid, building in object_dict['cands'].items():
            self._transform_building(building, self.R_crs, self.t_crs)

        print(f"[DisasterSimulator] CRS simulation applied: "
              f"rotation={np.degrees(theta):.1f}°, "
              f"translation=({tx:.0f}, {ty:.0f}) m")
        return object_dict

    @staticmethod
    def _transform_building(building: dict, R: np.ndarray, t: np.ndarray) -> None:
        """Apply rigid transform (R, t) to all geometry of one building in-place."""
        # vertices: (N, 3)
        verts = building['vertices']
        building['vertices'] = (R @ verts.T).T + t

        # centroid: (3,)
        building['centroid'] = R @ np.asarray(building['centroid'], dtype=np.float64) + t

        # polygon_mesh: list of surfaces, each surface = list of [x, y, z]
        new_mesh = []
        for surface in building['polygon_mesh']:
            new_surface = []
            for coord in surface:
                v = np.array(coord, dtype=np.float64)
                new_surface.append((R @ v + t).tolist())
            new_mesh.append(new_surface)
        building['polygon_mesh'] = new_mesh

    # ------------------------------------------------------------------ #
    # Damage simulation
    # ------------------------------------------------------------------ #

    def _apply_damage_simulation(self, object_dict: dict) -> dict:
        """
        Randomly reduce height of a fraction of cand buildings.

        Each damaged building keeps its ground footprint but all vertices
        above z_min are scaled: z_new = z_min + (z - z_min) * damage_factor
        """
        cands = object_dict['cands']
        cand_ids = list(cands.keys())
        n_to_damage = int(round(self.damage_probability * len(cand_ids)))

        # Select which buildings to damage
        damaged_indices = self._rng.choice(len(cand_ids), size=n_to_damage, replace=False)
        damaged_ids = [cand_ids[i] for i in damaged_indices]

        # One damage factor per building
        damage_factors = self._rng.uniform(
            self.min_damage_factor, self.max_damage_factor, size=n_to_damage
        )

        for bid, factor in zip(damaged_ids, damage_factors):
            self._damage_building(cands[bid], factor)
            self.damage_log[bid] = round(float(factor), 4)

        # Undamaged buildings recorded as 1.0
        for bid in cand_ids:
            if bid not in self.damage_log:
                self.damage_log[bid] = 1.0

        print(f"[DisasterSimulator] Damage simulation: "
              f"{n_to_damage}/{len(cand_ids)} buildings damaged "
              f"(factor range [{self.min_damage_factor}, {self.max_damage_factor}])")
        return object_dict

    def _damage_building(self, building: dict, damage_factor: float) -> None:
        """Reduce height of a single building in-place."""
        verts = building['vertices']  # (N, 3)
        z_min = float(verts[:, 2].min())

        # Update vertices array
        mask = verts[:, 2] > (z_min + self._Z_EPSILON)
        verts[mask, 2] = z_min + (verts[mask, 2] - z_min) * damage_factor
        building['vertices'] = verts

        # Update polygon_mesh
        new_mesh = []
        for surface in building['polygon_mesh']:
            new_surface = []
            for coord in surface:
                x, y, z = coord[0], coord[1], coord[2]
                if z > z_min + self._Z_EPSILON:
                    z = z_min + (z - z_min) * damage_factor
                new_surface.append([x, y, z])
            new_mesh.append(new_surface)
        building['polygon_mesh'] = new_mesh

        # Update centroid z
        new_z_max = float(verts[:, 2].max())
        c = np.asarray(building['centroid'], dtype=np.float64)
        c[2] = (z_min + new_z_max) / 2.0
        building['centroid'] = c

    # ------------------------------------------------------------------ #
    # Reporting
    # ------------------------------------------------------------------ #

    @staticmethod
    def _print_summary(object_dict: dict) -> None:
        print(f"[DisasterSimulator] Done. "
              f"cands: {len(object_dict['cands'])}, "
              f"index: {len(object_dict['index'])} (unchanged)")