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

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

news 2025/7/11 7:08:06

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

研究目标

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

技术方案

1. 元件检测（深度学习）

模型：YOLOv5（轻量级实时目标检测）
优势：
- 直接处理原始扫描图（无需形态学预处理，避免传统方法导致的图像腐蚀）。
- 训练数据增强（旋转/翻转），388张图像训练。
输出：元件类别 + 边界框（Bounding Box）。

2. 节点识别（传统图像处理）

步骤：
1. 终端提取：基于边界框位置生成二值掩膜 + 自适应阈值分割（兼容光照变化）。
2. 连线分离：移除元件区域，保留连接线。
3. 节点定位：
  - Hough变换检测线段 → 按斜率分类水平/垂直线（斜率45°~135°为垂直线）。
  - 求线段交点 → 筛选有效节点（交点需位于线段端点间）。
  - K-means聚类精确定位节点坐标（解决交点区域扩散问题）。

3. 原理图重建

映射逻辑：
- 元件端子 → 最近邻节点（距离优先）。
- 孤立节点 → 相互连接（需至少连接两个端子）。
伪代码核心：遍历端子，计算与所有节点的欧氏距离，分配至最近节点。

实验结果

1. 元件检测性能（YOLOv5最优）

模型	mAP@0.5 (%)	推理时间 (秒)
YOLOv5	98.2	0.027
YOLOv3	98.1	0.052
SSD300	92.5	0.051

元件分类准确率：电压源/二极管≈100%，电感/电阻≈98%（形状相似导致轻微混淆）。

2. 整体系统性能

任务	准确率	耗时
元件检测	99%	-
节点识别	92%	-
全电路重建	80%	0.33s

测试集：51张手绘图（5人绘制），41张成功重建。

创新点

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

局限与未来方向

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

横向对比

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

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

附：核心流程图

一段话总结：本文提出了一种基于目标检测（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（%）	耗时（秒）
YOLOv5	98.1	99.17	98.75	98.40	0.0270
YOLOv3	98.1	98.62	97.01	97.62	0.0520
SSD300	92.5	98.20	95.91	96.97	0.0515

电路重建：51张测试图中41张成功，准确率80%；平均推理时间0.33秒。

4.4 与现有方法对比

方法	元件识别准确率（%）	节点识别准确率（%）	特点
Edwards等（2000）	86	92	依赖thinning操作，易断线
本文方法	99	92	首个端到端目标检测方法，无需thinning

5. 局限性与结论

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

关键问题：

问题：该研究中三种目标检测算法（YOLOv5、YOLOv3、SSD300）的核心差异的是什么？哪种更适合手绘电路元件检测？
答案：核心差异体现在架构、速度和性能上。YOLOv5基于CSPNet和PANet，速度最快（0.027秒），综合指标最优（平均F1-score 98.40%）；YOLOv3基于Darknet-53，速度较慢（0.052秒）；SSD300输入分辨率低，性能最差（mAP 0.5 92.5%）。YOLOv5更适合，因其兼顾速度与精度，满足实时应用需求。
问题：该研究的节点识别流程是怎样的？如何确保节点识别的准确性？
答案：流程为：①移除元件区域（边界框内设为白像素）；②霍夫变换检测线条，按斜率分水平/竖线；③计算线交点，筛选位于线段内的交点；④通过轮廓检测和k-means聚类确定节点坐标。准确性保障措施包括：限制交点必须位于线段内、对交点进行膨胀处理减少间隙影响、用k-means精确定位节点。
问题：与现有研究相比，该方法的创新点和优势是什么？
答案：创新点：①首个采用目标检测算法（而非仅分类）处理手绘电路识别；②提出端到端流程，实现从手绘图像到电路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

实现说明：

元件检测：
- 使用YOLOv5模型（需预先训练）
- 输出元件类别和边界框
节点识别流程：
原理图生成：
- 基于最近邻距离映射端子到节点
- 构建网络表（Netlist）表示连接关系

训练YOLOv5模型：

准备数据集：
- 收集手绘电路图（约150+张）
- 使用LabelImg标注元件边界框
- 数据增强（旋转、翻转等）
训练命令：

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

优化建议：

端子定位改进：

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]# ...

节点识别增强：
- 添加曲线检测（使用概率Hough变换）
- 引入线段连接性分析
- 使用形态学操作填充小间隙
输出格式：
- 支持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()