# 導入必要庫
import detectron2
from detectron2.engine import DefaultPredictor  # Detectron2的默認預測器
from vlm_wrapper import VLM  # 用于LLaVA或類似VLM的假設性包裝器（需自行實現(xiàn)或調用現(xiàn)有API）
import cv2  # 用于圖像裁剪（需提前安裝：pip install opencv-python）

def run_detection(image, detectron2_config):
    """
    功能：使用Detectron2運行目標檢測，輸出邊界框
    參數(shù)：
        image: 輸入圖像（格式為numpy數(shù)組，如cv2.imread讀取的結果）
        detectron2_config: Detectron2的配置對象（需提前配置模型路徑、類別等）
    返回：
        boxes: 檢測到的邊界框列表（格式為[x1, y1, x2, y2]，代表矩形框的左上角和右下角坐標）
    """
    # 初始化Detectron2預測器
    predictor = DefaultPredictor(detectron2_config)
    # 執(zhí)行檢測，獲取輸出結果
    outputs = predictor(image)
    # 提取邊界框（從檢測結果的"instances"字段中獲取"pred_boxes"）
    boxes = outputs["instances"].pred_boxes.tensor.cpu().numpy()  # 轉換為numpy數(shù)組便于后續(xù)處理
    return boxes

def crop_image(image, box):
    """
    功能：根據(jù)邊界框裁剪圖像區(qū)域
    參數(shù)：
        image: 原始輸入圖像（numpy數(shù)組，BGR格式，cv2默認讀取格式）
        box: 單個邊界框（格式為[x1, y1, x2, y2]，坐標為整數(shù)）
    返回：
        cropped_image: 裁剪后的圖像區(qū)域（numpy數(shù)組）
    """
    # 將邊界框坐標轉換為整數(shù)（避免cv2裁剪報錯）
    x1, y1, x2, y2 = map(int, box)
    # 裁剪圖像（注意cv2圖像的坐標順序：y軸為先，x軸為后）
    cropped_image = image[y1:y2, x1:x2]
    return cropped_image

def verify_box(image, box, query, vlm_model):
    """
    功能：使用VLM驗證邊界框區(qū)域是否匹配查詢指令
    參數(shù)：
        image: 原始輸入圖像（numpy數(shù)組）
        box: 單個待驗證邊界框（格式為[x1, y1, x2, y2]）
        query: 用戶查詢指令（如“汽車”“動物”）
        vlm_model: 初始化后的VLM模型對象（如LLaVA、Florence-2）
    返回：
        is_valid: 布爾值，True表示邊界框匹配查詢，F(xiàn)alse表示不匹配
    """
    # 1. 根據(jù)邊界框裁剪圖像區(qū)域
    cropped_image = crop_image(image, box)
    # 2. 構造VLM的查詢prompt（提示詞），引導VLM輸出明確結果
    vlm_prompt = f"請判斷以下圖像區(qū)域是否包含'{query}'？僅需回答'是'或'否'，無需額外解釋。"
    # 3. 調用VLM模型獲取響應（假設VLM的query方法支持“圖像+文本”輸入）
    vlm_response = vlm_model.query(image=cropped_image, text=vlm_prompt)
    # 4. 解析VLM響應（忽略大小寫，判斷是否包含“是”）
    is_valid = "是"in vlm_response.lower()
    return is_valid

# ------------------- 代碼使用示例 -------------------
# 1. 配置Detectron2（需根據(jù)實際模型調整，此處以COCO預訓練模型為例）
from detectron2.config import get_cfg
cfg = get_cfg()
cfg.merge_from_file("detectron2/configs/COCO-Detection/faster_rcnn_R_50_FPN_3x.yaml")  # 加載配置文件
cfg.MODEL.WEIGHTS = "detectron2://COCO-Detection/faster_rcnn_R_50_FPN_3x/1378494582/model_final_280758.pkl"# 加載預訓練權重
cfg.MODEL.DEVICE = "cuda"if detectron2.utils.env.is_cuda_available() else"cpu"# 自動選擇CPU/GPU
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5# 置信度閾值（僅保留置信度>0.5的檢測結果）

# 2. 初始化VLM模型（假設使用Hugging Face的LLaVA模型）
vlm = VLM(model_name="liuhaotian/LLaVA-7b-v1.5")  # 加載LLaVA-7B模型

# 3. 讀取輸入圖像
image = cv2.imread("city_street.jpg")  # 讀取城市街道圖像
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # 轉換為RGB格式（部分VLM要求RGB輸入）

# 4. 運行檢測，獲取邊界框
detected_boxes = run_detection(image_rgb, cfg)

# 5. 驗證每個邊界框是否匹配查詢“汽車”
valid_boxes = []
query = "汽車"
for box in detected_boxes:
    if verify_box(image_rgb, box, query, vlm):
        valid_boxes.append(box)

# 6. 輸出結果
print(f"原始檢測到的邊界框數(shù)量：{len(detected_boxes)}")
print(f"VLM驗證后有效的邊界框數(shù)量：{len(valid_boxes)}")
print(f"有效邊界框坐標（x1, y1, x2, y2）：{valid_boxes}")

# 導入必要庫
from transformers import BlipProcessor, BlipForConditionalGeneration
from PIL import Image  # 用于圖像處理

def init_vlm_describer(model_name="Salesforce/blip-image-captioning-large"):
    """
    功能：初始化用于圖像描述的VLM（此處使用Salesforce的BLIP模型）
    參數(shù)：
        model_name: VLM模型名稱（Hugging Face模型庫中的名稱）
    返回：
        processor: VLM的圖像/文本處理器（用于預處理輸入）
        model: 初始化后的VLM模型
    """
    # 加載BLIP模型的處理器（負責圖像編碼和文本tokenize）
    processor = BlipProcessor.from_pretrained(model_name)
    # 加載BLIP模型（用于生成圖像描述）
    model = BlipForConditionalGeneration.from_pretrained(model_name)
    # 將模型移動到GPU（若有GPU可用）
    model = model.to("cuda"if torch.cuda.is_available() else"cpu")
    return processor, model

def vlm_describe_image(image_path, processor, model, max_length=50):
    """
    功能：使用VLM生成圖像的文字描述
    參數(shù)：
        image_path: 圖像文件路徑（如"fruit_bowl.jpg"）
        processor: VLM的處理器
        model: 初始化后的VLM模型
        max_length: 生成描述的最大長度（避免過長）
    返回：
        image_caption: 圖像的文字描述（字符串）
    """
    # 1. 讀取圖像（使用PIL庫，支持多種格式）
    image = Image.open(image_path).convert("RGB")  # 轉換為RGB格式
    # 2. 預處理圖像（按VLM要求調整尺寸、歸一化等）
    inputs = processor(images=image, return_tensors="pt").to(model.device)
    # 3. 生成圖像描述（使用beam search解碼，提升描述質量）
    outputs = model.generate(
        **inputs,
        max_length=max_length,
        num_beams=5,  #  beam search的 beam 數(shù)量（越大質量越高，速度越慢）
        early_stopping=True# 當生成結束符時停止
    )
    # 4. 解碼模型輸出（將token轉換為文字）
    image_caption = processor.decode(outputs[0], skip_special_tokens=True)
    return image_caption

# ------------------- 代碼使用示例 -------------------
# 1. 初始化VLM（圖像描述模型）
processor, vlm_model = init_vlm_describer()

# 2. 生成圖像描述
image_path = "fruit_bowl.jpg"# 一碗水果的圖像
caption = vlm_describe_image(image_path, processor, vlm_model)

# 3. 輸出結果
print(f"圖像描述：{caption}")
# 示例輸出："a bowl of fresh fruits including apples, oranges, and bananas placed on a wooden table"
# （中文翻譯：“一碗新鮮水果，包含蘋果、橙子和香蕉，放在木桌上”）

def critique_query(initial_query, vlm_processor, vlm_model):
    """
    功能：使用VLM評判并優(yōu)化初始查詢（解決指令模糊問題）
    參數(shù)：
        initial_query: 用戶輸入的初始查詢（如“找出動物”）
        vlm_processor: VLM的處理器
        vlm_model: 初始化后的VLM模型
    返回：
        refined_query: 優(yōu)化后的明確查詢（如“找出哺乳動物和鳥類”）
    """
    # 構造引導VLM優(yōu)化查詢的prompt
    critique_prompt = f"""
    請評判以下目標檢測查詢是否模糊：“{initial_query}”。
    若模糊，請?zhí)岢龀吻鍐栴}并生成優(yōu)化后的查詢（需明確檢測范圍）；若清晰，直接返回原查詢。
    輸出格式要求：僅返回優(yōu)化后的查詢，無需額外內容。
    """
    # 調用VLM生成優(yōu)化后的查詢
    inputs = vlm_processor(text=critique_prompt, return_tensors="pt").to(vlm_model.device)
    outputs = vlm_model.generate(**inputs, max_length=100, num_beams=3)
    refined_query = vlm_processor.decode(outputs[0], skip_special_tokens=True)
    return refined_query

def run_batched_detection(image, query, detector, batch_size=5):
    """
    功能：分批次運行目標檢測（降低單次計算壓力，支持動態(tài)調整類別）
    參數(shù)：
        image: 輸入圖像（numpy數(shù)組/RGB格式）
        query: 優(yōu)化后的查詢（明確檢測類別）
        detector: 初始化后的目標檢測器（如YOLOv8）
        batch_size: 每批次檢測的類別數(shù)量（默認5）
    返回：
        all_boxes: 所有批次檢測到的邊界框列表
    """
    # 1. 從查詢中提取檢測類別（如“找出汽車、卡車、自行車”→ 類別列表：["汽車", "卡車", "自行車"]）
    classes = extract_classes_from_query(query)  # 需自行實現(xiàn)：基于NLP提取類別
    # 2. 分批次檢測（避免單次輸入過多類別導致檢測器性能下降）
    all_boxes = []
    for i in range(0, len(classes), batch_size):
        batch_classes = classes[i:i+batch_size]
        # 調整檢測器的目標類別（僅檢測當前批次的類別）
        detector.set_classes(batch_classes)
        # 運行檢測，獲取當前批次的邊界框
        batch_boxes = detector.detect(image)
        all_boxes.extend(batch_boxes)
    return all_boxes

def agentic_pipeline(
    image_path, 
    initial_query, 
    vlm_processor, 
    vlm_model, 
    detector, 
    confidence_threshold=0.7, 
    max_iteratinotallow=3
):
    """
    功能：完整的智能體目標檢測管道（循環(huán)迭代優(yōu)化）
    參數(shù)：
        image_path: 圖像文件路徑
        initial_query: 用戶初始查詢
        vlm_processor: VLM處理器
        vlm_model: VLM模型
        detector: 目標檢測器
        confidence_threshold: 有效邊界框的置信度閾值（默認0.7）
        max_iterations: 最大迭代次數(shù)（避免無限循環(huán)，默認3）
    返回：
        final_valid_boxes: 最終驗證通過的邊界框列表
    """
    # 1. 讀取并預處理圖像
    image = Image.open(image_path).convert("RGB")
    image_np = np.array(image)  # 轉換為numpy數(shù)組，便于檢測器處理
    # 2. 初始化迭代參數(shù)
    current_query = initial_query
    iterations = 0
    final_valid_boxes = []
    # 3. 智能體循環(huán)：查詢→檢測→驗證→優(yōu)化
    while iterations < max_iterations:
        # 步驟1：評判并優(yōu)化當前查詢
        refined_query = critique_query(current_query, vlm_processor, vlm_model)
        # 步驟2：分批次運行目標檢測
        detected_boxes = run_batched_detection(image_np, refined_query, detector)
        # 步驟3：VLM驗證邊界框（僅保留置信度>閾值且驗證通過的框）
        valid_boxes = []
        for box in detected_boxes:
            # 提取邊界框的置信度分數(shù)（假設box包含"confidence"字段）
            if box["confidence"] < confidence_threshold:
                continue# 跳過低置信度框
            # 使用VLM驗證邊界框
            is_valid = verify_box(
                image=image_np,
                box=box["coordinates"],  # 邊界框坐標：[x1, y1, x2, y2]
                query=refined_query,
                vlm_processor=vlm_processor,
                vlm_model=vlm_model
            )
            if is_valid:
                valid_boxes.append(box)
        # 步驟4：判斷是否滿足終止條件（有效框數(shù)量穩(wěn)定或達到最大迭代次數(shù)）
        if len(valid_boxes) >= len(final_valid_boxes):
            final_valid_boxes = valid_boxes
            current_query = refined_query  # 基于當前優(yōu)化結果更新查詢
        else:
            # 有效框數(shù)量減少，停止迭代（避免過度優(yōu)化）
            break
        # 更新迭代次數(shù)
        iterations += 1
    # 4. 返回最終結果
    return final_valid_boxes

# ------------------- 管道調用示例 -------------------
# 1. 初始化組件（VLM、檢測器）
# （1）初始化VLM（以BLIP為例）
vlm_processor, vlm_model = init_vlm_describer()
# （2）初始化目標檢測器（以YOLOv8為例）
from ultralytics import YOLO
detector = YOLO("yolov8n.pt")  # 加載YOLOv8 nano模型（輕量型，適合快速測試）
detector.set_conf(0.5)  # 設置檢測器的基礎置信度閾值

# 2. 定義輸入?yún)?shù)
image_path = "busy_street.jpg"# 繁忙街道的圖像
initial_query = "找出所有交通工具"# 用戶初始查詢（模糊）

# 3. 運行智能體管道
final_boxes = agentic_pipeline(
    image_path=image_path,
    initial_query=initial_query,
    vlm_processor=vlm_processor,
    vlm_model=vlm_model,
    detector=detector
)

# 4. 輸出最終結果
print(f"用戶初始查詢：{initial_query}")
print(f"VLM優(yōu)化后查詢：{final_boxes[0]['refined_query'] if final_boxes else '無'}")
print(f"最終有效邊界框數(shù)量：{len(final_boxes)}")
for i, box in enumerate(final_boxes, 1):
    print(f"邊界框{i}：坐標={box['coordinates']}，類別={box['class']}，置信度={box['confidence']:.2f}")

from ultralytics import YOLO
import cv2
import numpy as np

class YOLODetector:
    def __init__(self, model_path="yolov8n.pt", conf_threshold=0.5, iou_threshold=0.45):
        """
        初始化YOLO檢測器
        參數(shù)：
            model_path: YOLO模型路徑（默認yolov8n.pt，nano版本，輕量快速）
            conf_threshold: 置信度閾值（默認0.5，過濾低置信度結果）
            iou_threshold: IOU閾值（用于非極大值抑制NMS，默認0.45，避免重復框）
        """
        # 加載YOLO模型（支持自動下載預訓練權重）
        self.model = YOLO(model_path)
        # 設置檢測參數(shù)
        self.conf_threshold = conf_threshold
        self.iou_threshold = iou_threshold
        # 初始化目標類別（默認使用COCO數(shù)據(jù)集的80個類別）
        self.classes = self.model.names  # 類別字典：key=類別ID，value=類別名稱（英文）
        self.target_classes = None# 用于動態(tài)設置待檢測的類別

    def set_classes(self, target_classes):
        """
        動態(tài)設置待檢測的類別（支持中文類別，需映射到YOLO的英文類別）
        參數(shù)：
            target_classes: 目標類別列表（如["汽車", "自行車"]）
        """
        # 中文→英文類別映射（需根據(jù)實際場景擴展）
        class_mapping = {
            "汽車": "car",
            "自行車": "bicycle",
            "卡車": "truck",
            "行人": "person",
            "貓": "cat",
            "狗": "dog"
        }
        # 將中文類別轉換為YOLO支持的英文類別，并獲取對應的類別ID
        self.target_classes = [
            class_id for class_id, class_name in self.classes.items()
            if class_name in [class_mapping.get(c, "") for c in target_classes]
        ]

    def preprocess_image(self, image):
        """
        預處理輸入圖像（適配YOLO的輸入要求）
        參數(shù)：
            image: 輸入圖像（numpy數(shù)組，RGB/BGR格式均可）
        返回：
            processed_image: 預處理后的圖像
        """
        # YOLO自動處理圖像尺寸，但手動調整可提升速度（可選）
        # 例如：將圖像 resize 到640x640（YOLO的默認輸入尺寸）
        processed_image = cv2.resize(image, (640, 640))
        # 若圖像為BGR格式（cv2讀?。?，轉換為RGB格式（YOLO默認輸入）
        if len(processed_image.shape) == 3and processed_image.shape[2] == 3:
            if processed_image[:, :, 0].mean() < processed_image[:, :, 2].mean():
                processed_image = cv2.cvtColor(processed_image, cv2.COLOR_BGR2RGB)
        return processed_image

    def detect(self, image):
        """
        執(zhí)行目標檢測，返回邊界框及相關信息
        參數(shù)：
            image: 輸入圖像（numpy數(shù)組，RGB/BGR格式）
        返回：
            detection_results: 檢測結果列表，每個元素為字典（含坐標、類別、置信度）
        """
        # 1. 預處理圖像
        processed_image = self.preprocess_image(image)
        # 2. 執(zhí)行檢測（設置置信度、IOU閾值，指定目標類別）
        results = self.model(
            processed_image,
            cnotallow=self.conf_threshold,
            iou=self.iou_threshold,
            classes=self.target_classes  # 僅檢測指定類別
        )
        # 3. 提取檢測結果（轉換為原始圖像尺寸的坐標）
        detection_results = []
        # 獲取圖像縮放比例（因預處理時resize，需還原坐標）
        scale_x = image.shape[1] / processed_image.shape[1]
        scale_y = image.shape[0] / processed_image.shape[0]
        # 解析YOLO的輸出結果
        for result in results:
            boxes = result.boxes  # 邊界框信息
            for box in boxes:
                # 提取邊界框坐標（x1, y1, x2, y2，YOLO輸出為歸一化坐標，需反歸一化）
                x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()  # 未歸一化坐標（基于processed_image）
                # 還原到原始圖像尺寸
                x1 = int(x1 * scale_x)
                y1 = int(y1 * scale_y)
                x2 = int(x2 * scale_x)
                y2 = int(y2 * scale_y)
                # 提取類別ID和置信度
                class_id = int(box.cls[0])
                class_name = self.classes[class_id]  # 英文類別名稱
                confidence = float(box.conf[0])
                # 轉換為中文類別名稱（基于之前的mapping）
                class_mapping_rev = {v: k for k, v in class_mapping.items()}
                chinese_class = class_mapping_rev.get(class_name, class_name)
                # 保存結果
                detection_results.append({
                    "coordinates": [x1, y1, x2, y2],
                    "class": chinese_class,
                    "class_id": class_id,
                    "confidence": confidence
                })
        return detection_results

# ------------------- 檢測器使用示例 -------------------
# 1. 初始化YOLO檢測器
yolo_detector = YOLODetector(
    model_path="yolov8s.pt",  # 使用YOLOv8 small模型（比nano更精準，速度稍慢）
    conf_threshold=0.5,
    iou_threshold=0.45
)

# 2. 設置待檢測類別（中文）
yolo_detector.set_classes(target_classes=["汽車", "自行車", "行人"])

# 3. 讀取圖像（使用cv2或PIL均可）
image = cv2.imread("city_street.jpg")  # BGR格式

# 4. 執(zhí)行檢測
results = yolo_detector.detect(image)

# 5. 輸出檢測結果
print(f"檢測到的目標數(shù)量：{len(results)}")
for i, res in enumerate(results, 1):
    print(f"目標{i}：")
    print(f"  - 類別：{res['class']}")
    print(f"  - 置信度：{res['confidence']:.2f}")
    print(f"  - 邊界框坐標（x1, y1, x2, y2）：{res['coordinates']}")

# 6. （可選）在圖像上繪制邊界框并保存
for res in results:
    x1, y1, x2, y2 = res['coordinates']
    # 繪制矩形框（紅色，線寬2）
    cv2.rectangle(image, (x1, y1), (x2, y2), (0, 0, 255), 2)
    # 添加類別和置信度標簽（白色背景，黑色文字）
    label = f"{res['class']} ({res['confidence']:.2f})"
    cv2.putText(
        image,
        label,
        (x1, y1 - 10),
        cv2.FONT_HERSHEY_SIMPLEX,
        0.5,
        (0, 0, 0),
        2,
        cv2.LINE_AA
    )
# 保存繪制后的圖像
cv2.imwrite("detected_street.jpg", image)
print("繪制邊界框后的圖像已保存為 detected_street.jpg")

def refine_query_with_llava(initial_query, vlm_processor, vlm_model):
    """
    使用LLaVA模型優(yōu)化模糊查詢（支持多輪澄清）
    參數(shù)：
        initial_query: 初始模糊查詢
        vlm_processor: LLaVA的處理器（需支持多模態(tài)輸入）
        vlm_model: 初始化后的LLaVA模型
    返回：
        final_query: 最終優(yōu)化后的查詢
    """
    # 第1輪：VLM生成澄清問題
    prompt_round1 = f"""
    用戶需要進行目標檢測，查詢?yōu)椋骸皗initial_query}”。
    請分析該查詢是否存在以下模糊點：
    1. 類別定義模糊（如“交通工具”未明確包含哪些子類別）；
    2. 場景限制模糊（如“水果”未明確是否限定“新鮮”）；
    3. 數(shù)量/形態(tài)模糊（如“動物”未明確是否包含“幼崽”）。
    針對模糊點，生成1-2個澄清問題（無需回答）。
    """
    # 調用LLaVA生成澄清問題
    inputs_round1 = vlm_processor(text=prompt_round1, return_tensors="pt").to(vlm_model.device)
    outputs_round1 = vlm_model.generate(**inputs_round1, max_length=200)
    clarification_questions = vlm_processor.decode(outputs_round1[0], skip_special_tokens=True)

    # 第2輪：模擬用戶回答（實際場景中可通過前端交互獲取用戶輸入，此處用默認回答）
    # 示例默認回答：針對“檢測水果”的澄清問題，回答“僅新鮮水果，包含蘋果、橙子，不含漿果”
    user_answer = "僅檢測新鮮水果，包含蘋果、橙子、香蕉，不含漿果、水果干、水果罐頭。"

    # 第3輪：VLM基于用戶回答生成優(yōu)化查詢
    prompt_round2 = f"""
    用戶初始查詢：“{initial_query}”
    VLM澄清問題：{clarification_questions}
    用戶回答：{user_answer}
    請基于以上信息，生成“目標檢測專用的優(yōu)化查詢”——需滿足：
    1. 明確檢測類別（如“蘋果、橙子、香蕉”）；
    2. 明確限制條件（如“新鮮，不含漿果”）；
    3. 語言簡潔，無歧義。
    輸出格式：僅返回優(yōu)化后的查詢，無需其他內容。
    """
    inputs_round2 = vlm_processor(text=prompt_round2, return_tensors="pt").to(vlm_model.device)
    outputs_round2 = vlm_model.generate(**inputs_round2, max_length=150)
    final_query = vlm_processor.decode(outputs_round2[0], skip_special_tokens=True)

    return final_query

# ------------------- 代碼使用示例 -------------------
# 初始化LLaVA模型（假設已下載并配置）
from transformers import AutoProcessor, AutoModelForVisionAndLanguageGeneration
llava_processor = AutoProcessor.from_pretrained("liuhaotian/LLaVA-7b-v1.5")
llava_model = AutoModelForVisionAndLanguageGeneration.from_pretrained("liuhaotian/LLaVA-7b-v1.5")
llava_model = llava_model.to("cuda")

# 優(yōu)化模糊查詢
initial_query = "檢測水果"
optimized_query = refine_query_with_llava(initial_query, llava_processor, llava_model)

# 輸出結果
print(f"初始查詢：{initial_query}")
print(f"優(yōu)化后查詢：{optimized_query}")
# 示例輸出："檢測蘋果、橙子、香蕉等新鮮水果，不含漿果、水果干、水果罐頭"

def verify_box_enhanced(
    image, 
    box, 
    query, 
    vlm_processor, 
    vlm_model, 
    uncertainty_threshold=0.6
):
    """
    增強版VLM邊界框驗證（支持處理VLM的疑問結果）
    參數(shù)：
        image: 原始圖像（numpy數(shù)組/RGB格式）
        box: 待驗證邊界框（[x1, y1, x2, y2]）
        query: 優(yōu)化后的查詢（明確類別）
        vlm_processor: VLM處理器
        vlm_model: VLM模型
        uncertainty_threshold: VLM回答的不確定性閾值（默認0.6）
    返回：
        result: 字典，含"is_valid"（是否有效）、"reason"（VLM理由）、"is_uncertain"（是否存在疑問）
    """
    # 1. 裁剪邊界框區(qū)域（并處理可能的坐標越界）
    x1, y1, x2, y2 = map(int, box)
    # 確保坐標在圖像范圍內（避免裁剪報錯）
    x1 = max(0, x1)
    y1 = max(0, y1)
    x2 = min(image.shape[1], x2)
    y2 = min(image.shape[0], y2)
    if x1 >= x2 or y1 >= y2:
        return {"is_valid": False, "reason": "邊界框坐標無效（x1>=x2或y1>=y2）", "is_uncertain": False}
    cropped_image = image[y1:y2, x1:x2]
    # 若裁剪區(qū)域過?。ㄈ缑娣e<100像素），直接判定為無效
    if cropped_image.size < 100:
        return {"is_valid": False, "reason": "裁剪區(qū)域過小，無法判斷", "is_uncertain": False}

    # 2. 構造VLM的驗證prompt（引導VLM輸出明確理由和置信度）
    vlm_prompt = f"""
    任務：判斷以下裁剪圖像區(qū)域是否屬于“{query}”中的目標類別。
    要求：
    1. 先明確回答“是”或“否”；
    2. 再說明理由（如“該區(qū)域包含車輪和車身，符合汽車特征”）；
    3. 最后給出回答的置信度（0-1，保留2位小數(shù)）。
    輸出格式：
    回答：是/否
    理由：[你的理由]
    置信度：[0.00-1.00]
    """

    # 3. 調用VLM（若為多模態(tài)模型，需同時輸入圖像和文本）
    if"vision"in vlm_model.config.architectures[0].lower():
        # 多模態(tài)VLM（如LLaVA、GPT-4V）：輸入圖像+文本
        inputs = vlm_processor(
            images=Image.fromarray(cropped_image),
            text=vlm_prompt,
            return_tensors="pt"
        ).to(vlm_model.device)
    else:
        # 純文本VLM（需先將圖像轉換為文字描述）
        cropped_caption = vlm_describe_image(cropped_image, vlm_processor, vlm_model)
        text_prompt = f"圖像描述：{cropped_caption}\n{vlm_prompt}"
        inputs = vlm_processor(text=text_prompt, return_tensors="pt").to(vlm_model.device)

    outputs = vlm_model.generate(**inputs, max_length=300)
    vlm_response = vlm_processor.decode(outputs[0], skip_special_tokens=True)

    # 4. 解析VLM響應
    result = {"is_valid": False, "reason": "VLM響應解析失敗", "is_uncertain": False}
    # 提取“回答”
    if"回答：是"in vlm_response:
        result["is_valid"] = True
    elif"回答：否"in vlm_response:
        result["is_valid"] = False
    # 提取“理由”
    reason_match = re.search(r"理由：(.*?)(?=置信度：|$)", vlm_response, re.DOTALL)
    if reason_match:
        result["reason"] = reason_match.group(1).strip()
    # 提取“置信度”并判斷是否存在疑問
    conf_match = re.search(r"置信度：(\d+\.\d+)", vlm_response)
    if conf_match:
        conf_score = float(conf_match.group(1))
        result["is_uncertain"] = conf_score < uncertainty_threshold  # 置信度低于閾值，判定為疑問
        result["reason"] += f"（VLM置信度：{conf_score}）"

    return result

# ------------------- 代碼使用示例 -------------------
# 驗證單個邊界框
box = [100, 200, 300, 400]  # 邊界框坐標
query = "檢測新鮮蘋果"
verification_result = verify_box_enhanced(
    image=image_np,  # 原始圖像（RGB格式numpy數(shù)組）
    box=box,
    query=query,
    vlm_processor=llava_processor,
    vlm_model=llava_model
)

# 輸出驗證結果
print(f"邊界框是否有效：{verification_result['is_valid']}")
print(f"VLM理由：{verification_result['reason']}")
print(f"是否存在疑問：{verification_result['is_uncertain']}")

# 處理疑問結果（如重新調整檢測器參數(shù)）
if verification_result["is_uncertain"]:
    print("VLM存在疑問，重新調整檢測器置信度閾值為0.4后重試...")
    yolo_detector.set_conf(0.4)  # 降低檢測器置信度閾值
    # 重新檢測該區(qū)域（此處省略具體代碼）