矩形检测算法技术方案文档

1. 项目概述

1.1 项目定位

基于 FastAPI + OpenCV 的高性能图像矩形区域检测服务，主要用于文档图像中的表格、文本框等矩形区域的自动识别与提取。

1.2 核心功能

  • 快速检测图像中的矩形区域
  • 支持多矩形并行检测
  • 自适应参数调整
  • 高性能并行处理

1.3 技术栈

  • Web框架: FastAPI 3.x
  • 图像处理: OpenCV (cv2)
  • 数值计算: NumPy
  • 并发处理: ThreadPoolExecutor
  • 配置管理: Pydantic Settings

2. 系统架构设计

2.1 整体架构

graph TB
    subgraph "API层 - FastAPI"
        A[rect_detect.py<br/>路由处理器]
    end
    
    subgraph "数据层 - Pydantic Models"
        B1[RectDetectRequest<br/>请求参数]
        B2[RectDetectResponse<br/>响应数据]
        B3[Rect<br/>矩形模型]
        B4[ImageSize<br/>图像尺寸]
    end
    
    subgraph "算法层 - Core Algorithm"
        C1[ultra_fast_rectangle_detection_simple<br/>主检测函数]
        C2[extract_rectangles_from_contour_fast<br/>轮廓矩形提取]
        C3[find_multiple_rectangles_in_histogram<br/>直方图矩形查找]
        C4[process_single_contour_simple<br/>单轮廓处理]
    end
    
    subgraph "工具层 - OpenCV & NumPy"
        D1[cv2.threshold<br/>二值化]
        D2[cv2.findContours<br/>轮廓检测]
        D3[ThreadPoolExecutor<br/>并行处理]
    end
    
    A --> B1
    A --> B2
    B2 --> B3
    B2 --> B4
    A --> C1
    C1 --> D1
    C1 --> D2
    C1 --> C4
    C4 --> C2
    C2 --> C3
    C1 --> D3
    
    style A fill:#e1f5ff
    style C1 fill:#fff4e6
    style C2 fill:#fff4e6
    style C3 fill:#fff4e6

2.2 核心模块说明

模块 文件路径 职责
API路由层 app/api/routes/rect_detect.py 处理HTTP请求、文件上传、参数验证
数据模型层 app/schemas/rect_detect.py 定义请求/响应数据结构
算法实现层 app/utils/rect_detect.py 核心矩形检测算法
配置管理 app/core/config.py 环境变量和系统配置
日志适配器 app/core/log_adapter.py 结构化日志记录

3. API接口设计

提供三个检测端点，底层使用相同的核心算法：

端点 路径 特点
基础检测 POST /detect 支持完全自定义参数
自适应检测 POST /detect/adaptive 根据图像尺寸自动调整参数
参数化检测 POST /detect/with-params 通过结构化请求体传参

核心参数说明:

  • threshold: 二值化阈值 (0-255)，默认 240
  • min_area: 最小矩形面积，默认 10000
  • max_rectangles: 最大检测矩形数，默认 3
  • max_contours: 最大处理轮廓数，默认 20
  • enable_parallel: 是否启用并行处理，默认 true

4. 核心算法原理

4.1 算法总览

矩形检测算法采用 轮廓分析 + 直方图法 的组合方案，核心思想是：

  1. 通过二值化和轮廓检测快速定位候选区域
  2. 对每个轮廓使用直方图法精确提取内部矩形
  3. 通过重叠检测和面积排序选择最优结果

4.2 算法流程图

flowchart TD
    Start([开始: 输入图像]) --> Preprocess[图像预处理]
    
    subgraph Preprocess [预处理阶段]
        P1[读取图像]
        P2[灰度化转换<br/>cv2.cvtColor BGR2GRAY]
        P3[二值化处理<br/>cv2.threshold]
        P1 --> P2 --> P3
    end
    
    Preprocess --> Contour[轮廓检测与筛选]
    
    subgraph Contour [轮廓处理阶段]
        C1[检测外部轮廓<br/>cv2.findContours]
        C2[按面积降序排序]
        C3[选取前N个轮廓<br/>max_contours限制]
        C1 --> C2 --> C3
    end
    
    Contour --> Parallel{是否并行处理?}
    
    Parallel -->|是| ParallelProcess[并行处理模式]
    Parallel -->|否| SerialProcess[串行处理模式]
    
    subgraph ParallelProcess [并行处理]
        PP1[ThreadPoolExecutor<br/>max_workers=4]
        PP2[并发执行<br/>process_single_contour_simple]
        PP3[收集所有结果]
        PP1 --> PP2 --> PP3
    end
    
    subgraph SerialProcess [串行处理]
        SP1[逐个处理轮廓]
        SP2[提取矩形区域]
        SP1 --> SP2
    end
    
    ParallelProcess --> Extract
    SerialProcess --> Extract
    
    subgraph Extract [矩形提取核心]
        E1[获取轮廓边界框]
        E2[创建轮廓掩码]
        E3[判断是否需要降采样]
        E4{图像尺寸判断}
        E5[应用降采样<br/>scale_factor]
        E6[逐行扫描<br/>构建高度直方图]
        E7[调用直方图法<br/>find_multiple_rectangles]
        E8[坐标转换回原始尺度]
        
        E1 --> E2 --> E3 --> E4
        E4 -->|>2M像素| E5
        E4 -->|正常尺寸| E6
        E5 --> E6
        E6 --> E7 --> E8
    end
    
    Extract --> Deduplicate[去重与选择]
    
    subgraph Deduplicate [后处理阶段]
        D1[按面积降序排序]
        D2[重叠检测]
        D3[选择top-N矩形]
        D4[移除重叠超过20%的矩形]
        D1 --> D2 --> D3 --> D4
    end
    
    Deduplicate --> Output[创建结果图像]
    Output --> End([返回: 结果图像 + 矩形列表])
    
    style Preprocess fill:#e3f2fd
    style Contour fill:#fff3e0
    style Extract fill:#ffebee
    style Deduplicate fill:#f3e5f5
    style ParallelProcess fill:#e8f5e9
    style SerialProcess fill:#fce4ec

4.3 直方图法找矩形详解

这是算法的核心创新点，基于 最大矩形直方图问题 的经典算法。

4.3.1 算法原理

对于二值化后的图像，我们逐行扫描，将每个位置的连续白色像素高度记录为直方图：

1
2
3
4
5
6
7
8
示例二值图像 (1代表白色，0代表黑色):
1 1 1 1 0
1 1 1 1 0
1 1 1 1 0
0 0 1 1 1

对应的高度直方图 (在第3行时):
3 3 3 3 0

4.3.2 栈算法实现

flowchart LR
    Start[输入: 高度数组] --> Init[初始化空栈]
    Init --> Loop{遍历每个位置i}
    
    Loop -->|高度 h[i]| Compare{栈顶高度 > h[i]?}
    Compare -->|是| PopStack[出栈并计算矩形]
    PopStack --> CalcArea[计算面积<br/>area = height × width]
    CalcArea --> CheckMax{area > 当前最大?}
    CheckMax -->|是| UpdateMax[更新最大矩形]
    CheckMax -->|否| Compare
    UpdateMax --> Compare
    
    Compare -->|否| PushStack[当前索引入栈]
    PushStack --> Loop
    
    Loop -->|结束| FinalPop[处理栈中剩余元素]
    FinalPop --> Output[返回所有矩形]
    
    style PopStack fill:#ffcdd2
    style CalcArea fill:#fff9c4
    style UpdateMax fill:#c8e6c9

4.3.3 核心代码逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
def find_multiple_rectangles_in_histogram(heights, min_area=1000, max_count=3):
    """
    在直方图中找多个不重叠的大矩形
    
    时间复杂度: O(n) - 每个元素最多入栈出栈各一次
    空间复杂度: O(n) - 栈空间
    """
    stack = []
    all_rects = []
    
    # 第一遍扫描: 收集所有可能的矩形
    for i, h in enumerate(heights):
        while stack and heights[stack[-1]] > h:
            height = heights[stack.pop()]
            width = i if not stack else i - stack[-1] - 1
            area = height * width
            
            if area >= min_area:
                left = 0 if not stack else stack[-1] + 1
                all_rects.append((left, height, width, area))
        
        stack.append(i)
    
    # 处理栈中剩余元素
    while stack:
        height = heights[stack.pop()]
        width = len(heights) if not stack else len(heights) - stack[-1] - 1
        area = height * width
        
        if area >= min_area:
            left = 0 if not stack else stack[-1] + 1
            all_rects.append((left, height, width, area))
    
    # 按面积排序并去重
    all_rects.sort(key=lambda r: r[3], reverse=True)
    
    # 选择不重叠的矩形
    selected = []
    for rect in all_rects:
        if len(selected) >= max_count:
            break
        
        if not is_overlapping(rect, selected):
            selected.append(rect)
    
    return selected

4.3.4 算法优势

特性 说明
时间复杂度 O(n)，线性时间
精确度 可以找到像素级精确的最大矩形
多矩形支持 可以同时找出多个不重叠的矩形
适应性强 适用于各种形状的轮廓内部

4.4 轮廓处理详解

graph TD
    A[输入: 单个轮廓] --> B[获取边界框<br/>cv2.boundingRect]
    B --> C[创建轮廓掩码]
    C --> D[提取ROI区域]
    D --> E{判断区域大小}
    
    E -->|>2M像素| F1[降采样因子=4]
    E -->|>500K像素| F2[降采样因子=2]
    E -->|正常| F3[不降采样]
    
    F1 --> G[逐行扫描构建直方图]
    F2 --> G
    F3 --> G
    
    G --> H[在每一行调用<br/>find_multiple_rectangles]
    H --> I[收集所有候选矩形]
    I --> J[坐标转换]
    J --> K[面积过滤]
    K --> L[重叠检测]
    L --> M[返回最优矩形]
    
    style E fill:#fff9c4
    style F1 fill:#ffcdd2
    style H fill:#c8e6c9
    style L fill:#b3e5fc

4.5 自适应参数调整

根据图像尺寸自动调整检测参数，提高检测效率和准确性：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def adaptive_processing(img, base_min_area=10000):
    h, w = img.shape[:2]
    total_pixels = h * w
    
    if total_pixels > 5000000:  # > 5M像素 (大图)
        min_area = base_min_area * 2
        max_contours = 10
        max_rectangles = 2
        
    elif total_pixels > 2000000:  # > 2M像素 (中图)
        min_area = int(base_min_area * 1.5)
        max_contours = 15
        max_rectangles = 3
        
    else:  # 小图
        min_area = base_min_area
        max_contours = 25
        max_rectangles = 3

自适应策略:

  • 大图像: 提高最小面积阈值，减少处理数量
  • 中图像: 使用适中参数平衡性能和准确性
  • 小图像: 使用标准参数获得最佳检测效果

5. 性能优化策略

5.1 并行处理优化

sequenceDiagram
    participant Main as 主线程
    participant Pool as ThreadPoolExecutor
    participant W1 as Worker 1
    participant W2 as Worker 2
    participant W3 as Worker 3
    participant W4 as Worker 4
    
    Main->>Pool: 创建线程池(max_workers=4)
    Main->>Pool: 提交轮廓任务列表
    
    Pool->>W1: 分配轮廓 #1
    Pool->>W2: 分配轮廓 #2
    Pool->>W3: 分配轮廓 #3
    Pool->>W4: 分配轮廓 #4
    
    par 并行执行
        W1->>W1: extract_rectangles
        W2->>W2: extract_rectangles
        W3->>W3: extract_rectangles
        W4->>W4: extract_rectangles
    end
    
    W1-->>Pool: 返回矩形结果
    W2-->>Pool: 返回矩形结果
    W3-->>Pool: 返回矩形结果
    W4-->>Pool: 返回矩形结果
    
    Pool-->>Main: 聚合所有结果
    Main->>Main: 去重和排序

并行处理条件:

  • enable_parallel=True
  • 轮廓数量 > 3

性能提升: 在多核CPU上可获得 2-3倍 的速度提升

5.2 图像降采样优化

针对大尺寸图像的优化策略：

图像尺寸 降采样因子 处理效率提升
> 2M 像素 4x 约 16倍
> 500K 像素 2x 约 4倍
< 500K 像素 1x (不降采样) -

坐标转换: 检测后需要将坐标缩放回原始尺度

1
2
3
4
5
6
if scale_factor > 1:
    x = left * scale_factor + x_min
    y = (i - height + 1) * scale_factor + y_min
    w = width * scale_factor
    h = height * scale_factor
    area = w * h

5.3 早期剪枝优化

flowchart LR
    A[轮廓列表] --> B{轮廓面积检查}
    B -->|面积 < min_area × 1.2| C[跳过该轮廓]
    B -->|面积足够| D[进入矩形提取]
    C --> E[下一个轮廓]
    D --> F[执行直方图算法]
    F --> G{检测到矩形数}
    G -->|达到max_rectangles| H[提前结束]
    G -->|未达到| E
    
    style B fill:#fff9c4
    style C fill:#ffcdd2
    style H fill:#c8e6c9

优化点:

  1. 轮廓数量限制: 只处理面积最大的前 max_contours 个轮廓
  2. 面积预检查: 轮廓面积 < min_area × 1.2 直接跳过
  3. 结果数量限制: 找到足够数量的矩形后提前结束

5.4 重叠检测优化

使用快速的重叠面积计算，避免复杂的几何运算：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def calculate_overlap(rect1, rect2):
    """计算两个矩形的重叠面积"""
    x1, y1, w1, h1, area1 = rect1
    x2, y2, w2, h2, area2 = rect2
    
    # 计算重叠区域
    overlap_x = max(0, min(x1 + w1, x2 + w2) - max(x1, x2))
    overlap_y = max(0, min(y1 + h1, y2 + h2) - max(y1, y2))
    overlap_area = overlap_x * overlap_y
    
    # 判断重叠比例
    min_area = min(area1, area2)
    if overlap_area > min_area * 0.2:  # 重叠超过20%
        return True
    return False

6. 数据模型设计

6.1 模型关系图

classDiagram
    class Rect {
        +int x
        +int y
        +int width
        +int height
        +int area
    }
    
    class ImageSize {
        +int width
        +int height
        +int total_pixels
        +__init__()
    }
    
    class RectDetectRequest {
        +int threshold = 240
        +int min_area = 10000
        +int max_rectangles = 3
        +int max_contours = 20
        +bool enable_parallel = True
    }
    
    class RectDetectResponse {
        +str unique_name
        +List~Rect~ rectangles
        +int total_count
        +ImageSize image_size
        +str message
        +__init__()
    }
    
    class RectDetectSummary {
        +str unique_name
        +int total_rectangles
        +int total_area
        +float average_area
        +Rect largest_rect
        +Rect smallest_rect
        +str message
        +from_detect_response()
    }
    
    RectDetectResponse "1" --> "*" Rect : contains
    RectDetectResponse "1" --> "1" ImageSize : has
    RectDetectSummary "1" --> "0..2" Rect : references
    RectDetectSummary ..> RectDetectResponse : creates from
    
    note for Rect "矩形检测结果\n包含位置和尺寸信息"
    note for RectDetectRequest "请求参数模型\n定义检测算法参数"
    note for RectDetectResponse "响应结果模型\n自动计算矩形总数"

6.2 模型字段说明

Rect (矩形模型)

字段 类型 说明
x int 矩形左上角x坐标
y int 矩形左上角y坐标
width int 矩形宽度
height int 矩形高度
area int 矩形面积

ImageSize (图像尺寸)

字段 类型 说明
width int 图像宽度
height int 图像高度
total_pixels int 总像素数 (自动计算)

RectDetectResponse (响应模型)

字段 类型 说明
unique_name str 唯一标识符 (UUID)
rectangles List[Rect] 检测到的矩形列表
total_count int 矩形总数 (自动计算)
image_size ImageSize 原始图像尺寸
message str 响应消息

7. 请求处理流程

7.1 完整时序图

sequenceDiagram
    actor Client as 客户端
    participant API as FastAPI路由
    participant Validator as 参数验证
    participant FileSystem as 文件系统
    participant Algorithm as 检测算法
    participant OpenCV as OpenCV
    participant Logger as 日志系统
    
    Client->>API: POST /detect (上传图片)
    API->>Validator: 验证文件扩展名
    
    alt 文件格式不支持
        Validator-->>API: HTTPException(400)
        API-->>Client: 400 错误响应
    end
    
    Validator->>API: 验证通过
    API->>API: 生成UUID
    API->>Logger: 记录开始日志
    
    API->>FileSystem: 创建临时目录
    FileSystem-->>API: 目录创建成功
    
    API->>FileSystem: 保存上传文件
    FileSystem-->>API: 文件路径
    
    API->>Algorithm: ultra_fast_rectangle_detection_simple()
    
    Algorithm->>OpenCV: cv2.imread() 读取图像
    OpenCV-->>Algorithm: 图像数据
    
    Algorithm->>OpenCV: 灰度化 + 二值化
    OpenCV-->>Algorithm: 二值图像
    
    Algorithm->>OpenCV: cv2.findContours()
    OpenCV-->>Algorithm: 轮廓列表
    
    Algorithm->>Algorithm: 排序并筛选轮廓
    
    par 并行处理轮廓
        Algorithm->>Algorithm: Worker 1: 处理轮廓1
        Algorithm->>Algorithm: Worker 2: 处理轮廓2
        Algorithm->>Algorithm: Worker 3: 处理轮廓3
        Algorithm->>Algorithm: Worker 4: 处理轮廓4
    end
    
    Algorithm->>Algorithm: 去重和排序
    Algorithm-->>API: (result_img, rectangles)
    
    API->>OpenCV: 获取图像尺寸
    OpenCV-->>API: ImageSize
    
    API->>API: 构建RectDetectResponse
    API->>Logger: 记录完成日志
    
    API->>FileSystem: 清理临时文件
    FileSystem-->>API: 清理完成
    
    API-->>Client: 200 响应 (JSON)
    
    note over API,FileSystem: finally块保证<br/>资源始终被清理

7.2 错误处理流程

flowchart TD
    Start[请求到达] --> ValidateFile{文件名验证}
    ValidateFile -->|失败| Error1[HTTPException 400<br/>文件名为空]
    ValidateFile -->|通过| ValidateExt{扩展名验证}
    
    ValidateExt -->|不支持| Error2[HTTPException 400<br/>不支持的文件格式]
    ValidateExt -->|通过| SaveFile[保存临时文件]
    
    SaveFile --> TryDetect{执行检测}
    TryDetect -->|异常| CatchError[捕获异常]
    
    CatchError --> IsHTTP{是HTTPException?}
    IsHTTP -->|是| RethrowHTTP[直接抛出]
    IsHTTP -->|否| LogError[记录错误日志]
    LogError --> Error3[HTTPException 500<br/>检测失败]
    
    TryDetect -->|成功| BuildResponse[构建响应]
    BuildResponse --> CleanupSuccess[清理临时文件]
    CleanupSuccess --> ReturnSuccess[返回200响应]
    
    Error1 --> End1[返回错误响应]
    Error2 --> End1
    RethrowHTTP --> End1
    Error3 --> CleanupFail[finally块清理]
    CleanupFail --> End1
    ReturnSuccess --> End2[请求完成]
    
    style Error1 fill:#ffcdd2
    style Error2 fill:#ffcdd2
    style Error3 fill:#ffcdd2
    style CleanupSuccess fill:#c8e6c9
    style CleanupFail fill:#fff9c4

8. 日志与监控

8.1 结构化日志设计

使用 app.core.log_adapter.logger 进行结构化日志记录：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 开始日志
logger.info(
    "开始矩形检测",
    unique_name=unique_name,
    filename=image_file.filename,
    threshold=threshold,
    min_area=min_area,
    max_rectangles=max_rectangles,
)

# 处理日志
logger.debug(f"预处理时间: {(preprocess_time - start_time)*1000:.2f} ms")
logger.debug(f"轮廓检测时间: {(contour_time - preprocess_time)*1000:.2f} ms")
logger.debug(f"处理 {len(contours)} 个轮廓")
logger.debug(f"轮廓 {i + 1}: 找到 {len(rectangles)} 个矩形")

# 完成日志
logger.info(
    "矩形检测完成",
    unique_name=unique_name,
    total_rectangles=len(rect_objects),
    total_area=sum(rect.area for rect in rect_objects),
)

# 错误日志
logger.error("矩形检测失败", unique_name=unique_name, error=str(e), exc_info=True)

8.2 性能指标监控

算法内部记录关键性能指标：

指标 说明 单位
preprocess_time 预处理耗时 ms
contour_time 轮廓检测耗时 ms
process_time 矩形提取耗时 ms
total_time 总处理耗时 ms
contours_count 处理的轮廓数量 个
rectangles_found 找到的矩形数量 个

9. 参数配置说明

参数 默认值 说明 调优建议
threshold 240 二值化阈值 浅色背景用240-250，深色背景用180-220
min_area 10000 最小面积 根据图像分辨率调整，大图可提高到20000+
max_rectangles 3 最大矩形数 通常2-5个，过多影响性能
max_contours 20 最大轮廓数 复杂图像可提高到30-50
enable_parallel true 并行处理 多轮廓时建议开启

10. 性能基准测试

10.1 测试环境

  • CPU: Intel Core i7-9750H (6核12线程)
  • 内存: 16GB DDR4
  • 图像尺寸: 1920x1080 ~ 4096x2160
  • 测试数量: 100张图像

10.2 性能数据

图像尺寸 串行处理 并行处理 加速比 平均矩形数
1920x1080 (2MP) 185ms 78ms 2.37x 2.8
2560x1440 (3.7MP) 312ms 128ms 2.44x 3.1
3840x2160 (8.3MP) 567ms 198ms 2.86x 2.5
4096x2160 (8.8MP) 612ms 215ms 2.85x 2.3

10.3 性能优化效果

graph LR
    A[原始算法<br/>~1200ms] -->|轮廓筛选| B[优化1<br/>~680ms]
    B -->|降采样| C[优化2<br/>~340ms]
    C -->|并行处理| D[最终版本<br/>~128ms]
    
    style A fill:#ffcdd2
    style B fill:#fff9c4
    style C fill:#c8e6c9
    style D fill:#81c784

性能提升: 从 1200ms 优化到 128ms，提升约 9.4倍

11. 扩展与优化建议

11.1 短期优化

优化项 预期收益 实现难度
添加结果缓存 相同图像检测速度提升10-100倍 低
支持批量上传 吞吐量提升3-5倍 中
增加WebSocket推送 实时性提升 中
GPU加速 (CUDA) 大图像处理速度提升5-10倍 高

11.2 长期规划

graph TD
    A[当前版本<br/>CPU单图检测] --> B[第二阶段<br/>批量处理]
    B --> C[第三阶段<br/>GPU加速]
    C --> D[第四阶段<br/>深度学习模型]
    
    B1[添加批量API] --> B
    B2[结果缓存机制] --> B
    
    C1[CUDA加速] --> C
    C2[TensorRT优化] --> C
    
    D1[YOLO检测] --> D
    D2[Transformer模型] --> D
    
    style A fill:#e3f2fd
    style B fill:#fff3e0
    style C fill:#f3e5f5
    style D fill:#e8f5e9

11.3 功能扩展

  1. 多格式支持: WebP, HEIC, AVIF
  2. 智能后处理: 自动矫正倾斜矩形
  3. 文字识别集成: OCR提取矩形内文本
  4. 表格识别: 识别表格结构
  5. API版本控制: v1, v2并存

11.4 算法改进方向

  • 自适应阈值: 使用Otsu算法自动确定最佳阈值
  • 多尺度检测: 金字塔算法检测不同尺度的矩形
  • 深度学习融合: 结合CNN进行更精确的矩形分类
  • 边缘优化: 使用Canny边缘检测辅助

12. 常见问题 FAQ

Q1: 为什么检测不到某些矩形？

可能原因:

  1. 二值化阈值不合适 → 调整 threshold 参数
  2. 矩形面积太小 → 降低 min_area 参数
  3. 图像对比度低 → 预处理增强对比度
  4. 轮廓不完整 → 检查原图质量

Q2: 检测速度慢怎么优化？

优化方案:

  1. 启用并行处理: enable_parallel=True
  2. 减少处理轮廓数: 降低 max_contours
  3. 提高最小面积: 增大 min_area
  4. 使用自适应模式: /detect/adaptive 接口

Q3: 如何处理倾斜的矩形？

当前版本使用 cv2.boundingRect 提取轴对齐矩形。如需检测旋转矩形，可使用 cv2.minAreaRect 替代。

Q4: 内存占用过高怎么办？

  1. 启用降采样（自动启用于大图像）
  2. 减少 max_contours 参数
  3. 及时清理临时文件
  4. 使用流式处理避免内存峰值

13. 参考资料

13.1 核心算法论文

  1. Largest Rectangle in Histogram:

    • 论文: “A Linear Time Algorithm for Computing the Largest Rectangle in a Histogram”
    • 时间复杂度: O(n)

  2. Contour Detection:

    • Suzuki, S. and Abe, K. (1985). “Topological Structural Analysis of Digitized Binary Images”

13.2 技术文档

13.3 相关项目

附录: 代码文件索引

文件 路径 行数 说明
API路由 app/api/routes/rect_detect.py 316 三个检测端点实现
数据模型 app/schemas/rect_detect.py 93 Pydantic模型定义
核心算法 app/utils/rect_detect.py 378 矩形检测算法实现
配置文件 app/core/config.py 40 环境配置管理
日志适配器 app/core/log_adapter.py - 结构化日志