#YOLO系列详解：从YOLOv1到YOLOv10的实时目标检测革命

def visualize_yolov1_grid(image, grid_size=7, center_threshold=5):
    """
    可视化YOLOv1的网格划分 + 中心点检测责任分配
    Args:
        image: 输入图像 (H, W, 3)
        grid_size: 网格数量
        center_threshold: 判定中心点在网格内的阈值
    Returns:
        带网格和标注的可视化图像
    """
    import cv2
    import numpy as np
    img_copy = image.copy()
    h, w = img_copy.shape[:2]
    cell_h, cell_w = h // grid_size, w // grid_size
    
    # 1. 画网格
    for i in range(1, grid_size):
        cv2.line(img_copy, (i*cell_w, 0), (i*cell_w, h), (255, 255, 255), 1)
        cv2.line(img_copy, (0, i*cell_h), (w, i*cell_h), (255, 255, 255), 1)
    
    # 2. 假设标注中心点 (示例数据)
    gt_centers = np.array([[180, 120], [320, 380], [400, 200]])
    for cx, cy in gt_centers:
        # 找到归属的网格
        grid_x = cx // cell_w
        grid_y = cy // cell_h
        # 画中心点和网格高亮
        cv2.circle(img_copy, (int(cx), int(cy)), 5, (0, 255, 0), -1)
        cv2.rectangle(
            img_copy, 
            (grid_x*cell_w, grid_y*cell_h), 
            ((grid_x+1)*cell_w-1, (grid_y+1)*cell_h-1), 
            (0, 255, 0), 2
        )
    return img_copy

import torch
import torch.nn as nn
import torch.nn.functional as F

def autopad(k: int | tuple, p: int | tuple | None = None, d: int = 1) -> int | tuple:
    """自动计算卷积的padding值，保证输出尺寸与输入一致（当stride=1时）"""
    if p is None:
        p = k // 2 if isinstance(k, int) else [x // 2 for x in k]
    return p

class Conv(nn.Module):
    """YOLOv8的标准卷积块：Conv2d + BatchNorm2d + SiLU激活函数"""
    default_act = nn.SiLU()  # 全局默认激活函数
    
    def __init__(self, c1: int, c2: int, k: int = 1, s: int = 1, p: int | tuple | None = None, g: int = 1, act: bool | nn.Module = True):
        """
        Args:
            c1: 输入通道数
            c2: 输出通道数
            k: 卷积核大小
            s: 步长
            p: padding（默认自动计算）
            g: 分组卷积的组数
            act: 激活函数（True=SiLU，False=无，nn.Module=自定义）
        """
        super().__init__()
        self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False)
        self.bn = nn.BatchNorm2d(c2)
        self.act = self.default_act if act is True else (act if isinstance(act, nn.Module) else nn.Identity())

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return self.act(self.bn(self.conv(x)))

class C2f(nn.Module):
    """YOLOv8的C2f模块：轻量化版的CSPNet模块，兼顾精度和速度"""
    def __init__(self, c1: int, c2: int, n: int = 1, shortcut: bool = False, g: int = 1, e: float = 0.5):
        """
        Args:
            c1: 输入通道数
            c2: 输出通道数
            n: Bottleneck的数量
            shortcut: 是否使用残差连接
            g: 分组卷积的组数
            e: 中间通道数的压缩比
        """
        super().__init__()
        self.c = int(c2 * e)  # 中间隐藏层的通道数
        # 第一个卷积：将输入通道拆分为两部分
        self.cv1 = Conv(c1, 2 * self.c, 1, 1)
        # 第二个卷积：将所有分支的特征融合
        self.cv2 = Conv((2 + n) * self.c, c2, 1)
        # n个Bottleneck模块
        self.m = nn.ModuleList(
            Bottleneck(self.c, self.c, shortcut, g, e=1.0) 
            for _ in range(n)
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # 第一步：cv1 + 按通道分割为两部分
        y1, y2 = self.cv1(x).chunk(2, dim=1)
        # 第二步：将y2输入到n个Bottleneck中，收集每一步的输出
        y = [y1, y2]
        for m in self.m:
            y.append(m(y[-1]))
        # 第三步：拼接所有输出 + cv2融合
        return self.cv2(torch.cat(y, dim=1))

class Bottleneck(nn.Module):
    """YOLOv8的标准瓶颈块：1×1降维 + 3×3卷积 + 1×1升维"""
    def __init__(self, c1: int, c2: int, shortcut: bool = False, g: int = 1, e: float = 0.5):
        super().__init__()
        self.c_ = int(c2 * e)
        self.cv1 = Conv(c1, self.c_, 1, 1)
        self.cv2 = Conv(self.c_, c2, 3, 1, g=g)
        self.add = shortcut and (c1 == c2)  # 只有输入输出通道数相同才能用残差

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))

from ultralytics import YOLO
import cv2

# 1. 加载预训练模型（nano版本最快，适合演示）
model = YOLO("yolov8n.pt")

# 2. 推理单张图片
results = model.predict(
    source="test_image.jpg",
    conf=0.5,  # 置信度阈值
    iou=0.45,  # NMS的IoU阈值
    save=True,  # 保存可视化结果
    save_txt=True  # 保存检测结果的txt文件
)

# 3. 访问推理结果
for result in results:
    print(f"检测到的目标数量: {len(result.boxes)}")
    for box in result.boxes:
        print(f"类别ID: {box.cls.item()}, 置信度: {box.conf.item():.2f}")
        print(f"边界框坐标（xyxy）: {box.xyxy.cpu().numpy().tolist()[0]}")