scripts/melbourne/grid_from_kml.py

"""
Build the 150 m tile grid for the City3D-MultiGen reconstruction pipeline.

Role in the pipeline:
    This script turns a coarse tile-index footprint into the fine, regularly
    spaced grid of 150 m x 150 m tiles that drives the rest of the pipeline.
    Each generated tile later defines the geographic extent used to crop the
    source city point cloud and to fetch aligned satellite/semantic maps.

Input:
    A KML tile-index file (default "Tile_Index.kml") whose polygons describe
    the WGS84 (lon/lat) coverage area of the source city data.

Outputs:
    - output_grids.kml: a colorized KML visualization of the generated tiles.
    - output_grids.json: the machine-readable grid consumed downstream. It
      stores grid_size_m, grid_spacing_m, input_polygons, total_grids, and a
      "grids" list where each entry has id, row, col, and both UTM and WGS84
      corner coordinates (utm_nw/utm_se, wgs84_nw/wgs84_se).

Key steps:
    Parse the KML polygons, pick a UTM zone from the data centroid, project the
    polygons into metric UTM coordinates, tile the bounding box on a fixed
    pitch, keep tiles whose center falls inside a footprint polygon, then
    project the tile corners back to WGS84 for output.

Coordinate-system handling:
    All distances/sizes are computed in metric UTM (zone chosen automatically
    from the centroid via EPSG:326xx/327xx). pyproj Transformers (always_xy)
    convert between EPSG:4326 (WGS84 lon/lat) and the chosen UTM CRS.
"""

import json
import math
from xml.etree import ElementTree as ET
from pyproj import Transformer, CRS
from typing import List, Tuple

GRID_SIZE = 150
GRID_SPACING = -130   # 150 m tile - 130 m overlap = 20 m center spacing (paper setting)

def parse_kml_polygons(kml_path: str) -> List[List[Tuple[float, float]]]:
    tree = ET.parse(kml_path)
    root = tree.getroot()
    
    polygons = []
    
    for elem in root.iter():
        if elem.tag.endswith('coordinates'):
            coords_text = elem.text
            if coords_text:
                coords = []
                for line in coords_text.strip().split():
                    parts = line.split(',')
                    if len(parts) >= 2:
                        lon, lat = float(parts[0]), float(parts[1])
                        coords.append((lon, lat))
                if coords:
                    polygons.append(coords)
    
    print(f"Parsed {len(polygons)} polygons from KML")
    return polygons

def get_utm_zone(lon: float, lat: float) -> str:
    zone = int((lon + 180) / 6) + 1
    hemisphere = 'north' if lat >= 0 else 'south'
    return f"EPSG:326{zone:02d}" if hemisphere == 'north' else f"EPSG:327{zone:02d}"

def point_in_polygon(point: Tuple[float, float], polygon: List[Tuple[float, float]]) -> bool:
    x, y = point
    n = len(polygon)
    inside = False
    
    p1x, p1y = polygon[0]
    for i in range(1, n + 1):
        p2x, p2y = polygon[i % n]
        if y > min(p1y, p2y):
            if y <= max(p1y, p2y):
                if x <= max(p1x, p2x):
                    if p1y != p2y:
                        xinters = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
                    if p1x == p2x or x <= xinters:
                        inside = not inside
        p1x, p1y = p2x, p2y
    
    return inside

def generate_grid(polygons_wgs84: List[List[Tuple[float, float]]], 
                  grid_size: float, 
                  spacing: float) -> List[dict]:
    
    all_points = [p for poly in polygons_wgs84 for p in poly]
    center_lon = sum(p[0] for p in all_points) / len(all_points)
    center_lat = sum(p[1] for p in all_points) / len(all_points)
    
    utm_crs = get_utm_zone(center_lon, center_lat)
    print(f"Using coordinate system: {utm_crs}")
    
    transformer_to_utm = Transformer.from_crs("EPSG:4326", utm_crs, always_xy=True)
    transformer_to_wgs = Transformer.from_crs(utm_crs, "EPSG:4326", always_xy=True)
    
    polygons_utm = []
    for poly_wgs in polygons_wgs84:
        poly_utm = [transformer_to_utm.transform(lon, lat) for lon, lat in poly_wgs]
        polygons_utm.append(poly_utm)
    
    all_utm_points = [p for poly in polygons_utm for p in poly]
    min_x = min(p[0] for p in all_utm_points)
    max_x = max(p[0] for p in all_utm_points)
    min_y = min(p[1] for p in all_utm_points)
    max_y = max(p[1] for p in all_utm_points)
    
    print(f"Overall boundary in UTM: X=[{min_x:.2f}, {max_x:.2f}], Y=[{min_y:.2f}, {max_y:.2f}]")
    print(f"Area size: {max_x-min_x:.2f}m x {max_y-min_y:.2f}m")
    
    grids = []
    grid_id = 0
    total_candidates = 0
    
    y = min_y
    row = 0
    while y < max_y:
        x = min_x
        col = 0
        while x < max_x:
            total_candidates += 1
            
            center_x = x + grid_size / 2
            center_y = y + grid_size / 2
            center_utm = (center_x, center_y)
            
            is_inside = False
            for poly_utm in polygons_utm:
                if point_in_polygon(center_utm, poly_utm):
                    is_inside = True
                    break
            
            if is_inside:
                nw_utm = (x, y + grid_size)
                ne_utm = (x + grid_size, y + grid_size)
                se_utm = (x + grid_size, y)
                sw_utm = (x, y)
                
                nw_wgs = transformer_to_wgs.transform(*nw_utm)
                ne_wgs = transformer_to_wgs.transform(*ne_utm)
                se_wgs = transformer_to_wgs.transform(*se_utm)
                sw_wgs = transformer_to_wgs.transform(*sw_utm)
                
                color_index = (row + col) % 2
                
                grids.append({
                    'id': grid_id,
                    'row': row,
                    'col': col,
                    'color_index': color_index,
                    'utm': {
                        'nw': nw_utm,
                        'ne': ne_utm,
                        'se': se_utm,
                        'sw': sw_utm
                    },
                    'wgs84': {
                        'nw': nw_wgs,
                        'ne': ne_wgs,
                        'se': se_wgs,
                        'sw': sw_wgs
                    }
                })
                
                grid_id += 1
            
            x += grid_size + spacing
            col += 1
        
        y += grid_size + spacing
        row += 1
    
    print(f"Generated {len(grids)} grids from {total_candidates} candidates")
    return grids

def create_kml(grids: List[dict], output_path: str):
    kml_header = '''<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://www.opengis.net/kml/2.2">
<Document>
<name>Grid Output</name>
<Style id="color0">
  <LineStyle><color>ff0000ff</color><width>2</width></LineStyle>
  <PolyStyle><color>4d0000ff</color></PolyStyle>
</Style>
<Style id="color1">
  <LineStyle><color>ff00ff00</color><width>2</width></LineStyle>
  <PolyStyle><color>4d00ff00</color></PolyStyle>
</Style>
'''
    
    kml_footer = '''</Document>
</kml>'''
    
    with open(output_path, 'w', encoding='utf-8') as f:
        f.write(kml_header)
        
        for grid in grids:
            wgs = grid['wgs84']
            color_id = f"color{grid['color_index']}"
            
            f.write(f'''<Placemark>
  <name>Grid_{grid['id']}</name>
  <styleUrl>#{color_id}</styleUrl>
  <Polygon>
    <outerBoundaryIs>
      <LinearRing>
        <coordinates>
          {wgs['nw'][0]},{wgs['nw'][1]},0
          {wgs['ne'][0]},{wgs['ne'][1]},0
          {wgs['se'][0]},{wgs['se'][1]},0
          {wgs['sw'][0]},{wgs['sw'][1]},0
          {wgs['nw'][0]},{wgs['nw'][1]},0
        </coordinates>
      </LinearRing>
    </outerBoundaryIs>
  </Polygon>
</Placemark>
''')
        
        f.write(kml_footer)
    
    print(f"KML file saved to: {output_path}")

def create_json(grids: List[dict], output_path: str, input_polygon_count: int = 1):
    output_data = {
        'grid_size_m': GRID_SIZE,
        'grid_spacing_m': GRID_SPACING,
        'input_polygons': input_polygon_count,
        'total_grids': len(grids),
        'grids': [
            {
                'id': g['id'],
                'row': g['row'],
                'col': g['col'],
                'utm_nw': g['utm']['nw'],
                'utm_se': g['utm']['se'],
                'wgs84_nw': g['wgs84']['nw'],
                'wgs84_se': g['wgs84']['se']
            }
            for g in grids
        ]
    }
    
    with open(output_path, 'w', encoding='utf-8') as f:
        json.dump(output_data, f, indent=2, ensure_ascii=False)
    
    print(f"JSON file saved to: {output_path}")

def main(input_kml: str, output_kml: str, output_json: str):
    print(f"Reading input KML: {input_kml}")
    print(f"Grid size: {GRID_SIZE}m, Spacing: {GRID_SPACING}m")
    print("-" * 60)
    
    polygons = parse_kml_polygons(input_kml)
    
    if not polygons:
        raise ValueError("No polygons found in input KML")
    
    grids = generate_grid(polygons, GRID_SIZE, GRID_SPACING)
    
    create_kml(grids, output_kml)
    create_json(grids, output_json, len(polygons))
    
    print("-" * 60)
    print("Grid generation completed successfully!")

if __name__ == "__main__":
    INPUT_KML = "Tile_Index.kml"
    OUTPUT_KML = "output_grids.kml"
    OUTPUT_JSON = "output_grids.json"
    
    main(INPUT_KML, OUTPUT_KML, OUTPUT_JSON)