AIStoryBoard/python/generate-anim/detect_panels.py

# -*- coding: utf-8 -*-
"""
使用opencv检测漫画格子（分镜框）
"""

import sys
import json
from pathlib import Path
import cv2
import numpy as np

# Windows编码修复
if sys.platform == 'win32':
    import io
    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
    sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8', errors='replace')


def validate_panel(gray, panel, border_width=10):
    """
    验证格子是否符合要求：内侧有画面，外侧完全空白
    
    参数:
        gray: 灰度图
        panel: 格子信息字典，包含 x, y, width, height
        border_width: 检查外侧区域的宽度（像素）
    
    返回:
        bool: True表示符合要求，False表示不符合
    """
    im_h, im_w = gray.shape
    x = panel['x']
    y = panel['y']
    w = panel['width']
    h = panel['height']
    
    # 确保坐标在图片范围内
    x = max(0, min(im_w - 1, x))
    y = max(0, min(im_h - 1, y))
    w = min(w, im_w - x)
    h = min(h, im_h - y)
    
    if w <= 0 or h <= 0:
        return False
    
    # 1. 检查内侧（格子内部）是否有画面内容
    # 内侧区域：稍微缩小一点，避免边界影响
    inner_margin = max(2, int(min(w, h) * 0.05))
    inner_x1 = x + inner_margin
    inner_y1 = y + inner_margin
    inner_x2 = x + w - inner_margin
    inner_y2 = y + h - inner_margin
    
    if inner_x2 <= inner_x1 or inner_y2 <= inner_y1:
        return False
    
    # 提取内侧区域
    inner_region = gray[inner_y1:inner_y2, inner_x1:inner_x2]
    
    # 计算内侧的平均亮度和标准差
    inner_mean = np.mean(inner_region)
    inner_std = np.std(inner_region)
    
    # 内侧应该有内容：平均亮度不能太高（< 250），或者标准差要足够大（> 5）
    # 放宽条件：如果平均亮度很高且标准差很低，说明是纯白色区域，没有内容
    if inner_mean > 250 and inner_std < 5:
        return False  # 内侧是纯白色，没有内容
    
    # 2. 检查外侧（格子边界外）是否完全空白
    # 外侧区域：格子边界外的 border_width 像素宽度
    outer_regions = []
    
    # 上侧外侧区域
    if y >= border_width:
        outer_top = gray[max(0, y - border_width):y, x:min(im_w, x + w)]
        if outer_top.size > 0:
            outer_regions.append(('top', outer_top))
    
    # 下侧外侧区域
    if y + h + border_width <= im_h:
        outer_bottom = gray[y + h:min(im_h, y + h + border_width), x:min(im_w, x + w)]
        if outer_bottom.size > 0:
            outer_regions.append(('bottom', outer_bottom))
    
    # 左侧外侧区域
    if x >= border_width:
        outer_left = gray[y:min(im_h, y + h), max(0, x - border_width):x]
        if outer_left.size > 0:
            outer_regions.append(('left', outer_left))
    
    # 右侧外侧区域
    if x + w + border_width <= im_w:
        outer_right = gray[y:min(im_h, y + h), x + w:min(im_w, x + w + border_width)]
        if outer_right.size > 0:
            outer_regions.append(('right', outer_right))
    
    # 如果没有任何外侧区域可以检查（格子太靠近边缘），放宽条件：允许通过
    if len(outer_regions) == 0:
        # 如果格子很大（占图片面积超过5%），可能是主要格子，允许通过
        if (w * h) > (im_w * im_h * 0.05):
            return True
        return False
    
    # 检查所有外侧区域是否都是白色（完全空白）
    # 放宽条件：外侧应该是白色：平均亮度 > 200，标准差 < 30
    # 至少有一半的外侧区域是白色即可
    white_count = 0
    for side_name, outer_region in outer_regions:
        if outer_region.size == 0:
            continue
        outer_mean = np.mean(outer_region)
        outer_std = np.std(outer_region)
        
        # 如果平均亮度足够高且标准差足够小，认为是白色区域
        if outer_mean > 200 and outer_std < 30:
            white_count += 1
    
    # 至少有一半的外侧区域是白色，就认为符合要求
    if white_count >= len(outer_regions) * 0.5:
        return True
    
    # 如果格子很大（占图片面积超过2%），即使外侧不完全符合，也允许通过（可能是主要格子）
    if (w * h) > (im_w * im_h * 0.02):
        return True
    
    return False


def detect_panels_from_white_borders(img):
    """
    基于漫画最外面区域一定是白色的特点检测格子
    策略：
    1. 识别图片边缘的白色区域
    2. 一行最多两个格子，先识别每个格子的两条边界线
    3. 找与这两条线成90°的直线段，组成完整的格子
    
    参数:
        img: 输入图片（BGR格式）
    
    返回:
        panel_mask: 格子遮罩图
        panels: 格子列表
    """
    if len(img.shape) == 3:
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    else:
        gray = img.copy()
    
    im_h, im_w = gray.shape
    img_area = im_h * im_w
    
    # 1. 识别图片边缘的白色区域
    # 检查四个边缘区域（上、下、左、右）是否为白色
    border_width = max(10, int(min(im_w, im_h) * 0.02))
    
    # 上边缘
    top_region = gray[0:border_width, :]
    top_white = np.mean(top_region) > 240
    
    # 下边缘
    bottom_region = gray[im_h-border_width:im_h, :]
    bottom_white = np.mean(bottom_region) > 240
    
    # 左边缘
    left_region = gray[:, 0:border_width]
    left_white = np.mean(left_region) > 240
    
    # 右边缘
    right_region = gray[:, im_w-border_width:im_w]
    right_white = np.mean(right_region) > 240
    
    print(f"[DEBUG] 边缘白色检测: 上={top_white}, 下={bottom_white}, 左={left_white}, 右={right_white}")
    
    # 2. 检测水平和垂直线（格子边界线）
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
    
    # 使用自适应阈值
    adaptive_thresh = cv2.adaptiveThreshold(
        blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
        cv2.THRESH_BINARY_INV, 11, 2
    )
    
    # Canny边缘检测
    edges = cv2.Canny(blurred, 30, 100, apertureSize=3)
    
    # 合并
    combined_edges = cv2.bitwise_or(edges, adaptive_thresh)
    
    # 检测水平线（用于分割行）
    h_kernel_size = max(int(im_w * 0.05), 30)
    horizontal_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (h_kernel_size, 1))
    horizontal_lines = cv2.morphologyEx(combined_edges, cv2.MORPH_OPEN, horizontal_kernel)
    horizontal_lines = cv2.dilate(horizontal_lines, horizontal_kernel, iterations=2)
    
    # 检测垂直线（用于分割列，一行最多两个格子）
    v_kernel_size = max(int(im_h * 0.05), 30)
    vertical_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, v_kernel_size))
    vertical_lines = cv2.morphologyEx(combined_edges, cv2.MORPH_OPEN, vertical_kernel)
    vertical_lines = cv2.dilate(vertical_lines, vertical_kernel, iterations=2)
    
    # 3. 使用霍夫直线检测，找到主要的水平和垂直线
    min_line_length = max(int(min(im_w, im_h) * 0.15), 50)  # 增加最小长度
    
    # 检测水平线（提高阈值，只检测主要的水平分割线）
    h_lines = cv2.HoughLinesP(
        horizontal_lines, 
        1, 
        np.pi/180, 
        threshold=max(int(min(im_w, im_h) * 0.25), 80),  # 提高阈值
        minLineLength=min_line_length,
        maxLineGap=max(int(min(im_w, im_h) * 0.03), 10)
    )
    
    # 检测垂直线（提高阈值，只检测主要的垂直分割线）
    v_lines = cv2.HoughLinesP(
        vertical_lines, 
        1, 
        np.pi/180, 
        threshold=max(int(min(im_w, im_h) * 0.25), 80),  # 提高阈值
        minLineLength=min_line_length,
        maxLineGap=max(int(min(im_w, im_h) * 0.03), 10)
    )
    
    # 4. 合并相近的水平线和垂直线，得到主要的格子分割线
    def merge_lines(lines, is_horizontal=True):
        """合并相近的直线，并过滤掉太短的线"""
        if lines is None or len(lines) == 0:
            return []
        
        merged = []
        used = set()
        
        # 合并阈值：根据图片尺寸调整
        merge_threshold_h = max(im_h * 0.03, 30)  # 水平线合并阈值
        merge_threshold_v = max(im_w * 0.03, 30)  # 垂直线合并阈值
        
        for i, line in enumerate(lines):
            if i in used:
                continue
            
            x1, y1, x2, y2 = line[0]
            
            if is_horizontal:
                # 水平线：合并Y坐标相近的线
                y = (y1 + y2) / 2
                similar_lines = [line]
                used.add(i)
                
                for j, other_line in enumerate(lines[i+1:], i+1):
                    if j in used:
                        continue
                    ox1, oy1, ox2, oy2 = other_line[0]
                    oy = (oy1 + oy2) / 2
                    
                    # 如果Y坐标相近（在阈值内），合并
                    if abs(y - oy) < merge_threshold_h:
                        similar_lines.append(other_line)
                        used.add(j)
                
                # 计算合并后的线的平均Y坐标和X范围
                avg_y = int(np.mean([(l[0][1] + l[0][3]) / 2 for l in similar_lines]))
                min_x = int(min([min(l[0][0], l[0][2]) for l in similar_lines]))
                max_x = int(max([max(l[0][0], l[0][2]) for l in similar_lines]))
                
                # 过滤：水平线必须跨越至少50%的图片宽度
                if (max_x - min_x) > im_w * 0.5:
                    merged.append((min_x, avg_y, max_x, avg_y))
            else:
                # 垂直线：合并X坐标相近的线
                x = (x1 + x2) / 2
                similar_lines = [line]
                used.add(i)
                
                for j, other_line in enumerate(lines[i+1:], i+1):
                    if j in used:
                        continue
                    ox1, oy1, ox2, oy2 = other_line[0]
                    ox = (ox1 + ox2) / 2
                    
                    # 如果X坐标相近（在阈值内），合并
                    if abs(x - ox) < merge_threshold_v:
                        similar_lines.append(other_line)
                        used.add(j)
                
                # 计算合并后的线的平均X坐标和Y范围
                avg_x = int(np.mean([(l[0][0] + l[0][2]) / 2 for l in similar_lines]))
                min_y = int(min([min(l[0][1], l[0][3]) for l in similar_lines]))
                max_y = int(max([max(l[0][1], l[0][3]) for l in similar_lines]))
                
                # 过滤：垂直线必须跨越至少50%的图片高度
                if (max_y - min_y) > im_h * 0.5:
                    merged.append((avg_x, min_y, avg_x, max_y))
        
        return merged
    
    h_merged = merge_lines(h_lines, is_horizontal=True)
    v_merged = merge_lines(v_lines, is_horizontal=False)
    
    print(f"[DEBUG] 检测到 {len(h_merged)} 条水平线和 {len(v_merged)} 条垂直线")
    
    # 5. 根据水平和垂直线构建格子
    # 添加图片边界线
    h_coords = [0]  # 上边界
    for line in h_merged:
        y = line[1]
        if 0 < y < im_h:
            h_coords.append(y)
    h_coords.append(im_h)  # 下边界
    h_coords = sorted(set(h_coords))
    
    v_coords = [0]  # 左边界
    for line in v_merged:
        x = line[0]
        if 0 < x < im_w:
            v_coords.append(x)
    v_coords.append(im_w)  # 右边界
    v_coords = sorted(set(v_coords))
    
    print(f"[DEBUG] 水平分割线Y坐标: {h_coords}")
    print(f"[DEBUG] 垂直分割线X坐标: {v_coords}")
    
    # 6. 构建格子（每行最多两个格子）
    panels = []
    min_panel_area = img_area * 0.02
    
    # 过滤掉太近的水平线（可能是重复检测）
    filtered_h_coords = [h_coords[0]]
    for i in range(1, len(h_coords) - 1):
        if h_coords[i] - filtered_h_coords[-1] > im_h * 0.05:  # 至少间隔5%的高度
            filtered_h_coords.append(h_coords[i])
    filtered_h_coords.append(h_coords[-1])
    
    # 过滤掉太近的垂直线（可能是重复检测）
    filtered_v_coords = [v_coords[0]]
    for i in range(1, len(v_coords) - 1):
        if v_coords[i] - filtered_v_coords[-1] > im_w * 0.05:  # 至少间隔5%的宽度
            filtered_v_coords.append(v_coords[i])
    filtered_v_coords.append(v_coords[-1])
    
    print(f"[DEBUG] 过滤后: {len(filtered_h_coords)} 条水平分割线, {len(filtered_v_coords)} 条垂直分割线")
    
    # 根据过滤后的坐标构建格子
    for i in range(len(filtered_h_coords) - 1):
        y1 = filtered_h_coords[i]
        y2 = filtered_h_coords[i + 1]
        
        # 一行最多两个格子
        # 找到在这个行范围内的垂直分割线
        row_v_coords = [filtered_v_coords[0]]  # 行的左边界
        
        for v_x in filtered_v_coords[1:-1]:  # 排除左右边界
            # 检查这条垂直线是否与当前行相交
            # 检查垂直线附近是否有足够的边缘响应
            line_region = combined_edges[y1:y2, max(0, v_x-10):min(im_w, v_x+10)]
            if np.sum(line_region > 0) > (y2 - y1) * 0.2:  # 至少20%的区域有边缘
                row_v_coords.append(v_x)
        
        row_v_coords.append(filtered_v_coords[-1])  # 行的右边界
        
        # 如果一行有太多垂直分割线，只保留主要的（每行最多2个格子，所以最多3条垂直线：左、中、右）
        if len(row_v_coords) > 3:
            # 选择最靠近左、中、右位置的线
            left = row_v_coords[0]
            right = row_v_coords[-1]
            mid = (left + right) / 2
            
            # 找到最接近中间位置的垂直线
            closest_mid = min(row_v_coords[1:-1], key=lambda x: abs(x - mid))
            row_v_coords = [left, closest_mid, right]
        
        # 根据垂直分割线创建格子（每行最多两个格子）
        for j in range(len(row_v_coords) - 1):
            x1 = row_v_coords[j]
            x2 = row_v_coords[j + 1]
            
            # 基本过滤
            w = x2 - x1
            h = y2 - y1
            area = w * h
            
            # 过滤：面积太小或高度/宽度太小
            min_height = im_h * 0.08  # 至少占图片高度的8%
            min_width = im_w * 0.15   # 至少占图片宽度的15%
            
            if area < min_panel_area or h < min_height or w < min_width:
                continue
            
            # 验证格子：内侧有内容，外侧是白色
            panel_candidate = {
                'x': int(x1),
                'y': int(y1),
                'width': int(w),
                'height': int(h),
                'area': area,
                'center_x': float(x1 + w / 2),
                'center_y': float(y1 + h / 2)
            }
            
            # 放宽验证条件，因为我们已经基于线条构建了格子
            if validate_panel(gray, panel_candidate, border_width=max(5, int(min(im_w, im_h) * 0.005))):
                panels.append(panel_candidate)
    
    # 绘制遮罩图（黑线白底：背景为白色255，格子线为黑色0）
    panel_mask = np.ones_like(gray) * 255  # 创建全白的mask
    for panel in panels:
        cv2.rectangle(panel_mask, 
                     (panel['x'], panel['y']), 
                     (panel['x'] + panel['width'], 
                      panel['y'] + panel['height']), 
                     0, 4)  # 绘制黑色的格子线
    
    return panel_mask, panels


def detect_panels_from_text_mask(img, text_mask=None):
    """
    基于文字遮罩图的连通域分析检测格子
    使用文字遮罩图找到包含文字的大连通区域，这些区域很可能就是格子
    
    参数:
        img: 输入图片（BGR格式）
        text_mask: 文字遮罩图（灰度图，文字区域为白色255，其他为黑色0）
    
    返回:
        panel_mask: 格子遮罩图
        panels: 格子列表
    """
    if len(img.shape) == 3:
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    else:
        gray = img.copy()
    
    im_h, im_w = gray.shape
    img_area = im_h * im_w
    
    # 如果没有提供文字遮罩图，使用传统方法
    if text_mask is None:
        return detect_comic_panels(img)
    
    # 确保文字遮罩图尺寸匹配
    if text_mask.shape[:2] != (im_h, im_w):
        text_mask = cv2.resize(text_mask, (im_w, im_h))
    
    # 方法：基于文字遮罩图的连通域分析
    # 1. 对文字遮罩图进行膨胀，连接相近的文字区域
    # 2. 使用连通域分析找到包含文字的大区域
    # 3. 扩展这些区域以包含周围的空白区域
    # 4. 验证每个区域是否符合格子特征
    
    # 对文字遮罩图进行膨胀，连接相近的文字区域
    kernel_size = max(5, int(min(im_w, im_h) * 0.01))
    kernel = np.ones((kernel_size, kernel_size), np.uint8)
    dilated_mask = cv2.dilate(text_mask, kernel, iterations=3)
    dilated_mask = cv2.morphologyEx(dilated_mask, cv2.MORPH_CLOSE, kernel, iterations=2)
    
    # 使用连通域分析找到包含文字的大区域
    connectivity = 8
    num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(
        dilated_mask, connectivity, cv2.CV_32S
    )
    
    print(f"[DEBUG] 文字遮罩图连通域分析：找到 {num_labels - 1} 个连通区域（排除背景）")
    
    panels = []
    min_panel_area = img_area * 0.02  # 最小格子面积（2%）
    max_panel_area = img_area * 0.50  # 最大格子面积（50%）
    
    # 遍历所有连通区域（跳过背景标签0）
    for label_index in range(1, num_labels):
        stat = stats[label_index]
        x, y, w, h, area = stat
        
        # 基本过滤：面积太小或太大
        if area < min_panel_area or area > max_panel_area:
            continue
        
        # 计算宽高比
        aspect_ratio = w / h if h > 0 else 0
        if aspect_ratio < 0.15 or aspect_ratio > 6.0:
            continue
        
        # 扩展边界框以包含周围的空白区域
        # 扩展比例：向四周扩展文字区域尺寸的 30-50%
        expand_x = int(w * 0.4)
        expand_y = int(h * 0.4)
        
        panel_x1 = max(0, x - expand_x)
        panel_y1 = max(0, y - expand_y)
        panel_x2 = min(im_w, x + w + expand_x)
        panel_y2 = min(im_h, y + h + expand_y)
        
        panel_w = panel_x2 - panel_x1
        panel_h = panel_y2 - panel_y1
        panel_area = panel_w * panel_h
        
        # 验证格子
        panel_candidate = {
            'x': panel_x1,
            'y': panel_y1,
            'width': panel_w,
            'height': panel_h,
            'area': panel_area,
            'center_x': float(panel_x1 + panel_w / 2),
            'center_y': float(panel_y1 + panel_h / 2)
        }
        
        if validate_panel(gray, panel_candidate, border_width=max(10, int(min(im_w, im_h) * 0.01))):
            panels.append(panel_candidate)
    
    # 合并重叠的格子
    merged_panels = []
    for panel in panels:
        merged = False
        for i, existing in enumerate(merged_panels):
            # 计算重叠
            overlap_x = max(0, min(panel['x'] + panel['width'], 
                                 existing['x'] + existing['width']) - 
                          max(panel['x'], existing['x']))
            overlap_y = max(0, min(panel['y'] + panel['height'], 
                                 existing['y'] + existing['height']) - 
                          max(panel['y'], existing['y']))
            overlap_area = overlap_x * overlap_y
            
            # 如果重叠面积超过较小格子的50%，合并它们
            min_area_for_merge = min(panel['area'], existing['area'])
            if overlap_area > min_area_for_merge * 0.5:
                # 合并：取两个格子的并集
                new_x = min(panel['x'], existing['x'])
                new_y = min(panel['y'], existing['y'])
                new_w = max(panel['x'] + panel['width'], 
                           existing['x'] + existing['width']) - new_x
                new_h = max(panel['y'] + panel['height'], 
                           existing['y'] + existing['height']) - new_y
                
                merged_panels[i] = {
                    'x': int(new_x),
                    'y': int(new_y),
                    'width': int(new_w),
                    'height': int(new_h),
                    'center_x': float(new_x + new_w / 2),
                    'center_y': float(new_y + new_h / 2)
                }
                merged = True
                break
        
        if not merged:
            merged_panels.append(panel)
    
    # 绘制遮罩图（黑线白底：背景为白色255，格子线为黑色0）
    panel_mask = np.ones_like(gray) * 255  # 创建全白的mask
    for panel in merged_panels:
        cv2.rectangle(panel_mask, 
                     (panel['x'], panel['y']), 
                     (panel['x'] + panel['width'], 
                      panel['y'] + panel['height']), 
                     0, 4)  # 绘制黑色的格子线
    
    return panel_mask, merged_panels


def detect_panels_from_text_blocks(img, text_blocks=None):
    """
    基于文字块位置检测格子
    如果提供了文字块列表，使用它们来推断格子边界
    
    参数:
        img: 输入图片（BGR格式）
        text_blocks: 文字块列表（可选），每个元素包含 xyxy 坐标 [x1, y1, x2, y2]
    
    返回:
        panel_mask: 格子遮罩图
        panels: 格子列表
    """
    if len(img.shape) == 3:
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    else:
        gray = img.copy()
    
    im_h, im_w = gray.shape
    img_area = im_h * im_w
    
    # 如果没有提供文字块，使用传统方法
    if text_blocks is None or len(text_blocks) == 0:
        return detect_comic_panels(img)
    
    # 方法：基于文字块聚类和区域扩展
    # 1. 根据文字块位置进行聚类（使用简单的距离阈值）
    # 2. 对每个聚类，扩展边界框以包含周围的空白区域
    # 3. 验证扩展后的区域是否符合格子特征
    
    panels = []
    used_blocks = set()
    
    # 计算文字块之间的距离，进行聚类
    min_panel_area = img_area * 0.02  # 最小格子面积
    max_panel_area = img_area * 0.50  # 最大格子面积
    
    for i, block in enumerate(text_blocks):
        if i in used_blocks:
            continue
        
        # 获取文字块的边界框
        if isinstance(block, dict):
            x1, y1, x2, y2 = block.get('xyxy', block.get('bbox', [0, 0, 0, 0]))
        else:
            x1, y1, x2, y2 = block[:4] if len(block) >= 4 else [0, 0, 0, 0]
        
        if x2 <= x1 or y2 <= y1:
            continue
        
        # 找到与当前文字块相邻的其他文字块（聚类）
        cluster_blocks = [i]
        used_blocks.add(i)
        
        # 扩展搜索范围：查找附近的文字块
        search_margin = max((x2 - x1) * 2, (y2 - y1) * 2, 100)
        
        for j, other_block in enumerate(text_blocks):
            if j in used_blocks or j == i:
                continue
            
            if isinstance(other_block, dict):
                ox1, oy1, ox2, oy2 = other_block.get('xyxy', other_block.get('bbox', [0, 0, 0, 0]))
            else:
                ox1, oy1, ox2, oy2 = other_block[:4] if len(other_block) >= 4 else [0, 0, 0, 0]
            
            if ox2 <= ox1 or oy2 <= oy1:
                continue
            
            # 计算两个文字块的距离
            center_x = (x1 + x2) / 2
            center_y = (y1 + y2) / 2
            o_center_x = (ox1 + ox2) / 2
            o_center_y = (oy1 + oy2) / 2
            
            distance = np.sqrt((center_x - o_center_x)**2 + (center_y - o_center_y)**2)
            
            # 如果距离在搜索范围内，加入聚类
            if distance < search_margin:
                cluster_blocks.append(j)
                used_blocks.add(j)
        
        # 计算聚类的边界框
        def get_bbox(block):
            if isinstance(block, dict):
                return block.get('xyxy', block.get('bbox', [0, 0, 0, 0]))
            else:
                return block[:4] if len(block) >= 4 else [0, 0, 0, 0]
        
        cluster_bboxes = [get_bbox(text_blocks[b]) for b in cluster_blocks]
        cluster_x1 = min([bbox[0] for bbox in cluster_bboxes])
        cluster_y1 = min([bbox[1] for bbox in cluster_bboxes])
        cluster_x2 = max([bbox[2] for bbox in cluster_bboxes])
        cluster_y2 = max([bbox[3] for bbox in cluster_bboxes])
        
        # 扩展边界框以包含周围的空白区域
        # 扩展比例：向四周扩展文字块尺寸的 20-50%
        expand_x = int((cluster_x2 - cluster_x1) * 0.3)
        expand_y = int((cluster_y2 - cluster_y1) * 0.3)
        
        panel_x1 = max(0, int(cluster_x1 - expand_x))
        panel_y1 = max(0, int(cluster_y1 - expand_y))
        panel_x2 = min(im_w, int(cluster_x2 + expand_x))
        panel_y2 = min(im_h, int(cluster_y2 + expand_y))
        
        panel_w = panel_x2 - panel_x1
        panel_h = panel_y2 - panel_y1
        panel_area = panel_w * panel_h
        
        # 基本过滤
        if panel_area < min_panel_area or panel_area > max_panel_area:
            continue
        
        # 验证格子
        panel_candidate = {
            'x': panel_x1,
            'y': panel_y1,
            'width': panel_w,
            'height': panel_h,
            'area': panel_area,
            'center_x': float(panel_x1 + panel_w / 2),
            'center_y': float(panel_y1 + panel_h / 2)
        }
        
        if validate_panel(gray, panel_candidate, border_width=max(10, int(min(im_w, im_h) * 0.01))):
            panels.append(panel_candidate)
    
    # 绘制遮罩图（黑线白底：背景为白色255，格子线为黑色0）
    panel_mask = np.ones_like(gray) * 255  # 创建全白的mask
    for panel in panels:
        cv2.rectangle(panel_mask, 
                     (panel['x'], panel['y']), 
                     (panel['x'] + panel['width'], 
                      panel['y'] + panel['height']), 
                     0, 4)  # 绘制黑色的格子线
    
    return panel_mask, panels


def detect_comic_panels(img, text_blocks=None, text_mask=None):
    """
    使用opencv检测漫画格子（分镜框）- 改进版
    策略：优先使用基于白色边界的方法，其次使用文字遮罩图，最后使用传统方法
    
    参数:
        img: 输入图片（BGR格式）
        text_blocks: 文字块列表（可选），来自 comic-text-detector
        text_mask: 文字遮罩图（可选），来自 comic-text-detector
    
    返回:
        panel_mask: 格子遮罩图（灰度图，格子线为黑色0，其他为白色255）
        panels: 格子列表，每个格子包含边界框信息
    """
    # 优先使用基于白色边界的方法（利用漫画边缘一定是白色的特点）
    try:
        print(f"[DEBUG] 尝试使用基于白色边界的方法...")
        panel_mask, panels = detect_panels_from_white_borders(img)
        print(f"[DEBUG] 基于白色边界的方法检测到 {len(panels)} 个格子")
        if len(panels) >= 4:  # 如果检测到足够多的格子，使用这个方法
            print(f"[DEBUG] 使用基于白色边界的方法，检测到 {len(panels)} 个格子")
            return panel_mask, panels
        else:
            print(f"[DEBUG] 基于白色边界的方法检测到的格子数量不足（{len(panels)}个），尝试其他方法")
    except Exception as e:
        print(f"[WARN] 基于白色边界的方法失败: {e}")
        import traceback
        traceback.print_exc()
    
    # 其次使用基于文字遮罩图的方法
    if text_mask is not None:
        try:
            print(f"[DEBUG] 尝试使用基于文字遮罩图的连通域分析方法...")
            panel_mask, panels = detect_panels_from_text_mask(img, text_mask)
            print(f"[DEBUG] 基于文字遮罩图的方法检测到 {len(panels)} 个格子")
            if len(panels) >= 4:  # 如果检测到足够多的格子，使用这个方法
                print(f"[DEBUG] 使用基于文字遮罩图的方法，检测到 {len(panels)} 个格子")
                return panel_mask, panels
            else:
                print(f"[DEBUG] 基于文字遮罩图的方法检测到的格子数量不足（{len(panels)}个），尝试其他方法")
        except Exception as e:
            print(f"[WARN] 基于文字遮罩图的方法失败: {e}")
            import traceback
            traceback.print_exc()
    
    # 再次使用基于文字块的方法
    if text_blocks is not None and len(text_blocks) > 0:
        try:
            print(f"[DEBUG] 尝试使用基于文字块的方法，文字块数量: {len(text_blocks)}")
            panel_mask, panels = detect_panels_from_text_blocks(img, text_blocks)
            print(f"[DEBUG] 基于文字块的方法检测到 {len(panels)} 个格子")
            if len(panels) >= 4:  # 如果检测到足够多的格子，使用这个方法
                print(f"[DEBUG] 使用基于文字块的方法，检测到 {len(panels)} 个格子")
                return panel_mask, panels
            else:
                print(f"[DEBUG] 基于文字块的方法检测到的格子数量不足（{len(panels)}个），使用传统方法")
        except Exception as e:
            print(f"[WARN] 基于文字块的方法失败，使用传统方法: {e}")
            import traceback
            traceback.print_exc()
    
    # 传统方法：基于边缘检测和轮廓分析
    # 转换为灰度图
    if len(img.shape) == 3:
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    else:
        gray = img.copy()
    
    im_h, im_w = gray.shape
    img_area = im_h * im_w
    
    # 第一步：放宽条件，检测所有可能的候选格子
    # 方法1: 改进的边缘检测（更宽松）
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
    
    # 使用自适应阈值（更敏感）
    adaptive_thresh = cv2.adaptiveThreshold(
        blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
        cv2.THRESH_BINARY_INV, 11, 2
    )
    
    # Canny边缘检测（更敏感的参数）
    edges = cv2.Canny(blurred, 20, 80, apertureSize=3)
    
    # 合并自适应阈值和Canny边缘
    combined_edges = cv2.bitwise_or(edges, adaptive_thresh)
    
    # 方法2: 检测水平线和垂直线（更宽松的kernel）
    h_kernel_size = max(int(im_w * 0.03), 20)  # 水平线kernel宽度（更小，更敏感）
    v_kernel_size = max(int(im_h * 0.03), 20)  # 垂直线kernel高度（更小，更敏感）
    
    # 检测水平线
    horizontal_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (h_kernel_size, 1))
    horizontal_lines = cv2.morphologyEx(combined_edges, cv2.MORPH_OPEN, horizontal_kernel)
    horizontal_lines = cv2.dilate(horizontal_lines, horizontal_kernel, iterations=3)  # 增加迭代次数
    
    # 检测垂直线
    vertical_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, v_kernel_size))
    vertical_lines = cv2.morphologyEx(combined_edges, cv2.MORPH_OPEN, vertical_kernel)
    vertical_lines = cv2.dilate(vertical_lines, vertical_kernel, iterations=3)  # 增加迭代次数
    
    # 合并水平和垂直线
    lines_mask = cv2.bitwise_or(horizontal_lines, vertical_lines)
    
    # 对边缘进行膨胀，连接断开的线条（更激进）
    kernel_size = max(5, int(min(im_w, im_h) * 0.005))
    kernel = np.ones((kernel_size, kernel_size), np.uint8)
    dilated = cv2.dilate(lines_mask, kernel, iterations=5)  # 增加迭代次数
    dilated = cv2.morphologyEx(dilated, cv2.MORPH_CLOSE, kernel, iterations=3)  # 增加迭代次数
    
    # 如果线条mask太稀疏，尝试使用更直接的方法：基于灰度值的分割
    # 使用阈值分割，找到可能的格子区域
    _, thresh = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
    
    # 合并线条mask和阈值分割结果
    combined_mask = cv2.bitwise_or(dilated, thresh)
    
    # 查找轮廓（使用RETR_TREE获取所有轮廓，包括嵌套的）
    contours, hierarchy = cv2.findContours(
        combined_mask, 
        cv2.RETR_TREE, 
        cv2.CHAIN_APPROX_SIMPLE
    )
    
    print(f"[DEBUG] 找到 {len(contours)} 个轮廓")
    
    # 第二步：放宽条件，收集所有候选格子
    candidate_panels = []
    min_area = img_area * 0.005  # 非常宽松：至少占图片0.5%的面积
    max_area = img_area * 0.95   # 最大不超过95%
    
    for contour in contours:
        # 计算轮廓的边界框
        x, y, w, h = cv2.boundingRect(contour)
        area = w * h
        
        # 基本过滤（非常宽松）
        if area < min_area or area > max_area:
            continue
        
        # 计算宽高比（非常宽松的范围）
        aspect_ratio = w / h if h > 0 else 0
        if aspect_ratio < 0.1 or aspect_ratio > 10.0:
            continue
        
        candidate_panels.append({
            'x': int(x),
            'y': int(y),
            'width': int(w),
            'height': int(h),
            'area': area,
            'aspect_ratio': aspect_ratio,
            'center_x': float(x + w / 2),
            'center_y': float(y + h / 2)
        })
    
    # 按面积排序，优先选择较大的区域（更可能是主要格子）
    candidate_panels.sort(key=lambda p: p['area'], reverse=True)
    
    # 如果候选格子太多，只保留前100个最大的（避免验证太多小区域）
    if len(candidate_panels) > 100:
        candidate_panels = candidate_panels[:100]
    
    print(f"[DEBUG] 检测到 {len(candidate_panels)} 个候选格子（已按面积排序）")
    
    # 第三步：验证每个候选格子是否符合要求（内侧有画面，外侧完全空白）
    valid_panels = []
    border_width = max(10, int(min(im_w, im_h) * 0.01))
    
    for i, candidate in enumerate(candidate_panels):
        is_valid = validate_panel(gray, candidate, border_width=border_width)
        if is_valid:
            valid_panels.append(candidate)
        # 只对前10个候选格子输出调试信息
        if i < 10:
            area_ratio = (candidate['area'] / img_area) * 100
            print(f"[DEBUG] 候选格子 {i+1}: 面积={candidate['area']:.0f} ({area_ratio:.2f}%), "
                  f"尺寸={candidate['width']}x{candidate['height']}, "
                  f"位置=({candidate['x']}, {candidate['y']}), 验证={'通过' if is_valid else '失败'}")
    
    print(f"[DEBUG] 验证后保留 {len(valid_panels)} 个有效格子")
    
    # 第四步：合并重叠和相邻的格子
    panels = []
    for candidate in valid_panels:
        merged = False
        
        # 检查是否可以与已有格子合并
        for i, existing in enumerate(panels):
            # 计算重叠或相邻关系
            overlap_x = max(0, min(candidate['x'] + candidate['width'], 
                                 existing['x'] + existing['width']) - 
                          max(candidate['x'], existing['x']))
            overlap_y = max(0, min(candidate['y'] + candidate['height'], 
                                 existing['y'] + existing['height']) - 
                          max(candidate['y'], existing['y']))
            overlap_area = overlap_x * overlap_y
            
            # 计算已有格子的面积
            existing_area = existing['width'] * existing['height']
            
            # 如果重叠面积超过较小格子的30%，合并它们
            min_area_for_merge = min(candidate['area'], existing_area)
            if overlap_area > min_area_for_merge * 0.3:
                # 合并：取两个格子的并集
                new_x = min(candidate['x'], existing['x'])
                new_y = min(candidate['y'], existing['y'])
                new_w = max(candidate['x'] + candidate['width'], 
                           existing['x'] + existing['width']) - new_x
                new_h = max(candidate['y'] + candidate['height'], 
                           existing['y'] + existing['height']) - new_y
                
                panels[i] = {
                    'x': int(new_x),
                    'y': int(new_y),
                    'width': int(new_w),
                    'height': int(new_h),
                    'center_x': float(new_x + new_w / 2),
                    'center_y': float(new_y + new_h / 2)
                }
                merged = True
                break
        
        # 如果不能合并，且不与已有格子重叠太多，添加为新格子
        if not merged:
            overlap_with_existing = False
            for existing in panels:
                overlap_x = max(0, min(candidate['x'] + candidate['width'], 
                                     existing['x'] + existing['width']) - 
                              max(candidate['x'], existing['x']))
                overlap_y = max(0, min(candidate['y'] + candidate['height'], 
                                     existing['y'] + existing['height']) - 
                              max(candidate['y'], existing['y']))
                overlap_area = overlap_x * overlap_y
                existing_area = existing['width'] * existing['height']
                min_area_check = min(candidate['area'], existing_area)
                
                # 如果重叠超过50%，跳过（可能是子区域）
                if overlap_area > min_area_check * 0.5:
                    overlap_with_existing = True
                    break
            
            if not overlap_with_existing:
                panels.append({
                    'x': candidate['x'],
                    'y': candidate['y'],
                    'width': candidate['width'],
                    'height': candidate['height'],
                    'center_x': candidate['center_x'],
                    'center_y': candidate['center_y']
                })
    
    # 第五步：绘制遮罩图（黑线白底：背景为白色255，格子线为黑色0）
    panel_mask = np.ones_like(gray) * 255  # 创建全白的mask
    for panel in panels:
        cv2.rectangle(panel_mask, 
                     (panel['x'], panel['y']), 
                     (panel['x'] + panel['width'], 
                      panel['y'] + panel['height']), 
                     0, 4)  # 绘制黑色的格子线
    
    return panel_mask, panels


def merge_panel_mask_with_text_mask(panel_mask, text_mask):
    """
    合并格子遮罩图和文字mask图
    
    参数:
        panel_mask: 格子遮罩图（格子线为黑色0，其他为白色255）
        text_mask: 文字mask图
    
    返回:
        combined_mask: 合并后的mask图
    """
    # 确保两个mask尺寸一致
    if panel_mask.shape != text_mask.shape:
        panel_mask = cv2.resize(panel_mask, (text_mask.shape[1], text_mask.shape[0]))
    
    # 合并：格子线（黑色0）和文字mask（非零部分）都保留
    # 格子遮罩图中，格子线是黑色(0)，其他是白色(255)
    # 文字mask中，文字区域是非零值（通常是白色255）
    # 合并策略：将panel_mask反转（黑线变白线），然后与text_mask合并（取最大值）
    # 这样格子线（白色）和文字（白色）都会保留，背景为黑色
    panel_mask_inv = cv2.bitwise_not(panel_mask)  # 反转：黑线(0)变白线(255)，白底(255)变黑底(0)
    combined_mask = np.maximum(panel_mask_inv, text_mask)  # 合并：保留格子线（白色）和文字（白色）
    
    return combined_mask


if __name__ == '__main__':
    import argparse
    
    parser = argparse.ArgumentParser(description='检测漫画格子并生成遮罩图')
    parser.add_argument('image', help='输入图片路径')
    parser.add_argument('-o', '--output', help='输出目录')
    parser.add_argument('--text-mask', help='文字mask图片路径（可选，用于合并）')
    parser.add_argument('--text-blocks', help='文字块JSON文件路径（可选，用于辅助格子检测）')
    
    args = parser.parse_args()
    
    image_path = Path(args.image)
    if not image_path.exists():
        print(f"[ERROR] 图片文件不存在: {image_path}")
        sys.exit(1)
    
    # 读取图片（处理中文路径）
    # 在Windows上，cv2.imread可能无法直接读取包含中文的路径
    # 使用numpy先读取文件，然后解码
    try:
        import numpy as np
        with open(str(image_path), 'rb') as f:
            img_data = np.frombuffer(f.read(), np.uint8)
            img = cv2.imdecode(img_data, cv2.IMREAD_COLOR)
    except Exception as e:
        # 如果上述方法失败，尝试直接读取
        img = cv2.imread(str(image_path))
    
    if img is None:
        print(f"[ERROR] 无法读取图片文件: {image_path}")
        print(f"[DEBUG] 尝试使用绝对路径: {image_path.resolve()}")
        sys.exit(1)
    
    # 尝试读取文字块信息（如果提供，或自动查找）
    text_blocks = None
    
    # 如果提供了文字块文件路径，使用它
    if args.text_blocks:
        text_blocks_path = Path(args.text_blocks)
    else:
        # 否则，尝试自动查找文字块JSON文件
        # 查找可能的文件名：{image_name}_dialogues.json, {image_name}_text_blocks.json
        # 优先从tmp目录查找，然后从output_dir查找
        image_name = image_path.stem
        output_dir = Path(args.output) if args.output else image_path.parent
        tmp_dir = output_dir / 'tmp'
        
        possible_names = [
            tmp_dir / f"{image_name}_dialogues.json",  # 优先从tmp目录查找
            output_dir / f"{image_name}_dialogues.json",
            output_dir / f"{image_name}_text_blocks.json",
            image_path.parent / f"{image_name}_dialogues.json",
            image_path.parent / f"{image_name}_text_blocks.json",
        ]
        
        text_blocks_path = None
        for possible_path in possible_names:
            if possible_path.exists():
                text_blocks_path = possible_path
                print(f"[INFO] 自动找到文字块文件: {text_blocks_path}")
                break
    
    # 读取文字块信息
    if text_blocks_path and text_blocks_path.exists():
        try:
            with open(text_blocks_path, 'r', encoding='utf-8') as f:
                text_blocks_data = json.load(f)
                # 尝试从不同格式的JSON中提取文字块信息
                if isinstance(text_blocks_data, list):
                    text_blocks = text_blocks_data
                elif isinstance(text_blocks_data, dict):
                    # 可能是包含 dialogues 或其他字段的格式
                    if 'dialogues' in text_blocks_data:
                        text_blocks = text_blocks_data['dialogues']
                    elif 'text_blocks' in text_blocks_data:
                        text_blocks = text_blocks_data['text_blocks']
                    elif 'blocks' in text_blocks_data:
                        text_blocks = text_blocks_data['blocks']
                
                # 转换文字块格式为统一格式
                if text_blocks:
                    formatted_blocks = []
                    for block in text_blocks:
                        if isinstance(block, dict):
                            # 尝试提取 bbox 或 xyxy
                            if 'bbox' in block:
                                bbox = block['bbox']
                                formatted_blocks.append({
                                    'xyxy': [bbox['x1'], bbox['y1'], bbox['x2'], bbox['y2']]
                                })
                            elif 'xyxy' in block:
                                formatted_blocks.append({'xyxy': block['xyxy']})
                    text_blocks = formatted_blocks if formatted_blocks else text_blocks
                    print(f"[INFO] 从JSON文件读取到 {len(text_blocks)} 个文字块")
        except Exception as e:
            print(f"[WARN] 无法读取文字块JSON文件: {e}")
            text_blocks = None
    
    # 尝试读取文字遮罩图（如果提供，或自动查找）
    text_mask = None
    
    # 如果提供了文字遮罩图路径，使用它
    if args.text_mask:
        text_mask_path = Path(args.text_mask)
        if text_mask_path.exists():
            try:
                text_mask = cv2.imread(str(text_mask_path), cv2.IMREAD_GRAYSCALE)
                if text_mask is not None:
                    print(f"[INFO] 从文件读取文字遮罩图: {text_mask_path}")
            except Exception as e:
                print(f"[WARN] 无法读取文字遮罩图: {e}")
    else:
        # 否则，尝试自动查找文字遮罩图
        # 优先从tmp目录查找，然后从output_dir查找
        image_name = image_path.stem
        output_dir = Path(args.output) if args.output else image_path.parent
        tmp_dir = output_dir / 'tmp'
        
        possible_names = [
            tmp_dir / f"{image_name}_text_mask.png",  # 优先从tmp目录查找
            output_dir / f"{image_name}_text_mask.png",
            image_path.parent / f"{image_name}_text_mask.png",
        ]
        
        for possible_path in possible_names:
            if possible_path.exists():
                try:
                    text_mask = cv2.imread(str(possible_path), cv2.IMREAD_GRAYSCALE)
                    if text_mask is not None:
                        print(f"[INFO] 自动找到文字遮罩图: {possible_path}")
                        break
                except Exception as e:
                    continue
    
    # 检测格子
    print(f"[INFO] 正在检测漫画格子: {image_path.name}")
    panel_mask, panels = detect_comic_panels(img, text_blocks=text_blocks, text_mask=text_mask)
    print(f"[OK] 检测到 {len(panels)} 个格子")
    
    # 设置输出目录
    if args.output:
        output_dir = Path(args.output)
        output_dir.mkdir(parents=True, exist_ok=True)
    else:
        output_dir = image_path.parent
    
    # 如果output_dir已经是tmp目录，直接使用它；否则创建tmp子目录
    # 检查路径的最后一部分是否是'tmp'（支持相对路径和绝对路径）
    output_dir_str = str(output_dir)
    if output_dir_str.endswith('tmp') or output_dir_str.endswith('tmp\\') or output_dir_str.endswith('tmp/'):
        tmp_dir = output_dir
    else:
        tmp_dir = output_dir / 'tmp'
        tmp_dir.mkdir(parents=True, exist_ok=True)
    
    image_name = image_path.stem
    
    # 保存格子遮罩图到tmp目录（中间文件）
    panel_mask_path = tmp_dir / f"{image_name}_panel_mask.png"
    # 使用cv2.imencode处理中文路径
    success, encoded_img = cv2.imencode('.png', panel_mask)
    if success:
        with open(str(panel_mask_path), 'wb') as f:
            f.write(encoded_img.tobytes())
        print(f"[OK] 已保存格子遮罩图: {panel_mask_path}")
    else:
        print(f"[ERROR] 保存格子遮罩图失败: {panel_mask_path}")
    
    # 如果提供了文字mask，进行合并
    if args.text_mask:
        text_mask_path = Path(args.text_mask)
        if text_mask_path.exists():
            # 使用np.fromfile处理中文路径
            text_mask_array = np.fromfile(str(text_mask_path), dtype=np.uint8)
            text_mask = cv2.imdecode(text_mask_array, cv2.IMREAD_GRAYSCALE)
            if text_mask is not None:
                combined_mask = merge_panel_mask_with_text_mask(panel_mask, text_mask)
                combined_mask_path = tmp_dir / f"{image_name}_combined_mask.png"
                # 使用cv2.imencode处理中文路径
                success, encoded_img = cv2.imencode('.png', combined_mask)
                if success:
                    with open(str(combined_mask_path), 'wb') as f:
                        f.write(encoded_img.tobytes())
                    print(f"[OK] 已保存合并后的mask图: {combined_mask_path}")
                else:
                    print(f"[ERROR] 保存合并后的mask图失败: {combined_mask_path}")
            else:
                print(f"[WARN] 无法读取文字mask图: {text_mask_path}")
        else:
            print(f"[WARN] 文字mask图不存在: {text_mask_path}")
    
    # 保存格子信息JSON到tmp目录（中间文件）
    panels_json = {
        'image_file': image_path.name,
        'panels': panels,
        'total_count': len(panels)
    }
    json_path = tmp_dir / f"{image_name}_panels.json"
    with open(json_path, 'w', encoding='utf-8') as f:
        json.dump(panels_json, f, ensure_ascii=False, indent=2)
    print(f"[OK] 已保存格子信息: {json_path}")