PhD Research: Methodological Developments

1. Python: Data Preparation

# --- Data Preparation & Georeferencing ---
# This script defines a pipeline to process raw architectural data (including
# complex floor levels) and georeferenced cameras, transforming them into
# a clean, structured, and localized 3D scene format for Blender.

import numpy as np
import geopandas as gpd
from shapely.geometry import Point
from shapely.affinity import apply as apply_transform
from geopy.distance import geodesic

# Define a constant for story height
FLOOR_HEIGHT = 3.0

# Define the final output path.
# This path should match the JSON_FILEPATH variable in your Blender script.
JSON_FILEPATH = "/path/to/blender_scene_data_all.json"

def sort_floor_keys(floors_dict):
    """
    Robustly sorts complex floor keys (e.g., '-1', '0', '2.5', 'R') into
    a logical vertical stack based on numeric value and special rules.
    """
    floor_map = []
    # Logic to parse numeric and special string keys like 'R' for Roof...
    numeric_keys = [float(k) for k in floors_dict if k.replace('.', '', 1).replace('-', '', 1).isdigit()]
    max_numeric_index = max(numeric_keys) if numeric_keys else -1
    
    for key in floors_dict.keys():
        try:
            numeric_index = float(key)
        except ValueError:
            numeric_index = max_numeric_index + 1 if key.upper() == 'R' else None
        
        if numeric_index is not None:
            floor_map.append({'original_key': key, 'numeric_index': numeric_index})
            
    return sorted(floor_map, key=lambda x: x['numeric_index'])

def prepare_data_for_blender(building_footprint, building_structure, selected_cameras_gdf, target_utm_crs, final_matrix):
    """
    Main function to orchestrate the data preparation pipeline.
    """
    # 1. Establish a local 3D origin from the building's projected centroid.
    local_origin = building_footprint.centroid
    origin_x, origin_y = local_origin.x, local_origin.y
    
    blender_data = {"building_geometries": [], "cameras": []}

    # 2. Sort all floor levels into a logical vertical order.
    sorted_floors = sort_floor_keys(building_structure['001']['floors'])
    
    # 3. Process each floor's geometry.
    for floor_info in sorted_floors:
        floor_data = building_structure['001']['floors'][floor_info['original_key']]
        base_z = floor_info['numeric_index'] * FLOOR_HEIGHT
        
        for wall_poly in floor_data.get('wall_polygon').geoms:
            # 3a. Apply a pre-calculated affine transformation matrix to align geometry.
            transformed_wall = apply_transform(wall_poly, final_matrix)
            
            # 3b. Re-center vertex coordinates relative to the local origin.
            verts_utm = np.array(transformed_wall.exterior.coords)
            local_verts = (verts_utm - [origin_x, origin_y]).tolist()
            
            blender_data["building_geometries"].append({
                "name": f"Wall_F{floor_info['original_key']}", "base_z": base_z, "verts": local_verts
            })

    # 4. Process and re-center each selected Street View camera.
    for index, cam_data in selected_cameras_gdf.iterrows():
        cam_point_geo = cam_data.geometry
        cam_heading = cam_data['original_heading']

        # 4a. Project camera's geographic lat/lon to the scene's projected UTM CRS.
        cam_point_utm = gpd.GeoSeries([cam_point_geo], crs="EPSG:4326").to_crs(target_utm_crs).iloc[0]
        cam_pos_utm = np.array([cam_point_utm.x, cam_point_utm.y, 2.5]) # Assume 2.5m camera height

        # 4b. Calculate a target point 10m away to define camera's viewing direction.
        target_geo_point = geodesic(meters=10).destination((cam_point_geo.y, cam_point_geo.x), cam_heading)
        target_utm_point = gpd.GeoSeries([Point(target_geo_point.longitude, target_geo_point.latitude)], crs="EPSG:4326").to_crs(target_utm_crs).iloc[0]
        target_pos_utm = np.array([target_utm_point.x, target_utm_point.y, 2.5])

        # 4c. Re-center 3D camera position and target relative to the local origin.
        local_cam_pos = (cam_pos_utm - [origin_x, origin_y, 0]).tolist()
        local_target_pos = (target_pos_utm - [origin_x, origin_y, 0]).tolist()
        
        blender_data["cameras"].append({
            "name": f"StreetView_Cam_h{int(cam_heading)}", "pos": local_cam_pos, "target": local_target_pos
        })
        
    return blender_data

# --- Implementation ---

# 1. Load the building's raw footprint and apply the transformation matrix
#    to create the final, registered footprint ('final_registered_fp').
final_registered_fp = apply_transformation_matrix(raw_footprint, final_matrix)

# 2. Load the full building data structure from a pre-processed pickle file.
sorted_building_structure = load_pickle_data("path/to/data.pickle")

# 3. Load the GeoDataFrame containing all potential camera positions and their
#    metadata, as returned by the Street View API analysis.
locations_gdf = gpd.read_file("path/to/camera_locations.geojson")

# 4. Filter for the specific cameras to be exported to the 3D scene.
desired_headings = [237, 135, 86]
selected_cameras_gdf = locations_gdf[locations_gdf['original_heading'].isin(desired_headings)]

# 5. Run the main function to generate the structured JSON for Blender.
blender_scene_data = prepare_data_for_blender(
    final_registered_fp,
    sorted_building_structure,
    selected_cameras_gdf,
    utm_crs, # The target CRS object (e.g., from the registered footprint)
    final_matrix
)

# 6. Save the prepared data to the target JSON file.
with open(JSON_FILEPATH, 'w') as f:
    json.dump(blender_scene_data, f, indent=4)