AIStoryBoard/python/generate-anim/detect_and_ocr_comic.py

# -*- coding: utf-8 -*-
"""
使用 comic-text-detector 检测文字区域，然后用 PaddleOCR 识别文字内容
按日式漫画阅读顺序（从右到左、从上到下）排序
"""

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


def convert_coordinate_to_math_system(x, y, image_height):
    """
    将OpenCV坐标系转换为数学坐标系
    
    原始坐标系（OpenCV）：左上角(0,0)，向下为y轴正方向，向右为x轴正方向
    目标坐标系（数学）：左下角(0,0)，向上为y轴正方向，向右为x轴正方向
    
    转换公式：
    - x_new = x_old (x坐标不变)
    - y_new = imageHeight - y_old (y坐标翻转)
    
    参数:
        x: 原始x坐标
        y: 原始y坐标
        image_height: 图片高度
    
    返回:
        (x_new, y_new): 转换后的坐标
    """
    x_new = x
    y_new = image_height - y
    return x_new, y_new


def detect_characters_with_opencv(img, text_bbox, text_content, ocr_bbox_hint=None):
    """
    使用OpenCV在文本区域内精确定位每个字符
    
    参数:
        img: 原始图像（BGR格式）
        text_bbox: 文本边界框，格式 {'x1': int, 'y1': int, 'x2': int, 'y2': int}
        text_content: 文本内容（用于验证字符数量）
        ocr_bbox_hint: OCR提供的文本边界框（可选，用于辅助识别）
    
    返回:
        char_boxes: 字符边界框列表，每个元素包含 {'x1', 'y1', 'x2', 'y2', 'center_x', 'center_y'}
        确保字符数量与OCR文本一致，且字符框不重叠
    """
    # 提取文本区域
    x1 = int(text_bbox['x1'])
    y1 = int(text_bbox['y1'])
    x2 = int(text_bbox['x2'])
    y2 = int(text_bbox['y2'])
    
    # 确保坐标在图像范围内
    h, w = img.shape[:2]
    x1 = max(0, x1)
    y1 = max(0, y1)
    x2 = min(w, x2)
    y2 = min(h, y2)
    
    if x2 <= x1 or y2 <= y1:
        return []
    
    # 提取文本区域ROI
    text_roi = img[y1:y2, x1:x2].copy()
    
    if text_roi.size == 0:
        return []
    
    # 转换为灰度图
    if len(text_roi.shape) == 3:
        gray_roi = cv2.cvtColor(text_roi, cv2.COLOR_BGR2GRAY)
    else:
        gray_roi = text_roi
    
    # 二值化处理
    # 使用自适应阈值，因为文本区域可能有不同的光照条件
    binary = cv2.adaptiveThreshold(
        gray_roi, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
        cv2.THRESH_BINARY_INV, 11, 2
    )
    
    # 形态学操作：去除噪点，连接字符笔画
    kernel = np.ones((2, 2), np.uint8)
    binary = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel, iterations=1)
    binary = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel, iterations=1)
    
    # 判断是竖排还是横排
    roi_height, roi_width = binary.shape
    is_vertical = roi_height > roi_width * 1.2
    
    # 保存布局信息，用于后续估算
    layout_info = {'is_vertical': is_vertical, 'roi_width': roi_width, 'roi_height': roi_height}
    
    char_boxes = []
    
    if is_vertical:
        # 竖排文字：使用垂直投影来分割字符
        # 计算垂直投影（每列的白色像素数量）
        vertical_projection = np.sum(binary, axis=0)
        
        # 找到字符之间的空白列（投影值接近0）
        threshold = np.max(vertical_projection) * 0.1
        char_boundaries = []
        
        in_char = False
        start_col = 0
        
        for col in range(len(vertical_projection)):
            if vertical_projection[col] > threshold:
                if not in_char:
                    in_char = True
                    start_col = col
            else:
                if in_char:
                    in_char = False
                    # 字符结束位置（使用中间位置作为分割点）
                    end_col = col
                    char_boundaries.append((start_col, end_col))
        
        # 处理最后一个字符
        if in_char:
            char_boundaries.append((start_col, len(vertical_projection)))
        
        # 为每个字符区域计算水平边界
        for start_col, end_col in char_boundaries:
            char_col_roi = binary[:, start_col:end_col]
            horizontal_projection = np.sum(char_col_roi, axis=1)
            
            # 找到字符的上下边界
            char_rows = np.where(horizontal_projection > 0)[0]
            if len(char_rows) > 0:
                top_row = char_rows[0]
                bottom_row = char_rows[-1]
                
                # 转换为原图坐标
                char_x1 = x1 + start_col
                char_y1 = y1 + top_row
                char_x2 = x1 + end_col
                char_y2 = y1 + bottom_row
                
                char_boxes.append({
                    'x1': float(char_x1),
                    'y1': float(char_y1),
                    'x2': float(char_x2),
                    'y2': float(char_y2),
                    'center_x': float((char_x1 + char_x2) / 2),
                    'center_y': float((char_y1 + char_y2) / 2)
                })
    else:
        # 横排文字：使用水平投影来分割字符
        # 计算水平投影（每行的白色像素数量）
        horizontal_projection = np.sum(binary, axis=1)
        
        # 找到字符之间的空白行（投影值接近0）
        threshold = np.max(horizontal_projection) * 0.1
        char_boundaries = []
        
        in_char = False
        start_row = 0
        
        for row in range(len(horizontal_projection)):
            if horizontal_projection[row] > threshold:
                if not in_char:
                    in_char = True
                    start_row = row
            else:
                if in_char:
                    in_char = False
                    # 字符结束位置
                    end_row = row
                    char_boundaries.append((start_row, end_row))
        
        # 处理最后一个字符
        if in_char:
            char_boundaries.append((start_row, len(horizontal_projection)))
        
        # 为每个字符区域计算垂直边界
        for start_row, end_row in char_boundaries:
            char_row_roi = binary[start_row:end_row, :]
            vertical_projection = np.sum(char_row_roi, axis=0)
            
            # 找到字符的左右边界
            char_cols = np.where(vertical_projection > 0)[0]
            if len(char_cols) > 0:
                left_col = char_cols[0]
                right_col = char_cols[-1]
                
                # 转换为原图坐标
                char_x1 = x1 + left_col
                char_y1 = y1 + start_row
                char_x2 = x1 + right_col
                char_y2 = y1 + end_row
                
                char_boxes.append({
                    'x1': float(char_x1),
                    'y1': float(char_y1),
                    'x2': float(char_x2),
                    'y2': float(char_y2),
                    'center_x': float((char_x1 + char_x2) / 2),
                    'center_y': float((char_y1 + char_y2) / 2)
                })
    
    # 如果投影方法检测到的字符数量与文本内容不匹配，使用轮廓检测作为主要方法
    text_no_space = text_content.replace(' ', '')
    expected_char_count = len(text_no_space)
    
    # 使用轮廓检测作为主要方法（更精确）
    contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    
    # 过滤掉太小的轮廓（可能是噪点）
    min_area = (roi_width * roi_height) / (expected_char_count * 20)  # 更严格的面积阈值
    max_area = (roi_width * roi_height) / 2  # 最大面积（避免误检测）
    
    valid_contours = []
    for contour in contours:
        area = cv2.contourArea(contour)
        if min_area < area < max_area:
            # 计算轮廓的宽高比，过滤掉明显不是字符的轮廓
            x, y, w, h = cv2.boundingRect(contour)
            aspect_ratio = h / w if w > 0 else 0
            # 字符的宽高比通常在合理范围内
            if 0.2 < aspect_ratio < 5.0:
                valid_contours.append(contour)
    
    # 如果轮廓数量合理，使用轮廓结果（更精确）
    if len(valid_contours) > 0:
        # 按位置排序轮廓（从上到下、从右到左）
        contour_boxes = []
        for contour in valid_contours:
            x, y, w, h = cv2.boundingRect(contour)
            # 转换为原图坐标
            char_x1 = float(x1 + x)
            char_y1 = float(y1 + y)
            char_x2 = float(x1 + x + w)
            char_y2 = float(y1 + y + h)
            
            contour_boxes.append({
                'x1': char_x1,
                'y1': char_y1,
                'x2': char_x2,
                'y2': char_y2,
                'center_x': float(char_x1 + w / 2),
                'center_y': float(char_y1 + h / 2),
                'area': area
            })
        
        # 按位置排序（从上到下、从右到左）
        contour_boxes.sort(key=lambda b: (b['y1'], -b['center_x']))
        
        # 如果轮廓数量接近预期，使用轮廓结果
        if abs(len(contour_boxes) - expected_char_count) <= abs(len(char_boxes) - expected_char_count):
            char_boxes = contour_boxes
    
    # 关键改进：确保字符数量与OCR文本一致，且字符框不重叠
    # 如果识别出的字符数量不匹配，使用OCR坐标作为参考来辅助识别
    if len(char_boxes) != expected_char_count and ocr_bbox_hint:
        # 使用OCR提供的边界框作为参考，估算字符位置
        char_boxes = refine_char_boxes_with_ocr_hint(
            img, text_bbox, text_content, char_boxes, ocr_bbox_hint, expected_char_count
        )
    
    # 确保字符框不重叠
    char_boxes = remove_overlapping_boxes(char_boxes, expected_char_count)
    
    # 如果字符数量仍然不匹配，使用估算方法
    if len(char_boxes) != expected_char_count:
        char_boxes = estimate_char_boxes_from_text_bbox(
            text_bbox, text_content, expected_char_count, is_vertical
        )
    
    return char_boxes


def refine_char_boxes_with_ocr_hint(img, text_bbox, text_content, detected_boxes, ocr_bbox_hint, expected_count):
    """
    使用OCR提供的边界框作为参考，改进字符检测
    
    参数:
        img: 原始图像
        text_bbox: 文本边界框
        text_content: 文本内容
        detected_boxes: 已检测到的字符框列表
        ocr_bbox_hint: OCR提供的文本边界框
        expected_count: 期望的字符数量
    
    返回:
        改进后的字符框列表
    """
    # 如果已检测到的字符框数量接近期望值，直接返回
    if abs(len(detected_boxes) - expected_count) <= 2:
        return detected_boxes
    
    # 使用OCR边界框估算字符位置
    text_no_space = text_content.replace(' ', '')
    roi_width = text_bbox['x2'] - text_bbox['x1']
    roi_height = text_bbox['y2'] - text_bbox['y1']
    is_vertical = roi_height > roi_width * 1.2
    
    estimated_boxes = []
    
    if is_vertical:
        # 竖排：估算每个字符的位置
        # 估算列数和行数
        estimated_cols = max(1, int(roi_width / (roi_height / expected_count * 0.8)))
        estimated_rows = (expected_count + estimated_cols - 1) // estimated_cols
        
        char_width = roi_width / estimated_cols
        char_height = roi_height / estimated_rows
        
        # 如果有已检测到的字符框，使用它们的位置来调整估算
        if len(detected_boxes) > 0:
            # 使用已检测到的字符框位置来调整估算
            for i in range(expected_count):
                col = i % estimated_cols
                row = i // estimated_cols
                
                est_x = text_bbox['x1'] + col * char_width + char_width / 2
                est_y = text_bbox['y1'] + row * char_height + char_height / 2
                
                # 找到最近的已检测字符框
                min_dist = float('inf')
                best_box = None
                for box in detected_boxes:
                    dist = abs(box['center_x'] - est_x) + abs(box['center_y'] - est_y)
                    if dist < min_dist:
                        min_dist = dist
                        best_box = box
                
                if best_box and min_dist < char_width:
                    # 使用已检测到的字符框
                    estimated_boxes.append(best_box)
                else:
                    # 使用估算位置
                    estimated_boxes.append({
                        'x1': float(est_x - char_width / 2),
                        'y1': float(est_y - char_height / 2),
                        'x2': float(est_x + char_width / 2),
                        'y2': float(est_y + char_height / 2),
                        'center_x': float(est_x),
                        'center_y': float(est_y)
                    })
        else:
            # 完全使用估算
            for i in range(expected_count):
                col = i % estimated_cols
                row = i // estimated_cols
                est_x = text_bbox['x1'] + col * char_width + char_width / 2
                est_y = text_bbox['y1'] + row * char_height + char_height / 2
                estimated_boxes.append({
                    'x1': float(est_x - char_width / 2),
                    'y1': float(est_y - char_height / 2),
                    'x2': float(est_x + char_width / 2),
                    'y2': float(est_y + char_height / 2),
                    'center_x': float(est_x),
                    'center_y': float(est_y)
                })
    else:
        # 横排：估算每个字符的位置
        char_width = roi_width / expected_count
        char_height = roi_height
        
        for i in range(expected_count):
            x = text_bbox['x1'] + i * char_width + char_width / 2
            y = text_bbox['y1'] + roi_height / 2
            
            estimated_boxes.append({
                'x1': float(x - char_width / 2),
                'y1': float(y - char_height / 2),
                'x2': float(x + char_width / 2),
                'y2': float(y + char_height / 2),
                'center_x': float(x),
                'center_y': float(y)
            })
    
    return estimated_boxes[:expected_count]


def remove_overlapping_boxes(char_boxes, expected_count):
    """
    移除重叠的字符框，确保字符框不重叠
    
    参数:
        char_boxes: 字符框列表
        expected_count: 期望的字符数量
    
    返回:
        去重后的字符框列表
    """
    if len(char_boxes) <= expected_count:
        return char_boxes
    
    # 按位置排序
    sorted_boxes = sorted(char_boxes, key=lambda b: (b['y1'], b['center_x']))
    
    # 移除重叠的字符框
    non_overlapping = []
    for box in sorted_boxes:
        is_overlapping = False
        for existing_box in non_overlapping:
            # 计算重叠面积
            overlap_x1 = max(box['x1'], existing_box['x1'])
            overlap_y1 = max(box['y1'], existing_box['y1'])
            overlap_x2 = min(box['x2'], existing_box['x2'])
            overlap_y2 = min(box['y2'], existing_box['y2'])
            
            if overlap_x2 > overlap_x1 and overlap_y2 > overlap_y1:
                overlap_area = (overlap_x2 - overlap_x1) * (overlap_y2 - overlap_y1)
                box_area = (box['x2'] - box['x1']) * (box['y2'] - box['y1'])
                existing_area = (existing_box['x2'] - existing_box['x1']) * (existing_box['y2'] - existing_box['y1'])
                
                # 如果重叠面积超过较小框的50%，认为是重叠
                if overlap_area > min(box_area, existing_area) * 0.5:
                    is_overlapping = True
                    break
        
        if not is_overlapping:
            non_overlapping.append(box)
    
    # 如果去重后数量不足，尝试合并相近的字符框
    if len(non_overlapping) < expected_count:
        # 按位置分组，合并相近的字符框
        grouped = []
        for box in sorted_boxes:
            added = False
            for group in grouped:
                # 检查是否与组内任何框相近
                for group_box in group:
                    dist = abs(box['center_x'] - group_box['center_x']) + abs(box['center_y'] - group_box['center_y'])
                    if dist < 20:  # 如果距离小于20像素，认为是同一个字符
                        group.append(box)
                        added = True
                        break
                if added:
                    break
            
            if not added:
                grouped.append([box])
        
        # 对每个组，选择最大的字符框
        non_overlapping = []
        for group in grouped:
            largest = max(group, key=lambda b: (b['x2'] - b['x1']) * (b['y2'] - b['y1']))
            non_overlapping.append(largest)
    
    return non_overlapping[:expected_count]


def estimate_char_boxes_from_text_bbox(text_bbox, text_content, expected_count, is_vertical):
    """
    从文本边界框估算字符位置（当OpenCV检测失败时使用）
    
    参数:
        text_bbox: 文本边界框
        text_content: 文本内容
        expected_count: 期望的字符数量
        is_vertical: 是否为竖排
    
    返回:
        估算的字符框列表
    """
    text_no_space = text_content.replace(' ', '')
    roi_width = text_bbox['x2'] - text_bbox['x1']
    roi_height = text_bbox['y2'] - text_bbox['y1']
    
    estimated_boxes = []
    
    if is_vertical:
        # 竖排：估算每个字符的位置
        # 估算列数和行数
        estimated_cols = max(1, int(roi_width / (roi_height / expected_count * 0.8)))
        estimated_rows = (expected_count + estimated_cols - 1) // estimated_cols
        
        char_width = roi_width / estimated_cols
        char_height = roi_height / estimated_rows
        
        for i in range(expected_count):
            col = i % estimated_cols
            row = i // estimated_cols
            
            x = text_bbox['x1'] + col * char_width + char_width / 2
            y = text_bbox['y1'] + row * char_height + char_height / 2
            
            estimated_boxes.append({
                'x1': float(x - char_width / 2),
                'y1': float(y - char_height / 2),
                'x2': float(x + char_width / 2),
                'y2': float(y + char_height / 2),
                'center_x': float(x),
                'center_y': float(y)
            })
    else:
        # 横排：估算每个字符的位置
        char_width = roi_width / expected_count
        char_height = roi_height
        
        for i in range(expected_count):
            x = text_bbox['x1'] + i * char_width + char_width / 2
            y = text_bbox['y1'] + roi_height / 2
            
            estimated_boxes.append({
                'x1': float(x - char_width / 2),
                'y1': float(y - char_height / 2),
                'x2': float(x + char_width / 2),
                'y2': float(y + char_height / 2),
                'center_x': float(x),
                'center_y': float(y)
            })
    
    return estimated_boxes

# 禁用 oneDNN 以避免 NotImplementedError（PaddlePaddle 3.3.0 的已知问题）
os.environ['FLAGS_onednn'] = '0'
os.environ['FLAGS_use_mkldnn'] = '0'

# 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')

# 添加comic-text-detector路径
project_root = Path(__file__).parent.parent
comic_detector_path = project_root / 'comic-text-detector-master' / 'comic-text-detector-master'
sys.path.insert(0, str(comic_detector_path))

# 添加OnnxOCR本地路径（作为回退选项）
onnxocr_path = project_root / 'OnnxOCR-main' / 'OnnxOCR-main'
if onnxocr_path.exists():
    sys.path.insert(0, str(onnxocr_path))

# 处理 wandb 可选依赖（comic-text-detector 需要但推理时不需要）
try:
    import wandb
except ImportError:
    # 创建一个假的 wandb 模块，避免导入错误
    class FakeWandb:
        @staticmethod
        def init(*args, **kwargs):
            return None
        @staticmethod
        def log(*args, **kwargs):
            pass
        @staticmethod
        def log_model(*args, **kwargs):
            pass
    sys.modules['wandb'] = FakeWandb()

try:
    from inference import TextDetector, REFINEMASK_ANNOTATION
    from utils.io_utils import imread, imwrite
except ImportError as e:
    print(f"[ERROR] 无法导入comic-text-detector模块: {e}")
    print(f"[INFO] 请确保已安装依赖: pip install torch torchvision opencv-python numpy tqdm")
    import traceback
    traceback.print_exc()
    sys.exit(1)

# PaddleOCR（唯一使用）
try:
    # 添加PaddleOCR路径
    paddleocr_path = project_root / 'PaddleOCR-main' / 'PaddleOCR-main'
    if paddleocr_path.exists():
        sys.path.insert(0, str(paddleocr_path))
    from paddleocr import PaddleOCR
    PADDLEOCR_AVAILABLE = True
    print("[INFO] PaddleOCR 可用")
except ImportError as e:
    print(f"[ERROR] 无法导入PaddleOCR模块: {e}")
    print("[ERROR] PaddleOCR 是必需的，请确保已正确安装")
    PADDLEOCR_AVAILABLE = False


# 格子识别代码已移动到 python/generate-anim/detect_panels.py
# 通过导入使用
try:
    # 添加当前目录到路径，以便导入同目录下的模块
    import sys
    current_dir = Path(__file__).parent
    if str(current_dir) not in sys.path:
        sys.path.insert(0, str(current_dir))
    from detect_panels import detect_comic_panels, merge_panel_mask_with_text_mask
except ImportError as e:
    print(f"[WARN] 无法导入detect_panels模块，使用本地实现: {e}")
    # 如果导入失败，使用本地实现（向后兼容）
    def detect_comic_panels(img):
        """使用opencv检测漫画格子（分镜框）- 本地实现"""
        if len(img.shape) == 3:
            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        else:
            gray = img.copy()
        
        panel_mask = np.zeros_like(gray)
        edges = cv2.Canny(gray, 50, 150, apertureSize=3)
        
        horizontal_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (40, 1))
        horizontal_lines = cv2.morphologyEx(edges, cv2.MORPH_OPEN, horizontal_kernel)
        
        vertical_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, 40))
        vertical_lines = cv2.morphologyEx(edges, cv2.MORPH_OPEN, vertical_kernel)
        
        lines_mask = cv2.bitwise_or(horizontal_lines, vertical_lines)
        lines = cv2.HoughLinesP(lines_mask, 1, np.pi/180, threshold=100, 
                                minLineLength=50, maxLineGap=10)
        
        if lines is not None:
            for line in lines:
                x1, y1, x2, y2 = line[0]
                cv2.line(panel_mask, (x1, y1), (x2, y2), 255, 2)
        
        kernel = np.ones((3, 3), np.uint8)
        dilated = cv2.dilate(lines_mask, kernel, iterations=2)
        contours, _ = cv2.findContours(dilated, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        
        panels = []
        for contour in contours:
            x, y, w, h = cv2.boundingRect(contour)
            area = w * h
            if area > img.shape[0] * img.shape[1] * 0.01:
                cv2.rectangle(panel_mask, (x, y), (x + w, y + h), 255, 2)
                panels.append({
                    'x': x,
                    'y': y,
                    'width': w,
                    'height': h,
                    'center_x': x + w / 2,
                    'center_y': y + h / 2
                })
        
        return panel_mask, panels
    
    def merge_panel_mask_with_text_mask(panel_mask, text_mask):
        """合并格子遮罩图和文字mask图"""
        if panel_mask.shape != text_mask.shape:
            panel_mask = cv2.resize(panel_mask, (text_mask.shape[1], text_mask.shape[0]))
        return np.maximum(panel_mask, text_mask)


def get_text_block_panel(text_block, panels):
    """
    判断文字块属于哪个格子
    
    参数:
        text_block: 文字块，包含bbox信息
        panels: 格子列表
    
    返回:
        panel_index: 格子索引，如果不在任何格子内返回-1
    """
    bbox = text_block['bbox']
    center_x = (bbox['x1'] + bbox['x2']) / 2
    center_y = (bbox['y1'] + bbox['y2']) / 2
    
    for i, panel in enumerate(panels):
        if (panel['x'] <= center_x <= panel['x'] + panel['width'] and
            panel['y'] <= center_y <= panel['y'] + panel['height']):
            return i
    
    return -1


def sort_text_blocks_by_panels(text_blocks, panels, image_width, image_height):
    """
    按日式漫画阅读顺序排序：从右到左、从上到下（竖着读取）
    
    排序规则：
    1. 先按列分组（从右到左）- 越往右的列越靠前
    2. 同一列内，按行排序（从上到下）- 越往上的行越靠前
    3. 同一格子内，按X坐标从右到左
    
    参数:
        text_blocks: 文字块列表，每个包含bbox信息
        panels: 格子列表
        image_width: 图片宽度
        image_height: 图片高度
    
    返回:
        排序后的文字块列表
    """
    if not text_blocks:
        return []
    
    # 计算每个文字块的中心点和所属格子
    for block in text_blocks:
        bbox = block['bbox']
        block['center_x'] = (bbox['x1'] + bbox['x2']) / 2
        block['center_y'] = (bbox['y1'] + bbox['y2']) / 2
        block['panel_index'] = get_text_block_panel(block, panels)
    
    # 排序规则（日式漫画：从右到左、从上到下竖着读取）：
    # 1. 先按X坐标分组（从右到左）- X坐标越大（越靠右）越靠前
    # 2. 同一列内，按Y坐标排序（从上到下）- Y坐标越小（越往上）越靠前
    # 3. 同一位置，按X坐标从右到左
    
    # 将图片分成列（从右到左）
    # 使用图片宽度的20%作为列的分组阈值（更宽松的分组）
    column_threshold = max(image_width * 0.2, 100)  # 至少100像素
    
    def sort_key(block):
        # 直接使用文字块的中心坐标，不依赖格子
        center_x = block['center_x']
        center_y = block['center_y']
        
        # 计算列号（从右到左，列号越小越靠右）
        # 将X坐标转换为列号：X坐标越大，列号越小（越靠右）
        # 使用 image_width - center_x 来计算距离右边的距离
        distance_from_right = image_width - center_x
        column = int(distance_from_right / column_threshold)
        
        # 使用列号和Y坐标作为主要排序依据
        # 列号越小（越靠右）越靠前，Y坐标越小（越往上）越靠前
        # 同一列同一行内，X坐标越大（越靠右）越靠前
        return (column, center_y, -center_x)
    
    sorted_blocks = sorted(text_blocks, key=sort_key)
    
    return sorted_blocks


def detect_and_ocr_comic(image_path, model_path=None, output_dir=None):
    """
    检测漫画文字区域并用OCR识别
    
    参数:
        image_path: 图片路径
        model_path: comic-text-detector模型路径
        output_dir: 输出目录
    """
    image_path = Path(image_path)
    
    if not image_path.exists():
        raise FileNotFoundError(f"图片文件不存在: {image_path}")
    
    print(f"📖 正在处理图片: {image_path.name}")
    
    # 设置模型路径
    if model_path is None:
        possible_paths = [
            comic_detector_path / 'data' / 'comictextdetector.pt',
            comic_detector_path / 'data' / 'comictextdetector.pt.onnx',
        ]
        model_path = None
        for path in possible_paths:
            if path.exists():
                model_path = path
                break
        
        if model_path is None:
            raise FileNotFoundError(
                f"未找到comic-text-detector模型文件。请下载模型并放到以下位置之一:\n" +
                "\n".join([f"  - {p}" for p in possible_paths])
            )
    
    # 设置输出目录
    if output_dir is None:
        output_dir = image_path.parent
    else:
        output_dir = Path(output_dir)
        output_dir.mkdir(parents=True, exist_ok=True)
    
    # 创建tmp子目录用于保存中间处理文件
    tmp_dir = output_dir / 'tmp'
    tmp_dir.mkdir(parents=True, exist_ok=True)
    
    # 初始化comic-text-detector
    device = 'cuda' if __import__('torch').cuda.is_available() else 'cpu'
    print(f"[INFO] 使用设备: {device}")
    
    try:
        detector = TextDetector(
            model_path=str(model_path),
            input_size=1024,
            device=device,
            act='leaky'
        )
    except Exception as e:
        print(f"[ERROR] 初始化检测器失败: {e}")
        raise
    
    # 初始化PaddleOCR（唯一使用）
    print("[INFO] 初始化PaddleOCR...")
    ocr_engine = None
    paddleocr_instance = None
    
    if not PADDLEOCR_AVAILABLE:
        raise RuntimeError("PaddleOCR 不可用，请确保已正确安装 paddlex[ocr-core]")
    
    try:
        # 初始化PaddleOCR，使用中文模型
        # enable_mkldnn=False 禁用 MKL-DNN 以避免 NotImplementedError
        # use_angle_cls=True 启用角度分类器，可以更好地识别竖排文字
        paddleocr_instance = PaddleOCR(
            use_angle_cls=True,  # 启用角度分类器，支持竖排文字识别
            lang='ch',  # 中文
            enable_mkldnn=False  # 禁用 MKL-DNN 以避免 oneDNN 错误
        )
        ocr_engine = 'paddleocr'
        print("[INFO] PaddleOCR 初始化成功")
    except Exception as e:
        print(f"[ERROR] PaddleOCR初始化失败: {e}")
        raise RuntimeError(f"PaddleOCR 初始化失败: {e}")
    
    # 读取图片
    img = imread(str(image_path))
    if img is None:
        raise ValueError(f"无法读取图片文件: {image_path}")
    
    im_h, im_w = img.shape[:2]
    print(f"[INFO] 图片尺寸: {im_w}x{im_h}")
    
    image_name = image_path.stem
    
    # 步骤1: 使用comic-text-detector检测文字区域（先检测文字块，用于辅助格子检测）
    print("[INFO] 步骤1: 检测文字区域...")
    try:
        mask, mask_refined, blk_list = detector(
            img,
            refine_mode=REFINEMASK_ANNOTATION,
            keep_undetected_mask=True
        )
    except Exception as e:
        print(f"[ERROR] 检测失败: {e}")
        raise
    
    print(f"[OK] 检测到 {len(blk_list)} 个文字区域")
    
    # 步骤2: 使用文字遮罩图和文字块信息辅助检测漫画格子
    print("[INFO] 步骤2: 检测漫画格子（使用文字遮罩图和文字块信息辅助）...")
    
    # 将文字块转换为统一格式
    text_blocks = []
    for blk in blk_list:
        x1, y1, x2, y2 = blk.xyxy
        text_blocks.append({
            'xyxy': [int(x1), int(y1), int(x2), int(y2)]
        })
    
    # 使用文字遮罩图和文字块信息检测格子（优先使用文字遮罩图）
    panel_mask, panels = detect_comic_panels(img, text_blocks=text_blocks, text_mask=mask_refined)
    print(f"[OK] 检测到 {len(panels)} 个格子")
    
    # 如果检测到的格子太少，尝试不使用辅助信息重新检测
    if len(panels) < 4:
        print(f"[WARN] 检测到的格子数量较少（{len(panels)}个），尝试使用传统方法重新检测...")
        panel_mask_fallback, panels_fallback = detect_comic_panels(img, text_blocks=None, text_mask=None)
        if len(panels_fallback) > len(panels):
            panel_mask = panel_mask_fallback
            panels = panels_fallback
            print(f"[OK] 使用传统方法检测到 {len(panels)} 个格子")
    
    # 保存格子遮罩图到tmp目录（中间文件）
    panel_mask_path = tmp_dir / f"{image_name}_panel_mask.png"
    imwrite(str(panel_mask_path), panel_mask)
    print(f"[OK] 已保存格子遮罩图: {panel_mask_path}")
    
    # 保存格子信息JSON到tmp目录（中间文件）
    panels_json = {
        'image_file': image_path.name,
        'panels': panels,
        'total_count': len(panels)
    }
    panels_json_path = tmp_dir / f"{image_name}_panels.json"
    with open(panels_json_path, 'w', encoding='utf-8') as f:
        json.dump(panels_json, f, ensure_ascii=False, indent=2)
    print(f"[OK] 已保存格子信息: {panels_json_path}")
    
    # 保存原始文字遮罩图到tmp目录（中间文件）
    text_mask_path = tmp_dir / f"{image_name}_text_mask.png"
    imwrite(str(text_mask_path), mask_refined)
    print(f"[OK] 已保存文字遮罩图: {text_mask_path}")
    
    # 步骤3: 合并格子遮罩图和文字mask图
    print("[INFO] 步骤3: 合并格子遮罩图和文字mask图...")
    combined_mask = merge_panel_mask_with_text_mask(panel_mask, mask_refined)
    
    # 保存合并后的mask图片到tmp目录（中间文件）
    combined_mask_path = tmp_dir / f"{image_name}_combined_mask.png"
    print(f"[INFO] 步骤4: 保存合并后的mask图片到磁盘...")
    imwrite(str(combined_mask_path), combined_mask)
    print(f"[OK] 已保存合并后的mask图片: {combined_mask_path}")
    
    # 确认文件已生成
    if not text_mask_path.exists():
        raise FileNotFoundError(f"文字遮罩图文件未成功生成: {text_mask_path}")
    print(f"[OK] 已确认文字遮罩图文件存在")
    
    # 步骤5: 从保存的mask文件中读取，裁剪每个文字区域，然后识别
    print(f"[INFO] 步骤5: 从mask文件中读取并识别 {len(blk_list)} 个文字区域...")
    
    # 使用合并后的mask（已经在内存中，不需要重新读取）
    mask_img = combined_mask
    
    dialogues = []
    
    for i, blk in enumerate(blk_list):
        x1, y1, x2, y2 = blk.xyxy
        
        # 确保坐标在图片范围内
        x1 = max(0, int(x1))
        y1 = max(0, int(y1))
        x2 = min(im_w, int(x2))
        y2 = min(im_h, int(y2))
        
        # 从mask图片中裁剪对应的文字区域
        crop_mask = mask_img[y1:y2, x1:x2]
        
        if crop_mask.size == 0:
            continue
        
        # 同时从原图中裁剪对应的文字区域（用于OCR识别，效果更好）
        crop_img = img[y1:y2, x1:x2]
        
        # 确保是RGB格式（Tesseract可以直接使用，但统一使用RGB格式）
        if len(crop_img.shape) == 2:
            # 如果是灰度图，转换为RGB
            crop_img = cv2.cvtColor(crop_img, cv2.COLOR_GRAY2RGB)
        elif len(crop_img.shape) == 3 and crop_img.shape[2] == 4:
            # 如果是RGBA，转换为RGB
            crop_img = cv2.cvtColor(crop_img, cv2.COLOR_RGBA2RGB)
        
        # 对图片进行预处理以提高OCR识别率（保守处理，避免过度处理）
        # 1. 转换为灰度图
        if len(crop_img.shape) == 3:
            gray = cv2.cvtColor(crop_img, cv2.COLOR_RGB2GRAY)
        else:
            gray = crop_img
        
        # 2. 检测是否为黑底白字（黑白漫画）
        # 计算图片的平均亮度
        mean_brightness = np.mean(gray)
        is_dark_background = mean_brightness < 127  # 如果平均亮度小于127，可能是黑底
        
        # 如果是黑底白字，先反转颜色（OCR模型通常训练在白底黑字上）
        if is_dark_background:
            gray = cv2.bitwise_not(gray)
        
        # 3. 适度放大图片（仅对很小的文字区域）
        h, w = gray.shape[:2]
        if h < 32 or w < 32:  # 只有很小的文字区域才放大
            scale = 2.0
            new_h, new_w = int(h * scale), int(w * scale)
            gray = cv2.resize(gray, (new_w, new_h), interpolation=cv2.INTER_CUBIC)
        
        # 4. 增强对比度（使用CLAHE，保守设置）
        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
        enhanced = clahe.apply(gray)
        
        # 5. 轻度去噪处理（避免过度模糊）
        enhanced = cv2.fastNlMeansDenoising(enhanced, h=8, templateWindowSize=7, searchWindowSize=21)
        
        # 6. 转换回RGB格式（Tesseract可以直接使用灰度图，但RGB也可以）
        if len(enhanced.shape) == 2:
            crop_img_processed = cv2.cvtColor(enhanced, cv2.COLOR_GRAY2RGB)
        else:
            crop_img_processed = enhanced
        
        text_block = {
            'index': i + 1,
            'bbox': {
                'x1': x1,
                'y1': y1,
                'x2': x2,
                'y2': y2,
                'width': x2 - x1,
                'height': y2 - y1,
                'center_x': (x1 + x2) / 2,
                'center_y': (y1 + y2) / 2
            }
        }
        
        try:
            if ocr_engine == 'paddleocr':
                # 使用PaddleOCR识别
                try:
                    # PaddleOCR返回格式: [[[x1, y1], [x2, y2], [x3, y3], [x4, y4]], (text, confidence), ...]
                    ocr_result = paddleocr_instance.ocr(crop_img_processed)
                    
                    # 调试：打印OCR结果格式
                    if ocr_result:
                        print(f"  [DEBUG] 第 {i+1} 个区域: ocr_result类型={type(ocr_result)}, 长度={len(ocr_result) if isinstance(ocr_result, (list, tuple)) else 'N/A'}")
                        if len(ocr_result) > 0:
                            result_item = ocr_result[0]
                            print(f"  [DEBUG] 第 {i+1} 个区域: ocr_result[0]类型={type(result_item)}")
                            # 检查OCRResult对象的属性
                            if hasattr(result_item, '__dict__'):
                                print(f"  [DEBUG] 第 {i+1} 个区域: OCRResult属性={list(result_item.__dict__.keys())}")
                            # 尝试转换为列表或字典
                            try:
                                if hasattr(result_item, 'text_lines') or hasattr(result_item, 'texts'):
                                    print(f"  [DEBUG] 第 {i+1} 个区域: 尝试访问text_lines或texts属性")
                            except:
                                pass
                    
                    if ocr_result and len(ocr_result) > 0:
                        # PaddleOCR 3.x 返回的是 OCRResult 对象
                        result_item = ocr_result[0]
                        
                        # OCRResult 对象有 json 属性，返回字典格式
                        # 结构: {'res': {'rec_texts': [...], 'rec_scores': [...], 'rec_polys': [...], 'rec_boxes': [...]}}
                        try:
                            result_json = result_item.json
                            res_data = result_json.get('res', {}) if isinstance(result_json, dict) else {}
                            
                            # 提取文本、置信度、坐标
                            rec_texts = res_data.get('rec_texts', [])
                            rec_scores = res_data.get('rec_scores', [])
                            rec_polys = res_data.get('rec_polys', [])  # 多边形坐标 [[[x1,y1],[x2,y2],[x3,y3],[x4,y4]], ...]
                            rec_boxes = res_data.get('rec_boxes', [])  # 边界框 [[x1,y1,x2,y2], ...]
                            
                            if not rec_texts:
                                print(f"  [DEBUG] 第 {i+1} 个区域: PaddleOCR未识别到文字")
                                continue
                            
                            text_lines_with_bbox = []
                            all_texts = []
                            all_char_boxes_list = []
                            
                            # 关键改进：先收集所有文本行和它们的边界框，然后对整个文本区域进行字符检测
                            # 这样可以确保OpenCV检测到所有字符，而不仅仅是单个文本行的字符
                            
                            # 解析PaddleOCR结果，收集所有文本行
                            all_text_lines = []  # 存储所有文本行及其边界框
                            for idx, text in enumerate(rec_texts):
                                if not text or not text.strip():
                                    continue
                                
                                # 获取置信度
                                confidence = float(rec_scores[idx]) if idx < len(rec_scores) else 0.9
                                
                                # 获取坐标（优先使用多边形坐标，如果没有则使用边界框）
                                if idx < len(rec_polys) and rec_polys[idx]:
                                    bbox_coords = rec_polys[idx]  # [[x1,y1],[x2,y2],[x3,y3],[x4,y4]]
                                elif idx < len(rec_boxes) and rec_boxes[idx]:
                                    # 将边界框转换为多边形格式
                                    box = rec_boxes[idx]  # [x1, y1, x2, y2]
                                    bbox_coords = [
                                        [box[0], box[1]],  # 左上
                                        [box[2], box[1]],  # 右上
                                        [box[2], box[3]],  # 右下
                                        [box[0], box[3]]   # 左下
                                    ]
                                else:
                                    print(f"  [DEBUG] 第 {i+1} 个区域: 第 {idx} 个文本没有坐标信息")
                                    continue
                                
                                if text and text.strip():
                                    # 计算边界框
                                    # 检查 bbox_coords 格式
                                    if not isinstance(bbox_coords, (list, tuple)) or len(bbox_coords) < 4:
                                        print(f"  [DEBUG] 第 {i+1} 个区域: bbox_coords 格式不正确: {type(bbox_coords)}, {bbox_coords}")
                                        continue
                                    
                                    # 检查每个坐标点格式
                                    try:
                                        x_coords = []
                                        y_coords = []
                                        for coord in bbox_coords:
                                            if isinstance(coord, (list, tuple)) and len(coord) >= 2:
                                                x_coords.append(coord[0])
                                                y_coords.append(coord[1])
                                            else:
                                                print(f"  [DEBUG] 第 {i+1} 个区域: 坐标点格式不正确: {coord}")
                                                break
                                        
                                        if not x_coords or not y_coords or len(x_coords) < 4:
                                            print(f"  [DEBUG] 第 {i+1} 个区域: 无法提取足够的坐标点")
                                            continue
                                    except (TypeError, IndexError) as e:
                                        print(f"  [DEBUG] 第 {i+1} 个区域: 解析坐标失败: {e}, bbox_coords={bbox_coords}")
                                        continue
                                    left = min(x_coords)
                                    top = min(y_coords)
                                    right = max(x_coords)
                                    bottom = max(y_coords)
                                    
                                    # 转换为绝对坐标（相对于原图）
                                    char_bbox = {
                                        'x1': float(x1 + left),
                                        'y1': float(y1 + top),
                                        'x2': float(x1 + right),
                                        'y2': float(y1 + bottom),
                                        'center_x': float(x1 + (left + right) / 2),
                                        'center_y': float(y1 + (top + bottom) / 2)
                                    }
                                    
                                    text_lines_with_bbox.append({
                                        'text': text,
                                        'bbox': char_bbox,
                                        'confidence': confidence
                                    })
                                    all_texts.append((text, confidence))
                                    
                                    # 收集文本行信息，稍后统一处理
                                    all_text_lines.append({
                                        'text': text,
                                        'bbox': char_bbox,
                                        'confidence': confidence
                                    })
                            
                            # 关键改进：对所有文本行合并后的整个区域进行字符检测
                            if all_text_lines:
                                # 计算整个文本区域的边界框（包含所有文本行）
                                all_x1 = [line['bbox']['x1'] for line in all_text_lines]
                                all_y1 = [line['bbox']['y1'] for line in all_text_lines]
                                all_x2 = [line['bbox']['x2'] for line in all_text_lines]
                                all_y2 = [line['bbox']['y2'] for line in all_text_lines]
                                
                                combined_bbox = {
                                    'x1': float(min(all_x1)),
                                    'y1': float(min(all_y1)),
                                    'x2': float(max(all_x2)),
                                    'y2': float(max(all_y2)),
                                    'center_x': float((min(all_x1) + max(all_x2)) / 2),
                                    'center_y': float((min(all_y1) + max(all_y2)) / 2)
                                }
                                
                                # 合并所有文本行的文本
                                combined_text_for_detection = ''.join([line['text'] for line in all_text_lines])
                                
                                # 使用OpenCV检测整个文本区域的所有字符
                                # 注意：text_bbox_for_detection必须使用绝对坐标（相对于原图）
                                # 因为detect_characters_with_opencv函数期望的是原图坐标
                                text_bbox_for_detection = {
                                    'x1': combined_bbox['x1'],
                                    'y1': combined_bbox['y1'],
                                    'x2': combined_bbox['x2'],
                                    'y2': combined_bbox['y2']
                                }
                                
                                # 使用OpenCV检测字符位置（需要传入原图img，而不是crop_img）
                                # 注意：坐标是相对于原图的，所以需要传入原图
                                # 传入OCR的边界框作为参考，提高识别率
                                detected_char_boxes = detect_characters_with_opencv(
                                    img, text_bbox_for_detection, combined_text_for_detection, ocr_bbox_hint=combined_bbox
                                )
                                
                                # 调试输出：检查OpenCV是否识别出所有字符
                                if '远道' in combined_text_for_detection or '石田' in combined_text_for_detection:
                                    print(f"  [DEBUG] 合并后OCR文本: {combined_text_for_detection}")
                                    text_no_space_debug = combined_text_for_detection.replace(' ', '')
                                    print(f"  [DEBUG] 去除空格后: {text_no_space_debug}, 字符数: {len(text_no_space_debug)}")
                                    print(f"  [DEBUG] OpenCV检测到的字符框数: {len(detected_char_boxes)}")
                                    if len(detected_char_boxes) > 0:
                                        print(f"  [DEBUG] 前3个字符框位置: center_x={[b['center_x'] for b in detected_char_boxes[:3]]}, center_y={[b['center_y'] for b in detected_char_boxes[:3]]}")
                                
                                text_no_space = combined_text_for_detection.replace(' ', '')
                                
                                if len(detected_char_boxes) > 0 and len(detected_char_boxes) == len(text_no_space):
                                    # 使用OpenCV检测到的精确位置
                                    # 关键：OpenCV检测的字符框顺序可能与OCR文本顺序不一致
                                    # 需要根据字符框的位置来匹配字符，而不是简单地按索引对应
                                    
                                    # 方法1：将字符框按位置排序（在OpenCV坐标系中：从上到下、从右到左）
                                    # 注意：detect_characters_with_opencv函数返回的字符框可能已经按某种顺序排列
                                    # 但我们需要确保按照正确的阅读顺序（从上到下、从右到左）排序
                                    sorted_char_boxes = sorted(detected_char_boxes, key=lambda b: (b['y1'], -b['center_x']))
                                    
                                    # 反转文本字符，使其与字符框的位置顺序对应
                                    reversed_text_chars = list(text_no_space[::-1])
                                    
                                    # 将排序后的字符框与反转后的文本字符对应
                                    for k, char_box in enumerate(sorted_char_boxes):
                                        char = reversed_text_chars[k] if k < len(reversed_text_chars) else '?'
                                        all_char_boxes_list.append({
                                            'char': char,
                                            'x1': char_box['x1'],
                                            'y1': char_box['y1'],
                                            'x2': char_box['x2'],
                                            'y2': char_box['y2'],
                                            'center_x': char_box['center_x'],
                                            'center_y': char_box['center_y']
                                        })
                                    else:
                                        # 如果OpenCV检测失败，回退到估算方法
                                        if len(text_no_space) > 0:
                                            bbox_width = right - left
                                            bbox_height = bottom - top
                                            is_vertical = bbox_height > bbox_width * 1.2
                                            
                                            if is_vertical:
                                                # 竖排：字符从上到下（y坐标从小到大）
                                                char_height = bbox_height / len(text_no_space)
                                                for k, char in enumerate(text_no_space):
                                                    char_x = char_bbox['center_x']
                                                    char_y = char_bbox['y1'] + char_height * (k + 0.5)
                                                    all_char_boxes_list.append({
                                                        'char': char,
                                                        'x1': char_x - 5,
                                                        'y1': char_y - char_height/2,
                                                        'x2': char_x + 5,
                                                        'y2': char_y + char_height/2,
                                                        'center_x': char_x,
                                                        'center_y': char_y
                                                    })
                                            else:
                                                # 横排：字符从左到右（估算）
                                                char_width = bbox_width / len(text_no_space)
                                                for k, char in enumerate(text_no_space):
                                                    char_x = char_bbox['x1'] + char_width * (k + 0.5)
                                                    char_y = char_bbox['center_y']
                                                    all_char_boxes_list.append({
                                                        'char': char,
                                                        'x1': char_x - char_width/2,
                                                        'y1': char_y - 5,
                                                        'x2': char_x + char_width/2,
                                                        'y2': char_y + 5,
                                                        'center_x': char_x,
                                                        'center_y': char_y
                                                    })
                            
                            # 合并所有文字
                            if all_texts:
                                # 先对文字行进行排序（从右到左、从上到下）
                                # 注意：对于日式漫画，阅读顺序是从右到左、从上到下
                                # 排序规则：先按Y坐标从上到下（y1越小越靠上），然后按X坐标从右到左（center_x越大越靠右）
                                if len(text_lines_with_bbox) > 1:
                                    text_lines_with_bbox.sort(key=lambda line: (line['bbox']['y1'], -line['bbox']['center_x']))
                                
                                # 从排序后的text_lines_with_bbox中提取文本
                                text_lines = [line['text'] for line in text_lines_with_bbox]
                                combined_text = ' '.join(text_lines)
                                avg_confidence = sum([t[1] for t in all_texts]) / len(all_texts) if all_texts else 0.0
                                
                                # 使用字符位置信息
                                character_positions = []
                                if all_char_boxes_list and len(all_char_boxes_list) > 0:
                                    # 获取图片高度（用于坐标转换）
                                    img_height = img.shape[0]
                                    
                                    # 注意：字符框已经在前面按位置排序并与文本字符对应了
                                    # 这里不需要再次排序，保持字符与坐标的对应关系
                                    # 直接使用all_char_boxes_list，保持字符与坐标的对应关系
                                    for char_box in all_char_boxes_list:
                                        # 将坐标转换为数学坐标系（左下角为原点，向上为y轴正方向）
                                        # 转换中心坐标
                                        center_x_old = char_box['center_x']
                                        center_y_old = char_box['center_y']
                                        center_x_new, center_y_new = convert_coordinate_to_math_system(center_x_old, center_y_old, img_height)
                                        
                                        # 转换边界框坐标（用于更精确的位置信息）
                                        x1_old = char_box['x1']
                                        y1_old = char_box['y1']
                                        x2_old = char_box['x2']
                                        y2_old = char_box['y2']
                                        
                                        x1_new, y1_new = convert_coordinate_to_math_system(x1_old, y1_old, img_height)
                                        x2_new, y2_new = convert_coordinate_to_math_system(x2_old, y2_old, img_height)
                                        
                                        # 注意：在数学坐标系中，y1_new > y2_new（因为y1在原图中更靠上，转换后y值更大）
                                        # 所以需要确保y1是上边界（y值更大），y2是下边界（y值更小）
                                        y1_math = max(y1_new, y2_new)  # 上边界（y值更大）
                                        y2_math = min(y1_new, y2_new)  # 下边界（y值更小）
                                        
                                        character_positions.append({
                                            'x': center_x_new,  # 转换后的中心x坐标（数学坐标系）
                                            'y': center_y_new,  # 转换后的中心y坐标（数学坐标系）
                                            'center_x': center_x_new,  # 转换后的中心x坐标
                                            'center_y': center_y_new,  # 转换后的中心y坐标
                                            'x1': min(x1_new, x2_new),  # 转换后的左边界x坐标
                                            'y1': y1_math,  # 转换后的上边界y坐标（数学坐标系中y值更大）
                                            'x2': max(x1_new, x2_new),  # 转换后的右边界x坐标
                                            'y2': y2_math,  # 转换后的下边界y坐标（数学坐标系中y值更小）
                                            'x_old': center_x_old,  # 保留原始中心x坐标（用于调试）
                                            'y_old': center_y_old   # 保留原始中心y坐标（用于调试）
                                        })
                                
                                # 如果字符位置数量不匹配，清空
                                text_no_space_for_check = combined_text.replace(' ', '')
                                if len(character_positions) != len(text_no_space_for_check):
                                    if '远道' in combined_text or '石田' in combined_text:
                                        print(f"  [DEBUG] 字符位置数量不匹配: character_positions={len(character_positions)}, text长度={len(text_no_space_for_check)}, text=\"{combined_text}\"")
                                    character_positions = []
                                elif '远道' in combined_text or '石田' in combined_text:
                                    print(f"  [DEBUG] 字符位置数量匹配: character_positions={len(character_positions)}, text长度={len(text_no_space_for_check)}")
                                    print(f"  [DEBUG] 前3个character_positions: {[{'x': p.get('center_x', p.get('x', 0)), 'y': p.get('center_y', p.get('y', 0))} for p in character_positions[:3]]}")
                                
                                # 调试输出：检查character_positions
                                if ('远道' in combined_text or '石田' in combined_text) and character_positions:
                                    print(f"  [DEBUG] 保存到dialogues: text=\"{combined_text}\", character_positions数量={len(character_positions)}")
                                
                                if combined_text and combined_text.strip():
                                    dialogues.append({
                                        'order': i + 1,
                                        'text': combined_text,
                                        'bbox': text_block['bbox'],
                                        'confidence': avg_confidence,
                                        'character_positions': character_positions if character_positions else None
                                    })
                                    text_preview = combined_text[:30] + '...' if len(combined_text) > 30 else combined_text
                                    print(f"  [{i+1}/{len(blk_list)}] 识别: {text_preview} (置信度: {avg_confidence:.2f})")
                                else:
                                    print(f"  [DEBUG] 第 {i+1} 个区域: combined_text为空 (all_texts长度: {len(all_texts)})")
                            else:
                                print(f"  [DEBUG] 第 {i+1} 个区域未识别到文字 (all_texts为空)")
                        except Exception as e:
                            print(f"  [WARN] PaddleOCR解析第 {i+1} 个区域结果失败: {e}")
                            import traceback
                            traceback.print_exc()
                            continue
                except Exception as e:
                    print(f"  [WARN] PaddleOCR识别第 {i+1} 个区域失败: {e}")
                    import traceback
                    traceback.print_exc()
                    continue
            else:
                # 只使用PaddleOCR，如果失败则报错
                raise RuntimeError(f"OCR引擎不是PaddleOCR，当前引擎: {ocr_engine}")
        except Exception as e:
            print(f"  [WARN] 识别第 {i+1} 个区域失败: {e}")
            import traceback
            traceback.print_exc()
            continue
    
    print(f"[OK] 成功识别 {len(dialogues)} 段文字")
    
    # 步骤6: 按格子位置排序（越往上、越往右的格子里的对话顺序越靠前）
    print("[INFO] 步骤6: 按格子位置排序...")
    sorted_dialogues = sort_text_blocks_by_panels(dialogues, panels, im_w, im_h)
    
    # 重新分配order，保留order、text、bbox和character_positions字段
    formatted_dialogues = []
    for i, dialogue in enumerate(sorted_dialogues, 1):
        formatted_dialogues.append({
            'order': i,
            'text': dialogue['text'],
            'bbox': dialogue.get('bbox', {}),  # 保留bbox信息用于排序
            'character_positions': dialogue.get('character_positions')  # 保留字符位置信息用于字符排序
        })
    
    # 步骤7: 保存JSON结果到output_dir（ocr目录，最终结果）
    print("[INFO] 步骤7: 保存JSON结果...")
    result = {
        'image_file': image_path.name,
        'reading_order': '从右到左、从上到下（日式漫画阅读顺序）',
        'dialogues': formatted_dialogues,
        'total_count': len(formatted_dialogues)
    }
    
    # 保存JSON到output_dir（ocr目录，最终结果文件）
    json_path = output_dir / f"{image_name}_dialogues.json"
    with open(json_path, 'w', encoding='utf-8') as f:
        json.dump(result, f, ensure_ascii=False, indent=2)
    print(f"[OK] 已保存对白结果: {json_path}")
    
    return result


def batch_detect_and_ocr(image_dir, model_path=None, output_dir=None):
    """
    批量处理目录下所有图片
    """
    image_dir = Path(image_dir)
    
    if not image_dir.exists():
        raise FileNotFoundError(f"图片目录不存在: {image_dir}")
    
    # 获取所有图片文件，按文件名数字排序
    image_files = []
    for ext in ['*.jpg', '*.jpeg', '*.png', '*.bmp', '*.webp']:
        image_files.extend(image_dir.glob(ext))
        image_files.extend(image_dir.glob(ext.upper()))
    
    # 按文件名开头的数字排序
    image_files = sorted(image_files, key=lambda x: int(x.stem.split('_')[0]) if x.stem.split('_')[0].isdigit() else 0)
    
    print(f"[INFO] 找到 {len(image_files)} 张图片")
    
    # 设置输出目录
    if output_dir is None:
        output_dir = image_dir / 'ocr'
    else:
        output_dir = Path(output_dir)
    
    output_dir.mkdir(parents=True, exist_ok=True)
    
    results = []
    for i, image_file in enumerate(image_files, 1):
        print(f"\n[{i}/{len(image_files)}] 处理: {image_file.name}")
        try:
            result = detect_and_ocr_comic(image_file, model_path, output_dir)
            results.append(result)
        except Exception as e:
            print(f"[ERROR] 处理 {image_file.name} 失败: {e}")
            import traceback
            traceback.print_exc()
            continue
    
    print(f"\n[OK] 批量处理完成，成功处理 {len(results)} 张图片")
    return results


if __name__ == '__main__':
    import argparse
    
    parser = argparse.ArgumentParser(description='检测漫画文字区域并用OCR识别')
    parser.add_argument('input', help='输入图片路径或目录')
    parser.add_argument('-o', '--output', help='输出目录')
    parser.add_argument('-m', '--model', help='comic-text-detector模型路径')
    
    args = parser.parse_args()
    
    input_path = Path(args.input)
    
    if input_path.is_file():
        detect_and_ocr_comic(input_path, args.model, args.output)
    elif input_path.is_dir():
        batch_detect_and_ocr(input_path, args.model, args.output)
    else:
        print(f"[ERROR] 输入路径不存在: {input_path}")
        sys.exit(1)