Hyperspectral Image Segmentation for Optimal Satellite Operations: In-Orbit Deployment of 1D-CNN

Abstract

AI on spaceborne platforms optimizes operations and increases automation, crucial for satellites with limited downlink capacity. It can ensure that only valuable information is transmitted, minimizing resources spent on unnecessary data, which is especially important in hyperspectral Earth Observation missions, producing large data volumes. Our previous work showed that the 1D-CNN, 1D-Justo-LiuNet, outperformed 2D-CNNs and Vision Transformers for hyperspectral segmentation with an accuracy of 0.93 and 4563 parameters, making our model the best choice for in-orbit deployment. While the state of the art has deployed 1D-CNNs on low-power platforms, such as Unmanned Aerial Vehicles, they have still not been deployed in space before. In this work, we mark the first deployment and testing of a 1D-CNN in a satellite. We implement a C version of the 1D-Justo-LiuNet and, after ground validation, we deploy it on board the HYPSO-1 satellite. We demonstrate in-flight segmentation of hyperspectral images via the 1D-CNN to classify pixels into sea, land, and cloud categories. We show how in-orbit segmentation improves satellite operations, increases automation, and optimizes downlink. We give examples of how in-orbit segmentation addresses mission challenges in HYPSO-1, such as incomplete data reception, incorrect satellite pointing, and cloud cover, helping to decide whether to transmit or discard data on board. An additional CNN autonomously interprets the segmented images, enabling on-board decisions on data downlink.

1. Introduction

1.1. Literature Review: Deep Learning for Hyperspectral Imaging Missions

Data science plays a crucial role in the current Big Data era and the AI revolution, where massive volumes of data are continuously generated [1]. It offers data-driven optimization across various industries, such as healthcare, finance, and space. Earth Observation (EO) satellites, which may generate vast amounts of data, can benefit from edge inference. In this context, edge inference refers to Machine Learning models making predictions directly on board the satellite, optimizing operations and automating its decision-making. This is particularly important for satellites equipped with hyperspectral (HS) instruments, generating large data cubes. The interest in HS technology lies in its ability to capture hundreds of wavelengths per image pixel, enabling more detailed target characterization beyond conventional RGB and multispectral (MS) imagery. Its potential for HS missions was first demonstrated in 2000, when the National Aeronautics and Space Administration (NASA) launched the first HS satellite, Earth Observing-1 (EO-1) [2]. The ongoing significance of HS missions is evident from the numerous current and planned missions. Current HS missions include the $Phi$-sat program from the European Space Agency (ESA) [3], PRecursore IperSpettrale della Missione Applicativa (PRISMA) from the Italian Space Agency (ASI) [4], the Environmental Mapping and Analysis Program (EnMAP) from the German Aerospace Center (DLR) [5], the Plankton, Aerosol, Cloud, ocean Ecosystem (PACE) from NASA [6], and the HYPerspectral small Satellite for Ocean observation (HYPSO) from the Norwegian University of Science and Technology (NTNU) [7], with HYPSO-1 launched in 2022 [8] and HYPSO-2 recently in 2024. Future HS missions include the Copernicus Hyperspectral Imaging Mission for the Environment (CHIME) from ESA [9], NASA’s Geosynchronous Littoral Imaging and Monitoring Radiometer (GLIMR) [10], and Surface Biology and Geology (SBG) [11]. However, despite the potential and clear interest in this technology, HS imagery has a major drawback: the substantial data volume of each image, leading to considerable processing challenges [12], is also affected by the limited computational resources on board satellites [13,14,15,16]. Furthermore, the large data output makes the downlink channel to Earth a critical bottleneck for satellites, as bandwidth is often limited [15,17,18], making efficient resource management essential. To address this, AI deployment on satellites has been explored to autonomously process data and optimize bandwidth by transmitting only essential information, while filtering out cloudy images or pixels [19,20]. In 2021, ESA reached a significant milestone by deploying the first on-board deep neural network for EO, the 2D Convolutional Neural Network (CNN) CloudScout, on the Φ-Sat-1 satellite, to detect clouds [21]. The detection was achieved through semantic segmentation [22], where each image pixel was classified into a binary category for the presence of clouds. Cloud detection is vital for optical remote sensing, as cloud cover can obscure target areas [23]. Since then, CloudScout’s performance has been studied and optimized across various hardware platforms, including Field-Programmable Gate Arrays (FPGAs) [24]. CloudScout’s milestone was significant not only because it marked the first deployment of deep learning in space, but also for overcoming the inference challenges induced by the complex physical conditions in space, including noise and diverse atmospheric disturbances [12], making the successful deployment even more remarkable.

1.2. Literature Review: 2D-CNNs

The literature highlights deep learning CNNs as a promising technique for on-board data analysis [12], outperforming Support Vector Machines (SVMs) with linear and radial basis function kernels [25]. CNNs, particularly 2D-CNNs, have been extensively studied and tested on the ground for future deployment on board satellites. Efforts have focused on prototyping 2D-CNN models for applications such as on-board detection of volcanic eruptions in MS imagery [26] and real-time change detection in RGB and MS data to improve response times for natural disasters such as floods and earthquakes [18], among other applications where on-board processing is key to accelerating decision-making. The potential of on-board processing is so significant that it may also enable autonomous ground-based responses. Furthermore, the use of 2D-CNNs has also been wide in traditional satellite domains using Synthetic Aperture Radar (SAR) imagery. Examples include oil spill detection [27], ship detection [13], and plane detection from space [14], based on lightweight MobileNets [28,29]. The 2D-CNNs have also been applied to regular RGB imagery for ship detection, utilizing ResNet architectures [30]. These are only a few examples showing the potential of 2D-CNNs in satellite imagery.

1.3. Literature Review: 1D-CNNs vs. 2D-CNNs

The 2D-CNNs generate predictions by using both spatial and spectral context. While 2D-CNNs dominate the state of the art of HS segmentation, 1D-CNNs have also been explored for HS applications, focusing solely on the spectral domain, similarly to time-series classification [31]. Kalomoiris et al. investigated a CNN with approximately 22 million parameters, aiming to reduce computational complexity by using a 1D-CNN for spectroscopic data [17], collected from satellite-based imaging sensors to estimate galaxy redshift [32], while running their experiments on an on-ground FPGA. Nalepa et al. conducted on-ground experiments using 1D-CNN, 2.5D-CNN, and 3D-CNN architectures for segmentation on four conventional HS datasets (Indian Pines, Salinas, Pavia University, and University of Houston) [12]. With limited training data (around 2 million pixels), the authors simulated atmospheric disturbances over Poland to improve model generalization, an important approach for small training sets [33]. Their results showed that the 1D-CNN consistently outperformed 2.5D- and 3D-CNNs for all performance metrics, achieving an average accuracy of 0.69 across datasets [12]. Furthermore, promising results have also been achieved for land cover classification using 1D-CNNs on MS imagery, with a peak accuracy of 0.927, tested on a small set of 50,000 pixels captured by an MS sensor, aimed at future in-orbit deployment [34]. Other authors have proposed networks such as ScannerNet [35] for on-board segmentation, combining 1D-CNN and LSTM architectures. This approach is particularly suited for push-broom sensors, being less computationally intensive and more memory-efficient, while demonstrating competitive accuracy on MS and thermal infrared data from the Landsat 8 mission, compared to the most compact versions of 2D-CUNet++ [36]. Subsequent works have tested on ground CHLNET, a model using a 1D-CNN architecture followed by support vector regression (SVR) to predict chlorophyll-A concentration from ocean surface reflectance across a few broad bands [37]. Other works have tested 1D-CNNs for detecting anomalies in one-dimensional satellite telemetry data [38], where the 1D-CNN-based model outperformed transformers, LSTMs, and other deep models. Additionally, further experiments with 1D-CNNs in the HS domain have been conducted in the literature. Furthermore, our previous work [39] conducted multiple experiments with 1D-CNNs applied to the HS domain, whose conclusions are summarized in the next section.

1.4. Literature Review: The 1D-CNN 1D-Justo-LiuNet

Our previous work, “Semantic Segmentation in Satellite Hyperspectral Imagery by Deep Learning”, published in [39], trained and tested 20 models for multiclass segmentation in HS imagery. The models under comparison were selected due to their potential for deployment on board satellites. Beyond conventional Machine Learning (ML) models, the comparison additionally included 1D-CNNs and 2D-CNNs. Given the potential of transformers for large-scale segmentation [40], our work also included the latest Vision Transformers (ViTs) in the field.

Table 1. Comparative metrics for segmentation models tested on data from the HYPSO-1 satellite [39].

Model	Accuracy	Model Size	Inference Time [ms]
1D-ML/SGD	0.91	-	72
1D-ML/NB	0.71	-	1234
1D-ML/LDA	0.89	-	190
1D-ML/QDA	0.89	-	2024
1D-Justo-LiuNet	0.93	4563	166
1D-Justo-HuNet	0.91	9543	69
1D-Justo-LucasCNN	0.91	25,323	142
2D-NU-Net-mod	0.80	32,340	364
2D-NU-Net	0.81	40,332	374
2D-CUNet	0.72	67,299	272
2D-CUNet++	0.83	24,619	294
2D-CUNet Reduced	0.76	22,019	270
2D-CUNet++ Reduced	0.90	12,379	294
2D-UNet FAUBAI	0.88	26,534,211	462
2D-UNet FAUBAI Reduced	0.85	1,956,835	388
2D-Justo-UNet-Simple	0.92	7641	318
FastViT-T8	0.82	5,033,795	132
FastViT-S12	0.90	10,242,819	156
FastViT-MA36	0.88	44,647,755	288

provides a summary of the results for the models, including accuracy, model size (number of parameters), and inference time. We proposed a lightweight 1D-CNN model, 1D-Justo-LiuNet, which proved to outperform state-of-the-art models in the HSI domain. As shown in the table 1D-Justo-LiuNet exceeded the performance of 2D-CNN UNets and outperformed Apple’s 2023 Fast Vision Transformers (FastViTs), designed for lightweight mobile inference [41]. In particular, 1D-Justo-LiuNet achieved the highest accuracy (0.93) with the smallest model size (4563 parameters) among all the tested models. The 1D-Justo-LiuNet has the highest accuracy while maintaining an optimal balance of model complexity and inference time for in-orbit deployment. With an inference time of 166 ms, faster than 2D-CNNs and comparable to FastViT-T8’s 132 ms as shown in Table 1, 1D-Justo-LiuNet uses over 1000 times fewer parameters and still achieves over 13% higher accuracy compared to the lightest version of FastViTs (T8).

Unlike 2D-CNNs and ViTs, which encode both spectral and spatial information, 1D-Justo-LiuNet focuses solely on the rich spectral features in HS data.

These findings were validated across different satellite datasets, with the HYPSO-1 mission serving as the primary case study for sea, land, and cloud segmentation. Our tests included multiple real images across different and diverse geographical locations around the Earth, without needing simulated acquisition conditions. We confirmed the same conclusions through generalization tests on other hyperspectral missions, such as NASA’s EO-1. The results are summarized in

Table 2. Comparative metrics comparing 1D-Justo-LiuNet with a 2D-CNN on data from NASA’s EO-1 satellite for generalization [39].

Model	Accuracy	F1 Score
1D-Justo-LiuNet	0.82	0.97
nnU-net 2D	0.81	0.87
2D-Justo-UNet-Simple	0.70	0.81
1D-Justo-LiuNet	0.74	0.85
nnU-net 2D	0.80	0.85
2D-Justo-UNet-Simple	0.72	0.86
1D-Justo-LiuNet	0.64	0.76
nnU-net 2D	0.77	0.86
2D-Justo-UNet-Simple	0.57	0.88

.

Based on its superior performance and compact size, we concluded that 1D-Justo-LiuNet was highly suitable and strongly recommended for in-orbit deployment, providing an effective solution for optimizing and automating satellite operations at edge. Our conclusions have also been highlighted in recent reviews by ESA [42]. Additional information on comparative metrics are summarized in Tables II-VI in our previous article, detailing our experiments [39].

Building on our recommendation in [39] to implement the 1D-Justo-LiuNet model in space, this article continues the progress by deploying the model in orbit. While the objective of our earlier article focused on training models to identify the most suitable configurations, the emphasis of this article shifts to in-orbit model inference utilizing the trained parameters from our previous work. Furthermore, beyond in-orbit inference, this article also demonstrates its advantages with multiple examples.

1.5. Literature Review: 1D-CNNs for Resource-Limited Platforms

The literature shows that 1D-CNNs have been deployed in, for example, Unmanned Aerial Vehicles (UAVs), such as drones, as 1D-CNNs also suit these resource-limited platforms. In this domain, 1D-CNNs have been widely used for GPS spoofing detection, identifying attacks that emit fake GPS signals to deceive the GPS receiver in UAVs [43,44]. The 1D-CNNs have also been explored for predicting droplet deposition during UAV pesticide spraying [45], among other UAV applications. Furthermore, the work of Sung et al. [25] is the first to successfully test 1D-CNNs on board UAVs for GPS spoofing detection in a real drone environment. The literature review suggests that 1D-CNNs hold promising potential for deployment on resource-limited on-board platforms, as demonstrated by studies on UAVs.

1.6. Novelty and Scientific Contributions

Many works have studied the viability and optimization of CNNs in imagery, especially 2D-CNNs, for future in-orbit deployment. Unlike articles consisting of mere on-ground studies, this paper concentrates on a real final deployment in space. Few works have achieved actual deployment, such as ESA’s 2D-CNN CloudScout on the Φ-Sat-1 satellite [21]. To the best of our knowledge, beyond the existing literature on UAVs, no 1D-CNN has been deployed on space satellites at the time of writing. This work is the first to deploy and test a 1D-CNN in a satellite in orbit, marking the novelty of our contribution and advancing further the current state of the art.

As part of our scientific contribution, the deployed 1D-CNN offers the advantage of low computational complexity, even when implemented using relatively simple C-code on board, compared to more advanced platforms such as FPGAs. Additionally, the findings suggest that an FPGA implementation of multiply-accumulate operations in deep convolutional layers could further enhance performance at the cost of increased implementation complexity. Our contribution also includes extensive examples demonstrating that on-board segmentation enhances current satellite operations and automation, resulting in benefits such as more efficient use of downlink capacity and reduced data latency while allowing on-ground georeferencing. We illustrate this with real scenarios, such as the handling of incomplete data captures, examples where the satellite points to space or to the wrong Earth location, and conditions like high cloud coverage or overexposure. In all cases, we find segmentation to be crucial to improve operational efficiency. It enables in-orbit segregation of relevant and non-relevant data to optimize downlink, and support on-ground georeferencing, even when raw data are not received.

1.7. Article’s Structure

In Section 2, we present the system architecture of the On-Board Processing Unit, where the 1D-CNN 1D-Justo-LiuNet is integrated for image segmentation in space. Section 3 details our methodology,

We begin Section 3.1 with an overview of the 1D-CNN architecture, including 1D convolutions and pooling layers for feature extraction, followed by a final classification layer. We provide further details on the data flow through the network’s layers in Section 3.2. Section 3.3, Section 3.4, Section 3.5, Section 3.6 and Section 3.7 cover the high-level functionality and implementation details of the network layers, followed by a summary of our testing and verification strategy in Section 3.8. In Section 4.1, we discuss example scenarios, where satellite operations benefit from on-board segmented images. We propose various decision-making approaches to either discard unimportant data or downlink meaningful information. We propose approaches from Ground-Based Segment Inspection requiring human intervention (Section 4.2) to fully autonomous on-board interpretation (Section 4.3). The latter includes simple class proportion analysis (Section 4.3.1) and a more advanced method (Section 4.3.2), where a new CNN model is trained and tested to interpret segmented images in space. We provide a case example where the CNN detects satellite mispointing based on the inferred segmented images. In Section 4.4, we discuss data products and compression techniques, such as Compressive Sensing [46], that may benefit from the segmented images. Section 5 presents our results, demonstrating successful segmentation of HS imagery across multiple geographical locations captured from space, and how these results enhance satellite operations. We also show results from the additional CNN trained for the autonomous on-board interpretation of segmented images, provide brief Explainable AI insights to explain model predictions, and conduct a timing analysis for future FPGA acceleration. Section 6 concludes our work.

2. System Architecture

Before presenting the implementation of 1D-Justo-LiuNet, we provide an overview of HYPSO-1’s system architecture in flight, where our model is deployed. The satellite’s subsystems are extensively detailed in the current state of the art [7,8]. Thus, we next highlight only the relevant aspects from Langer et al. [47]. We consider that this architecture is representative of current in-orbit processing systems, making our results broadly applicable.

To begin, the processing pipeline includes a hardware stage for data captures, followed by a software for data processing. Langer et al. refer to a Minimal On-Board Image Processing (MOBIP) pipeline for the basic processing steps at launch. Post-launch, this pipeline is updated with additional processing during flight [47]. In Figure 1, we provide an overview of the satellite’s system architecture showing only what is most relevant to this work. Namely, the HS camera captures in (1) an image using a push-broom technique, scanning line frames as the satellite orbits. Subsequent lines form an image with spatial dimensions $L\times S$, each pixel containing B bands, resulting in a 3D data cube with dimensions $L\times S\times B$. The data are serialized as a Band Interleaved by Pixel (BIP) stream and sent to the On-Board Processing Unit (OPU). The OPU, built with Commercial-off-the-Shelf (COTS) components, consists of a Zynq-7030 System-on-Chip (SoC) with a dual-core ARM Cortex-A9 CPU processor and a Kintex-7 FPGA [48]. As seen in Figure 1, after streaming the data, step (2) involves binning it on the CPU, where pixels are grouped into intervals (bins) and replaced by a representative value [47]. While this reduces resolution, Langer et al. note benefits such as compression and improved SNR. Furthermore, in step (3), the binned data cube is stored on a microSD card. In addition, data are loaded in (4) into a RAM memory for CPU processing. In step (5), data processing begins in a submodule named pipeline applications in [47]. This is where we integrate, in this work, 1D-Justo-LiuNet to demonstrate inference at the edge. This will be further described throughout this article. As opposed to the pipeline described by Langer et al., our pipeline implementation has been modified to increase maintainability and ease of use. Instead of a single C program, the pipeline has been split up into individual programs, one for each module, such that they can be executed individually. This reduces time spent in testing and integration. The modules are then run in the pipeline sequence using a Linux shell script.

In addition to 1D-Justo-LiuNet, other modules include smile and keystone HS data cube correction, a linear SVM [49], spatial pixel subsampling [47], and an image composition module from three bands of the data cube. Furthermore, the FPGA in (6) supports additional processing, achieving lower latency and power consumption. Through a Direct Memory Access (DMA) module, the FPGA directly accesses RAM, allowing faster memory reads and writes, bypassing the CPU. This approach enables the FPGA implementation to perform lossless compression CCSDS-123v1. The compression ratios vary depending on the content, such as cloudy images allowing for more compression. This can reduce the cube size to approximately 40-80 MB. Additionally, near-lossless compression CCSDS-123v2 has been recently tested in [50] for future nominal operations. On the CPU, the segmented images by 1D-Justo-LiuNet are also compressed and packaged together with the data cube into one single file and stored in the SD card. At this stage, the OPU enters an idle state to be powered off and save energy [47]. When the satellite has Line-of-Sight (LoS) with a ground station, and the payload is powered to stream the compressed segmented image first, followed by the HS raw data cube, to a Payload Controller’s (PC) buffer in (7) with a limited capacity up to two HS data cubes. Data throughput to the PC is slow (about 280 kbps) via a CAN bus, but the PC sends the buffered data to the S-band radio transmitter at a significantly higher throughput of 5 Mbps using an UART interface, which is higher than the S-band throughput. This is done to ensure we maximize the S-band utilization instead of being limited by the CAN-bus. When the satellite has LoS with a ground station, the data temporarily stored on the PC’s buffer are transmitted to the ground station through the S-band radio at 1 Mbps throughput.

For HYPSO-1, a standard capture involves image acquisition and data transfer, with acquisition preceding transfer but not necessarily running consecutively. Other captures can occur between these steps. Image acquisition includes preparation, capture, and data compression. The 1D-Justo-LiuNet is added as a step between acquisition and compression. If another capture is planned immediately after the first, segmentation may be skipped or manually disabled, as automation for this scenario is not yet in place.

When integrating the 1D-Justo-LiuNet on the OPU, we store the program along with files such as model parameters, all within a single directory. A bash script then triggers the program to process newly acquired images. In our setup, inference prior to compression can be enabled or disabled from the ground via scheduling software. To prevent interference with other on-board processes, the scheduling software allocates sufficient time for segmentation and related data handling. Once the segmentation is complete, the output image is packed into a compressed tarball to reduce its size.

3. Methodology

3.1. Deep Learning Model: 1D-Justo-LiuNet

Figure 2 shows the 1D-CNN architecture of the lightweight 1D-Justo-LiuNet trained in our previous work [39], where we increased the kernel size to capture patterns within a larger receptive field, with more spectral bands. Larger kernels allowed us to reduce the total number of kernels, thereby reducing overall model size while preserving accuracy. We demonstrated that 1D-Justo-LiuNet outperformed state-of-the-art 2D-CNNs for on-board segmentation [39]. Furthermore, we also proved that our 1D-CNN outperformed the novel Fast Vision Transformers (FastViTs) proposed in 2023 by Apple [41] for computer vision tasks, including image segmentation. In the following sections, we describe how features are automatically extracted from the data for 1D-Justo-LiuNet prior to classification, and detail our implementation of the network using low-level programming in C. We emphasize that the detailed explanation of the 1D-CNN layers in the subsequent sections is given to serve as a foundation for future FPGA design, optimizing power consumption on board the satellite. Register Transfer Level (RTL) for FPGA design demands a careful and rigorous low-level analysis.

3.1.1. Network Interface

In the CNN architecture in Figure 2, the input is a spectral signature of a single pixel in the HS image, denoted as $x\left[\lambda \right]$, where the network outputs class probabilities, $p\left[c\right]$, indicate the likelihood of the signature belonging to each class. Following terminology and notation from digital signal processing, we refer to each entry in $x\left[\lambda \right]$ as a sample and to the entire series as a sequence. We use the same terms for $p\left[c\right]$ and all sequences in this work.

3.1.2. Overview of Feature Extraction and Classification

The network architecture shown in Figure 2 performs feature extraction followed by feature classification. The first processing stage consists of a 1D convolutional layer to identify basic patterns within the spectral samples in $x\left[\lambda \right]$. Unlike 2D convolution, 1D convolution focuses solely on spectral context, reducing the number of model parameters and complexity. The figure shows that the first layer employs six kernels. Each kernel slides over the input sequence to detect a different pattern, producing a characteristic output 1D sequence known as a feature map. The remaining convolutional layers in the figure function similarly, but they gradually add more kernels from 6 to 24, detecting increasingly complex and higher-level abstract patterns. This also results in a greater number of feature maps. To handle this growing complexity, intermediate pooling layers are applied after convolutional layers to reduce the size of the feature maps. In Figure 2, pooling layers consistently halve the length of feature maps with a pooling factor of $F=2$, by preserving key features while discarding less important ones through max-pooling. This additionally ensures invariant feature representations, less sensitive to minor input changes. Furthermore, Figure 2 shows that the 4th deepest level of feature extraction contains only 24 kernels. This spans a highly compressed 48-dimensional latent space, encoding only the most essential features of the input data in $x\left[\lambda \right]$ for our sea–land–cloud segmentation task. We will explain later why this feature space is 48-dimensional. Finally, Figure 2 shows that, after extraction, the feature space is flattened and passed through a final dense layer for classification. This output layer estimates the probabilities that the features correspond to one of three classes: sea, land, or clouds, where the class with the highest probability is selected as the final categorical prediction.

3.2. Analysis of Data Sequences and Flow in 1D-Justo-LiuNet

Before detailing the layers, functionality, and implementation,

Table 3. Notation and descriptions of sequences in 1D-Justo-LiuNet.

NOTATION	DESCRIPTION OF THE SEQUENCE
NETWORK’S INPUT
$x\left[\lambda \right]$	Image pixel to be classified, represented by its spectral signature along wavelengths $\lambda$. In this work, each pixel comprises $\Lambda =112$ spectral bands.
CONVOLUTIONS FOR FEATURE EXTRACTION
$w_X[n_X,n_{(X-1)},k]$	Weight parameters of the $N_X$ kernels in the convolution layer at level X. Each 2D kernel consists of $N_{(X-1)}$ components across the K dimension. The number of kernel components, $N_{(X-1)}$, corresponds to the number of kernels used in the convolution at the previous level $X-1$. Since it is common to use multiple kernels at previous levels, the convolution at level X also demands kernels with multiple components, i.e., $N_{(X-1)}>1$. Only at level 1, convolution kernels are, however, single-components (1D) across K as there are no previous convolutions and hence weight parameters are given by $w_1[n_1,k]$. In Table 4, we provide the numerical dimensions for $N_X$, $N_{(X-1)}$, and K across 1D-Justo-LiuNet.
$b_X\left[n_X\right]$	Bias parameters of the $N_X$ kernels in the convolution at level X. The sequence $b_X\left[n_X\right]$ is always 1D, regardless of whether the kernel weights are multi-component (2D) or single-component (1D).
$y[n_X,l_X]$	Output sequence of the convolution layer at level X, including all $N_X$ one-dimensional feature maps with length $L_X$ produced by the respective $N_X$ kernels. Each feature map is always one-dimensional regardless of whether the kernel weights are multi- or single-components.
POOLING FOR FEATURE REDUCTION
$z[n_X,m_X]$	Output sequence of pooling layer at level X with $N_X$ feature maps, where their original length $L_X$ is reduced down to $M_X$.
CLASSIFICATION OUTPUT
$f\left[i\right]$	Output sequence of flatten layer representing the I-th highest-level extracted features in the latent space relevant for sea–land–cloud classification.
$w_d[c,i]$	Weight parameters of the C neurons in the dense layer, where C represents the number of classes to detect. Each neuron is fully connected, with I synapses, to the respective features in $f\left[i\right]$ to calculate the probability that they belong to the neuron’s respective class.
$b_d\left[c\right]$	Bias parameters of the C neurons in the dense layer.
$p\left[c\right]$	Output sequence of the dense layer (i.e., output of the network), consisting of C class probabilities.

first presents the notations for the data sequences at each processing stage of the deep network. The table includes descriptions of the input and output sequences for each layer, its internal weights and biases, and the dimensions of the sequences.

Table 4. Overview of the 1D-CNN 1D-Justo-LiuNet showing sequence dimensions.

INPUT		LAYER PARAMETERS		OUTPUT
SEQUENCE	DIMENSIONS	SEQUENCES	DIMENSIONS	SEQUENCE	DIMENSIONS
FEATURE EXTRACTION AND REDUCTION
LEVEL 1
CONVOLUTION ($N_1=6$ kernels; $K=6$)
$x\left[\lambda \right]$	1 × 112	$w_1[n_1,k]$	6 × 6	$y[n_1,l_1]$	6 × 107
		$b_1\left[n_1\right]$	1 × 6
POOLING
$y[n_1,l_1]$	6 × 107	N/A*	N/A	$z[n_1,m_1]$	6 × 53
LEVEL 2
CONVOLUTION ($N_2=12$ kernels; $K=6$)
$z[n_1,m_1]$	6 × 53	$w_2[n_2,n_1,k]$	12 × 6 × 6	$y[n_2,l_2]$	12 × 48
		$b_2\left[n_2\right]$	1 × 12
POOLING
$y[n_2,l_2]$	12 × 48	N/A	N/A	$z[n_2,m_2]$	12 × 24
LEVEL 3
CONVOLUTION ($N_3=18$ kernels; $K=6$)
$z[n_2,m_2]$	12 × 24	$w_3[n_3,n_2,k]$	18 × 12 × 6	$y[n_3,l_3]$	18 × 19
		$b_3\left[n_3\right]$	1 × 18
POOLING
$y[n_3,l_3]$	18 × 19	N/A	N/A	$z[n_3,m_3]$	18 × 9
LEVEL 4
CONVOLUTION ($N_4=24$ kernels; $K=6$)
$z[n_3,m_3]$	18 × 9	$w_4[n_4,n_3,k]$	24 × 18 × 6	$y[n_4,l_4]$	24 × 4
		$b_4\left[n_4\right]$	1 × 24
POOLING
$y[n_4,l_4]$	24 × 4	N/A	N/A	$z[n_4,m_4]$	24 × 2
FLATTENING OF FEATURES
$z[n_4,m_4]$	24 × 2	N/A	N/A	$f\left[i\right]$	1 × 48
CLASSIFICATION OF FEATURES
DENSE ($C=3$ class neurons to 48-dimensional latent space)
$f\left[i\right]$	1 × 48	$w_d[c,i]$	3 × 48	$p\left[c\right]$	1 × 3
		$b_d\left[c\right]$	1 × 3

* N/A: Pooling layers do not contain trainable parameters.

details the data pipeline within the network by specifying numerical dimensions and showing the layer interconnections that route the data path from the receipt of an input pixel, $x\left[\lambda \right]$, to the output class probabilities, $p\left[c\right]$. In the following sections, in addition to explaining the numerical dimensions shown in Table 4, we describe our CPU-based implementation of the 1D convolution with single- and multi-component kernels, pooling, flatten, and dense layers.

3.3. Convolution Layer with Single-Component Kernels

3.3.1. High-Level Functionality

Table 4 shows that the sequence $x\left[\lambda \right]$ is the input to the first convolutional layer. This spectral signature consists of raw sensor data measured across $\Lambda =112$ wavelengths. With a spectral resolution of about 5 nm, the signature spans from the near-infrared to the visible blue (800–400 nm). Although HYPSO-1’s sensor measures 120 wavelengths, we excluded eight wavelengths in our previous work [39], such as those in the oxygen A-band within the NIR, due to significant light absorption [51,52]. Since the input to the convolution $x\left[\lambda \right]$ is a 1D sequence, and the patterns to be detected also share this dimensionality, the kernel weight parameters must also be 1D. As a result, each convolution kernel has only one component, and with $K=6$, each kernel contains 6 weight parameters. The detection of each pattern occurs by convolving the input sequence $x\left[\lambda \right]$ with these weights, sliding the kernel over $x\left[\lambda \right]$ and scanning small segments (or windows) of the input sequence against the weights. For each window, the operation results in one sample, as follows:

$$h\left[j\right]=\mathrm{ReLU}(\sum _{k=0}^{K=5}s\left[k\right]·w\left[k\right]+b_{\mathrm{kernel}}),$$

(1)

where $s\left[k\right]$ denotes the windowed samples, $w\left[k\right]$ the kernel weights, and $b_{kernel}$ the kernel bias. The result is then passed through a ReLU activation function, which outputs zero if the result is negative or retains its value if positive. The resulting convolution sample, $h\left[j\right]$, where j indexes the window being processed, indicates the strength of the local pattern detected by the kernel at that position in the input sequence. This process is repeated for each window along the sequence $x\left[\lambda \right]$, as described by Equation (1).

Figure 3 illustrates how the window slides one sample at a time, with a stride of $S=1$. The window slides across the entire sequence $x\left[\lambda \right]$, ensuring that every sample is processed at least once. However, because 1D-Justo-LiuNet does not employ padding ($P=0$), the last window does not extend beyond the end of sequence. This slightly reduces computations by avoiding repeating the operations from Equation (1) $K-1=5$ times, and slightly shortens the convolution sequence. Not extending the window beyond is not critical, as our previous work [39] found that the final samples in $x\left[\lambda \right]$ for the blue spectrum contain redundant information, while most variance is in the first samples, corresponding to the NIR and visible red [53]. After the window has finally slid over the entire input sequence, the number of samples in $h\left[j\right]$ produced by the convolution (i.e., the length of the 1D feature map), is calculated as follows:

$$L_{\mathrm{OUT}}=⌊{\displaystyle \frac{L_{\mathrm{IN}}+2P-K}{S}}⌋+1,$$

(2)

where $L_{\mathrm{IN}}$ is the length of the input sequence $x\left[\lambda \right]$, and $L_{\mathrm{OUT}}$ represents both the length of the convolution and the number of windows processed. For the first convolution layer, this results in

$$L_1=⌊{\displaystyle \frac{\Lambda +2P-K}{S}}⌋+1=⌊{\displaystyle \frac{112+0-6}{1}}⌋+1=107,$$

(3)

indicating that the first convolution layer produces $L_1=107$ samples per kernel, as also shown in Table 4, reducing the length of the input sequence $x\left[\lambda \right]$ by $K-1=5$ samples.

Finally, the same convolution process is applied to the remaining kernels in the layer, but using different weight parameters $w\left[k\right]$ and bias $b_{\mathrm{kernel}}$, as each of the six kernels in the layer is trained to detect a different pattern. The 1D feature map from each kernel is then stacked together at the output, forming the 2D sequence $y[n_1,l_1]$.

3.3.2. Implementation

In Algorithm 1, we present the pseudocode for our implementation in C, with a flow diagram given in Figure 4. The C code for all network layers is also openly available in our GitHub repository at https://github.com/NTNU-SmallSat-Lab/AI_deployment_justoliunet (accessed on 7 January 2025).

Steps (3–5) in Algorithm 1 initialize the window with the first $K=6$ samples from $x\left[\lambda \right]$. In steps (6–20), we first process this window. Namely, after initializing an accumulator to 0 in (7), we perform multiply-accumulate (MAC) operations between the window samples and weights in (8–10). The bias is added in (11), followed by ReLU activation in (12), and the result is saved in (13) to the output sequence. If more samples remain to be processed in $x\left[\lambda \right]$, the window slides by stride $S=1$ in (14–19), where samples are first shifted (15–17), and then a new sample from $x\left[\lambda \right]$ is introduced in (18). The processing outlined in (6–20) is repeated for all windows, eventually producing a 1D feature map per kernel $n_1$. As shown in step (2), the processing then restarts for a new kernel to detect a different pattern. A potential minor speed improvement involves initializing the accumulator with $b\left[n_1\right]$ in (7), and removing step (11) to reduce the number of addition operations.

To minimize computational resources, we extensively use C pre-compiling directives for all the hyper-parameters, such as $N_1=6$, $K=6$, and $L_1=107$, among others, substituting their values directly before compilation. This eliminates the overhead of creating and initializing variables at runtime, while also saving memory since no allocation is required for the hyper-parameters. However, weights $w[n_1,k]$ and bias $b\left[n_1\right]$ are initialized at runtime and contribute to the program’s memory footprint, along with sequences like input $x\left[\lambda \right]$, output $y[n_1,l_1]$, and the internal MAC accumulator. However, the critical aspect in terms of performance is the handling of multi-dimensional sequences in memory since adequate access patterns are crucial for optimizing performance, dependent on memory cache utilization. In our case, the SoC’s dual-core CPU has 32 KB of the L1 data cache per core and 512 KB of the L2 cache [48]. The L1 cache has lower latency due to its proximity to the CPU, while the L2 is slower but has larger storage. The caches are handled by the CPU’s cache controller based on data size and access patterns. To this extent, data with adequate spatial and temporal memory locality are more likely to remain in the L1 cache for faster access. Spatial locality refers to data being laid out contiguously in memory. For example, when accessing an element in an array, the cache assumes that the contiguous memory addresses will be accessed next and pre-fetches their content for faster access. In our case, for 1D sequences like the spectral signature $x\left[\lambda \right]$, window $s\left[i\right]$, and bias $b\left[n_1\right]$, samples are stored contiguously in memory, making their access pattern straightforward. However, for multi-dimensional sequences, C uses a row-major order by default, where the columns of each row are stored contiguously in linear memory before the next row. Therefore, to optimize memory access during MAC operations in step (9) in Algorithm 1, we deliberately arrange the K kernel weights in columns within $w[n_1,k]$, making it more efficient to access all weights within the same kernel before moving to the next one. We follow this access pattern for most multi-dimensional sequences in this work. In addition, the CPU’s cache controller handles temporal locality by pre-fetching frequently accessed data. Sequences like weight parameters in $w[n_1,k]$ exhibit strong temporal locality, as they are repeatedly accessed while processing the windows.

Algorithm 1 Implementation 1 for convolution layer with single-component kernels

1: $N_1=6$, $K=6$, $L_1=107$   2: for $n_1$ ← from 0 to $N_1-1$ do   3:     for i ← from 0 to $K-1$ do   4:         $s\left[i\right]$ ← $x\left[i\right]$   5:     end for   6:     for j ← from 0 to $L_1-1$ do   7:         $Acc.$ ← 0   8:         for i ← from 0 to $K-1$ do   9:            $Acc.\leftarrow Acc.+s\left[i\right]\ast w[n_1,i]$ 10:         end for 11:         $Acc.\leftarrow Acc.+b\left[n_1\right]$ 12:         $Acc.\leftarrow ReLU(Acc.)$ 13:         $y[n_1,j]\leftarrow Acc.$ 14:         if j < $L_1-1$ then 15:            for i ← from 0 to $K-2$ do 16:                $s\left[i\right]\leftarrow s[i+1]$ 17:            end for 18:            $s[K-1]\leftarrow x[K+j]$ 19:         end if 20:     end for 21: end for

Overall, spatial and temporal locality reduce computation time. However, a drawback of our implementation given in Algorithm 1 is the inefficiency caused by the window sliding from the start of $x\left[\lambda \right]$ for each new kernel. Although we could slide over the input sequence $x\left[\lambda \right]$ only once, as we propose alternatively in Algorithm 2 and in Figure 5, this implementation would sacrifice row-major memory access. Regardless, we have not implemented this second alternative CPU approach, as the Zynq-7030’s slow dual-core CPU makes FPGA acceleration a more suitable option for faster inference. Therefore, our focus is on creating a C implementation that can be more easily synthesized for the SoC’s FPGA in the future. For example, in our CPU implementation, unlike the linear SVM in [49], we avoid dynamic memory allocation (e.g., malloc), as we verify it cannot be synthesized into Register Transfer Level (RTL) and FPGA logic by high-level synthesis (HLS) tools like Xilinx’ Vitis HLS. Using dynamic memory at runtime would prevent the tools from determining the exact memory required, which must be known for placing and routing at design time.

Algorithm 2 Implementation 2 for convolution layer with single-component kernels

1: for i ← from 0 to $K-1$ do   2:     $s\left[i\right]$ ← $x\left[i\right]$   3: end for   4: for j ← from 0 to $L_1-1$ do   5:     for $n_1$ ← from 0 to $N_1-1$ do   6:         $Acc.$ ← 0   7:         for i ← from 0 to $K-1$ do   8:            $Acc.\leftarrow Acc.+s\left[i\right]\ast w[n_1,i]$   9:         end for 10:         $Acc.\leftarrow Acc.+b\left[n_1\right]$ 11:         $Acc.\leftarrow ReLU(Acc.)$ 12:         $y[n_1,j]\leftarrow Acc.$ 13:     end for 14:     for i ← from 0 to $K-2$ do 15:         $s\left[i\right]\leftarrow s[i+1]$ 16:     end for 17:     $s[K-1]\leftarrow x[K+j]$ 18: end for

3.4. Pooling Layers

Pooling layers maintain invariant feature representation, prevent convolution layers from escalating further the network’s complexity, and reduce the final latent space dimensionality. Since pooling across 1D-Justo-LiuNet functions similarly, we illustrate our implementation by focusing only on the first pooling layer. It receives input from the first convolution’s output, $y[n_1,l_1]$, consisting of $N_1=6$ feature maps. While the number of pooled maps remains the same as the input, the length of each is reduced from $L_1$ down to $M_1$, where $M_1$ also represents the number of pooling operations. The pooling factor, F, determines how much the map’s length is reduced. This length is calculated as $M_1=⌊{\displaystyle \frac{L_1}{F}}⌋$. In 1D-Justo-LiuNet, all pooling layers use $F=2$, halving the length of the feature maps [39]. If $L_1$ is odd, the last sample in $y[n_1,l_1]$—from the blue spectrum—is discarded, given that the network’s pooling layers also do not use padding, requiring the floor operation for odd input lengths.

Algorithm 3 provides the pseudocode for the first pooling layer. Steps (2–6) show that each feature map is pooled individually, following C row-major order. In step (5), the layer compares two consecutive samples and selects the largest one, then moves to the next two samples and repeats the process. The results are stored in $z[n_1,m_1]$. Overall, pooling shows considerably lower complexity than convolutions, as it does not need extensive arithmetic operations with weights and biases. Given that $F=2$, a potential speed improvement involves replacing the multiplication in step (4) with a left shift operation by one bit, which is typically faster at hardware level than multiplying by 2. This optimization assumes that the iteration in step (4) has been previously initialized to 0 and that j is calculated as the sum of j with F before left shift is applied.

Algorithm 3 Pooling layer

1: $N_1=6$, $M_1=53$, $F=2$ 2: for s ← from 0 to $N_1-1$ do 3:     for i ← from 0 to $M_1-1$ do 4:         $j\leftarrow i\ast F$ 5:         $z[s,i]\leftarrow max\left(y\right[s,j],y[s,j+1\left]\right)$ 6:     end for 7: end for

3.5. Convolution Layer with Multi-Component Kernels

The first convolution layer uses single-component kernels, while the remaining convolution layers utilize multi-component kernels, as illustrated next with an example of the second convolution layer. To begin, while the functionality remains the same as in the first convolution, the kernel weights dimensionality introduces some differences. Unlike the first layer, which processes a 1D input $x\left[\lambda \right]$, the pooled features $z[n_1,m_1]$ are instead 2D as each position contains $N_1$ components representing the features detected previously. As a result, the kernel weights are also 2D. In short, while the first convolution had $K=6$ coefficients per kernel, the second convolution now includes $N_1=6$ components for each of the $K=6$ coefficients per kernel. This allows abstract feature extraction combining the simple patterns detected by the previous convolution, yet at the cost of increased complexity. The sliding window also becomes 2D with dimensions $N_1\times K$ (accordingly with $z[n_1,m_1]$), and following C row-major order, we store the kernel weights as $w[n_2,n_1,k]$ (see notation and description in Table 3). However, the output still remains a 1D feature map per kernel, with all results stacked in $y[n_2,l_2]$.

Algorithm 4 provides the pseudocode for the convolutional layer. Steps (3–7) initialize the 2D window with the first $N_1\times K=6\times 6$ samples from $z[n_1,m_1]$. Following row-major order, columns are accessed first. Then in steps (8–26), we first process this window. The processing is nearly identical to using single-component kernels. Namely, after initializing the accumulator in (9), we perform MAC operations in (10–14) between the window and weights, also following row-major order. The use of multi-component kernels affects only the weights, so the addition of bias and ReLU activation before storing the result, in steps (15–17), remain the same. Finally, the window slides over $z[n_1,m_1]$ in (20–22), shifting samples for each separate component and then introducing in (23) a new sample from $z[n_1,m_1]$ with all its features. This process is repeated for all windows and restarts for each new kernel. Certainly, the functionality remains the same as for the first convolution layer. However, multiple-component kernels require significantly more operations and parameters, where the number of MAC operations increases critically. Deeper convolution layers also include more kernels, further increasing complexity. In short, convolution layers tend to be considerably more complex than pooling and flatten layers. In this work, we will provide a numerical example to illustrate the growing complexity and explain which convolution layer we propose for future FPGA acceleration.

Algorithm 4 Implementation 1 for convolution layer with multi-component kernels

1: $N_2=12$, $N_1=6$, $K=6$, $L_2=48$   2: for $n_2$ ← from 0 to $N_2-1$ do   3:     for r ← from 0 to $N_1-1$ do   4:         for i ← from 0 to $K-1$ do   5:            $s[r,i]$ ← $z[r,i]$   6:         end for   7:     end for   8:     for j ← from 0 to $L_2-1$ do   9:         $Acc.$ ← 0 10:         for r ← from 0 to $N_1-1$ do 11:            for i ← from 0 to $K-1$ do 12:                $Acc.\leftarrow Acc.+s[r,i]\ast w[n_2,r,i]$ 13:            end for 14:         end for 15:         $Acc.\leftarrow Acc.+b\left[n_2\right]$ 16:         $Acc.\leftarrow ReLU(Acc.)$ 17:         $y[n_2,j]\leftarrow Acc.$ 18:         if j < $L_2-1$ then 19:            for r ← from 0 to $N_1-1$ do 20:                for i ← from 0 to $K-2$ do 21:                    $s[r,i]\leftarrow s[r,i+1]$ 22:                end for 23:                $s[r,K-1]\leftarrow z[r,K+j]$ 24:            end for 25:         end if 26:     end for 27: end for

3.6. Flatten Layer

In Algorithm 5, we implement the flatten layer. As noted in Table 4, the input to the flatten layer is the sequence $z[n_4,m_4]$ from the last pooling layer in the network with dimensions $N_4\times M_4=24\times 2$, i.e, 24 feature maps of length 2. The sequence length has reduced across the network from $\Lambda =112$ in $x\left[\lambda \right]$ to 2 due to the repeated pooling operations, ensuring high feature invariance at this stage. The flattening operation now serializes the first column sample with its 24 features, followed by the second sample with its respective 24 features. Due to how Keras implements flattening, this is the only operation in this work where we do not use row-major order. The output is a 1D flattened sequence, $f\left[i\right]$, with $I=48$ samples, spanning a 48-dimensional latent space. These feature samples are fully connected to $C=3$ classification neurons in a subsequent dense layer, predicting whether the features correspond to sea, land, or a cloud.

Algorithm 5 Flatten layer

1: $M_4=2$, $N_4=24$ 2: $j\leftarrow 0$ 3: for i ← from 0 to $M_4-1$ do 4:     for s ← from 0 to $N_4-1$ do 5:         $f\left[j\right]\leftarrow z[s,i]$ 6:         $j\leftarrow j+1$ 7:     end for 8: end for

3.7. Dense Layer

The dense layer classifies the features in $f\left[i\right]$ into one of the $C=3$ classes: sea, land, or clouds. It calculates one probability per class using $C=3$ neurons. Each neuron is fully connected to the $I=48$ input features in $f\left[i\right]$, with synaptic weights stored in $w_d[c,i]$ with dimensions $C\times I=3\times 48$. The neuron that gets activated the most indicates the most likely class for the spectral signature $x\left[\lambda \right]$.

Algorithm 6 follows a similar concept to convolution layers when processing each individual window, yet with some differences due to exponential calculations during activation, unlike simple ReLU functions in convolutions. In steps (2–9), we compute one pre-activation value per neuron, known as logit. Since logits do not represent probabilities, they need to be converted, later in (10–17), into probabilities for easier interpretation. In Algorithm 6, we first reset the accumulator in (3) and perform MAC operations in (4–6) between the input features and the synaptic weights using row-major order, then add the bias in (7) to compute the logit. However, we cannot convert it to a probability yet, as we need the logits from all neurons. Only when all logits are available, we can normalize them into probabilities. Therefore, in (8), we merely store the logit and return to step (2) for computing the next neuron’s logit. Once the process is complete for all neurons, we finally convert the logits in (10–17) into probabilities using the softmax activation, which is standard for multiclass classification. This function scales the logits, representing them as class probabilities as follows:

$$\mathrm{softmax}\left(z_i\right)={\displaystyle \frac{e^{z_i}}{{\sum }_{j=1}^{C=3}{e}^{z_j}}},$$

(4)

where $z_i$ is the logit from a given neuron, and the denominator is the normalization factor—summing the exponentials of all the logits—ensuring the probabilities add up to 1. In Algorithm 6, steps (10–14) exponentiate each logit and sum the exponentiated values. In (15–17), each exponentiated logit is divided by the normalization factor, yielding the predicted class probabilities in $p\left[c\right]$. These values indicate the likelihood and confidence that the spectral sequence $x\left[\lambda \right]$ belongs to a specific class. The highest probability in $p\left[c\right]$ gives the final categorical prediction P, i.e., $P=argmax\left(p\right[c\left]\right)$, with an ideally minimal error of $1-p[c=P]$. A speed improvement can be achieved by calculating the inverse of the normalization before step (15), so that in step (16) each probability is multiplied by this inverse instead of dividing. This replaces multiple divisions with a single division calculation, making it more scalable as the number of class neurons increases.

Algorithm 6 Dense layer

1: $C=3$, $I=48$   2: for n ← from 0 to $C-1$ do   3:     $Acc.$ ← 0   4:     for i ← from 0 to $I-1$ do   5:         $Acc.\leftarrow Acc.+f\left[i\right]\ast w[n,i]$   6:     end for   7:     $Acc.\leftarrow Acc.+b\left[n\right]$   8:     $logits\left[n\right]\leftarrow Acc.$   9: end for 10: $Normalization\leftarrow 0$ 11: for i ← from 0 to $C-1$ do 12:     $p\left[i\right]\leftarrow exp\left(logits\right[i\left]\right)$ 13:     $Normalization\leftarrow Normalization+p\left[i\right]$ 14: end for 15: for i ← from 0 to $C-1$ do 16:     $p\left[i\right]\leftarrow p\left[i\right]/Normalization$ 17: end for

3.8. Testing, Verification, and Deployment

After completing the C implementation, we first test inference on a general-purpose computer on ground, comparing the results of our implementation with those from a reliable framework like Keras offering higher abstraction. If the results match, it confirms the correctness of our implementation. We perform this evaluation in two steps to facilitate debugging. Our first step consists of feeding the model’s layers with predefined input stimuli resembling a pixel and manually configuring the layer’s weight and bias parameters using integer values for easier testing. By comparing their outputs to those inferred from the Keras layers with the same weights, biases, and input stimuli, we confirm that the outputs are the same, validating our functionality in C. Our second step, after verifying pixel-level functionality, is to test inference at the image level for a complete data cube from HYPSO-1. Our implementation and Keras now utilize the weights and bias parameters obtained during model training for sea–land–cloud segmentation. After this, we confirm that the segmented image by our implementation in C is identical to the one inferred by Keras, further validating the reliability of the segmentation results.

Following this verification, we migrate our implementation in C to a Laboratory Processing Unit (LPU), similarly to the method used in the literature for testing deep learning on ground-based processing units [30]. The LPU replicates on ground the same hardware and configuration flying on board HYPSO-1 with the architecture previously presented in Figure 1. We first confirm that our implementation migrates and runs without issues. We then verify that the segmented images by 1D-Justo-LiuNet in the LPU remain consistent with those inferred by Keras. Additionally, we measure the total time for segmenting each data cube, using available single-core and double-core multi-thread CPU processing. Upon completed verification, our final stage is the deployment of 1D-Justo-LiuNet in space, updating the application pipeline in Figure 1. For the experiments in this work, we modify configuration files to enable this update module and conduct edge inference for each new acquired data cube for sea–land–cloud segmentation.

4. Example Case Scenarios

4.1. Incomplete Downlink of Data Cubes

Satellites may encounter challenges during the radio downlink, leading to incomplete data reception on the ground and requiring retransmission. We use these challenges to illustrate how in-orbit inference helps optimize the limited downlink resources in this scenario. Furthermore, we will introduce additional case scenarios where edge segmentation enhances satellite operations, such as when the satellite mispoints at space instead of Earth, misses the intended geographical area, or when conditions like high cloud coverage or overexposure make the data cube unusable. We will explain how inferred segments at edge can be interpreted both on ground and autonomously in orbit for more efficient operations.

As an example, in HYPSO-1, the on-board streaming process to the PC and S-band transmitter is generally error-free. Nevertheless, the S-band radio occasionally experiences interruptions due to telecommunication disruptions, which affect the raw data cube more than the segmented images. This occurs because the segmented images are transmitted first, allowing enough time for the retransmission of lost packets, while the data cube is more susceptible to disruptions, as it occupies most of the remaining transmission window. For downlink, a radio connection is established during a satellite pass when a ground station has LoS to the satellite. However, the estimated downlink window is sometimes longer than what third-party ground stations can actually provide, which is beyond our control, but may result in the reception of incomplete data cubes. In general terms, other factors can also affect the ground station’s ability to receive sufficient signal strength. Meeting the necessary Signal-to-Noise Ratio (SNR) and Signal-to-Interference Ratio (SIR) thresholds is not always guaranteed [54], which can disrupt the downlink and lead to incomplete data reception. For example, HYPSO-1’s transmitter operates in a congested S-band, where interference from other systems can be expected, even under optimal antenna alignment, polarization, directional pattern with minimal side lobes to minimize interference, and adequate transmission window. In broad terms, while the S-band is also less susceptible to rain fade and other weather-related disruptions compared to higher frequencies, severe weather can still attenuate signals below the levels predicted by Friis’ link nominal budgets, interrupting downlink. In summary, disrupted downlink can occur for various reasons, including ground station unavailability. In such cases, the data cube received is more likely to be compromised, and when data are missing, the CCSDS-123v1 on-ground decoder cannot recover the lost information, resulting in artifacts being produced to fill the cube’s dimensions.

Previously, when receiving incomplete data, we would have generally retransmitted the entire HS data cube in an attempt to receive it fully. However, with our contribution, the received segmented images allow us to assess first the importance of the missing pixels, whether they correspond, e.g., to clouds or irrelevant data. Additionally, it also enables us to perform on-ground georeferencing using the segmented images to align the area with approximate coordinates on the Earth’s surface, although the downlinked HS data cube is incomplete. Furthermore, the images also allow us to make an informed decision from ground on the best course of action: whether to command the satellite to reattempt downlink of the cube or discard it without downlinking and instead command the flight control to revisit the area later. The action taken is important, as revisiting could introduce significant latency, often of least one day for HYPSO-1, compared to reattempting downlink, which can often be performed faster, within an orbital period of 96 minutes, assuming the satellite gets LoS with the Svalbard Satellite Station located in the Arctic region. This operational improvement in decision-making would not be possible if segmentation was conducted on ground, where data were missing.

As we will present in the following sections, there are additional use cases where segmented images can enhance and automate future operations. From here on, we will use the terms segmented images and segments interchangeably. In Section 4.2, we present an approach for Ground-Based Segment Inspection, while in Section 4.3, we propose On-Board Automated Segment Interpretation, eliminating the need for ground-based human inspection. We will present in-orbit automation, from basic techniques, like class proportion analysis, to more advanced segment interpretation using deep learning based on the classification of segmented images. This work will demonstrate the latter on ground, by implementing a new CNN to interpret the segments directly during flight.

4.2. Ground-Based Segment Inspection

Instead of blindly streaming captured data cubes into the PC’s buffer for downlink without considering if their content justifies the high transmission cost, we propose buffering all inferred segments first. While the PC’s buffer is limited, this approach is feasible since segments require significantly less space than raw data cubes. When the satellite has LoS with a ground station, numerous segmented images can be downlinked in a single pass, unlike data cubes, which require at least two passes in HYPSO-1. However, several segmented images can be transmitted at once via a radio with an average throughput of 1 Mbps (equivalent to 125 kBps). Since each segmented image is 19 kB in size, downlinking one image takes less than a second using 1-byte encoding.

Once the segmented images are received on ground, a human operator can inspect them to identify any issues with the data cubes on board. Problems that can be detected from the images include the HS camera mistakenly pointing at space, which creates a distinctive striped pattern (e.g., see Figure 9b), or capturing incorrect geographical areas. Other issues, like heavy cloud cover or overexposure, can also be identified. Langer et al. [47] outline parameters the operator must configure on ground for new captures, such as exposure time, gain, and geographic coordinates. We propose that the operator, during this process, also decides whether to buffer the raw data from the SD card to the PC’s buffer or discard them and command flight control to revisit the area. While this process improves operations and bandwidth efficiency, manually inspecting numerous segmented images on ground is time-consuming and depends on human intervention. A more efficient approach would involve using AI algorithms to automate segment interpretation. Ideally, this interpretation should happen in orbit, allowing decisions to downlink or discard data cubes automatically during flight. This is what we address in the following section.

4.3. On-Board Automated Segment Interpretation

Interpreting segmented images in orbit enables actionable intelligence deciding whether to downlink or discard a data cube based on the inference results. In terms of HYPSO-1’s system architecture in Figure 1, we propose that, before streaming data to the PC’s buffer, only the relevant data are buffered for downlink, based on the segments inferred at the pipeline applications. If a HS data cube is flagged as usable, we propose automatically streaming its segments first, followed by the raw HS data cube, to the PC’s buffer for downlink. Streaming segments first maintains maximal optimization in case of downlink disruptions affecting the cube. However, if the HS data cube is flagged as unusable, the system can automatically delete it from the SD card, avoiding unnecessary buffering for downlink, and possibly repeating a new capture over the same coordinates (this demands updating the scheduling software), aiming for a more useful data cube. To track adequate model performance over time, we still recommend downlinking the segmented images, even for the discarded cubes. To flag whether a HS data cube is usable, the inferred segments can be processed, starting with a simple framework of class proportion analysis. However, training deep learning models for classification of the segmented images can provide deeper understanding beyond basic class proportion analysis.

• Class Proportion Analysis: As Langer et al. [47] note, the operator configures various parameters for new captures on the ground. Therefore, we propose using this flexibility by adding class proportion thresholds to the uplink scripts, allowing the OPU to automatically flag captures as usable or not based on the detected class proportions. For example, when planning a capture over an oceanic archipelago of islands where most pixels are expected to be segmented as water, a threshold can be set so that if detected land exceeds an obviously disproportionate high value (e.g., over 90%), it may indicate a pointing error, flagging the capture as not usable. In our previous work [39], 1D-Justo-LiuNet was tested using metrics like Spearman’s correlation and found that it performed well for ranking data cubes to prioritize downlink based on the analysis of sea, land, and cloud coverage proportions, achieving an error-free ranking. We will discuss the strengths and limitations of this method in more detail.
• Segments Classification Analysis: While class proportion analysis is simple and effective, we will show examples where it is insufficient and inadequate for segment interpretation due to the need for spatial context. Therefore, we also test an additional deep model, trained on segmented images inferred in flight, to illustrate how these images can be further interpreted in orbit to enable autonomous decisions on whether to downlink or discard the raw data cubes. We will also discuss the strengths and challenges of this approach.

4.3.1. Class Proportion Analysis

A segment interpreter based on class thresholds can be effective for decision-making in scenarios such as the following:

• Similarly to our previous example, a water scene (e.g., deep ocean, archipelago, coastline) where detected land disproportionately exceeds a threshold.
• A land scene (e.g., inland, coastline, islands) where water pixels unexpectedly surpass a threshold. This also applies to snow or ice scenes (e.g., in Arctic regions) where little to no snow/ice is detected, and water dominates the capture.
• Areas with cloud cover or overexposure exceeding a certain threshold.

In such cases, there is a risk the satellite missed the intended area, possibly making the HS data cube unusable. Segment interpretation based on class thresholds can be suitable for satellites seeking cloud-free scenes, such as ESA’s Φ-Sat-1 mission, which sets cloud cover limits to 70% for acceptable captures [55]. However, this approach has limitations in missions like HYPSO-1, where target areas are often much smaller than the full captured area. Even with high cloud cover percentage, captures may still be useful if the remaining non-cloud pixels cover the small area of interest. Therefore, relying solely on thresholds can be misleading in such cases, although if cloud cover is extremely high (e.g., over 90%), it may suggest the decision to take based on the high risk of relevant target areas being also cloud-affected.

4.3.2. Segment Classification Analysis

Interpretation using AI algorithms or statistical analysis for classification of segmented images is certainly more computationally complex. It demands the OPU’s pipeline applications to run cascaded inference to interpret a segmented image to decide whether to downlink or discard the raw data cube on board. However, this approach is preferred to achieve precise in-orbit automation.

To begin, in computer vision (CV), the term segmentation refers to pixel-level classification (as in 1D-Justo-LiuNet). However, when we next use the term classification from CV, it means labeling the entire segmented image under a single class. In this work, we train and test an additional 2D-CNN model to demonstrate how segmented images can be autonomously interpreted in flight. For illustration, the 2D-CNN is trained to detect the characteristic striped pattern seen in HYPSO-1 data when the satellite mispoints at space instead of Earth, allowing the HS data cube to be flagged as unusable and discarded on board. We train the model using 12 segmented images for training (4 with and 8 without mispointing) and 4 for testing (2 with and 2 without mispointing). While more training data could be used, this data split suffices to demonstrate segment interpretation for future in-orbit deployment. Further details on the used data and obtained results will be discussed in Section 5.

Furthermore, given the increased automation level, we consider that it is important to briefly introduce techniques that explain the 2D-CNN model’s final decision on whether a capture is unusable, especially since this decision may lead to irreversibly discarding the data on board. Therefore, to explain the 2D-CNN model’s predictions, we additionally use algorithms from Explainable Artificial Intelligence (XAI) [56], an emerging AI field aimed at revealing how black-box AI models make their decisions. While we emphasize that XAI is not the focus of this work, we deem XAI will most likely play a key role in AI’s future due to ethical and accountability concerns of AI technology. As a result, in this work, we demonstrate XAI on HYPSO-1 using standard methods like model-agnostic SHAP (SHapley Additive exPlanations) and Grad-CAM (Gradient-Weighted Class Activation Mapping). As an example, we apply these algorithms to the 2D-CNN to explain why the model determined whether a capture is usable. SHAP, based on cooperative game theory, assigns an importance score to the individual contribution of each data feature to the model’s final prediction. However, Grad-CAM, more suited for CNNs, uses the gradients of the target class into the last convolution layer to produce a localization map, which highlights the features (in this case, pixels in the segmented image) driving the model’s prediction the most. This localization map is typically displayed as a heatmap, created by combining the last convolution layer’s feature maps with the target class gradients, resulting in a weighted feature map. Results will be discussed in Section 5.

4.4. In-Orbit Data Products and Selective Compressive Sensing

Beyond automated decisions to downlink or discard HS data cubes, the output of 1D-Justo-LiuNet can serve as input for current and future processing modules in the pipeline applications in Figure 1. At the time of writing, these mainly include smile and keystone data cube correction, spatial pixel subsampling, a linear SVM, and an RGB composition module. For example, the linear SVM can detect water colors, with potential for future products such as maps indicating chlorophyll-A levels for detecting phytoplankton and algae blooms [37,57,58], which should apply only to pixels segmented as water. For land pixels, indexes like the Normalized Difference Vegetation Index (NDVI) [59] and Enhanced Vegetation Index (EVI) [60] used to assess temporal changes in green vegetation can be computed in orbit to monitor crop health and estimate biomass, assisting soil monitoring [61] for food security, one of CHIME’s nominal goals [9]. In addition, if the minimal expected reliability of in-orbit segment interpretation cannot be ensured when flagging data cubes as not usable, we suggest they are marked as potentially unusable instead of being discarded. In this case, rather than downlinking the full data cube, the result from the RGB composition module would be streamed to the ground for operator inspection. The operator can then confirm whether the capture should indeed be discarded. However, this approach would reintroduce human intervention, reducing efficiency.

Moreover, the pipeline applications include a subsampling module. For future implementation, we suggest applying here an informed lossy compression only to certain segmented pixels from 1D-Justo-LiuNet when downlinking usable HS data cubes. Selective compression, proposed, e.g., by ESA for missions like CHIME in [23], uses on-board cloud detection to apply higher compression ratios to cloud pixels with different lossy schemes, while non-cloud pixels receive lossless or near-lossless compression. This method was successfully tested on AVIRIS and simulated CHIME data. Additionally, one may also use, for instance, selective Compressive Sensing (CS). Unlike traditional compression methods, CS simplifies on-board compression by subsampling a few random spectral channels for each pixel, transferring computational complexity to ground-based lossy reconstruction. Based on our previous studies [46], we recommend using the Generalized Orthogonal Matching Pursuit (GOMP) algorithm [62] due to its faster convergence and acceptable accuracy. For sparse pixel recovery on ground, GOMP can be applied to less relevant pixels, such as clouds, or to other classes; for example, if the target area is water, both land and cloud pixels may undergo in-orbit random subsampling and GOMP reconstruction on ground. However, future efforts are needed to modify the current OPU’s compression capabilities, as the current lossless CCSDS-123v1 implementation in flight only supports compression of entire cubes and does not allow selective lossy compression for selected pixels.

5. Results and Discussion

We will illustrate segmented images inferred in orbit for various examples to demonstrate segmentation performance in the different case scenarios previously described. Most figures will primarily include the following:

• A Google map image showing the approximate geographical area where it was planned to image with HYPSO-1.
• The segmented image, where blue denotes water, orange indicates land, and gray represents clouds or overexposed pixels.
• An RGB composite created from the raw HS data cube, utilizing bands for the red, green, and blue channels out of the 120 available (at 603, 564, and 497 nm, respectively).

We include various captures, selected to address issues such as incomplete downlink, satellite mispointing, varying levels of cloud cover and thickness, and overexposure. Additionally, the captures cover a broad range of terrain types:

• Arid landscapes and desert regions with different mineral compositions.
• Forested areas and urban environments.
• Lakes, rivers, lagoons, and fjords of different sizes.
• Coastlines, islands, and oceans.
• Waters with colors ranging from cyan to deep blue.
• Arctic regions with snow and ice.

We will also present results from a 2D-CNN detecting patterns in the segmented images that indicate satellite mispointing at space instead of Earth, enabling autonomous decision-making to discard unusable data cubes on board. Brief results from AI explainers will be included to justify the model’s decision. Finally, we will provide timing results to identify which model layers may benefit the most from FPGA acceleration. In the Appendix A, segmentation results by 1D-Justo-LiuNet for over 300 images processed in orbit are additionally provided.

5.1. Accuracy: Incomplete Downlink of Data Cubes

We assess segmentation accuracy in orbit via visual inspection, as no ground-truth labels are available for comparison. This subjective approach is common in the literature when analyzing segmentation results in unlabeled satellite imagery [63]. However, metrics such as the Davies–Bouldin Index (DBI) and Silhouette Score [64] may be used to evaluate the quality of segmented images without ground truth. These metrics evaluate segment separation (ideally maximized) and distance between data points within clusters (ideally minimized). Nevertheless, objective quality assessments in digital applications are increasingly challenged, as seen in recent standards like ITU/P.910 from the International Telecommunication Union [65]. These standards prioritize subjective quality, as objective metrics, like the ones mentioned, can fail to capture user-perceived quality. In this work, relying on objective metrics can be misleading, as they may not capture mission-critical anomalies, making expert inspection more suitable. Since proposing subjective scores is unnecessary and beyond this work’s scope, the evaluation is based on our own expertise with HYPSO-1. We simply compare the RGB composite from the raw data cube with the inferred segmented image.

5.1.1. Imagery of Venice

We planned a capture of the Venetian Lagoon, shown in Figure 6a, where only the water is of interest in this case. Other possible regions captured, like the Northern Italian Alps, are incidental and irrelevant here. When comparing the segments in (b) with the map in (a), we confirm the satellite correctly pointed and captured the intended Earth’s coordinates around the Venetian Lagoon by approximate georeferencing. However, we did not receive the complete HS data cube resulting in the decompression artifacts seen in (c). With the proposed algorithms, in-flight segmentation allowed us to decide whether to reattempt downlink or discard the on-board HS data cube and revisit Venice instead. Since the lagoon’s water was segmented as cloud-free, with clouds mainly covering the Alps, we decided to reattempt downlink, thereby optimizing latency over revisiting the area. This informed decision was clearly better than discarding the cube based on the incorrect assumption that cloudy top pixels in (c) indicate that the lagoon is also obscured.

After reattempting downlink, we received the capture in Figure 7a mostly without downlink issues. For easier comparison, the segmented image is overlaid on the RGB composite in (b). We confirm the satellite correctly pointed to Venice’s area and captured the lagoon cloud-free, with only the Alps in the north affected, validating our decision to reattempt downlink. We consider the segmentation accuracy guiding this operation as acceptable for our application, even if some misclassifications occurred. Although large water bodies and coastlines are well detected, cloud shadows are sometimes mistaken for deep water due to their dark color, and lighter-toned river water is confused with clouds. This suggests that improved model training could reduce these errors. However, the focus of this article is on model inference, not on training.

5.1.2. Imagery of Norway

Figure 8a shows our target area around Trondheimsfjord, one of Norway’s longest fjords at over 100 km, surrounded by extensive forests. We aimed to capture the fjord and the surrounding forests without significant cloud cover. The segments in (b) confirm that the satellite was correctly oriented toward Trondheim’s area. However, similarly to the Venice capture, the data in (c) were affected by artifacts. Despite Norway’s complex and island-dense coastlines, where small islands are often misclassified as water due to stronger ocean reflections overshadowing land scattering, the model still identifies the ocean, land, and clouds at the top of the capture with a precision that meets our operational needs. Although Trondheimsfjord remains cloud-free, substantial cover affects the southern forests. As a result, rather than reattempting downlink, we decide to discard the data cube and plan a revisit for a clearer capture of the southern forests.

5.2. Accuracy: Satellite Mistakenly Pointing at Space

We plan a capture of the Namib desert in Namibia, Africa, shown in Figure 9a. The region hosts a station from ESA that is part of RedCalNet (Radiometric Calibration Network), a global network of sites providing publicly available measurements to support data product validation and radiometric calibration. The downlinked segments in (b) exhibit a characteristic stripped pattern, typically inferred when the satellite mistakenly points at space instead of the Earth. The RGB composite in (c) confirms an unusable capture, showing stripes in a mostly gray image. If future operations adopt our Ground-Based Segment Inspection approach (see Section 4.2), operators can manually review the downlinked segments and easily spot the mispointing error solely from the segments in (b). While uplinking parameters for new captures, operators can additionally command the satellite to discard the on-board data cube and revisit the area instead, avoiding the high transmission cost of downlinking this unusable cube.

Alternatively, interpreting segments in orbit offers a more autonomous solution (see Section 4.3). For captures mispointing at space, relying on class proportions alone is insufficient, as it does not account for spatial context. Instead, we propose using a 2D-CNN in flight to detect the striped pattern in the segmented image. The CNN would autonomously decide to discard this unusable data cube without human intervention. This serves as an example of how in-orbit segment interpretation can enable autonomous decision-making.

In our previous work [39], we found that the 1D-CNN model 1D-Justo-LiuNet, which focuses solely on spectral context, outperformed 2D-CNNs and ViTs in the HS domain. However, the resulting segmented images have a single-channel value per pixel: 0 for sea, 1 for land, and 2 for clouds. Therefore, applying a 1D-CNN to each pixel is not viable, and while flattening the image for 1D processing is possible, it would fail to capture the strong spatial patterns in the stripes. Detecting such patterns, with significant global spatial features, is better suited to 2D-CNNs. In Figure 6b, we showed a segmented image over the Venice area, which is now part of the test set for validating the 2D-CNN. Manual inspection suggested no mispointing error, but we aimed for the satellite to infer this autonomously. The 2D-CNN correctly predicted no mispointing (the Earth was not missed) with 100% confidence, as shown in

Table 5. Classification of segmented images based on confidence probability.

SEGMENTED IMAGES	PROBABILITY	CATEGORICAL PREDICTION
Figure 6b	(1.00, 0.00)	no mispointing
Figure 9b	(0.00, 1.00)	mispointing

. The table shows that the network outputs a probability vector, with the first position representing the likelihood that the segmented image belongs to the no mispointing class (1.00 in this case), and the second position indicating the probability of it belonging to the mispointing class (0.00 in this case). Moreover, Figure 9b shows another segmented image, part of the test set, with a striped pattern indicating a pointing error toward space. Table 5 shows the 2D-CNN correctly classifies it as mispointing with 100% confidence.

To explain the 2D-CNN model’s predictions, we also use XAI algorithms [56]. In XAI, choosing the adequate explainer is crucial, as some explanations can obscure rather than clarify the reasoning behind a model’s predicted outcome. For our data and 2D-CNN model, initial SHAP tests do not explain the CNN’s predictions intuitively enough, so we focus on Grad-CAM instead, which provides more interpretable explanations in our case and is commonly used for CNNs. Figure 10a shows the segmented image over Venice (rotated in the figure), classified in Table 5 as no mispointing. Figure 10b presents a Grad-CAM heatmap, where lighter colors indicate the pixels that influence the model’s decision the most. Grad-CAM shows that the overexposed cloud pixels, along with the coastline shapes, play the key role in the CNN’s classification as no mispointing, while vegetation and especially water have a minimal impact. Furthermore, Figure 10c shows again the segmented image with a stripped pattern, classified in Table 5 as mispointing. Figure 10d presents the Grad-CAM heatmap. Unlike in (b), the heatmap now lacks clear contributing regions, suggesting the model likely relies on the global striped pattern rather than on local features. We further confirm this with additional SHAP tests, where most Shapley scores are around 0, indicating no significant impact from any local region, unlike in (b), where overexposed cloud pixels and coastlines drive the CNN’s decision the most. This example demonstrates how XAI can be applied to CNNs in HYPSO-1 to gain a better understanding of model predictions.

5.3. Accuracy: Satellite’s Inadequate Pointing at Earth’s Surface (Imagery of Bermuda, Greek, and Eritrean Archipelagos)

HYPSO-1’s agile operations allow for flexible changes in the satellite’s orientation. However, this can result in the satellite mispointing at space, as previously mentioned, or, despite pointing at Earth, targeting the wrong geographical area and missing the intended targets. For example, in our planned capture of the Bermuda Archipelago in Figure 11a, known for its turquoise waters from shallow depths and coral reefs, the downlinked segments in (b) show mostly water with no land detected, indicating the satellite missed the archipelago. Class proportions reveal 92.03% of pixels are water, 7.93% clouds, and only 0.03% land.

Considering Ground-Based Segment Inspection (Section 4.2), operators would determine the satellite imaged deep Atlantic water and clouds, with no land detected, indicating the archipelago was missed. Consequently, the transmission cost of downlinking the data cube would be unnecessary, leading operators to command the satellite to discard the on-board cube and revisit the area. The composite in (c) confirms that, although some turquoise colors, likely from Bermuda’s coast, appear on the right of the capture, the archipelago was indeed missed. Decompression artifacts from incomplete downlink, visible at the bottom of the capture, have been previously discussed.

For in-flight segment interpretation, we can apply our two approaches for On-Board Automated Segment Interpretation (Section 4.3). In this case, where only 0.03% of pixels are segmented as land, interpretation based on the proportion of detected classes is appropriate. During capture planning, in addition to the setup parameters for new captures, the operator could have also uplinked a rough land threshold (e.g., below 0.5%, at the operator’s choice) for the OPU to flag the capture as not usable due to minimal land detection. In orbit, the 0.03% land proportion would fall below this threshold, making the OPU discard the capture. However, beyond merely evaluating the proportion of segmented land, a deep 2D-CNN could interpret patterns in the segmented image, such as island shapes and their spatial arrangement surrounded by water with sharp land–water transitions. If an island-like scene is not detected, the OPU may discard the cube. While we previously demonstrated the concept with a 2D-CNN trained to detect stripes when the satellite mispoints at space, future training to identify more complex features in flight, like island-shapes and other spatial distributions, could be relevant.

An additional example of satellite mispointing is given in Figure 12 for the Dahlak Archipelago (Eritrea) in the Red Sea. The segmented image indicates no water is detected. The class proportions are 64.60% land, 35.40% overexposed, and 0.00% water, indicating the satellite did not capture the expected scene of an archipelago surrounded by water. Ground-Based Segment Inspection would reveal that the satellite missed the Red Sea around the archipelago, detecting only the arid terrain with high overexposure and no water, leading to operators commanding the satellite to discard the HS data cube and scheduling a revisit. Alternatively, for in-flight segment interpretation, the OPU can easily assess the proportion of detected classes. A minimal water threshold can be set, and if not met, the cube is flagged as unusable. In this case, with 0.00% water pixels, the flagging would be straightforward.

Finally, Figure 13 shows an example of the satellite correctly pointing to the intended area, a Greek Aegean Archipelago near Athens, including islands such as Andros and Limnos. Ground-Based Segment Inspection would note a more reasonable pattern in (b) for an archipelago, with 87.33% water, 6.80% land, and 5.87% clouds. The class proportions, and especially the segmented image shown in (b), suggest the archipelago was captured correctly. As a result, the operators would command the satellite to downlink the cube, deeming the transmission cost worth, as indeed confirmed by the capture received in (c). For in-flight segment interpretation, the OPU could autonomously check that the class proportions are within certain reasonable thresholds and, using a 2D-CNN, evaluate in orbit if the spatial patterns match an island-like scene.

5.4. Accuracy: Captures of Arid and Desert Regions (Imagery of United Arab Emirates, Namibia, and Nevada)

Figure 14 and Figure 15 show captures over the United Arab Emirates (UAE), a region of interest for studying desertification and monitoring aeolian processes resulting in sand movement that could bury roads and threaten urban infrastructure in Abu Dhabi and Dubai. Figure 14a shows that sand near Abu Dhabi has a lighter color, while sand further into the desert takes on a reddish tone. This color variation is due to differences in mineral content: reddish sand has more iron oxide, whereas lighter sand contains more silica and less iron oxide. By monitoring the sand colors over time, the potential aeolian transport of red sand toward Abu Dhabi may indicate the movement of iron oxide-rich sands from the desert dunes into the cities.

Desert regions, especially those with higher silica, are generally more prone to overexposure. Indeed, segments in (b) show most land is detected as overexposed along the UAE’s coast (bottom segments) and extending north to Iran’s coast (top segments). Dubai’s Palm Islands (the Palm Jabel Ali and the Palm Jumeirah) and World Islands, artificial structures built into the sea, are visible on the right. They are highly saturated because the excessive light from the island easily dominates the scattered light from the surrounding water, as confirmed in (c). However, not only is the land overexposed, but some water too. Namely, while the UAE’s coastal water is correctly segmented, the light cyan water along Iran’s coast is overexposed and segmented as such.

After acquiring a new capture with adjusted exposure settings, the segmented image in Figure 15a shows a significant reduction in overexposure. Only the lighter silica-rich sand near Abu Dhabi is overexposed, while the reddish iron oxide-rich sand deeper in the desert is not. Larger islands are well identified, but the Palms and World Islands are partially misclassified as water due to the now stronger scattering from the surrounding larger water body compared to the thin islands. Despite this, water near Abu Dhabi’s coast, including shallow waters with potential confusion with land, is correctly segmented. The cyan water along Iran’s coast (in the top) is no longer overexposed, being correctly segmented as water.

Ground-Based Segment Inspection can confirm the satellite correctly pointed at the UAE region and assess whether the new cube is worth downlinking. However, the OPU would face challenges to autonomously decide whether to downlink or discard the capture based solely on detected class proportions. In addition, while a 2D-CNN can accurately detect the coastlines, it cannot guarantee with full certainty that the area corresponds to the intended coastline. Therefore, we recommend future work to implement in-orbit georeferencing for better automation in flight. We note that in our upcoming discussion, we will omit the analysis of Ground-Based Segment Inspection and On-Board Automated Segment Interpretation, as several examples have already been discussed.

Finally, to demonstrate segmentation accuracy in other deserts, Figure 16 shows accurate results over the iron-rich Namib Desert, hosting ESA’s station part of RedCalNet. Furthermore, Figure 17 captures Mojave Desert in Nevada near Las Vegas, with minor water misclassifications from cloud shadows, which remain acceptable for our application.

5.5. Accuracy: Captures of Water with Extreme Salinity (Imagery of Lake Assal near the Red Sea)

Given HYPSO’s focus on water observation, Figure 18 captures Lake Assal near the Red Sea, known for its extreme salinity—higher than the ocean and more than the Dead Sea. This volcanic lake, the lowest point in Africa, is surrounded by salt flats. The segments in (b) accurately identify the Gulf of Tadjoura, Lake Ghoubet, and Lake Assal. In Lake Assal, significant overexposure is detected, due to the highly reflective salt flats. The lake’s extreme saline water is also more reflective than typical water systems, resulting in some water pixels being classified as overexposed. The Red Sea, also saline, has similar overexposed pixels in the top segments. The RGB composite in (c) confirms the model accurately segments the salt flats as overexposed. Additionally, although Lake Assal’s water does not appear overexposed in the RGB, segmentation across all HS bands reveals higher reflectance likely due to its extreme salinity.

5.6. Accuracy: Captures of Water Colors (Imagery of South Africa, Vancouver, Caspian Sea, and Gulf of Mexico)

Given the importance of water observation and ocean color studies for HYPSO, Figure 19, Figure 20, Figure 21 and Figure 22 present examples of captures with varying water colors, correctly segmented as water. We note that the training set from the HYPSO-1 Sea–Land–Cloud-Labeled Dataset from our previous work [53] does not include subcategories to distinguish water colors due to the lack of ground-truth data to conclude a meaningful and physical interpretation of each color.

Figure 19 images the South African coastline, where darker water colors are correctly segmented due to the extensive dark water annotations in our training set. Furthermore, while thicker clouds are correctly segmented, thinner clouds are misclassified as water, which we will comment on later. Additionally, some non-cloud pixels are mistakenly identified as clouds in the top right, suggesting the need for further model training. However, the overall accuracy is still acceptable for our needs. Additionally, Figure 20 captures channels near Vancouver Island with clean waters similar to other coastlines, exhibiting cyan colors. The cyan water is correctly segmented. Finally, Figure 21 and Figure 22 depict other coastal images from the Caspian Sea and the Gulf of Mexico in New Orleans with light and darker green-blue waters, also accurately segmented.

5.7. Accuracy: Captures with Different Cloud Thickness

Figure 23 and Figure 24 show varying cloud thickness. Figure 23 captures Trondheimsfjord with thick clouds and acceptable segmentation. Figure 24 over Long Island, New York, shows thinner and more transparent clouds that are harder to segment as light scatters from both the clouds and the background. The segmented image shows cloud cover over the water, and the RGB confirms that, while the clouds are not thick, they obscure enough the of water to justify the cloud predictions.

Beyond cloud cover, a few aspects in Figure 24 are worth discussing. Several pixels on the left side of Long Island are segmented as overexposed, likely due to the bright urban surfaces in New York City. Light-colored, low iron oxide beaches in New Jersey are also correctly segmented as overexposed. Additionally, the Connecticut River, north of Long Island, is mostly misclassified as land due to strong NIR light scattered from surrounding vegetation, causing the river’s thin body to be misclassified as land.

Regarding cloud cover, detection is heavily influenced by contrast levels. Back to Figure 11 of the Bermuda Archipelago, small thin clouds are misclassified as water due to their lower contrast. Only the higher-contrast pixels in the top left are correctly detected as clouds, while the lower-contrast ones are misclassified as water. However, this is still permissible for our application.

5.8. Segmentation in Snow and Ice Conditions

The 1D-Justo-LiuNet model currently operational in orbit was not trained in [39] to reliably segment snow and ice, since the HYPSO-1 Sea–Land–Cloud-Labeled Dataset in [53] excluded these conditions to simplify the time-consuming labeling process. Regardless, we attempt to gain any insights from segmenting these scenes. Future training should improve the model’s ability to distinguish between clouds and snow/ice.

Figure 25 shows Alaska’s Prince William Sound, a water body between the Chugach National Forest and barrier islands, such as Montague Island. If only water was detected in the segments, it would indicate satellite mispointing, as no snow or land would be detected. However, gray segments suggest white pixels that may represent snow. Since the model is not trained to distinguish between clouds and snow, we compare the segmented images with the map for georeferencing. By matching the segment shapes with the map, it seems likely that many of the gray segments represent snow, as they tend to align with the land’s surfaces and contours. Additionally, some pixels also present lower reflectivity, indicating land. While not fully reliable, this method enhances the model’s potential to also segment scenes under snow and ice conditions, as it occurs in the Arctic, where HYPSO-1 often takes captures. For example, Figure 26 captures the Norwegian Archipelago of Svalbard in the Arctic region, crucial for climate change monitoring. Despite the challenges of georeferencing due to ice movement not represented in the available map, we apply the same approach as with Alaska. The snow-covered land (orange dots within gray segments) suggests the satellite correctly pointed and captured the archipelago, despite uncertainties in cloud cover. The composite confirms that the conclusion is correct.

5.9. Accuracy: Relevant Misclassifications (Low-Light Imagery and Florida’s Coast)

Although the 1D-Justo-LiuNet model was not trained to detect snow-covered surfaces, it can still identify them due to extensive training where many white pixels were annotated as clouds or overexposed areas. However, the HYPSO-1 Sea–Land–Cloud-Labeled Dataset lacks nighttime annotations [53], as labeling in such conditions would have been more complex. Consequently, the model performs poorly in low-light conditions, as seen in Figure 27, where a low-light capture from northern Norway shows significant misclassifications. The segmented image also exhibits a vertical stripe due to the segmentation being applied to uncalibrated sensor data, where sensor stripes have not been corrected. Finally, Figure 28 shows Florida’s misclassified coastal waters, where brighter water pixels are mistaken for clouds. This issue, seen across multiple captures in the concrete area off Florida’s coast, suggests the need for further exploration or model training in this region. However, the segmentation of the coastline, land, and clouds remains otherwise acceptable.

5.10. Inference Time

We continue our discussion by analyzing the processing time of 1D-Justo-LiuNet for segmenting a data cube. While our previous work [39] concluded that the network was one of the fastest lightweight models, the dual-core CPU in the Zynq-7030 remains considerably slow. Although an FPGA implementation is beyond the scope of this work, our Appendix A provides an analysis of potential future FPGA acceleration. We conclude that 1D-Justo-LiuNet can benefit significantly from accelerating the MAC operations in the third convolution layer on the FPGA.

6. Conclusions

This work marked the first deployment and testing of a 1D-CNN in a satellite in orbit. We implemented a C version of the lightweight 1D-CNN, 1D-Justo-LiuNet, previously shown to outperform 2D-CNNs and ViTs for semantic segmentation in hyperspectral imagery. The C implementation considered efficient memory access for CPU use, while facilitating future FPGA high-level synthesis. After validating the code on a general-purpose computer against high-level frameworks like Keras, we tested it on lab hardware identical to the hardware flying in space. The implementation was then deployed in space on the HYPSO-1 mission’s On-Board Processing Unit to segment acquired hyperspectral images at pixel-level into sea, land, or cloud categories. We obtained acceptable results in space, meeting our application needs. Additionally, we illustrated case examples demonstrating how the 1D-CNN enhances current and future satellite operations and increases automation. Case scenarios on HYPSO-1 benefiting from in-orbit segmentation included incomplete data downlinks, mispointing to space or incorrect geographic areas, and varying cloud conditions. To this extent, we introduced a framework to decide whether to downlink or discard the data based on the segmented images. Our proposed framework ranged from simple decision-making with human intervention to more autonomous approaches, from basic class proportion-based decisions to more advanced in-orbit automation, by using AI models which can interpret segmented images during flight. We trained a CNN to detect when segmented images indicate mispointing into space, demonstrating how segmentation results can be used in orbit to make autonomous downlink decisions. As future work:

• Based on our acceleration analysis, we recommend implementing multiply-accumulate operations from convolutions on the FPGA, to reduce processing time and accelerate inference.
• We suggest optimizing the 2D-CNN into a lightweight version for in-orbit deployment while expanding its capabilities to detect more patterns (e.g., detection of islands, coastlines, etc.) to increase automation in flight. If the spatial patterns in the segmented images happen to be more complex than expected, we advise conducting training with more advanced techniques like knowledge distillation, transferring knowledge from a larger teacher model (e.g., ViTs [41,66] based on self-attention mechanisms [67]) into a lighter student model that mimics the teacher’s performance.
• Our approach can be further generalized to include additional segmentation classes of relevance for other missions and sensors with differing performance, resolutions, or frequency bands. Deploying inference AI models in orbit enables complex decision logic, paving the way for future research on orbital autonomy.