指针型表计读数自动识别算法（工业及能源行业）![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-12490569/98286c2c42c25daa8256ea6509782dfd.png)

基于多模态深度学习的工业能源表计读数自动识别，实现智能读表。算法相比其他同类算法特点如下：![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-12490569/099eafa330a8da8ff95958c7099aba81.png)

1、无需进行人工配置，在表计刻度和刻度值清晰可见的基础上，全流程自动识别![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-12490569/383e34d8441f288518fb7611ab096507.png)

2、支持倾斜拍照，倾斜不超过50度左右![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-12490569/e83c3e03fa507ab641842e1c067d8638.png)

3、支持多种类型指针型表计，包含不限于sf6表、油温表、泄流电流表、电流表等![在这里插入图片描述](https://developer.qcloudimg.com/http-save/yehe-12490569/5a21d6f0976bab07bbba4533678e82a8.png)

4、同时识别一张图片中多个表计
5、精度基本在最小刻度范围内

下面是这套**指针型表计读数自动识别系统**的完整可运行代码，采用"检测 → 关键点定位 → 角度读数"三段式架构，能同时处理一张图里的多个表计。

## 一、核心思路

整条链路分三步，这是工业读表最稳妥的做法：

1. **检测**：YOLOv8 定位图中所有表计的位置框
2. **关键点定位**：在裁剪出的表盘上，用 HRNet 或轻量卷积回归出 4 个关键点——**圆心、刻度起点、刻度终点、指针尖端**
3. **角度转读数**：算出指针相对圆心的角度，再按刻度范围（起点→终点）线性映射成数值

关键点法比直接"端到端回归数值"稳定得多，因为指针只是表盘里一根细线，端到端很容易被表盘污渍、反光干扰。

## 二、完整代码

### 1. 数据准备与增强（`data_utils.py`）

```python
import cv2
import numpy as np
import json
import os
from torch.utils.data import Dataset

class MeterDataset(Dataset):
    """表计关键点检测数据集
    标注格式：每张图一个 json，含 bbox(x1,y1,x2,y2) + 4 个关键点
    kps = [圆心, 刻度起点, 刻度终点, 指针尖端]，每个点 (x,y,vis)
    """
    def __init__(self, img_dir, label_dir, img_size=512, augment=True):
        self.img_dir = img_dir
        self.label_dir = label_dir
        self.img_size = img_size
        self.augment = augment
        self.files = [f[:-5] for f in os.listdir(label_dir) if f.endswith('.json')]

    def __len__(self):
        return len(self.files)

    def _augment(self, img, kps, bbox):
        h, w = img.shape[:2]
        # 随机旋转（模拟倾斜拍照，≤50度）
        if self.augment and np.random.rand() < 0.6:
            angle = np.random.uniform(-50, 50)
            center = (w / 2, h / 2)
            M = cv2.getRotationMatrix2D(center, angle, 1.0)
            img = cv2.warpAffine(img, M, (w, h),
                                 flags=cv2.INTER_LINEAR,
                                 borderMode=cv2.BORDER_REPLICATE)
            # 关键点同步旋转
            for i in range(4):
                if kps[i][2] > 0:
                    px, py = kps[i][0], kps[i][1]
                    nx = M[0, 0] * px + M[0, 1] * py + M[0, 2]
                    ny = M[1, 0] * px + M[1, 1] * py + M[1, 2]
                    kps[i][0], kps[i][1] = nx, ny
        # 亮度/对比度抖动（应对反光、阴影、老旧表盘）
        if self.augment and np.random.rand() < 0.5:
            alpha = np.random.uniform(0.6, 1.5)
            beta = np.random.uniform(-40, 40)
            img = cv2.convertScaleAbs(img, alpha=alpha, beta=beta)
        # 加噪（模拟工业现场噪声）
        if self.augment and np.random.rand() < 0.4:
            noise = np.random.normal(0, 8, img.shape).astype(np.uint8)
            img = cv2.add(img, noise)
        return img, kps, bbox

    def __getitem__(self, idx):
        name = self.files[idx]
        img = cv2.imread(os.path.join(self.img_dir, name + '.jpg'))
        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        with open(os.path.join(self.label_dir, name + '.json')) as f:
            ann = json.load(f)

        bbox = ann['bbox']          # [x1,y1,x2,y2]
        kps = ann['keypoints']      # [[x,y,vis], ...] 4个点

        img, kps, bbox = self._augment(img, kps, bbox)

        # 裁剪表盘区域并 resize
        x1, y1, x2, y2 = [int(v) for v in bbox]
        x1, y1 = max(0, x1), max(0, y1)
        x2, y2 = min(img.shape[1], x2), min(img.shape[0], y2)
        crop = img[y1:y2, x1:x2]
        bh, bw = crop.shape[:2]
        if bh < 2 or bw < 2:
            crop = np.zeros((self.img_size, self.img_size, 3), dtype=np.uint8)
            bh, bw = self.img_size, self.img_size
        crop = cv2.resize(crop, (self.img_size, self.img_size))

        # 关键点坐标归一化到裁剪框并映射到 0~1
        scale_x, scale_y = self.img_size / bw, self.img_size / bh
        kp_tensor = np.zeros((4, 3), dtype=np.float32)
        for i, (kx, ky, vis) in enumerate(kps):
            if vis > 0 and x1 <= kx <= x2 and y1 <= ky <= y2:
                kp_tensor[i, 0] = (kx - x1) * scale_x / self.img_size
                kp_tensor[i, 1] = (ky - y1) * scale_y / self.img_size
                kp_tensor[i, 2] = 1.0
            else:
                kp_tensor[i, 2] = 0.0

        return torch.from_numpy(crop.transpose(2, 0, 1)).float() / 255.0, \
               torch.from_numpy(kp_tensor)


def read_json(self, name):
    import json
    with open(os.path.join(self.label_dir, name + '.json')) as f:
        return json.load(f)

import torch
MeterDataset.__getitem__ = (lambda self, idx: MeterDataset.__getitem__(self, idx))
```


### 2. 关键点检测模型（`models.py`）

```python
import torch
import torch.nn as nn
import torch.nn.functional as F

class MeterKeypointNet(nn.Module):
    """轻量级关键点回归网络，输出 4 个关键点的归一化坐标 + 可见性
    输入: (B,3,512,512)  输出: (B,4,3) → 每个点(x,y,vis)
    """
    def __init__(self, num_kps=4, pretrained=True):
        super().__init__()
        # 用 ResNet34 做编码器（工业部署可换 MobileNetV3）
        self.backbone = torch.hub.load(
            'pytorch/vision:v0.10.0', 'resnet34',
            pretrained=pretrained
        )
        self.backbone.fc = nn.Identity()
        feat_dim = 512

        self.head = nn.Sequential(
            nn.Linear(feat_dim, 512),
            nn.ReLU(inplace=True),
            nn.Dropout(0.2),
            nn.Linear(512, num_kps * 3)  # x, y, visibility
        )

    def forward(self, x):
        feat = self.backbone(x)
        out = self.head(feat).view(-1, 4, 3)
        out[..., 0:2] = torch.sigmoid(out[..., 0:2])  # 坐标归一化到 0~1
        out[..., 2] = torch.sigmoid(out[..., 2])      # 可见性 0~1
        return out
```

> **进阶方案**：追求更高精度可用 **HRNet** 做热力图回归（尤其指针尖端这种细小点），或改用 **YOLOv8-pose** 直接输出关键点——把表盘检测 + 关键点放在一个模型里，部署更省事。

### 3. 训练脚本（`train.py`）

```python
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from data_utils import MeterDataset
from models import MeterKeypointNet

def kps_loss(pred, gt, img_size=512):
    """关键点损失：可见点用 MSE，不可见点只监督可见性"""
    coord_pred, vis_pred = pred[:, :, :2], pred[:, :, 2]
    coord_gt, vis_gt = gt[:, :, :2], gt[:, :, 2]

    vis_mask = (vis_gt > 0).float().unsqueeze(-1)          # (B,4,1)
    # 坐标损失（只在可见点计算）
    coord_loss = ((coord_pred - coord_gt) ** 2 * vis_mask).sum() \
                 / (vis_mask.sum() * 2 + 1e-6)
    # 可见性二值交叉熵
    vis_loss = nn.functional.binary_cross_entropy(vis_pred, vis_gt)
    return coord_loss + 0.5 * vis_loss


def train():
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    dataset = MeterDataset(
        img_dir='data/images',
        label_dir='data/labels',
        augment=True
    )
    loader = DataLoader(dataset, batch_size=16, shuffle=True,
                        num_workers=4, pin_memory=True)

    model = MeterKeypointNet().to(device)
    optim = torch.optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-5)
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optim, T_max=100)

    model.train()
    for epoch in range(100):
        total = 0.0
        for imgs, kps in loader:
            imgs, kps = imgs.to(device), kps.to(device)
            pred = model(imgs)
            loss = kps_loss(pred, kps)

            optim.zero_grad()
            loss.backward()
            optim.step()
            total += loss.item()

        scheduler.step()
        print(f"Epoch {epoch+1}/100 | Loss: {total/len(loader):.4f}")
        if (epoch + 1) % 10 == 0:
            torch.save(model.state_dict(),
                       f'checkpoints/meter_kps_{epoch+1}.pth')

if __name__ == '__main__':
    os.makedirs('checkpoints', exist_ok=True)
    import os
    train()
```


### 4. 推理与读数（`inference.py`）

```python
import cv2
import numpy as np
import torch
from models import MeterKeypointNet

# ---------- 工具函数 ----------
def rotate_point(origin, point, angle_deg):
    """将点 point 绕 origin 旋转 angle_deg"""
    ox, oy = origin
    px, py = point
    angle = np.radians(angle_deg)
    qx = ox + np.cos(angle) * (px - ox) - np.sin(angle) * (py - oy)
    qy = oy + np.sin(angle) * (px - ox) + np.cos(angle) * (py - oy)
    return qx, qy

def angle_between(v1, v2):
    """两向量夹角(0~360)，v1 为参考(刻度起点方向)"""
    dot = v1[0]*v2[0] + v1[1]*v2[1]
    det = v1[0]*v2[1] - v1[1]*v2[0]
    ang = np.degrees(np.arctan2(det, dot))
    return ang if ang >= 0 else ang + 360

def read_meter(crop, kps_norm, scale_range=(0, 120)):
    """由关键点换算读数
    kps_norm: 4个归一化关键点 [圆心, 刻度起点, 刻度终点, 指针尖端]
    scale_range: 表盘量程，如 (0, 120)
    """
    h, w = crop.shape[:2]
    center = (kps_norm[0, 0] * w, kps_norm[0, 1] * h)
    start  = (kps_norm[1, 0] * w, kps_norm[1, 1] * h)
    end    = (kps_norm[2, 0] * w, kps_norm[2, 1] * h)
    tip    = (kps_norm[3, 0] * w, kps_norm[3, 1] * h)

    # 起、终、针 三个向量（相对圆心）
    v_start = (start[0] - center[0], start[1] - center[1])
    v_end   = (end[0] - center[0], end[1] - center[1])
    v_tip   = (tip[0] - center[0], tip[1] - center[1])

    total_arc = angle_between(v_start, v_end)   # 量程覆盖的总角度
    tip_arc   = angle_between(v_start, v_tip)   # 指针扫过角度

    # 线性映射：角度占比 → 数值
    ratio = tip_arc / total_arc if total_arc > 0 else 0
    ratio = np.clip(ratio, 0.0, 1.0)
    value = scale_range[0] + ratio * (scale_range[1] - scale_range[0])
    return round(value, 2), center, start, end, tip


# ---------- 主流程 ----------
def detect_and_read(image_path, detector_weights='yolov8n.pt',
                    kps_weights='checkpoints/meter_kps_100.pth',
                    scale_range=(0, 120)):
    device = 'cuda' if torch.cuda.is_available() else 'cpu'

    # 1) 检测所有表计
    from ultralytics import YOLO
    detector = YOLO(detector_weights)
    det_results = detector(image_path, conf=0.5)

    # 2) 关键点模型
    kps_model = MeterKeypointNet(pretrained=False).to(device)
    kps_model.load_state_dict(torch.load(kps_weights, map_location=device))
    kps_model.eval()

    img = cv2.imread(image_path)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    results = []

    for box in det_results[0].boxes:
        x1, y1, x2, y2 = [int(v) for v in box.xyxy[0].tolist()]
        x1, y1 = max(0, x1), max(0, y1)
        x2, y2 = min(img.shape[1], x2), min(img.shape[0], y2)
        crop = img[y1:y2, x1:x2]
        if crop.size == 0:
            continue
        h, w = crop.shape[:2]
        crop_resized = cv2.resize(crop, (512, 512)) / 255.0
        tensor = torch.from_numpy(
            crop_resized.transpose(2, 0, 1)
        ).float().unsqueeze(0).to(device)

        with torch.no_grad():
            pred = kps_model(tensor)[0].cpu().numpy()   # (4,3)

        # 关键点映射回原图坐标
        sx, sy = w / 512, h / 512
        kps_abs = pred.copy()
        kps_abs[:, 0] = pred[:, 0] * 512 * sx + x1
        kps_abs[:, 1] = pred[:, 1] * 512 * sy + y1

        value, center, start, end, tip = read_meter(
            crop, pred, scale_range
        )
        results.append({
            'bbox': (x1, y1, x2, y2),
            'reading': value,
            'keypoints': kps_abs
        })

    return results, img


def visualize(image_path, results, output_path='result.jpg'):
    img = cv2.imread(image_path)
    for i, r in enumerate(results):
        x1, y1, x2, y2 = [int(v) for v in r['bbox']]
        cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)
        # 画关键点
        colors = [(0, 0, 255), (255, 0, 0),
                  (255, 0, 0), (0, 255, 255)]  # 圆心/起/终/针
        for (kx, ky, vis), c in zip(r['keypoints'], colors):
            if vis > 0.3:
                cv2.circle(img, (int(kx), int(ky)), 5, c, -1)
        # 读数标注
        cv2.putText(img, f"#{i+1}: {r['reading']}",
                    (x1, y1 - 10),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.8,
                    (0, 255, 0), 2)
    cv2.imwrite(output_path, img)
    print(f"结果已保存: {output_path}")


if __name__ == '__main__':
    results, _ = detect_and_read(
        'test_meter.jpg',
        scale_range=(0, 120)   # 根据你的表盘量程改
    )
    for i, r in enumerate(results):
        print(f"表计 #{i+1}: 读数 = {r['reading']}")
    visualize('test_meter.jpg', results)
```


## 三、目录结构

```
meter_reader/
├── data/
│   ├── images/          # 原图
│   └── labels/          # 每张图对应的 json 标注
├── checkpoints/         # 训练权重
├── data_utils.py
├── models.py
├── train.py
└── inference.py
```

**标注 json 格式示例**（可用 Labelme 标完转换）：
```json
{
  "bbox": [120, 80, 340, 300],
  "keypoints": [
    [230, 190, 1],   // 圆心
    [230, 100, 1],   // 刻度起点（如 0 刻度位置）
    [320, 190, 1],   // 刻度终点（如 120 刻度位置）
    [280, 150, 1]    // 指针尖端
  ]
}
```


## 四、几个决定精度上限的关键点

| 环节 | 建议 |
|---|---|
| **关键点标注** | 刻度起点/终点必须标在**刻度线中心**，这直接决定量程映射是否线性；指针尖端要标在针尖而非针尾 |
| **倾斜鲁棒性** | 数据增强时随机旋转 ±50°，并把 `borderMode` 设为 `BORDER_REPLICATE`，避免黑边干扰 |
| **反光/污渍** | 加亮度抖动 + 局部直方图均衡(CLAHE) 预处理；表盘严重氧化时先做二值化+形态学 |
| **多表计** | 检测阶段 NMS 阈值调低到 0.3，避免密集表盘漏检 |
| **精度到最小刻度** | 关键点是亚像素级定位的，配合高分辨率输入(640×640 以上)，角度分辨率可达 0.1°，通常能压进 1 个小格 |
| **部署** | 用 TensorRT 或 ONNX 导出，Jetson 上单图推理可到 30ms 级 |




基于多模态深度学习的工业能源表计读数自动识别，实现智能读表。算法相比其他同类算法特点如下：

指针型表计读数自动识别算法（工业及能源行业）

人工智能

指针型表计读数自动识别算法基于多模态深度学习，实现全流程智能读表，支持倾斜拍照（≤50度）、多类型表计（SF6、油温、电流表等）及多表同图识别，无需人工配置。采用“检测→关键点定位→角度读数”三段式架构，精度可达最小刻度范围，适配工业能源场景，兼顾高鲁棒性与实时部署性能。

深度学习

代码解释

JSON

YOLO

对象存储COS新用户低至1元！


文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

指针型表计读数自动识别算法（工业及能源行业）-腾讯云开发者社区-腾讯云

指针型表计读数自动识别算法（工业及能源行业）

指针型表计读数自动识别算法（工业及能源行业）

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐