A Spatiotemporal U-Net-Based Data Preprocessing Pipeline for Sun-Synchronous Path Planning in Lunar South Polar Exploration

Abstract

The dynamic illumination conditions in the Moon’s polar region present challenges for future rover explorations, which require enhanced efficiency and intelligent data preprocessing for Sun-synchronous path planning. Within the Chang’E-7 polar exploration mission context, this study investigates automated, intelligent preprocessing of 2.5D illumination data from high-resolution Digital Elevation Models for polar rover global path planning. A preprocessing pipeline is developed using a Sun-synchronous spatiotemporal U-Net,3STU-Net, incorporating time-slice and time-series sub-networks, to streamline data handling and identify regions with favorable illumination. Subsequently, an enhanced A* algorithm named 3ST-A*, leveraging preprocessed data, is applied in a designated area of interest for global path-planning experimental validation. The findings significantly improve illumination data processing efficiency and advance path-planning research, offering valuable support for future lunar exploration missions.

1. Introduction

The Moon’s south pole offers a new frontier for conducting scientific research and engineering exploration missions, including the Artemis and China’s Chang’E-7 (CE-7) missions, as well as future initiatives like the Japan–India Lunar Polar Exploration (LUPEX) and the International Lunar Research Station (ILRS) [1,2,3,4,5]. The innovative CE-7 mission will utilize a rover to study geological features in sunlit areas and a mini-flying probe to investigate water ice and volatiles in the permanent shadow regions (PSRs) [6]. Landing site selection is critical due to complex terrains, extreme illumination conditions, and limited Earth communication. The Queqiao-2 relay satellite has successfully provided Earth–Moon communication for the successful Chang’E-6 sample return mission and will continue to support the CE-7 mission. While the mini-flying probe will explore cold traps using jet propulsion without considering the sunlit conditions, this work will focus on solar-powered rover exploration, which requires a reliable energy supply and effective optical navigation. The key challenge lies in planning and optimizing the rover’s path to maximize the duration of solar energy utilization, avoid obstacles, and reach the target points efficiently. Additionally, the rover must contend with dynamic and temporal illumination conditions and static spatial factors like slopes and exposed rocks.

Predicting dynamic illumination conditions at target landing areas can be effectively achieved by combining high-resolution Digital Elevation Model (DEM) data with ephemeris information for Sun-synchronous path planning. The current spatiotemporal dataset of Sun-synchronicity has been developed using data from the Lunar Orbiter Laser Altimeter (LOLA) onboard the Lunar Reconnaissance Orbiter (LRO) and the Chang’E-1 satellite [7,8,9]. To perform path planning, several data preprocessing requirements must be met. Firstly, traditional research focuses on ex-ante processing, relying on expert experience and hard coding, which lacks new models for in-process processing and fails to reduce the dependence on expert experience and the maintenance costs of hard coding. Additionally, establishing a systematic process to enhance automation and intelligence in data preprocessing is urgent. Secondly, Sun-synchronous path planning focuses on regions with favorable illumination conditions. Data from sunlit regions should be classified and segmented while identifying dark and low-light areas. This prescreening will enhance path-planning algorithm design, implementation, and coverage. Thirdly, in contrast to the 2.5D concept in biomedicine [10,11,12], 2.5D data in remote sensing incorporates vertical-derived DEM information, such as illumination, into 2D coordinates. Given the rapid changes in solar altitude in the lunar polar regions, illumination data can be processed in time-sequential forms like time slice (Figure 1a) or time series (Figure 1b), establishing essential mappings and temporal relationships between the additional vertical spatial information and the RGB data of image pixels. Targeted preprocessing capabilities, including customized pipelines with relevant data segmentation models and path-planning algorithms, are also necessary.

The data preprocessing pipeline is a systematic approach that enhances data processing capabilities in research [13,14,15]. This method is applied in remote sensing workflows, including satellite and terrestrial data preprocessing, identification, and classification [16,17]. In lunar exploration, studies focus on processing lunar-surface remote sensing data and identifying craters and boulders through artificial intelligence, incorporating core modules like data transformation and machine learning networks [18,19,20].

The development of artificial intelligence technologies such as deep learning, relevant classification, and semantic segmentation models and algorithms, such as convolutional neural networks (CNN), fully convolutional networks (FCN), and U-Net, have brought new solutions to the processing of remote sensing data [21,22,23,24,25,26,27,28]. U-Net and U-Net-based architectures like U-Net++, Attention U-Net, and HRU-Net represent a class of convolutional neural network architecture with state-of-the-art performance for image segmentation, featuring an encoder–decoder structure with skip connections that enable them to capture both global and local features, thus achieving high-performance and fine-grained segmentation results [28,29,30,31]. In the field of lunar exploration, U-Net primarily conducts tasks such as lunar static spatial surface-feature segmentation, obstacle recognition, and crater identification, with related studies occurring outside the lunar south pole region [32,33,34]. Through these trained artificial intelligence models and algorithms, target data can be intelligently proceeded and output automatically, which greatly reduces the dependence on expert experience and the workload of hard coding. However, there is limited research on U-Net constructed for spatiotemporal 2.5D data in the lunar polar region. Due to the dynamic changes in Sun angle and illumination conditions in the polar regions, dynamic light intensity and angle changes pose new challenges to continuous and temporal time-slice or time-series image segmentation tasks. Currently, there are few in-depth explorations in this regard.

Path planning can be categorized into global path planning and local path planning. Global path planning often seeks the optimal path from a given starting point to a goal point based on static, largely environmental information, whereas local path planning conducts path planning within a small-scale environment by interacting with the surrounding environmental information through sensors [35,36]. This paper focuses on global path planning and related algorithms are categorized into four types: graph search, sampling-based methods, heuristic optimization techniques, and learning-based approaches [37,38,39,40,41,42,43,44,45,46]. Graph-based path-planning algorithms utilize specific search strategies on pre-constructed grid maps [37], employing methods like depth-first search, breadth-first search, A*, and D* [47,48,49]. A* merges Dijkstra’s optimal path search with a heuristic strategy from the greedy best-first search algorithm [50]. However, it relies on a cost function to guide the search process, which limits its adaptability to changing temporal situations, particularly in spatiotemporal contexts. These algorithms prioritize static spatial features such as slopes and obstacles in lunar exploration. The data used often has low resolution and accuracy, making quality assurance more challenging [51,52,53,54,55]. As a result, efficient processing and generating high-quality spatiotemporal datasets are crucial for effective path-planning in polar regions.

This paper constructs a data preprocessing pipeline utilizing data derived from a 20 m/pixel DEM. An improved spatiotemporal U-Net architecture is introduced for data segmentation based on 2.5D illumination data. Additionally, an enhanced A* path-planning algorithm operates on the preprocessed data. Experimental results demonstrate that these core models significantly improve automation and intelligence in data preprocessing and path planning, supporting further research. The paper’s structure is as follows: Section 2 mainly presents the dataset, detailing the data preprocessing pipeline using the Sun-synchronous spatiotemporal U-Net, referred to as 3STU-Net, and the Sun-synchronous spatiotemporal A* algorithm (known as 3ST-A*). Section 3 outlines the experimental setup, while Section 4 and Section 5 present the experimental results and their analysis. The final section summarizes the findings.

2. Data and Methods

2.1. Datasets

The lunar polar region’s DEM has been extensively utilized to assess illumination conditions for future missions [8,56,57,58,59]. Since the launch of the Lunar Reconnaissance Orbiter (LRO) in July 2009, the onboard Lunar Orbiter Laser Altimeter (LOLA) has observed the Moon for over 15 years [60]. This has resulted in a comprehensive DEM dataset covering the polar region at various resolutions, facilitating high-quality simulations for landing safety and rover path planning. In this study, we employ the DEM dataset (https://imbrium.mit.edu/ (accessed on 15 January 2025)) at a resolution of 20 m/pixel to compute illumination conditions that balance efficiency and accuracy. Figure 2a,b illustrates the topography of the Moon’s southern pole and the region of interest (ROI), respectively. Previous researchers have extensively studied complex lighting conditions to identify suitable landing sites. For example, reference [61] simulated illumination for the European Space Agency’s Lunar Lander project, while [62] utilized high-resolution images from the Lunar Reconnaissance Orbiter to analyze the illumination environment over a lunar year, revealing ideal exploration sites. Recently, reference [63] identified favorable landing areas for China’s Chang’E-7 mission, indicating regions with long illumination periods. The above potential landing areas include our ROI, which allows us to develop effective path planning for upcoming missions. By utilizing the horizon method [64] and SPICE toolkit [65] for obtaining the position of the Sun, we calculated the ROI’s real-time Sun visibility from 1 to 30 November 2026, at 5 min intervals. Figure 2c presents the time-averaged Sun visibility for this range. Notably, regions with high Sun visibility closely correlate with the peaks of the ROI. The time range utilized demonstrates the efficacy of our algorithm in computing the real-time illumination conditions.

Figure 3 illustrates the workflow for generating time-slice and time-series data including both the process of training data and inference data. Initially, a TIF (Tag Image File Format) file with stacked raw data is loaded and converted into a sequence of data slices, each with a calculated Sun Visibility Factor (SVF). In the processing sub-workflow of the training data, an iteration process exports each slice to a CSV (Comma-Separated Values) file, mapping it to a 2.5D time-slice grid image and generating its ground truth mask. Following this, time-series data for model training, validation, or testing is created by aggregating a fixed number of time-slice data and determining the ground truth mask via the keyframe method. In contrast, in the experiment, time-series mean data can be generated by averaging the fixed number of time-slice data and producing its ground truth mask. Further principles and formulas will be discussed in subsequent sections. However, in the processing sub-workflow of the inference data, there is no mandatory requirement to generate CSV files and the ground truth masks. If we need to further examine and evaluate the model’s performance, we can manually generate the ground truth masks for a portion of the new inference data and incorporate them into the training data.

In this study, the Sun Visibility Factor (SVF) quantifies solar disk visibility as the ratio of the unobstructed area to the total area. This ratio ranges from 0, indicating complete obstruction, to 1, which signifies full visibility. The Sun-synchronous illumination training dataset comprises a total of 9928 image–mask pairs collected from 1 November to 30 November 2026, in the south polar area, divided into two subsets: The primary subset includes 8464 illumination data slices at 5 min intervals, while the supplementary subset contains 1464 slices at one-hour intervals. Additionally, there is an independent inference dataset comprising thousands of illumination images at 5 min intervals collected from 1 February to 28 February 2027, in the same area. Each data slice has a resolution of 20 m per pixel, dimensions of 65 × 65 pixels per image, and the same ROI in Figure 2.

2.2. Data Preprocessing Pipeline

We developed a 2.5D data preprocessing pipeline that organizes various core data nodes, as illustrated in Figure 4. This pipeline encompasses acquiring and calculating raw data, centralized dataset processing, machine learning-based end-to-end processing, and the application of data in path-planning algorithms. Notably, the implementation of a Sun-synchronous spatiotemporal U-Net network, utilizing polar illumination data’s dynamic characteristics, has significantly improved the pipeline’s automation and intelligence, reducing reliance on expert experience and the costs associated with hard-coding maintenance.

The pipeline mainly consists of three parts: input, network, and output. The input part mainly focuses on raw data and datasets. It uses high-resolution DEM data, combines information such as ephemeris tables, and applies computer technologies for preliminary processing like fine-grained data calculation and merging. In the dataset, computer technology is utilized to automate various requirements for the processed data obtained from the calculation, such as data loading, parsing, exporting, grouping, and labeling. The network part mainly focuses on model training and inference. In the training block, a Sun-synchronous spatiotemporal U-Net known as 3STU-Net consists of two sub-U-Net networks that are constructed according to the time-slice and time-series characteristics of 2.5D illumination data to train semantic segmentation models of friendly illumination data under different research conditions. In the inference block, the focus is on using the tested models to conduct centralized segmentation processing of illumination data and generate new datasets (related content will be elaborated in detail in the next section). The output part mainly focuses on data preparation and path planning. Data preparation work, such as data merging and grouping, is completed according to the data requirements of path planning. In the path-planning block, research and experiments on algorithms are mainly carried out, the experimental results are analyzed, and iterations are performed. This study focuses on the research and processing of an improved Sun-synchronous spatiotemporal A* algorithm referred to as 3ST-A*. This algorithm is based on either preprocessed illumination data or alternative methods, enhancing path planning effectiveness.

Both data segmentation and the path-planning algorithm are core components of this pipeline, representing the ability to extract illuminated areas during data preprocessing and the research achievements of the path-planning algorithm. They will be discussed in the next sections.

2.3. Sun-Synchronous Spatiotemporal U-Net (3STU-Net)

The dataset is generated by integrating segmented data from various temporal sampling points into a cohesive spatiotemporal framework, as previously discussed. This integration ensures a comprehensive understanding of the data’s dynamics over time. When addressing data segmentation requirements, two prevalent scenarios emerge: The first involves segmenting data at a specific temporal instance under optimal illumination conditions, known as time-slice 2.5D data. These data are organized sequentially along the dynamic illumination time axis. The second scenario involves a temporal duration characterized by continuous time slices, referred to as time-series 2.5D data. Our research utilizes a one-hour time-series dataset comprising 12 5 min time slices, derived from the primary dataset. We perform feature fusion by aggregating data from these consecutive time slices along the temporal axis, generating a new set of time-period slice data. That is, for the input data sample $F_{svf}$ and its data element in the style of SVF $f_i$, we have

$$F_{svf}=\left\{\begin{array}{c} \left\{f_{i,t_k}\right\} i,k\in \mathbb{N}\\ \left\{f_{i,T_k}\right\} i,k,n\in \mathbb{N}, T_k=\left\{t_{k,n}\right\},n\in \left[1,12\right],\end{array}\right.$$

(1)

where $f_{i,t_k}$ denotes the SVF value for pixel $i$ at time slice $t_k$, $k$ represents the sequence number of a time-slice or time-series sample, and $\mathbb{N}$ represents the set of natural numbers and $\mathbb{N}=\{0,1,2,3\dots \}$; $f_{i,T_k}$ denotes the SVF value for pixel $i$ at time series $T_k$ and $n$ represents the number of time slice in one time-series sample $T_k$.

Considering the mapping relationship between the RGB information of the image and SVF, we have

$$F_{gray}=\left\{\begin{array}{c}\left\{g_{i,t_k}=255\cdot f_{i,t_k}\right\} i,k\in \mathbb{N}\\ \left\{g_{i,T_k}=255\cdot f_{i,T_k}\right\} i,k,n\in \mathbb{N}, T_k=\left\{t_{k,n}\right\},n\in \left[1,12\right]\end{array} \right.$$

(2)

where $g_{i,t_k}$ denotes the RGB channel value for pixel $i$ at time slice $t_k$ and $g_{i,T_k}$ denotes the RGB channel value for pixel $i$ at time series $T_k$. Next, we use $F_{t_k}$ to represent the corresponding dataset under the condition of the time slice and $F_{T_k}$ to represent the corresponding dataset under the condition of the time series.

The 3STU-Net architecture consists of two specialized sub-networks: one for processing 2.5D time-slice data and the other for handling 2.5D time-series data. Our objective is to create sub-models that autonomously process input data from distinct scenarios and accurately segment illumination-friendly regions. This segmentation can be performed either temporally, on a slice-by-slice basis, or periodically over extended durations, requiring minimal expert knowledge or predefined maintenance protocols. Before detailing the architecture, it is crucial to quantitatively define the term “illumination-friendly”. For effective solar power utilization in lunar polar exploration, a pixel in the ROI is considered “illumination-friendly” if it receives over 75% of solar disk energy, meaning the SVF value must be at least 0.75. We assert that by adhering to this strict criterion, we can ensure that illumination conditions fulfill engineering requirements for optimal path planning.

2.3.1. 3STU-Net-1 for Time-Slice 2.5D Data

For dataset $F_{t_k}$, the network must master fine-grained feature extraction from 2.5D illumination time-slice data while maintaining performance balance. We have refined the original U-Net architecture by incorporating residual operations and an attention mechanism, creating an advanced framework specifically designed for time-slice 2.5D data (see Figure 5).

1. Architecture

The architecture integrates attention mechanisms with residual connections to enhance illumination feature extraction and segmentation performance. It is adaptable, allowing adjustments based on the number of input channels and classes to suit various tasks, and comprises multiple core modules.

• “Channel Attention” Block: This block serves to enhance the responses of significant feature channels. It employs adaptive average pooling to reduce the spatial dimensions of the input feature map to 1 × 1. Subsequently, it determines the channel weights through a Multi-Layer Perceptron block, which comprises two fully connected layers interspersed with a rectified linear unit and incorporates a Sigmoid function. During the forward propagation process, the input feature map is initially pooled and flattened. The channel weights are then derived from the fully connected layers. Ultimately, the weights are expanded to correspond with the original shape of the input and are multiplied element-wise with the input, thereby augmenting the feature representation of critical channels.
• “Spatial Attention” Block: This module executes average and maximum pooling operations on the input feature map within the channel dimension to optimize the extraction of static features. After the concatenation of the resultant outputs, it derives the weights via a 7 × 7 convolutional layer followed by the application of the Sigmoid function.
• “Residual Attention” Block: This block comprises two groups of 3 × 3 convolutional layers accompanied by a batch normalization layer interspersed with a rectified linear unit. Subsequently, it integrates the aforementioned two attention mechanisms and incorporates residual connections to enhance the model’s efficiency.
• The architecture’s encoder comprises “Down” modules that integrate a max-pooling layer alongside a “Residual Attention” block for down-sampling. This configuration methodically diminishes the dimensionality of the feature map while concurrently augmenting the channel count. In contrast, the decoder is structured with “Up” modules, which incorporate a transposed convolutional layer and a “Residual Attention” block to facilitate up-sampling. This process systematically enlarges the feature map’s dimensions whilst reducing the number of channels. During the up-sampling phase, the architecture adeptly addresses the discrepancies in size by concatenating the feature maps corresponding to the layers in the encoder. Ultimately, the “Out-Conv” module employs a 1 × 1 convolution to produce the segmentation results.

2. Formulation

The relevant formulas involved in this sub-3STU-Net for time-slice data $X_{t_k}$ are summarized as follows:

• The formula of the “Channel Attention” block is

$$A_c\left(X_{t_k}\right)=\delta \left(W_2\cdot ReLU\left(W_1\cdot GAP\left(X_{t_k}\right)\right)\right)$$

(3)

where $X_{t_k}$ is the input of time-slice data, $GAP$ represents the global average pooling operation, and $W_1$ and $W_2$ are the weight parameters of the two fully connected layers, respectively. $\delta \left(\cdot \right)$ represents the Sigmoid function to map the output of the attention weight values to the range of [0, 1] and the results are represented as $A_c\left(X_{t_k}\right)$.

• The formula of the “Spatial Attention” block is

$$A_s\left(X_{t_k}\right)=\sigma \left(Conv\left(Concat\left(GMP\left(X_{t_k}\right),GAP\left(X_{t_k}\right)\right)\right)\right)$$

(4)

where $GMP$ represents the global max pooling operation, $Concat$ represents the concatenating operation, $Conv$ represents the 7 × 7 convolutional operation, and the attention weight results are represented as $A_s\left(X_{t_k}\right)$. Other characters maintain the same operation meaning.

• The formula of the “Residual Attention” block is

$$ResAtten\left(X_{t_k}\right)=ReLU\left(P\left(X_{t_k}\right)+G\left(X_{t_k}\right)\right)$$

(5)

where $P\left(X_{t_k}\right)$ represents the output feature map from the main path, $G\left(X_{t_k}\right)$ represents the output of the residual path, and $ReLU$ represents the rectified linear unit operation. The formula of $P\left(X_{t_k}\right)$ is

$$P\left(X_{t_k}\right)=\left(M\left(X_{t_k}\right)\otimes A_c\left(X_{t_k}\right)\right)\otimes A_s\left(X_{t_k}\right)$$

(6)

$M\left(X_{t_k}\right)$ represents the output feature map from the previous main path and its formula is

$$M\left(X_{t_k}\right)=BN\left(Conv\left(ReLU\left(BN\left(Conv\left(X_{t_k}\right)\right)\right)\right)\right)$$

(7)

where $BN$ represents the batch operation, $Conv$ represents the 3 × 3 convolutional operation, $\otimes$ represents the element-wise multiplication operation, $A_c\left(X_{t_k}\right)$ represents the “Channel Attention” block operation, and $A_s\left(X_{t_k}\right)$ represents the “Spatial Attention” block operation.

• The feature update formula for each level in the encoder is

$$X_{t_k}^{\left(l+1\right)}=ResAtten\left(down\left(X_{t_k}^l\right)\right) l=0,1,2,3$$

(8)

where $down\left(\cdot \right)$ represents the down-sampling max-pooling operation, $X_{t_k}^l$ is the feature map of the previous low layer, and $X_{t_k}^{\left(l+1\right)}$ is the feature map of the corresponding high layer both in the encoder.

The feature update formula for each level in the decoder is

$$X_{t_k}^l=ResAtten\left(up\left(X_{t_k}^{\left(l+1\right)},X_{t_k}^l\right)\right) l=0,1,2,3$$

(9)

where $up\left(\cdot \right)$ represents the up-sampling transposed-convolutional operation. $X_{t_k}^{\left(l+1\right)}$ is the feature map of the previous high layer in the decoder and $X_{t_k}^l$ is the feature map of the corresponding low layer in the encoder.

3. Ground Truth Mask

The ground truth mask for each data slice is made based on the “illumination-friendly” threshold: 1 for SVF > 0.75 and 0 for otherwise.

2.3.2. 3STU-Net-2 for Time-Series 2.5D Data

In the context of sample $F_{T_k}$, the network must learn feature fusion and extraction capabilities from 12 time-slice samples while ensuring optimal performance. Building on 3STU-Net-2’s design, we enhance time-series data processing by capturing dynamic variations through data aggregation and averaging. Additionally, we extract spatial static features from each slice and present an improved U-Net architecture for time-series 2.5D data, as shown in Figure 6.

1. Architecture

The architecture integrates the attention mechanism with residual connections, enhancing illumination feature extraction and segmentation performance. It can be adjusted based on input channels and class numbers for various tasks. Targeted improvements are made on the time-slice U-Net architecture modules, leading to the proposal of relevant core modules.

• “Input Layer” block: This block enhances input features by using a 3 × 3 convolutional layer to convert input channels into 64 channels, extracting basic features such as edges and textures. It is then processed by a custom residual convolution block, known as the “Residual Attention” block, which will be introduced later. The residual connection alleviates the vanishing gradient problem and improves feature extraction.
• “Temporal Attention” Block: This block enhances feature extraction of time slices by replacing both the “Channel Attention” and “Spatial Attention” blocks. It utilizes the channel attention mechanism, beginning with adaptive average pooling to condense the input feature map to 1 × 1, obtaining global average features for each channel. Next, two 1 × 1 convolutional operations are performed, separated by a rectified linear unit. The first convolution reduces the channel count to one-eighth of the original, thereby lowering computational complexity. The second convolution restores the channel count to its original level. The Sigmoid function then maps the output to the range of [0, 1], producing attention weights for each channel. These weights are finally multiplied element-wise with the input feature map to enhance the important channel features.
• “Residual Attention” Block: This block enhances the temporal feature extraction ability of temporal slice data by employing a temporal attention mechanism alongside a residual connection. The primary modification involves replacing the original “Channel Attention” and “Spatial Attention” blocks with the “Temporal Attention” block, while other design elements remain unchanged.
• “Spatiotemporal Fusion” Block: This module fuses temporal and spatial features, connecting the encoder and decoder. In the temporal branch, the input feature map is averaged along the channel dimension to create a temporal feature map, which is processed through a 3 × 3 convolutional layer with a channel constraint of 1. This is followed by batch normalization and a rectified linear unit, resulting in a feature map with half the input channels. In contrast, the spatial branch retains its structures without the average pooling in the channel dimension, emphasizing static spatial features. Finally, the temporal and spatial feature maps are concatenated along the channel dimension and processed through another 3 × 3 convolutional layer for effective feature fusion.
• The designs of the other parts of the encoder and decoder of this architecture are the same as those for time-slice data. The improved “Residual Attention” block is placed in each layer for refined feature extraction. Ultimately, the “Out-Conv” module uses a 1 × 1 convolution to output the segmentation result.
• The encoder and decoder designs in this architecture mirror those used for time-slice data. Each layer incorporates an enhanced “Residual Attention” block for improved feature extraction. Ultimately, the “Out-Conv” module employs a 1 × 1 convolution to produce the segmentation results.

2. Formulation

The relevant formulas involved in this 3STU-Net-2 for time-series data $X_{T_k\cdot Input}$ are summarized as follows:

• The formula of the “Input Layer” block is

  $$X_{T_k}^{\left(l=0\right)}=ResAtten\left(Conv\left(X_{T_k\cdot Input}\right) \right)$$

  (10)

  $X_{T_k}^{\left(l=0\right)}$ is the output feature map of the input layer, $Conv$ represents the 3 × 3 convolutional operation, and $ResAtten\left(\cdot \right)$ represents the “Residual Attention” block operation, which we will discuss later. $X_{T_k\cdot Input}$ is the input of time-series data.
• The formula of the “Temporal Attention” block is

  $$A_T\left(X_{T_k}\right)=\delta \left(Conv\right(ReLU\left(Conv(GAP\left(X_{T_k}\right)\right)\left)\right))$$

  (11)

  where $GAP$ represents the global average pooling operation. $Conv$ represents the 1 × 1 convolutional operation. $ReLU$ represents the rectified linear unit operation. $\delta \left(\cdot \right)$ represents the Sigmoid function to output the attention weight values to the range of [0, 1] and the results are represented as $A_T\left(X_{T_k}\right)$.
• The formula of the “Residual Attention” block is

  $$ResAtten\left(X_{T_k}\right)=ReLU\left(P\left(X_{T_k}\right)+G\left(X_{T_k}\right)\right)$$

  (12)

  $ReLU$ represents the rectified linear unit operation. $P\left(X_{T_k}\right)$ represents the output feature map from the main path and $G\left(X_{T_k}\right)$ represents output of the residual path. The formula of $P\left(X_{T_k}\right)$ is

  $$P\left(X_{T_k}\right)=M\left(X_{T_k}\right)\otimes A_T\left(X_{T_k}\right)$$

  (13)

  $M\left(X_{T_k}\right)$ represents the output feature map from the previous main path, and its formula is

  $$M\left(X_{T_k}\right)=BN\left(Conv\left(ReLU\left(BN\left(Conv\left(X_{T_k}\right)\right)\right)\right)\right)$$

  (14)

  where $BN$ represents the batch operation. $Conv$ represents the 3 × 3 convolutional operation. $\otimes$ represents the element-wise multiplication operation. $A_T\left(X_{T_k}\right)$ represents the “Temporal Attention” block operation. The formula of $G\left(X_{T_k}\right)$ is

  $$G\left(X_{T_k}\right)=\left\{\begin{array}{c}Conv\left(X_{T_k}\right),C_{in}\ne C_{out}\\ X_{T_k}, otherwise\end{array}\right.$$

  (15)

The goal of this formula is to ensure that the data output by the shortcut operation meets the corresponding value requirements of the residual output.

• The formula for the “Spatiotemporal Fusion” block is

$$F\left(X_{T_k}\right)=Conv\left(Concat\left(ReLU\left(BN\left(Conv\left(GAP\left(X_{T_k}\right)\right)\right)\right),ReLU\left(BN\left(Conv\left(X_{T_k}\right)\right)\right)\right)\right)$$

(16)

where $Concat$ represents the concatenating operation and $Conv$ represents the 3 × 3 convolutional operation. Other characters maintain the same operation meaning as mentioned before.

• The feature update formula for each level in the encoder is

$$X_{T_k}^{\left(l+1\right)}=ResAtten\left(down\left(X_{T_k}^l\right)\right) l=0,1,2,3$$

(17)

where $down\left(\cdot \right)$ represents the down-sampling max-pooling operation. Between the encoder and the decoder, the “Spatiotemporal Fusion” block, which is represented by Formula (16), needs to be invoked to perform fusion processing on the spatiotemporal data. This part mainly deals with the data $X_{T_k}^{\left(4\right)}$ that are the final output of the encoder and transmit values into the decoder network represented by Formular (18). The feature update formula for each level in the decoder is represented by Formular (19):

$${X^{\prime }}_{T_k}^{\left(4\right)}=F\left(X_{T_k}^{\left(4\right)}\right)$$

(18)

$$X_{T_k}^{\prime l}=ResAtten\left(up\left({X^{\prime }}_{T_k}^{\left(l+1\right)},X_{T_k}^l\right)\right) l=0,1,2,3$$

(19)

where $up\left(\cdot \right)$ represents the up-sampling transposed-convolutional operation. ${X^{\prime }}_{T_k}^{\left(l+1\right)}$ is the feature map of the previous layer in the decoder and $X_{T_k}^l$ is the feature map of the corresponding layer in the encoder.

3. Ground Truth Mask

The ground truth mask for each series is determined by the “illumination-friendly” threshold: a value of 1 for SVF > 0.75 and 0 otherwise. To effectively obtain the ground truth mask, we employ the keyframe method, selecting the middle slice of each series to balance accuracy and performance.

2.3.3. Loss Function

Compared with other types of U-Net, the 3STU-Net in this paper focuses on the fine extraction and segmentation ability of the polar illumination-friendly areas. While giving priority to optimizing the ability of global illumination extraction and segmentation, it also needs to take into account the ability to extract illumination information in local areas, boundary areas, and intersection areas. Therefore, it is necessary to consider the comprehensive optimization ability in these two aspects. Since the cross-entropy loss function mainly focuses on global optimization [66], and the Dice loss function focuses on local optimization [67], this paper adopts a hybrid loss function composed of the cross-entropy function and the Dice loss function to optimize the model.

The general formula for the hybrid loss ${\mathcal{L}}_{total}$ is

$${\mathcal{L}}_{total}=\alpha {\mathcal{L}}_{CE}+\left(1-\alpha \right){\mathcal{L}}_{Dice}$$

(20)

where ${\mathcal{L}}_{CE}$ is the cross-entropy loss, ${\mathcal{L}}_{Dice}$ is the Dice loss, and $\alpha$ is a hyperparameter used to balance the weights of two losses. The calculation for the cross-entropy loss is

$${\mathcal{L}}_{CE}=-{\displaystyle \frac{1}{N}}{\sum }_{i=1}^N{\sum }_{k=1}^2{y}_{i,k}\log \left(p_{i,k}\right) { y}_{i,k}\in \left\{0,1\right\}$$

(21)

where $y_{i,k}$ represents the one-hot encoding of the ground truth label for pixel $i$, which is the true illumination condition classification ($k=1$ for the illumination-friendly area, and $k=0$ for the illumination-unfriendly area). $p_{i,k}$ is the probability of the illumination condition classification predicted by the model and $N$ is the total number of pixels. The calculation for the Dice loss is

$${\mathcal{L}}_{Dice}=1-{\displaystyle \frac{2{\sum }_{k=1}^2{\sum }_{i=1}^N{y}_{i,k}\cdot p_{i,k}+ϵ}{{\sum }_{k=1}^2{\sum }_{i=1}^N\left(y_{i,k}{+p}_{i,k}\right)+ϵ}}$$

(22)

where $ϵ$ is a small constant used for numerical stability, and its main function is to avoid division by zero errors and illegal inputs in logarithmic operations.

2.3.4. Assessment

In this paper, the evaluation metrics for the model mainly include accuracy and mean intersection over union ($mIoU$). These two metrics are used to mainly reflect the performance of the model in the semantic segmentation of spatiotemporal characteristic illumination data.

Accuracy is a widely used metric for evaluating model performance. In classification tasks, it is used to measure the proportion of correctly predicted samples by the model in the total number of samples. The formula is

$$Accuracy={\displaystyle \frac{TP+TN}{TP+TN+FP+FN}}$$

(23)

Here, we consider the illumination-friendly condition as the positive class (P) and the illumination-unfriendly cases as the negative class (N). The meanings of the characters in Formula (23) are shown in Figure 7.

$IoU$ is a commonly used evaluation metric in semantic segmentation tasks, representing the degree of overlap between the predicted region and the ground-truth region. The formula is shown as (24), where $y_{i,c}$ represents the ground truth label for pixel $i$ and class $c$, while $q_{i,c}$ represents the predicted label for pixel $i$ and class $c$.

$${IoU}_c={\displaystyle \frac{Intersection\left(\mathrm{y},q\right)}{Union\left(\mathrm{y},q\right)}}={\displaystyle \frac{{\sum }_{i=1}{y}_{i,c}\cdot q_{i,c}+ϵ}{{\sum }_{i=1}{y}_{i,c}+{\sum }_{i=1}{q}_{i,c}-{\sum }_{i=1}{y}_{i,c}\cdot q_{i,c}+ϵ}} c\in \left\{0,1\right\}$$

(24)

$mIoU$ is the average value of $IoU$, representing the average of $IoU$s for all classes, as shown in Formula (25).

$$mIoU={\displaystyle \frac{1}{2}}{\sum }_{C=1}^2{IoU}_C$$

(25)

2.4. Sun-Synchronous Spatiotemporal A* Path-Planning Algorithm (3ST-A*)

2.4.1. A* and Spatiotemporal A* (ST-A*)

The A* path-planning algorithm is a heuristic search algorithm used to find the optimal path in grid-based maps. It comprehensively takes into account the actual cost from the starting point to the current point and the estimated cost from the current point to the target point. It guides the search direction through a heuristic function $f\left(n\right)$ and can efficiently find the shortest path or the optimal path from the starting point to the ending point by minimizing the $f\left(n\right)$ for each node in the path [68,69]. The formula of $f\left(n\right)$ is

$$f\left(n\right)=g\left(n\right)+h\left(n\right)$$

(26)

where $n$ represent the node for estimating, $g\left(n\right)$ is the actual cost from the starting node to node $n$ and $g\left(n_s\right)=0$ for start node, and $h\left(n\right)$ is the estimated cost from node $n$ to the target node, which is usually calculated using heuristic functions such as the Manhattan distance, Euclidean distance, etc.

Spatiotemporal A* or ST-A* is an extension of the A* path-planning algorithm. Based on the traditional A* algorithm that considers spatial information, it incorporates the time dimension, calculates costs by integrating spatial location and time factors, and is used to find the optimal path in a dynamically changing environment [53]. In addition to non-time-varying spatial factors such as slopes and obstacles, environmental factors like illumination change dynamically over time. Thus, the spatiotemporal map information faced during each step of path planning is different, and the planned path cannot be dynamically adjusted. This makes the traditional A* algorithm based on static spatiotemporal information unable to handle such problems. Currently, one of the main research directions of spatiotemporal A* is to improve the algorithm by introducing the time dimension and fusing non-variable and variable spatiotemporal data based on the traditional algorithm. However, it also faces research challenges such as low-resolution datasets and complex cost functions [53,54].

2.4.2. 3ST-A*

This paper supports research on the data preprocessing pipeline by implementing an enhanced ST-A* algorithm. Utilizing slope and dynamic illumination data on 1 km × 1 km polar grid maps, we propose the 3ST-A* (Sun-Synchronous Spatiotemporal A*) path-planning algorithm, characterized by a simple cost function derived from high-spatial-resolution data.

1.

Maps

This algorithm uses non-time-varying slope and time-varying illumination 2.5D grid-based maps in the same area, where slope or illumination data are appended vertically to the 2D coordinates. Let the slope map data be $S_{slope}$, and the illumination data be divided into time slice $F_{t_k}$ and time series $F_{T_k}$, where data are arranged in chronological order to form a data sequence. It denotes the node as $n$, the current point as $n_i$, the starting point as $n_s$, and the goal point as $n_g$.

For the time series $F_{T_k}$, in the case of no fusion processing of time series by 3STU-Net, we define that a single sample data $f_{T_k}$ is processed as the average of N time-slice data, that is

$$f_{{i,T}_k}={\displaystyle \frac{1}{N}}{\sum }_{i=0}^N{f}_{i,t_k}$$

(27)

The rule for generating its ground truth mask follows the same rules as the time-slice data by using the mean data.

2.

Fixed Path Route

Since the illumination data varies at each time point, the explored paths need to be fixed and recorded. In this algorithm, the open set is stored in the form of $(f\left(n_e\right),n_e)$. Beginning from the starting point, the algorithm extracts the node with the minimum cost $f\left(n_e\right)$ from the searched neighbor nodes and saves it into the closed set. Then, before searching for the next neighbor node, the open set is emptied, and the optimal neighbor node search is carried out. This ensures that the already planned nodes are only related to the current node, achieving the fixation of the planned route.

3.

Cost Function

For a neighbor node $n_e$ of the current node $n_i$ at each searching time, the cost function of 3ST-A* is to ensure that, through searching the minimum value of the heuristic function $f\left(n_e\right)$, while selecting nodes are illuminated and suitably sloped areas, the ability to search for the next node by using the Euclidean distance is retained. The formulas are

$$\left\{\begin{array}{c}f\left(n_e\right)=g\left(n_e\right)+h\left(n_e\right)\\ g\left(n_e\right)=g\left(n_i\right)+dis\left(n_i,n_e\right)\\ h\left(n_e\right)=dis\left(n_e,n_g\right)+h_{slope}\left(n_e\right)+h_{ill}(n_e,f_{{n_e,t}_k})/h_{ill}(n_e,f_{{n_e,T}_k}) \end{array}\right.$$

(28)

where $h\left(n_e\right)$ is the function that is mainly different from the original A* algorithm, which is composed of the estimated cost of the Euclidean distance $dis\left(n_e,n_g\right)$ from the neighbor node to the target node, the estimated slope cost of the neighbor node $h_{slope}\left(n_e\right)$, and the estimated illumination cost $h_{ill}(n_e,f_{{n_e,t}_k})/h_{ill}(n_e,f_{{n_e,T}_k})$. The value of $h_{slope}\left(n_e\right)$ is defined as follows:

$$h_{slope}\left(n_e\right)=\left\{\begin{array}{c}0 s_{n_e}<slope\_threshold\\ +\infty others\end{array}\right.$$

(29)

where the slope threshold in this algorithm is ${20}^{°}$. The value of $h_{ill}(n_e,f_{{n_e,t}_k})/h_{ill}(n_e,f_{{n_e,T}_k})$ is defined as follows:

$$h_{ill}(n_e,f_{{n_e,t}_k})/h_{ill}(n_e,f_{{n_e,T}_k})=\left\{\begin{array}{c}+\infty f_{{n_e,t}_k}/f_{{n_e,T}_k} is dark\\ 0 others\end{array}\right.$$

(30)

where the dark refers to the SVF $f_{{n_i,t}_k}/f_{{n_i,T}_k} ,$ and for the neighbor node, $n_e$ is 0. The $g\left(n_e\right)$ is the actual cost function, which is composed of the actual cost of the current node $g\left(n_i\right)$ and the actual cost of the Euclidean distance $dis\left(n_i,n_e\right)$ from the current node to the neighbor node.

Finally, we give the main process of the 3ST-A* algorithm in

Table 1. The implementation process of the 3ST-A* algorithm.

1.	Initialization
	Input: Region slope $S_{slope}$, Region illumination $F_{t_k}$/$F_{T_k}$, Start node $n_s$, Goal node $n_g$, Current node $n_i$, Current node slope $s_{n_i}$, Current node illumination $f_{{n_i,t}_k}$/$f_{{n_i,T}_k}$, Next chosen node illumination $f_{{n_j,t}_{k+1}}$/$f_{{n_j,T}_{k+1}}$
	Initialization: $OpenSet=\left\{n_s\right\}, ClosedSet=\mathrm{\varnothing }, h\left(n_s\right)=dis\left(n_s,n_g\right)+h_{slope}\left(n_s\right)+$$h_{ill}(n_s,f_{{n_s,t}_0})$/$h_{ill}(n_s,f_{{n_s,T}_0}), { g}_{n_s}=0$
2.	Node Search and Path Planning
	While True  If $n_i$ is $n_g$   Add $n_i$ into $ClosedSet$   Break and return planning path $ClosedSet$  If $f_{{n_i,t}_k}$/$f_{{n_i,T}_k}$ is not dark   Add $n_i$ into $ClosedSet$  Else   Rechoose a new non-dark node  Set $OpenSet=\mathrm{\varnothing }$  For each neighbor $n_e$ of neighbors at $n_i$   $g\left(n_e\right)=g\left(n_i\right)+dis\left(n_i,n_e\right)$   $h\left(n_e\right)=$$dis\left(n_e,n_g\right)+h_{slope}\left(n_e\right)+$$h_{ill}(n_e,f_{{n_e,t}_k})$/$h_{ill}(n_e,f_{{n_e,T}_k})$   $f\left(n_e\right)=g\left(n_e\right)+$$h\left(n_e\right)$   Add ${(f}_{n_e},$$n_e$) into $OpenSet$  If $OpenSet$ is empty   Region illumination $F_{t_k}$/$F_{T_k}⟵F_{t_{k+1}}$/$F_{T_{k+1}}$   $f_{{n_i,t}_k}$/$f_{{n_i,T}_k}⟵f_{{n_i,t}_{k+1}}$/$f_{{n_i,T}_{k+1}}$   Stay, continue and begin the next iteration  $n_i⟵$$argmin f\left(n_e\right) where (f\left(n_e\right) ,n_e)\in OpenSet$  Region illumination $F_{t_k}$/$F_{T_k}⟵F_{t_{k+1}}$/$F_{T_{k+1}}$ $f_{{n_i,t}_k}$/$f_{{n_i,T}_k}⟵f_{{n_j,t}_{k+1}}$/$f_{{n_j,T}_{k+1}}$
3.	End

.

4.

Assessment

This paper introduces two additional criteria for evaluating the algorithm: the number of illumination grid conditions (NoI) and the number of slope grid conditions (NoS). These criteria complement the existing metrics of steps and time required for path planning in the Sun-synchronous scenario. Detailed information is provided in

Table 2. Illumination and Slope grid condition assessment.

Illumination Grid Condition Assessment
	Dark	Weak	Bright
SVF Value Range	$f_{{n_i,t}_{k+1}}$/$f_{{n_i,T}_{k+1}}\le 0$	$0<f_{{n_i,t}_{k+1}}$/$f_{{n_i,T}_{k+1}}\le 0$.75	$f_{{n_i,t}_{k+1}}$/$f_{{n_i,T}_{k+1}}>0.75$
Slope Grid Condition Assessment
	Forbidden	Good
Slope Value Range	$s_{n_i}\ge {20}^{°}$	$s_{n_i}<{20}^{°}$

.

3. Experiment Setup

The experimental setup comprises two main components: 3STU-Net and 3ST-A*. We implemented all algorithms and pipeline modules using Python 3.10 and the PyTorch 2.6.0 library. Experiments were conducted on an Intel^® Arc™ Graphics GPU (XPU) with 18 GB of memory and 22 Intel^® Core™ Ultra CPUs.

3.1. 3STU-Net

The experimental section on the 3STU-Net focuses on model training and performance verification. We compare the 3STU-Net-1 model with the original U-Net and Attention U-Net. In contrast, the 3STU-Net-2 network processes 12 time-slice data simultaneously for feature fusion, complicating direct comparisons. To enable comparison, we calculate the average of every 12 time-slice data using Equation (27) as the input for both U-Net models. The dataset comprises three parts: 70% for training, 20% for validation, and 10% for testing, with all input data resized to 65 × 65. Detailed hyperparameters for the 3STU-Net model training are available in

Table 3. Hyperparameters for 3STU-Net.

Hyperparameter	Values
Learning Rate	1 × 10−4
Optimizer	Adam
Batch Size	8
Epochs	30~800
$\alpha$	0.3
$ϵ$	1 × 10−6

.

To optimize computing resource usage and facilitate comparison, we configured different hyperparameters for the original U-Net and Attention U-Net. Both models use a batch size of 4 and the cross-entropy loss function, employing the Adam optimizer with a learning rate of 0.0002.

3.2. 3ST-A*

This study focuses on various path-planning scenarios of 3ST-A*, using data derived from DEM and comparing results with and without 3STU-Net preprocessing. Details of the relevant experimental settings can be found in

Table 4. Experiment setting.

No.	${\mathit{n}}_{\mathit{s}}$	${\mathit{n}}_{\mathit{g}}$	A*	3ST-A*	Data Preprocessed Pipeline
					Time-Slice Data	3STU-Net-1 Preprocessed	Tim-Series Data	3STU-Net-2 Preprocessed
1	$a$	$b$	☑	☐	☑	☐	☐	☐
2	$a$	$b$	☑	☐	☐	☐	☑	☐
3	$a$	$b$	☐	☑	☑	☐	☐	☐
4	$a$	$b$	☐	☑	☑	☑	☐	☐
5	$a$	$b$	☐	☑	☐	☐	☑	☐
6	$a$	$b$	☐	☑	☐	☐	☑	☑
7	$c$	$d$	☐	☑	☑	☐	☐	☐
8	$c$	$d$	☐	☑	☑	☑	☐	☐
9	$c$	$d$	☐	☑	☐	☐	☑	☐
10	$c$	$d$	☐	☑	☐	☐	☑	☑

.

In Table 4, we examine two distinct groups of start and goal nodes, each containing 10 scenarios for comparison. The first group, illustrated in Figure 8a, spans a longer path from node a (the red dot) to node b (the green dot) and includes scenarios No. 1–6. The second group, shown in Figure 8b, focuses on a shorter path from node c to node d, incorporating scenarios No. 7–10. The data utilized in the preprocessing pipeline encompasses time-slice and time-series illumination data, including both 3STU-Net preprocessed and non-preprocessed data. Non-preprocessed time-series data are derived from the average of 12 time slices, while the preprocessed data originate from 3STU-Net-2. Due to slope condition limitations, an independent slope grid map of the same area was also incorporated into this experiment.

In this study’s context of global path planning, the rover’s motion model has been simplified to include four navigation directions, as discussed in detail in reference [55]. This simplification aids in understanding the planning process and enhances the overall effectiveness of the navigation strategy.

4. Results and Discussion

4.1. 3STU-Net Learning Results

Figure 9, Figure 10 and Figure 11 display the learning curves for 3STU-Net-1, 3STU-Net-2, U-Net, and Attention U-Net, illustrating training and validation losses. The blue line indicates training loss, while the orange line shows validation loss. The curves converge after several epochs, indicating the model’s readiness for comparative analysis despite limited lunar south pole lighting data.

The test results for 3STU-Net-1, 3STU-Net-2, U-Net, and Attention U-Net were evaluated on independent testing datasets, focusing primarily on accuracy. The extracted results are summarized in

Table 5. Extraction evaluation values of 3STU-Net-1, 3STU-Net-2, U-Net, and Attention U-Net.

	Time-Slice Dataset		Time-Series Dataset (Time-Series Data Input)		Time-Series Dataset (Mean Data Input)
	Accuracy	$\mathit{m}\mathit{I}\mathit{o}\mathit{U}$	Accuracy	$\mathit{m}\mathit{I}\mathit{o}\mathit{U}$	Accuracy	$\mathit{m}\mathit{I}\mathit{o}\mathit{U}$
3STU-Net-1	95.01	87.18	-	-	-	-
3STU-Net-2	-	-	96.43	91.83	-	-
U-Net	94.89	86.87	-	-	94.99	89.94
Attention U-Net	94.80	86.67	-	-	94.90	89.75

.

The results in Table 5 demonstrate that the 3STU-Net significantly enhances accuracy and mIoU for both sub-networks. The 3STU-Net-1 achieved 95.01% accuracy and 87.18% mIoU, surpassing the original U-Net by 0.12% and 0.31%, respectively, and improving by 0.21% and 0.51% over Attention U-Net. For 3STU-Net-2, which processes 12 temporal time-slice data simultaneously, accuracy reached 96.44% and mIoU 91.85%. In contrast, U-Net yielded 94.99% accuracy and 89.94% mIoU, while Attention U-Net recorded 94.90% accuracy and 89.84% mIoU using averaged data. Despite different data processing methods and architectures, the model’s performance with time-series data outperformed that of time-slice data, highlighting that feature fusion from multiple slices is more effective for model segmentation.

Figure 12 and Figure 13 show the comparison of results proceed by two groups: one contains the data proceed by 3STU-Net-1, U-Net, and Attention U-Net with the same input data and ground truth mask, the other contains 3STU-Net-2, U-Net, and Attention U-Net with time-series data as the input, and keyframe as the ground truth mask for 3STU-Net-2 and the mean value of the same time-series for U-Net and Attention U-Net. The subfigures with a green color shown in Figure 12 and Figure 13 were an overlay of the proceeding data marked as green and the original input data as the base background to showcase the comparison of difference between them. The comparison shows different models’ performance in marking illumination-friendly areas: In Figure 12, the green area indicates the illumination-friendly zone identified by the 3STU-Net-1 model, while the raw input data shows various illumination conditions; Figure 13 demonstrates that the 3STU-Net-2 network can directly extract illumination-friendly areas using time-series data, whereas U-Net and Attention U-Net rely on pre-calculated mean values. While 3STU-Net demonstrates superior edge detail, 3STU-Net-2 introduces a novel approach for multi-slice data fusion. However, the model struggles with extracting complex lighting areas, indicating a need for further research to improve segmentation capabilities.

4.2. 3ST-A* Path Planning Results and Comparation

The results of the path-planning algorithm experiments, as detailed in Table 4, were carried out. The route curves are shown in Figure 14, the snapshots of key time points for path planning for scenario No. 4 are shown in Figure 15 and the related data are displayed in

Table 6. Experiment result for path planning in different scenarios.

No.	${\mathit{n}}_{\mathit{s}}$	${\mathit{n}}_{\mathit{g}}$	AG 1	SG 2	Total Steps	Planning Time (s)	NoI			NoS		Stay
							Dark	Weak	Bright	Forbidden	Good
1	a	b	A*	-	104	23	20	23	61	0	104	0
2	a	b	A*	-	104	24	24	19	61	0	104	0
3	a	b	3ST-A*	-	147	34	0	53	87 + 7R 3	0	147	1
4	a	b	3ST-A*	3STU-Net-1	522	119	0	0	522	0	522	0
5	a	b	3ST-A*	-	148	27	0	61	80 + 7R	0	148	28
6	a	b	3ST-A*	3STU-Net-2	508	126	0	0	508	0	508	0
7	c	d	3ST-A*	-	62	11	0	3	59	0	62	0
8	c	d	3ST-A*	3STU-Net-1	62	16	0	0	62	0	62	0
9	c	d	3ST-A*	-	62	11	0	4	58	0	62	0
10	c	d	3ST-A*	3STU-Net-2	62	14	0	0	62	0	62	0

¹ AG: Algorithm. ² SG: Segmentation operation model. ³ R: Rechoosing a new non-dark node.

.

The visualizations of path-planning algorithms in Figure 14 depict the route status at the last time point. The green tile indicates the state node, the red tile indicates the goal node, and the blue line indicates the planned route trace. The time-slice data, labeled with serialized numbers, derives from either original datasets or those preprocessed using the 3STU-Net-1 model. Meanwhile, time-series data comes from original datasets calculated through Equation (27) or preprocessed with the 3STU-Net-2 model. All algorithms successfully plan a route between the start and goal nodes, with differences in planned steps and areas traversed, such as dark, weak-light, and bright zones. In scenarios using original image data (Nos. 1, 2, 3, 5, 7, 9), various lighting conditions are represented. Conversely, in cases with segmented data (Nos. 4, 6, 8, 10), only areas with an SVF above 0.75 are marked as illuminated. As shown in Table 6, the original A* algorithm (Nos. 1, 2) offers the shortest path but passes through dark and weak-light areas, failing to meet Sun-synchronous path planning requirements. The 3ST-A* algorithm effectively avoids dark areas. In unsegmented data scenarios, traces may pass through dark and weak-light areas, necessitating replanning using the 3ST-A* rechoosing approach (Nos. 3 and 5).

In Figure 15, there are four snapshots of the path planning of No. 4 in Table 4 by using the 3ST-A* with the 3STU-Net-1 model preprocessed time-slice data. From the figures, we can see that all the planned routes at each time point can ensure the rover moves in a friendly illumination condition, which is dynamically changing at every time point.

Comparing path-planning algorithms reveals that the 3STU-Net-2 fused time-series data processing effectively avoids stagnation and bypasses weak lighting areas (Nos. 5, 6, 9, 10). The mean processing of original time-slice data suffers from significant blighting data accuracy loss. In long-distance path planning (Nos. 4 and 6), the number of steps increases due to the segmentation process, which imposes additional restrictions and reduces available planning data. However, this method ensures that the selected lighting areas meet the requirements for Sun-synchronous path planning.

4.3. Discussion

An automated data preprocessing pipeline for 2.5D data significantly enhances Sun-synchronous path planning research in polar regions. The 3STU-Net network improves fine-grained segmentation for sequential time-slice data. In contrast, the original U-Net and Attention U-Net networks fail to adequately address temporal details, resulting in poor scenario adaptation and edge segmentation under complex illumination. Consequently, these models often depend on mean input time-series data, distorting information and increasing manual processing workload.

In this study, we demonstrate that the 3ST-A* algorithm facilitates dynamic path planning, allowing the rover to navigate illuminated areas effectively. By utilizing the 3STU-Net for data segmentation, the planned path remains within optimal lighting zones. Furthermore, the proposed segmentation algorithm improves path-planning accuracy through the integration of fused time-series data. The Sun-synchronous path-planning algorithm introduces additional selection constraints, extending beyond the original Euclidean distance requirement, which results in a slight increase in path steps. In the context of the flat study area, the slopes of paths from all algorithms, including the original A*, satisfy the requirements. Due to the rover motion mode in this study, the planned routes shown in Figure 14 and Figure 15 have broken lines. However, considering the actual speed of the rover, the global path planning described in this paper is first carried out rapidly based on the illumination conditions for Sun-synchronous path planning, which guides the rover in selecting the navigation direction in dynamic scenarios, providing a fast, cost-effective solution for adapting to complex changes by using 3STU-Net models and 3ST-A*. After the rover completes the local path planning in reality and travels according to the global path, new global path planning can be carried out promptly and an evaluation basis can be provided. Therefore, the single broken line has certain practical significance within the scale of 20 m/pixel resolution when it comes to providing the choice of driving direction and the main path. Certainly, future research should explore the possibility of extending path planning to cover eight or more moving directions to better meet the requirements of practical tasks.

Our methods, models, and algorithms significantly contribute to Sun-synchronous path planning, particularly in complex lighting conditions. However, the segmentation processing model needs further training to improve generalization for intricate texture features, given the limited polar region data. The enhanced A*-based path-planning algorithm relies on the cost function for identifying feasible regions, highlighting the necessity for expert input and refinement of hard coding techniques. Furthermore, adapting to changing environmental conditions for real-time path planning is crucial. Future research will focus on leveraging data preprocessing to advance learning-based Sun-synchronous path planning.

5. Conclusions

This paper investigates dynamic spatiotemporal data preprocessing for Sun-synchronous path planning in the Lunar polar regions. It presents a workflow for data preprocessing and introduces a pipeline model that standardizes spatiotemporal data processing. Central to this model is an enhanced U-Net network, 3STU-Net, designed for segmentation and classification of Sun-synchronous time-slice and time-series data. Additionally, the processed data enhanced the 3ST-A* path algorithm, improving its complexity, accuracy, and usability in path planning.

In the pipeline, the 3STU-Net facilitates fine-grained segmentation of friendly lighting areas. Key conclusions include the following:

(1)

A residual module enhances feature extraction for time-slice data through a channel attention mechanism.

(2)

Twelve consecutive time slices are used for time-series data, employing a residual attention module that combines a temporal attention block and spatiotemporal fusion block to minimize accuracy loss.

(3)

Performance in edge regions has improved compared to the original U-Net and Attention U-Net.

The 3ST-A* algorithm uses dynamic lighting data to create a cost function that enhances the Sun-synchronous A* path-planning algorithm.

(1)

The algorithm integrates dynamic lighting and slope data as constraints in the heuristic function, limiting optimal conditions at each step.

(2)

Resetting the open set fixes the planned path, adapting to real-world lighting changes in polar regions and enhancing the algorithm’s practical value.

(3)

A comparison of the path-planning results between using the original data and the data segmented by 3STU-Net shows that the segmented data can ensure that each step of the planned path can obtain adequate sunlight.

This paper explores a data preprocessing pipeline model that, alongside the 3STU-Net and 3ST-A* path-planning algorithms, establishes a solid foundation for advancing research in Sun-synchronous path planning. As calculation data volume increases, the model’s generalization ability improves, thereby enhancing support for exploration activities in dynamic spatiotemporal environments of polar regions.