As the global demand for renewable energy continues to rise, solar energy has become one of the most promising sources of clean power. The rapid expansion of photovoltaic installations has created an urgent need for efficient monitoring and management systems. In this context, the detection and counting of solar panels from aerial imagery play a crucial role in asset management, maintenance planning, and energy output estimation. Traditional manual counting methods are labor-intensive and prone to errors. Remote sensing technology, especially unmanned aerial vehicles, provides high-resolution images that can be processed automatically. However, the large image size and relatively small targets in aerial photographs pose significant challenges for object detection algorithms.
In this thesis, I focus on the research of solar panel detection algorithms based on convolutional neural networks. My goal is to develop an effective method for locating and counting individual solar panels in industrial rooftop installations using high-resolution drone images. I build a dedicated dataset, compare various detection frameworks and feature extraction networks, and propose improvements that integrate sliding window processing and attention mechanisms. The experimental results demonstrate that my proposed method significantly enhances detection accuracy compared with baseline algorithms and traditional machine learning approaches.
Introduction and Background
The utilization of solar energy has attracted worldwide attention due to its environmental benefits and long-term economic viability. According to global energy transition scenarios, the installed capacity of photovoltaic systems is expected to grow enormously in the coming decades. Therefore, the management and supervision of solar panel arrays become essential for both utility companies and individual stakeholders. Accurate detection and counting of solar panels enable efficient asset inventory, project acquisition evaluation, and periodic inspection. Aerial images captured by drones provide a comprehensive view of rooftop installations, but the manual interpretation of these images is time-consuming and subjective.
Object detection technology has evolved significantly in recent years, particularly with the advent of deep learning. Convolutional neural networks have demonstrated remarkable capabilities in extracting high-level semantic features from images. Compared with traditional image processing methods, CNN-based detectors are more robust to variations in illumination, scale, and perspective. For solar panel detection, the characteristics of the target (regular shape, repetitive texture, and high density) make it suitable for deep learning approaches. Nevertheless, existing research on solar panel detection from aerial high-resolution images is still limited. Some studies focus on segmenting entire solar farms rather than locating individual panels. Others apply traditional machine vision techniques that require manual threshold adjustments and are sensitive to environmental conditions.
In this work, I aim to answer the following research questions. First, which detection framework is more suitable for high-resolution aerial solar panel images: a two-stage detector like Faster RCNN or a one-stage detector like SSD? Second, how does the choice of feature extraction network affect the performance of solar panel detection? Third, can sliding window processing and attention mechanisms further improve the detection accuracy? To answer these questions, I conduct a series of experiments and analyze the results in detail.
Convolutional Neural Network Fundamentals
A convolutional neural network is a type of deep neural network designed for processing structured grid data such as images. The key components of a CNN include convolutional layers, activation functions, pooling layers, and fully connected layers. The convolutional layer applies a set of learnable filters to the input image, producing feature maps that highlight various visual patterns. The activation function introduces nonlinearity, commonly implemented as the Rectified Linear Unit (ReLU):
\[
\text{ReLU}(x) = \max(0, x)
\]
The pooling layer reduces the spatial dimensions of feature maps while preserving important information. Two common pooling operations are max pooling and average pooling. For a given input patch, max pooling selects the maximum value, whereas average pooling computes the mean. The pooling operation can be expressed as:
\[
y_{i,j} = \max_{m,n \in \mathcal{R}} x_{i+m, j+n}
\]
or
\[
y_{i,j} = \frac{1}{|\mathcal{R}|} \sum_{m,n \in \mathcal{R}} x_{i+m, j+n}
\]
The training of a CNN involves two stages: forward propagation and backward propagation. During forward propagation, the input data is passed through the network layers to produce the output. The loss function measures the discrepancy between the predicted output and the ground truth labels. In backward propagation, the gradient of the loss with respect to each network parameter is computed using the chain rule, and the parameters are updated using gradient descent:
\[
w^{(l)}_{jk} = w^{(l)}_{jk} – \eta \frac{\partial L}{\partial w^{(l)}_{jk}}
\]
where \(\eta\) is the learning rate and \(L\) is the loss function.
Two fundamental properties of CNNs are local receptive fields and weight sharing. Local receptive fields mean that each neuron in a convolutional layer connects only to a small region of the previous layer, mimicking the local perception of biological vision. Weight sharing indicates that the same set of filters is applied across the entire input, drastically reducing the number of parameters. The receptive field size at layer \(k\) can be calculated recursively:
\[
l_k = l_{k-1} + \left( (f_k – 1) \times \prod_{i=1}^{k-1} s_i \right)
\]
where \(f_k\) is the kernel size and \(s_i\) is the stride of layer \(i\).
Object Detection Frameworks
Object detection involves locating and classifying objects within an image. Deep learning-based detectors can be categorized into two families: two-stage detectors and one-stage detectors. Two-stage detectors first generate a set of region proposals and then classify each proposal. One-stage detectors directly predict object locations and categories from feature maps without a separate proposal stage.
RCNN and Its Variants
The original RCNN (Regions with CNN features) algorithm extracts region proposals using selective search, then applies a CNN to each proposal to extract features, and finally classifies the features with a support vector machine. Although effective, RCNN is computationally expensive because each region proposal is processed independently. Fast RCNN improves the efficiency by sharing the convolutional computation across the whole image and using a ROI pooling layer to extract fixed-length feature vectors from the feature map for each proposal. The architecture of Fast RCNN is shown conceptually as follows:
\[
\text{ROI Pooling}: \text{feature map} \times \text{region proposal} \rightarrow \text{fixed-size feature vector}
\]
Faster RCNN further enhances the pipeline by replacing selective search with a Region Proposal Network (RPN). The RPN shares convolutional features with the detection network, enabling nearly cost-free region proposals. The entire network can be trained end-to-end. An anchor box at each spatial location is defined with different scales and aspect ratios. The RPN outputs objectness scores and bounding-box regression offsets. The loss function for RPN is:
\[
L(\{p_i\}, \{t_i\}) = \frac{1}{N_{cls}} \sum_i L_{cls}(p_i, p_i^*) + \lambda \frac{1}{N_{reg}} \sum_i p_i^* L_{reg}(t_i, t_i^*)
\]
where \(p_i\) is the predicted probability of anchor \(i\) being an object, \(p_i^*\) is the ground truth label, \(t_i\) is the bounding-box regression parameters, and \(t_i^*\) is the ground-truth regression target.
SSD and YOLO
Single Shot MultiBox Detector (SSD) is a one-stage detector that predicts bounding boxes and class scores from multiple feature maps of different resolutions. Each feature map cell is associated with a set of default boxes of various scales and aspect ratios. SSD eliminates the proposal generation step, resulting in high detection speed. The multi-scale feature maps allow SSD to handle objects of different sizes. However, for small objects, SSD is generally less accurate than Faster RCNN because the shallow feature maps contain limited semantic information.
You Only Look Once (YOLO) is another famous one-stage detector. YOLO divides the input image into a grid and each grid cell predicts a fixed number of bounding boxes and confidence scores. The original YOLO has difficulty detecting small objects because each grid cell is limited to a small number of predictions. Later versions of YOLO improve the accuracy and speed, but for dense small targets, two-stage detectors are often superior.
Feature Extraction Networks
The backbone network is a crucial component of any CNN-based detector. VGGNet is a classic architecture that uses small 3×3 convolutional filters and deepens the network to 16 or 19 layers. VGG16 has 13 convolutional layers and 3 fully connected layers. Although VGG is powerful, its fully connected layers introduce a large number of parameters, making the model heavy and slow.
Residual Network (ResNet) introduces skip connections to ease the training of very deep networks. The residual block can be formulated as:
\[
\mathbf{y} = \mathcal{F}(\mathbf{x}, \{W_i\}) + \mathbf{x}
\]
where \(\mathbf{x}\) is the input, \(\mathcal{F}\) represents the residual mapping to be learned, and \(\mathbf{y}\) is the output. This identity mapping allows gradients to flow directly through the network, mitigating the vanishing gradient problem. ResNet50 and ResNet101 are two common variants with 50 and 101 layers, respectively. In my solar panel detection experiments, I evaluate VGG16, ResNet50, and ResNet101 as backbone networks.
Dataset Construction and Preprocessing
Since there is no public dataset dedicated to solar panel detection from high-resolution aerial images, I construct my own dataset. The images are captured by an unmanned aerial vehicle in an industrial area in Guilin, China. They show rooftop photovoltaic arrays arranged in dense regular patterns. The dataset contains 150 high-resolution images with a uniform size of 4000×3000 pixels. The flying altitude ranges from 88 to 152 meters, and the camera is mostly oriented vertically downward.
The dataset is split into training, validation, and test sets. I use 120 images for training and validation, and 30 images for testing. The ratio of training to validation is approximately 6:2, resulting in 90 training images and 30 validation images. The remaining 30 images are used exclusively for testing.
I annotate every solar panel instance in each image using the LabelImg tool. The annotation files are stored in XML format, containing the image dimensions, object class names, and bounding box coordinates. Because solar panels are densely packed, some images contain more than 400 individual panels. Accurate annotation of such dense objects is challenging and time-consuming but essential for training a reliable detector.
To improve the robustness of the model and increase the diversity of training data, I apply several data augmentation techniques. Specifically, I perform random horizontal flipping and random contrast adjustment. The contrast factor is randomly chosen from the range [0.8, 1.25]. These operations simulate variations in lighting and viewing conditions, helping the network generalize better. The preprocessing steps are applied on-the-fly during training, not to the entire dataset in advance.
Solar Panel Detection with Faster RCNN and SSD
In my first set of experiments, I compare the performance of Faster RCNN and SSD for solar panel detection. Both networks are initialized with weights pretrained on the ImageNet dataset and then fine-tuned on my solar panel dataset. This transfer learning strategy accelerates convergence and improves accuracy.
Because the solar panels are small relative to the full image size, I adjust the input resolution and candidate box parameters accordingly. For Faster RCNN, the input image is resized to 1000×800. The number of region proposals generated by RPN is set to 600, and the maximum number of detections per image after non-maximum suppression is 300. For SSD, the input size is set to 512×512, and the maximum number of predicted boxes is 600.
The detection results on a representative test image are summarized in the table below.
| Network | Actual Panels | Detected Panels | Missed | False Positives | Detection Rate |
|---|---|---|---|---|---|
| SSD (VGG16) | 400 | 198 | 201 | 3 | 0.4950 |
| Faster RCNN (VGG16) | 400 | 300 | 100 | 0 | 0.7500 |
The results show that Faster RCNN significantly outperforms SSD. SSD tends to produce imprecise bounding boxes and misses many small panels. The two-stage strategy of Faster RCNN, where candidate regions are refined before classification, is more suitable for dense small objects. Therefore, I choose Faster RCNN as the primary detection framework for the rest of this study.
Evaluation of Feature Extraction Networks
Next, I explore the impact of different backbone networks on solar panel detection using the Faster RCNN framework. I compare VGG16, ResNet50, and ResNet101. The experiments are conducted on the same training and test sets. I selected three test images (denoted as A, B, and C) to illustrate the results in detail.
The following table shows the number of detected panels and detection rates for each backbone network on images A, B, and C.
| Test Image | Backbone | Actual | Detected | Missed | Detection Rate |
|---|---|---|---|---|---|
| A | VGG16 | 288 | 77 | 211 | 0.2673 |
| A | ResNet50 | 288 | 202 | 86 | 0.7013 |
| A | ResNet101 | 288 | 172 | 116 | 0.5792 |
| B | VGG16 | 396 | 207 | 189 | 0.5227 |
| B | ResNet50 | 396 | 150 | 246 | 0.3787 |
| B | ResNet101 | 396 | 162 | 234 | 0.4090 |
| C | VGG16 | 168 | 167 | 1 | 0.9940 |
| C | ResNet50 | 168 | 163 | 5 | 0.9702 |
| C | ResNet101 | 168 | 162 | 5 | 0.9642 |
The detection performance varies substantially across images. Image C, which has a cleaner background and less dense solar panel layout, achieves high recall for all backbones. Image A and Image B present more challenging scenarios with dense arrays and complex roof structures. On average, ResNet50 provides the best trade-off between accuracy and speed. Although ResNet101 is deeper, the limited amount of training data leads to overfitting, which reduces its generalization capability.
I also evaluate the mean average precision and total inference time on the entire test set. The results are summarized below.
| Backbone | mAP (%) | Total Inference Time (s) |
|---|---|---|
| VGG16 | 67.99 | 35.7335 |
| ResNet50 | 69.63 | 22.0168 |
| ResNet101 | 69.61 | 28.6873 |
ResNet50 achieves the highest mAP among the three networks and requires the least inference time. This is because ResNet50 has a moderate depth that is sufficient to capture the repetitive and regular features of solar panels without suffering from the overfitting issue seen in ResNet101. The residual connections also help to avoid gradient degradation, making the training more stable.
Based on these findings, I adopt Faster RCNN with ResNet50 as the baseline for further improvements.
Sliding Window Approach for High-Resolution Images
One of the major challenges of aerial solar panel detection is the large image size compared with the small object size. The original Faster RCNN performs downsampling to fit the input image into a fixed size (e.g., 1000×800), which inevitably reduces the amount of detail available for small objects. To mitigate this issue, I introduce a sliding window mechanism combined with cropping input.
Instead of feeding the entire 4000×3000 image into the network, I first crop the image into smaller patches of size 1000×1000. The cropping is performed in a sliding manner with a stride of 500 pixels to avoid missing objects at the boundaries. This operation increases the effective resolution of solar panels within each input patch. The number of training patches generated from the original dataset is 1493, which provides more training samples and reduces the negative effects of downsampling.
During inference, I apply the same sliding window strategy to the test image. Each patch is passed through the trained ResNet50-based Faster RCNN detector. All predicted bounding boxes from all patches are collected. Since neighboring patches overlap, the same solar panel may be detected multiple times with slightly different bounding boxes. To eliminate duplicate detections, I apply non-maximum suppression (NMS) to the combined set of predictions. The NMS algorithm can be described as:
\[
\text{NMS}(\mathcal{B}, \mathcal{S}) = \text{select boxes with maximum score while suppressing overlapping boxes}
\]
The sliding window approach significantly improves the detection recall and localization accuracy. The following table compares the results with and without the sliding window strategy on the test images A, B, and C.
| Test Image | Method | Actual | Detected | Missed | Detection Rate |
|---|---|---|---|---|---|
| A | Faster RCNN (ResNet50) | 288 | 77 | 211 | 0.2673 |
| A | Faster RCNN (ResNet50) + Sliding Window | 288 | 282 | 6 | 0.9791 |
| B | Faster RCNN (ResNet50) | 396 | 207 | 189 | 0.5227 |
| B | Faster RCNN (ResNet50) + Sliding Window | 396 | 387 | 9 | 0.9772 |
| C | Faster RCNN (ResNet50) | 168 | 167 | 1 | 0.9940 |
| C | Faster RCNN (ResNet50) + Sliding Window | 168 | 168 | 0 | 1.0000 |
The improvement is remarkable. The detection rate on image A jumps from 26.73% to 97.91%, and on image B from 52.27% to 97.72%. On image C, the detector achieves a perfect recall. These results confirm that the sliding window strategy effectively preserves the spatial details of small solar panels, leading to a significant accuracy boost.
On the entire test set, the mAP increases from 69.63% to 86.00%, while the total inference time rises from 22.0168 seconds to 479.322 seconds due to the increased number of patches processed per image. The time cost is substantial but acceptable for applications where accuracy is more critical than real-time speed.
Attention Mechanisms for Improved Feature Extraction
Inspired by the human visual system, attention mechanisms have been widely adopted in deep learning to focus on important features and suppress irrelevant ones. In the context of solar panel detection, attention can help highlight the distinctive texture and shape of solar panels while reducing the influence of background clutter. I investigate two types of attention modules: channel attention (Squeeze-and-Excitation Network, SENet) and mixed channel-spatial attention (Convolutional Block Attention Module, CBAM).
Channel Attention: SENet
The SENet module explicitly models the interdependencies between channels. It consists of two operations: squeeze and excitation. The squeeze operation applies global average pooling to each channel, producing a channel descriptor. Given a feature map \(\mathbf{X} \in \mathbb{R}^{H \times W \times C}\), the squeeze step generates a vector \(\mathbf{z} \in \mathbb{R}^{C}\) where the \(c\)-th element is:
\[
z_c = \frac{1}{H \times W} \sum_{i=1}^{H} \sum_{j=1}^{W} x_c(i,j)
\]
The excitation step uses two fully connected layers to capture channel-wise dependencies and outputs scaling weights \(\mathbf{s}\) via a sigmoid activation:
\[
\mathbf{s} = \sigma\left( \mathbf{W}_2 \delta\left( \mathbf{W}_1 \mathbf{z} \right) \right)
\]
where \(\mathbf{W}_1\) and \(\mathbf{W}_2\) are the weights of the dimensionality-reduction and dimensionality-increasing layers, and \(\delta\) is the ReLU function. The final output is obtained by scaling the original feature map:
\[
\tilde{x}_c = s_c \cdot x_c
\]
I integrate the SE module into each residual block of ResNet50. This allows the network to recalibrate the importance of each channel after every residual stage, strengthening the response to solar panel features.
Mixed Attention: CBAM
CBAM sequentially applies channel attention and spatial attention to refine the feature map. The channel attention part uses both average pooling and max pooling to produce two channel descriptors, which are passed through a shared multi-layer perceptron. The outputs are summed and passed through a sigmoid function to generate the channel attention map \(\mathbf{M}_c \in \mathbb{R}^{C \times 1 \times 1}\). The spatial attention part applies average pooling and max pooling along the channel dimension, concatenates the resulting features, and convolves them with a 7×7 filter to produce the spatial attention map \(\mathbf{M}_s \in \mathbb{R}^{1 \times H \times W}\). The overall process is:
\[
\mathbf{F}’ = \mathbf{M}_c(\mathbf{F}) \otimes \mathbf{F}
\]
\[
\mathbf{F}” = \mathbf{M}_s(\mathbf{F}’) \otimes \mathbf{F}’
\]
where \(\otimes\) denotes element-wise multiplication.
Experimental Comparison of Attention Modules
I first evaluate SENet and CBAM without the sliding window strategy to isolate their effect on the backbone. The experiments are performed using Faster RCNN with ResNet50 as the base network. The results are shown below.
| Backbone | mAP (%) | Inference Time (s) |
|---|---|---|
| ResNet50 | 43.67 | 17.6023 |
| CBAM-ResNet50 | 44.70 | 19.2584 |
| SE-ResNet50 | 46.01 | 18.5587 |
Both attention mechanisms improve the mAP compared with the plain ResNet50 backbone. SENet provides a higher mAP improvement (2.34 percentage points) than CBAM (1.03 percentage points). In terms of inference time, SENet adds only about 0.96 seconds, while CBAM adds about 1.66 seconds. Therefore, I choose SENet as the attention module for further integration.
Proposed Method: Faster RCNN with SE-ResNet50 and Sliding Window
After verifying the benefits of individual components, I combine the sliding window strategy and the channel attention mechanism into a unified solar panel detection algorithm. The architecture proceeds as follows:
1. Preprocess the input image: random horizontal flipping and contrast adjustment for training; no semantic changes for inference.
2. Crop the image into overlapping patches of size 1000×1000 with stride 500.
3. Feed each patch into the Faster RCNN detector with the SE-ResNet50 backbone. The backbone is modified by inserting SE blocks after each residual block.
4. Generate region proposals via the RPN and refine them with ROI pooling and classification/regression heads.
5. Collect all predictions from all patches and apply non-maximum suppression to obtain the final detections.
The complete model is trained end-to-end using stochastic gradient descent. I use a learning rate of 0.001, a momentum of 0.9, and a weight decay of 0.0005. The learning rate is decayed by a factor of 0.1 every few epochs. The maximum number of training epochs is determined empirically by monitoring the loss convergence.
Experimental Results and Discussions
I compare the proposed method (Faster RCNN with SE-ResNet50 and sliding window) against several baselines, including the original VGG16-based Faster RCNN, ResNet50-based Faster RCNN, ResNet101-based Faster RCNN, and the machine vision method of Yao et al. (referred to as Yao’s method). The comparison is performed on test images A, B, and C in terms of detection rate and inference time per image.
| Test Image | Method | Actual | Detected | Missed | Detection Rate | Time (s) |
|---|---|---|---|---|---|---|
| A | Yao’s method | 288 | 199 | 89 | 0.6909 | 16.0233 |
| A | Faster RCNN (VGG16) | 288 | 281 | 7 | 0.9756 | 15.9770 |
| A | Faster RCNN (ResNet50) | 288 | 288 | 0 | 1.0000 | 15.9265 |
| A | Faster RCNN (ResNet101) | 288 | 288 | 0 | 1.0000 | 19.9614 |
| A | Faster RCNN (SE-ResNet50) | 288 | 288 | 0 | 1.0000 | 16.5059 |
| A | Faster RCNN (SE-ResNet101) | 288 | 288 | 0 | 1.0000 | 29.3763 |
| B | Yao’s method | 396 | 237 | 159 | 0.5984 | 16.5871 |
| B | Faster RCNN (VGG16) | 396 | 385 | 11 | 0.9722 | 15.9770 |
| B | Faster RCNN (ResNet50) | 396 | 394 | 2 | 0.9949 | 15.9265 |
| B | Faster RCNN (ResNet101) | 396 | 396 | 0 | 1.0000 | 19.9614 |
| B | Faster RCNN (SE-ResNet50) | 396 | 396 | 0 | 1.0000 | 16.5059 |
| B | Faster RCNN (SE-ResNet101) | 396 | 396 | 0 | 1.0000 | 29.3763 |
| C | Yao’s method | 168 | 112 | 56 | 0.6666 | 14.9120 |
| C | Faster RCNN (VGG16) | 168 | 164 | 4 | 0.9761 | 15.9770 |
| C | Faster RCNN (ResNet50) | 168 | 168 | 0 | 1.0000 | 15.9265 |
| C | Faster RCNN (ResNet101) | 168 | 168 | 0 | 1.0000 | 19.9614 |
| C | Faster RCNN (SE-ResNet50) | 168 | 168 | 0 | 1.0000 | 16.5059 |
| C | Faster RCNN (SE-ResNet101) | 168 | 168 | 0 | 1.0000 | 29.3763 |
The proposed SE-ResNet50-based Faster RCNN with sliding window achieves a detection rate of 100% on all three test images, meaning every solar panel is correctly localized and counted. The plain ResNet50 also achieves perfect recall on images A and C but misses two panels on image B. SE-ResNet50 further eliminates these misses, demonstrating the benefit of channel attention in extracting subtle features.
I also evaluate the overall performance on the entire test set. The mAP and total inference time for different backbones with the sliding window strategy are presented below.
| Backbone | mAP (%) | Total Inference Time (s) |
|---|---|---|
| VGG16 | 86.00 | 479.3220 |
| ResNet50 | 87.09 | 477.7950 |
| ResNet101 | 85.42 | 598.8420 |
| SE-ResNet50 | 87.53 | 495.1770 |
| SE-ResNet101 | 86.47 | 881.2890 |
The results clearly indicate that the combination of SE-ResNet50 and the sliding window achieves the highest mAP (87.53%) among all tested configurations. The improvement over the original VGG16 baseline (86.00%) is 1.53 percentage points, and over plain ResNet50 (87.09%) is 0.44 percentage points. Although the inference time is higher than the non-sliding-window versions, the accuracy gain is substantial for the counting task, where missing a panel is more costly than a slight delay.
In addition, I compare the proposed method with Yao’s machine vision approach. Yao’s method relies on contour matching and HSV color space conversion, requiring manual threshold settings and being sensitive to illumination changes. In contrast, my deep learning method is fully automatic and does not require any manual feature engineering. The detection rates of Yao’s method are below 70% on all three test images, while my method achieves nearly perfect or perfect recalls. The inference time of Yao’s method is comparable to that of my method, but its accuracy is far inferior.
Counting Solar Panels in Full Test Images
Tofurther demonstrate the practical value of my algorithm, I apply the proposed method to count solar panels in several test images. I set the confidence threshold to 0.75 and show the detection results for six randomly selected images. The table below reports the number of detected panels, false positives, and the actual number of panels in each image.
| Image ID | Detected Panels | False Positives | Actual Panels |
|---|---|---|---|
| 1 | 223 | 3 | 220 |
| 2 | 61 | 9 | 52 |
| 3 | 17 | 0 | 17 |
| 4 | 394 | 2 | 392 |
| 5 | 248 | 0 | 248 |
| 6 | 268 | 0 | 268 |
For images 3, 5, and 6, the detection is perfectly accurate with no false positives. Images 1 and 4 have a small number of false positives (3 and 2, respectively), while image 2 has 9 false positives. False positives may occur due to objects on the roof that resemble solar panels, such as skylights or reflective surfaces. Nevertheless, the counting accuracy is high enough for practical asset management tasks.
The image below shows an example of solar panels in aerial imagery, illustrating the typical appearance and density of such installations.
The visual results confirm that my detector is able to localize the vast majority of solar panels even in highly dense arrays. The bounding boxes align well with the panel boundaries, and the counting process is reliable.
Conclusion and Future Work
In this thesis, I have presented a systematic study of solar panel detection from high-resolution aerial images using convolutional neural networks. I constructed a dedicated dataset of industrial rooftop photovoltaic installations, annotated with individual panel bounding boxes. Through extensive experiments, I found that the two-stage Faster RCNN detector significantly outperforms the one-stage SSD detector for this task, mainly due to the dense and small nature of solar panels.
I then compared several feature extraction networks and concluded that ResNet50 offers the best trade-off between accuracy and speed. To overcome the challenge of small targets in large images, I introduced a sliding window strategy that crops the image into overlapping patches before detection. This simple yet effective technique dramatically improved the detection rate from less than 70% to over 97% on challenging test images.
Furthermore, I incorporated the channel attention mechanism SENet into the ResNet50 backbone, allowing the network to emphasize important feature channels and suppress irrelevant ones. The combination of SENet and the sliding window yielded the highest mean average precision of 87.53% on the test set, surpassing all baseline methods and a traditional machine vision approach. The final detector is capable of counting solar panels with near-perfect recall, making it a valuable tool for the automated management of photovoltaic installations.
There are several directions for future research. First, I plan to expand the dataset with more diverse solar panel images captured at different altitudes, angles, and weather conditions to further validate and improve the model’s generalization. Second, the sliding window approach increases the inference time considerably; I aim to explore more efficient alternatives, such as feature pyramid networks or tiling-based methods with reduced computation. Third, I intend to investigate the integration of orientation-aware detectors to handle tilted solar panels more accurately. Finally, the proposed method may be extended to other dense small-object detection tasks, such as detecting vehicles in satellite images or counting trees in aerial forestry surveys.
In summary, my work demonstrates that deep learning-based object detection, combined with appropriate preprocessing and attention mechanisms, can achieve high accuracy in solar panel detection and counting. This research provides a solid foundation for the development of practical photovoltaic monitoring systems and contributes to the broader field of remote sensing image analysis.
I would like to emphasize that the successful detection of solar panels is not only academically interesting but also has significant economic and environmental implications. Accurate inventorying of solar panels enables companies to optimize their maintenance schedules, evaluate the performance of their assets, and make informed decisions about future investments. By automating this process with convolutional neural networks, we can save time and resources while promoting the growth of renewable energy.
| Symbol | Description |
|---|---|
| \(H, W\) | Height and width of a feature map |
| \(C\) | Number of channels |
| \(p_i\) | Predicted probability for anchor \(i\) |
| \(t_i\) | Predicted bounding box offsets |
| \(L_{cls}\) | Classification loss |
| \(L_{reg}\) | Regression loss |
| \(\sigma\) | Sigmoid activation function |
| \(\delta\) | ReLU activation function |
Through this comprehensive investigation, I have shown that a carefully designed convolutional neural network pipeline is well-suited for solar panel detection in high-resolution aerial imagery. The combination of a two-stage detector, a residual backbone with channel attention, and sliding window processing leads to state-of-the-art performance on my dataset. I believe that the insights gained from this research will be valuable for practitioners working on similar remote sensing tasks and for the ongoing transition towards a more sustainable energy infrastructure.