Abstract:
An improved radar system and method for detecting targets is described. The system employs a sliding window range indicator which non-coherently integrates multiple contiguous range cells to reconstruct target cross sections. The invention has particular applicability to large targets.

Description:
FIELD OF THE INVENTION  
       [0001]     The present invention is directed to radar processing with high resolution radars.  
       BACKGROUND OF THE INVENTION  
       [0002]     There are different types of high resolution radar. One type is pulse compression which is a radar method that typically combines the high energy of a long pulse width with the high resolution of a short pulse width. The pulse is frequency modulated which provides a method to further resolve targets which may have overlapping returns. Since each part of the pulse has a unique frequency, the two returns can be completely separated. The receiver is able to separate two or more targets with overlapping returns on the basis of the frequency.  
         [0003]     Another type of high resolution radar is Synthetic Aperture Radar (SAR). Synthetic Aperture Radar uses the motion of the transmitter/receiver to generate a large effective aperture. In order to accomplish this, the system must store several returns taken while the antenna is moving and then reconstruct them as if they came in simultaneously. The most frequent application SAR is with satellite radar systems. Because the satellite is traveling at a high velocity, the accuracy of these systems can be made very high. Furthermore, in the event the target is fixed in location, the period for data collection can be made very long without introducing significant error. Therefore, satellite SAR is used for imaging fixed objects such as military bases.  
         [0004]     Inverse Synthetic Aperture Radar (ISAR) is a third type of high resolution radar. In this method, a large synthetic aperture is created without moving the transmitter/receiver. If the target rotates by a small amount, it has the same effect as if the transmitter/receiver were to travel a distance equal to the arc length at the range “R”. ISAR systems are typically used for long-range imaging and identification of possible targets. The ISAR platform may be fixed or moving. The best targets for ISAR are usually ships which tend to yaw periodically in the sea.  
         [0005]     Sliding window base algorithms have been reported in connection with self training algorithms for Ultra-wideband SAR target detection. See Self Training Algorithms for Ultra-wideband Radar Target Detection, Aerosence, 2003. A set of localized regions within a giver SAR image are sampled in real-time for purposes of obtaining low-order and robust real-time cluster models. The real time models are applied in a sliding window type target detection paradigm for clutter cancellation and target detection. In this article, using Terrain Filtered SVD. In this approach, a convolutional spatial filter kernel is designed that computes an intensity-weighted distance metric from the kernel center in an effort to pre-filter severe “blob-like” and “sparsely-impulsive” clutter discretes. The particular filter kernel designed for this investigation is illustrated in  FIG. 2 . This is a convolutional pre-filter that is implemented as a sliding window over a test image. This kernel function is calculated by setting all pixels within an 11-pixel radius of the kernel center equal to zero and by equating the remainder of the pixels equal to the Euclidian distance between the kernel center and the pixel. The filter is implemented as a pixel-by-pixel sliding window where all the output values are stored in histogram form.  
         [0006]     Generally, a sliding window algorithm works as follows. First, the sender assigns a sequence number, denoted SeqNum, to each frame. The sender maintains three variables: the send window size, denoted SWS, gives the upper bound on the number of outstanding (unacknowledged) frames that the sender can transmit; LAR denotes the sequence number of the last acknowledgment received; and LFS denotes the sequence number of the last frame sent. The sender also maintains the following invariant: 
 
 LFS−LAR+ 1≦SWS 
 
 When an acknowledgment arrives, the sender moves LAR to the right thereby allowing the sender to transmit another frame. Also, the sender associates a timer with each frame it transmits, and retransmits the frame should the timer expire before an ACK is received. Notice that the sender has to be willing to buffer up to SWS frames since it must be prepared to retransmit them until they are acknowledged. 
 
         [0007]     The receiver maintains the following three variables: the receive window size, denoted RWS, gives the upper bound on the number of out-of-order frames that the receiver is willing to accept; LFA denotes the sequence number of the last frame acceptable; and NFE denotes the sequence number of the next frame expected. The receiver also maintains the following invariant: 
 
 LFA−NFE+ 1≦RWS 
 
 When a frame with sequence number SeqNum arrives, the receiver takes the following action. If SeqNum&lt;NFE or SeqNurR&gt;LFA, then the frame is outside the receiver&#39;s window, and it is discarded. If NFE≦SeqNum≦LFA, then the frame is within the receiver&#39;s window and it is accepted. Now the receiver needs to decide whether or not to send an ACK. SeqNumToAck denote the largest sequence number not yet acknowledged, such that all frames with sequence numbers less than SeqNumToAck have been received. The receiver acknowledges the receipt of SeqNumToAck, even if higher numbered packets have been received. This acknowledgment is said to be cumulative. It then sets NFE=SeqNumToAck+1, and adjusts LFA=SeqNumToAck+RWS. 
 
         [0008]     Sliding window algorithms are a method of flow control for network data transfers. TCP, the Internet&#39;s stream transfer protocol, uses a sliding window algorithm. A long-term stream of data from A to B is sent as a sequence of IP packets. Each packet contains a sequence number. An ACK (acknowledgment) packet is sent back to A by B for each packet P correctly received. The ACK packet contains the sequence number of P. It is inefficient for the sender to wait after each packet for its ACK before sending the next, so A and B agree on a window: a maximum number of packets, say 10, which can be sent before being acknowledged. The sender keeps track of the last packet to be acknowledged; the receiver reserves 10 buffers.  
         [0009]     A sliding window algorithm places a buffer between the application program and the network data flow. For TCP, the buffer is typically in the operating system kernel. Data received from the network is stored in the buffer, from whence the application can read at its own pace. As the application reads data, buffer space is freed up to accept more input from the network. The window is the amount of data that can be “read ahead”—the size of the buffer, less the amount of valid data stored in it. Window announcements are used to inform the remote host of the current window size. If the local application can&#39;t process data fast enough, the window size will drop to zero and the remote host will stop sending data. After the local application has processed some of the queued data, the window size rises, and the remote host starts transmitting again. On the other hand, if the local application can process data at the rate it&#39;s being transferred, sliding window still gives an advantage. If the window size is larger than the packet size, then multiple packets can be outstanding in the network, since the sender knows that buffer space is available on the receiver to hold all of them. Ideally, a steady-state condition can be reached where a series of packets (in the forward direction) and window announcements (in the reverse direction) are constantly in transit. As each new window announcement is received by the sender, more data packets are transmitted. As the application reads data from the buffer (remember, we&#39;re assuming the application can keep up with the network), more window announcements are generated. Keeping a series of data packets in transit ensures the efficient use of network resources.  
       SUMMARY OF THE INVENTION  
       [0010]     The present invention improves detection performance against larger targets that are frequently over resolved by a high resolution radar. Many radars normally detect targets by processing each range resolution cell individually, even when they divide a target into multiple range cells. Once a large target is detected, prior art radars may reconstruct the target so as to not display multiple targets on the display. The present invention employs a Sliding Window Range Indicator to non-coherently integrate multiple contiguous range cells to reconstruct larger target cross-sections prior to detection. This process improves detection.  
     
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0011]      FIG. 1  is a representation of the Sliding Window Integrator of the present invention. 
     
    
     DETAILED DESCRIPTION OF THE INVENTION  
       [0012]      FIG. 1  describes the present invention. The range data from a single radar sweep (single pulse) is accumulated in such a way so as to form a continuous sum of the magnitude of the last N range cells. The accumulation is zeroed at the beginning of each sweep and then is updated as each sample is clocked through the system by adding the K &amp; N th  sample and subtracting the older K th  sample. The sweep data is also initialized with at least N zeros at the beginning of each sweep. The process outputs both a high resolution channel and a low resolution, sliding window integrated channel.  
         [0013]     A high resolution radar will divide a target into many smaller pieces, each with a smaller radar cross section (RCS) than the original. By providing one or more additional channels that integrate many range cells for each output, this effect can be minimized. A Sliding Window Range Integrator can be formed that is tuned to a given target length, so that it non-coherently integrates multiple range cells to match the typical length of a preferred target. This will also minimize the loss associated with other targets which may be larger or even somewhat smaller than the preferred target.  
         [0000]     Sliding Window Range Integrator Performance  
         [0014]     The following program (Math Cad) provides some examples of the benefit of this approach using a “noise-only” case.  
       λ   :=     c     9.457   ⁢           ⁢   GHz           
 
                                             Input Target Dimensions       Tgt: = 1 . . . 7            Tgt =   Length Tgt : =   Width Tgt : =               1    0.5 · ft   0.5 · ft        2    15 · ft    5 · ft       3    40 · ft   12 · ft       4    85 · ft   16 · ft       5   130 · ft   32 · ft       6   225 · ft   48 · ft       7   500 · ft   80 · ft                  
 
         [0015]     Average Length Used to Determine Performance  
         AveTgtLgth   Tgt     :=         ∫     -   π               ⁢   π       ⁢       (                      cos   ⁡     (   θ   )       ·     Length   Tgt            +     ⁢                              sin   ⁡     (   θ   )       ·     Width   Tgt                  )     ⁢     ⅆ   θ           2   ·   π           
       Res   :=     5   ·   ft         
         NPieces   ⁡     (     Res   ,   Tgt     )       :=     if   (       1   &gt;       AveTgtLgth   Tgt     Res       ,   1   ,       AveTgtLgth   Tgt     Res       )         
 
 Read Meyer &amp; Mayer Signal-to-Noise Data: 
 
 Signal_to_Noise_file ≡“SNC262 — 3.dat”
 
 SNMAT:=READPRN(Signal_to_Noise_File) P d :=SNMAT 1,0  
 
 NR:=rows (SNMAT)−1 CASE:=SNMAT 0,0  P d =0.62 
 
 NR=17 CASE:=2 
 
 ii:=2 . . . NR 
 
 NPULSVEC ii−2 :=SNMAT ii,0  SIGNOIVEC ii−2 :=SNMAT ii,1  
 
 VSS:=lspline(NPULSVEC,SIGNOIVEC) 
 
 S N NonCoh (NPULS):=interp(VSS,NPULSVEC,SIGNOIVEC,NPULS) 
 
 First Assume Noncoherent Integration of SW2 Target (though this is not over time, but over range): 
 
         [0016]     ResLossNC(Res,Tgt):=−(10·log(NPieces(Res,Tgt)))+(S_N_NonCoh(1)−S_N_NonCoh(NPieces(Res,Tgt)))  
                                                                           Loss with Tuned “Sliding Window Range Integrator” for Each Target            Tgt =   AveTgtLgth Tgtft  =   ResLossNC(7.5 · ft, Tgt) =   ResLossNC(5 · ft, Tgt) =                        1   0.64   0   0   (Tuning to range       2   12.73   0.41   0.34   cell With “sliding       3   33.1   0.09   −0.33   window” reduces       4   64.3   −0.64   −1.18   loss)*       5   103.13   −1.27   −1.92       6   173.8   −2.08   −2.72       7   369.24   −3.39   −4.11                 *Losses without this approach shown on next page             
 
         [0017]     Consider Peak Detection (the most likely situation due to range collapsing):  
                                                                                                 Pd out  := 0.62   Note: Ignore small effect on           false alarm rate. Look only           at Pd effects.                           Pd   in     ⁡     (     Res   ,   Tgt     )       :=     1   -       (     1   -     Pd   out       )       1     NPieces   ⁡     (     Res   ,   Tgt     )                                          NPnt := 0 . . . 15   (pfa = 1 × 10 −3 )                ProbVec2 NPnt  :=   SNVec2 NPnt  :=           95   21.2           90   18.1           80   14.7           70   12.6           60   10.95           50   9.5           40   8.15           30   6.75           20   5.15           10   3.03           5   1.13       LogProbVec NPnt  :=   4   0.55       log(ProbVec2 15−NPnt )           3   −0.1           1   −3       SNVec NPnt  := SNVec2 15−NPnt     0.5   −5.15           0.2   −9.5            VSSs := lspline(LogProbVec,SNVec)       S_N_NCIntg(LogProb) := interp(VSSs,LogProbVec,SNVec,LogProb)       GainPeak(Res,Tgt) := S_N_NCIntg(log(Pd out  · 100)) −       S_N_NCIntg(log(Pd in (Res,Tgt) · 100))                    GainPeak(7.5 ·           Tgt =   Pd in (Res,Tgt) =   ft,Tgt) =   GainPeak(50 · ft,Tgt) =               1   0.62    0   0       2   0.32    2.64   0       3   0.14    6.16   0       4   0.07    8.04   1.35       5   0.05    9.29   3.45       6   0.03   10.65   5.38       7   0.01   12.42   7.64                    ResLossPeak(Res,Tgt) := −(10 · log(NPieces(Res,Tgt))) +       GainPeak(Res,Tgt)                  
 
         [0018]    
       
         
               
             
               
               
               
               
               
               
             
               
               
               
               
               
               
             
           
               
                   
               
               
                   
               
               
                 Losses in High Resolution Channel vs Resolution Cell, Due to Tgt Breakup 
               
             
          
           
               
                   
                 ResLossPeak(7.5 · ft, 
                 ResLossPeak(5 · ft,  
                 ResLossPeak(50 · ft, Tgt) − 
                 ResLossPeak(7.5 · ft, 
                 ResLossPeak(50 · ft, Tgt) − 
               
               
                 Tgt = 
                 Tgt) = 
                 Tgt) = 
                 Tgt) = 
                 ResLossPeak(5 · ft, Tgt) = 
                 ResLossPeak(7.5 · ft, Tgt)= 
               
               
                   
               
             
          
           
               
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
               
               
                 2 
                 0.34 
                 0.21 
                 0 
                 0.14 
                 −0.34 
               
               
                 3 
                 −0.29 
                 −0.87 
                 0 
                 0.58 
                 0.29 
               
               
                 4 
                 −1.29 
                 −1.98 
                 0.25 
                 0.69 
                 1.55 
               
               
                 5 
                 −2.09 
                 −2.79 
                 0.31 
                 0.7 
                 2.4 
               
               
                 6 
                 −3 
                 −3.85 
                 −0.03 
                 0.85 
                 2.97 
               
               
                 7 
                 −4.5 
                 −5.17 
                 −1.04 
                 0.66 
                 3.46 
               
               
                   
               
             
          
         
       
     
         [0019]    
       
         
               
             
               
               
               
             
               
               
               
             
           
               
                   
               
               
                   
               
               
                 Determine Average Power Per Mode 
               
               
                 NPRF: = 1 . . . 13 
               
               
                 PeakPwr: = 8000 · W 
               
             
          
           
               
                 PRF NPRF : = 
                 PW NPRF : = 
                 PWC NPRF : = 
               
               
                   
               
             
          
           
               
                 2491 
                 10 · μsec 
                 100 · nsec 
               
               
                 1513 
                 10 · μsec 
                 100 · nsec 
               
               
                 750 
                 40 · μsec 
                 100 · nsec 
               
               
                 391 
                 40 · μsec 
                 100 · nsec 
               
               
                 800 
                 24.3 · μsec   
                  6.7 · nsec 
               
               
                 1024 
                 24.3 · μsec   
                  6.7 · nsec 
               
               
                 1990 
                 17.5 · μsec   
                 100 · nsec 
               
               
                 600 
                 65 · μsec 
                  10 · nsec 
               
               
                 1200 
                 30 · μsec 
                  15 · nsec 
               
               
                 560 
                 42 · μsec 
                 100 · nsec 
               
               
                 1120 
                 42 · μsec 
                 100 · nsec 
               
               
                 520 
                 42 · μsec 
                 100 · nsec 
               
               
                 1040 
                 42 · μsec 
                 100 · nsec 
               
               
                   
               
               
                   SW_Improv(Res, Tgt) := ResLossNC(Res, Tgt) − ResLossPeak(Res, Tgt)    
               
             
          
         
       
     
         [0020]    
       
         
               
             
               
               
               
             
               
               
               
               
               
             
           
               
                   
               
               
                   
               
               
                 Improvement Using “Sliding Window” vs High Resolution 
               
               
                 Channel Alone for 10 −3  pfa and 0.62 Pd in Noise* 
               
             
          
           
               
                 Tgt = 
                 SW_Improv(7.5 · ft, Tgt) = 
                 SW_Improv(5 · ft, Tgt) = 
               
               
                   
               
             
          
           
               
                 1 
                 0 
                 dB 
                 0 
                 dB 
               
               
                 2 
                 0.06 
                   
                 0.13 
               
               
                 3 
                 0.38 
                   
                 0.54 
               
               
                 4 
                 0.65 
                   
                 0.8 
               
               
                 5 
                 0.82 
                   
                 0.87 
               
               
                 6 
                 0.92 
                   
                 1.13 
               
               
                 7 
                 1.11 
                   
                 1.05 
               
               
                   
               
               
                   *Note that improvement would be better with lower Pfa&#39;s and higher Pd&#39;s, which would be associated with less scan integration.