A Fast Inverse Synthetic Aperture Radar Imaging Scheme Combining GPU-Accelerated Shooting and Bouncing Ray and Back Projection Algorithm under Wide Bandwidths and Angles

Abstract

Inverse synthetic aperture radar (ISAR) imaging techniques are frequently used in target classification and recognition applications, due to its capability to produce high-resolution images for moving targets. In order to meet the demand of ISAR imaging for electromagnetic calculation with high efficiency and accuracy, a novel accelerated shooting and bouncing ray (SBR) method is presented by combining a Graphics Processing Unit (GPU) and Bounding Volume Hierarchies (BVH) tree structure. To overcome the problem of unfocused images by a Fourier-based ISAR procedure under wide-angle and wide-bandwidth conditions, an efficient parallel back projection (BP) imaging algorithm is developed by utilizing the GPU acceleration technique. The presented GPU-accelerated SBR is validated by comparison with the RL-GO method in commercial software FEKO v2020. For ISAR images, it is clearly indicated that strong scattering centers as well as target profiles can be observed under large observation azimuth angles, $\Delta \phi =90°$, and wide bandwidths, 3 GHz. It is also indicated that ISAR imaging is heavily sensitive to observation angles. In addition, obvious sidelobes can be observed, due to the phase history of the electromagnetic wave being distorted resulting from multipole scattering. Simulation results confirm the feasibility and efficiency of our scheme by combining GPU-accelerated SBR with the BP algorithm for fast ISAR imaging simulation under wide-angle and wide-bandwidth conditions.

1. Introduction

Inverse synthetic aperture radar (ISAR) is a powerful active microwave imaging radar system widely utilized in military and civil applications due to its capability to produce high-resolution images for moving targets in almost all-weather and all-day conditions [1,2,3]. ISAR images can be obtained by focusing scattering field data at multiple angles and frequencies, which are a two-dimensional representation of the target scattering center [4,5,6]. The simulation of ISAR imaging for electrical large targets is extremely time-consuming, due to the calculation of multiple angles and frequencies’ scattering field. Several methods and their improved versions as well as acceleration techniques have been developed to efficiently calculate the scattering from electrical large targets, including both the low-frequency numerical method and high-frequency approximation methods [7,8]. Due to the tremendous computational time and memory requirements, pure numerical methods such as method of moments (MoM) and finite element method (FEM) are facing enormous challenges [9]. Due to the good compromise between accuracy and efficiency, high-frequency approximation methods are widely utilized in ISAR imaging simulation for electrical large targets. Among them, the shooting and bouncing ray (SBR) method is the most popular one, which is a combination of physical optics (PO) and geometrical optics (GO) and is suitable for taking multiple scattering into account.

Following the proposal of the SBR method by Ling in 1989, researchers have implemented numerous improvements [10], such as the time domain shooting and bouncing ray method (TDSBR), bidirectional analytic ray tracing [11], etc. These advancements have contributed to the growing popularity of the bouncing ray method. In recent years, a GPU-accelerated bouncing ray method is proposed based on a stackless k-dimension (Kd) tree traversal algorithm, enabling the ray tracing process to be efficiently carried out in the GPU [12]. In [13], an enhanced bouncing ray method using a ray propulsion technique is proposed to accelerate the ray tracing process and enhance the ray intersection efficiency, making it able to efficiently calculate the scattering characteristics of electrically large targets. In [14], the inclusion of reverse ray paths in the SBR method is proposed to improve the accuracy of cavity radar cross section (RCS) predictions, which can be implemented into existing SBR code almost trivially, while producing potentially substantial improvements in prediction accuracy. A reverse ray tracing technique is proposed based on the ropes Kd-tree data structure, which has been demonstrated to yield satisfactory results in the calculation of high-frequency scattering characteristics [15]. In addition to the enhancement of SBR through the utilization of GPUs and data structures, the SBR method has also been integrated with other electromagnetic computational methods, thereby rendering this method more comprehensive in its consideration of the electromagnetic scattering characteristics of complex target structures [16,17,18,19]. For instance, the octree-based SBR method in combination with the physical theory of diffraction (PTD) is presented for the analysis of electromagnetic (EM) scattering from the moving target [20]. In [21], a hybrid method of equivalent dipole moment (EDM), MOM, and SBR is proposed to enhance the computational efficiency of the RCS of complex objects within the EDM framework. In this hybrid method, an iterative approach is introduced to enhance the algorithm performance, offering high accuracy and reducing the computational time.

On the basis of electromagnetic scattering modeling, focused ISAR images can be obtained by applying a signal processing algorithm, including the range Doppler (RD) algorithm, polar format algorithm (PFA), back projection (BP) algorithm, etc. [22,23,24]. The most commonly used ISAR imaging algorithm interpolates the polar data to a Cartesian grid and then applies a 2-D FFT to achieve ISAR reconstruction. As a special case, under small-angle and small-bandwidth conditions, ISAR images can be approximately obtained by performing inverse Fourier transform of 2D backscattered field data, and the resultant ISAR images are composed of the scattering centers of target with their electromagnetic reflection coefficient. Due to its suitability for GPU parallel processing and ability for ISAR imaging in any mode, the BP algorithm and its modified versions are extensively used in SAR/ISAR imaging applications [25]. As early as in 1989, a simplified BP algorithm and its parallel processing architecture were proposed by using the radar waveform as the impulse response of the filter to obtain the filtered projection [26]. Up to now, the GPU-based BP algorithm is still being developed to optimize the peak performance of the BP algorithm on servers and miniaturized GPU devices, which can deal with the differences in hardware platforms as well as the differences in data scales [27]. In [28], an ISAR imaging algorithm for composite target–ocean scenes based on time-domain shooting and bouncing rays (TDSBRs) is developed. In [29], time-domain iterative physical optics (TD-LIPO) is proposed to analyze scattering from electrically large and complex targets. In [30], an accelerated time-domain iterative physical optics method is developed for analyzing the scattering from electrically large and complex targets, and an IFFT is performed to obtain the ISAR image under small-bandwidth and small-angle conditions.

Aiming at ISAR imaging for electrical large targets under large-bandwidth and wide-angle conditions, this paper is devoted to a scheme of ISAR imaging by combining GPU-accelerated SBR based on GPU and BVH tree acceleration with the GPU-accelerated BP algorithm. To enhance ray intersection efficiency, a BVH tree structure is constructed according to the target structure, which is implemented in C++AMP to achieve GPU parallel acceleration computation. The SAH method is incorporated into the scene bounding box division, effectively mitigating the impact of bounding box overlapping on the ray traversal efficiency of the BVH tree structure. To efficiently perform ISAR imaging simulation, a GPU-based accelerated BP imaging algorithm is developed by virtue of a compute unified device architecture (CUDA).

This paper is organized as follows: Section 2 introduces a GPU-accelerated SBR using BVH tree structure. In Section 3, the GPU-accelerated BP imaging algorithm is presented. In Section 4, the results and discussion are presented, and several simulations are performed to confirm the feasibility and efficiency of our scheme by combining GPU-accelerated SBR with the BP algorithm for fast ISAR imaging simulation under wide-angle and wide-bandwidth conditions. Section 5 concludes this paper.

2. A GPU-Accelerated SBR Using BVH Tree Structure

2.1. Calculation of Multiple Scattering Using PO and GO

As a high-frequency approximation method, the shooting and bouncing ray method is a combination of PO and GO, which uses GO to trace the electromagnetic wave reflection path and PO to calculate the scattering field, resulting in a great advantage in solving electromagnetic scattering problems for complex targets [31]. According to PO approximate theory, target surfaces are divided into bright and dark areas, depending on whether the surfaces are illuminated by electromagnetic waves or not. The total field scattered from the dark area is assumed to be zero. However, this assumption is only valid when the wavelength of the electromagnetic wave is much smaller than the target geometry. It becomes difficult to determine the total field of the area on the target that is not directly illuminated by the incident wave when the target’s dimensions are very large along the perpendicular direction of the incident wave. Assuming a total field of zero on the shaded surface would imply a discontinuity in the field on the shaded boundary. Therefore, to resolve the discontinuity in the boundary field, a line integral must be added on the boundary [32,33]. In Figure 1, a schematic diagram of multiple scattering of SBR is illustrated, in which only the 1st reflection (in yellow arrows) and 2nd reflection (in green arrows)are depicted.

The PO field of the perfect electric conductor (PEC) target at position ${\mathit{r}}_s$ can be expressed as [34]

$$\begin{array}{cc}\hfill {\mathit{E}}_s^{po}\left({\mathit{r}}_s\right)& =-jk\eta {\displaystyle \underset{S}{\int }\left[{\widehat{\mathit{k}}}_s\times \left({\widehat{\mathit{k}}}_s\times \mathit{J}\right)\right]}G\left({\mathit{r}}_s,{\mathit{r}}^{\prime }\right)d{S}^{\prime }\hfill \\ & =-jk\eta {\displaystyle \frac{H_i{\mathrm{e}}^{-jk\left({\mathit{r}}_s-{\mathit{r}}^{\prime }\right)}}{2\pi r_s}}{\displaystyle \underset{S}{\int }\left\{{\widehat{\mathit{k}}}_s\times \left[{\widehat{\mathit{k}}}_s\times \left(\widehat{\mathit{n}}\times {\widehat{\mathit{h}}}_i\right)\right]\right\}}{\mathrm{e}}^{-jk\left({\widehat{\mathit{k}}}_i-{\widehat{\mathit{k}}}_s\right)\cdot {\mathit{r}}^{\prime }}d{S}^{\prime }\hfill \end{array}$$

(1)

where ${\widehat{\mathit{h}}}_i$ is direction vector of the incident magnetic field and ${\widehat{\mathit{k}}}_i$ is electromagnetic wave propagation direction vector. ${\widehat{\mathit{k}}}_s$ is the unit vector of the scattering wave direction. $S$ represents the area illuminated by the incident wave, and ${\mathit{r}}^{\prime }$ is the source point location. In far field zone, Green’s function in free space can be approximated as [35]

$$\mathrm{G}(\mathit{r},{\mathit{r}}^{\prime })\approx {\displaystyle \frac{{\mathrm{e}}^{-\mathit{jk}\cdot (\mathit{r}-{\mathit{r}}^{\prime })}}{4\pi \left|\mathit{r}\right|}}$$

(2)

When the radius of curvature at a point on the target is much larger than the wavelength of the incident wave, tangential plane approximation can be applied, and the induced current can be expressed as [36]

$$\mathit{J}=\widehat{\mathit{n}}\times \mathit{H}=\{\begin{array}{ll}2\widehat{\mathit{n}}\times {\mathit{H}}_i& \mathrm{Illuminated} \mathrm{region}\\ 0& \mathrm{Shadow} \mathrm{region}\end{array}$$

(3)

In Figure 2, $D_m$ is the area of the ray tube at the $m$ ray, and $D_{m+1}$ is the area of the ray tube at the reflected ray of the $m$ ray. Rays cause changes in the amplitude and phase of the electric field as they propagate and reflect, and information about the strength and phase of the electric field of each ray tube is tracked at each reflection point. In GO, the electric field at ${\mathit{r}}_m$ is related to the electric field at its reflected ${\mathit{r}}_{m+1}$ according to the following equation.

$${\mathit{E}}^s\left({\mathit{r}}_{m+1}\right)={\Gamma }_m\cdot {\mathit{E}}^s\left({\mathit{r}}_m\right)\cdot {\left(DF\right)}_m\cdot {\mathrm{e}}^{-j\beta }$$

(4)

In Equation (4), ${\Gamma }_m$ denotes the reflection coefficient at ${\mathit{r}}_m$. For a perfect conductor, ${\Gamma }_m=-1$ for horizontal polarization and ${\Gamma }_m=1$ for vertical polarization. The divergence factor ${\left(DF\right)}_m$ at ${\mathit{r}}_m$ is usually denoted by ${\left(DF\right)}_m\approx \sqrt{D_m/D_{m+1}}$.$\beta =k_0\left|{\mathit{r}}_{m+1}-{\mathit{r}}_m\right|$, which represents the phase difference between two neighboring reflection points. Substituting Equation (1) into Equation (4), the scattered field after reflection of the m-th ray can be expressed as [37,38,39,40].

$$\begin{array}{cc}\hfill {\displaystyle \sum _x{\mathit{E}}_{\Delta x}^{po}\left({\mathit{r}}_m\right)}& =-jk\eta {\Gamma }_m{\left(DF\right)}_m{\mathrm{e}}^{-jk\left|{\mathit{r}}_{m+1}-{\mathit{r}}_m\right|}{\displaystyle \sum _x{\displaystyle \underset{\Delta x}{\int }\left[{\widehat{\mathit{k}}}_s\times \left({\widehat{\mathit{k}}}_s\times \mathit{J}\right)\right]}G\left({\mathit{r}}_m,{\mathit{r}}^{\prime }\right)}d{S}^{\prime }\hfill \\ & =-jk\eta {\Gamma }_m{\left(DF\right)}_m{\mathrm{e}}^{-jk\left|{\mathit{r}}_{m+1}-{\mathit{r}}_m\right|}{\displaystyle \frac{H_i{\mathrm{e}}^{-jk\left({\mathit{r}}_m-{\mathit{r}}^{\prime }\right)}}{2\pi \left|r\right|}}{\displaystyle \sum _x{\displaystyle \underset{\Delta x}{\int }\left\{{\widehat{\mathit{k}}}_s\times \left[{\widehat{\mathit{k}}}_s\times \left(\widehat{\mathit{n}}\times {\widehat{\mathit{h}}}_i\right)\right]\right\}}}{\mathrm{e}}^{-jk\left({\widehat{\mathit{k}}}_i-{\widehat{\mathit{k}}}_s\right)\cdot {\mathit{r}}^{\prime }}d{S}^{\prime }\hfill \end{array}$$

(5)

In Equation (5), ${\displaystyle \sum _x{\mathit{E}}_{\Delta x}^{po}\left({\mathit{r}}_m\right)}$ is the PO field generated by the facet element struck by the m-th ray, and $x$ is the number of facet elements struck. The resulting scattered field for each ray is subsequently superimposed to obtain the total scattered field.

$${\mathit{E}}_s^{SBRtotal}\left(r_m\right)={\displaystyle \sum _1^l{\displaystyle \sum _x{\mathit{E}}_{\Delta x}^{po}\left({\mathit{r}}_m\right)}}$$

(6)

In Equation (6), $l$ is the total number of rays and $\Delta x$ is the area of some triangular face element that was hit.

2.2. GPU-Accelerated Ray Tracing Using BVH Tree Structure

2.2.1. GPU Acceleration Process

In this paper, GPU-accelerated SBR is parallelized using C++ accelerated massive parallelism (C++AMP). In comparison with CPUs, GPUs possess a greater number of cores, making them more suitable for massive parallel processing. C++AMP is a C++-based heterogeneous parallel computing platform released by Microsoft, which is a native programming model with the advantage of running across devices on the Windows platform [41]. Most of the programming methods for GPUs, such as Direct Compute and OpenCL, require different programming languages and compilers. C++AMP unifies the programming language and the compiler, which sets it apart from other approaches. The C++ AMP library enables parallel computation through a set of abstractions and a high-level API, with the underlying GPU hardware being accessed directly through Direct Compute [42,43]. It is important to allocate an array for applying C++AMP to implement parallel computing. The array template is in the concurrency namespace. It takes two parameters: one for the collection element type and the other for the dimension. The dimension of the array is set according to the type of collection elements in this paper method. For example, when collecting swept frequency data, defining an <array a (frequency counts)>, this example defines a one-dimensional array with the size of the array being the number of frequencies. Arrays play an extremely important role in C++AMP by representing a view that can access data on the GPU and encapsulating C++ arrays or vectors, which are arrays on <accelerator_view>. In C++AMP, the GPU is not the only accelerator, and each accelerator has its own default view. Once the array has been constructed, the data will be transferred to GPU memory, where it can be accessed directly by the GPU. The <parallel_for_each> function is used to execute parallel computation tasks. The <parallel_for_each> function is a parallel execution function in C++AMP that accepts a range of indexes and a lambda function, and it executes this lambda function in parallel on the GPU for each index. The <parallel_for_each> function delegates parallel computing tasks to the GPU’s kernel functions, which can be directly assigned to the GPU hardware through the Direct Compute API. The <restrict(amp)> keyword is used to specify that the function is to be executed only on the GPU. It is used to identify specific blocks of code and lambda functions to be executed on the GPU, and it lets the compiler optimize the function for Single Instruction, Multiple Threads (SIMT) [44]. The operations within the function will utilize SIMT instructions to achieve the effect of single instruction multi-thread parallel computation. C++AMP synchronizes the data and copies them from GPU memory back into host memory after the <parallel_for_each> function executes the parallel computation task.

Figure 3 gives a parallel computation process for C++AMP using the Direct Computing API to send parallel instructions to the GPU device. The BVH tree structure as well as the ray data, etc., are constructed in the CPU and stored in the Global Memory of the GPU. The data will be automatically copied from the CPU host to GPU memory by creating the <array_view> array, allowing the GPU to access these data directly. The Constant Memory in the GPU will store data that remain unchanged during parallel computation. Texture Memory is used to store data during model rendering. There are many Streaming Multiprocessors (SMs) in the GPU hardware architecture, and SMs in GPUs use the SIMT architecture. Each SM contains a number of streaming processors (SPs), and each SP corresponds to a thread. A single warp is comprised of 32 threads, with the number of threads per warp being determined by the GPU architecture. Warp is the scheduling and execution unit in SM, where threads in each warp execute computations in parallel. As previously stated, the <parallel_for_each> function assigns tasks directly to the underlying GPU hardware through the Direct Compute API. The GPU assigns instructions to warps in the SM with the SIMT architecture. The SIMT architecture permits the threads within each warp to execute a sequence of instructions, including collision detection, ray tracing, PO field calculation, and other operations, in parallel modes. In the SIMD architecture, the GPU assigns a thread to each ray. The BVH tree structure is obtained by thread accessing the GPU’s Global Memory and is responsible for calculating the ray tracing path and the PO field. In the <parallel_for_each> function, intersection detection and the parallel acceleration of rays and bounding boxes are achieved by traversing the BVH tree structure. After the execution of the <parallel_for_each> function is completed, C++AMP copies the scattered field data from GPU memory to host memory. The CPU will sum the scattered fields of all the rays to obtain the total target scattering field.

The ray information is initialized, and the nodes as well as the structure of the BVH tree are generated in the CPU as illustrated in Figure 4. The CPU will share the data of the BVH tree to the GPU Global Memory and it will share these data with each thread. In the SIMT architecture, instructions are emitted to the warp by the Direct Compute API. Threads in a warp will execute the received instructions sequentially and in parallel, and each thread in a warp will be responsible for the computation of one ray. At this stage, all the rays traverse the BVH tree intersecting the target are recorded, and their reflected rays are traced until the ray leaves the target surface. The GPU calculates the scattered field of this ray and transfers the data to the CPU. Finally, the CPU combines the scattered field data from all the rays to determine the total scattering field from the target.

2.2.2. Ray Tracing Algorithm Using BVH Tree

Figure 5 illustrates the ray tracing process using BVH tree structure with the multiple scattering process of an electromagnetic wave between the tree structures. GO is used to track the scattering path of the electromagnetic wave between the triangular surface tuples, and PO is used to calculate the scattered field of the electromagnetic wave when it hits the triangular surface tuples.

In order to solve the time-consuming ray intersection process in ray tracing, we resort to BVH tree structure on the basis of GPU acceleration. A BVH tree is a computer graphics structure, which is a tuple-based ray intersection detection technique. A BVH tree divides the tuples into a hierarchical structure of disjoint sets, which is widely used in ray tracing and collision detection. We will build the bounding box that encloses the target according to the target geometric features, and its enclosure box structure is an axisymmetric bounding box, an AABB bounding box. In the BVH tree structure, all the tuples are stored in the leaf nodes of the BVH tree, and the middle nodes store the box information. Finally, the whole scene’s information is stored in the BVH tree structure [45]. When traversing the BVH tree, the ray will first judge whether it intersects with the box or not. If it is not intersected, then it will skip all the tuples in the box, achieving an improvement for the ray tracing efficiency.

In Figure 6, the scene contains eight tuples. In Step ①, the tuples are divided into two parts in the scene. If the light rays do not intersect with the bounding box, then they will not intersect with the tuples, which can exclude half of the tuples at one time and thus reduce the number of intersections. In Step ②, we continue to divide the tuples in half, and by doing so, the ray intersection complexity can be reduced from $O\left(n\right)$ to $O\left(\log \right(n\left)\right)$ [46]. After pairwise semi-recursive division, the bounding box that surrounds only one tuple can be found. If a ray intersects this bounding box, the ray continues to intersect with the tuple. The ray parameter equation can be expressed as

$$\mathit{r}(t)=\mathit{o}+t\cdot \mathit{d}$$

(7)

In Equation (7), $\mathit{o}$ and $\mathit{d}$ are ray starting point and the normalized ray direction vector, respectively. Substituting the ray parameter equation into the implicit plane equation of the plane where the tuple is located, the implicit plane equation can be written as

$${\mathit{N}}^T(\mathit{o}+t\cdot \mathit{d})=c$$

(8)

From Equation (8), the parameter $t$ corresponding to the intersection point of the ray with the plane can be resolved as

$$t={\displaystyle \frac{c-{\mathit{N}}^T\cdot \mathit{o}}{{\mathit{N}}^T\cdot \mathit{d}}}$$

(9)

In this paper, the surface element is a triangular surface element, and the plane parametric equation of the triangular surface element is

$$f\left(u,v\right)=(1-u-v)\cdot {\mathit{p}}_0+u\cdot {\mathit{p}}_1+v\cdot {\mathit{p}}_2$$

(10)

where $u$ and $v$ are the triangle center of mass coordinates, satisfying $u\ge 0$, $v\ge 0$, and $u+v\le 1$. The triangular face element can be regarded as the mapping of the unit triangle face element on its three edges

$$f\left(u,v\right)={\mathit{p}}_0+u({\mathit{p}}_1-{\mathit{p}}_0)+v({\mathit{p}}_2-{\mathit{p}}_0)$$

(11)

Combining Equation (11) with Equation (7), one can obtain

$$\underset{M^{-1}}{\underbrace{[{\mathit{p}}_1-{\mathit{p}}_0{\mathit{p}}_2-{\mathit{p}}_0-\mathit{d}] }}\left[\begin{array}{l}u\\ v\\ t\end{array}\right]=\mathit{o}-{\mathit{p}}_0$$

(12)

In Equation (12), $M^{-1}$ is the matrix transforming a triangular face element into a unit triangular face element in the $u,v$ plane, in which the mapped ray is orthogonal to the unit triangular face element. The mapping of triangular surface elements into the $u,v$ plane is illustrated in Figure 7. Figure 7a is the case before mapping, and Figure 7b is the case corresponding to Equation (11). Figure 7c accounts for the intersection of the ray with the unit triangular surface element after mapping.

According to the half-division method, the bounding boxes in the scene may overlap or intersect, and the overlapping of bounding boxes is illustrated in Figure 8. In Figure 8, when the light traverses the BVH tree, the overlapping of bounding boxes causes the light to intersect both bounding boxes, which leads to a decrease in the intersection efficiency.

In order to eliminate the phenomenon of envelope box overlapping, the SAH division method instead of the half-division method is adopted in the process of BVH tree construction. The SAH is based on the surface area heuristic division method, and after adding SAH, we can estimate the probability of the light ray hitting the enveloping boxes in terms of the size of the surface area of the parent enveloping box in which there are two or more overlapping child enveloping boxes.

In the BVH tree structure, under the assumption that the current node has three bounding boxes A, B, and C, the cost of intersecting the ray with the current node is

$$c(A,B,C)=p\left(A\right){\displaystyle \sum _{i\in A}t\left(i\right)}+p\left(B\right){\displaystyle \sum _{i\in B}t\left(j\right)}+p\left(C\right){\displaystyle \sum _{i\in C}t\left(k\right)+t_{\mathit{trav}}}$$

(13)

In Equation (13), ${\displaystyle \sum t\left(i\right)}$ is the intersection cost of each sub-enclosure box, and $t\left(i\right)$ is the $i-\mathit{th}$ tuple in the child enclosure box. $p\left(A\right)$, $p\left(B\right)$, and $p\left(C\right)$ are the probabilities of the light hitting the objects in the bounding boxes A, B, and C, respectively. $t_{\mathit{trav}}$ is the cost of the light traversing the BVH tree.

In SAH, we use the surface area of the child bounding box in the parent node instead of the probability of the ray hitting the bounding box. Assuming that the surface areas of the child bounding boxes A, B, and C are $S\left(A\right)$, $S\left(B\right)$, and $S\left(C\right)$, respectively, and the surface of the parent node bounding box D is $S\left(D\right)$, Equation (13) can be rewritten as

$$c\left(A,B,C\right)={\displaystyle \frac{S\left(A\right)}{S\left(D\right)}}{\displaystyle \sum _{i\in A}t\left(i\right)}+{\displaystyle \frac{S\left(B\right)}{S\left(D\right)}}{\displaystyle \sum _{i\in B}t\left(j\right)}+{\displaystyle \frac{S\left(C\right)}{S\left(D\right)}}{\displaystyle \sum _{i\in C}t\left(k\right)+t_{\mathit{trav}}}$$

(14)

After resolving the optimal division method by calculating the minimum value of Equation (14), the ray traversal of the BVH tree is most efficient [47].

3. GPU-Accelerated BP Imaging Algorithm

3.1. BP Algorithm for ISAR Imaging

Under small-angle and small-bandwidth conditions, ISAR images can be approximately obtained by performing the inverse Fourier transform of 2D backscattered field data, and the resultant ISAR images are composed of the scattering centers of the target with their electromagnetic reflection coefficient. Due to its suitability for GPU parallel processing and ability for ISAR imaging in any mode, the BP algorithm and its modified versions are extensively used in SAR/ISAR imaging applications. The BP imaging algorithm is a method with high imaging accuracy. However, due to its high complexity, the BP algorithm is not as good as other imaging algorithms in terms of imaging speed. Aiming at ISAR imaging for electrical large targets under large-bandwidth and wide-angle conditions, a GPU-based accelerated BP imaging algorithm is developed in this paper by virtue of CUDA, while maintaining the imaging accuracy of the BP algorithm.

The fundamental idea of the BP algorithm involves coherently superimposing the calculated echoes of each pulse by transmitting electromagnetic pulses and calculating the two-way time delay between the pixel points in the imaging area and the radar at the moment of each pulse. The superimposition depends on the phase relationship between pixel points. If the echoes are in phase, the superimposed pixel points’ echoes become increasingly stronger. When pixel points with different phases are superimposed, the effect is weaker. As an accurate time-domain algorithm, the range profile in the BP algorithm is obtained using the pulse compression technique, similar to the Range-Doppler algorithm. The processing of the azimuthal direction is achieved by computing the echoes of the pixel points for coherent superposition, which is related to the angle of rotation of the target with respect to the radar. Azimuthal resolution is observed to increase as the angle between the target and the radar increases, with no apparent limit. For any motion trajectory of the target, if the motion trajectory can be predicted in advance, then the BP algorithm can achieve accurate imaging.

Figure 9 illustrates the schematic diagram of backward projection for ISAR imaging. $xyz$ is a global coordinate system of space target. $XY$ is the local coordinate system. $S$ is the grid for the imaging area. $R_a$ and $R_b$ denote the radar distance from the target at moments $a$ and $b$, respectively. The imaging area is divided into $N\times N$ grids. $\left(X_a,Y_a\right)$ and $\left(X_b,Y_b\right)$ are the positions of the target in the imaging grid at time $a$ and $b$, respectively. $v$ is the speed and direction of the moving target. The transmitting signal is [48]

$$s\left(t,m\right)=\mathrm{rect}\left({\displaystyle \frac{t}{T_p}}\right)\cdot \exp \left(j2\pi f_{0}t+jK\pi t^2\right)$$

(15)

In Equation (15), $t$ is fast time. $T_p$ is the signal pulse width. $m$ is slow time. $\mathrm{rect}$ is a rectangular window function. $f_0$ is the signal carrier frequency. $K={\displaystyle \frac{B}{T_p}}$, $K$ is the signal modulation frequency. $B$ is the signal bandwidth. The received echo is as follows

$$s_r\left(t,m\right)={\displaystyle \sum _{i,j}\mathrm{rect}\left(\frac{t-{\tau }_{i,j}\left(m\right)}{T_p}\right)}\exp \left(j2\pi f_0\left(t-{\tau }_{i,j}\left(m\right)\right)+j\pi K{\left(t-{\tau }_{i,j}\left(m\right)\right)}^2\right)$$

(16)

In Equation (16), ${\tau }_{i,j}\left(m\right)={\displaystyle \frac{2\sqrt{{\left(x\left(m\right)+X_i\right)}^2+{\left(y\left(m\right)+Y_i\right)}^2+z{\left(m\right)}^2}}{c}}$ is the two-way delay from pixel $\left(X_i,Y_i\right)$ in the imaging plane to the radar at the slow time $m$. $x\left(m\right)$, $y\left(m\right)$, and $z\left(m\right)$ are the positions of pixel $\left(X_i,Y_i\right)$ in the imaging grid in the spatial target coordinate system. The matched filter is as follows

$$h\left(t,m\right)=\exp \left(j2\pi f_{0}t-jK\pi t^2\right)$$

(17)

In Equation (17), $t_0$ is the two-way delay at the closest distance between the target and the radar. Converting the time domain convolution to frequency domain multiplication processing, the matched filter output can be expressed as follows

$$s_{out}\left(t,m\right)=\mathrm{IFFT}\left(\mathrm{FFT}\left(s_r\left(t,m\right)\right)\cdot \mathrm{FFT}\left(h\left(t,m\right)\right)\right)$$

(18)

The high resolution in azimuthal is obtained by the coherent accumulation of pulses. The integral formula for coherent accumulation is as follows [49]

$$I\left(x,y\right)={\displaystyle \underset{m}{\int }{s}_{out}\left(t,m\right)\cdot \exp \left(j2\pi f_0{\tau }_{i,j}\left(m\right)\right)dm}$$

(19)

The energy of each pixel point in the grid is coherently superimposed over the target motion time. The pixel value is accumulated by each pixel point during the movement time to synthesize the final image.

3.2. GPU Acceleration of BP Algorithm for ISAR Imaging

Released by NVIDIA in 2006, CUDA is a general-purpose parallel computing platform and programming model built on GPUs. Computations for complex tasks can be performed more efficiently with CUDA programming. In recent years, CUDA programming techniques have been developed in hardware as well as software [50]. At the time of its initial release, CUDA was capable of utilizing GPUs with a limited number of cores, typically in the range of a few dozen or a few hundred. Consequently, it was not possible to make meaningful comparisons in terms of computational power between these early GPUs and the GPUs that are available today [51]. For example, NVIDIA’s NVIDIA RTX 2080, which was released on 20 September 2018, is a GPU with 2944 CUDA cores and an FP32 compute power of 10.07 trillion times per second. However, the NVIDIA RTX 4090 now has 16,384 CUDA cores, with FP32 computing power reaching 82.58 trillion times per second. In recent years, CUDA has widely utilized its powerful parallel computing capabilities in the field of scientific computation [52].

In this paper, we realized the highly parallel BP imaging algorithm by CUDA. The scattered field data obtained by the SBR calculation are first loaded into the GPU Global Memory from the host memory under the <cudaMemcpy> function. These data contain information such as azimuth, angle of incidence, frequency, frequency sampling points, angle sampling points, polarization mode, etc. The specified memory space is allocated for these parameters from the GPU with memory size $N_f\times N_{phi}\times N_{fft}$ by the <cudaMalloc> function. Global variables on the device are defined through the _device_ symbol, including the distance compression signal and the variables used to store the raw scattered field data, the variables used to store the coordinates and radar position, and the variables used to store the final imaging results. Range pulse compression of the raw echo data is performed using the <cufft> function library in CUDA, by which highly parallel FFTs and IFFTs can be realized. The range compression signal is copied into GPU memory using the <cudaMemcpy> function with an allocated memory size $N_f\times N_{phi}\times N_{fft}$.

Parallel accelerated computation is mainly implemented on the device by the CUDA kernel function. Kernel is an important concept in CUDA, and it is a function that is executed in parallel in a thread on the device. The kernel function is declared with the <_global_> symbol, and the number of threads required when calling this function needs to be specified, specifically by <<<grid, block>>>. The kernel function is executed by every thread. The azimuthal focusing process of the BP algorithm is written as a kernel function, and the corresponding number of threads are allocated to the kernel function to enable parallel computation on the GPU.

In Figure 10, the kernel function is responsible for calculating the distances of all pixels from the radar at each azimuthal moment, as well as phase compensation. The position of the corresponding azimuthal signal is determined by the distance of the pixel point from the radar. ISAR imaging using the BP algorithm is obtained by coherently superimposing the echoes of all pixel points at each azimuthal moment. The blocks and threads are defined as one-dimensional when running the CUDA function of the BP algorithm. The distribution of threads in each block is $\left(N_y,1,1\right)$, with $N_x$ blocks in total and $\left(N_x,1,1\right)$ distribution of blocks. $N_x$ and $N_y$ are the number of pixels in the $x$ direction and the number of pixels in the $y$ direction, respectively. In order to optimize the efficiency of the kernel function in processing large-scale data, computational tasks for imaging pixels larger than $500\times 500$ are batch-computed. The maximum number of pixel points computed in each batch is $500\times 500$ in order to adapt to the resource limitations of the GPU. In the kernel function, the GPU allocates 250,000 threads for each batch of computational tasks, with every 500 threads being a block, for a total of 500 blocks. Each thread is responsible for computing the value of one-pixel point, and multiple batches of data will be executed in parallel on the CUDA core.

In Figure 10, the scattered field data are first copied from Host Memory to the GPU Global Memory. Each thread can access the data stored in Global Memory. Constant Memory is a read-only memory used to broadcast instructions sent by the host. Texture Memory is used to store texture data. The number of blocks and threads is determined by the number of pixels $N_x$ in the $x$ direction and the number of pixels $N_y$ in the $y$ direction, respectively. In a block, all threads execute the same instructions, and each thread executes the kernel function. The kernel function relies on threads to realize the highly parallel computation of all the azimuthal focusing calculations.

Figure 11 presents the flow chart of the GPU-accelerated BP algorithm. After range compression, the imaging region is divided into a grid of pixels of size $N_f\times N_{phi}$. If the number of pixel grids in the imaging area is less than $500\times 500$, then a corresponding number of threads are allocated to be responsible for computing the echo data of these pixel grids and accumulating them to the corresponding positions. The combination of these pixel grids is divided into several sub-regions for parallel processing if the pixels are over $500\times 500$. Each thread of the GPU is responsible for processing a one-pixel point, including distance computation, phase compensation, etc. It calculates the current pixel location and accumulates the echo to the corresponding pixel grid. Once each block has completed the computation of its sub-region data, the data are transferred to their respective position in the final image. Finally, the entire image is output.

4. Results and Discussion

4.1. Validation of GPU-Accelerated SBR Method

The implementation of the GPU-accelerated electromagnetic computational method and the GPU-accelerated BP imaging method has been previously presented, as described in this paper. In this section, the validity of GPU-accelerated SBR combining GO with PO approximations is verified by comparison with RL-GO in FEKO v2020 software. Taking a full-scale F-22 fighter as an example, RL-GO is set up with two types of ray densities, one is $\lambda /10$ and the other is $\lambda /100$. A comparison of far-field RCS is made with the electromagnetic wave frequency $f_0=3\mathrm{GHz}$. The model dissection produced 2444 triangular meshes, and the BVH tree was constructed to produce 4887 leaf nodes. The CAD model is as in Figure 12. The calculation time and memory cost are listed in

Table 1. A comparison of calculation time and memory cost for a full-scale F-22 fighter.

	Polarization	Calculation Time (s)			Memory (MB)
		This Paper $\mathit{\lambda }/10$	RL-GO $\mathit{\lambda }/10$	RL-GO $\mathit{\lambda }/100$	This Paper $\mathit{\lambda }/10$	RL-GO $\mathit{\lambda }/10$	$\mathbf{RL}-\mathbf{GO} \mathit{\lambda }/100$
Figure 13a	VV	207.96	186.4	2303.3	557.6	130.9	181.4
Figure 13b	HH	433.195	103.1	1427.43	552.1	136.4	185.1

. Our computer’s CPU is a 12th Gen Intel(R) Core (TM) i5-12490F with a benchmark speed of 3.00 GHz, manufactured by Intel Corporation for China special edition products. The GPU is an NVIDIA GeForce RTX 2080 with 8.0 GB of dedicated GPU memory, manufactured by NVIDIA Corporation in China mainland.

Figure 13 shows the comparison of the RCS angular distribution of a full-scale F-22 fighter obtained by our GPU-accelerated SBR method and the parallel RL-GO method in FEKO. From Figure 13a,b, it is observed that the RCS calculated by our GPU-accelerated SBR method is generally in good agreement with that by the RL-GO method in FEKO. There is a slight difference between our GPU-accelerated SBR method and the parallel RL-GO method with a ray density of $\lambda /100$ in FEKO due to the effect of ray density, and the RL-GO method with a ray density of $\lambda /100$ also takes the diffraction field [53] into account.

4.2. ISAR Imaging Simulations

In this section, ISAR imaging results of representative aircraft target are presented and discussed. The matrix of the backscattered field of representative aircraft targets is calculated by our GPU-accelerated SBR method, and then the echoes are focused to obtain ISAR images by utilizing the GPU-accelerated BP algorithm developed in this paper. For comparison, our GPU-accelerated BP algorithm was also applied to focus the backscattered field by employing the RL-GO method in the FEKO v2020 software to obtain focused ISAR.

Figure 14 shows the CAD model of a scaled A380 aircraft model with dimensions. This model has 3770 triangles. Figure 15a–c illustrate three typical observation configurations with different azimuthal scanning ranges. The incidence angle is fixed at $\theta =60°$. The ISAR imaging parameters for Figures 16 and 18 are set as in

Table 2. Parameters of ISAR simulation for Figures 16 and 18.

Parameter	Value
$f_0$	1.75 GHz
$B$	3 GHz
$\Delta \phi$	90
$\theta$	60 or 120
$\Delta x$	0.05 m
$\Delta y$	0.05 m
Sampling points	200
Polarization	VV

.

Figure 16 presents ISAR imaging results for three typical observation configurations with different azimuthal scanning ranges. The incidence angle is fixed at $\theta =60°$. Our GPU-accelerated BP imaging algorithm is applied to focus the backscattering fields to obtain focused ISAR images. In Figure 16, Figure 16d–f are RL-GO at a ray density of $\lambda /10$ without diffraction and Figure 16g–i are RL-GO at a ray density of $\lambda /100$ with diffraction. Comparing Figure 16a–c and Figure 16d–f, it can be found that the results of this paper’s method and the RL-GO method are in better agreement with those obtained by FEKO’s RL-GO method under the condition of the same ray density, and it even outperforms the RL-GO at specific angles. For example, in Figure 16a,d, the difference in the scattering in the engine part of the airplane can be seen to be more obvious, and the differences in the scattering in the engine area of the airplane can be seen to be more obvious in Figure 16c,f; Figure 16f has strong clutter that overwhelms the information such as the structural features of the airplane, and the results of Figure 16f are not as good as the results of Figure 16c. When the ray density is $\lambda /100$, the echoes are able to record the geometrical structural features of the airplane in detail, so Figure 16g–i have very good imaging results compared to Figure 16a–c and Figure 16d–f, which confirms the effectiveness of the GPU-accelerated BP imaging algorithms in this paper from the side.

Table 3. Computation time and peak memory for Figure 16.

	SBR		RL-GO
	Time (s)	Memory (MB)	Time (s)	Memory (MB)
Figure 16a,d	2423.3	76.2	1584.2	177.8
Figure 16b,e	2669.8	78.4	1614.3	179.6
Figure 16c,f	2623.3	72.5	1474.1	179.5

shows the computation time and peak memory comparisons for Figure 16.

It can be concluded that when the ray density is the same, the results of the method in this paper are in good agreement with those of RL-GO. Next, we analyze the difference between the results of the two methods when the ray densities are not the same. In Figure 16a, there are strong echoes from both the engine and the wing portion attached to the engine. The area indicated by the red arrow ① in (a) represents the wing position. At the observation angles $\phi =45°~135°$, the ray will be reflected once after striking the wing portion at position ①. Due to the flatness of this portion of the structure, the ray will subsequently leave the target after being reflected. In our GPU-accelerated SBR method, multiple scattering is taken into account by ray tracing, in which the maximum reflection number is 10, while the diffraction field due to target edges is not taken into account, which leads to a pronounced difference between position ① in (a) and position ② in (g). Scattering spots appear at the positions indicated by the green arrows ③, ④, ⑤, and ⑥ in Figure 16a,b,g,h. Figure 16a,b are the results calculated by the method in this paper, and Figure 16g,h are the results calculated by the RL-GO with diffraction at a ray density of $\lambda /100$ in FEKO. Both our GPU-accelerated SBR and RL-GO in FEKO are ray-based methods. These scattering spots are related to the scattering mechanism of the electromagnetic waves and the ray tracing mechanism. Due to neglection of the diffraction field resulting from target edges, the target echo in Figure 16c is weaker than that in Figure 16i. A comparison of the ISAR imaging results of Figure 16a–c with Figure 16d–f and Figure 16g–i demonstrates the feasibility and efficiency of our scheme by combining GPU-accelerated SBR with the BP algorithm for fast ISAR imaging simulation.

Figure 17a–c illustrate three typical observation configurations with different azimuthal scanning ranges. ISAR imaging results for three typical observation configurations with different azimuthal scanning ranges are shown in Figure 18a, b, and c, respectively. In Figure 18, the incidence angle is set as $\theta =120°$, and the other parameters are the same as those in Figure 16. In Figure 18a–c, the backscattering fields are calculated by our GPU-accelerated SBR method. In Figure 18d–i, the backscattering fields are obtained by the RL-GO method in FEKO v2020 software, where (d–f) are RL-GO at a ray density of $\lambda /10$ and (g–i) are RL-GO at a ray density of $\lambda /100$. Since the ray densities are the same and none of them include the wrap-around field, the results for the corresponding angle ranges in (a–c) and (d–f) are in good agreement. A comparison of the results of (c) and (f) shows that the echo strength of the airplane body is very weak in (f). There is also noise. Only the engine area exhibits strong echoes, which makes this paper’s method work better under the same ray densities and it can better record the target’s geometric structure information. In general, the focused ISAR images of backscattered fields calculated by our GPU-accelerated SBR method are in good agreement with those obtained by FEKO’s RL-GO method. Some scattering spots can be observed as indicated by the red arrows in Figure 18a,b,g,h, as in Figure 16. This is due to multiple scattering of electromagnetic waves from the target surface. For rays reflected multiple times, the phase history of the electromagnetic wave is distorted. Therefore, the scattering spots indicated by the red arrows in Figure 18a,b,g,h can be eliminated by reducing the reflection numbers in the ray tracing algorithm.

Table 4. Computation time and peak memory for Figure 18.

	SBR		RL-GO
	Time (s)	Memory (MB)	Time (s)	Memory (MB)
Figure 18a,d	2315.2	72.4	1655.6	194.6
Figure 18b,e	2647.05	74.2	1702.4	202
Figure 18c,f	2872.9	77.1	1764.2	196.9

shows the computation time and peak memory comparisons for Figure 18.

Figure 19 shows a CAD model of an electrically large-sized aircraft target, which is in the electrically large-sized category with an electrical size of 171 × 104 wavelengths. This CAD model has 712 face elements. ISAR images for this model were computed using the method in this paper and the RL-GO method in FEKO. The ray densities for both the method in this paper and the RL-GO method are set to be $\lambda /10$. The azimuth centers of Figure 20a–c are $90°$, $0°$, $-90°$. Figure 20 demonstrates three different azimuth ranges. In the following simulations of Figure 21, the ISAR imaging parameters are set as in

Table 5. Parameters of ISAR simulation for Figure 21.

Parameter	Value
$f_0$	1.75 GHz
$B$	3 GHz
$\Delta \phi$	90
$\theta$	60
$\Delta x$	0.05 m
$\Delta y$	0.05 m
Sampling points	600
Polarization	VV

.

Figure 21 shows the ISAR imaging results of both methods for electrically large-sized aircraft targets, with ray densities of $\lambda /10$ for this paper method and RL-GO in FEKO. Comparing Figure 21b and Figure 21e, ① and ② in Figure 21b are the structural information of the airplane, and ① is the wing and ② is the tail, while Figure 21e cannot show this structural information, so this paper’s method is better than the RL-GO imaging result when $\phi =-45°~45°$. Comparing Figure 21a and Figure 21d, the result of Figure 21a is obviously better than that of Figure 21d, where phase history distortion occurs at the place indicated by the white arrows in Figure 21d. Detailed information on the wings, nose, and tail of the aircraft can be clearly displayed in Figure 21a. This also occurs in Figure 21c,f, where the white arrows in Figure 21c,f point. It can be clearly seen that the scattered spots that appear in these places indicated by the arrows are not aircraft structural information. It is a well-established fact that electromagnetic waves exhibit a multipath effect during propagation. This phenomenon entails that an incident wave traverses a multitude of paths to reach a designated receiving point. Changes in phase history data caused by these different paths can be superimposed, resulting in phase history distortion.

Table 6. Computation time and peak memory for Figure 21.

	SBR		RL-GO
	Time (h)	Memory (MB)	Time (h)	Memory (MB)
Figure 21a,d	20.1	141.2	16.3	269.6
Figure 21b,e	19.6	140.7	15.5	258.5
Figure 21c,f	20.7	145.6	16.9	273.1

shows the computation time and peak memory comparisons for Figure 21.

From numerical simulations of ISAR imaging, it is clearly indicated that strong scattering centers as well as target profiles can be observed under large observation azimuth angles and wide bandwidth. It is also indicated that the ISAR images are heavily sensitive to observation angles. Due to multiple scattering, several triangular patches will be hit by identical rays, resulting in the phase history distortion of electromagnetic waves. Phase history distortion is a common problem with ray methods. Thus, obvious sidelobes can be observed in focused ISAR images. In comparison with RL-GO in FEKO v2020 software, the feasibility and efficiency of our scheme are demonstrated by combining GPU-accelerated SBR with BP algorithm for fast ISAR imaging simulations under wide-angle and wide-bandwidth conditions.

5. Conclusions

In this paper, a novel bouncing ray method based on GPU and BVH tree acceleration is presented for ISAR imaging simulations. It employs C++AMP to achieve GPU parallel acceleration computation, in which a BVH tree structure is constructed according to the target structure, thereby enhancing ray intersection efficiency. The SAH method is incorporated into the scene bounding box division, effectively mitigating the impact of bounding box overlapping on the ray traversal efficiency of the BVH tree structure. To efficiently perform ISAR imaging simulations, a GPU-based accelerated BP imaging algorithm has been developed by virtue of CUDA. The accuracy of GPU-accelerated SBR is validated by comparing the RCS calculated by our SBR method with that obtained by RL-GO in FEKO. It is demonstrated that the presented GPU-accelerated SBR shows good validity and reliability. For ISAR imaging simulations, taking an A380 and a simplified aircraft model as examples, the backscattering fields were calculated utilizing the GPU-accelerated SBR algorithm under large azimuth angles, $\Delta \phi =90°$, and wide bandwidths, 3 GHz. The backscattered echoes are focused using the GPU-accelerated BP imaging algorithm, and the focused ISAR images of our GPU-accelerated SBR method are in good agreement with those of FEKO’s RL-GO method, indicating the feasibility and efficiency of our GPU-accelerated BP ISAR imaging algorithm. The simulations indicate that strong scattering centers as well as target profiles can be observed clearly from ISAR images under large observation angles and wide bandwidths. Obvious sidelobes in focused ISAR images can be observed, due to the phase history of electromagnetic waves being distorted resulting from multipole scattering. It is also indicated by numerical simulations that the ISAR imaging results are heavily sensitive to observation angles. In the future, the present work will be extended to swarm targets’ ISAR imaging as well as 3D ISAR imaging by developing an efficient electromagnetic simulation algorithm by combining GPU-accelerated SBR and PTD for taking edge diffraction into account.