代码见文章末尾

一、下载数据集

打开roboflow

 选择登录,没魔法上网是没法登录的,也没法下载数据集

我选择采用github的账号登录

输入crack,然后点搜索

然后选择分割模型,yolo11,点搜索

找一个图片多的,我找的如下链接

裂缝数据集

将下载好的数据集放到项目目录下,然后解压

二、下载分割模型

模型下载地址

 这里看情况下一个,从小到大的模型,我这里做演示,下了一个s的,实际工作中建议下个大的

三、预训练 

新建一个train_seg.py文件


from ultralytics import YOLO

if __name__ == '__main__':

    # 设置数据集路径
    dataset_config = "./datasets/Surface Crack Segmentation.v1i.yolov11/data.yaml"

    # 加载预训练模型(推荐使用分割模型检测裂缝轮廓)
    model = YOLO("yolo11s-seg.pt")  # 分割模型

    # 训练参数配置
    results = model.train(
        data=dataset_config,
        epochs=50,
        batch=16,  # 根据GPU显存调整
        imgsz=640,  # 输入图像尺寸
        lr0=0.01,  # 初始学习率
        lrf=0.01,  # 最终学习率
        device=0,  # 使用GPU(0表示第一块GPU)
        optimizer="auto",  # 自动选择优化器
        project='runs/train',
        name='exp',
        pretrained=True,  # 使用预训练权重
        augment=True,  # 启用数据增强
        mosaic=0.5,  # Mosaic增强的概率
        hsv_h=0.015,  # 色调增强强度
        hsv_s=0.7,  # 饱和度增强强度
        hsv_v=0.4,  # 明度增强强度
        degrees=10,  # 随机旋转角度范围
        translate=0.1,  # 平移增强
        scale=0.5,  # 缩放增强
        shear=5,  # 错切增强
        flipud=0.5,  # 上下翻转概率
        fliplr=0.5,  # 左右翻转概率
        copy_paste=0.2,  # 复制粘贴增强(对裂缝检测有效)
    )

    # 验证模型性能
    metrics = model.val()  # 默认使用验证集
    print(f"mAP@0.5: {metrics.box.map}")  # 输出mAP@0.5

修改data.yaml,修改train、val、test的路径。 

 运行train_seg.py文件,开始预训练

预训练它会下载一个yolo11n.pt的文件

开始训练了:

 训练结束

训练得到的模型

四、测试训练结果

新建一个seg.py文件

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("D:/work/python/yolo/runs/train/exp/weights/best.pt")
# Run inference on 'crack.jpg' with arguments
model.predict("crack.jpg", save=True, imgsz=640, conf=0.5, show=True)

在从test里面复制一张裂缝图片放到当前目录下

运行seg.py,得到结果

五、测试裂缝视频

准备一个裂缝的视频

修改seg.py文件

可以检测视频,窗口可以控制大小

import cv2
from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("D:/work/python/yolo/runs/train/exp/weights/best.pt")
# Run inference on 'crack.jpg' with arguments
# model.predict("crack.jpg", save=True, imgsz=640, conf=0.5, show=True)
results = model.predict("crack.mp4", imgsz=640, conf=0.5, show=False)  # 必须关闭默认显示

# 创建可调节窗口
cv2.namedWindow('Detection Window', cv2.WINDOW_NORMAL)
cv2.resizeWindow('Detection Window', 640, 360)  # 设置初始窗口尺寸

# 逐帧显示结果
for result in results:
    # 获取绘制检测框的帧
    rendered_frame = result.plot()

    # 显示处理后的帧
    cv2.imshow('Detection Window', rendered_frame)

    # 退出控制(按Q键)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

    # 释放资源
cv2.destroyAllWindows()

运行结果如下:

六、测试裂缝视频流

将04 yolo检测摄像头的视频流-CSDN博客里的例子复制一份为seg_rtst.py文件,修改一下模型地址,如下:

import cv2
from ultralytics import YOLO
import time


class RTSPYOLODetector:
    def __init__(self, rtsp_url, model_path="yolo11n.pt"):
        self.rtsp_url = rtsp_url
        self.model = YOLO(model_path)  #
        self.cap = None
        self.last_frame = None
        self.reconnect_interval = 3  # 重连等待时间(秒)
        self.frame_skip = 2  # 跳帧检测以降低延迟

    def start_detection(self):
        cv2.namedWindow("YOLO RTSP Detection", cv2.WINDOW_NORMAL)
        self._connect_stream()

        frame_count = 0
        while True:
            try:
                if not self.cap.isOpened():
                    self._reconnect()
                    continue

                ret, frame = self.cap.read()
                if not ret:
                    print("视频流中断,尝试重连...")
                    self._reconnect()
                    continue

                    # 跳帧处理:每3帧处理1次以降低延迟
                frame_count += 1
                if frame_count % self.frame_skip != 0:
                    continue

                    # YOLO检测
                results = self.model.predict(
                    frame,
                    conf=0.6,  # 置信度阈值
                    iou=0.45,  # IOU阈值
                    classes=[0, 2, 3, 5],  # 只检测人、车、摩托车、公交车 
                    verbose=False
                )

                # 绘制检测结果 
                annotated_frame = results[0].plot()

                # 自适应窗口缩放 
                h, w = annotated_frame.shape[:2]
                win_w = cv2.getWindowImageRect("YOLO RTSP Detection")[2]
                win_h = int(win_w * h / w)
                resized_frame = cv2.resize(annotated_frame, (win_w, win_h))

                cv2.imshow("YOLO RTSP Detection", resized_frame)

                # ESC退出 
                if cv2.waitKey(1) == 27:
                    break

            except Exception as e:
                print(f"发生错误: {str(e)}")
                self._reconnect()

        self.cap.release()
        cv2.destroyAllWindows()

    def _connect_stream(self):
        if self.cap:
            self.cap.release()
        # 优化RTSP参数减少延迟 
        self.cap = cv2.VideoCapture(self.rtsp_url)
        self.cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)  # 缓冲区大小
        self.cap.set(cv2.CAP_PROP_OPEN_TIMEOUT_MSEC, 3000)  # 超时时间 
        time.sleep(self.reconnect_interval)


if __name__ == "__main__":
    # RTSP示例地址(替换为实际摄像头地址)
    rtsp_url = "rtsp://192.168.12.100/stream1"

    # 初始化检测器
    detector = RTSPYOLODetector(
        rtsp_url,
        model_path="D:/work/python/yolo/runs/train/exp/weights/best.pt"
    )
    detector.start_detection()

运行结果:

七、检测裂缝图片的裂缝的最大宽度和最小宽度

该功能可以用于长期检测裂缝变化情况

新建crack_measure.py文件

import cv2
import numpy as np
from ultralytics import YOLO

# 加载训练好的分割模型
model = YOLO("D:/work/python/yolo/runs/train/exp/weights/best.pt")

# 进行预测并获取结果
results = model.predict("crack.jpg", save=True, imgsz=640, conf=0.5, show=True)

# 获取第一个结果(假设处理单张图像)
result = results[0]
orig_img = result.orig_img.copy()  # 原始图像的副本

# 确保图像为BGR格式(OpenCV要求)
if orig_img.shape[-1] == 3:
    orig_img = cv2.cvtColor(orig_img, cv2.COLOR_RGB2BGR)

# 检查是否存在分割掩码
if result.masks is not None:
    # 获取所有分割掩膜
    masks = result.masks.data.cpu().numpy()
    # 获取原始图像尺寸
    H, W = orig_img.shape[:2]

    for i, mask in enumerate(masks):
        # 调整掩膜到原始图像尺寸
        mask_resized = cv2.resize(mask, (W, H))
        # 二值化处理
        mask_binary = np.where(mask_resized > 0.5, 255, 0).astype(np.uint8)

        # 计算距离变换(获取单边距离)
        dist_transform = cv2.distanceTransform(mask_binary, cv2.DIST_L2, 3)


        # 计算最大宽度
        max_val = np.max(dist_transform)
        if max_val <= 0:
            continue  # 跳过无效掩膜

        # 获取最大宽度位置
        max_coords = np.where(dist_transform == max_val)
        y_max, x_max = max_coords[0][0], max_coords[1][0]
        max_width = max_val * 2  # 宽度为双边距离

        # 计算最小宽度(排除零值)
        non_zero_dists = dist_transform[dist_transform > 0]
        if len(non_zero_dists) == 0:
            continue

        min_val = np.min(non_zero_dists)
        min_coords = np.where(dist_transform == min_val)
        y_min, x_min = min_coords[0][0], min_coords[1][0]
        min_width = min_val * 2

        # 在图像上标注
        cv2.circle(orig_img, (x_max, y_max), 7, (0, 0, 255), -1)  # 红色标记最大值
        cv2.putText(orig_img, f"Max: {max_width:.1f}px",
                    (22, 22), cv2.FONT_HERSHEY_SIMPLEX,
                    0.6, (0, 0, 255), 2)

        cv2.circle(orig_img, (x_min, y_min), 7, (255, 0, 0), -1)  # 蓝色标记最小值
        cv2.putText(orig_img, f"Min: {min_width:.1f}px",
                    (22, 52), cv2.FONT_HERSHEY_SIMPLEX,
                    0.6, (255, 0, 0), 2)

# 保存并显示结果
cv2.imwrite('crack_with_measurements.jpg', orig_img)
cv2.imshow('Crack Measurements', orig_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

运行结果

代码点这里

更多推荐