pipelines/run_hm3d_pipeline.py

#!/usr/bin/env python3
"""
Blend 全流程 Pipeline v5（单 Blender 进程）

v3 → v4 改进:
  - Phase 0+1+2 全部在一个 Blender 进程内完成
  - 不再导出 GLB（用 Blender scene.ray_cast 替代 trimesh）
  - 不再每帧重启 Blender（同进程内移动相机 + 渲染）
  - 去掉 trimesh 外部依赖

v5 → v6 改进:
  - 新增 GLB/GLTF 格式支持（--glb 参数）
  - --blend / --glb 二选一，支持 .blend .glb .gltf 三种格式
  - GLB 导入后与 .blend 流程完全统一

对外接口 100% 兼容 v3/v5:
  - 命令行参数完全一致（新增 --glb 为可选补充）
  - 输出文件名完全一致（panorama_XXXX.png / _depth.npy / pose_XXXX.json）
  - run_full_pipeline.py 零改动

双模式运行:
  1) python run_blend_pipeline.py --blender X --blend Y ...
     python run_blend_pipeline.py --blender X --glb Y ...
     → 检测到 --blender → 启动 blender --python THIS_FILE -- --blend/--glb Y ...
  2) Blender 内部自动进入 in-process 模式
     → Phase 0 (边界) + Phase 1 (撒点+过滤) + Phase 2 (边渲边选)
"""

# =====================================================================
# 检测运行环境
# =====================================================================
try:
    import bpy
    from mathutils import Vector, Euler, Matrix
    IN_BLENDER = True
except ImportError:
    IN_BLENDER = False

import argparse
import json
import math
import os
import subprocess
import sys
import time
import random as _random
from pathlib import Path

import numpy as np


# =====================================================================
# 常量
# =====================================================================

WARP_H = 128
WARP_W = 256
MARGIN = 0.5  # 距墙最小安全距离（防穿模）

DEFAULT_STOP_GAIN = 0.08
DEFAULT_OVERLAP_PENALTY = 0.5
DEFAULT_MIN_DIST = 0.6
DEFAULT_MIN_FRAMES = 5

ROTATION_TYPES = {
    "none":         [0.0, 0.0, 0.0],
    "rotate_x_90":  [math.pi / 2, 0.0, 0.0],
    "rotate_x_180": [math.pi, 0.0, 0.0],
    "rotate_z_90":  [0.0, 0.0, math.pi / 2],
}


def get_camera_rot(rotation_type: str, frame_id: int):
    if rotation_type == "random_yaw":
        yaw = 0.0 if frame_id == 0 else _random.uniform(0, 2 * math.pi)
        return [math.pi / 2, 0.0, yaw]
    return list(ROTATION_TYPES[rotation_type])


#######################################################################
# 渲染设置
#######################################################################
def is_room_structure(obj_name):
    """
    判断对象是否是房间结构（墙面、地板、天花板）
    
    房间结构的常见命名模式：
    1. None.obj - 标准3D-Front房间结构
    2. geometry_N - 无纹理的通用几何体
    3. 纯数字.obj (如 12670.obj) - 数字ID命名的结构
    """
    name_lower = obj_name.lower()
    
    # 模式1: 包含 "none"
    if 'none' in name_lower:
        return True
    
    # 模式2: 以 "geometry_" 开头
    if name_lower.startswith('geometry_') or name_lower.startswith('geometry.'):
        return True
    
    # 模式3: 纯数字命名 (如 "12670.obj", "7319.obj")
    base_name = obj_name.replace('.obj', '').replace('.OBJ', '')
    if base_name.isdigit():
        return True
    
    return False


def create_wood_floor_material(nodes, links):
    """创建木地板程序化材质（Emission模式，显示原始颜色）"""
    # 使用Emission材质，直接发光，不受光照影响
    emission = nodes.new('ShaderNodeEmission')
    emission.name = "FloorEmission"
    
    # 木纹噪波纹理
    noise = nodes.new('ShaderNodeTexNoise')
    noise.inputs['Scale'].default_value = 20.0
    noise.inputs['Detail'].default_value = 8.0
    noise.inputs['Roughness'].default_value = 0.6
    noise.location = (-600, 200)
    
    # 波浪纹理（模拟木纹条纹）
    wave = nodes.new('ShaderNodeTexWave')
    wave.wave_type = 'BANDS'
    wave.bands_direction = 'X'
    wave.inputs['Scale'].default_value = 3.0
    wave.inputs['Distortion'].default_value = 5.0
    wave.inputs['Detail'].default_value = 3.0
    wave.location = (-600, 0)
    
    # 颜色渐变（木材颜色）
    color_ramp = nodes.new('ShaderNodeValToRGB')
    color_ramp.color_ramp.elements[0].color = (0.15, 0.08, 0.04, 1.0)  # 深棕色
    color_ramp.color_ramp.elements[1].color = (0.35, 0.20, 0.10, 1.0)  # 浅棕色
    color_ramp.location = (-400, 100)
    
    # 混合噪波和波浪
    mix_rgb = nodes.new('ShaderNodeMix')
    mix_rgb.data_type = 'RGBA'
    mix_rgb.inputs['Factor'].default_value = 0.5
    mix_rgb.location = (-400, 0)
    
    links.new(noise.outputs['Fac'], mix_rgb.inputs['A'])
    links.new(wave.outputs['Fac'], mix_rgb.inputs['B'])
    links.new(mix_rgb.outputs['Result'], color_ramp.inputs['Fac'])
    
    # 连接到Emission材质（直接显示颜色，不受光照影响）
    links.new(color_ramp.outputs['Color'], emission.inputs['Color'])
    emission.inputs['Strength'].default_value = 1.0  # Emission强度（材质预览模式，避免过曝）
    
    return emission


def create_brick_wall_material(nodes, links):
    """创建砖墙程序化材质（Emission模式，显示原始颜色）"""
    # 使用Emission材质，直接发光，不受光照影响
    emission = nodes.new('ShaderNodeEmission')
    emission.name = "BrickWallEmission"
    
    # 使用纹理坐标
    tex_coord = nodes.new('ShaderNodeTexCoord')
    tex_coord.location = (-800, 0)
    
    # 缩放映射（控制砖块大小）
    mapping = nodes.new('ShaderNodeMapping')
    mapping.inputs['Scale'].default_value = (4.0, 8.0, 1.0)  # X方向砖块较宽
    mapping.location = (-600, 0)
    links.new(tex_coord.outputs['Generated'], mapping.inputs['Vector'])
    
    # 砖块纹理
    brick = nodes.new('ShaderNodeTexBrick')
    brick.inputs['Color1'].default_value = (0.6, 0.3, 0.2, 1.0)  # 砖红色
    brick.inputs['Color2'].default_value = (0.5, 0.25, 0.15, 1.0)  # 深砖红色
    brick.inputs['Mortar'].default_value = (0.85, 0.85, 0.8, 1.0)  # 灰白色砂浆
    brick.inputs['Scale'].default_value = 3.0
    brick.inputs['Mortar Size'].default_value = 0.02
    brick.inputs['Mortar Smooth'].default_value = 0.1
    brick.inputs['Bias'].default_value = 0.0
    brick.inputs['Brick Width'].default_value = 0.5
    brick.inputs['Row Height'].default_value = 0.25
    brick.location = (-400, 0)
    links.new(mapping.outputs['Vector'], brick.inputs['Vector'])
    
    # 添加细微噪波增加真实感
    noise = nodes.new('ShaderNodeTexNoise')
    noise.inputs['Scale'].default_value = 50.0
    noise.inputs['Detail'].default_value = 3.0
    noise.location = (-400, -200)
    links.new(mapping.outputs['Vector'], noise.inputs['Vector'])
    
    # 混合砖块颜色和噪波
    mix_color = nodes.new('ShaderNodeMix')
    mix_color.data_type = 'RGBA'
    mix_color.inputs['Factor'].default_value = 0.1
    mix_color.location = (-200, 0)
    links.new(brick.outputs['Color'], mix_color.inputs['A'])
    links.new(noise.outputs['Color'], mix_color.inputs['B'])
    
    # 连接到Emission材质（直接显示颜色，不受光照影响）
    links.new(mix_color.outputs['Result'], emission.inputs['Color'])
    emission.inputs['Strength'].default_value = 2.0  # Emission强度（材质预览模式，避免过曝）
    
    return emission


def create_grid_ceiling_material(nodes, links):
    """创建网格天花板程序化材质（Emission模式，显示原始颜色）"""
    # 使用Emission材质，直接发光，不受光照影响
    emission = nodes.new('ShaderNodeEmission')
    emission.name = "GridCeilingEmission"
    
    # 使用纹理坐标
    tex_coord = nodes.new('ShaderNodeTexCoord')
    tex_coord.location = (-800, -400)
    
    # 缩放映射
    mapping = nodes.new('ShaderNodeMapping')
    mapping.inputs['Scale'].default_value = (5.0, 5.0, 1.0)
    mapping.location = (-600, -400)
    links.new(tex_coord.outputs['Generated'], mapping.inputs['Vector'])
    
    # 分离XY坐标
    separate = nodes.new('ShaderNodeSeparateXYZ')
    separate.location = (-400, -400)
    links.new(mapping.outputs['Vector'], separate.inputs['Vector'])
    
    # X方向网格线（使用正弦波）
    math_sin_x = nodes.new('ShaderNodeMath')
    math_sin_x.operation = 'SINE'
    math_sin_x.location = (-200, -350)
    
    math_mul_x = nodes.new('ShaderNodeMath')
    math_mul_x.operation = 'MULTIPLY'
    math_mul_x.inputs[1].default_value = 6.28  # 2*PI
    math_mul_x.location = (-300, -350)
    links.new(separate.outputs['X'], math_mul_x.inputs[0])
    links.new(math_mul_x.outputs['Value'], math_sin_x.inputs[0])
    
    # Y方向网格线
    math_sin_y = nodes.new('ShaderNodeMath')
    math_sin_y.operation = 'SINE'
    math_sin_y.location = (-200, -500)
    
    math_mul_y = nodes.new('ShaderNodeMath')
    math_mul_y.operation = 'MULTIPLY'
    math_mul_y.inputs[1].default_value = 6.28
    math_mul_y.location = (-300, -500)
    links.new(separate.outputs['Y'], math_mul_y.inputs[0])
    links.new(math_mul_y.outputs['Value'], math_sin_y.inputs[0])
    
    # 取绝对值使线条清晰
    abs_x = nodes.new('ShaderNodeMath')
    abs_x.operation = 'ABSOLUTE'
    abs_x.location = (-100, -350)
    links.new(math_sin_x.outputs['Value'], abs_x.inputs[0])
    
    abs_y = nodes.new('ShaderNodeMath')
    abs_y.operation = 'ABSOLUTE'
    abs_y.location = (-100, -500)
    links.new(math_sin_y.outputs['Value'], abs_y.inputs[0])
    
    # 合并X和Y网格（取最小值形成网格交叉）
    math_min = nodes.new('ShaderNodeMath')
    math_min.operation = 'MINIMUM'
    math_min.location = (0, -425)
    links.new(abs_x.outputs['Value'], math_min.inputs[0])
    links.new(abs_y.outputs['Value'], math_min.inputs[1])
    
    # 颜色渐变：网格线深色，格子浅色
    color_ramp = nodes.new('ShaderNodeValToRGB')
    color_ramp.color_ramp.elements[0].color = (0.3, 0.3, 0.35, 1.0)  # 深灰色网格线
    color_ramp.color_ramp.elements[0].position = 0.0
    color_ramp.color_ramp.elements[1].color = (0.95, 0.95, 0.95, 1.0)  # 白色格子
    color_ramp.color_ramp.elements[1].position = 0.15
    color_ramp.location = (150, -425)
    links.new(math_min.outputs['Value'], color_ramp.inputs['Fac'])
    
    # 连接到Emission材质（直接显示颜色，不受光照影响）
    links.new(color_ramp.outputs['Color'], emission.inputs['Color'])
    emission.inputs['Strength'].default_value = 2.0  # Emission强度（材质预览模式，避免过曝）
    
    return emission


def convert_to_emission_material(obj):
    """将现有材质转换为Emission材质（材质预览模式）"""
    if not obj.data.materials or len(obj.data.materials) == 0:
        # 如果没有材质，直接应用房间材质
        apply_room_material(obj)
        return
    
    # 获取现有材质
    existing_mat = obj.data.materials[0]
    if existing_mat is None:
        apply_room_material(obj)
        return
    
    # 如果材质已经有节点，尝试提取Base Color并转换为Emission
    if existing_mat.use_nodes:
        nodes = existing_mat.node_tree.nodes
        links = existing_mat.node_tree.links
        
        # 查找Principled BSDF节点
        bsdf_node = None
        for node in nodes:
            if node.type == 'BSDF_PRINCIPLED':
                bsdf_node = node
                break
        
        if bsdf_node and 'Base Color' in bsdf_node.inputs:
            # 找到Base Color输入
            base_color_input = bsdf_node.inputs['Base Color']
            
            # 创建Emission节点
            emission = nodes.new('ShaderNodeEmission')
            emission.name = "Emission"
            emission.location = bsdf_node.location
            
            # 获取Base Color的值或连接
            if base_color_input.is_linked:
                # 如果有连接，连接到Emission
                color_source = base_color_input.links[0].from_node
                color_output = base_color_input.links[0].from_socket
                links.new(color_output, emission.inputs['Color'])
            else:
                # 如果没有连接，使用默认值
                emission.inputs['Color'].default_value = base_color_input.default_value
            
            emission.inputs['Strength'].default_value = 1.0  # Emission强度（材质预览模式，避免过曝）
            
            # 找到输出节点并连接
            output_node = None
            for node in nodes:
                if node.type == 'OUTPUT_MATERIAL':
                    output_node = node
                    break
            
            if output_node:
                # 断开原有连接
                if output_node.inputs['Surface'].is_linked:
                    for link in output_node.inputs['Surface'].links:
                        existing_mat.node_tree.links.remove(link)
                # 连接Emission
                links.new(emission.outputs['Emission'], output_node.inputs['Surface'])
                print(f"[INFO] 已将材质转换为Emission: {obj.name}")
                return
    
    # 如果无法转换，直接应用房间材质
    apply_room_material(obj)


def apply_procedural_textures(objects):
    """为所有对象添加Emission材质（材质预览模式：显示原始颜色，不受光照影响）"""
    applied_count = 0
    for obj in objects:
        if obj.type != 'MESH':
            continue
        
        # 检查对象是否有材质，或者材质是否为空
        has_material = obj.data.materials and len(obj.data.materials) > 0 and obj.data.materials[0] is not None
        
        # 为所有对象应用Emission材质（材质预览模式）
        # 这样所有对象都会显示原始颜色，不受光照影响
        if not has_material or is_room_structure(obj.name):
            # 没有材质或者是房间结构：应用Emission材质
            print(f"[INFO] 为对象添加Emission材质: {obj.name}")
            apply_room_material(obj)
            applied_count += 1
        else:
            # 有材质：也转换为Emission材质（确保所有对象都使用Emission模式）
            print(f"[INFO] 将对象材质转换为Emission: {obj.name}")
            convert_to_emission_material(obj)
            applied_count += 1
    
    if applied_count == 0:
        print("[WARN] 未找到需要添加材质的对象")
    else:
        print(f"[INFO] 共为 {applied_count} 个对象添加了Emission材质（材质预览模式）")


def apply_room_material(obj):
    """为房间结构应用程序化材质（墙面、地板、天花板）"""
    # 创建新材质
    mat = bpy.data.materials.new(name="RoomProceduralMaterial")
    mat.use_nodes = True
    
    nodes = mat.node_tree.nodes
    links = mat.node_tree.links
    
    # 清除默认节点
    nodes.clear()
    
    # 创建输出节点
    output = nodes.new('ShaderNodeOutputMaterial')
    output.location = (800, 0)
    
    # 使用几何节点获取法线
    geometry = nodes.new('ShaderNodeNewGeometry')
    geometry.location = (-600, 0)
    
    # 分离法线的Z分量
    separate_xyz = nodes.new('ShaderNodeSeparateXYZ')
    separate_xyz.location = (-400, 0)
    links.new(geometry.outputs['Normal'], separate_xyz.inputs['Vector'])
    
    # === 判断天花板（法线Z < -0.5，朝下的面） ===
    ceiling_check = nodes.new('ShaderNodeMath')
    ceiling_check.operation = 'LESS_THAN'
    ceiling_check.inputs[1].default_value = -0.5
    ceiling_check.location = (-200, 100)
    links.new(separate_xyz.outputs['Z'], ceiling_check.inputs[0])
    
    # === 判断地板（法线Z > 0.5，朝上的面） ===
    floor_check = nodes.new('ShaderNodeMath')
    floor_check.operation = 'GREATER_THAN'
    floor_check.inputs[1].default_value = 0.5
    floor_check.location = (-200, -100)
    links.new(separate_xyz.outputs['Z'], floor_check.inputs[0])
    
    # === 创建三种材质 ===
    floor_shader = create_wood_floor_material(nodes, links)
    floor_shader.location = (0, 300)
    
    wall_shader = create_brick_wall_material(nodes, links)  # 砖墙材质
    wall_shader.location = (0, 0)
    
    ceiling_shader = create_grid_ceiling_material(nodes, links)  # 网格天花板
    ceiling_shader.location = (0, -300)
    
    # === 混合着色器：先混合地板和墙面 ===
    mix_floor_wall = nodes.new('ShaderNodeMixShader')
    mix_floor_wall.location = (300, 100)
    links.new(floor_check.outputs['Value'], mix_floor_wall.inputs['Fac'])
    links.new(wall_shader.outputs['Emission'], mix_floor_wall.inputs[1])  # Emission材质输出
    links.new(floor_shader.outputs['Emission'], mix_floor_wall.inputs[2])  # Emission材质输出
    
    # === 混合着色器：再混合天花板 ===
    mix_final = nodes.new('ShaderNodeMixShader')
    mix_final.location = (500, 0)
    links.new(ceiling_check.outputs['Value'], mix_final.inputs['Fac'])
    links.new(mix_floor_wall.outputs['Shader'], mix_final.inputs[1])
    links.new(ceiling_shader.outputs['Emission'], mix_final.inputs[2])  # Emission材质输出
    
    # 连接输出
    links.new(mix_final.outputs['Shader'], output.inputs['Surface'])
    
    # 应用材质到对象
    if obj.data.materials:
        obj.data.materials[0] = mat
    else:
        obj.data.materials.append(mat)
    
    print(f"[INFO] Emission材质已应用（地板+砖墙+网格天花板，材质预览模式）")


# =====================================================================
# 参数解析（兼容两种模式）
# =====================================================================

def parse_args_python():
    """Python 模式: 需要 --blender"""
    parser = argparse.ArgumentParser(description="Blend Pipeline v5（边渲边选）")
    parser.add_argument("--blender", type=str, required=True)
    scene_grp = parser.add_mutually_exclusive_group(required=True)
    scene_grp.add_argument("--blend", type=str, default=None,
                           help=".blend 场景文件路径")
    scene_grp.add_argument("--glb", type=str, default=None,
                           help=".glb / .gltf 场景文件路径")
    # parser.add_argument("--exposure_rate", type=float, default=0.5, help="多次曝光时，前后两次曝光的差距阈值")
    # parser.add_argument("--exposure_count", type=int, default=5, help="最大曝光次数")
    parser.add_argument("--output-dir", type=str, required=True)
    parser.add_argument("--num-frames", type=int, default=30)
    parser.add_argument("--render-depth", action="store_true")
    parser.add_argument("--resolution", type=str, default="2048,1024")
    parser.add_argument("--samples", type=int, default=128)
    parser.add_argument("--engine", type=str, default="CYCLES")
    parser.add_argument("--exposure", type=float, default=0.0)
    parser.add_argument("--grid-spacing", type=float, default=0.5)
    parser.add_argument("--camera-height", type=float, default=None)
    parser.add_argument("--stop-gain", type=float, default=DEFAULT_STOP_GAIN)
    parser.add_argument("--stop-score", type=float, default=-0.3)
    parser.add_argument("--stop-delta", type=float, default=0.08)
    parser.add_argument("--min-frames", type=int, default=DEFAULT_MIN_FRAMES)
    parser.add_argument("--rotation-type", type=str, default="random_yaw",
                        choices=["none", "rotate_x_90", "rotate_x_180",
                                 "rotate_z_90", "random_yaw"])
    parser.add_argument("--gain-curve", action="store_true", default=True)
    parser.add_argument("--no-gain-curve", dest="gain_curve", action="store_false")
    parser.add_argument("--hm3d", type=bool, default=False, help="是否启用 HM3D 数据集的房间搜索和场景加载逻辑")
    return parser.parse_args()


def parse_args_blender():
    """Blender 模式: 不需要 --blender"""
    argv = sys.argv
    if "--" in argv:
        argv = argv[argv.index("--") + 1:]
    else:
        argv = []
    parser = argparse.ArgumentParser()
    scene_grp = parser.add_mutually_exclusive_group(required=True)
    scene_grp.add_argument("--blend", type=str, default=None,
                           help=".blend 场景文件路径")
    scene_grp.add_argument("--glb", type=str, default=None,
                           help=".glb / .gltf 场景文件路径")
    # parser.add_argument("--exposure_rate", type=float, default=0.5, help="多次曝光时，前后两次曝光的差距阈值")
    # parser.add_argument("--exposure_count", type=int, default=5, help="最大曝光次数")
    parser.add_argument("--output-dir", type=str, required=True)
    parser.add_argument("--num-frames", type=int, default=30)
    parser.add_argument("--resolution", type=str, default="2048,1024")
    parser.add_argument("--samples", type=int, default=128)
    parser.add_argument("--engine", type=str, default="CYCLES")
    parser.add_argument("--exposure", type=float, default=0.0)
    parser.add_argument("--grid-spacing", type=float, default=0.5)
    parser.add_argument("--camera-height", type=float, default=None)
    parser.add_argument("--stop-gain", type=float, default=DEFAULT_STOP_GAIN)
    parser.add_argument("--stop-score", type=float, default=-0.3)
    parser.add_argument("--stop-delta", type=float, default=0.08)
    parser.add_argument("--min-frames", type=int, default=DEFAULT_MIN_FRAMES)
    parser.add_argument("--rotation-type", type=str, default="random_yaw",
                        choices=["none", "rotate_x_90", "rotate_x_180",
                                 "rotate_z_90", "random_yaw"])
    parser.add_argument("--gain-curve", action="store_true", default=True)
    parser.add_argument("--no-gain-curve", dest="gain_curve", action="store_false")
    parser.add_argument("--rooms", type=str, default=None, help="HM3D 房间信息的 JSON 字符串")
    return parser.parse_args(argv)

###############################
#
# 房间搜索相关工具函数
#
###############################
def load_semantic_info(mesh_path):
    """
    加载语义信息（包装函数）
    
    Args:
        mesh_path: GLB文件路径
    
    Returns:
        (room_to_objects, semantic_file_path): 
        - room_to_objects: {room_id: [object_ids]} 字典，如果不存在则返回None
        - semantic_file_path: 使用的语义文件路径，如果不存在则返回None
    """
    from tools.semantic_utils import load_semantic_info as load_semantic_info_util
    return load_semantic_info_util(mesh_path)


def get_scene_bounds(mesh_path, room_id=None, room_to_objects=None):
    """
    获取场景边界框（使用trimesh）
    
    Args:
        mesh_path: mesh文件路径
        room_id: 房间ID（可选），如果提供则只计算该房间的边界框
        room_to_objects: 房间到对象的映射 {room_id: [object_ids]}（可选）
    
    Returns:
        bounds_min, bounds_max: 边界框的最小和最大坐标
    """
    try:
        import trimesh
        import re
        
        scene_or_mesh = trimesh.load(mesh_path, process=False)
        
        # 如果指定了房间ID，需要过滤对象
        object_ids_to_include = None
        if room_id is not None and room_to_objects is not None:
            object_ids_to_include = set(room_to_objects.get(room_id, []))
            if not object_ids_to_include:
                # 如果房间没有对象，返回默认边界框
                return np.array([-1, -1, -1]), np.array([1, 1, 1])
        
        if isinstance(scene_or_mesh, trimesh.Scene):
            # 合并所有几何体的顶点
            all_vertices = []
            for name, geom in scene_or_mesh.geometry.items():
                if isinstance(geom, trimesh.Trimesh):
                    # 如果指定了房间ID，检查对象是否属于该房间
                    if object_ids_to_include is not None:
                        # HM3D的GLB中，对象名称格式为 "chunkXXX_..." 
                        # chunk编号+1对应semantic.txt中的对象ID
                        obj_id = None
                        
                        # 方法1: 尝试从chunk编号提取（chunk000 -> 对象ID 1）
                        match = re.search(r'chunk(\d+)', name)
                        if match:
                            chunk_num = int(match.group(1))
                            obj_id = chunk_num + 1
                        
                        # 方法2: 如果名称是纯数字，直接使用
                        if obj_id is None:
                            try:
                                obj_id = int(name)
                            except (ValueError, TypeError):
                                pass
                        
                        # 如果无法提取对象ID，或者对象ID不在该房间中，跳过
                        if obj_id is None or obj_id not in object_ids_to_include:
                            continue
                    
                    # 获取变换矩阵
                    for node_name in scene_or_mesh.graph.nodes_geometry:
                        if scene_or_mesh.graph[node_name][1] == name:
                            transform = scene_or_mesh.graph[node_name][0]
                            vertices = np.dot(geom.vertices, transform[:3, :3].T) + transform[:3, 3]
                            all_vertices.append(vertices)
                            break
            
            if all_vertices:
                all_vertices = np.vstack(all_vertices)
                bounds_min = all_vertices.min(axis=0)
                bounds_max = all_vertices.max(axis=0)
            else:
                bounds_min = np.array([-1, -1, -1])
                bounds_max = np.array([1, 1, 1])
        else:
            bounds_min = scene_or_mesh.bounds[0]
            bounds_max = scene_or_mesh.bounds[1]
        
        return bounds_min, bounds_max
        
    except ImportError:
        print("[WARN] trimesh未安装，使用默认边界框")
        return np.array([-1, -1, -1]), np.array([1, 1, 1])

def get_valid_object_ids(mesh_path):
    """
    获取GLB文件中所有有效的对象ID
    
    Args:
        mesh_path: mesh文件路径
    
    Returns:
        valid_obj_ids: 有效对象ID的集合
    """
    try:
        import trimesh
        import re
        
        valid_obj_ids = set()
        scene_or_mesh = trimesh.load(mesh_path, process=False)
        
        if isinstance(scene_or_mesh, trimesh.Scene):
            for name, geom in scene_or_mesh.geometry.items():
                if isinstance(geom, trimesh.Trimesh):
                    # 从chunk编号提取对象ID
                    match = re.search(r'chunk(\d+)', name)
                    if match:
                        chunk_num = int(match.group(1))
                        obj_id = chunk_num + 1
                        valid_obj_ids.add(obj_id)
                    else:
                        # 如果名称是纯数字，直接使用
                        try:
                            obj_id = int(name)
                            valid_obj_ids.add(obj_id)
                        except (ValueError, TypeError):
                            pass
        
        return valid_obj_ids
    except Exception as e:
        print(f"[WARN] 获取有效对象ID失败: {e}")
        return set()

def get_valid_object_ids(mesh_path):
    """
    获取GLB文件中所有有效的对象ID
    
    Args:
        mesh_path: mesh文件路径
    
    Returns:
        valid_obj_ids: 有效对象ID的集合
    """
    try:
        import trimesh
        import re
        
        valid_obj_ids = set()
        scene_or_mesh = trimesh.load(mesh_path, process=False)
        
        if isinstance(scene_or_mesh, trimesh.Scene):
            for name, geom in scene_or_mesh.geometry.items():
                if isinstance(geom, trimesh.Trimesh):
                    # 从chunk编号提取对象ID
                    match = re.search(r'chunk(\d+)', name)
                    if match:
                        chunk_num = int(match.group(1))
                        obj_id = chunk_num + 1
                        valid_obj_ids.add(obj_id)
                    else:
                        # 如果名称是纯数字，直接使用
                        try:
                            obj_id = int(name)
                            valid_obj_ids.add(obj_id)
                        except (ValueError, TypeError):
                            pass
        
        return valid_obj_ids
    except Exception as e:
        print(f"[WARN] 获取有效对象ID失败: {e}")
        return set()


def detect_rooms(mesh_path, room_to_objects=None, use_navmesh=True):
    """
    检测场景中的所有房间，计算每个房间的边界框和几何中心
    
    优先使用NavMesh方法，如果NavMesh不可用则使用语义方法
    
    Args:
        mesh_path: mesh文件路径
        room_to_objects: 房间到对象的映射 {room_id: [object_ids]}（可选）
        use_navmesh: 是否优先使用NavMesh方法
    
    Returns:
        rooms: 房间列表，每个元素包含 {"room_id": int, "bounds_min": array, "bounds_max": array, "center": array, "source": str}
    """
    rooms = []
    
    # 尝试使用NavMesh方法
    from tools.navmesh_utils import extract_spaces_from_glb, find_navmesh_file, navmesh_to_3d_spaces
    if use_navmesh:
        navmesh_path = find_navmesh_file(mesh_path)
        if navmesh_path:
            print(f"  [INFO] 找到NavMesh文件: {navmesh_path}")
            print(f"  [INFO] 使用NavMesh方法识别空间...")
            
            # 使用NavMesh结合语义信息提取空间（启用空间聚类）
            navmesh_spaces = navmesh_to_3d_spaces(
                navmesh_path, 
                mesh_path=mesh_path, 
                room_to_objects=room_to_objects,
                use_clustering=True  # 启用空间聚类，识别所有独立空间
            )
            
            if navmesh_spaces:
                print(f"  [INFO] NavMesh方法识别到 {len(navmesh_spaces)} 个空间")
                # 转换格式以保持兼容性
                for space in navmesh_spaces:
                    rooms.append({
                        "room_id": int(space["space_id"]),
                        "bounds_min": space["bounds_min"].tolist(),
                        "bounds_max": space["bounds_max"].tolist(),
                        "center": space["center"].tolist(),
                        "object_count": space.get("object_count", 0),
                        "source": space.get("source", "navmesh")
                    })
                return rooms
            else:
                print(f"  [WARN] NavMesh方法未识别到空间，回退到GLB聚类方法")
        else:
            print(f"  [INFO] 未找到NavMesh文件，尝试直接从GLB文件进行空间聚类...")
    
    # 尝试直接从GLB文件进行空间聚类（不依赖NavMesh和语义信息）
    print(f"  [INFO] 使用GLB空间聚类方法...")
    glb_spaces = extract_spaces_from_glb(mesh_path, room_to_objects, use_clustering=True)
    
    if glb_spaces:
        print(f"  [INFO] GLB聚类方法识别到 {len(glb_spaces)} 个空间")
        for space in glb_spaces:
            rooms.append({
                        "room_id": int(space["space_id"]),
                        "bounds_min": space["bounds_min"].tolist(),
                        "bounds_max": space["bounds_max"].tolist(),
                        "center": space["center"].tolist(),
                        "object_count": space.get("object_count", 0),
                        "source": space.get("source", "navmesh")
                    })
        return rooms
    else:
        print(f"  [WARN] GLB聚类方法未识别到空间，回退到语义方法")
    
    # 回退到语义方法
    if not room_to_objects:
        return rooms
    
    # 获取GLB中有效的对象ID
    valid_obj_ids = get_valid_object_ids(mesh_path)
    
    # 过滤掉无效的对象ID
    filtered_room_to_objects = {}
    for room_id, obj_ids in room_to_objects.items():
        valid_ids = [obj_id for obj_id in obj_ids if obj_id in valid_obj_ids]
        if valid_ids:
            filtered_room_to_objects[room_id] = valid_ids
    
    if not filtered_room_to_objects:
        return rooms
    
    print(f"  过滤后有效房间数: {len(filtered_room_to_objects)}/{len(room_to_objects)}")
    
    for room_id in sorted(filtered_room_to_objects.keys()):
        # 使用过滤后的对象ID获取边界框
        bounds_min, bounds_max = get_scene_bounds(
            mesh_path, 
            room_id=room_id, 
            room_to_objects=filtered_room_to_objects
        )
        
        # 计算几何中心（trimesh Y-up坐标系）
        center = (bounds_min + bounds_max) / 2
        
        # 检查边界框是否有效（不是默认值，且有合理的尺寸）
        if not np.allclose(bounds_min, [-1, -1, -1]) and not np.allclose(bounds_max, [1, 1, 1]):
            size = bounds_max - bounds_min
            # 检查房间是否有合理的尺寸（至少0.1米）
            if np.all(size > 0.1):
                rooms.append({
                    "room_id": room_id,
                    "bounds_min": bounds_min,
                    "bounds_max": bounds_max,
                    "center": center,
                    "object_count": len(filtered_room_to_objects[room_id]),
                    "source": "semantic"
                })
    
    return rooms


# #####################################################################
#
#  Python 模式入口: 启动单个 Blender 进程
#
# #####################################################################
def main_python():
    """Python 调用入口 → 启动一个 Blender 进程执行本脚本"""
    args = parse_args_python()

    # 判断场景格式
    if args.blend:
        scene_path = str(Path(args.blend).resolve())
        scene_flag = "--blend"
        scene_label = f"Blend: {scene_path}"
    else:
        scene_path = str(Path(args.glb).resolve())
        scene_flag = "--glb"
        scene_label = f"GLB:   {scene_path}"

    output_dir = str(Path(args.output_dir).resolve())
    os.makedirs(output_dir, exist_ok=True)

    this_script = str(Path(__file__).resolve())

    # 构建 Blender 命令（把参数透传，去掉 --blender 和 --render-depth）
    cmd = [
        args.blender, "--background",
        "--python", this_script,
        "--",
        scene_flag, scene_path,
        "--output-dir", output_dir,
        "--num-frames", str(args.num_frames),
        "--resolution", args.resolution,
        "--samples", str(args.samples),
        "--engine", args.engine,
        "--exposure", str(args.exposure),
        "--grid-spacing", str(args.grid_spacing),
        "--stop-gain", str(args.stop_gain),
        "--stop-score", str(args.stop_score),
        "--stop-delta", str(args.stop_delta),
        "--min-frames", str(args.min_frames),
        "--rotation-type", args.rotation_type,
        # "--exposure-rate", args.exposure_rate,
        # "--exposure-count", args.exposure_count
    ]
    if args.camera_height is not None:
        cmd += ["--camera-height", str(args.camera_height)]
    if not args.gain_curve:
        cmd += ["--no-gain-curve"]
    
    # [TODO] 如果是hm3d数据集，进行房间搜索并通过添加 `--rooms` 参数传递房间信息（json字符串）给 Blender 内部
    # Blender 内部根据房间列表加载对应的场景并进行渲染。
    if args.hm3d:
        # 记得在 Blender 内部解析 `--rooms` 参数，加载对应的场景并进行渲染。
        # print("\n[INFO] 加载语义信息...")
        room_to_objects, semantic_file_path = load_semantic_info(args.glb)
        rooms = detect_rooms(args.glb, room_to_objects=room_to_objects, use_navmesh=True)
        # 如果NavMesh方法未识别到空间，且语义信息可用，使用纯语义方法
        if len(rooms) == 0 and room_to_objects and semantic_file_path:
            print(f"  [INFO] NavMesh方法未识别到空间，使用语义方法...")
            print(f"  找到语义文件: {semantic_file_path}")
            print(f"  检测到 {len(room_to_objects)} 个房间")
            rooms = detect_rooms(args.glb, room_to_objects=room_to_objects, use_navmesh=False)
            print(f"  有效房间数: {len(rooms)}")
        elif len(rooms) > 0:
            print(f"  [INFO] 成功识别到 {len(rooms)} 个空间")
            # 统计空间来源
            sources = {}
            for room in rooms:
                source = room.get("source", "unknown")
                sources[source] = sources.get(source, 0) + 1
            print(f"  空间来源: {sources}")
        # print("*"*60, json.dumps({"rooms": rooms}), sep="\n")
        # exit(0)
        print(f"  房间数量: {len(rooms)}")
        # input("\n按Enter键继续...")
        cmd += ["--rooms", json.dumps({"rooms": rooms})]
        # print("\n".join(cmd))
        # exit()
        # pass
    print("=" * 60)
    print("ERPT Blend Pipeline v5（单进程边渲边选）")
    print("=" * 60)
    print(f"  {scene_label}")
    print(f"  Output:     {output_dir}")
    print(f"  Max frames: {args.num_frames}")

    # 不设 timeout — 大场景渲染时间不可预测
    proc = subprocess.run(cmd, text=True)
    sys.exit(proc.returncode)


# #####################################################################
#
#  Blender 模式: Phase 0 + 1 + 2 全部在 Blender 内部执行
#
# #####################################################################

# =====================================================================
# Phase 0: 加载场景 + 获取边界
# =====================================================================

def load_scene(mesh_path):
    """导入mesh文件"""
    ext = os.path.splitext(mesh_path)[1].lower()
    
    if ext in ['.glb', '.gltf']:
        bpy.ops.import_scene.gltf(filepath=mesh_path)
    elif ext == '.obj':
        bpy.ops.wm.obj_import(filepath=mesh_path)
    elif ext == '.fbx':
        bpy.ops.import_scene.fbx(filepath=mesh_path)
    elif ext == '.ply':
        bpy.ops.wm.ply_import(filepath=mesh_path)
    else:
        raise ValueError(f"不支持的文件格式: {ext}")
    
    print(f"[INFO] 导入mesh: {mesh_path}")
    
    # 获取导入的对象
    imported_objects = [obj for obj in bpy.context.selected_objects]
    print(f"[INFO] 导入了 {len(imported_objects)} 个对象")
    
    # 为房间结构添加程序化纹理
    apply_procedural_textures(imported_objects)
    
    return imported_objects


# =====================================================================
# Phase 1: 撒点 + 4 层 Blender ray_cast 过滤
# =====================================================================

def compute_camera_heights(floor_z, ceiling_z, manual_height=None, bmin=None, bmax=None):
    """计算相机高度层

    策略:
      - 手动指定 → 只用该高度
      - 多层建筑 → 每层铺固定高度 [0.5, 0.8, 1.2, 1.7, 2.1] + 动态顶层
      - 单层高空间 → 2.5m 以下用固定高度，2.5m 以上阶梯递增:
          +1.0m, +1.5m, +2.0m, +2.5m, +3.0m ...（间距逐步放大）
          最后加动态顶层（天花板 -0.5m）
    """
    CEIL_CLEARANCE = 0.3    # 最高高度：离天花板 0.3m（保留 2.1m 层）
    FIXED_HEIGHTS = [0.5, 0.8, 1.2, 1.7, 2.1]  # 2.5m 以下的固定高度

    if manual_height is not None:
        return [manual_height]

    room_h = ceiling_z - floor_z
    if room_h <= 0:
        return [floor_z + 1.5]

    def _stepped_heights_for_floor(fz, local_ceil):
        """单层高度计算：固定 + 阶梯递增 + 动态顶层"""
        heights = []
        local_h = local_ceil - fz

        # 2.5m 以下: 固定高度
        for eye_h in FIXED_HEIGHTS:
            z = fz + eye_h
            if z < local_ceil - CEIL_CLEARANCE:
                heights.append(z)

        # 2.5m 以上: 阶梯递增（间距从 1.0m 逐步增大到 3.0m）
        if local_h > 3.0:  # 层高 > 3m 才加中间高度
            cur_h = FIXED_HEIGHTS[-1]  # 从 2.1m 开始
            step = 1.0                  # 初始步长 1.0m
            MAX_STEP = 3.0              # 最大步长 3.0m
            STEP_GROW = 0.5             # 每次步长增加 0.5m

            while True:
                cur_h += step
                z = fz + cur_h
                if z >= local_ceil - CEIL_CLEARANCE:
                    break
                heights.append(z)
                step = min(step + STEP_GROW, MAX_STEP)

        # 动态顶层：天花板 - 0.5m（如果比最高已有高度至少高 0.5m）
        top_z = local_ceil - CEIL_CLEARANCE
        if heights:
            if top_z > max(heights) + 0.5:
                heights.append(top_z)
        elif top_z > fz + 0.5:
            heights.append(top_z)

        return heights

    # 先尝试用 Blender raycast 探测楼板
    try:
        floors = _detect_floor_levels(floor_z, ceiling_z, bmin, bmax)
        if floors:
            print(f"  [楼层检测] 发现 {len(floors)} 个楼层: "
                  f"{[f'{z:.2f}m' for z in floors]}")
            heights = []
            for idx, fz in enumerate(floors):
                # 每层的天花板 = 下一层楼板 或 全局天花板
                if idx + 1 < len(floors):
                    local_ceil = floors[idx + 1]
                else:
                    local_ceil = ceiling_z
                heights.extend(_stepped_heights_for_floor(fz, local_ceil))

            if heights:
                result = sorted(set(round(h, 2) for h in heights))
                # 打印高度分布
                for h in result:
                    rel = h - floors[0]
                    print(f"    高度 Z={h:.2f}m (离地 {rel:.2f}m)")
                return result
        else:
            print(f"  [楼层检测] 未检测到楼板，使用启发式")
    except Exception as e:
        print(f"  [楼层检测] 异常: {e}，使用启发式")

    # fallback: 简单启发式（同样用阶梯递增）
    h_list = _stepped_heights_for_floor(floor_z, ceiling_z)
    return sorted(set(round(h, 2) for h in h_list)) if h_list else [floor_z + 1.5]


def _detect_floor_levels(floor_z, ceiling_z, bmin=None, bmax=None):
    """用 raycast 从上往下扫描，检测楼板位置

    在 XY 平面采样若干点，每个点从顶部往下打射线，收集 hit 的 Z 坐标。
    对 Z 坐标做聚类（间距 > 1.5m 算不同楼层），得到各楼层地面高度。

    关键改进:
    1. 采样范围按场景大小缩放（不只中心 ±2m）
    2. 检测到楼板后验证上方有天花板（排除屋顶外表面）
    """
    scene = bpy.context.scene
    depsgraph = bpy.context.evaluated_depsgraph_get()
    dir_down = Vector((0, 0, -1))
    dir_up = Vector((0, 0, 1))

    # 用场景 AABB 的 XY 中心和范围
    if bmin is not None and bmax is not None:
        cx = (bmin[0] + bmax[0]) / 2
        cy = (bmin[1] + bmax[1]) / 2
        # 采样范围: 场景 XY 的 1/4 跨度，至少 2m，最多 20m
        rx = min(20.0, max(2.0, (bmax[0] - bmin[0]) * 0.25))
        ry = min(20.0, max(2.0, (bmax[1] - bmin[1]) * 0.25))
    else:
        cx, cy = 0.0, 0.0
        rx, ry = 2.0, 2.0

    hit_zs = []
    # 3x3 网格采样，按场景大小缩放
    offsets = []
    for fx in [-1, 0, 1]:
        for fy in [-1, 0, 1]:
            offsets.append((fx * rx, fy * ry))

    for dx, dy in offsets:
        origin = Vector((cx + dx, cy + dy, ceiling_z + 1.0))
        # 多次向下 raycast（穿透式：命中后从命中点下方继续）
        cur_z = ceiling_z + 1.0
        for _ in range(10):  # 最多穿 10 层
            hit, loc, norm, *_ = scene.ray_cast(
                depsgraph, Vector((cx + dx, cy + dy, cur_z)), dir_down)
            if not hit:
                break
            # 法线朝上（Z 分量 > 0.5）→ 这是地板/楼板表面
            if norm.z > 0.5:
                hit_zs.append((loc.z, cx + dx, cy + dy))
            cur_z = loc.z - 0.05  # 穿过这个表面继续往下

    if not hit_zs:
        return []

    # 聚类: 排序后间距 > 1.5m 算不同楼层
    hit_zs.sort(key=lambda t: t[0])
    clusters = [[hit_zs[0]]]
    for item in hit_zs[1:]:
        if item[0] - clusters[-1][-1][0] > 1.5:
            clusters.append([item])
        else:
            clusters[-1].append(item)

    # 每个 cluster 验证: 楼板上方是否有天花板
    MAX_CEILING_DIST = 30.0  # 最高天花板距离（超过说明是露天/屋顶外表面）
    floors = []
    for c in clusters:
        fz = sorted(c, key=lambda t: t[0])[len(c) // 2][0]
        if not (floor_z - 0.5 <= fz <= ceiling_z - 1.0):
            continue

        # 验证: 从该楼板上方 1m 处往上打射线，检查是否有天花板
        n_has_ceiling = 0
        n_tested = 0
        for _, px, py in c:
            test_origin = Vector((px, py, fz + 1.0))
            hit_ceil, loc_ceil, norm_ceil, *_ = scene.ray_cast(
                depsgraph, test_origin, dir_up)
            n_tested += 1
            if hit_ceil and (loc_ceil.z - fz) < MAX_CEILING_DIST:
                n_has_ceiling += 1

        # 过半采样点上方有天花板 → 真正的楼板
        if n_tested > 0 and n_has_ceiling / n_tested >= 0.5:
            floors.append(fz)
        else:
            print(f"    [楼层检测] Z={fz:.2f}m 上方无天花板"
                  f"（{n_has_ceiling}/{n_tested}），排除（可能是屋顶外表面）")

    return sorted(floors)


def generate_candidate_grid(bmin, bmax, x_spacing, y_spacing, heights):
    cx = (bmin[0] + bmax[0]) / 2
    cy = (bmin[1] + bmax[1]) / 2
    x_half = int((bmax[0] - cx - MARGIN) / x_spacing)
    y_half = int((bmax[1] - cy - MARGIN) / y_spacing)

    xy_offsets = []
    for ix in range(-x_half, x_half + 1):
        for iy in range(-y_half, y_half + 1):
            x = cx + ix * x_spacing
            y = cy + iy * y_spacing
            if bmin[0] + MARGIN <= x <= bmax[0] - MARGIN and \
               bmin[1] + MARGIN <= y <= bmax[1] - MARGIN:
                xy_offsets.append((ix * ix + iy * iy, x, y))
    xy_offsets.sort(key=lambda t: t[0])

    candidates = []
    for z in heights:
        for _, x, y in xy_offsets:
            candidates.append([float(x), float(y), float(z)])

    n_xy = len(xy_offsets)
    print(f"  网格: {n_xy}点/层 x {len(heights)}层 = {len(candidates)} 个候选")
    print(f"    中心: ({cx:.1f}, {cy:.1f}), X间距={x_spacing:.1f}m, Y间距={y_spacing:.1f}m")
    for i, z in enumerate(heights):
        print(f"    第{i+1}层: Z={z:.2f}m")
    return candidates


def _build_26_directions():
    """26 方向球面采样（mathutils.Vector）"""
    dirs = []
    for i in range(16):
        a = i * (2 * math.pi / 16)
        dirs.append(Vector((math.cos(a), math.sin(a), 0.0)))
    elev = math.pi / 4
    for i in range(5):
        a = i * (2 * math.pi / 5)
        dirs.append(Vector((math.cos(a) * math.cos(elev),
                            math.sin(a) * math.cos(elev),
                            math.sin(elev))))
    for i in range(5):
        a = i * (2 * math.pi / 5)
        dirs.append(Vector((math.cos(a) * math.cos(elev),
                            math.sin(a) * math.cos(elev),
                            -math.sin(elev))))
    return dirs


def raycast_6layer_filter(candidates, room_height, min_wall_dist=1.0):
    """7 层过滤 — 直接用 Blender scene.ray_cast（不需要 trimesh/GLB）

    第 1 层: 室内检测（朝上朝下必须 hit）
    第 2 层: 穿模检测（≥2 方向 < 0.2m）
    第 3 层: 角落检测（>50% 水平方向 < 1.0m）
    第 4 层: 包裹检测（hit_rate≥90% + cv<0.30 + max<8m）
    第 5 层: 墙面间距（最近水平方向 < 0.3m → Blender 渲染会穿模）
    第 6 层: 视野质量（<35% 方向有有效命中 → 太空旷或太闭塞）
    第 7 层: 窄缝检测（对向方向距离之和 < 1.5m → 两面墙夹着）★ 新增

    性能: 用第 1~4 层同样的 26 方向数据，第 5~7 层零额外射线开销
    """
    scene = bpy.context.scene
    depsgraph = bpy.context.evaluated_depsgraph_get()

    N = len(candidates)
    max_up = max(5.0, room_height)
    max_down = max(3.0, room_height)
    dir_up = Vector((0, 0, 1))
    dir_down = Vector((0, 0, -1))
    DIRS_26 = _build_26_directions()
    n26 = len(DIRS_26)

    # 第 5 层阈值: 最近水平墙面距离
    MIN_WALL_CLEARANCE = 0.3  # Blender 渲染安全距离

    # 第 6 层阈值: 有效视野比例
    VIEW_GOOD_MIN = 0.5    # 有效命中距离下限
    VIEW_GOOD_MAX = 20.0   # 有效命中距离上限
    VIEW_GOOD_RATIO = 0.35 # 至少 35% 方向有有效命中

    # 第 7 层阈值: 窄缝检测（对向距离之和）
    MIN_SLIT_WIDTH = 1.5   # 对向墙距之和 < 1.5m → 窄缝

    passed = []
    stats = {"无天花板": 0, "无地板": 0, "穿模": 0, "角落": 0,
             "包裹": 0, "贴墙": 0, "视野差": 0, "窄缝": 0}

    t0 = time.time()
    log_interval = max(1, N // 10)

    for idx, pos in enumerate(candidates):
        if idx % log_interval == 0 and idx > 0:
            print(f"    过滤进度: {idx}/{N} ({idx*100//N}%)", flush=True)

        origin = Vector(pos)

        # ---- 第 1 层: 室内检测（朝上朝下各 1 条射线）----
        hit_up, loc_up, *_ = scene.ray_cast(depsgraph, origin, dir_up)
        if not hit_up or (loc_up - origin).length > max_up:
            stats["无天花板"] += 1
            continue

        hit_dn, loc_dn, *_ = scene.ray_cast(depsgraph, origin, dir_down)
        if not hit_dn or (loc_dn - origin).length > max_down:
            stats["无地板"] += 1
            continue

        # ---- 第 2~6 层: 26 方向球面采样 ----
        dists = []
        for d in DIRS_26:
            hit, loc, *_ = scene.ray_cast(depsgraph, origin, d)
            dists.append((loc - origin).length if hit else float('inf'))

        # 第 2 层: 穿模（≥2 方向 < 0.2m → 在物体内部）
        n_close = sum(1 for d in dists if d < 0.2)
        if n_close >= 2:
            stats["穿模"] += 1
            continue

        # 第 3 层: 角落（水平 16 方向中 > 一半 < 1.0m）
        n_wall = sum(1 for d in dists[:16] if d < min_wall_dist)
        if n_wall > 8:
            stats["角落"] += 1
            continue

        # 第 4 层: 包裹（hit_rate≥90% + CV<0.30 + max<8m）
        finite = [d for d in dists if d < float('inf')]
        hit_rate = len(finite) / n26
        if hit_rate >= 0.90 and len(finite) >= 2:
            mean_d = sum(finite) / len(finite)
            max_d = max(finite)
            if mean_d > 0:
                var = sum((d - mean_d) ** 2 for d in finite) / len(finite)
                cv = var ** 0.5 / mean_d
                if cv < 0.30 and max_d < 8.0:
                    stats["包裹"] += 1
                    continue

        # 第 5 层: 墙面间距（水平 16 方向最近 hit < 0.3m → 贴墙）★ 新增
        horiz_finite = [d for d in dists[:16] if d < float('inf')]
        if horiz_finite and min(horiz_finite) < MIN_WALL_CLEARANCE:
            stats["贴墙"] += 1
            continue

        # 第 6 层: 视野质量（有效方向太少 → 视野差）
        n_good = sum(1 for d in dists
                     if VIEW_GOOD_MIN <= d <= VIEW_GOOD_MAX)
        good_ratio = n_good / n26
        if good_ratio < VIEW_GOOD_RATIO:
            stats["视野差"] += 1
            continue

        # 第 7 层: 窄缝检测（对向水平方向距离之和 < 1.5m → 两面墙夹着）
        # 水平 16 方向中，方向 i 和方向 i+8 是对向的（0°↔180°, 22.5°↔202.5°...）
        in_slit = False
        for i in range(8):
            d_fwd = dists[i] if dists[i] < float('inf') else 999
            d_bwd = dists[i + 8] if dists[i + 8] < float('inf') else 999
            if d_fwd + d_bwd < MIN_SLIT_WIDTH:
                in_slit = True
                break
        if in_slit:
            stats["窄缝"] += 1
            continue

        passed.append(pos)

    dt = time.time() - t0
    print(f"  过滤统计 ({dt:.1f}s): 总计={N}, 通过={len(passed)}")
    for k, v in stats.items():
        print(f"    ❌ {k}: {v} ({v * 100 // max(N, 1)}%)")
    print(f"    阈值: 天花板<{max_up:.1f}m, 地板<{max_down:.1f}m, "
          f"穿模<0.2m, 角落<{min_wall_dist:.1f}m, "
          f"包裹: hit≥90%+cv<0.3+max<8m, "
          f"贴墙<{MIN_WALL_CLEARANCE}m, "
          f"视野: ≥{VIEW_GOOD_RATIO:.0%}方向 {VIEW_GOOD_MIN}-{VIEW_GOOD_MAX}m, "
          f"窄缝<{MIN_SLIT_WIDTH}m")

    if len(passed) < 5 and N > 20:
        print(f"    [诊断] 通过率低 ({len(passed)}/{N})")

    return passed


def setup_erp_camera():
    """创建 ERP 全景相机"""
    for obj in list(bpy.context.scene.objects):
        if obj.type == 'CAMERA':
            bpy.data.objects.remove(obj, do_unlink=True)

    cam_data = bpy.data.cameras.new("ERP_Camera")
    cam_data.type = 'PANO'
    if hasattr(cam_data, 'panorama_type'):
        cam_data.panorama_type = 'EQUIRECTANGULAR'
    if hasattr(cam_data, 'cycles'):
        cam_data.cycles.panorama_type = 'EQUIRECTANGULAR'

    cam_obj = bpy.data.objects.new("ERP_Camera", cam_data)
    bpy.context.scene.collection.objects.link(cam_obj)
    bpy.context.scene.camera = cam_obj
    print(f"  创建 ERP 相机: {cam_obj.name}")
    return cam_obj


def enable_gpu():
    try:
        prefs = bpy.context.preferences.addons['cycles'].preferences
        for dt in ['OPTIX', 'CUDA']:
            try:
                prefs.compute_device_type = dt
                prefs.get_devices()
                gpus = [d for d in prefs.devices if d.type == dt]
                if gpus:
                    for d in prefs.devices:
                        d.use = (d.type == dt)
                    bpy.context.scene.cycles.device = 'GPU'
                    print(f"  GPU 渲染: {gpus[0].name} ({dt})")
                    return True
            except Exception:
                continue
        print("  [WARN] 无可用 GPU，使用 CPU 渲染")
        bpy.context.scene.cycles.device = 'CPU'
    except Exception as e:
        print(f"  [ERROR] GPU 设置异常: {e}")
    return False


def setup_render_settings(resolution, engine, samples, exposure):
    scene = bpy.context.scene
    scene.render.engine = engine
    scene.render.resolution_x = resolution[0]
    scene.render.resolution_y = resolution[1]
    scene.render.resolution_percentage = 100
    scene.render.image_settings.file_format = 'PNG'
    scene.render.image_settings.color_mode = 'RGB'
    scene.render.image_settings.color_depth = '8'
    # 取消曝光，使用强环境光
    # scene.view_settings.exposure = exposure
    # AgX（Blender 4+默认）对室内场景会严重压暗；改用 Standard 线性映射，
    # 颜色准确且更亮，曝光完全由 exposure 参数控制。
    # scene.view_settings.view_transform = 'Standard'
    # scene.view_settings.look = 'None'

    if engine == 'CYCLES':
        scene.cycles.samples = samples
        scene.cycles.use_denoising = True
        scene.cycles.max_bounces = 4
        scene.cycles.diffuse_bounces = 2
        scene.cycles.glossy_bounces = 2
        scene.cycles.transmission_bounces = 2
        scene.cycles.transparent_max_bounces = 8
        enable_gpu()

    print(f"  渲染设置: {engine} {resolution[0]}x{resolution[1]} "
          f"samples={samples} exposure={exposure} view_transform=Standard")


def _world_has_effective_light(world) -> bool:
    """判断 World 节点是否能产生有效的环境光（Strength > 0.05）。
    GLB 导入的场景通常有一个 World 对象，但 Background Strength 可能为 0。
    """
    if world is None:
        return False
    if not world.use_nodes or world.node_tree is None:
        # 没用节点系统：用旧 API 的纯色环境，认为有效
        return True
    for node in world.node_tree.nodes:
        if node.type == 'BACKGROUND':
            strength = node.inputs.get('Strength')
            if strength is not None:
                val = strength.default_value
                # 如果有链接（HDR 贴图等），视为有效
                if strength.is_linked or float(val) > 0.05:
                    return True
    return False


def setup_lighting(camera_position=None, scene_bounds=None):
    """
    设置照明（材质预览模式：仅使用强环境光，无其他光源，显示材质原始颜色和亮度）
    
    Args:
        camera_position: 相机位置 (x, y, z)（未使用）
        scene_bounds: 场景边界 (min, max)（未使用）
    """
    scene = bpy.context.scene
    
    # 添加环境光（材质预览模式）
    world = bpy.data.worlds.new("World")
    scene.world = world
    world.use_nodes = True
    
    # 获取节点树
    nodes = world.node_tree.nodes
    links = world.node_tree.links
    
    # 清除默认节点
    nodes.clear()
    
    # 创建背景节点 - 使用非常强的环境光（类似材质预览模式）
    # 只使用环境光，无其他光源，确保材质显示原始颜色和亮度，无明暗变化
    background = nodes.new('ShaderNodeBackground')
    background.inputs['Color'].default_value = (1.0, 1.0, 1.0, 1.0)  # 白色背景
    background.inputs['Strength'].default_value = 1.0  # 环境光强度（材质预览模式，避免过曝）
    
    # 创建输出节点
    output = nodes.new('ShaderNodeOutputWorld')
    
    # 连接节点
    links.new(background.outputs['Background'], output.inputs['Surface'])
    
    # === 不添加任何其他光源 ===
    # 只使用环境光，确保整个场景光照完全均匀，无距离衰减，无明暗变化
    # 这样材质会显示其原始颜色和亮度，就像Blender材质预览模式一样
    
    print("[INFO] 设置照明完成（材质预览模式：仅强环境光，无其他光源，显示材质原始颜色和亮度）")


def setup_depth_pass():
    """
    设置深度渲染 pass（Blender 5.0+ API）
    
    在 Blender 中启用 Z pass，用于获取深度信息。
    使用 Blender 5.0 新的 compositing_node_group API。
    """
    scene = bpy.context.scene
    
    # 启用 View Layer 的 Z pass
    view_layer = bpy.context.view_layer
    view_layer.use_pass_z = True
    
    # Blender 5.0: scene.node_tree 已移除，改用 compositing_node_group
    # 创建新的 CompositorNodeTree 并赋给场景
    tree = bpy.data.node_groups.new("DepthCompositor", "CompositorNodeTree")
    scene.compositing_node_group = tree
    nodes = tree.nodes
    links = tree.links
    
    # 创建 Render Layers 节点
    render_layers = nodes.new('CompositorNodeRLayers')
    render_layers.location = (0, 300)
    
    # Blender 5.0: 用 NodeGroupOutput 替代 CompositorNodeComposite
    output = nodes.new('NodeGroupOutput')
    output.location = (400, 300)
    tree.interface.new_socket(name="Image", in_out="OUTPUT", socket_type="NodeSocketColor")
    
    # 连接 RGB 输出
    links.new(render_layers.outputs['Image'], output.inputs['Image'])
    
    # 创建 File Output 节点（用于深度 EXR）
    file_output = nodes.new('CompositorNodeOutputFile')
    file_output.location = (400, 0)
    file_output.directory = ""  # 稍后在渲染时设置（Blender 5.0: 替代 base_path）
    file_output.format.media_type = 'IMAGE'  # Blender 5.0: 必须先设 media_type
    file_output.format.file_format = 'OPEN_EXR'
    file_output.format.color_depth = '32'
    file_output.format.exr_codec = 'ZIP'
    
    # Blender 5.0: file_output_items 替代 file_slots
    file_output.file_output_items.clear()
    file_output.file_output_items.new('FLOAT', "depth")
    
    # 连接深度输出
    links.new(render_layers.outputs['Depth'], file_output.inputs['depth'])
    
    print("[INFO] 深度 pass 已启用（Blender 5.0 API）")
    
    return file_output


# =====================================================================
# 渲染 + 深度转换 + 位姿保存（同进程，只移动相机）
# =====================================================================

def convert_depth_exr_to_npy(exr_path, npy_path):
    """EXR → NPY（Blender 内置 API，不依赖 OpenEXR 库）"""
    img = bpy.data.images.load(exr_path)
    w, h = img.size[0], img.size[1]
    pixels = np.array(img.pixels[:]).reshape(h, w, -1)
    depth = np.flipud(pixels[:, :, 0])

    unit_scale = bpy.context.scene.unit_settings.scale_length
    depth_m = depth * unit_scale
    depth_m[(depth_m > 1000.0) | (depth_m <= 0)] = 0.0

    np.save(npy_path, depth_m.astype(np.float32))
    bpy.data.images.remove(img)
    try:
        os.remove(exr_path)
    except OSError:
        pass


def render_frame_inprocess(cam_obj, frame_id, camera_pos, camera_rot,
                           output_dir, depth_fo):
    """同进程渲染一帧，返回 (rgb_path, depth_path, pose_path)"""
    cam_obj.location = Vector(camera_pos)
    cam_obj.rotation_euler = Euler(camera_rot, 'XYZ')

    base = f"panorama_{frame_id:04d}"
    rgb_path = os.path.join(output_dir, f"{base}.png")
    depth_npy = os.path.join(output_dir, f"{base}_depth.npy")
    pose_path = os.path.join(output_dir, f"pose_{frame_id:04d}.json")

    bpy.context.scene.render.filepath = rgb_path

    abs_dir = os.path.abspath(output_dir)
    depth_fo.directory = abs_dir
    depth_fo.file_name = base + "_"
    depth_exr = os.path.join(abs_dir, base + "_depth.exr")

    bpy.context.scene.frame_set(frame_id)
    bpy.ops.render.render(write_still=True)

    # 深度转换
    if os.path.exists(depth_exr):
        convert_depth_exr_to_npy(depth_exr, depth_npy)
    else:
        import glob
        hits = glob.glob(os.path.join(abs_dir, f"*{base}*depth*.exr"))
        if hits:
            convert_depth_exr_to_npy(hits[0], depth_npy)
        else:
            print(f"    [WARN] 未找到深度 EXR: {depth_exr}")
            depth_npy = None

    # 位姿（与 render_erp_blender.py save_pose 完全一致的格式）
    save_pose(cam_obj, pose_path, frame_id)

    return rgb_path, depth_npy, pose_path


def save_pose(camera_object, output_path, frame_id):
    """保存位姿（绝对位姿，cam_to_world，兼容 ERPT）

    格式与 render_erp_blender.py 的 save_pose 完全一致：
      R_cw_erpt = T @ R_obj_blender @ M
    """
    unit_scale = bpy.context.scene.unit_settings.scale_length

    abs_pos_b = list(camera_object.location)
    abs_quat_b = camera_object.rotation_euler.to_quaternion()

    # Blender(X右,Y前,Z上) → 统一(X右,Y上,Z前)
    abs_pos_u = [
        abs_pos_b[0] * unit_scale,   # X
        abs_pos_b[2] * unit_scale,   # Y_unified = Z_blender
        abs_pos_b[1] * unit_scale,   # Z_unified = Y_blender
    ]

    R_obj = abs_quat_b.to_matrix()
    T = Matrix([[1, 0, 0], [0, 0, 1], [0, 1, 0]])
    M = Matrix([[1, 0, 0], [0, 1, 0], [0, 0, -1]])
    R_cw = T @ R_obj @ M
    q = R_cw.to_quaternion()

    pose_data = {
        "frame_id": frame_id,
        "position": abs_pos_u,
        "rotation_quaternion": [q.w, q.x, q.y, q.z],
        "camera_type": "erp_ray",
        "coordinate_system": "right-handed, Y-up, Z-forward (cam_to_world)",
        "render_method": "blender_cycles",
    }
    with open(output_path, 'w') as f:
        json.dump(pose_data, f, indent=2)


# =====================================================================
# 选帧核心（向量化，内嵌）
# =====================================================================

def build_ray_directions(H=WARP_H, W=WARP_W):
    """向量化构建 ERP 射线方向（Z-up）"""
    i = np.arange(H, dtype=np.float64)
    j = np.arange(W, dtype=np.float64)
    phi = np.pi / 2 - np.pi * (i + 0.5) / H
    theta = 2 * np.pi * (j + 0.5) / W
    phi, theta = np.meshgrid(phi, theta, indexing='ij')
    return np.stack([
        np.cos(phi) * np.cos(theta),
        np.cos(phi) * np.sin(theta),
        np.sin(phi),
    ], axis=-1)


_ray_dirs_cache = {}


def get_ray_dirs(H=WARP_H, W=WARP_W):
    if (H, W) not in _ray_dirs_cache:
        _ray_dirs_cache[(H, W)] = build_ray_directions(H, W)
    return _ray_dirs_cache[(H, W)]


def depth_to_3d_points(position, depth, ray_dirs, max_depth=None):
    valid = depth > 0
    if max_depth is not None:
        valid &= (depth <= max_depth)
    if not np.any(valid):
        return np.empty((0, 3), dtype=np.float64)
    pos = np.array(position, dtype=np.float64)
    return (pos + ray_dirs * depth[..., np.newaxis])[valid]


def project_points_to_coverage(pts, tgt_pos, H=WARP_H, W=WARP_W):
    """把累积点云投影到候选位置的全景图，返回覆盖 mask。"""
    if len(pts) == 0:
        return np.zeros((H, W), dtype=bool)
    tgt = np.array(tgt_pos, dtype=np.float64)
    vecs = pts - tgt
    x, y, z = vecs[:, 0], vecs[:, 1], vecs[:, 2]
    r_xy = np.sqrt(x ** 2 + y ** 2)
    phi = np.arctan2(z, r_xy)
    theta = np.arctan2(y, x) % (2 * np.pi)
    vi = np.clip(((np.pi / 2 - phi) / np.pi * H).astype(np.int32), 0, H - 1)
    uj = np.clip((theta / (2 * np.pi) * W).astype(np.int32), 0, W - 1)
    cov = np.zeros((H, W), dtype=bool)
    cov[vi, uj] = True
    pad = cov.copy()
    pad[1:, :] |= cov[:-1, :]
    pad[:-1, :] |= cov[1:, :]
    pad[:, 1:] |= cov[:, :-1]
    pad[:, :-1] |= cov[:, 1:]
    return pad


# ---- GPU 加速（延迟初始化，Phase 2 第一次选帧时检测）----
_GPU_BACKEND = None
_gpu_lib = None
_gpu_checked = False

def _init_gpu():
    """延迟初始化 GPU，避免模块加载时显存冲突"""
    global _GPU_BACKEND, _gpu_lib, _gpu_checked
    if _gpu_checked:
        return
    _gpu_checked = True

    try:
        import torch
        if torch.cuda.is_available():
            _GPU_BACKEND = "torch"
            _gpu_lib = torch
            print(f"[GPU] torch {torch.__version__} (CUDA)，选帧将使用 GPU 加速")
            return
    except ImportError:
        pass

    try:
        import cupy as cp
        try:
            cp.get_default_memory_pool().free_all_blocks()
            cp.get_default_pinned_memory_pool().free_all_blocks()
        except Exception:
            pass
        cp.zeros(1)
        _GPU_BACKEND = "cupy"
        _gpu_lib = cp
        print(f"[GPU] cupy {cp.__version__}，选帧将使用 GPU 加速")
        return
    except Exception as e:
        print(f"[Warning] cupy 初始化失败: {e}")

    print("[CPU] 未检测到 torch/cupy，选帧使用 CPU")


def _batch_coverage_gpu(pts_np, candidate_positions, remaining_indices, H, W):
    """GPU 批量投影：逐候选在 GPU 上算覆盖数

    返回: dict[ci] -> covered_pixels (int)
    """
    total_px = H * W
    results = {}

    if _GPU_BACKEND == "torch":
        import torch
        device = torch.device("cuda")
        pts_gpu = torch.from_numpy(pts_np).double().to(device)
        PI = torch.pi
        TWO_PI = 2 * torch.pi

        for ci in remaining_indices:
            tgt = torch.tensor(candidate_positions[ci], dtype=torch.float64, device=device)
            vecs = pts_gpu - tgt
            x, y, z = vecs[:, 0], vecs[:, 1], vecs[:, 2]
            r_xy = torch.sqrt(x ** 2 + y ** 2)
            phi = torch.atan2(z, r_xy)
            theta = torch.atan2(y, x) % TWO_PI
            vi = torch.clamp(((PI / 2 - phi) / PI * H).long(), 0, H - 1)
            uj = torch.clamp((theta / TWO_PI * W).long(), 0, W - 1)

            flat = vi * W + uj
            cov = torch.zeros(total_px, dtype=torch.bool, device=device)
            cov[flat] = True
            cov_2d = cov.view(H, W)
            pad = cov_2d.clone()
            pad[1:, :] |= cov_2d[:-1, :]
            pad[:-1, :] |= cov_2d[1:, :]
            pad[:, 1:] |= cov_2d[:, :-1]
            pad[:, :-1] |= cov_2d[:, 1:]
            results[ci] = int(pad.sum().item())

    elif _GPU_BACKEND == "cupy":
        import cupy as cp
        pts_gpu = cp.asarray(pts_np, dtype=cp.float64)
        PI = cp.pi
        TWO_PI = 2 * cp.pi

        for ci in remaining_indices:
            tgt = cp.array(candidate_positions[ci], dtype=cp.float64)
            vecs = pts_gpu - tgt
            x, y, z = vecs[:, 0], vecs[:, 1], vecs[:, 2]
            r_xy = cp.sqrt(x ** 2 + y ** 2)
            phi = cp.arctan2(z, r_xy)
            theta = cp.arctan2(y, x) % TWO_PI
            vi = cp.clip(((PI / 2 - phi) / PI * H).astype(cp.int32), 0, H - 1)
            uj = cp.clip((theta / TWO_PI * W).astype(cp.int32), 0, W - 1)

            flat = vi * W + uj
            cov = cp.zeros(total_px, dtype=cp.bool_)
            cov[flat] = True
            cov_2d = cov.reshape(H, W)
            pad = cov_2d.copy()
            pad[1:, :] |= cov_2d[:-1, :]
            pad[:-1, :] |= cov_2d[1:, :]
            pad[:, 1:] |= cov_2d[:, :-1]
            pad[:, :-1] |= cov_2d[:, 1:]
            results[ci] = int(cp.sum(pad))

    return results


def trim_depth(new_depth, new_pos, existing_pts, ray_dirs):
    H, W = new_depth.shape
    n_orig = int(np.sum(new_depth > 0))
    if len(existing_pts) == 0:
        return new_depth.copy(), n_orig, n_orig
    cov = project_points_to_coverage(existing_pts, new_pos, H, W)
    trimmed = new_depth.copy()
    trimmed[cov] = 0
    return trimmed, n_orig, int(np.sum(trimmed > 0))


def load_depth_downsampled(path, H=WARP_H, W=WARP_W):
    d = np.load(path).astype(np.float32)
    d = np.nan_to_num(d, nan=0.0)
    if d.shape == (H, W):
        return d
    try:
        import cv2
        return cv2.resize(d, (W, H), interpolation=cv2.INTER_AREA)
    except ImportError:
        h, w = d.shape
        bh, bw = h // H, w // W
        if bh < 1 or bw < 1:
            r = np.zeros((H, W), dtype=np.float32)
            r[:min(h, H), :min(w, W)] = d[:min(h, H), :min(w, W)]
            return r
        return d[:bh * H, :bw * W].reshape(H, bh, W, bw).mean(axis=(1, 3))


def select_next_frame(candidates, selected_idx, selected_pos,
                      all_pts, reachable=None):
    """选下一帧：纯贪心，选 score 最高的候选

    reachable: set of candidate indices，可达候选集合。
               None = 不限制。
    cupy 可用时自动 GPU 加速。
    """
    n = len(candidates)
    H, W = WARP_H, WARP_W
    total_px = H * W
    overlap_penalty = DEFAULT_OVERLAP_PENALTY

    remaining = []
    for i in range(n):
        if i in selected_idx:
            continue
        if reachable is not None and i not in reachable:
            continue
        remaining.append(i)

    if not remaining:
        return -1, 0.0, -999.0, 0

    # ---- GPU 路径 ----
    _init_gpu()
    if _GPU_BACKEND and len(all_pts) > 0:
        covered_map = _batch_coverage_gpu(all_pts, candidates, remaining, H, W)
        scores = {}
        for ci in remaining:
            covered = covered_map.get(ci, 0)
            new_r = (total_px - covered) / total_px
            ovl_r = covered / total_px
            scores[ci] = {
                "gain": new_r,
                "overlap": ovl_r,
                "score": new_r - overlap_penalty * ovl_r,
            }
    else:
        # ---- CPU 路径 ----
        scores = {}
        for ci in remaining:
            cov = project_points_to_coverage(all_pts, candidates[ci], H, W)
            covered = int(np.sum(cov))
            new_r = (total_px - covered) / total_px
            ovl_r = covered / total_px
            scores[ci] = {
                "gain": new_r,
                "overlap": ovl_r,
                "score": new_r - overlap_penalty * ovl_r,
            }

    best_ci, best_sc, best_g = -1, -999.0, 0.0
    for ci in remaining:
        if scores[ci]["score"] > best_sc:
            best_sc = scores[ci]["score"]
            best_ci = ci
            best_g = scores[ci]["gain"]

    return best_ci, best_g, best_sc, len(remaining)


def compute_max_depth(candidates):
    pos_arr = np.array(candidates)
    diag = float(np.linalg.norm(pos_arr.max(0) - pos_arr.min(0)))
    return diag * 1.5


# =====================================================================
# Phase 2: 边渲边选主循环
# =====================================================================

def run_phase2(cam_obj, candidates, mesh_center, output_dir,
               max_frames, resolution, depth_fo, args):

    ray_dirs = get_ray_dirs(WARP_H, WARP_W)
    max_depth = compute_max_depth(candidates)

    scene_diag = float(np.linalg.norm(
        np.array(candidates).max(0) - np.array(candidates).min(0)))

    selected_idx = set()
    selected_pos = []
    all_pts = np.empty((0, 3), dtype=np.float64)
    pts_chunks = []
    results = []

    # 可达性
    reachable = set()

    actual_gain_history = []
    delta_history = []

    # ======== 楼层分组（候选按 Z 聚类）========
    z_vals = sorted(set(round(c[2], 2) for c in candidates))
    floors = [[z_vals[0]]]
    for z in z_vals[1:]:
        if z - floors[-1][-1] > 1.0:
            floors.append([z])
        else:
            floors[-1].append(z)

    # 每个候选标记楼层（找 Z 最近的楼层）
    n_floors = len(floors)
    floor_mids = [sum(f) / len(f) for f in floors]  # 每层的 Z 中心
    candidate_floor = []
    for c in candidates:
        cz = c[2]
        fi = min(range(n_floors), key=lambda i: abs(cz - floor_mids[i]))
        candidate_floor.append(fi)

    current_floor = 0

    # 当前楼层的候选索引集合
    def floor_set(fi):
        return set(i for i, f in enumerate(candidate_floor) if f == fi)

    floor_names = [f"楼层{i+1}(Z={min(f):.1f}~{max(f):.1f})" for i, f in enumerate(floors)]

    print(f"\n{'='*60}")
    print(f"[Phase 2] 边渲边选 (候选={len(candidates)}, 固定={max_frames}帧)")
    print(f"{'='*60}")
    print(f"  {n_floors} 个楼层: {floor_names}")
    print(f"  高度层: {['%.2f' % z for z in z_vals]}")
    print(f"  选帧策略: 楼层顺序 + 层内全局最优 (可达优先, 无提前停止)")

    t_total = time.time()

    # 时间统计
    time_select = 0.0
    time_render = 0.0
    time_depth = 0.0
    time_reach = 0.0

    for frame_count in range(max_frames):

        # ======== 选位置 ========
        t_sel = time.time()
        if frame_count == 0:
            # F0: XY 取第一楼层候选的几何中心，Z 取高度层中心
            floor0_candidates = [(i, c) for i, c in enumerate(candidates)
                                 if candidate_floor[i] == 0]
            if floor0_candidates:
                f0_pts = np.array([c for _, c in floor0_candidates])
                xy_center = f0_pts[:, :2].mean(axis=0)  # XY 几何中心
                floor0_zs = sorted(set(c[2] for _, c in floor0_candidates))
                z_target = min(floor0_zs) + 1.2  # 楼板高度 + 1.7m ≈ 人眼高度
                target = np.array([xy_center[0], xy_center[1], z_target])
                dists_to_target = [np.linalg.norm(np.array(c) - target)
                                   for _, c in floor0_candidates]
                best_idx = int(np.argmin(dists_to_target))
                ci = floor0_candidates[best_idx][0]
            else:
                mc = np.array(mesh_center, dtype=np.float64)
                ci = int(np.argmin([np.linalg.norm(np.array(c) - mc)
                                     for c in candidates]))
            gain, score = 1.0, 1.0
            print(f"\n  F{frame_count}: 选候选[{ci}] "
                  f"(楼层中心, Z={candidates[ci][2]:.2f}m) "
                  f"[{floor_names[current_floor]}]")
        else:
            cur_floor_ids = floor_set(current_floor)
            floor_reachable = reachable & cur_floor_ids if reachable else set()

            ci, gain, score, n_remain = select_next_frame(
                candidates, selected_idx, selected_pos, all_pts,
                reachable=floor_reachable if floor_reachable else cur_floor_ids)

            # 当前楼层可达候选不够 → 扩展到当前楼层全局
            if ci < 0:
                ci, gain, score, n_remain = select_next_frame(
                    candidates, selected_idx, selected_pos, all_pts,
                    reachable=cur_floor_ids)

            # 当前楼层无候选 → 切换楼层
            if ci < 0:
                current_floor += 1
                if current_floor < n_floors:
                    print(f"\n  F{frame_count}: {floor_names[current_floor-1]} 候选用尽,"
                          f" 切换到 {floor_names[current_floor]}")
                    ci, gain, score, n_remain = select_next_frame(
                        candidates, selected_idx, selected_pos, all_pts,
                        reachable=floor_set(current_floor))
                    if ci < 0:
                        ci, gain, score, n_remain = select_next_frame(
                            candidates, selected_idx, selected_pos, all_pts,
                            reachable=None)

            # 全局无候选 → 无法继续
            if ci < 0:
                print(f"\n  F{frame_count}: 所有候选已用尽，停止 (已渲染 {len(results)} 帧)")
                break

            print(f"\n  F{frame_count}: 选候选[{ci}]  "
                  f"gain={gain:.1%}  score={score:.3f}  剩余={n_remain}"
                  f"  [Z={candidates[ci][2]:.2f} {floor_names[current_floor]}"
                  f" 可达={len(floor_reachable)}]")

        pos = candidates[ci]
        selected_idx.add(ci)
        selected_pos.append(pos)
        dt_sel = time.time() - t_sel
        time_select += dt_sel
        if frame_count > 0:
            print(f"    [选帧 {dt_sel:.1f}s]")

        # ======== 渲染 ========
        cam_rot = get_camera_rot(args.rotation_type, frame_count)
        print(f"    位置: [{pos[0]:.2f}, {pos[1]:.2f}, {pos[2]:.2f}]")
        print(f"    渲染...", end="", flush=True)
        t_r = time.time()

        rgb_path, depth_path, pose_path = render_frame_inprocess(
            cam_obj, frame_count, pos, cam_rot, output_dir, depth_fo)
        dt_r = time.time() - t_r
        time_render += dt_r
        print(f" {dt_r:.1f}s")

        # ======== depth → 3D 点云 ========
        t_dep = time.time()
        actual_gain = 1.0
        delta_ratio = 1.0

        if depth_path and os.path.exists(depth_path):
            depth = load_depth_downsampled(depth_path, WARP_H, WARP_W)
            total_px = WARP_H * WARP_W
            n_valid = int(np.sum(depth > 0))
            valid_ratio = n_valid / total_px

            if frame_count == 0:
                new_pts = depth_to_3d_points(pos, depth, ray_dirs, max_depth)
                pts_chunks.append(new_pts)
                all_pts = new_pts
                actual_gain = valid_ratio
                print(f"    depth: {n_valid}px ({valid_ratio:.0%} 有效)"
                      f" → {len(new_pts)} 个 3D 点 (全部)")
            else:
                # ---- 质量检查 ----
                MIN_VALID_RATIO = 0.30
                if valid_ratio < MIN_VALID_RATIO:
                    print(f"    depth: {n_valid}px ({valid_ratio:.0%} 有效)"
                          f" < {MIN_VALID_RATIO:.0%} → 室外/空壳，跳过此帧")
                    results.append({
                        "frame_id": frame_count,
                        "candidate_idx": ci,
                        "position": pos,
                        "gain": float(gain),
                        "actual_gain": 0.0,
                        "delta_ratio": 0.0,
                        "score": float(score),
                        "skipped": True,
                        "skip_reason": f"valid_ratio={valid_ratio:.1%}",
                    })
                    for fp in [rgb_path, depth_path]:
                        if fp and os.path.exists(fp):
                            try:
                                os.remove(fp)
                            except OSError:
                                pass
                    time_depth += time.time() - t_dep
                    continue

                trimmed, n_orig, n_new = trim_depth(
                    depth, pos, all_pts, ray_dirs)
                new_pts = depth_to_3d_points(pos, trimmed, ray_dirs, max_depth)
                pts_chunks.append(new_pts)
                all_pts = np.concatenate(pts_chunks)
                actual_gain = n_new / total_px
                delta_ratio = (len(new_pts) / len(all_pts)
                               if len(all_pts) > 0 else 1.0)
                print(f"    depth: {n_valid}px ({valid_ratio:.0%} 有效)"
                      f" → trim → {n_new}px 新增"
                      f" → {len(new_pts)} 个新 3D 点 (delta)")
                print(f"    累积点云: {len(all_pts)}")
                print(f"    实际gain: {actual_gain:.1%}, "
                      f"点云增量: {delta_ratio:.1%}")
        else:
            print(f"    [Error] 无 depth 文件！")
            break

        results.append({
            "frame_id": frame_count,
            "candidate_idx": ci,
            "position": pos,
            "gain": float(gain),
            "actual_gain": float(actual_gain),
            "delta_ratio": float(delta_ratio),
            "score": float(score),
        })
        time_depth += time.time() - t_dep

        # ======== 更新可达性 ========
        if IN_BLENDER:
            t_reach = time.time()
            scene = bpy.context.scene
            depsgraph = bpy.context.evaluated_depsgraph_get()
            n_new_reachable = 0
            for ci_check in range(len(candidates)):
                if ci_check in selected_idx or ci_check in reachable:
                    continue
                origin = Vector(pos)
                target = Vector(candidates[ci_check])
                direction = (target - origin).normalized()
                dist_to_target = (target - origin).length

                if dist_to_target < 0.1:
                    reachable.add(ci_check)
                    n_new_reachable += 1
                    continue

                hit, loc, *_ = scene.ray_cast(depsgraph, origin, direction)
                if not hit or (loc - origin).length >= dist_to_target * 0.95:
                    reachable.add(ci_check)
                    n_new_reachable += 1

            dt_reach = time.time() - t_reach
            time_reach += dt_reach
            print(f"    [可达性] 新增 {n_new_reachable} 个可达候选, "
                  f"总可达 {len(reachable)} / {len(candidates)} "
                  f"({dt_reach:.1f}s)")

        if frame_count > 0:
            actual_gain_history.append(actual_gain)
            delta_history.append(delta_ratio)

    # ======== 补帧：候选不足时生成扰动位置补齐到 max_frames ========
    valid_results = [r for r in results if not r.get("skipped")]
    if len(valid_results) < max_frames:
        need = max_frames - len(valid_results)
        print(f"\n  [补帧] 有效帧 {len(valid_results)}/{max_frames}，需补 {need} 帧")

        scene = bpy.context.scene
        depsgraph = bpy.context.evaluated_depsgraph_get()
        frame_count = (results[-1]["frame_id"] + 1) if results else 0
        PERTURB_OFFSETS = [0.2, 0.3, 0.15, 0.25, 0.35]
        perturb_round = 0

        while len(valid_results) < max_frames:
            # 先尝试未使用的原始候选
            ci_sup, gain_sup, score_sup, _ = select_next_frame(
                candidates, selected_idx, selected_pos, all_pts, reachable=None)

            if ci_sup >= 0:
                pos = candidates[ci_sup]
                selected_idx.add(ci_sup)
                selected_pos.append(pos)
                label = f"候选[{ci_sup}]"
            else:
                # 原始候选用尽 → 从已选位置生成扰动位置
                offset = PERTURB_OFFSETS[perturb_round % len(PERTURB_OFFSETS)]
                perturb_round += 1
                found = False

                _random.shuffle(selected_pos)
                for base_pos in selected_pos:
                    for _ in range(20):
                        dx = _random.uniform(-offset, offset)
                        dy = _random.uniform(-offset, offset)
                        new_pos = [base_pos[0] + dx, base_pos[1] + dy, base_pos[2]]

                        # raycast 验证：上下必须 hit（在室内）
                        origin = Vector(new_pos)
                        hit_up, *_ = scene.ray_cast(depsgraph, origin, Vector((0, 0, 1)))
                        hit_dn, *_ = scene.ray_cast(depsgraph, origin, Vector((0, 0, -1)))
                        if hit_up and hit_dn:
                            pos = new_pos
                            selected_pos.append(pos)
                            found = True
                            break
                    if found:
                        break

                if not found:
                    print(f"    无法生成有效扰动位置，停止补帧")
                    break
                label = f"扰动(±{offset:.2f}m)"
                gain_sup, score_sup = 0.0, 0.0

            cam_rot = get_camera_rot(args.rotation_type, frame_count)
            print(f"    补帧 F{frame_count}: {label}"
                  f" [{pos[0]:.2f}, {pos[1]:.2f}, {pos[2]:.2f}]")
            print(f"    渲染...", end="", flush=True)
            t_r = time.time()
            rgb_path, depth_path, pose_path = render_frame_inprocess(
                cam_obj, frame_count, pos, cam_rot, output_dir, depth_fo)
            dt_r = time.time() - t_r
            time_render += dt_r
            print(f" {dt_r:.1f}s")

            actual_gain = 0.0
            delta_ratio = 0.0
            skipped = False
            if depth_path and os.path.exists(depth_path):
                depth = load_depth_downsampled(depth_path, WARP_H, WARP_W)
                total_px = WARP_H * WARP_W
                n_valid = int(np.sum(depth > 0))
                valid_ratio = n_valid / total_px
                if valid_ratio < 0.30:
                    skipped = True
                    for fp in [rgb_path, depth_path]:
                        if fp and os.path.exists(fp):
                            try:
                                os.remove(fp)
                            except OSError:
                                pass
                    print(f"    valid={valid_ratio:.0%} < 30% → 跳过")
                else:
                    trimmed, n_orig, n_new = trim_depth(depth, pos, all_pts, ray_dirs)
                    new_pts = depth_to_3d_points(pos, trimmed, ray_dirs, max_depth)
                    pts_chunks.append(new_pts)
                    all_pts = np.concatenate(pts_chunks)
                    actual_gain = n_new / total_px
                    delta_ratio = len(new_pts) / len(all_pts) if len(all_pts) > 0 else 0
                    print(f"    depth: {n_new}px 新增, gain={actual_gain:.1%}")

            result_entry = {
                "frame_id": frame_count,
                "position": pos,
                "gain": float(gain_sup),
                "actual_gain": float(actual_gain),
                "delta_ratio": float(delta_ratio),
                "score": float(score_sup),
                "supplementary": True,
            }
            if skipped:
                result_entry["skipped"] = True
            results.append(result_entry)

            if not skipped:
                valid_results = [r for r in results if not r.get("skipped")]

            frame_count += 1

        valid_results = [r for r in results if not r.get("skipped")]
        print(f"  补帧完成: 有效帧 {len(valid_results)}/{max_frames}")

    dt = time.time() - t_total
    time_other = dt - time_select - time_render - time_depth - time_reach
    print(f"\n  {'─'*50}")
    print(f"  共 {len(results)} 帧, {dt:.1f}s ({dt/60:.1f}min)")
    print(f"  耗时分布:")
    print(f"    选帧:   {time_select:.1f}s ({time_select/max(dt,1)*100:.0f}%)"
          f"  — 点云投影评估候选")
    print(f"    渲染:   {time_render:.1f}s ({time_render/max(dt,1)*100:.0f}%)"
          f"  — Blender Cycles GPU")
    print(f"    深度:   {time_depth:.1f}s ({time_depth/max(dt,1)*100:.0f}%)"
          f"  — depth→点云+trim")
    print(f"    可达性: {time_reach:.1f}s ({time_reach/max(dt,1)*100:.0f}%)"
          f"  — raycast 扫描")
    if time_other > 1:
        print(f"    其他:   {time_other:.1f}s ({time_other/max(dt,1)*100:.0f}%)")

    return results


# =====================================================================
# 自动曝光
# =====================================================================

def auto_adjust_exposure(cam_obj, test_pos, output_dir, initial_exposure):
    """F0 位置低采样快速渲一帧，分析亮度，自动调整 exposure。

    目标：有效像素平均亮度 ≈ 120/255。
    过曝 (>200): 降 EV
    欠曝 (<40):  升 EV
    正常 (40~200): 不动
    """
    TARGET_MEAN = 120.0
    scene = bpy.context.scene
    original_samples = scene.cycles.samples

    # 低采样快速测试
    scene.cycles.samples = 16
    test_path = os.path.join(output_dir, "_exposure_test.png")
    scene.render.filepath = test_path

    cam_obj.location = Vector(test_pos)
    cam_obj.rotation_euler = Euler((math.pi / 2, 0, 0), 'XYZ')

    print(f"\n[自动曝光] 测试渲染 (16 samples, exposure={initial_exposure:.1f})...",
          end="", flush=True)
    t0 = time.time()
    bpy.ops.render.render(write_still=True)
    print(f" {time.time() - t0:.1f}s")

    # 分析亮度
    img = bpy.data.images.load(test_path)
    w, h = img.size[0], img.size[1]
    pixels = np.array(img.pixels[:]).reshape(h, w, -1)
    rgb = pixels[:, :, :3]
    brightness = (0.299 * rgb[:,:,0] + 0.587 * rgb[:,:,1] + 0.114 * rgb[:,:,2]) * 255

    # 只看非纯黑像素（排除天空/无效区域）
    valid_mask = brightness > 1.0
    n_valid = int(np.sum(valid_mask))
    if n_valid > 0:
        mean_b = float(np.mean(brightness[valid_mask]))
        # 过曝比例（亮度 > 250 的像素占比）
        overexposed = float(np.sum(brightness[valid_mask] > 250)) / n_valid
        # 欠曝比例（亮度 < 10 的像素占比）
        underexposed = float(np.sum(brightness[valid_mask] < 10)) / n_valid
    else:
        mean_b = 0.0
        overexposed = 0.0
        underexposed = 1.0

    bpy.data.images.remove(img)
    try:
        os.remove(test_path)
    except OSError:
        pass

    print(f"  亮度分析: 平均={mean_b:.0f}/255, "
          f"过曝={overexposed:.0%}, 欠曝={underexposed:.0%}, "
          f"有效像素={n_valid}/{h*w}")

    # 调整
    new_exposure = initial_exposure
    if mean_b < 1.0:
        new_exposure = initial_exposure + 4.0
        print(f"  [严重欠曝] exposure: {initial_exposure:.1f} → {new_exposure:.1f} (+4.0 EV)")
    elif mean_b < 40:
        ev_adj = min(4.0, math.log2(TARGET_MEAN / max(mean_b, 1.0)))
        new_exposure = initial_exposure + ev_adj + 1.0  # 额外 +1
        print(f"  [欠曝] exposure: {initial_exposure:.1f} → {new_exposure:.1f} (+{ev_adj:.1f} EV)")
    elif mean_b > 200:
        ev_adj = max(-4.0, math.log2(TARGET_MEAN / mean_b))
        new_exposure = initial_exposure + ev_adj
        print(f"  [过曝] exposure: {initial_exposure:.1f} → {new_exposure:.1f} ({ev_adj:.1f} EV)")
    elif overexposed > 0.3:
        # 平均还行但大面积过曝
        new_exposure = initial_exposure - 1.5
        print(f"  [局部过曝 {overexposed:.0%}] exposure: {initial_exposure:.1f} → {new_exposure:.1f} (-1.5 EV)")
    else:
        print(f"  [正常] 曝光无需调整")

    # 限幅
    new_exposure = max(-2.0, min(12.0, new_exposure))

    scene.view_settings.exposure = new_exposure
    scene.cycles.samples = original_samples
    return new_exposure


# =====================================================================
# 有效天花板检测（忽略塔尖/天线等异常高点）
# =====================================================================

def _detect_effective_ceiling(bmin, bmax, floor_z, ceiling_z_raw):
    """用 raycast 从多个 XY 采样点往上打，统计天花板高度的 75% 分位数。

    塔尖、天线等只有少量采样点能 hit 到，被分位数过滤掉。
    """
    scene = bpy.context.scene
    depsgraph = bpy.context.evaluated_depsgraph_get()
    dir_up = Vector((0, 0, 1))

    cx = (bmin[0] + bmax[0]) / 2
    cy = (bmin[1] + bmax[1]) / 2
    x_range = bmax[0] - bmin[0]
    y_range = bmax[1] - bmin[1]

    # 5x5 网格采样
    ceil_hits = []
    for ix in range(5):
        for iy in range(5):
            x = bmin[0] + x_range * (ix + 0.5) / 5
            y = bmin[1] + y_range * (iy + 0.5) / 5
            origin = Vector((x, y, floor_z + 0.5))
            hit, loc, *_ = scene.ray_cast(depsgraph, origin, dir_up)
            if hit:
                ceil_hits.append(loc.z)

    if not ceil_hits:
        print(f"  [天花板] 无 hit，使用 AABB: {ceiling_z_raw:.2f}m")
        return ceiling_z_raw

    ceil_hits.sort()
    # 75% 分位数：忽略最高的 25%（塔尖/天线）
    p75_idx = int(len(ceil_hits) * 0.75)
    effective_ceil = ceil_hits[min(p75_idx, len(ceil_hits) - 1)]

    # 至少保留 AABB 高度的合理范围（不能比中位数还低太多）
    median_ceil = ceil_hits[len(ceil_hits) // 2]
    effective_ceil = max(effective_ceil, median_ceil)

    # 不能比最低的 hit 还低（安全下限）
    effective_ceil = max(effective_ceil, floor_z + 2.5)

    if effective_ceil < ceiling_z_raw - 1.0:
        print(f"  [天花板] AABB={ceiling_z_raw:.2f}m → 有效={effective_ceil:.2f}m"
              f" (忽略 {ceiling_z_raw - effective_ceil:.1f}m 塔尖/天线)")
    else:
        print(f"  [天花板] {effective_ceil:.2f}m")

    return effective_ceil


# =====================================================================
# Blender 模式主函数
# =====================================================================

def main_blender():
    args = parse_args_blender()

    # 统一 scene_path
    if args.blend:
        scene_path = os.path.abspath(args.blend)
    else:
        scene_path = os.path.abspath(args.glb)

    output_dir = os.path.abspath(args.output_dir)
    resolution = tuple(int(x) for x in args.resolution.split(","))
    os.makedirs(output_dir, exist_ok=True)
    

    scene_ext = Path(scene_path).suffix.lower()

    print("=" * 60)
    print("ERPT Blend Pipeline v5（单进程边渲边选）")
    print("=" * 60)
    print(f"  Scene:      {scene_path}  [{scene_ext}]")
    print(f"  Output:     {output_dir}")
    print(f"  Max frames: {args.num_frames}")
    print(f"  Resolution: {resolution[0]}x{resolution[1]}")
    t_start = time.time()

    # ===== Phase 0: 加载场景 =====
    load_scene(scene_path)

    # ===== 渲染设置（只做一次） =====
    print(f"\n[Setup] 渲染配置")
    cam_obj = setup_erp_camera()
    setup_render_settings(resolution, args.engine, args.samples, args.exposure)
    setup_lighting()
    depth_fo = setup_depth_pass()

    rooms = json.loads(args.rooms) if args.rooms else {"rooms": []}
    for room in rooms["rooms"]:
        print(f"  房间: {room['room_id']}")
        # input("\n按Enter键继续...")
        bmin, bmax = np.array(room['bounds_min']), np.array(room['bounds_max'])

        # ===== Phase 1: 撒点 + 过滤 =====
        print(f"\n{'='*60}")
        print("[Phase 1] 多层撒点 + 4层过滤")
        print(f"{'='*60}")

        floor_z_raw, ceiling_z_raw = bmin[2], bmax[2]

        # 有效天花板检测：用 raycast 忽略塔尖等异常高点
        ceiling_z = _detect_effective_ceiling(bmin, bmax, floor_z_raw, ceiling_z_raw)
        floor_z = floor_z_raw

        heights = compute_camera_heights(floor_z, ceiling_z, args.camera_height,
                                        bmin=bmin, bmax=bmax)
        print(f"  场景 Z 范围: {floor_z:.2f} ~ {ceiling_z:.2f}m (总高 {ceiling_z - floor_z:.2f}m)")
        print(f"  相机层数: {len(heights)}")
        for i, z in enumerate(heights):
            print(f"    第{i+1}层: Z={z:.2f}m (离地 {z - floor_z:.2f}m)")

        x_range = bmax[0] - bmin[0]
        y_range = bmax[1] - bmin[1]
        n_layers = len(heights)
        scene_diag = math.sqrt(x_range ** 2 + y_range ** 2)

        x_sp = max(0.5, x_range / 20)
        y_sp = max(0.5, y_range / 20)
        nx = max(1, int((x_range - 2 * MARGIN) / args.grid_spacing))
        ny = max(1, int((y_range - 2 * MARGIN) / args.grid_spacing))
        total_user = nx * ny * n_layers

        if total_user <= 10000:
            x_sp = args.grid_spacing
            y_sp = args.grid_spacing
            print(f"  间距: {args.grid_spacing}m (候选≈{total_user}个)")
        else:
            nx_auto = max(1, int((x_range - 2 * MARGIN) / x_sp))
            ny_auto = max(1, int((y_range - 2 * MARGIN) / y_sp))
            total_auto = nx_auto * ny_auto * n_layers
            print(f"  [自适应] 场景 {x_range:.0f}x{y_range:.0f}m, "
                f"X间距={x_sp:.1f}m, Y间距={y_sp:.1f}m "
                f"(候选≈{total_auto})")

        candidates = generate_candidate_grid(bmin, bmax, x_sp, y_sp, heights)
        if not candidates:
            print("  [Error] 没有候选点")
            # sys.exit(1)

        room_height = ceiling_z - floor_z
        candidates = raycast_6layer_filter(candidates, room_height)
        if not candidates:
            print("  [Warning] 全部被过滤，使用 mesh 中心")
            cx = (bmin[0] + bmax[0]) / 2
            cy = (bmin[1] + bmax[1]) / 2
            candidates = [[cx, cy, heights[0]]]

        sel_dir = os.path.join(output_dir, "frame_selection")
        os.makedirs(sel_dir, exist_ok=True)
        np.save(os.path.join(sel_dir, "candidates_filtered.npy"),
                np.array(candidates))

        # ===== 自动曝光：用候选中心点快速测试 =====
        mesh_center = [(bmin[0] + bmax[0]) / 2,
                    (bmin[1] + bmax[1]) / 2,
                    (bmin[2] + bmax[2]) / 2]
        # # 选最靠近中心的候选作为测试点
        # mc = np.array(mesh_center)
        # test_dists = [np.linalg.norm(np.array(c) - mc) for c in candidates]
        # test_pos = candidates[int(np.argmin(test_dists))]
        space_output = os.path.join(output_dir, f"space_{room['room_id']:02d}")
        # # final_exposure = auto_adjust_exposure(cam_obj, test_pos, output_dir, depth_fo, args.exposure)
        # exposure_rate = 0.5
        # exposure_count = 5
        # exposure1 = auto_adjust_exposure(cam_obj, test_pos, space_output, args.exposure)
        # exposure2 = auto_adjust_exposure(cam_obj, test_pos, space_output, exposure1)
        # count = 2
        # while abs(exposure1 - exposure2) > exposure_rate and count <= exposure_count:
        #     exposure1 = exposure2
        #     exposure2 = auto_adjust_exposure(cam_obj, test_pos, space_output, exposure2)
        #     count += 1
        # print(f"  最终曝光: {exposure2:.1f} (共调整 {count-1} 次)")
        # ===== Phase 2: 边渲边选 =====
        results = run_phase2(
            cam_obj, candidates, mesh_center, space_output,
            args.num_frames, resolution, depth_fo, args)

        # ===== 保存选帧摘要 =====
        summary = {
            "scene": os.path.basename(scene_path),
            "scene_format": scene_ext,
            "total_frames": len(results),
            "candidates_count": len(candidates),
            "frames": [{
                "frame_id": r["frame_id"],
                "position": r["position"],
                "gain": r["gain"],
                "actual_gain": r["actual_gain"],
                "delta_ratio": r["delta_ratio"],
                "score": r["score"],
            } for r in results],
        }
        
        with open(os.path.join(sel_dir, "selected_frames.json"), "w") as f:
            json.dump(summary, f, indent=2, ensure_ascii=False)

        dt = time.time() - t_start
        print(f"\n{'='*60}")
        print(f"完成! {len(results)} 帧, {dt:.1f}s ({dt/60:.1f}min)")
        print(f"{'='*60}")
        print(f"输出目录: {output_dir}/")
        for r in results:
            fid = r["frame_id"]
            print(f"  panorama_{fid:04d}.png  +  _depth.npy  +  pose_{fid:04d}.json")


# =====================================================================
# 入口
# =====================================================================

if __name__ == "__main__":
    if IN_BLENDER:
        main_blender()
    else:
        main_python()