PriKMet: Prior-Guided Pointer Meter Reading for Automated Substation Inspections

Abstract

Despite the rapid advancement of smart-grid technologies, automated pointer meter reading in power substations remains a persistent challenge due to complex electromagnetic interference and dynamic field conditions. Traditional computer vision methods, typically designed for ideal imaging environments, exhibit limited robustness against real-world perturbations such as illumination fluctuations, partial occlusions, and motion artifacts. To address this gap, we propose PriKMet (Prior-Guided Pointer Meter Reader), a novel meter reading algorithm that integrates deep learning with domain-specific priors through three key contributions: (1) a unified hierarchical framework for joint meter detection and keypoint localization, (2) an intelligent meter reading method that fuses the predefined inspection route information with perception results, and (3) an adaptive offset correction mechanism for UAV-based inspections. Extensive experiments on a comprehensive dataset of 3237 substation meter images demonstrate the superior performance of PriKMet, achieving state-of-the-art meter detection results of 99.4% AP50 and 85.5% for meter reading accuracy. The real-time processing capability of the method offers a practical solution for modernizing power infrastructure monitoring. This approach effectively reduces reliance on manual inspections in complex operational environments while enhancing the intelligence of power maintenance operations.

1. Introduction

In the digital era, the integration of digital meters in industrial systems has revolutionized the monitoring of equipment due to their superior signal transmission capabilities [1]. Digital meters offer enhanced data accuracy, real-time monitoring, and ease of integration into automated systems. However, in critical power transmission and transformation scenarios, especially those involving high magnetic interference and challenging environmental conditions, traditional pointer meters still play an essential role [2]. These meters are renowned for their resilience, providing stable readings in environments where digital meters often struggle due to electromagnetic noise, variable lighting, and other environmental disturbances. As smart grid technologies advance, the demand for automated condition monitoring solutions has grown significantly. However, despite progress in automated meter reading technologies, accurate and reliable pointer meter recognition in real-world industrial settings remains a formidable challenge.

In real-world applications, cameras used in power station inspections are required to cover large areas, and they frequently encounter dynamic environmental changes, which complicate meter recognition tasks. These challenges, such as lighting fluctuations, partial occlusions, motion artifacts, and varying angles, limit the effectiveness of many existing methods [3]. Furthermore, the performance of most existing algorithms significantly drops when these factors come into play, thus failing to meet the real-time and reliability requirements of industrial power systems. For instance, traditional computer vision approaches like the improved Hough circle transform and edge detection algorithms [4,5] struggle with noise interference in complex backgrounds, while template matching techniques remain sensitive to viewpoint variations. Wang et al. [6] developed a multi-scale template matching algorithm that leveraged prior knowledge of dial scales to improve positioning accuracy. Deep learning-based solutions, such as Mask R-CNN for pointer segmentation [7] or keypoint detection frameworks [8], have demonstrated remarkable capability in accurately localizing pointers. However, existing approaches exhibit performance degradation under low illumination or motion blur conditions and fail to utilize structured prior knowledge specific to power scenarios fully.

The integration of UAVs (Unmanned Aerial Vehicles) in smart-grid systems has revolutionized power equipment inspection methodologies. However, as illustrated in Figure 1a, UAV-based substation inspections introduce unique challenges for meter reading: while providing unprecedented operational flexibility, UAVs are susceptible to positional deviations during flight operations (shown in Figure 1b), potentially compromising reading accuracy. To address this limitation, recent research has explored the fusion of inspection systems with prior knowledge. Multi-camera collaborative calibration systems [9] improve meter positioning accuracy through 3D reconstruction, while SLAM-based UAV navigation frameworks [10] achieve centimeter-level hovering precision. Knowledge graph-driven detection algorithms [11] encode equipment topological relationships into networks, and advanced OCR techniques [12] enhance scale information extraction. However, these approaches often target isolated interference factors, demonstrating limited applicability in UAV-assisted power equipment inspection scenarios where complex, coupled environmental conditions are prevalent.

To address these challenges, we introduce PriKMet (Prior-Guided Pointer Meter Reader), a robust algorithm that synergizes deep learning with domain-specific prior knowledge to achieve accurate meter readings in challenging field environments. By leveraging predefined inspection routes and meter specifications, PriKMet mitigates environmental uncertainties. Additionally, our novel UAV pose correction mechanism compensates for operational deviations, ensuring reliable readings even during dynamic inspections. The main contributions of this paper include the following:

• Innovative Meter Dial Detection and Keypoint Localization: We present a novel approach to meter dial detection, coupled with keypoint localization, that enhances the generalization of the model. This technique is robust to environmental challenges such as poor lighting, occlusion, and blurring, which are often encountered in real-world power equipment inspections.
• Effective Use of Prior Information: Our algorithm makes use of predefined information, such as inspection routes and meter range data, to interpret meter readings accurately. This use of prior information reduces the uncertainty caused by environmental interference and enhances the accuracy of the readings.
• UAV Inspection Error Correction: We introduce a correction mechanism that compensates for any deviations in the UAV position during inspections. This adjustment ensures that the meter readings are accurate despite any operational inconsistencies, thus making the algorithm suitable for real-time, field-deployed systems.

Comprehensive evaluation on a 3237-image dataset collected from five operational substations demonstrates the superiority of PriKMet over state-of-the-art methods, achieving 99.4% AP50 in detection and 85.5% reading accuracy. The system maintains real-time performance (30.9 FPS on server-grade GPUs) while significantly outperforming existing approaches in challenging scenarios involving occlusion, glare, and motion blur.

2. PriKMet: Prior-Guided Pointer Meter Reader

In this section, we introduce the PriKMet algorithm. The overall pipeline of PriKMet is summarized in Figure 2. The process begins with meter detection, followed by pointer keypoint localization. Once the pointer is localized, the angle calculation and offset correction mechanisms are applied to derive the accurate meter reading. Finally, the system leverages prior knowledge of inspection routes and meter scales to refine the reading and ensure robustness under diverse environmental conditions.

2.1. PriKMet Network

As shown in Figure 3, the framework of the PriKMet model begins with the detection of the meter dial from an input image. Once the meter dial is localized, the algorithm proceeds to identify the keypoints of the pointer. The predictions of the model provide the information source for the subsequent reading calculation.

2.1.1. Detection Module

The detection module architecture, as shown in Figure 3, consists of two main parts: the backbone network and the head network. The backbone network is constructed using CSPNet (Cross-Stage Partial Network). The CSPNet Backbone extracts image features, and the P3, P4, and P5 feature layers are input into the Head network for further processing of the dial region. In the Head stage, image features are processed using concatenation (Concat), upsampling (Upsample), convolution (Conv), and C2f modules [13]. Inspired by [13], we adopt the Cross-Stage Partial feature-Fusion module (C2F), which enriches gradient pathways with minimal overhead, keeping the network lightweight yet markedly enhancing its fine-grained feature capture. The detailed structure of the Head section is shown in Figure 4. Concat, Split, Bottleneck, Conv2d, BatchNorm2d, and SiLU denote the standard PyTorch v1.11.0 operations for channel-wise concatenation, channel splitting, residual bottleneck block, 2D convolution, batch normalization, and SiLU activation, respectively. The C2f module is defined as follows:

$$\mathrm{C}2\mathrm{f}\left(x\right)=\mathrm{Concat}\left(\mathrm{Split}\left(x\right),\mathrm{Bottleneck}\left(\mathrm{Split}\right(x\left)\right)\right)$$

(1)

Here, the Split operation divides the input tensor x into two parts, and Concat represents the concatenation operation, while Bottleneck refers to a series of convolutional layers that form the bottleneck structure.

The Bottleneck module, as shown in Figure 4, includes one or more depthwise separable convolution layers, which reduce the number of parameters and computational complexity. Let the input tensor x have dimensions $H\times W\times C$, where H, W, and C represent the height, width, and channels, respectively. After the Split operation, each sub-tensor has dimensions $H\times W\times 0.5C$. The output dimensions of each layer in the Bottleneck remain unchanged, i.e., $H\times W\times 0.5C$.

$$\mathrm{Bottleneck}\left(x\right)=x+\left(\mathrm{Conv}\left(\left(\mathrm{Conv}\left(x\right)\right)\right)\right)$$

(2)

In the Conv module, depthwise separable convolutions replace traditional convolution operations. Depthwise separable convolution consists of two steps: depthwise convolution (Depthwise Convolution) and pointwise convolution (Pointwise Convolution). For a given input tensor x, depthwise convolution applies a convolutional kernel to each input channel independently, and pointwise convolution uses a $1\times 1$ kernel to combine the outputs. Specifically, the Conv operation is expressed as:

$$\mathrm{Conv}\left(x\right)=\mathrm{SiLU}\left(\mathrm{BatchNorm}2\mathrm{d}\left(\mathrm{Conv}2\mathrm{d}\left(x\right)\right)\right)$$

(3)

Compared to traditional convolution, depthwise separable convolution significantly reduces the number of parameters and computational cost while maintaining competitive expressive power.

To locate the dial position and category, the Head network uses the Anchor-Free mechanism of YOLO-v8 to handle classification and regression tasks. The detection module loss function includes classification loss $L_{cls}$, localization loss $L_{loc}$, and confidence loss $L_{conf}$. The overall loss function is:

$${\mathcal{L}}_{total}={\lambda }_{coord}·{\mathcal{L}}_{loc}+{\lambda }_{class}·{\mathcal{L}}_{cls}+{\mathcal{L}}_{conf}$$

(4)

where ${\lambda }_{coord}$ and ${\lambda }_{class}$ are hyperparameters used to adjust the weight of each loss term. For the localization loss, the model uses CIoU Loss, which considers the overlap between the predicted and ground truth boxes, along with the center distance and aspect ratio differences:

$${\mathcal{L}}_{loc}=1-{\displaystyle \frac{{\mathrm{IoU}}^2-d^2/c^2}{{\mathrm{IoU}}^2+\alpha ·d^2/c^2+{(1-\mathrm{IoU})}^2}}$$

(5)

Here, d represents the Euclidean distance between the center points of the predicted and true boxes, c is the diagonal length of the smallest enclosing rectangle around both boxes, and $\alpha$ is a balancing factor.

For the classification loss, the model uses the Varifocal Loss (VFL) function, which handles class imbalance via an asymmetrical weighted loss function:

$${\mathcal{L}}_{cls}=-q{(1-p)}^{\gamma }log\left(p\right)$$

(6)

where p is the predicted probability, q is the ground truth label, and $\gamma$ is the adjustment factor.

2.1.2. Pointer Keypoint Localization Module

Building on the meter dial region localized in the inspection image, the PriKMet network further performs keypoint localization for the pointer. Referring to the RTMPose method [14], PriKMet utilizes a feature encoder (CSPNeXt) network to extract features from the local dial image. The decoder then refines these features, integrating context from the entire image to improve keypoint prediction accuracy.

To better capture spatial relationships in the image, the pointer keypoint localization module uses a 7 × 7 convolution layer to generate feature maps that describe low-level structures. By applying multiple convolution layers, the model can learn more abstract and complex patterns.

The network introduces Graph Attention Units (GAUs) to enhance pose estimation accuracy. GAUs allow the model to dynamically adjust the attention of different parts based on the dependencies between nodes. Specifically, compute the initial attention score for each node pair i and j:

$$e_{ij}=a^T[W{h}_i\parallel W{h}_j]$$

(7)

where $h_i$ and $h_j$ are the feature vectors for nodes i and j, W is the weight matrix, and a is the attention parameter vector. ∥ represents vector concatenation.

Normalize the attention scores:

$${\alpha }_{ij}={\displaystyle \frac{exp\left(e_{ij}\right)}{{\sum }_{k\in {\mathcal{N}}_i}exp\left(e_{ik}\right)}}$$

(8)

where ${\mathcal{N}}_i$ denotes the set of neighbors of node i.

Update the node features based on the normalized attention scores:

$$h_i^{\prime }=\sigma \left(\sum _{j\in {\mathcal{N}}_i}{\alpha }_{ij}W{h}_j\right)$$

(9)

where $\sigma$ is typically the ReLU activation function.

The pointer keypoint localization module uses two loss functions to optimize the model: keypoint loss and confidence loss. Keypoint loss: Encourages the model to accurately predict keypoint locations:

$$L_{kp}={\displaystyle \frac{1}{N}}\sum _{i=1}^N{\parallel {\widehat{p}}_i-p_i\parallel }^2$$

(10)

where ${\widehat{p}}_i$ and $p_i$ are the predicted and actual keypoint coordinates and N is the total number of keypoints.

Confidence loss: Ensures the model assigns high confidence scores to correct keypoints:

$$L_{conf}={\displaystyle \frac{1}{N}}\sum _{i=1}^N(1-\sigma \left({\widehat{c}}_i\right)·\sigma \left(c_i\right))$$

(11)

where ${\widehat{c}}_i$ and $c_i$ represent the predicted and actual confidence scores and $\sigma$ is the sigmoid function.

2.2. Angle Calculation and Offset Correction

After locating the pointer, PriKMet calculates the pointer’s orientation angles ${\alpha }_{original}$ and $\theta$ relative to the dial scale, as shown in Figure 2.

Angle Calculation: The angle $\theta$ is calculated using the positions of the center, starting, and ending points relative to the center and the scale markings of the dial. The formula for angle calculation is:

$$\theta =\mathrm{atan}2(y_{\mathrm{end}}-y_{\mathrm{center}},x_{\mathrm{end}}-x_{\mathrm{center}})-\mathrm{atan}2(y_{\mathrm{start}}-y_{\mathrm{center}},x_{\mathrm{start}}-x_{\mathrm{center}})$$

(12)

where $(x_{\mathrm{start}},y_{\mathrm{start}})$ are coordinates of the starting points of the dial scale markings, $(x_{\mathrm{center}},y_{\mathrm{center}})$ are coordinates of the dial center points, and $(x_{\mathrm{end}},y_{\mathrm{end}})$ are coordinates of the ending points of the dial scale markings. Note that these coordinate parameters can be predetermined based on prior knowledge.

$${\alpha }_{original}=\mathrm{atan}2(y_{\mathrm{end}}-y_{\mathrm{center}},x_{\mathrm{end}}-x_{\mathrm{center}})-\mathrm{atan}2(y_{\mathrm{pointer}}-y_{\mathrm{center}},x_{\mathrm{pointer}}-x_{\mathrm{center}})$$

(13)

where $(x_{\mathrm{pointer}},y_{\mathrm{pointer}})$ are the prediction coordinates of the pointer tip, $(x_{\mathrm{center}},y_{\mathrm{center}})$ are coordinates of the dial center points, and $(x_{\mathrm{end}},y_{\mathrm{end}})$ are coordinates of the ending points of the dial scale markings.

Offset Correction: UAV inspections often introduce tilt or positional errors. PriKMet compensates for this by calculating the deflection angle $\beta$, which adjusts for the deviation in UAV position. As shown in Figure 5, we apply OpenCV for the segmentation of the dial of the meters and the fitting of and measurement of the deflection. The deflection angle is calculated as:

$$\beta =arccos\left({\displaystyle \frac{l}{d}}\right)$$

(14)

where l and d are the lengths of the major and minor axes of the dial ellipse of the meter.

The corrected pointer angle ${\alpha }_{\mathrm{corrected}}$ is then computed as:

$${\alpha }_{\mathrm{corrected}}=arctan\left({\displaystyle \frac{d}{l}}\times tan\left({\alpha }_{original}\right)\right)$$

(15)

where $\alpha$ is the initially calculated pointer angle.

Figure 5. Visualization of deflection analysis and correction in PriKMet: (a) Meter face prediction identifies the dial region; (b) Deflection fitting estimates the pointer’s angular displacement; (c) Deflection measurement calculates the precise tilt angle; (d) Angle correction adjusts the reading based on UAV positional offsets during inspections.

Figure 5. Visualization of deflection analysis and correction in PriKMet: (a) Meter face prediction identifies the dial region; (b) Deflection fitting estimates the pointer’s angular displacement; (c) Deflection measurement calculates the precise tilt angle; (d) Angle correction adjusts the reading based on UAV positional offsets during inspections.

Meter Reading Calculation: The final step is to calculate the meter reading X by combining the corrected pointer angle with the predefined meter scale. The meter reading is given by:

$$X=X_{\min }+(X_{\max }-X_{\min })\times {\displaystyle \frac{{\alpha }_{\mathrm{corrected}}}{\theta }}$$

(16)

where $X_{\min }$ and $X_{\max }$ are the minimum and maximum values of the meter’s scale, ${\alpha }_{\mathrm{corrected}}$ is the corrected pointer angle, and $\theta$ is the deflection angle that accounts for UAV positional deviations.

By using this prior information, PriKMet ensures real-time accuracy in diverse environmental conditions, reducing uncertainty and improving the overall robustness of the system.

3. Experiment Results

3.1. Benchmark

3.1.1. Training and Test Dataset

To verify the effectiveness of PriKMet proposed in this paper, we collected meter inspection data from substations and created training and test datasets to conduct thorough experimental validations of the algorithm models. Specifically, we conducted UAV-based inspections using five DJI Mavic 2 Pro UAVs (DJI, Shenzhen, China) equipped with their own onboard 20-megapixel Hasselblad camera (5472 × 3648 px). The drone was flown along eight pre-planned flight routes per site across five geographically distinct substations, yielding 3037 valid meter images that spanned a wide range of lighting, viewpoint, and occlusive conditions for model training. Based on the raw data, a total of 2199 partial meter images were extracted, including multiple types of meters such as oil level gauges, lightning arresters, SF6 meters, etc., shown in Figure 6b. To evaluate the performance of the model algorithm, we simultaneously collected 200 substation images as the test dataset, each containing one meter, totaling 200 partially annotated images, summarized in

Table 1. Dataset composition and statistical details. The training set includes 3037 UAV inspection images and 2199 partial meter images. The test set contains 200 UAV inspection images with corresponding partial meter images, covering diverse scenarios, lighting conditions, and meter types.

Training Set		Test Set
Description	Quantity	Description	Quantity
UAV Inspection Images	3037	UAV Inspection Images	200
Partial Meter Images	2199	Partial Meter Images	200

.

3.1.2. Evaluation Metric

To compare the performance of different models, we evaluated the final trained model on the validation set using standard detection metrics such as mAP, Recall, and Accuracy for meter box detection. We also compared the accuracy of key point detection for meter pointers. For assessing meter reading accuracy, we calculated the deviation between actual and predicted readings, deeming a reading correct if the error was within ±5%, and incorrect otherwise. Reading accuracy was determined by the proportion of meters that were correctly read. Additionally, model inference speed was assessed based on inference time and frame rate.

3.2. Implementation Details

During the model training and testing process, we employed the PyTorch framework for both training and experimental inference. The experiments were conducted using 2 NVIDIA GTX 3090 GPUs by default. For model training, we used Stochastic Gradient Descent (SGD) as the optimization algorithm, with the following hyperparameters: 100 epochs, a batch size of 16, and an initial learning rate of 0.01.

3.3. Main Results

3.3.1. Meter Detection Results

As shown in

Table 2. Performance comparison of mainstream detection models. Our PriKMet outperforms the state-of-the-art YOLO detectors and DETRs in both AP, Recall, and Precision.

Method	AP50	AP75	Recall	Precision
YOLOv5-L [16]	97.9	79.2	-	-
PPYOLOE-L [17]	98.0	79.6	97.6	99.1
YOLOv6-L [18]	98.3	79.8	97.7	99.1
YOLOv7-L [19]	97.7	80.2	97.5	98.2
YOLOv8-L [13]	98.2	80.9	97.5	98.3
DETR-DC5 [20]	93.6	76.3	95.2	92.1
Anchor-DETR-DC5 [21]	93.3	76.2	92.2	94.0
Conditional-DETR-DC5 [22]	91.4	75.2	88.5	92.3
Efficient-DETR [23]	93.2	72.1	89.1	94.3
SMCA-DETR [24]	86.5	75.3	89.2	85.2
Deformable-DETR [25]	85.3	76.2	84.1	87.2
DAB-Deformable-DETR [26]	86.1	76.3	82.2	88.1
DAB-Deformable-DETR++ [26]	87.1	78.8	86.3	88.4
DN-Deformable-DETR [27]	87.2	78.6	88.3	86.0
DN-Deformable-DETR++ [27]	87.4	79.5	86.9	90.2
DINO-Deformable-DETR [28]	89.4	80.3	87.2	89.9
PriKMet	99.4	81.1	98.2	99.8

, PriKMet achieves an AP50 of 99.4% in detection tasks, significantly outperforming models from the YOLO series and DETR-like models. In key point localization tasks (

Table 3. Comparison of keypoint detection performance. PriKMet achieves a keypoint AP50 of 90.7%, showing a 4.2% improvement over Mask R-CNN while maintaining high localization accuracy under occlusion and blur.

Method	${\mathrm{AP}}_{\mathbf{kp}}^{50}$	${\mathrm{AP}}_{\mathbf{kp}}^{75}$	Precision	Recall	Accuracy
Mask RCNN	86.5	70.8	91.6	92.1	82.3
PriKMet	90.7	72.8	94.2	95.8	85.5

), PriKMet AP⁵⁰_kp reaches 90.7%, which is a 4.2 percentage points improvement over Mask R-CNN [15]. The reading accuracy increases to 85.5% when incorporating prior information with a correction mechanism (Table 3), demonstrating the algorithm’s robustness in complex scenarios.

3.3.2. Analysis of Meter Reading Accuracy

Table 3 compares the performance of keypoint detection. By introducing Graph Attention Units (GAUs) to enhance spatial relationship modeling, PriKMet achieves an AP⁷⁵_kp of 72.8%, a 2.0% increase over baseline models. Various results show that the model can accurately locate pointer base and tip keypoints even under occlusion and blur conditions.

3.3.3. Inference Time Comparison

To evaluate the computational efficiency of PriKMet for real-time deployment in power inspection systems, we conducted comprehensive inference time comparisons with state-of-the-art methods under different hardware configurations. The experiments were designed to simulate both high-performance server and edge computing scenarios commonly found in power monitoring applications. Specifically, we employed NVIDIA GTX 3090 as server-grade hardware and used NVIDIA Jetson AGX Orin as edge-computing and NVIDIA Jetson TX2 as an embedded device.

Table 4. Inference time comparison across hardware platforms . PriKMet achieves real-time performance compared with state-of-the-art methods, meeting real-world inspection requirements.

Method	Tesla V100		AGX Orin		Jetson TX2
	Time (ms)	FPS	Time (ms)	FPS	Time (ms)	FPS
YOLOv8-L	38.2	26.2	68.5	14.6	152.3	6.6
Mask R-CNN	112.7	8.9	203.4	4.9	487.6	2.1
DETR-DC5	89.5	11.2	165.2	6.1	398.7	2.5
PP-YOLOE-L	35.8	27.9	62.3	16.1	138.6	7.2
PriKMet (Ours)	32.4	30.9	56.8	17.6	126.5	7.9

presents the detailed comparison with mainstream detection frameworks. PriKMet achieves 30.9 FPS on server-grade hardware and maintains 17.6 FPS on edge devices, meeting the minimum 15 FPS requirement for UAV real-time inspection systems. Compared to YOLOv8-L, our method shows 17% faster inference on AGX Orin with comparable accuracy, making it more suitable for field deployment. On embedded devices, PriKMet maintains <150 ms latency, which is critical for mobile inspection robots with limited computing resources.

3.4. Ablation Study

3.4.1. Ablation Study on Meter Detection and Result Correction

To validate the effectiveness of each module, three groups of experiments were designed: (1) removing the dial detection module (relying solely on keypoint localization); (2) basic model (including detection and keypoint modules); (3) full model (adding tilt correction mechanisms). As shown in

Table 5. Ablation experiments of PriKMet on key point localization and meter reading results.

Method		${\mathrm{AP}}_{\mathbf{kp}}^{50}$	${\mathrm{AP}}_{\mathbf{kp}}^{75}$	Accuracy
PriKMet	without detection	40.3	39.8	43.2
	basic model	90.7	72.8	83.7
	with correction	90.7	72.8	85.5

, without dial detection, the reading accuracy plummets to 43.2%, indicating the critical role of local dial positioning for subsequent tasks. The correction mechanism further improves accuracy by 1.8%, proving its efficacy in compensating for UAV pose offset errors.

3.4.2. Ablation Study on Different Backbones

To further evaluate the impact of different backbone networks on the performance of PriKMet, we conducted an ablation study comparing several popular backbone architectures. The backbones tested included CSPNet (used in the original PriKMet), ResNet-50, EfficientNet-B4, and Swin Transformer. The experiments were performed on the same dataset and training parameters to ensure a fair comparison. To fully evaluate the model, we used AP50 for detection tasks, ${\mathrm{AP}}_{\mathit{kp}}^{50}$ for keypoint localization, and reading accuracy (error within $\pm 5\%$). The performance metrics for each backbone are summarized in

Table 6. Performance comparison of PriKMet with different backbone networks. CSPNet outperforms ResNet, EfficientNet, and Swin Transformer in detection and reading accuracy, proving its architectural suitability.

Backbone	AP50 (Detection)	${\mathrm{AP}}_{\mathbf{kp}}^{50}$ (Keypoint)	Reading Accuracy (%)
CSPNet	99.4	90.7	85.5
ResNet-50	98.1	88.2	82.3
EfficientNet-B4	98.5	89.1	83.7
Swin Transformer	98.8	89.8	84.2

. CSPNet achieves the highest performance across all metrics, demonstrating its suitability for the PriKMet framework. Its design, which combines cross-stage partial connections, effectively balances computational efficiency and feature extraction capability. ResNet-50 shows competitive results but slightly lagged behind CSPNet, particularly in keypoint localization. This may be due to its less efficient feature fusion mechanism compared to CSPNet. EfficientNet-B4 performs well in detection tasks but exhibited a marginal drop in keypoint localization accuracy, likely due to its focus on computational efficiency over fine-grained feature extraction. Swin Transformer delivers strong results, especially in detection tasks, but its performance in keypoint localization was slightly inferior to CSPNet. The transformer global attention mechanism may not be as effective for precise keypoint localization as CSPNet hierarchical feature extraction.

The ablation study confirms that CSPNet is the optimal backbone for PriKMet, as it provides the best balance between detection accuracy, keypoint localization precision, and reading reliability. While other backbones like Swin Transformer and EfficientNet-B4 offer competitive performance, the CSPNet architecture is better suited for the specific challenges of meter reading in complex power scenarios. Future work could explore hybrid architectures or further optimizations of CSPNet to enhance performance.

3.5. Visualization

To validate the reliability of PriKMet in real-world substation inspections, we conducted a comprehensive visualization study under six representative challenging conditions: strong direct light, partial occlusion, geometric distortion, low-light conditions, blurred dial, and dust and stains. Figure 7 illustrates the method’s performance across all these scenarios. In the first case (Figure 7a), the model successfully locates the dial region under strong light reflections, maintaining precise pointer localization despite significant glare interference. The second scenario (Figure 7b) demonstrates the algorithm’s resilience to partial occlusions: the pointer tip and root keypoints are accurately localized, even when external objects partially obscure the pointer. The third example (Figure 7c) highlights the system’s capability to handle geometric distortions caused by UAV positional offsets. Here, the dial exhibits a light tilt due to UAV instability during inspection. PriKMet adaptively accounts for this spatial misalignment, preserving reliable keypoint detection and angle measurement without explicit post-correction. In the fourth example (Figure 7d), despite severely insufficient ambient lighting, PriKMet still accurately captures the dial contour and pointer position. In Figure 7e, the overall appearance of the dial and its scale marks are heavily blurred and nearly indistinguishable; nevertheless, our PriKMet still achieves precise pointer localization. For scenarios involving dials contaminated by stains, dust, or water droplets, we visualize the results in Figure 7f; the outcomes demonstrate that even when the dials are partially occluded by such contaminants, pointer localization remains unaffected. These visual results collectively validate the framework’s robustness against variable illumination, occlusion, blur, geometric distortion, surface contamination, and perspective distortions commonly encountered in power-substation environments.

3.6. Limitations

The current PriKMet framework is trained and evaluated on standard clockwise, circular analogue meters with uniform scales. In practice, however, industrial plants may deploy instruments with counter-clockwise dials, non-uniform tick marks, or elliptical faces. Counter-clockwise rotation demands a reversed reading logic, non-linear scales require precise OCR-based tick recognition, and elliptical geometries impose stricter accuracy on the pointer-tip position. Extending PriKMet to handle these variations remains an open direction for future work.

4. Conclusions

This paper proposes a prior-guided keypoint detection algorithm (PriKMet) for pointer meter reading in complex power scenarios, integrating deep learning with domain-specific priors to achieve unified solutions for dial detection, pointer localization, and reading calibration. The algorithm innovatively combines a robust detection framework, spatial relationship modeling, and dynamic error compensation mechanisms, demonstrating effectiveness and practicality under diverse environmental challenges. Extensive experiments on a comprehensive dataset of 3237 substation meter images demonstrate the superior performance of PriKMet, achieving state-of-the-art meter detection results of 99.4% AP50 and 85.5% for meter reading accuracy. Future work will focus on improving adaptability to extreme conditions, reducing reliance on predefined priors, and exploring multimodal collaborative perception to extend the algorithm’s generalization capabilities and deployment efficiency, thereby advancing intelligent industrial instrument inspection technologies.