当前位置: 首页 > news >正文

机器学习 YOLOv5手绘电路图识别 手绘电路图自动转换为仿真软件(如LT Spice)可用的原理图,避免人工重绘

以下是对《手绘电路图识别》论文的核心解读,结合技术方案、实验数据和创新点进行结构化总结:


研究目标

解决痛点:将手绘电路图自动转换为仿真软件(如LT Spice)可用的原理图,避免人工重绘。
关键挑战:元件识别 + 节点连接追踪,需兼容手绘风格差异、纸张/光照噪声。


技术方案

1. 元件检测(深度学习)
  • 模型:YOLOv5(轻量级实时目标检测)
  • 优势
    • 直接处理原始扫描图(无需形态学预处理,避免传统方法导致的图像腐蚀)。
    • 训练数据增强(旋转/翻转),388张图像训练。
  • 输出:元件类别 + 边界框(Bounding Box)。
2. 节点识别(传统图像处理)
  • 步骤
    1. 终端提取:基于边界框位置生成二值掩膜 + 自适应阈值分割(兼容光照变化)。
    2. 连线分离:移除元件区域,保留连接线。
    3. 节点定位
      • Hough变换检测线段 → 按斜率分类水平/垂直线(斜率45°~135°为垂直线)。
      • 求线段交点 → 筛选有效节点(交点需位于线段端点间)。
      • K-means聚类精确定位节点坐标(解决交点区域扩散问题)。
3. 原理图重建
  • 映射逻辑
    • 元件端子 → 最近邻节点(距离优先)。
    • 孤立节点 → 相互连接(需至少连接两个端子)。
  • 伪代码核心:遍历端子,计算与所有节点的欧氏距离,分配至最近节点。

实验结果

1. 元件检测性能(YOLOv5最优)
模型mAP@0.5 (%)推理时间 (秒)
YOLOv598.20.027
YOLOv398.10.052
SSD30092.50.051
  • 元件分类准确率:电压源/二极管≈100%,电感/电阻≈98%(形状相似导致轻微混淆)。
2. 整体系统性能
任务准确率耗时
元件检测99%-
节点识别92%-
全电路重建80%0.33s
  • 测试集:51张手绘图(5人绘制),41张成功重建。

创新点

  1. 端到端流程:首个结合目标检测(YOLOv5)与节点识别(Hough变换 + K-means)的实时方案。
  2. 抗干扰能力:自适应阈值 + 直接原始图像处理,避免传统细化(Thinning)操作的图像退化问题。
  3. 速度优势:0.33秒/图的近实时性能(传统方法需复杂预处理)。

局限与未来方向

  1. 当前限制
    • 仅支持单支路单元件(如并联电阻需分多支路绘制)。
    • 距离映射法对非规范绘图敏感(如交叉线)。
  2. 改进方向
    • 扩展元件类别(晶体管、逻辑门等)。
    • 用神经网络替代传统节点识别(实现全深度学习流程)。
    • 公开数据集促进研究(当前为自建154张图)。

横向对比

方法元件识别 (%)节点识别 (%)关键技术
本文 (YOLOv5)9992目标检测 + Hough变换
Edwards [9]8692形态学细化 + 句法分析
Dey [1]97.33-两阶段CNN分类(仅元件)

总结:本文在元件检测精度(99% vs 86%)和抗干扰性上显著优于传统方法,首次实现近实时的端到端电路重建。


附:核心流程图

手绘电路扫描图
YOLOv5元件检测
提取边界框 + 类别
自适应阈值分割
生成端子掩膜
分离连线 + Hough变换检测线段
计算交点 + K-means聚类节点
端子-节点距离映射
生成原理图

一段话总结:本文提出了一种基于目标检测(YOLOv5)和节点识别(霍夫变换) 的实时手绘电路图识别算法,可自动重建电路 schematic。该算法使用YOLOv5检测电路元件,实现了98.2%的mAP 0.5;通过霍夫变换和k-means聚类进行节点识别,结合距离匹配算法完成元件与节点的连接映射,最终电路重建准确率达80%,实时性能为0.33秒/张。实验基于自定义数据集(154张手绘电路图像,增强后388张用于训练),对比YOLOv3、SSD300后发现YOLOv5在速度(0.027秒)和综合性能上更优,且该方法是首个端到端实时从手绘电路生成可用于仿真的schematic的研究。


思维导图

## **研究背景**
- 手绘电路需数字化以用于仿真,但现有研究多聚焦元件分类,缺乏端到端重建方法
- 挑战:手绘风格差异、图像质量、噪声等
## **提出方法**
- 元件检测:对比YOLOv5、YOLOv3、SSD300,选YOLOv5(轻量、快速)
- 终端识别:结合边界框与自适应阈值二值化图像,k-means聚类求终端中心
- 节点识别:移除元件后用霍夫变换检测线,通过斜率分水平/垂直线,求交点为节点,k-means精确定位
- 电路schematic生成:基于距离匹配终端与节点,节点间补充连接
## **数据集**
- 自定义:154张手绘电路(含电压源、电阻等5类元件)
- 划分:103张训练,51张测试;数据增强后388张训练
## **实验结果**
- 性能对比:YOLOv5 mAP 0.5 98.1%,耗时0.027s,综合指标最优
- 电路重建:准确率80%,平均推理时间0.33s
- 与现有方法:首个用目标检测实现端到端重建,元件识别准确率99%优于Edwards等(86%)
## **局限性与未来工作**
- 局限:单分支仅含1元件、依赖距离匹配易出错、受手绘风格和图像条件影响
- 未来:扩展元件类型、优化匹配算法、提升抗干扰性

详细总结

1. 引言

  • 研究背景:手绘电路需手动转化为仿真软件可用的schematic,现有研究多聚焦文本数字化,电路数字化研究较少,因此自动转化具有重要价值。
  • 核心挑战:手绘风格差异、图像质量(纸张、墨水、噪声)等导致识别难度大。
  • 研究目标:提出实时算法,实现手绘电路到可仿真schematic的自动转化,涵盖元件检测、连接追踪。

2. 相关工作

  • 现有研究多聚焦元件分类,如:
    • Dey等(201)用两阶段CNN分类20类元件,准确率97.33%;
    • Roy等(2020)结合HOG特征与SMO分类器,准确率93.63%;
    • 少数涉及连接追踪,如Edwards等(2000)节点识别准确率92%,元件识别86%,但依赖图像 thinning 操作,易导致线条断裂。
  • 现有方法局限:缺乏端到端电路重建,未使用目标检测算法。

3. 提出方法

3.1 电路元件检测
  • 采用目标检测算法(YOLOv5、YOLOv3、SSD300),实现元件分类与定位。
  • 对比分析:
    • YOLOv5:基于CSPNet特征提取,PANet特征金字塔,速度快(0.027s);
    • YOLOv3:基于Darknet-53,106层卷积,速度较慢(0.052s);
    • SSD300:输入分辨率300×300,性能较差(mAP 0.5 92.5%)。
3.2 终端识别
  • 步骤:生成边界框二值化图像与自适应阈值二值化图像,求交集;用k-means聚类(质心数为元件数的2倍)确定终端中心。
  • 自适应阈值公式:根据区域高斯加权和减常数C确定阈值,应对光照变化。
3.3 节点识别
  • 步骤:移除元件区域(边界框内设为白像素);霍夫变换检测线条,按斜率(>45°且<135°为竖线,<45°或>135°为横线)分割;求线交点,通过轮廓检测和k-means确定节点坐标。
  • 交点约束:需位于线段内,避免误检。
3.4 电路schematic生成
  • 基于距离匹配:终端连接最近节点,节点间连接(少于2个终端的节点),完成电路重建。

4. 结果与评估

4.1 数据集
  • 自定义:154张手绘电路(5人绘制,含电压源、电阻、电容、电感、二极管);
  • 划分:103张训练,51张测试;数据增强(旋转、翻转)后388张训练。
4.2 训练方法
  • 框架:PyTorch;
  • 参数:YOLOv5/YOLOv3输入416×416,学习率0.001,动量0.937,批次16,epoch 500;SSD300输入300×300,学习率0.001,动量0.9,批次8,epoch 1500。
4.3 性能指标
模型mAP 0.5(%)平均准确率(%)平均召回率(%)平均F1-score(%)耗时(秒)
YOLOv598.199.1798.7598.400.0270
YOLOv398.198.6297.0197.620.0520
SSD30092.598.2095.9196.970.0515
  • 电路重建:51张测试图中41张成功,准确率80%;平均推理时间0.33秒。
4.4 与现有方法对比
方法元件识别准确率(%)节点识别准确率(%)特点
Edwards等(2000)8692依赖thinning操作,易断线
本文方法9992首个端到端目标检测方法,无需thinning

5. 局限性与结论

  • 局限性:单分支仅含1元件、距离匹配易出错、受手绘风格和图像条件影响。
  • 结论:该方法实现了手绘电路到schematic的实时重建,YOLOv5性能最优,为电路数字化提供新方案。

关键问题

  1. 问题:该研究中三种目标检测算法(YOLOv5、YOLOv3、SSD300)的核心差异的是什么?哪种更适合手绘电路元件检测?
    答案:核心差异体现在架构、速度和性能上。YOLOv5基于CSPNet和PANet,速度最快(0.027秒),综合指标最优(平均F1-score 98.40%);YOLOv3基于Darknet-53,速度较慢(0.052秒);SSD300输入分辨率低,性能最差(mAP 0.5 92.5%)。YOLOv5更适合,因其兼顾速度与精度,满足实时应用需求。

  2. 问题:该研究的节点识别流程是怎样的?如何确保节点识别的准确性?
    答案:流程为:①移除元件区域(边界框内设为白像素);②霍夫变换检测线条,按斜率分水平/竖线;③计算线交点,筛选位于线段内的交点;④通过轮廓检测和k-means聚类确定节点坐标。准确性保障措施包括:限制交点必须位于线段内、对交点进行膨胀处理减少间隙影响、用k-means精确定位节点。

  3. 问题:与现有研究相比,该方法的创新点和优势是什么?
    答案:创新点:①首个采用目标检测算法(而非仅分类)处理手绘电路识别;②提出端到端流程,实现从手绘图像到电路schematic的完整重建;③结合YOLOv5与霍夫变换,兼顾速度与精度。优势:①元件检测准确率更高(99% vs 现有最高86%);②无需依赖图像thinning操作,避免线条断裂问题;③实时性能优异(0.33秒/张),可用于实际应用。

以下是一个简化的Python代码框架,实现手绘电路图识别的核心流程。实际部署需要结合YOLOv5模型和OpenCV等库,并准备训练数据。

import cv2
import numpy as np
import torch
from yolov5 import YOLOv5  # 需安装yolov5库
from sklearn.cluster import KMeansclass CircuitRecognizer:def __init__(self, model_path='circuit_yolov5.pt'):# 加载预训练的YOLOv5模型self.model = YOLOv5(model_path)self.component_classes = ['resistor', 'capacitor', 'inductor', 'diode', 'voltage_source']def detect_components(self, img_path):"""使用YOLOv5检测电路元件"""results = self.model.predict(img_path)detections = []for result in results.pred[0]:x1, y1, x2, y2, conf, cls = result[:6]detections.append({'bbox': [x1, y1, x2, y2],'class': self.component_classes[int(cls)],'confidence': float(conf)})return detectionsdef adaptive_threshold(self, img):"""自适应阈值处理"""gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)return cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 11, 2)def extract_terminals(self, img, detections):"""提取元件端子位置"""# 步骤1:创建元件掩膜mask = np.zeros(img.shape[:2], dtype=np.uint8)for det in detections:x1, y1, x2, y2 = map(int, det['bbox'])cv2.rectangle(mask, (x1, y1), (x2, y2), 255, -1)# 步骤2:自适应阈值处理binary = self.adaptive_threshold(img)# 步骤3:分离连接线wires = cv2.bitwise_and(binary, cv2.bitwise_not(mask))return wiresdef detect_nodes(self, wires_img):"""使用Hough变换和聚类检测节点"""# 检测线段lines = cv2.HoughLinesP(wires_img, 1, np.pi/180, 50, minLineLength=50, maxLineGap=10)# 分离水平和垂直线horizontal, vertical = [], []for line in lines:x1, y1, x2, y2 = line[0]angle = np.abs(np.arctan2(y2-y1, x2-x1) * 180 / np.pi)if 45 < angle < 135:vertical.append([(x1, y1), (x2, y2)])else:horizontal.append([(x1, y1), (x2, y2)])# 计算交点intersections = []for h_line in horizontal:for v_line in vertical:# 计算交点 (使用向量方法)x, y = self.line_intersection(h_line, v_line)if x is not None:intersections.append([x, y])# K-means聚类精确定位节点if intersections:kmeans = KMeans(n_clusters=min(10, len(intersections)))kmeans.fit(intersections)return kmeans.cluster_centers_return []def line_intersection(self, line1, line2):"""计算两线段交点"""# 向量计算方法 (实现公式5)# ... (此处省略具体实现)return x, ydef generate_schematic(self, detections, nodes):"""生成电路原理图(简化版)"""# 步骤1:提取元件端子坐标terminals = []for det in detections:x1, y1, x2, y2 = det['bbox']# 假设端子位于边界框左右中点terminals.append(((x1, (y1+y2)/2), det['class'] + '_1'))terminals.append(((x2, (y1+y2)/2), det['class'] + '_2'))# 步骤2:端子-节点映射(最近邻)connections = {}for terminal_pos, terminal_id in terminals:min_dist = float('inf')closest_node = Nonefor node in nodes:dist = np.linalg.norm(np.array(terminal_pos) - np.array(node))if dist < min_dist:min_dist = distclosest_node = tuple(node)if closest_node not in connections:connections[closest_node] = []connections[closest_node].append(terminal_id)# 步骤3:构建网络表netlist = {}for node, terms in connections.items():if len(terms) >= 2:  # 有效节点需连接至少两个端子net_id = f"net{len(netlist)+1}"netlist[net_id] = termsreturn netlistdef process_circuit(self, img_path):"""端到端处理流程"""# 1. 元件检测img = cv2.imread(img_path)detections = self.detect_components(img_path)# 2. 节点识别wires_img = self.extract_terminals(img, detections)nodes = self.detect_nodes(wires_img)# 3. 生成原理图schematic = self.generate_schematic(detections, nodes)return {'detections': detections,'nodes': nodes,'schematic': schematic}# 使用示例
if __name__ == "__main__":recognizer = CircuitRecognizer()result = recognizer.process_circuit("hand_drawn_circuit.jpg")print("检测到的元件:")for det in result['detections']:print(f"- {det['class']} (置信度: {det['confidence']:.2f})")print("\n检测到的节点:", result['nodes'])print("\n生成的网络表:")for net, components in result['schematic'].items():print(f"{net}: {', '.join(components)}")

关键依赖库安装:

pip install opencv-python numpy torch scikit-learn
git clone https://github.com/ultralytics/yolov5  # 下载YOLOv5
pip install -r yolov5/requirements.txt

实现说明:

  1. 元件检测

    • 使用YOLOv5模型(需预先训练)
    • 输出元件类别和边界框
  2. 节点识别流程

    原始图像
    自适应阈值处理
    生成元件掩膜
    提取连接线
    Hough变换检测线段
    分类水平/垂直线
    计算交点
    K-means聚类节点
  3. 原理图生成

    • 基于最近邻距离映射端子到节点
    • 构建网络表(Netlist)表示连接关系

训练YOLOv5模型:

  1. 准备数据集:

    • 收集手绘电路图(约150+张)
    • 使用LabelImg标注元件边界框
    • 数据增强(旋转、翻转等)
  2. 训练命令:

python yolov5/train.py --img 416 --batch 16 --epochs 500 \--data circuit.yaml --weights yolov5s.pt

优化建议:

  1. 端子定位改进

    def get_component_terminals(bbox, component_type):"""根据元件类型定位端子"""if component_type == 'resistor':# 电阻端子位于左右边界中点return [left_center, right_center]elif component_type == 'capacitor':# 电容端子位于上下边界中点return [top_center, bottom_center]# ...
    
  2. 节点识别增强

    • 添加曲线检测(使用概率Hough变换)
    • 引入线段连接性分析
    • 使用形态学操作填充小间隙
  3. 输出格式

    • 支持SPICE网表导出
    • 生成可视化原理图(使用Schematics库)

此代码提供了核心框架,实际部署需根据具体电路特性调整参数和处理逻辑。

或者

以下是手绘电路图识别算法的完整Python实现。这个代码结合了YOLOv5进行元件检测和传统计算机视觉方法进行终端、节点识别,实现了从手绘电路图像到可仿真电路原理图的转换。

import cv2
import numpy as np
import torch
from PIL import Image
from yolov5.models.common import DetectMultiBackend
from yolov5.utils.general import non_max_suppression, scale_boxes
from yolov5.utils.torch_utils import select_device
import matplotlib.pyplot as plt
from sklearn.cluster import KMeansclass CircuitRecognizer:def __init__(self, weights_path='yolov5s.pt', device='', conf_thres=0.5, iou_thres=0.45):# 初始化YOLOv5模型用于元件检测self.device = select_device(device)self.model = DetectMultiBackend(weights_path, device=self.device, dnn=False, data=None)self.stride, self.names, self.pt = self.model.stride, self.model.names, self.model.ptself.conf_thres = conf_thresself.iou_thres = iou_thresdef detect_components(self, img_path):"""检测电路元件"""# 加载图像img = cv2.imread(img_path)img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)im = Image.fromarray(img)# 预处理图像im = self.model.preprocess(im)im = im.to(self.device)im = im.half() if self.model.fp16 else im.float()  # uint8 to fp16/32im /= 255  # 0 - 255 to 0.0 - 1.0if len(im.shape) == 3:im = im[None]  # expand for batch dim# 模型推理pred = self.model(im)pred = non_max_suppression(pred, self.conf_thres, self.iou_thres, classes=None, agnostic=False)# 处理检测结果components = []im0 = img.copy()for i, det in enumerate(pred):  # per imageif len(det):# Rescale boxes from img_size to im0 sizedet[:, :4] = scale_boxes(im.shape[2:], det[:, :4], im0.shape).round()# 保存检测到的元件for *xyxy, conf, cls in reversed(det):x1, y1, x2, y2 = map(int, xyxy)components.append({'class': self.names[int(cls)],'confidence': float(conf),'bbox': (x1, y1, x2, y2)})return components, imgdef identify_terminals(self, img, components):"""识别元件终端"""terminals = []for comp in components:x1, y1, x2, y2 = comp['bbox']# 提取元件区域comp_img = img[y1:y2, x1:x2]# 转换为灰度图并进行二值化gray = cv2.cvtColor(comp_img, cv2.COLOR_RGB2GRAY)_, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)# 计算轮廓contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)# 计算终端点(简化版,实际应用中可能需要更复杂的算法)if contours:# 找到最大的轮廓largest_contour = max(contours, key=lambda c: cv2.contourArea(c))# 计算轮廓的矩M = cv2.moments(largest_contour)# 计算中心点if M["m00"] != 0:cx = int(M["m10"] / M["m00"])cy = int(M["m01"] / M["m00"])# 将坐标转换回原图terminals.append({'component': comp['class'],'x': x1 + cx,'y': y1 + cy})return terminalsdef identify_nodes(self, img, components):"""识别电路图中的节点"""# 创建一个掩码,移除元件区域mask = np.ones(img.shape[:2], dtype=np.uint8) * 255for comp in components:x1, y1, x2, y2 = comp['bbox']mask[y1:y2, x1:x2] = 0# 对原图应用掩码masked_img = cv2.bitwise_and(img, img, mask=mask)# 转换为灰度图并进行边缘检测gray = cv2.cvtColor(masked_img, cv2.COLOR_RGB2GRAY)edges = cv2.Canny(gray, 50, 150, apertureSize=3)# 使用霍夫变换检测线条lines = cv2.HoughLinesP(edges, 1, np.pi/180, threshold=100, minLineLength=50, maxLineGap=10)# 分类线条为水平和垂直horizontal_lines = []vertical_lines = []if lines is not None:for line in lines:x1, y1, x2, y2 = line[0]if abs(y2 - y1) < abs(x2 - x1):  # 水平线条horizontal_lines.append((x1, y1, x2, y2))else:  # 垂直线条vertical_lines.append((x1, y1, x2, y2))# 计算线条交点intersections = []for h_line in horizontal_lines:for v_line in vertical_lines:x1h, y1h, x2h, y2h = h_linex1v, y1v, x2v, y2v = v_line# 计算交点x = x1vy = y1h# 检查交点是否在线段上if (x >= min(x1h, x2h) and x <= max(x1h, x2h) andy >= min(y1v, y2v) and y <= max(y1v, y2v)):intersections.append((x, y))# 使用K-means聚类精确定位节点if intersections:X = np.array(intersections)kmeans = KMeans(n_clusters=min(10, len(intersections)), random_state=0).fit(X)nodes = kmeans.cluster_centers_.astype(int)return [{'x': x, 'y': y} for x, y in nodes]else:return []def build_circuit_schematic(self, components, terminals, nodes):"""构建电路原理图"""# 简化版:基于距离匹配终端和节点connections = []for terminal in terminals:min_dist = float('inf')closest_node = Nonefor node in nodes:dist = np.sqrt((terminal['x'] - node['x'])**2 + (terminal['y'] - node['y'])**2)if dist < min_dist:min_dist = distclosest_node = nodeif closest_node and min_dist < 50:  # 设置距离阈值connections.append({'terminal': terminal,'node': closest_node})# 构建节点间的连接node_connections = []for i, node1 in enumerate(nodes):for j, node2 in enumerate(nodes):if i < j:# 检查是否有足够的终端连接到这两个节点node1_terminals = [conn['terminal'] for conn in connections if conn['node'] == node1]node2_terminals = [conn['terminal'] for conn in connections if conn['node'] == node2]if len(node1_terminals) >= 1 and len(node2_terminals) >= 1:node_connections.append({'node1': node1,'node2': node2})return {'components': components,'terminals': terminals,'nodes': nodes,'connections': connections,'node_connections': node_connections}def visualize_results(self, img, schematic):"""可视化识别结果"""result = img.copy()# 绘制元件边界框for comp in schematic['components']:x1, y1, x2, y2 = comp['bbox']cv2.rectangle(result, (x1, y1), (x2, y2), (0, 255, 0), 2)cv2.putText(result, f"{comp['class']}: {comp['confidence']:.2f}", (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)# 绘制终端点for term in schematic['terminals']:cv2.circle(result, (term['x'], term['y']), 5, (0, 0, 255), -1)# 绘制节点for node in schematic['nodes']:cv2.circle(result, (node['x'], node['y']), 8, (255, 0, 0), -1)# 绘制连接for conn in schematic['connections']:term = conn['terminal']node = conn['node']cv2.line(result, (term['x'], term['y']), (node['x'], node['y']), (255, 255, 0), 2)# 绘制节点间连接for conn in schematic['node_connections']:node1 = conn['node1']node2 = conn['node2']cv2.line(result, (node1['x'], node1['y']), (node2['x'], node2['y']), (255, 0, 255), 2)return result# 使用示例
def main():# 初始化识别器recognizer = CircuitRecognizer(weights_path='path/to/your/yolov5_model.pt')# 检测元件components, img = recognizer.detect_components('hand_drawn_circuit.jpg')# 识别终端terminals = recognizer.identify_terminals(img, components)# 识别节点nodes = recognizer.identify_nodes(img, components)# 构建电路原理图schematic = recognizer.build_circuit_schematic(components, terminals, nodes)# 可视化结果result = recognizer.visualize_results(img, schematic)# 显示结果plt.figure(figsize=(10, 10))plt.imshow(result)plt.axis('off')plt.show()# 保存结果cv2.imwrite('recognized_circuit.jpg', cv2.cvtColor(result, cv2.COLOR_RGB2BGR))if __name__ == "__main__":main()

这个代码实现了论文中描述的手绘电路图识别算法的主要功能:

  1. 元件检测:使用预训练的YOLOv5模型识别电路图中的各种元件
  2. 终端识别:定位每个元件的连接端点
  3. 节点识别:通过霍夫变换检测连接线并识别连接节点
  4. 电路原理图构建:基于距离匹配算法建立元件、终端和节点之间的连接关系
  5. 结果可视化:在原图上绘制识别结果,包括元件边界框、终端点、节点和连接线

使用前需要准备好训练好的YOLOv5模型权重文件,并确保安装了必要的依赖库。代码中的参数(如距离阈值、霍夫变换参数等)可能需要根据实际应用场景进行调整。

http://www.dtcms.com/a/272323.html

相关文章:

  • Spring MVC 1
  • C++中的list的学习
  • Go语言教程-变量、常量、命名规则
  • 亚矩阵云手机破解Maio广告平台多账号风控:从“生存焦虑”到“规模化增长”的终极方案
  • 电路研究9.4——合宙Air780EP的LuatOS、CSDK跟标准AT
  • 基于开源AI大模型AI智能名片S2B2C商城小程序源码的私域流量新生态构建
  • 独立服务器选择Rocky Linux还是CentOS
  • 【数据结构】顺序表(sequential list)
  • 学习中断配置的一天(第五天)
  • 安装nginx+php环境
  • OpenCV探索之旅:多尺度视觉与形状的灵魂--图像金字塔与轮廓分析
  • 无人机识别比赛记录与分析
  • Java---IDEA
  • 【论文阅读】Decoupled Knowledge Distillation
  • 【大模型推理论文阅读】 Thinking Tokens are Information Peaks in LLM Reasoning
  • iOS 抓包详细教程:从零搭建、操作到实战调试的全流程指南
  • 图像亮度调整的简单实现
  • Flutter多线程机制深度解析
  • 【Docker基础】Docker容器与网络关联命令使用指南:深入理解容器网络连接
  • 力扣61.旋转链表
  • Windows下VScode配置FFmpeg开发环境保姆级教程
  • 面试150 LRU缓存
  • LeetCode - 1668. 最大重复子字符串
  • 原创:多面体编译,polybench-c-4.2批量测试脚本
  • php中array($this, ‘loadClass‘)表示啥意思?
  • 阿里云-跨账号同步OSS Bucket
  • 【Note】Linux Kernel 之 内核架构、源码文件、API/ABI 、FHS
  • Linux 内核日志中常见错误
  • idea安装maven 拉取依赖失败的解决办法
  • 网络基本概念