*3.2. General Deceptive Scene Case*

In this subsection, the TDFS-TS algorithm is applied to yield a fake scene. The jamming object is RADARSAT-1, whose parameters are listed in Table 1, and the squint angle <sup>θ</sup> ≈ −1.58◦ . The raw data of the radar are obtained from the appendix in [22]. The fake scene template is another SAR image, as shown in Figure 10, whose length in the range dimension is 12.5 km and 4.5 km in the azimuth dimension. We divide the template according to the same block size calculated in Section 2.2.2, as shown by the yellow line in Figure 10.

**Figure 10.** Deceptive jamming template with 12.5 km in the range dimension and 4.5 km in the azimuth dimension, which is divided into blocks by the yellow line. The block size is 2.5 km × 1.5 km.

First, the signals generated by the two algorithms are processed to get the images which are shown in Figure 11 after being amplitude-normalized, and partially enlarged images are shown in Figure 12. Due to the existence of the squint angle, each segment of the image generated by the RDS algorithm has geometric distortion, which is especially obvious at the splicing of each segment. Moreover, since the positions of adjacent scatters in the template are shifted after the imaging process, the image is blurred, and the ghost targets generated by the Doppler center frequency shifting in the azimuth dimension will be more obvious after the amplitude normalization. Actually, for the same reason, the brightness of the image is weakened as well, this phenomenon can be seen in Figures 13 and 14. These problems are solved by the TDFS-TS algorithm which corrected the geometric distortion caused by the squint angle.

(**a**)

**Figure 11.** Imaging results of the fake scene in Figure 10 using (**a**) the RDS algorithm and (**b**) the TDFS-TS algorithm. Parts of the images marked by rectangular boxes are enlarged and shown in Figure 12.

**Figure 12.** Partially enlarged image of Figure 11. (**a**–**c**) are the partial enlargement of the image generated by the RDS algorithm in the yellow, green, and red boxes, respectively; (**d**–**f**) are the partial enlargement of the image generated by the TDFS-TS algorithm in the yellow, green, and red boxes.

(**b**) **Figure 13.** *Cont*.

**Figure 13.** Comparison of jamming results. (**a**) is the image formed by the original signal, (**b**) is the image formed by the superposition of the original signal and jamming signal generated by the RDS algorithm, and (**c**) is the image formed by the superposition of the original signal and jamming signal generated by the TDFS-TS algorithm. Parts of the images marked by rectangular boxes are enlarged and shown in Figure 14.

(**a**) (**b**) (**c**)

**Figure 14.** Partially enlarged image of Figure 13. (**a**–**c**) are the partial enlargement of the original image, the jamming image of the RDS algorithm, and the TDFS-TS algorithm, respectively in the yellow rectangular boxes; (**d**–**f**) are the partial enlargement of the original image, the jamming image of the RDS algorithm, and the TDFS-TS algorithm, respectively in the green boxes.

The imaging results of the superposition of the jamming signal and original signal are shown in Figure 13, and partially enlarged images are shown in Figure 14. It can be seen that the TDFS-TS algorithm achieves a good deception effect, generating clear false targets such as land and buildings and changing the topographic structure of the protected area. However, the fake scene generated by the RDS algorithm is not obvious, mainly because of the decrease in brightness caused by geometric distortion. The jamming power has to increase in order to achieve a satisfactory jamming purpose, but the ghost targets will be strengthened at the same time. In conclusion, the TDFS-TS algorithm has certain advantages compared with the RDS algorithm in large-scene jamming.

#### *3.3. Computational Complexity Analysis*

The effectiveness of the TDFS-TS algorithm is verified by simulation in the previous subsection. In this subsection, we will estimate the computational complexity of the TDFS-TS algorithm to assess its practical value. Assume that the jamming scene template consists of *m* × *n* point scatters and is divided into *M* × *N* blocks, each block contains *U* × *V* point scatters. Here, for ease of analysis, the addition, multiplication and power operations are all considered to be a basic operation. The following will analyze the number of basic operations to obtain the JSF *H*(*fr*, *ta*) at a specific frequency *fr* and azimuth time *ta*.

In the preprocessing stage, calculating an element of matrix **Hr**<sup>1</sup> requires 15 basic operations, and the operation amount of all elements is 15*V*; however, because the elements in **Hr**<sup>1</sup> are actually a geometric series, the other elements can be generated by multiplying the first element by the common ratio, meaning that the amount of calculation is reduced to 15 + *V*. According to the same analysis, the operation amount of **Hr**<sup>2</sup> is 12 + *U*, so the total computational complexity in the preprocessing stage is

$$\mathbb{C}\_{\text{pre}} = 15 + V + 12 + lI = lI + V + 27. \tag{43}$$

In the real-time calculation stage, calculating the JSF of a block center requires 20 basic operations, and a total of 20*MN* operations are required for all blocks. The operation amount for calculating matrix **Ha***q*<sup>1</sup> is 15 + *V*, which needs to be repeated *N* times. The calculation amount of matrix **Ha***q*<sup>2</sup> is 14 + *U* and needs to be repeated *N* times as well. The computational complexity of matrix multiplication in Equation (42) is 2*UV* + *U* + 2*V* − 1, so the operation amount of Equation (42) is 2*UV* + *U* + 2*V* added to the multiplication with *Hcpq*(*fr*, *ta*), and the calculation of Equation (42) needs to be repeated *MN* times. Finally, the operation amount of the summation—i.e., Equation (32)—is *MN* − 1. Based on the analysis above, the total amount of computation in the real-time calculation stage is

$$\begin{split} \mathcal{C}\_{rt} &= 20 \text{MN} + N(15+V) + N(14+lI) + MN(21IV + lI + 2V) + MN - 1 \\ &= mn \Big( 2 + \frac{2}{U} + \frac{1}{V} + \frac{21}{UV} \Big) + n \Big( 1 + \frac{U}{V} + \frac{29}{V} \Big) - 1. \end{split} \tag{44}$$

According to the same analysis method, the computational complexity of different jamming algorithms including TDFS-TS, RDS, TDFS-TS without squint correction (TDFS-TS-WSC) and the basic algorithm (BA) shown by Equation (3) is derived and shown in Table 4.


**Table 4.** Computational complexity comparison of different algorithms.

<sup>1</sup> the segment length in the range dimension of the RDS algorithm is the same as the block size of the TDFS-TS algorithm.

The block size *U* and *V* are determined by the parameters of the jamming object, the scatter density of the template, and the two imaging quality control factors ε and η. We fix *U* and *V* and observe the relationship between the computational complexity and the template size *m* and *n*. According to the simulation parameters in Section 4.1, we set *U* = 267 and *V* = 539, draw the relationship between

the computational complexity and the total number of scatters in the template shown in Figure 15. Here, for the convenience of analysis, we set *m* = *n* and take the logarithm of computational amount for display.

**Figure 15.** The relationship between the computational complexity and the total number of scatters in the template. (**a**) is the computational complexity in the preprocessing stage and (**b**) is the computational complexity in the real-time calculation stage.

It can be seen that, no matter in the preprocessing stage or in the real-time calculation stage, the computational complexity of the TDFS-TS-WSC algorithm is less than that of the RDS algorithm. In particular, in the real-time calculation stage, the computational complexity can be reduced by more than one order of magnitude because the TDFS algorithm in Equation (31) simplifies the calculation procedure significantly. When the squint correction is added, the calculation amount in the preprocessing stage is reduced, but increased in the real-time calculation stage.
