tools/utils/visualize_zones.py

"""
Visualize functional zones in a 3D indoor scene layout.
Each zone is rendered with a colored bounding box encompassing all its assets.
"""

import os
import json
import argparse
import subprocess
import sys
import tempfile
import shutil
from pathlib import Path
from typing import List, Dict, Any, Optional, Tuple

# Add project root
SCRIPT_DIR = Path(__file__).parent
REPO_ROOT = SCRIPT_DIR.parent.parent
sys.path.insert(0, str(REPO_ROOT))


# Predefined colors for zones (distinguishable colors)
ZONE_COLORS = [
    (1.0, 0.2, 0.2),    # Red
    (0.2, 0.8, 0.2),    # Green
    (0.2, 0.4, 1.0),    # Blue
    (1.0, 0.8, 0.0),    # Yellow
    (1.0, 0.4, 0.8),    # Pink
    (0.0, 0.9, 0.9),    # Cyan
    (0.9, 0.5, 0.0),    # Orange
    (0.6, 0.2, 0.8),    # Purple
    (0.5, 0.9, 0.5),    # Light Green
    (0.9, 0.3, 0.5),    # Coral
    (0.3, 0.7, 0.9),    # Sky Blue
    (0.8, 0.8, 0.3),    # Olive
]


def get_asset_position_size(asset: Dict) -> Tuple[Optional[List[float]], Optional[List[float]]]:
    """
    Extract position and size from asset, handling different data formats.
    
    Supports:
    - asset['transform']['pos'] / asset['transform']['size']
    - asset['position'] / asset['size']
    - asset['pos'] / asset['size']
    """
    pos = None
    size = None
    
    # Try transform format first (unified-layout-aligned format)
    if 'transform' in asset:
        transform = asset['transform']
        pos = transform.get('pos') or transform.get('position')
        size = transform.get('size')
    
    # Fallback to direct fields
    if pos is None:
        pos = asset.get('pos') or asset.get('position')
    if size is None:
        size = asset.get('size')
    
    return pos, size


def get_scene_bounds(layout: Dict) -> Optional[Dict[str, List[float]]]:
    """
    Get scene boundary from layout's architecture.boundary_polygon.
    
    Returns:
        Dict with 'min' and 'max' corners, or None if not available.
    """
    architecture = layout.get('architecture', {})
    boundary_polygon = architecture.get('boundary_polygon', [])
    
    if not boundary_polygon:
        return None
    
    import numpy as np
    boundary = np.array(boundary_polygon)
    
    if len(boundary) == 0:
        return None
    
    return {
        'min': boundary.min(axis=0).tolist(),
        'max': boundary.max(axis=0).tolist(),
    }


def clamp_bbox_to_bounds(bbox: Dict, bounds: Dict) -> Dict:
    """
    Clamp a bounding box to stay within scene bounds.
    
    Args:
        bbox: Zone bounding box with 'min' and 'max'
        bounds: Scene bounds with 'min' and 'max'
    
    Returns:
        Clamped bbox dict
    """
    clamped_min = [
        max(bbox['min'][0], bounds['min'][0]),
        max(bbox['min'][1], bounds['min'][1]),
        max(bbox['min'][2], bounds['min'][2]),
    ]
    clamped_max = [
        min(bbox['max'][0], bounds['max'][0]),
        min(bbox['max'][1], bounds['max'][1]),
        min(bbox['max'][2], bounds['max'][2]),
    ]
    
    # Ensure min <= max (in case zone is completely outside)
    for i in range(3):
        if clamped_min[i] > clamped_max[i]:
            # Zone is outside bounds on this axis, use boundary edge
            mid = (bounds['min'][i] + bounds['max'][i]) / 2
            clamped_min[i] = mid
            clamped_max[i] = mid
    
    return {
        'min': clamped_min,
        'max': clamped_max,
        'center': [(clamped_min[i] + clamped_max[i]) / 2 for i in range(3)],
        'size': [clamped_max[i] - clamped_min[i] for i in range(3)],
    }


def compute_zone_bbox(zone: Dict) -> Optional[Dict[str, List[float]]]:
    """
    Compute the bounding box for a functional zone based on its assets.
    
    Important: This applies the same transform logic as compose_generated.py:
    - Floor alignment: if pos[2] ≈ 0, adjust to size[2]/2 (lift object to sit on floor)
    
    Returns:
        Dict with 'min' and 'max' corners, or None if no valid assets.
    """
    assets = zone.get('assets', [])
    if not assets:
        return None
    
    min_x, max_x = float('inf'), float('-inf')
    min_y, max_y = float('inf'), float('-inf')
    min_z, max_z = float('inf'), float('-inf')
    
    valid_count = 0
    
    for asset in assets:
        pos, size = get_asset_position_size(asset)
        
        if pos is None or size is None:
            continue
        
        # Skip zero-size assets
        if all(s == 0 for s in size):
            continue
        
        valid_count += 1
        
        # Convert to numpy for easier manipulation
        pos = list(pos)  # Make a copy
        size = list(size)
        
        # Apply floor alignment (same as compose_generated.py)
        # If pos[2] ≈ 0 (object on floor), lift it by half its height
        if abs(pos[2]) < 1e-3:
            pos[2] = size[2] / 2.0
        
        # Compute asset bounds (position is center)
        half_size = [s / 2 for s in size]
        
        asset_min_x = pos[0] - half_size[0]
        asset_max_x = pos[0] + half_size[0]
        asset_min_y = pos[1] - half_size[1]
        asset_max_y = pos[1] + half_size[1]
        asset_min_z = pos[2] - half_size[2]
        asset_max_z = pos[2] + half_size[2]
        
        min_x = min(min_x, asset_min_x)
        max_x = max(max_x, asset_max_x)
        min_y = min(min_y, asset_min_y)
        max_y = max(max_y, asset_max_y)
        min_z = min(min_z, asset_min_z)
        max_z = max(max_z, asset_max_z)
    
    if valid_count == 0:
        return None
    
    return {
        'min': [min_x, min_y, min_z],
        'max': [max_x, max_y, max_z],
        'center': [(min_x + max_x) / 2, (min_y + max_y) / 2, (min_z + max_z) / 2],
        'size': [max_x - min_x, max_y - min_y, max_z - min_z],
    }


def compute_all_zone_bboxes(layout: Dict) -> List[Dict]:
    """
    Compute bounding boxes for all functional zones in a layout.
    Zone bboxes are clamped to the scene boundary.
    
    Returns:
        List of zone info dicts with bbox data.
    """
    zones_info = []
    
    # Get scene boundary from architecture
    scene_bounds = get_scene_bounds(layout)
    if scene_bounds:
        print(f"  Scene boundary: X=[{scene_bounds['min'][0]:.2f}, {scene_bounds['max'][0]:.2f}], "
              f"Y=[{scene_bounds['min'][1]:.2f}, {scene_bounds['max'][1]:.2f}], "
              f"Z=[{scene_bounds['min'][2]:.2f}, {scene_bounds['max'][2]:.2f}]")
    
    functional_zones = layout.get('functional_zones', [])
    
    for i, zone in enumerate(functional_zones):
        zone_id = zone.get('id', f'zone_{i}')
        semantic_label = zone.get('semantic_label', 'Unknown')
        
        bbox = compute_zone_bbox(zone)
        
        if bbox is None:
            print(f"  Warning: Zone '{zone_id}' ({semantic_label}) has no valid assets with position/size")
            continue
        
        # Clamp bbox to scene boundary
        if scene_bounds:
            bbox = clamp_bbox_to_bounds(bbox, scene_bounds)
        
        zones_info.append({
            'zone_id': zone_id,
            'semantic_label': semantic_label,
            'bbox': bbox,
            'color': ZONE_COLORS[i % len(ZONE_COLORS)],
            'asset_count': len(zone.get('assets', [])),
        })
    
    return zones_info


def create_zone_bbox_glb(zones_info: List[Dict], output_path: str, scene_bounds: Optional[Dict] = None,
                          face_alpha: float = 0.25, edge_alpha: float = 0.8, edge_radius: float = 0.015,
                          render_faces: bool = True, render_edges: bool = True):
    """
    Create a GLB file containing bounding boxes for all zones with transparent faces and edges.
    
    This creates solid box faces with high transparency (like the reference image shows),
    plus optional wireframe edges for better visibility.
    
    Important: This applies the same global rotation as compose_generated.py:
    - Global rotation: -π/2 around X axis
    - This transforms: original Y -> -Z, original Z -> Y
    
    Args:
        zones_info: List of zone info dicts with bbox and color
        output_path: Output GLB path
        scene_bounds: Optional scene bounds to clamp bbox after padding
        face_alpha: Alpha value for box faces (0.0-1.0, default 0.25 for high transparency)
        edge_alpha: Alpha value for wireframe edges (0.0-1.0, default 0.8)
        edge_radius: Radius of edge cylinders (default 0.015m = 1.5cm)
        render_faces: Whether to render transparent box faces (default True)
        render_edges: Whether to render wireframe edges (default True)
    """
    import numpy as np
    import trimesh
    from trimesh.visual.material import PBRMaterial
    
    # Global rotation matrix (same as compose_generated.py)
    # Rotates -π/2 around X axis: Y -> -Z, Z -> Y
    global_rot = trimesh.transformations.rotation_matrix(-np.pi / 2, [1, 0, 0])
    
    scene = trimesh.Scene()
    
    for zone in zones_info:
        bbox = zone['bbox']
        color = zone['color']
        zone_id = zone['zone_id']
        
        # Create box
        min_pt = np.array(bbox['min'])
        max_pt = np.array(bbox['max'])
        
        # Add small padding (5cm)
        padding = 0.05
        min_pt -= padding
        max_pt += padding
        
        # Clamp to scene bounds if provided (ensure padding doesn't exceed room boundary)
        if scene_bounds is not None:
            min_pt = np.maximum(min_pt, scene_bounds['min'])
            max_pt = np.minimum(max_pt, scene_bounds['max'])
        
        # Box dimensions
        box_size = max_pt - min_pt
        box_center = (min_pt + max_pt) / 2
        
        # ============ RENDER TRANSPARENT FACES ============
        if render_faces:
            # Create a box mesh for the faces
            box_mesh = trimesh.creation.box(extents=box_size)
            box_mesh.apply_translation(box_center)
            
            # Apply global rotation
            box_mesh.apply_transform(global_rot)
            
            # Create transparent PBR material for faces
            face_rgba = [int(c * 255) for c in color] + [int(face_alpha * 255)]
            face_material = PBRMaterial(
                baseColorFactor=face_rgba,
                metallicFactor=0.0,
                roughnessFactor=0.8,
                alphaMode='BLEND',  # Enable alpha blending for transparency
            )
            
            box_mesh.visual = trimesh.visual.TextureVisuals(material=face_material)
            scene.add_geometry(box_mesh, node_name=f"{zone_id}_faces")
        
        # ============ RENDER WIREFRAME EDGES ============
        if render_edges:
            # Define 8 corner vertices
            vertices = np.array([
                [min_pt[0], min_pt[1], min_pt[2]],  # 0: bottom-front-left
                [max_pt[0], min_pt[1], min_pt[2]],  # 1: bottom-front-right
                [max_pt[0], max_pt[1], min_pt[2]],  # 2: bottom-back-right
                [min_pt[0], max_pt[1], min_pt[2]],  # 3: bottom-back-left
                [min_pt[0], min_pt[1], max_pt[2]],  # 4: top-front-left
                [max_pt[0], min_pt[1], max_pt[2]],  # 5: top-front-right
                [max_pt[0], max_pt[1], max_pt[2]],  # 6: top-back-right
                [min_pt[0], max_pt[1], max_pt[2]],  # 7: top-back-left
            ])
            
            # Define 12 edges (pairs of vertex indices)
            edges = [
                # Bottom face
                [0, 1], [1, 2], [2, 3], [3, 0],
                # Top face
                [4, 5], [5, 6], [6, 7], [7, 4],
                # Vertical edges
                [0, 4], [1, 5], [2, 6], [3, 7],
            ]
            
            # Create PBR material for edges (slightly more opaque)
            edge_rgba = [int(c * 255) for c in color] + [int(edge_alpha * 255)]
            edge_material = PBRMaterial(
                baseColorFactor=edge_rgba,
                metallicFactor=0.0,
                roughnessFactor=0.5,
            )
            
            # Create cylinders for each edge
            for i, edge in enumerate(edges):
                start = vertices[edge[0]]
                end = vertices[edge[1]]
                
                segment = end - start
                length = np.linalg.norm(segment)
                
                if length < 0.001:
                    continue
                
                # Create cylinder along Z axis
                cylinder = trimesh.creation.cylinder(
                    radius=edge_radius,
                    height=length,
                    sections=8
                )
                
                # Compute rotation to align cylinder with edge
                direction = segment / length
                z_axis = np.array([0, 0, 1])
                
                if np.allclose(direction, z_axis):
                    rotation = np.eye(4)
                elif np.allclose(direction, -z_axis):
                    rotation = trimesh.transformations.rotation_matrix(np.pi, [1, 0, 0])
                else:
                    axis = np.cross(z_axis, direction)
                    axis = axis / np.linalg.norm(axis)
                    angle = np.arccos(np.clip(np.dot(z_axis, direction), -1, 1))
                    rotation = trimesh.transformations.rotation_matrix(angle, axis)
                
                # Move to edge midpoint
                midpoint = (start + end) / 2
                translation = trimesh.transformations.translation_matrix(midpoint)
                
                cylinder.apply_transform(rotation)
                cylinder.apply_transform(translation)
                
                # Apply global rotation
                cylinder.apply_transform(global_rot)
                
                # Apply PBR material
                cylinder.visual = trimesh.visual.TextureVisuals(material=edge_material)
                
                scene.add_geometry(cylinder, node_name=f"{zone_id}_edge_{i}")
    
    scene.export(output_path)
    print(f"  Created zone bbox GLB: {output_path}")


def _add_zone_label(scene, zone: Dict, global_rot):
    """
    Add a 3D label marker for a zone at the top-center of its bounding box.
    Uses a colored sphere/cylinder combination to indicate the zone.
    
    Args:
        scene: trimesh.Scene to add geometry to
        zone: Zone info dict with bbox, color, semantic_label
        global_rot: Global rotation matrix to apply
    """
    import numpy as np
    import trimesh
    from trimesh.visual.material import PBRMaterial
    
    bbox = zone['bbox']
    color = zone['color']
    zone_id = zone['zone_id']
    semantic_label = zone.get('semantic_label', 'Unknown')
    
    # Position: center of bbox in X/Y, top in Z (with some offset above)
    label_pos = np.array([
        bbox['center'][0],
        bbox['center'][1],
        bbox['max'][2] + 0.3  # 30cm above the top of the zone
    ])
    
    # Create a marker: sphere with a vertical pole
    rgba = [int(c * 255) for c in color] + [255]
    material = PBRMaterial(
        baseColorFactor=rgba,
        metallicFactor=0.0,
        roughnessFactor=0.5,
    )
    
    # Sphere marker at the top
    sphere_radius = 0.12  # 12cm radius
    sphere = trimesh.creation.icosphere(radius=sphere_radius, subdivisions=2)
    sphere.apply_translation(label_pos)
    sphere.apply_transform(global_rot)
    sphere.visual = trimesh.visual.TextureVisuals(material=material)
    scene.add_geometry(sphere, node_name=f"{zone_id}_label_sphere")
    
    # Vertical pole from zone top to the sphere
    pole_start = np.array([bbox['center'][0], bbox['center'][1], bbox['max'][2]])
    pole_end = label_pos - np.array([0, 0, sphere_radius])
    pole_height = np.linalg.norm(pole_end - pole_start)
    
    if pole_height > 0.01:
        pole = trimesh.creation.cylinder(radius=0.02, height=pole_height, sections=8)
        pole_center = (pole_start + pole_end) / 2
        pole.apply_translation(pole_center)
        pole.apply_transform(global_rot)
        pole.visual = trimesh.visual.TextureVisuals(material=material)
        scene.add_geometry(pole, node_name=f"{zone_id}_label_pole")
    
    # Add a small horizontal bar indicating direction (optional visual cue)
    bar_length = 0.2
    bar = trimesh.creation.cylinder(radius=0.015, height=bar_length, sections=6)
    # Rotate to horizontal (along X axis)
    bar.apply_transform(trimesh.transformations.rotation_matrix(np.pi/2, [0, 1, 0]))
    bar.apply_translation(label_pos + np.array([bar_length/2 + sphere_radius, 0, 0]))
    bar.apply_transform(global_rot)
    bar.visual = trimesh.visual.TextureVisuals(material=material)
    scene.add_geometry(bar, node_name=f"{zone_id}_label_bar")


def _deprecated_add_coordinate_axes(scene, zones_info: List[Dict]):
    """
    [DEPRECATED] Add coordinate axis markers on the floor plane (Z=0) for verification.
    This function is kept for reference but is no longer used.
    """
    import numpy as np
    import trimesh
    from trimesh.visual.material import PBRMaterial
    
    # Global rotation matrix (same as compose_generated.py)
    global_rot = trimesh.transformations.rotation_matrix(-np.pi / 2, [1, 0, 0])
    
    # Find extent of all zones
    all_min = np.array([float('inf'), float('inf'), float('inf')])
    all_max = np.array([float('-inf'), float('-inf'), float('-inf')])
    
    for zone in zones_info:
        bbox = zone['bbox']
        all_min = np.minimum(all_min, bbox['min'])
        all_max = np.maximum(all_max, bbox['max'])
    
    # Extend slightly beyond
    margin = 1.0
    x_min, x_max = int(all_min[0] - margin), int(all_max[0] + margin)
    y_min, y_max = int(all_min[1] - margin), int(all_max[1] + margin)
    z_floor = 0.0
    
    # Axis colors
    x_color = [255, 0, 0, 255]  # Red for X
    y_color = [0, 255, 0, 255]  # Green for Y
    tick_color = [100, 100, 100, 255]  # Gray for tick marks
    
    x_material = PBRMaterial(baseColorFactor=x_color, metallicFactor=0.0, roughnessFactor=0.5)
    y_material = PBRMaterial(baseColorFactor=y_color, metallicFactor=0.0, roughnessFactor=0.5)
    tick_material = PBRMaterial(baseColorFactor=tick_color, metallicFactor=0.0, roughnessFactor=0.5)
    
    axis_radius = 0.03
    tick_radius = 0.02
    tick_height = 0.3
    
    # X axis (red) - horizontal line along X
    x_length = x_max - x_min
    x_axis = trimesh.creation.cylinder(radius=axis_radius, height=x_length, sections=8)
    # Rotate to align with X axis (default is Z)
    x_axis.apply_transform(trimesh.transformations.rotation_matrix(np.pi/2, [0, 1, 0]))
    x_axis.apply_translation([(x_min + x_max) / 2, 0, z_floor])
    x_axis.apply_transform(global_rot)  # Apply global rotation
    x_axis.visual = trimesh.visual.TextureVisuals(material=x_material)
    scene.add_geometry(x_axis, node_name="axis_x")
    
    # Y axis (green) - horizontal line along Y
    y_length = y_max - y_min
    y_axis = trimesh.creation.cylinder(radius=axis_radius, height=y_length, sections=8)
    # Rotate to align with Y axis
    y_axis.apply_transform(trimesh.transformations.rotation_matrix(np.pi/2, [1, 0, 0]))
    y_axis.apply_translation([0, (y_min + y_max) / 2, z_floor])
    y_axis.apply_transform(global_rot)  # Apply global rotation
    y_axis.visual = trimesh.visual.TextureVisuals(material=y_material)
    scene.add_geometry(y_axis, node_name="axis_y")
    
    # Add tick marks along X axis
    for x in range(x_min, x_max + 1):
        tick = trimesh.creation.cylinder(radius=tick_radius, height=tick_height, sections=6)
        tick.apply_translation([x, 0, z_floor + tick_height/2])
        tick.apply_transform(global_rot)  # Apply global rotation
        tick.visual = trimesh.visual.TextureVisuals(material=tick_material)
        scene.add_geometry(tick, node_name=f"tick_x_{x}")
        
        # Add label sphere at integer coordinates (larger at origin)
        sphere_radius = 0.08 if x == 0 else 0.05
        sphere = trimesh.creation.icosphere(radius=sphere_radius, subdivisions=2)
        sphere.apply_translation([x, 0, z_floor + tick_height + 0.1])
        sphere.apply_transform(global_rot)  # Apply global rotation
        sphere.visual = trimesh.visual.TextureVisuals(material=x_material)
        scene.add_geometry(sphere, node_name=f"label_x_{x}")
    
    # Add tick marks along Y axis
    for y in range(y_min, y_max + 1):
        tick = trimesh.creation.cylinder(radius=tick_radius, height=tick_height, sections=6)
        tick.apply_translation([0, y, z_floor + tick_height/2])
        tick.apply_transform(global_rot)  # Apply global rotation
        tick.visual = trimesh.visual.TextureVisuals(material=tick_material)
        scene.add_geometry(tick, node_name=f"tick_y_{y}")
        
        # Add label sphere
        sphere_radius = 0.08 if y == 0 else 0.05
        sphere = trimesh.creation.icosphere(radius=sphere_radius, subdivisions=2)
        sphere.apply_translation([0, y, z_floor + tick_height + 0.1])
        sphere.apply_transform(global_rot)  # Apply global rotation
        sphere.visual = trimesh.visual.TextureVisuals(material=y_material)
        scene.add_geometry(sphere, node_name=f"label_y_{y}")
    
    # Add origin marker (larger sphere)
    origin_material = PBRMaterial(baseColorFactor=[255, 255, 255, 255], metallicFactor=0.0, roughnessFactor=0.3)
    origin = trimesh.creation.icosphere(radius=0.12, subdivisions=3)
    origin.apply_translation([0, 0, z_floor])
    origin.visual = trimesh.visual.TextureVisuals(material=origin_material)
    scene.add_geometry(origin, node_name="origin")
    
    print(f"  Added coordinate axes: X=[{x_min}, {x_max}], Y=[{y_min}, {y_max}]")


def run_command(cmd, env=None, quiet=False):
    """Run a shell command."""
    print(f"  Running: {cmd[:100]}...")
    try:
        if quiet:
            subprocess.check_call(cmd, shell=True, env=env,
                                  stdout=subprocess.DEVNULL,
                                  stderr=subprocess.DEVNULL)
        else:
            subprocess.check_call(cmd, shell=True, env=env)
        return True
    except subprocess.CalledProcessError as e:
        print(f"  Command failed: {e}")
        return False


def project_3d_to_2d_diagonal(point_3d, scene_center, scene_radius, img_width, img_height, 
                              camera_factor=0.8, diagonal_distance=1.2, diagonal_height_offset=0.1, view_mode="diagonal"):
    """
    Project a 3D point to 2D image coordinates for diagonal view.
    Mimics the camera setup in blender_renderer.py.
    
    Args:
        point_3d: (x, y, z) in world coordinates
        scene_center: (cx, cy, cz) scene center
        scene_radius: scene bounding radius
        img_width, img_height: image dimensions
        camera_factor: camera distance factor (default: 0.8, from blender_renderer.py)
        diagonal_distance: distance multiplier (default: 1.2, from blender_renderer.py)
        diagonal_height_offset: vertical camera offset (default: 0.1, from blender_renderer.py)
        view_mode: "diagonal" or "diagonal2"
    
    Returns:
        (x_2d, y_2d) in image coordinates, or None if behind camera
    """
    import math
    import numpy as np
    
    # IMPORTANT: Apply the same global rotation as compose_generated.py and create_zone_bbox_glb
    # Global rotation: -π/2 around X axis
    # Rotation matrix Rx(-π/2) = [[1, 0, 0], [0, 0, 1], [0, -1, 0]]
    # So (x, y, z) -> (x, z, -y)
    point_world_original = np.array(point_3d)
    point_world = np.array([
        point_world_original[0],   # X stays X
        point_world_original[2],   # new Y = original Z
        -point_world_original[1]   # new Z = -original Y
    ])
    
    # Also transform scene center
    scene_center_original = np.array(scene_center)
    scene_center_transformed = np.array([
        scene_center_original[0],
        scene_center_original[2],
        -scene_center_original[1]
    ])
    
    # Camera direction (same as blender_renderer.py)
    if view_mode == "diagonal":
        cam_dir = np.array([1.0, 1.0, 1.0])
    else:  # diagonal2
        cam_dir = np.array([-1.0, -1.0, 1.0])
    cam_dir = cam_dir / np.linalg.norm(cam_dir)
    
    # Camera position (matching blender_renderer.py line 295)
    distance = scene_radius * max(1.0, diagonal_distance * camera_factor * 1.5)
    eye = scene_center_transformed + cam_dir * distance
    
    # Look target with height offset (matching blender_renderer.py line 298-305)
    look_target = scene_center_transformed.copy()
    z_offset = scene_radius * diagonal_height_offset
    eye[2] -= z_offset
    look_target[2] -= z_offset
    
    # Look direction (from camera to look target)
    look_dir = look_target - eye
    look_dir = look_dir / np.linalg.norm(look_dir)
    
    # Build camera coordinate system
    world_up = np.array([0.0, 0.0, 1.0])
    right = np.cross(look_dir, world_up)
    if np.linalg.norm(right) < 1e-6:
        right = np.array([1.0, 0.0, 0.0])
    right = right / np.linalg.norm(right)
    up = np.cross(right, look_dir)
    up = up / np.linalg.norm(up)
    
    # Transform point to camera space (use transformed point)
    point_cam = point_world - eye
    
    # Project to camera coordinates
    x_cam = np.dot(point_cam, right)
    y_cam = np.dot(point_cam, up)
    z_cam = np.dot(point_cam, look_dir)
    
    # Check if behind camera
    if z_cam <= 0.1:
        return None
    
    # Perspective projection (FOV based on lens=35mm)
    # For 35mm lens, approximate FOV ~54 degrees
    fov = math.radians(54.0)
    f = img_height / (2.0 * math.tan(fov / 2.0))
    
    x_2d = (x_cam / z_cam) * f + img_width / 2.0
    y_2d = img_height / 2.0 - (y_cam / z_cam) * f  # Flip Y for image coordinates
    
    return (x_2d, y_2d)


def add_zone_labels_to_image(image_path: str, zones_info: List[Dict], scene_bounds: Dict, 
                            output_path: str = None, view_mode: str = "diagonal"):
    """
    Add zone labels as text overlays on a rendered image, positioned above each zone's bbox.
    
    Args:
        image_path: Path to input image
        zones_info: List of zone info dicts with zone_id, semantic_label, color, bbox
        scene_bounds: Dict with 'center' and 'radius' for camera projection
        output_path: Path to save annotated image (default: overwrite input)
        view_mode: Camera view mode (diagonal, diagonal2, etc.)
    """
    try:
        from PIL import Image, ImageDraw, ImageFont
    except ImportError:
        print("  Warning: PIL not available, skipping label annotation")
        return False
    
    if zones_info is None or len(zones_info) == 0:
        return False
    
    if output_path is None:
        output_path = image_path
    
    # Open image
    img = Image.open(image_path)
    draw = ImageDraw.Draw(img)
    img_width, img_height = img.size
    
    # Load Times New Roman font
    try:
        font_size = 28
        # Try common paths for Times New Roman
        font_paths = [
            "/usr/share/fonts/truetype/msttcorefonts/Times_New_Roman.ttf",
            "/usr/share/fonts/truetype/liberation/LiberationSerif-Bold.ttf",  # Free alternative
            "/System/Library/Fonts/Times New Roman.ttf",  # macOS
            "C:/Windows/Fonts/times.ttf",  # Windows
        ]
        font = None
        for path in font_paths:
            try:
                font = ImageFont.truetype(path, font_size)
                break
            except:
                continue
        if font is None:
            # Fallback to DejaVu Serif
            font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSerif-Bold.ttf", font_size)
    except:
        font = ImageFont.load_default()
    
    # Get scene center and radius for projection
    scene_center = scene_bounds['center']
    scene_radius = scene_bounds['radius']
    
    # For each zone, calculate bbox top center and project to 2D
    for zone in zones_info:
        semantic_label = zone['semantic_label']
        color = zone['color']
        bbox = zone['bbox']
        
        # Calculate bbox top center (x_center, y_center, z_max)
        x_center = (bbox['min'][0] + bbox['max'][0]) / 2.0
        y_center = (bbox['min'][1] + bbox['max'][1]) / 2.0
        z_top = bbox['max'][2]  # Top of the bbox
        
        # Project to 2D
        point_3d = (x_center, y_center, z_top)
        projected = project_3d_to_2d_diagonal(
            point_3d, scene_center, scene_radius,
            img_width, img_height, view_mode=view_mode
        )
        
        if projected is None:
            continue  # Skip if behind camera
        
        x_2d, y_2d = projected
        
        # Convert color to RGB (0-255)
        rgb_color = tuple(int(c * 255) for c in color)
        
        # Create label text
        label_text = f"{semantic_label}"
        
        # Get text bounding box
        bbox_text = draw.textbbox((0, 0), label_text, font=font)
        text_width = bbox_text[2] - bbox_text[0]
        text_height = bbox_text[3] - bbox_text[1]
        
        # Position label above the bbox top (centered horizontally)
        text_x = x_2d - text_width / 2.0
        text_y = y_2d - text_height - 10  # 10px above the point
        
        # Clamp to image bounds
        text_x = max(5, min(text_x, img_width - text_width - 5))
        text_y = max(5, min(text_y, img_height - text_height - 5))
        
        # Draw semi-transparent colored background
        bg_padding = 8
        bg_coords = [
            text_x - bg_padding, 
            text_y - bg_padding,
            text_x + text_width + bg_padding,
            text_y + text_height + bg_padding
        ]
        # Draw background with zone color at 60% opacity
        draw.rectangle(bg_coords, fill=rgb_color + (153,), outline=(0, 0, 0, 255), width=2)
        
        # Draw text in white for contrast
        draw.text((text_x, text_y), label_text, fill=(255, 255, 255), font=font)
    
    # Save annotated image
    img.save(output_path)
    return True


def run_command(cmd, env=None, quiet=False):
    """Run a shell command."""
    print(f"  Running: {cmd[:100]}...")
    try:
        if quiet:
            subprocess.check_call(cmd, shell=True, env=env,
                                  stdout=subprocess.DEVNULL,
                                  stderr=subprocess.DEVNULL)
        else:
            subprocess.check_call(cmd, shell=True, env=env)
        return True
    except subprocess.CalledProcessError as e:
        print(f"  Command failed: {e}")
        return False


def visualize_zones(
    layout_path: str,
    output_dir: str,
    render_diagonal: bool = True,
    render_diagonal2: bool = True,
    render_topdown: bool = True,
    use_retrieval: bool = True,
    show_labels: bool = True,
    # Zone bbox visualization parameters
    face_alpha: float = 0.25,
    edge_alpha: float = 0.8,
    edge_radius: float = 0.015,
    render_faces: bool = True,
    render_edges: bool = True,
):
    """
    Main function to visualize functional zones in a layout.
    
    Args:
        layout_path: Path to layout.json file
        output_dir: Directory to save outputs
        render_diagonal: Whether to render diagonal view (front-left)
        render_diagonal2: Whether to render opposite diagonal view (back-right)
        render_topdown: Whether to render top-down view
        use_retrieval: Whether to run asset retrieval (requires embedding manager)
        show_labels: Whether to add semantic label text overlays on rendered images
        face_alpha: Alpha value for zone bbox faces (0.0-1.0, default 0.25 for high transparency)
        edge_alpha: Alpha value for zone bbox edges (0.0-1.0, default 0.8)
        edge_radius: Radius of edge cylinders in meters (default 0.015)
        render_faces: Whether to render transparent box faces (default True)
        render_edges: Whether to render wireframe edges (default True)
    """
    print(f"\n=== Visualizing Zones for: {layout_path} ===")
    
    # Load layout
    with open(layout_path, 'r') as f:
        layout = json.load(f)
    
    # Create output directory
    os.makedirs(output_dir, exist_ok=True)
    
    # Compute zone bounding boxes
    print("\nComputing zone bounding boxes...")
    zones_info = compute_all_zone_bboxes(layout)
    
    # Get scene bounds for clamping bbox visualization
    scene_bounds = get_scene_bounds(layout)
    
    for zone in zones_info:
        bbox = zone['bbox']
        print(f"  {zone['zone_id']} ({zone['semantic_label']}): "
              f"{zone['asset_count']} assets, "
              f"size={bbox['size'][0]:.2f}x{bbox['size'][1]:.2f}x{bbox['size'][2]:.2f}")
    
    # Save zone info
    zones_info_path = os.path.join(output_dir, "zones_info.json")
    with open(zones_info_path, 'w') as f:
        json.dump(zones_info, f, indent=2)
    print(f"\nSaved zones info to: {zones_info_path}")
    
    # Create zone bbox GLB (pass scene_bounds to clamp padding)
    zone_bbox_glb_path = os.path.join(output_dir, "zone_bboxes.glb")
    create_zone_bbox_glb(
        zones_info, 
        zone_bbox_glb_path, 
        scene_bounds=scene_bounds,
        face_alpha=face_alpha,
        edge_alpha=edge_alpha,
        edge_radius=edge_radius,
        render_faces=render_faces,
        render_edges=render_edges,
    )
    
    # Optionally run retrieval and compose scene
    scene_glb_path = os.path.join(output_dir, "scene.glb")
    
    if use_retrieval:
        print("\nRunning asset retrieval and scene composition...")
        from tools.asset_description.asset_embedding_manager import AssetEmbeddingManager
        from tools.asset_description.asset_finder import AssetFinder
        from tools.data_gen.layout_retrieval import process_layout
        from tools.data_gen.compose_generated import compose_scene
        
        asset_library_dir = os.path.join(REPO_ROOT, "data/asset_library")
        embeddings_file = os.path.join(REPO_ROOT, "tools/asset_embeddings.pkl")
        
        embedding_manager = AssetEmbeddingManager(embeddings_file=embeddings_file)
        asset_finder = AssetFinder(asset_library_dir)
        
        retrieved_layout = process_layout(layout, embedding_manager, asset_finder)
        
        retrieved_path = os.path.join(output_dir, "layout_retrieved.json")
        with open(retrieved_path, 'w') as f:
            json.dump(retrieved_layout, f, indent=4)
        
        compose_scene(
            layout=retrieved_layout,
            output_path=scene_glb_path,
            add_walls=False,
            add_ceiling=False
        )
    else:
        print("\nSkipping retrieval (use_retrieval=False)")
        # Check if scene.glb already exists
        if not os.path.exists(scene_glb_path):
            print(f"  Warning: {scene_glb_path} does not exist. Cannot render without scene.")
            return zones_info
    
    # Merge scene.glb with zone_bboxes.glb
    print("\nMerging scene with zone bboxes...")
    merged_glb_path = os.path.join(output_dir, "scene_with_zones.glb")
    
    try:
        import trimesh
        
        # Load scene
        scene_mesh = trimesh.load(scene_glb_path)
        
        # Load zone bboxes
        if os.path.exists(zone_bbox_glb_path):
            zone_mesh = trimesh.load(zone_bbox_glb_path)
            
            # Merge
            if isinstance(scene_mesh, trimesh.Scene):
                if isinstance(zone_mesh, trimesh.Scene):
                    for name, geom in zone_mesh.geometry.items():
                        scene_mesh.add_geometry(geom, node_name=f"zone_bbox_{name}")
                else:
                    scene_mesh.add_geometry(zone_mesh, node_name="zone_bboxes")
            else:
                # Convert to scene
                scene = trimesh.Scene()
                scene.add_geometry(scene_mesh, node_name="scene")
                if isinstance(zone_mesh, trimesh.Scene):
                    for name, geom in zone_mesh.geometry.items():
                        scene.add_geometry(geom, node_name=f"zone_bbox_{name}")
                else:
                    scene.add_geometry(zone_mesh, node_name="zone_bboxes")
                scene_mesh = scene
            
            scene_mesh.export(merged_glb_path)
            print(f"  Created merged GLB: {merged_glb_path}")
        else:
            # Just copy scene
            shutil.copy(scene_glb_path, merged_glb_path)
    except Exception as e:
        print(f"  Warning: Could not merge GLBs: {e}")
        merged_glb_path = scene_glb_path
    
    # Render
    current_env = os.environ.copy()
    
    # Calculate scene center and radius for 3D->2D projection
    import numpy as np
    scene_min = np.array(scene_bounds['min'])
    scene_max = np.array(scene_bounds['max'])
    scene_center_arr = (scene_min + scene_max) / 2.0
    scene_radius = np.linalg.norm(scene_max - scene_min) / 2.0
    scene_bounds_for_projection = {
        'center': scene_center_arr.tolist(),
        'radius': float(scene_radius)
    }
    
    if render_diagonal:
        print("\nRendering diagonal view (front-left)...")
        render_path = os.path.join(output_dir, "render_diagonal.png")
        cmd = (
            f"conda run -n blender python InternScenes/InternScenes_Real2Sim/blender_renderer.py "
            f"--input '{merged_glb_path}' "
            f"--output '{render_path}' "
            f"--width 1600 --height 900 "
            f"--engine BLENDER_EEVEE --samples 64 "
            f"--view-mode diagonal --auto-crop "
            f"--floor-material ceramic_tile"
        )
        run_command(cmd, env=current_env, quiet=True)
        # Add zone labels as text overlays
        if show_labels:
            add_zone_labels_to_image(render_path, zones_info, scene_bounds_for_projection, view_mode="diagonal")
    
    if render_diagonal2:
        print("\nRendering diagonal view (back-right)...")
        render_path = os.path.join(output_dir, "render_diagonal2.png")
        cmd = (
            f"conda run -n blender python InternScenes/InternScenes_Real2Sim/blender_renderer.py "
            f"--input '{merged_glb_path}' "
            f"--output '{render_path}' "
            f"--width 1600 --height 900 "
            f"--engine BLENDER_EEVEE --samples 64 "
            f"--view-mode diagonal2 --auto-crop "
            f"--floor-material concrete"
        )
        run_command(cmd, env=current_env, quiet=True)
        # Add zone labels as text overlays
        if show_labels:
            add_zone_labels_to_image(render_path, zones_info, scene_bounds_for_projection, view_mode="diagonal2")
    
    if render_topdown:
        print("\nRendering top-down view...")
        render_path = os.path.join(output_dir, "render_topdown.png")
        cmd = (
            f"conda run -n blender python InternScenes/InternScenes_Real2Sim/blender_renderer.py "
            f"--input '{merged_glb_path}' "
            f"--output '{render_path}' "
            f"--width 1600 --height 900 "
            f"--engine BLENDER_EEVEE --samples 64 "
            f"--view-mode topdown --auto-crop "
            f"--floor-material ceramic_tile"
        )
        run_command(cmd, env=current_env, quiet=True)
        # Note: topdown uses orthographic projection, 2D label positioning needs different logic
        # For now, diagonal views are the main focus
    
    print(f"\n=== Done! Outputs saved to: {output_dir} ===")
    
    # Print legend
    print("\n=== Zone Color Legend ===")
    for zone in zones_info:
        color = zone['color']
        color_str = f"RGB({int(color[0]*255)}, {int(color[1]*255)}, {int(color[2]*255)})"
        print(f"  {zone['zone_id']}: {zone['semantic_label']} - {color_str}")
    
    return zones_info


def main():
    parser = argparse.ArgumentParser(description="Visualize functional zones in a 3D scene layout")
    parser.add_argument("--input", default="/home/v-meiszhang/backup/datas/unified-layout-aligned/scannet/scene0024_00/layout.json", help="Path to layout.json file")
    parser.add_argument("--output", default="zone_vis_output", help="Output directory")
    parser.add_argument("--no-retrieval", action="store_true", help="Skip asset retrieval (use existing scene.glb)")
    parser.add_argument("--no-diagonal", action="store_true", help="Skip diagonal view rendering (front-left)")
    parser.add_argument("--no-diagonal2", action="store_true", help="Skip diagonal2 view rendering (back-right)")
    parser.add_argument("--no-topdown", action="store_true", help="Skip top-down view rendering")
    parser.add_argument("--no-labels", dest="show_labels", action="store_false", default=True,
                        help="Don't add semantic label text overlays on rendered images")
    # Zone bbox visualization options
    parser.add_argument("--face-alpha", type=float, default=0.25,
                        help="Alpha value for zone bbox faces (0.0-1.0, default 0.25)")
    parser.add_argument("--edge-alpha", type=float, default=0.8,
                        help="Alpha value for zone bbox edges (0.0-1.0, default 0.8)")
    parser.add_argument("--edge-radius", type=float, default=0.015,
                        help="Radius of edge cylinders in meters (default 0.015)")
    parser.add_argument("--no-faces", dest="render_faces", action="store_false", default=True,
                        help="Don't render transparent box faces (wireframe only)")
    parser.add_argument("--no-edges", dest="render_edges", action="store_false", default=True,
                        help="Don't render wireframe edges (faces only)")
    
    args = parser.parse_args()
    
    visualize_zones(
        layout_path=args.input,
        output_dir=args.output,
        render_diagonal=not args.no_diagonal,
        render_diagonal2=not args.no_diagonal2,
        render_topdown=not args.no_topdown,
        use_retrieval=not args.no_retrieval,
        show_labels=args.show_labels,
        face_alpha=args.face_alpha,
        edge_alpha=args.edge_alpha,
        edge_radius=args.edge_radius,
        render_faces=args.render_faces,
        render_edges=args.render_edges,
    )


if __name__ == "__main__":
    main()