Geometric correction method for hyperspectral image system based on MPI peer-to-peer mode and GPU cooperative acceleration

Abstract

The invention relates to the technical field of remote sensing image processing, in particular to a hyperspectral image system geometric correction method based on MPI peer-to-peer mode and GPU collaborative acceleration, which comprises the following steps: uniformly analyzing input parameters by a No.0 process and creating an output image, and synchronously completing local GPU environment initialization by all processes through broadcasting; all the processes adopt a strategy of blocking according to rows, and data blocks processed by the processes are determined according to output image information and local GPU video memory capacity; each process loads the block data to a GPU, and the GPU is used for executing a core calculation process composed of coordinate conversion based on an RPC model, position searching and multi-band resampling in parallel; and each process writes the result after the GPU acceleration processing back to the corresponding position of the output image. The problems that the calculation efficiency is low and the hardware resource utilization rate is insufficient when a traditional method is used for processing large-scale and multi-band hyperspectral images are effectively solved.

Description

Technical Field

[0001] This invention relates to the field of remote sensing image processing technology, and in particular to a geometric correction method for hyperspectral image systems that utilizes MPI peer-to-peer mode and GPU co-acceleration. Background Technology

[0002] Hyperspectral satellite remote sensing, as an advanced Earth observation technology, possesses unique characteristics and broad application value. Hyperspectral imagery can acquire spectral information of ground features across hundreds of continuous narrow bands. Compared to traditional multispectral remote sensing imagery, it boasts higher spectral resolution, providing detailed spectral characteristics of ground features and offering strong support for accurate identification of feature types and analysis of their properties. However, hyperspectral satellite remote sensing imagery also faces the problem of geometric distortion during acquisition. Factors causing geometric distortion mainly include changes in satellite platform attitude, orbital errors, sensor optical characteristics, Earth curvature, and terrain undulations. Geometric distortion can cause deviations between the positions of ground features in the imagery and their actual locations in geographic space, severely impacting the accuracy and usability of the imagery.

[0003] RPC (Rational Polynomial Coefficients) models, based on collinearity condition equations, are independent of specific satellite orbital parameters and sensor physical models. They are applicable to different types of hyperspectral satellite imagery and are a universal and effective method for geometric correction. With the continuous improvement of image resolution and the dramatic increase in data volume, traditional serial algorithms face significant challenges in processing large-scale hyperspectral image data. Traditional algorithms typically fail to fully utilize the multi-functional computing advantages of modern computing environments, neglecting the synergistic performance of multi-core processors and distributed computing systems, as well as the high-density parallel computing capabilities of graphics processing units (GPUs). Overall, they lack efficient parallel acceleration design and struggle to meet the real-time processing demands of massive amounts of data. In particular, hyperspectral imagery data often contains hundreds of bands, with higher data dimensionality and exponentially increasing computational load, placing more stringent demands on the parallelism and hardware adaptability of processing algorithms. Most existing geometric correction algorithms have not been optimized for the massive characteristics of hyperspectral data by simultaneously integrating distributed parallelism and GPU hardware acceleration capabilities, making it difficult to meet the high-efficiency requirements of large-scale operational processing in ground systems.

[0004] Therefore, there is an urgent need to propose an efficient geometric correction method that can fully coordinate and schedule distributed computing resources and GPU hardware computing power to solve the processing efficiency bottleneck problem faced by hyperspectral images, especially multi-band, large-scale data, in system geometric correction. Summary of the Invention

[0005] The purpose of this invention is to provide a geometric correction method for hyperspectral imaging systems that uses MPI peer-to-peer mode and GPU co-acceleration, which solves the problems of low computational efficiency and insufficient hardware resource utilization faced by existing technologies when processing large-scale hyperspectral images.

[0006] To achieve the above objectives, this invention provides a geometric correction method for a hyperspectral imaging system using MPI peer-to-peer mode and GPU co-acceleration, comprising the following steps:

[0007] Process 0 parses the input parameters and creates the output image, then broadcasts the input parameters to other processes.

[0008] Each process determines its own image data block to be processed based on the output image information and local computing resources;

[0009] Each process reads its block of data and uses the local GPU to execute the system geometry correction core calculation for that block in parallel;

[0010] Each process writes the calculated results back to the corresponding position in the output image.

[0011] Specifically, process 0 parses the input parameters, creates the output image, and broadcasts the input parameters to other processes, including:

[0012] The system parses the input image, input RPC or RPB file, and output file; calculates the size and six-parameter information of the output image after geometric correction based on the input image and RPC parameters, and creates the output image.

[0013] Among these processes, each process determines its own image data block to be processed based on the output image information and local computing resources. This process also includes the following prior steps:

[0014] All processes synchronously complete the initialization of the local GPU environment; the initialization includes allocating GPU memory space for each process and creating a CUDA context for executing GPU kernel functions.

[0015] Specifically, each process determines its own image data block to be processed based on the output image information and local computing resources, including:

[0016] A row-by-row block strategy is adopted; each process calculates the starting row position of the image block to be processed, the number of sub-block rows transferred to the GPU for processing in a single time, and the total number of rows that the process needs to process, based on the total number of rows of the output image, the total number of MPI processes, and the local GPU memory capacity. The number of sub-block rows ensures that the corresponding data volume does not exceed the GPU memory limit.

[0017] Specifically, each process determines its own image data block to be processed based on the output image information and local computing resources, including:

[0018] Each process, based on the memory capacity and parallel computing capabilities of its local GPU, internally subdivides the allocated contiguous rows of data into multiple smaller sub-blocks for cyclic processing.

[0019] Each process reads its block of data and uses the local GPU to execute the system geometry correction core calculation for that block in parallel, which includes the following steps:

[0020] The system is based on the RPC model for coordinate transformation calculation, finding the corresponding position of the output image pixel in the input image, and resampling interpolation calculation for multi-band images.

[0021] Specifically, the coordinate transformation calculation based on the RPC model includes:

[0022] By mapping each pixel to be corrected to a GPU thread, the multi-core parallel capabilities of the GPU are utilized to solve the RPC rational polynomial function model in batches and synchronously, thereby accelerating the construction of the mapping relationship from the output image pixel coordinates to the input image pixel coordinates.

[0023] The resampling and interpolation calculation for multi-band images specifically includes:

[0024] To address the multi-band characteristics of hyperspectral images, a band-pixel two-dimensional parallel strategy is adopted: a GPU thread block is allocated to each band of the image, and the threads within each thread block are responsible for the interpolation calculation of the next pixel in that band, thereby achieving synchronous parallel processing across bands and across pixels.

[0025] The strategy of using row-based block partitioning specifically includes:

[0026] The goal is to perform block computation with the aim of making the processing time required for each process to complete its block computation approximately equal, thereby achieving load balancing among MPI processes.

[0027] The interpolation calculation specifically includes:

[0028] For pixels in the output image whose corresponding positions in the input image are non-integer coordinates, a spatial interpolation algorithm is executed in parallel by a GPU thread to determine their final pixel values.

[0029] This invention discloses a geometric correction method for a hyperspectral image system using MPI peer-to-peer mode and GPU co-acceleration. Process 0 uniformly parses input parameters and creates the output image, broadcasting to all processes to synchronously initialize their local GPU environments. Subsequently, all processes employ a row-by-row block strategy, determining their respective data blocks based on the output image information and local GPU memory capacity. Each process loads its block data onto the GPU and utilizes the GPU to execute the core computational process—comprising coordinate transformation based on an RPC model, location lookup, and multi-band resampling—in parallel. Finally, each process writes the GPU-accelerated results back to the corresponding positions in the output image. By constructing a two-layer acceleration architecture of "MPI distributed task scheduling + GPU localized parallel computing," this invention effectively solves the technical bottlenecks of low computational efficiency and insufficient hardware resource utilization in traditional methods when processing large-scale, multi-band hyperspectral images. Experiments show that it achieves a significant speedup (e.g., a GPU speedup of over 11 times), greatly improving the throughput and real-time performance of the system's geometric correction. Attached Figure Description

[0030] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the accompanying drawings used in the description of the embodiments or the prior art will be briefly introduced below.

[0031] Figure 1 This is a flowchart of the geometric correction method for hyperspectral imaging systems using MPI peer-to-peer mode and GPU co-acceleration, as described in this invention.

[0032] Figure 2 This is a schematic diagram of the geometric transformation mapping relationship before and after geometric correction in the remote sensing image system of the present invention.

[0033] Figure 3 This is a schematic diagram of the process for determining the range of the system geometric correction image according to the present invention.

[0034] Figure 4 This is a schematic diagram of the block-segmentation strategy of the present invention.

[0035] Figure 5 This is the parallel execution time diagram of the system geometry correction of the present invention.

[0036] Figure 6 This is a speedup chart of parallel execution of system geometric correction according to the present invention.

[0037] Figure 7 This is a graph showing the increase in geometric correction time of the CPU / GPU system of the present invention as a function of computational load.

[0038] Figure 8 This is a flowchart of the steps of the geometric correction method for hyperspectral imaging systems using MPI peer-to-peer mode and GPU co-acceleration according to the present invention. Detailed Implementation

[0039] The embodiments of the present invention are described in detail below. Examples of the embodiments are shown in the accompanying drawings. The embodiments described below with reference to the accompanying drawings are exemplary and intended to explain the present invention, but should not be construed as limiting the present invention.

[0040] Please see Figures 1 to 8 This invention provides a geometric correction method for a hyperspectral imaging system using MPI peer-to-peer mode and GPU co-acceleration, comprising the following steps:

[0041] S101: Process 0 parses the input parameters and creates the output image, and then broadcasts the input parameters to other processes;

[0042] Specifically, this step completes the parsing of input parameters and GPU environment initialization. First, process 0 parses the input parameters required for geometric correction. These parameters include the input image, the input RPC (Rational Polynomial Coefficients) file or RPB (Rational Polynomial Bias) file, and the output file. Next, based on the parsed RPC parameters, a mapping relationship between the image row and column coordinates and the geodetic latitude and longitude coordinates is constructed. This mapping relationship model is the foundation for subsequent core calculation steps, and its batch solution process will be accelerated by the GPU. (See [link to relevant documentation]). Figure 2 Mid-pixel-level parallel mapping logic; using the mapping relationship between row and column coordinates and geodetic latitude and longitude coordinates, as well as information such as the size and six parameters of the image after geometric correction by the image information calculation system (synchronously adapting to GPU memory capacity during block division, see...). Figure 3 The process combines hardware characteristics to determine the range logic and creates a geometric correction result image. Finally, the geometric correction input parameters (input image, RPC and output image, etc.) are broadcast to other processes. After receiving the parameters, each process synchronously completes the GPU environment initialization, including CUDA context creation and memory space pre-allocation, to ensure that block data can be efficiently loaded into the GPU.

[0043] Construct image row and column coordinates based on the parsed RPC parameters. and geodetic latitude and longitude coordinates Mapping relationship between them:

[0044]

[0045]

[0046] In the formula, Represents the normalized row and column values. Representing normalized latitude, longitude, and elevation; the 20 coefficients of the cubic polynomial are represented as:

[0047] in, It means , , and These coefficients; in this rational polynomial function model, distortion caused by optical projection is represented by a first-order polynomial, distortion caused by Earth's curvature, atmospheric refraction, and lens distortion is represented by a second-order polynomial, and other unknown distortions are represented by a third-order polynomial. The conversion relationships between row and column values ​​and normalized row and column values, and between geographic coordinates and normalized geographic coordinates are as follows:

[0048]

[0049]

[0050]

[0051]

[0052]

[0053] The polynomial coefficients and normalized coefficients in the above RPC model are stored in the RPC file.

[0054] The image row and column coordinates obtained through the above construction and geodetic latitude and longitude coordinates The mapping relationship between the input image and the output image is used to calculate the geographic coordinates of the edge pixels (first row, first column, last row, and last column) in the output image to determine the geographic extent of the output image. See also: Figure 3 .

[0055] The resolution of the output image can be determined by using the relationship that the number of pixels on the diagonal of the output image and the input image are equal, as well as the geographical range of the output image determined above.

[0056] S102: All processes determine their respective image data blocks to be processed based on the output image information and local computing resources;

[0057] Specifically, image data segmentation (adapted to GPU memory and computing power characteristics): Extensive data testing revealed that row-by-row segmentation is faster than other segmentation methods. Therefore, this invention adopts the row-by-row segmentation strategy while optimizing the segmentation logic based on GPU hardware characteristics: Each process processes a certain number of consecutive data blocks. To balance memory and GPU memory usage, each process further divides the consecutive rows into smaller blocks for processing. To achieve process load balancing and full utilization of GPU computing power, image rows are evenly distributed according to the total number of MPI processes during segmentation, while strictly controlling the data size of a single block to not exceed the GPU memory safety threshold (to avoid memory overflow), ensuring that the processing time of each process is approximately equal, and that the block size is adapted to the GPU thread block scheduling characteristics.

[0058] For example: Suppose an image has N rows, which are divided among n processes, and the size of a single data block must meet the GPU's memory requirements; then process 0 processes the data block from row 0 to N / n, process 1 processes the data block from row N / n to 2*N / n, ..., process n-1 processes the data block from row (n-1)*N / n to N; each process further subdivides the data based on its local GPU memory capacity and thread parallelism efficiency, so that the smaller data blocks can be efficiently loaded into the GPU and fully utilize its multi-core computing power. For specific block division logic, please refer to... Figure 4 (This reflects the collaborative design of MPI block partitioning and GPU hardware adaptation).

[0059] S103: Each process reads its block of data and uses the local GPU to execute the system geometry correction core calculation for that block in parallel;

[0060] S104: Each process writes the calculated results back to the corresponding position of the output image.

[0061] Specifically, the MPI+GPU collaborative parallel system performs geometric correction: based on the data block information (starting position and block size of the process) in step S102, all processes further subdivide the data blocks according to the GPU memory capacity (reducing host memory usage while ensuring efficient loading of individual data blocks into the GPU); then, the corresponding data blocks are read according to the block information, and the data is transferred from host memory to GPU memory; relying on the geometric correction function chain of "RPC coordinate transformation relationship construction - finding the positional relationship of output points in the input image - image resampling", the core calculations are performed in parallel on the GPU, as follows:

[0062] Based on image row and column coordinates and geodetic latitude and longitude coordinates The mapping relationship between the two is calculated by the GPU in parallel, which calculates the position of each pixel in the input image of the output image: by mapping the GPU threads to pixels one by one, the RPC model is solved in batches, and the coordinate transformation of all pixels in the block is processed at the same time. Compared with the CPU serial calculation, the time for building the mapping relationship is greatly shortened.

[0063] The position coordinates of pixels in the output image within the input image are usually not integers (see [reference]). Figure 2 To ensure the smoothness of the output image, spatial interpolation is required to calculate the pixel values ​​of each pixel in the corrected image. During this process, the GPU adopts a two-dimensional parallel strategy of "band-pixel" for the hyperspectral multi-band characteristics: each thread block is responsible for the interpolation calculation of one band, and the threads within the thread block correspond to different pixels of the same band, synchronously completing the solution of multi-band pixel values, thus avoiding the efficiency bottleneck of CPU single-band serial processing.

[0064] This invention achieves distributed segmentation of output images through MPI, combined with parallel processing of single blocks of data by GPU. This not only saves host memory and GPU video memory resources through the segmentation strategy, but also improves computational efficiency by leveraging the high-density parallel capabilities of GPU. The overall parallel computing time is positively correlated with the image size and the number of bands. Moreover, the more bands there are (such as hundreds of bands in hyperspectral imaging), the more significant the advantages of multi-band parallelism of GPU become. Compared with pure MPI parallelism or CPU serial processing, the efficiency improvement is more obvious.

[0065] To verify the efficiency of the hyperspectral imaging system geometric correction method provided by this invention, a comparative experiment on system geometric correction was conducted using hyperspectral data (containing 150 bands) from a certain company's XIGUANG-02 satellite as an example. The experiment was divided into two groups: (1) an efficiency comparison between the MPI parallel correction method and the traditional serial correction method; and (2) a performance benchmarking between the GPU-accelerated correction scheme and the CPU-based pure computation correction scheme. Three core indicators were selected to measure the parallel computation efficiency, as follows:

[0066] The time complexity of serial computation is calculated using the following formula:

[0067]

[0068] The time complexity of parallel computing is calculated using the following formula:

[0069]

[0070] The acceleration ratio is calculated using the following formula:

[0071]

[0072] Efficiency, calculated using the following formula:

[0073]

[0074] Among them, large This represents the worst-case time complexity of the algorithm. The time complexity of the algorithm is proportional to the size of the y-image, V. For the size of the image, The speedup ratio is directly proportional to the number of processes. Efficiency measures the utilization of multiple processors during computation, and is typically less than or equal to 1. The closer to 1, the higher the efficiency of the P processors. Table 1 shows the execution time, speedup ratio, and efficiency of the parallel system for geometric correction of Xiguang 02 satellite imagery (2000×2200).

[0075] Table 1. Geometric correction execution time, speedup ratio, and efficiency of the parallel system for XIGUANG-02 satellite hyperspectral data. Number of processes Execution time (seconds) acceleration ratio efficiency 1 15.70 1 1 2 12.15 1.24 0.62 3 8.31 1.89 0.63 4 6.34 2.47 0.62 5 5.15 3.05 0.61

[0076] The table shows that the speedup ratio is roughly proportional to the number of processes. However, as the number of processes increases, the increase in speedup ratio decreases. This is because as the number of processes increases, the proportion of time spent on algorithm computation gradually decreases, while the proportion of time spent on inter-process communication continuously increases, causing the rate of increase in speedup ratio to slow down. Additionally, process 0 needs to parse input parameters and create output files, while other processes are in a waiting state. As the number of processes increases, the proportion of time spent on algorithm computation gradually decreases, and the time spent by process 0 alone increases, also leading to a decrease in the rate of increase in speedup ratio. Figure 5 This is a graph showing the change in parallel execution time of the system geometry correction as a function of the number of processes, as illustrated in the example. Figure 6 (See the parallel speedup diagram for the system geometry correction in the example)

[0077] To quantify the efficiency difference between CPU and GPU in computationally intensive scenarios (such as pixel-level batch processing of hyperspectral images), this experiment increases the total computational load by performing repetitive loop calculations on each pixel (simulating high-frequency calls to core operations such as pixel-level RPC conversion and resampling in hyperspectral correction). By gradually increasing the number of loops (i.e., stepwise increasing the computational load), the system compares the processing time and speedup ratio of the two. The comparison results are shown in Table 2 below (simulating pixel-level loop calculation scenario of hyperspectral images).

[0078] Table 2. CPU / GPU System Geometric Correction Execution Time and GPU Speedup Ratio for XIGUANG-02 Satellite Hyperspectral Data Cycle number Execution time (CPU) Execution time (GPU) GPU acceleration 10 31.6405 16.4128 1.88 20 35.3897 15.5174 2.22 30 46.5180 16.6310 2.73 40 55.3930 16.5586 3.26 50 63.3314 16.5831 3.72 60 75.0494 17.1718 4.26 70 86.5849 17.7289 4.76 80 100.4438 16.2776 6.02 90 117.2339 16.2251 7.05 100 133.0014 16.1107 8.05 110 141.4640 16.4014 8.41 120 144.8392 17.3514 8.14 130 164.9005 16.4916 9.75 140 180.7507 17.7140 9.95 150 188.1372 16.3514 11.22

[0079] As can be seen from the table above, the speedup of the GPU shows a significant upward trend as the number of loops increases (the amount of computation increases linearly): the CPU, limited by the number of cores and the serial loop mechanism, struggles to break through the single-thread processing limit under the parallel computing requirements of multiple pixels and multiple bands, and the time consumption increases approximately linearly with the increase in the amount of computation; while the GPU, relying on the three-dimensional parallel mapping architecture of "band-pixel-repeated computation", efficiently distributes massive loop tasks to thousands of GPU cores for parallel processing - when the amount of computation increases, it only needs to extend the execution time of a single thread, without additional task scheduling overhead. Therefore, the parallel efficiency advantage becomes more and more significant as the amount of computation increases. Figure 7 (See the graph showing the increase in geometry correction time for the CPU / GPU system as a function of computational load in the example).

[0080] The results of the two sets of verification experiments above fully demonstrate that when the scale of hyperspectral data expands (such as an increase in the number of bands and a surge in total computational load due to improved pixel resolution), the MPI+GPU collaborative architecture proposed in this invention can fully unleash the high-density parallel computing power of the GPU, effectively break through the traditional computing performance bottleneck dominated by the CPU, and provide reliable technical support for the efficient processing of large-scale, high-dimensional hyperspectral images.

[0081] The above-disclosed embodiments are merely one or more preferred embodiments of this application and should not be construed as limiting the scope of this application. Those skilled in the art can understand that all or part of the processes for implementing the above embodiments and equivalent changes made in accordance with the claims of this application still fall within the scope of this application.

Claims

1. A geometric correction method for hyperspectral imaging systems accelerated by MPI peer-to-peer mode and GPU, characterized in that, Includes the following steps: Process 0 parses the input parameters and creates the output image, then broadcasts the input parameters to other processes. Each process determines its own image data block to be processed based on the output image information and local computing resources; Each process reads its block of data and uses the local GPU to execute the system geometry correction core calculation for that block in parallel; Each process writes the calculated results back to the corresponding position in the output image.

2. The geometric correction method for hyperspectral imaging systems using MPI peer-to-peer mode and GPU co-acceleration as described in claim 1, characterized in that, Process 0 parses the input parameters and creates the output image, then broadcasts the input parameters to other processes, specifically including: The system parses the input image, input RPC or RPB file, and output file; calculates the size and six-parameter information of the output image after geometric correction based on the input image and RPC parameters, and creates the output image.

3. The geometric correction method for hyperspectral imaging systems using MPI peer-to-peer mode and GPU co-acceleration as described in claim 1, characterized in that, Each process determines its own image data block to be processed based on the output image information and local computing resources, which also includes: All processes synchronously complete the initialization of the local GPU environment; the initialization includes allocating GPU memory space for each process and creating a CUDA context for executing GPU kernel functions.

4. The geometric correction method for hyperspectral imaging systems using MPI peer-to-peer mode and GPU co-acceleration as described in claim 1, characterized in that, Each process determines its own image data block to be processed based on the output image information and local computing resources, specifically including: A row-by-row block strategy is adopted; each process calculates the starting row position of the image block to be processed, the number of sub-block rows transferred to the GPU for processing in a single time, and the total number of rows that the process needs to process, based on the total number of rows of the output image, the total number of MPI processes, and the local GPU memory capacity. The number of sub-block rows ensures that the corresponding data volume does not exceed the GPU memory limit.

5. The geometric correction method for hyperspectral imaging systems using MPI peer-to-peer mode and GPU co-acceleration as described in claim 4, characterized in that, Each process determines its own image data block to be processed based on the output image information and local computing resources, specifically including: Each process, based on the memory capacity and parallel computing capabilities of its local GPU, internally subdivides the allocated contiguous rows of data into multiple smaller sub-blocks for cyclic processing.

6. The geometric correction method for hyperspectral imaging systems using MPI peer-to-peer mode and GPU co-acceleration as described in claim 1, characterized in that, Each process reads its block of data and uses the local GPU to execute the system geometry correction core calculation for that block in parallel, which includes the following steps: The system is based on the RPC model for coordinate transformation calculation, finding the corresponding position of the output image pixel in the input image, and resampling interpolation calculation for multi-band images.

7. The geometric correction method for hyperspectral imaging systems using MPI peer-to-peer mode and GPU co-acceleration as described in claim 6, characterized in that, Coordinate transformation calculation based on the RPC model specifically includes: By mapping each pixel to be corrected to a GPU thread, the multi-core parallel capabilities of the GPU are utilized to solve the RPC rational polynomial function model in batches and synchronously, thereby accelerating the construction of the mapping relationship from the output image pixel coordinates to the input image pixel coordinates.

8. The geometric correction method for hyperspectral imaging systems using MPI peer-to-peer mode and GPU co-acceleration as described in claim 6, characterized in that, Resampling interpolation calculations are performed on multi-band images, specifically including: To address the multi-band characteristics of hyperspectral images, a band-pixel two-dimensional parallel strategy is adopted: a GPU thread block is allocated to each band of the image, and the threads within each thread block are responsible for the interpolation calculation of the next pixel in that band, thereby achieving synchronous parallel processing across bands and across pixels.

9. The geometric correction method for hyperspectral imaging systems using MPI peer-to-peer mode and GPU co-acceleration as described in claim 4, characterized in that, The strategy of dividing data into blocks by row includes: The goal is to perform block computation with the aim of making the processing time required for each process to complete its block computation approximately equal, thereby achieving load balancing among MPI processes.

10. The geometric correction method for a hyperspectral imaging system using MPI peer-to-peer mode and GPU co-acceleration as described in claim 8, characterized in that, The interpolation calculation specifically includes: For pixels in the output image whose corresponding positions in the input image are non-integer coordinates, a spatial interpolation algorithm is executed in parallel by a GPU thread to determine their final pixel values.

Images