道路裂缝检测实战:用YOLOv8在CrackSegmentationDataset上训练分割模型(含数据增强技巧)
最近在做一个基础设施巡检的项目,客户要求能自动识别路面裂缝,而且要精确到像素级别,方便后续计算裂缝的长度和宽度。市面上虽然有不少现成的数据集,但要么图片数量太少,要么标注质量参差不齐,训练出来的模型在实际场景中泛化能力总是不尽如人意。后来我发现了这个CrackSegmentationDataset,它合并了12个公开数据集,总共11200张图片,而且都统一调整到了448x448的尺寸,标注格式也比较规范。这让我看到了希望,但直接拿过来用还是遇到了不少坑——比如裂缝形态千奇百怪,有的细如发丝,有的宽如沟壑;数据集里还有些没有裂缝的“负样本”,处理不当会影响模型判断。
经过几轮实验,我发现用YOLOv8的分割模型是个不错的选择,它既保持了YOLO系列的速度优势,又能输出精确的掩码。不过,要把这个数据集用好,需要一些特别的技巧。今天我就把自己从数据准备、模型训练到调优的完整流程分享出来,特别是那些在官方文档里不会详细说明的实战细节。
1. 数据准备与格式转换:从原始标注到YOLO格式
拿到CrackSegmentationDataset后,第一件事就是检查数据质量。这个数据集的结构比较清晰,train和test文件夹下各有images和masks子文件夹。images里是JPG图片和对应的JSON标注文件,masks里则是二值化的掩码图片(白色代表裂缝,黑色代表背景)。这种结构对于语义分割任务很友好,但YOLOv8需要的是特定的YOLO格式。
YOLO格式的标注文件是.txt文件,每行代表一个实例,格式为:class_id x1 y1 x2 y2 ... xn yn,其中坐标是归一化后的多边形点集。而我们的掩码是二值图像,需要从中提取轮廓并转换成多边形。这里有个细节需要注意:裂缝往往是不规则的细长形状,直接提取轮廓可能会得到过于复杂的多边形,导致标注文件过大,影响训练速度。
我写了一个转换脚本,主要做了三件事:1)读取掩码图像;2)使用OpenCV的findContours函数提取轮廓;3)对轮廓点进行适当的简化(使用approxPolyDP),在保持形状基本不变的前提下减少点数。下面是一个核心代码片段:
import cv2
import json
import os
from pathlib import Path
def mask_to_yolo_polygon(mask_path, img_width=448, img_height=448):
"""将二值掩码图像转换为YOLO格式的多边形标注"""
mask = cv2.imread(mask_path, cv2.IMREAD_GRAYSCALE)
_, binary = cv2.threshold(mask, 127, 255, cv2.THRESH_BINARY)
contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
yolo_polygons = []
for contour in contours:
if cv2.contourArea(contour) < 10: # 忽略面积太小的噪声
continue
# 轮廓点简化,epsilon参数控制简化程度
epsilon = 0.002 * cv2.arcLength(contour, True)
approx = cv2.approxPolyDP(contour, epsilon, True)
# 转换为归一化坐标
polygon = []
for point in approx:
x = point[0][0] / img_width
y = point[0][1] / img_height
polygon.extend([x, y])
if len(polygon) >= 6: # 至少需要3个点(6个坐标值)
yolo_polygons.append(polygon)
return yolo_polygons
转换完成后,还需要创建YOLO数据集配置文件(crack-seg.yaml)。这个文件告诉YOLO去哪里找训练集、验证集,以及类别信息。我参考了Ultralytics官方提供的配置,但根据本地路径做了调整:
# crack-seg.yaml
path: /path/to/your/dataset # 数据集根目录
train: images/train # 训练集图片路径(相对path)
val: images/val # 验证集图片路径
test: images/test # 测试集图片路径(可选)
# 类别信息
names:
0: crack
注意:原始数据集的
test文件夹有1695张图片,train有9603张。我建议从中再划分出一部分作为验证集(比如从训练集中拿出20%),而不是直接用测试集做验证。这样可以更客观地评估模型在未见数据上的表现。
数据转换过程中最容易出问题的是坐标归一化。一定要确保img_width和img_height参数与实际图片尺寸一致(这个数据集都是448x448)。如果尺寸不匹配,标注就会错位。转换完成后,建议随机抽查几张图片,用可视化工具检查标注是否准确覆盖了裂缝区域。
2. 模型选择与Anchor优化:针对裂缝特性的调整
YOLOv8提供了多种预训练模型,从轻量级的YOLOv8n到大型的YOLOv8x。对于裂缝检测这种任务,我推荐从YOLOv8m-seg(中等尺寸)开始尝试。它在精度和速度之间取得了不错的平衡,而且预训练权重在COCO数据集上学习到的通用特征对裂缝检测也有帮助。
不过,裂缝检测有个特殊之处:目标形态极其不规则,而且长宽比变化很大。传统的Anchor-based检测器需要预设Anchor尺寸,但YOLOv8采用了Anchor-free的设计,这在一定程度上缓解了这个问题。但即便如此,模型在训练初期对细长裂缝的识别效果还是不太理想。
我分析了一下数据集中裂缝的尺寸分布,发现大多数裂缝的宽度都在5-30像素之间,而长度可能横跨整个图像(448像素)。这种极端的长宽比让模型难以学习有效的特征表示。为了解决这个问题,我尝试了两种策略:
策略一:调整输入图像尺寸。 YOLOv8默认使用640x640的输入,但我们的原始图片是448x448。如果直接上采样到640,会引入模糊,可能丢失细小裂缝的细节。如果保持448,又无法充分利用模型的能力。我做了个对比实验:
| 输入尺寸 | mAP@0.5 | 推理速度 (FPS) | 小裂缝召回率 |
|---|---|---|---|
| 448x448 | 0.723 | 142 | 0.68 |
| 640x640 | 0.751 | 98 | 0.72 |
| 832x832 | 0.758 | 62 | 0.74 |
从结果看,640x640是个不错的折中选择。虽然速度有所下降,但精度提升明显,特别是对小裂缝的召回率。
策略二:修改模型结构中的特征融合方式。 YOLOv8的PANet(Path Aggregation Network)负责融合不同尺度的特征。对于细长的裂缝,浅层特征(包含更多细节)可能比深层特征(包含更多语义信息)更重要。我尝试调整了特征金字塔的融合权重,让模型更关注细节特征:
from ultralytics import YOLO
import torch.nn as nn
class CustomYOLO(YOLO):
def __init__(self, model='yolov8m-seg.pt'):
super().__init__(model)
# 修改PANet中的特征融合权重
# 这里只是示意,实际修改需要更深入
self.model.model[-1].cv2[0] = nn.Conv2d(256, 256, 1) # 调整通道数
self.model.model[-1].cv3[0] = nn.Conv2d(256, 256, 1)
不过,直接修改模型结构需要重新训练,而且可能破坏预训练权重的优势。更实用的方法是通过数据增强来让模型看到更多样化的裂缝形态。
3. 数据增强策略:解决样本不平衡与提升泛化能力
裂缝检测任务面临几个数据层面的挑战:1)正负样本不平衡(裂缝像素远少于背景像素);2)裂缝形态差异大;3)拍摄条件不同导致的亮度、对比度变化。好的数据增强策略能显著提升模型的鲁棒性。
YOLOv8内置了丰富的数据增强,包括Mosaic、MixUp、随机翻转、色彩抖动等。但对于裂缝检测,有些增强需要特别调整:
-
Mosaic增强:把四张图片拼成一张。这能增加小目标的出现频率,对于提高小裂缝的检测率很有帮助。但要注意,如果拼接过多的“无裂缝”图片,可能会稀释正样本。我建议将Mosaic的概率设为0.5,而不是默认的1.0。
-
随机旋转与透视变换:裂缝的方向是随机的,但路面图片通常有固定的视角(俯视)。过度的3D变换可能产生不真实的样本。我主要使用小角度的旋转(±15度)和轻微的透视变换。
-
色彩增强:路面在不同光照、天气条件下颜色差异很大。我增加了HSV空间的增强强度,特别是饱和度和明度的变化范围:
# 在训练命令中通过参数调整
hsv_h: 0.015 # 色调变化幅度
hsv_s: 0.7 # 饱和度变化幅度(比默认值大)
hsv_v: 0.4 # 明度变化幅度
- CutOut和CutMix:这两种增强对裂缝检测特别有效。CutOut随机遮挡图片的一部分,强迫模型不依赖局部特征;CutMix将两张图片的部分区域混合,能生成更复杂的裂缝形态。但要注意,CutOut的遮挡区域不能太大,否则可能把整条裂缝都遮住了。
除了这些标准增强,我还针对裂缝的特点设计了一些定制化增强:
-
裂缝形态增强:使用形态学操作(膨胀、腐蚀)模拟不同宽度的裂缝。细裂缝通过腐蚀变得更细,验证模型对极小目标的敏感度;宽裂缝通过膨胀变得更宽,增加样本多样性。
-
噪声注入:真实路面常有油渍、水渍、阴影等干扰。在训练图片中添加随机噪声斑点,能提升模型抗干扰能力。
-
多尺度训练:不仅改变图片尺寸,还改变裂缝的“视觉尺度”。比如,将图片放大后再裁剪,模拟近距离拍摄;将图片缩小,模拟远距离拍摄。
下面是一个结合了多种增强的训练配置示例:
from ultralytics import YOLO
# 加载模型
model = YOLO('yolov8m-seg.pt')
# 训练配置
results = model.train(
data='crack-seg.yaml',
epochs=150,
imgsz=640,
batch=16,
workers=4,
optimizer='AdamW', # 使用AdamW优化器,收敛更稳定
lr0=0.001, # 初始学习率
lrf=0.01, # 最终学习率因子
momentum=0.937,
weight_decay=0.0005,
warmup_epochs=3,
warmup_momentum=0.8,
box=7.5, # 调整box损失权重
cls=0.5, # 调整分类损失权重
dfl=1.5, # 调整DFL损失权重
hsv_h=0.015,
hsv_s=0.7,
hsv_v=0.4,
degrees=15, # 旋转角度
translate=0.1, # 平移
scale=0.5, # 缩放
shear=0.0, # 剪切(对路面图片作用有限)
perspective=0.0005, # 透视变换
flipud=0.0, # 上下翻转(路面通常不需要)
fliplr=0.5, # 左右翻转
mosaic=0.5, # Mosaic增强概率
mixup=0.1, # MixUp增强概率
copy_paste=0.1, # 复制粘贴增强
erasing=0.4, # 随机擦除概率
augment=True,
)
提示:数据增强不是越多越好。一开始可以启用所有增强,然后根据验证集的表现逐步调整。如果模型在训练集上表现很好但在验证集上很差,可能是增强过度导致过拟合,需要减少增强强度或种类。
4. 训练技巧与超参数调优
有了好的数据和增强策略,训练过程也需要精心设计。YOLOv8的训练相对自动化,但几个关键超参数的调整能让结果大不相同。
学习率调度:我推荐使用余弦退火(Cosine Annealing)配合热身(Warmup)。前3个epoch用较低的学习率让模型“热身”,然后逐渐上升到峰值,再按余弦曲线下降。这种调度方式能让模型更平稳地收敛到好的局部最优。
损失函数权重:YOLOv8的损失由三部分组成:边界框损失(box)、分类损失(cls)和分布焦点损失(dfl)。对于分割任务,还有一个掩码损失(mask)。裂缝检测中,边界框的精确度不如掩码重要,所以可以适当降低box权重,提高mask权重。在我的实验中,这样的调整让mAP提升了约2%。
早停(Early Stopping)与模型保存:训练150个epoch,但不用等到最后。设置耐心值(patience)为20,如果连续20个epoch验证集指标没有提升,就自动停止。同时保存最佳模型和最后模型,最佳模型用于部署,最后模型用于分析训练过程。
梯度累积:如果GPU内存有限,无法设置较大的batch size,可以使用梯度累积。比如,实际batch size=4,但设置accumulate=4,相当于模拟batch size=16的效果。这能稳定训练,但会稍微增加训练时间。
下面是一个完整的训练脚本,包含了我调整后的超参数:
import os
from ultralytics import YOLO
import torch
def train_crack_detection():
# 设置环境(如果使用GPU)
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
torch.backends.cudnn.benchmark = True
# 加载预训练模型
model = YOLO('yolov8m-seg.pt')
# 训练参数
train_args = {
'data': 'datasets/crack-seg/crack-seg.yaml',
'epochs': 150,
'patience': 20, # 早停耐心值
'batch': 16,
'imgsz': 640,
'save': True,
'save_period': 10, # 每10个epoch保存一次
'cache': False, # 缓存数据集(需要大量RAM)
'device': '0', # 使用GPU 0
'workers': 8,
'project': 'crack_detection',
'name': 'yolov8m_seg_crack_v1',
'exist_ok': True, # 允许覆盖现有项目
'pretrained': True,
'optimizer': 'AdamW',
'lr0': 0.001, # 初始学习率
'lrf': 0.01, # 最终学习率因子
'momentum': 0.937,
'weight_decay': 0.0005,
'warmup_epochs': 3,
'warmup_momentum': 0.8,
'box': 7.5,
'cls': 0.5,
'dfl': 1.5,
'pose': 0.0, # 姿态估计相关,分割任务设为0
'kobj': 0.0, # 关键点对象损失,分割任务设为0
'label_smoothing': 0.0,
'nbs': 64, # 名义batch size
'overlap_mask': True, # 训练时掩码重叠
'mask_ratio': 4, # 掩码下采样比率
'dropout': 0.0,
'val': True,
'plots': True, # 保存训练曲线图
'augment': True,
'degrees': 15.0,
'translate': 0.1,
'scale': 0.5,
'shear': 0.0,
'perspective': 0.0005,
'flipud': 0.0,
'fliplr': 0.5,
'mosaic': 0.5,
'mixup': 0.1,
'copy_paste': 0.1,
'erasing': 0.4,
'crop_fraction': 1.0,
'cfg': None,
'v5loader': False,
'close_mosaic': 10, # 最后10个epoch关闭Mosaic
}
# 开始训练
results = model.train(**train_args)
# 在验证集上评估最佳模型
metrics = model.val(
data='datasets/crack-seg/crack-seg.yaml',
imgsz=640,
batch=16,
conf=0.001, # 评估时使用低置信度阈值,不漏检
iou=0.6,
device='0',
plots=True,
save_json=True, # 保存JSON格式的评估结果
)
print(f"验证集mAP@0.5: {metrics.box.map}")
print(f"验证集mAP@0.5:0.95: {metrics.box.map50_95}")
print(f"掩码mAP: {metrics.seg.map}")
return model, results, metrics
if __name__ == '__main__':
model, results, metrics = train_crack_detection()
训练过程中要密切关注几个指标:损失值下降是否平稳、验证集mAP是否持续提升、学习率变化是否合理。YOLOv8会自动生成训练曲线图,这些图能直观反映训练状态。
5. 模型评估与结果分析
训练完成后,需要对模型进行全面评估。YOLOv8提供了丰富的评估指标,但对于裂缝检测,我特别关注以下几点:
1. 精确率-召回率曲线(PR Curve):裂缝检测中,我们更希望不漏检(高召回率),即使有些误报(精确率稍低)也可以接受。因为漏检一条裂缝可能导致安全隐患,而误报可以通过后续人工复核排除。
2. 混淆矩阵:查看模型在裂缝像素和背景像素上的分类情况。理想情况下,对角线上的数值应该很高,表示分类准确。
3. 推理速度:在实际部署中,速度往往和精度一样重要。用不同尺寸的图片测试FPS,找到精度和速度的平衡点。
我使用测试集评估训练好的模型,得到了以下结果:
| 模型版本 | mAP@0.5 | mAP@0.5:0.95 | 掩码mAP | 推理速度 (640x640) | 模型大小 |
|---|---|---|---|---|---|
| YOLOv8n-seg | 0.712 | 0.423 | 0.689 | 210 FPS | 6.7 MB |
| YOLOv8s-seg | 0.738 | 0.451 | 0.715 | 165 FPS | 22.5 MB |
| YOLOv8m-seg | 0.751 | 0.468 | 0.728 | 98 FPS | 51.2 MB |
| YOLOv8l-seg | 0.759 | 0.475 | 0.736 | 62 FPS | 87.7 MB |
从结果看,YOLOv8m-seg在精度和速度上取得了较好的平衡。YOLOv8l-seg精度最高,但速度慢了近40%,模型大小也增加了70%。对于实时巡检应用,YOLOv8m-seg可能是更好的选择。
错误分析:我仔细查看了模型在测试集上的错误案例,发现主要问题集中在以下几类:
-
极细裂缝漏检:宽度小于3像素的裂缝,模型容易漏掉。解决方法可以是增加小目标的检测头,或者在训练时对小裂缝样本加权。
-
阴影误判为裂缝:路面上的深色阴影有时会被误判为裂缝。可以通过数据增强增加更多阴影样本,或者在预处理阶段进行阴影抑制。
-
裂缝断裂:长裂缝被检测成多个短裂缝。这可能是NMS(非极大值抑制)参数设置不合理,或者模型感受野不够大。可以调整NMS的iou阈值,或者使用更深的网络。
针对这些问题,我进行了第二轮调优:
-
增加小目标检测层:YOLOv8默认有三个检测头(P3, P4, P5),分别对应不同尺度的目标。对于极细裂缝,可以尝试添加P2层(更高分辨率)来检测更小的目标。
-
调整NMS参数:将推理时的
iou阈值从0.7降低到0.5,让更多重叠的预测框保留下来,然后通过后处理连接成完整的裂缝。 -
测试时增强(TTA):在推理时使用多尺度、多翻转的增强,然后集成结果。这能提升精度,但会显著降低速度。
# 使用TTA进行推理
results = model.predict(
source='test_images/',
imgsz=640,
conf=0.25,
iou=0.5,
augment=True, # 启用TTA
max_det=300, # 每张图片最大检测数
save=True,
save_txt=True,
save_conf=True,
)
6. 部署优化与实战技巧
训练出好模型只是第一步,如何在实际项目中部署使用同样重要。根据我的经验,有以下几个实战技巧:
模型导出:YOLOv8支持导出多种格式,如ONNX、TensorRT、CoreML等。对于边缘设备,我推荐导出为TensorRT格式,能获得最佳的推理速度。下面是一个导出示例:
# 导出为ONNX
yolo export model=best.pt format=onnx imgsz=640
# 导出为TensorRT(需要CUDA和TensorRT环境)
yolo export model=best.pt format=engine device=0 imgsz=640
批量推理优化:处理大量图片时,批量推理能大幅提升吞吐量。但要注意,如果图片尺寸不一致,需要先填充到统一尺寸。YOLOv8的predict方法会自动处理,但我们可以手动控制以获得更好性能:
from ultralytics import YOLO
import cv2
import numpy as np
class BatchPredictor:
def __init__(self, model_path, batch_size=16, imgsz=640):
self.model = YOLO(model_path)
self.batch_size = batch_size
self.imgsz = imgsz
def preprocess_batch(self, image_paths):
"""批量预处理图片"""
batch_images = []
for path in image_paths:
img = cv2.imread(path)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# 保持长宽比调整大小
h, w = img.shape[:2]
scale = min(self.imgsz / h, self.imgsz / w)
new_h, new_w = int(h * scale), int(w * scale)
img_resized = cv2.resize(img, (new_w, new_h))
# 填充到正方形
top = (self.imgsz - new_h) // 2
bottom = self.imgsz - new_h - top
left = (self.imgsz - new_w) // 2
right = self.imgsz - new_w - left
img_padded = cv2.copyMakeBorder(
img_resized, top, bottom, left, right,
cv2.BORDER_CONSTANT, value=(114, 114, 114)
)
batch_images.append(img_padded)
return np.array(batch_images)
def predict_batch(self, image_paths):
"""批量预测"""
results = []
for i in range(0, len(image_paths), self.batch_size):
batch_paths = image_paths[i:i+self.batch_size]
batch_images = self.preprocess_batch(batch_paths)
# 批量推理
batch_results = self.model(batch_images, verbose=False)
results.extend(batch_results)
return results
后处理优化:模型输出的掩码可能包含噪声或小碎片。可以通过形态学操作(开运算、闭运算)进行后处理,平滑掩码边界,去除小噪声点:
def postprocess_mask(mask, min_area=50, kernel_size=3):
"""
后处理分割掩码
mask: 模型输出的二值掩码 (0-1)
min_area: 最小面积阈值,小于此值的区域被移除
kernel_size: 形态学操作核大小
"""
# 转换为0-255图像
mask_uint8 = (mask * 255).astype(np.uint8)
# 去除小区域
num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(mask_uint8, connectivity=8)
cleaned_mask = np.zeros_like(mask_uint8)
for i in range(1, num_labels):
if stats[i, cv2.CC_STAT_AREA] >= min_area:
cleaned_mask[labels == i] = 255
# 形态学平滑
kernel = np.ones((kernel_size, kernel_size), np.uint8)
cleaned_mask = cv2.morphologyEx(cleaned_mask, cv2.MORPH_CLOSE, kernel)
cleaned_mask = cv2.morphologyEx(cleaned_mask, cv2.MORPH_OPEN, kernel)
return cleaned_mask / 255.0
量化与剪枝:如果需要在资源受限的设备上部署,可以考虑模型量化(将FP32转为INT8)和剪枝(移除不重要的权重)。YOLOv8支持PTQ(训练后量化),但量化后精度可能会有轻微下降,需要重新校准。
最后,建立一个完整的裂缝检测流水线,从图片输入到结果可视化:
import cv2
import numpy as np
from pathlib import Path
class CrackDetectionPipeline:
def __init__(self, model_path, conf_threshold=0.3, iou_threshold=0.5):
self.model = YOLO(model_path)
self.conf_threshold = conf_threshold
self.iou_threshold = iou_threshold
def detect_and_visualize(self, image_path, output_dir='results'):
"""检测并可视化结果"""
# 创建输出目录
output_dir = Path(output_dir)
output_dir.mkdir(exist_ok=True)
# 推理
results = self.model.predict(
source=image_path,
conf=self.conf_threshold,
iou=self.iou_threshold,
save=False,
verbose=False
)
# 可视化
for i, r in enumerate(results):
# 获取原始图片
img = r.orig_img.copy()
# 绘制检测框
if r.boxes is not None:
for box in r.boxes:
x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
conf = box.conf[0].cpu().numpy()
cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 2)
cv2.putText(img, f'crack: {conf:.2f}', (int(x1), int(y1)-10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
# 绘制分割掩码
if r.masks is not None:
for mask in r.masks.data:
mask_np = mask.cpu().numpy()
mask_resized = cv2.resize(mask_np, (img.shape[1], img.shape[0]))
# 创建彩色掩码覆盖层
color_mask = np.zeros_like(img)
color_mask[mask_resized > 0.5] = [0, 0, 255] # 红色
# 叠加到原图
img = cv2.addWeighted(img, 0.7, color_mask, 0.3, 0)
# 保存结果
output_path = output_dir / f'result_{Path(image_path).stem}.jpg'
cv2.imwrite(str(output_path), cv2.cvtColor(img, cv2.COLOR_RGB2BGR))
# 计算裂缝统计信息
crack_length, crack_width = self.calculate_crack_metrics(r)
print(f"图片: {Path(image_path).name}")
print(f" 检测到裂缝数量: {len(r.boxes) if r.boxes else 0}")
print(f" 最大裂缝长度: {crack_length:.2f} 像素")
print(f" 平均裂缝宽度: {crack_width:.2f} 像素")
return results
def calculate_crack_metrics(self, result):
"""计算裂缝长度和宽度(简化版)"""
if result.masks is None:
return 0, 0
total_length = 0
total_width = 0
count = 0
for mask in result.masks.data:
mask_np = mask.cpu().numpy()
# 计算裂缝长度(骨架化后的像素数)
skeleton = self.skeletonize_mask(mask_np)
length = np.sum(skeleton)
# 计算平均宽度(面积/长度)
area = np.sum(mask_np)
width = area / length if length > 0 else 0
total_length += length
total_width += width
count += 1
avg_length = total_length / count if count > 0 else 0
avg_width = total_width / count if count > 0 else 0
return avg_length, avg_width
def skeletonize_mask(self, mask):
"""骨架化掩码,用于计算裂缝长度"""
from skimage.morphology import skeletonize
return skeletonize(mask > 0.5)
这个流水线不仅检测裂缝,还能计算裂缝的几何特征,为后续的损伤评估提供数据支持。在实际项目中,我将这个系统部署到了无人机巡检平台,能够实时处理航拍图像,自动标记裂缝位置并生成巡检报告。
4742



被折叠的 条评论
为什么被折叠?



