tools/utils/render_top2_largest.py

"""
Render the N largest assets from a scene layout (default N=2).
"""

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

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


def get_asset_volume(asset: Dict) -> float:
    """Calculate the volume of an asset from its size."""
    size = asset.get('size', [1, 1, 1])
    if len(size) >= 3:
        return size[0] * size[1] * size[2]
    return 0.0


def get_all_assets(layout: Dict) -> List[Dict]:
    """Extract all assets from layout (supports both flat and zone-based formats)."""
    all_assets = []
    
    # Check for flat assets list
    if 'assets' in layout:
        all_assets.extend(layout['assets'])
    
    # Check for functional_zones format
    if 'functional_zones' in layout:
        for zone in layout['functional_zones']:
            if 'assets' in zone:
                all_assets.extend(zone['assets'])
    
    return all_assets


def find_top_n_largest(layout: Dict, n: int = 2) -> List[Dict]:
    """Find the N largest assets by volume."""
    all_assets = get_all_assets(layout)
    
    # Calculate volume for each asset
    assets_with_volume = []
    for asset in all_assets:
        volume = get_asset_volume(asset)
        assets_with_volume.append({
            'asset': asset,
            'volume': volume
        })
    
    # Sort by volume (descending)
    assets_with_volume.sort(key=lambda x: x['volume'], reverse=True)
    
    # Return top N
    return [item['asset'] for item in assets_with_volume[:n]]


def compose_assets_scene(assets: List[Dict], output_path: str):
    """Compose a scene with only the specified assets."""
    from tools.data_gen.compose_generated import compose_scene
    
    # Create a minimal layout with just these assets
    layout = {
        "meta": {"scene_type": "asset_vis"},
        "architecture": {"boundary_polygon": []},
        "assets": assets
    }
    
    compose_scene(
        layout=layout,
        output_path=output_path,
        add_floor=False,
        add_walls=False,
        add_ceiling=False,
    )
    print(f"  Composed scene: {output_path}")


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 render_scene(glb_path: str, output_path: str, view_mode: str = "diagonal",
                 width: int = 1200, height: int = 900):
    """Render a GLB scene using Blender."""
    current_env = os.environ.copy()
    
    cmd = (
        f"conda run -n blender python InternScenes/InternScenes_Real2Sim/blender_renderer.py "
        f"--input '{glb_path}' "
        f"--output '{output_path}' "
        f"--width {width} --height {height} "
        f"--engine BLENDER_EEVEE --samples 64 "
        f"--view-mode {view_mode} --auto-crop "
        f"--floor-material solid "
        f"--diagonal-distance 3.0 "
        f"--camera-factor 2.0 "
    )
    
    run_command(cmd, env=current_env, quiet=True)


def render_top_n_largest(
    layout_path: str,
    output_dir: str,
    n: int = 2,
    render_views: List[str] = None,
):
    """Main function to render the N largest assets from a layout."""
    if render_views is None:
        render_views = ["side_front"]
    
    print(f"\n{'='*60}")
    print(f"Render Top {n} Largest Assets")
    print(f"{'='*60}")
    print(f"Input: {layout_path}")
    print(f"Output: {output_dir}")
    print(f"{'='*60}\n")
    
    # Load layout
    with open(layout_path, 'r') as f:
        layout = json.load(f)
    
    # Create output directory
    os.makedirs(output_dir, exist_ok=True)
    
    # Find top N largest assets
    print(f"Finding the {n} largest assets by volume...")
    top_assets = find_top_n_largest(layout, n=n)
    
    if len(top_assets) < n:
        print(f"Warning: Only found {len(top_assets)} asset(s)!")
    
    print(f"\nTop {n} largest assets:")
    for i, asset in enumerate(top_assets):
        volume = get_asset_volume(asset)
        category = asset.get('category', 'unknown')
        size = asset.get('size', [0, 0, 0])
        model_uid = asset.get('model_uid', asset.get('uid', 'unknown'))[:40]
        print(f"  {i+1}. {category}")
        print(f"     Size: {size[0]:.2f} x {size[1]:.2f} x {size[2]:.2f}")
        print(f"     Volume: {volume:.3f}")
        print(f"     Model: {model_uid}...")
    
    if not top_assets:
        print("No assets found in this layout!")
        return
    
    print(f"\nRendering {len(top_assets)} asset(s) separately...")
    
    # Create temporary directory for intermediate files
    with tempfile.TemporaryDirectory() as tmpdir:
        # Render each asset separately
        for idx, asset in enumerate(top_assets):
            category = asset.get('category', 'unknown')
            print(f"\n--- Rendering asset {idx+1}: {category} ---")
            
            # Compose scene with single asset
            scene_glb = os.path.join(tmpdir, f"asset_{idx+1}.glb")
            compose_assets_scene([asset], scene_glb)
            
            # Render from different views
            for view in render_views:
                print(f"  Rendering {view} view...")
                output_img = os.path.join(output_dir, f"asset{idx+1}_{category}_{view}.png")
                render_scene(scene_glb, output_img, view_mode=view)
                
                if os.path.exists(output_img):
                    print(f"    Saved: {output_img}")
    
    # Save asset info
    info_path = os.path.join(output_dir, "asset_info.json")
    info = {
        'top_assets': [
            {
                'category': a.get('category'),
                'model_uid': a.get('model_uid', a.get('uid')),
                'size': a.get('size'),
                'volume': get_asset_volume(a),
                'pos': a.get('pos'),
            }
            for a in top_assets
        ]
    }
    with open(info_path, 'w') as f:
        json.dump(info, f, indent=2)
    
    print(f"\n{'='*60}")
    print(f"Done! Outputs saved to {output_dir}")
    print(f"{'='*60}\n")


def main():
    parser = argparse.ArgumentParser(description='Render the N largest assets from a scene layout')
    parser.add_argument('--input', default="/home/v-meiszhang/amlt-project/InternScenes/test_vis_output2/scannet_scene0368_01_coarse/layout_retrieved.json", help='Path to layout JSON file')
    parser.add_argument('--output', default='top_n_output', help='Output directory')
    parser.add_argument('-n', '--num', type=int, default=48, help='Number of assets to render (default: 2)')
    parser.add_argument('--all-views', default=True, help='Render from all standard views')
    
    args = parser.parse_args()
    
    views = ["side_front"]  # Use side_front for front view
    if args.all_views:
        views = ["side_front", "diagonal", "diagonal2", "topdown"]
    
    render_top_n_largest(
        layout_path=args.input,
        output_dir=args.output,
        n=args.num,
        render_views=views,
    )


if __name__ == "__main__":
    main()