Abstract:
The present invention relates to the field of target tracking and more generally to a method employing improved algorithms, which achieve excellent tracking performance for a high-g maneuvering target. The two-model Interacting Multiple Model algorithm and the Interacting Acceleration Compensation algorithm will be modified by introducing adaptive factors through the detection of the normalized innovation squared which is chi-square probability distributed. The implementation results show that the modified algorithms can handle the target sudden maneuver better and are more accurate than the original algorithms.

Description:
BACKGROUND OF THE INVENTION 
   (a) Technical Field of the Invention 
   The present invention relates to the field of target tracking and more generally to a method employing improved algorithms, which achieve excellent tracking performance for a high-g maneuvering target. 
   (b) Description of the Prior Art 
   Target tracking is a critical component in multi-platform Multi-sensor Data Fusion(MSDF) for tactical situation awareness of the dynamic battlefield and for threat assessment. For most airborne fire control radar in fighters, the simple Kalman filter is widely used as the target tracking technique. However target maneuvers are highly unpredictable and can range from 2 g to more than 9 g. The Kalman filter will have to compromise between accuracy and track loss. Both of which are detrimental to weapon engagement. 
   The Kalman filter is the conventional and most widely used state estimator for providing optimal tracking performance based on the critical assumption that a single state model is required. In the practical multi-target tracking scenario, the targets being tracked will at times undergo maneuvers. which cannot be modeled well for the Kalman filter. To achieve superior performance while tracking maneuvering targets, it is necessary that the estimator allows for the motion of a target to be described by different models with different state equations in different time intervals. A hybrid system can match the above target model well and systems with Markovian switching parameters are typical examples of the hybrid systems. This has been disclosed in “MULTITARGET-MULTISENSORS TRACKING: PRINCIPLES AND TECHNIQUES”, Norwood, Mass.: Artech House, 1995, by Y. Bar-Shalom and X. R. Li. 
   However, the estimator for hybrid systems has exponentially increasing complexity. The optimal approach to estimate the target state requires that every possible model sequence from the initial through the most recent observation to be considered. Thus for M models and N observations, there are M N  hypotheses to consider. This is not practical and hence efficient management of the multiple hypotheses is critical to limiting computational requirements while maintaining performance. Many techniques such as generalized pseudo Bayesian algorithm (e.g. GPB 1  and GPB 2 ) have been employed to reduce the number of hypotheses and most search in the literature indicate that the two model IMM algorithm is the preferred technique for real-time tracking of maneuvering targets, considering the performance and computational requirements. With the IMM estimator, an explicit provision is made for the target motion to automatically “switch” from one motion model to another in a probabilistic manner, thereby achieving adaptive bandwidth adjustment required by a maneuvering target tracking filter. 
   Compared with IMM algorithm, another effective maneuvering target track algorithm, the Interacting Acceleration Compensation algorithm, was proposed by Watson and Blair in “INTERACTING ACCELERATION COMPENSATION ALGORITHM FOR TRACKING MANEUVERING TARGETS”, IEEE Transactions on Aerospace and Electronic Systems, Vol. 31, No. 2, Jul. 1995. The simulation results from “INTERACTING ACCELERATION COMPENSATION ALGORITHM FOR TRACKING MANEUVERING TARGETS” showed that the IAC algorithm saves about 50% computation cost in comparison to IMM but with slight degradation in tracking performance. The algorithm is viewed as a two-stage estimator having two acceleration models: the zero acceleration of the constant velocity model and a constant acceleration model. It combines the concept of the IMM for two motion models into the framework of the two-stage estimator. 
   In the practical implementation, the real-time performances of the above two algorithms are not satisfactory enough, especially in high-g maneuvering air target tracking. In view of these drawbacks, it is a principle object of the present invention to provide a maneuvering target tracking method via modifying the Interacting Multiple Model (IMM) and the Interacting Acceleration Compensation (IAC) algorithms to achieve a better tracking performance. 
   SUMMARY OF THE INVENTION 
   Accordingly, it is an object of the present invention to provide a maneuvering target tracking method via modifying the Interacting Multiple Model (IMM) and the Interacting Acceleration Compensation (IAC) algorithms, wherein adaptive factors are introduced through the detection of the normalized innovation squared which is chi-square probability distributed. 
   Yet another object of the present invention is to provide a maneuvering target tracking method via modifying Interacting Multiple Model(IMM) and the Interacting Acceleration Compensation(IAC) algorithms, wherein the modified IMM and IAC algorithms scale up the process noise covariance in time and reflecting the high-g maneuver motion of the targets. 
   A further object of the present invention is to provide a maneuvering target tracking method via modifying the Interacting Multiple Model (IMM) and the Interacting Acceleration Compensation (IAC) algorithms, wherein the simulation results show that the modified algorithms perform better than the original algorithms. 
   Other object and advantages of the present invention will become more apparent from the following description taken in conjunction with the accompanying drawing. 

   
     BRIEF DESCRIPTION OF THE DRAWINGS 
       FIG. 1  shows the structure of the two model Interacting Multiple Model tracking algorithm. 
       FIG. 2  is a graph schematically showing the target trajectory of scenario 1 of the present invention. 
       FIG. 3  is a graph schematically showing the model probability of scenario 1 of the present invention. 
       FIG. 4  is a graph schematically showing the position RMSE of scenario 1 of the present invention. 
       FIG. 5  is a graph schematically showing the target trajectory of scenario 2 of the present invention. 
       FIG. 6  is a graph schematically showing the model probability of scenario 2 of the present invention. 
       FIG. 7  is a graph schematically showing the position RMSE of scenario 2 of the present invention. 
   

   DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT 
   In accordance with the present invention, the Interacting Multiple Model algorithm will be described as follows: 
   Consider a target model with Markovian switching coefficients
 
 x ( k+ 1)= F ( k )σ( k+ 1) x ( k )+ G ( k )σ( k+ 1) v ( k )  (1)
 
 z ( k )= H ( k )σ( k ) x ( k )+ w ( k )  (2)
 
where σ(k) is a finite state Markov chain taking values in {1, . . . j} according to the model transiting probability p ij  from model i to model j; and v(k) and w(k) are white process and measurement noise, respectively. One cycle of two models (j=2) Interacting Multiple Model algorithm is given by the following structural chart ( FIG. 1 ).  FIG. 1  shows the structure of two model IMM algorithm.
 
   In view of the above, the IMM algorithm consists of running a filter F 1 (k) and F 2 (k) for each model, respectively; a state estimate mixer at the input of the filters; a model probability evaluator and a state estimate combiner at the output of the filters. The multiple models interact through the mixing to track a maneuvering target. 
   Assuming the target model transiting is governed by an underlying Markov chain, the state estimate mixer uses the model probabilities u(k) and the model transiting probabilities p ij  to compute a mixed estimate for filter F 1 (k) and F 2 (k). Each filter then uses the mixed estimate and the measurement to compute a new estimate and likelihood Λ(k). The likelihood, prior model probabilities u(k−1), and model transiting probabilities p ij  are then used to compute the new model probabilities. 
   An overall state estimate {circumflex over (x)}(k) is computed with the new state estimates and their model probabilities. The j models IMM algorithm is concluded in the following 4 steps:
     Step 1: State Estimates Mixing
 
Starting with state estimates {circumflex over (x)} i (k−1|k−1), state error covariances P j (k−1|k−1), and associated model probabilities μ j (k−1). The initial state estimate for model j at time k, M j (k), is computed as
   

                         x   ^       0   ⁢   j       (       k   -   1     ❘     k   -   1       )     =       ∑     i   =   1     N     ⁢           ⁢           x   ^     j     (       k   -   1     ❘     k   -   1       )     ⁢       u     i   ❘   j       (       k   -   1     ❘     k   -   1       )           ⁢     
     ⁢   where           (   3   )                   u     i   ❘   j       ⁡     (       k   -   1     ❘     k   -   1       )       =       1       c   _     j       ⁢     p   ij     ⁢       μ   i     ⁡     (     k   -   1     )                 (   4   )                   c   _     j     =       ∑     i   =   1     N     ⁢       p   ij     ⁢       μ   i     ⁡     (     k   -   1     )                   (   5   )               
The mixed covariance for M j (k) is computed as
 
   
     
       
         
           
             
               
                 
                   
                     
                       
                         
                           P 
                           
                             0 
                             ⁢ 
                             j 
                           
                         
                         ( 
                         
                           
                             k 
                             - 
                             1 
                           
                           ❘ 
                           
                             k 
                             - 
                             1 
                           
                         
                         ) 
                       
                       = 
                         
                       ⁢ 
                       
                         
                           ∑ 
                           
                             i 
                             = 
                             1 
                           
                           N 
                         
                         ⁢ 
                         
                           
                             
                               u 
                               
                                 i 
                                 ❘ 
                                 j 
                               
                             
                             ( 
                             
                               
                                 k 
                                 - 
                                 1 
                               
                               ❘ 
                               
                                 k 
                                 - 
                                 1 
                               
                             
                             ) 
                           
                           ⁢ 
                           
                             { 
                             
                               
                                 
                                   P 
                                   i 
                                 
                                 ( 
                                 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                   ❘ 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                 
                                 ) 
                               
                               + 
                             
                           
                         
                       
                     
                   
                 
                 
                   
                     
                         
                       ⁢ 
                       
                         
                           [ 
                           
                             
                               
                                 
                                   x 
                                   ^ 
                                 
                                 i 
                               
                               ( 
                               
                                 
                                   k 
                                   - 
                                   1 
                                 
                                 ❘ 
                                 
                                   k 
                                   - 
                                   1 
                                 
                               
                               ) 
                             
                             - 
                             
                               
                                 
                                   x 
                                   ^ 
                                 
                                 
                                   0 
                                   ⁢ 
                                   j 
                                 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                   ❘ 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                 
                                 ) 
                               
                             
                           
                           ] 
                         
                         × 
                       
                     
                   
                 
                 
                   
                     
                         
                       ⁢ 
                       
                         
                           [ 
                           
                             
                               
                                 
                                   x 
                                   ^ 
                                 
                                 i 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                   ❘ 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                 
                                 ) 
                               
                             
                             - 
                             
                               
                                 
                                   x 
                                   ^ 
                                 
                                 
                                   0 
                                   ⁢ 
                                   j 
                                 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                   ❘ 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                 
                                 ) 
                               
                             
                           
                           ] 
                         
                         T 
                       
                       } 
                     
                   
                 
               
             
             
               
                 ( 
                 6 
                 ) 
               
             
           
         
       
     
       
       Step 2: Model-Conditioned Updates
 
The M j (k) model-conditioned updates are obtained through Kalman filtering equations
 
 {circumflex over (x)}   j ( k|k ) ={circumflex over (x)}   j ( k|k− 1)+ W   j ( k ) V   j ( k )  (7)
 
 P   j ( k|k )= P   j ( k|k− 1)− W   j ( k ) S   j ( k ) W   j ( k ) T   (8)
 
with
 
 P   j ( k|k 31 1)= F   J ( k ) P   0j ( k− 1| k− 1) F   J ( k ) T   +Q   J ( k )  (9)
 
 S   J ( k )= H   J ( k ) P   J ( k|k− 1) H   J ( k ) T   +R   J ( k )  (10)
 
 W   J ( k )= P   J ( k|k− 1)H J ( k ) T   S   J ( k ) −1   (11)
 
 V   J ( k )= z ( k )−H J ( k ) {circumflex over (x)}   J ( k|k− 1)  (12)
 
where V J (k),S J (k) and W J (k) are the innovation, innovation covariance and filter gain, respectively.
 
       Step 3: Model Probabilities Update
 
The model probabilities are updated as
 
     
  
                     μ   j     ⁡     (   k   )       =         1   c     ⁢       Λ   j     ⁡     (   k   )       ⁢       c   _     j     ⁢           ⁢   with   ⁢           ⁢   c     =       ∑     i   =   1     N     ⁢         Λ   i     ⁡     (   k   )       ⁢       c   _     i                   (   13   )               
where Λ J (k) is the likelihood of M J (k) and is computed as
 
   
     
       
         
           
             
               
                 
                   
                     Λ 
                     j 
                   
                   ⁡ 
                   
                     ( 
                     k 
                     ) 
                   
                 
                 = 
                 
                   
                     1 
                     
                       
                          
                         
                           2 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           π 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           
                             
                               S 
                               j 
                             
                             ⁡ 
                             
                               ( 
                               k 
                               ) 
                             
                           
                         
                          
                       
                     
                   
                   ⁢ 
                   
                     exp 
                     ⁡ 
                     
                       [ 
                       
                         
                           - 
                           0.5 
                         
                         ⁢ 
                         
                           
                             
                               V 
                               j 
                             
                             ⁡ 
                             
                               ( 
                               k 
                               ) 
                             
                           
                           T 
                         
                         ⁢ 
                         
                           
                             
                               S 
                               j 
                             
                             ⁡ 
                             
                               ( 
                               k 
                               ) 
                             
                           
                           
                             - 
                             1 
                           
                         
                         ⁢ 
                         
                           
                             V 
                             j 
                           
                           ⁡ 
                           
                             ( 
                             k 
                             ) 
                           
                         
                       
                       ] 
                     
                   
                 
               
             
             
               
                 ( 
                 14 
                 ) 
               
             
           
         
       
     
       
       Step 4: State Estimates Combination
 
The output state estimate and error covariance are obtained by
 
     
  
                     x   ^     ⁡     (   k   )       =       ∑     i   =   1     N     ⁢           x   ^     i     ⁡     (     k   ❘   k     )       ⁢       u   i     ⁡     (   k   )                   (   15   )                       P   (     k   ❘   k     )     =       ⁢       ∑     i   =   1     N     ⁢         u   i     ⁡     (   k   )       ⁢     {         P   i     ⁡     (     k   ❘   k     )       +                           ⁢       [           x   ^     i     ⁡     (     k   ❘   k     )       -     x   ⁢     (     k   ❘   k     )         ]     ×       [           x   ^     i     ⁡     (     k   ❘   k     )       -     x   ⁡     (     k   ❘   k     )         ]     T       }                 (   16   )               
Interacting Acceleration Compensation (IAC) Algorithm
 
   In the IAC algorithm, the two models IMM algorithm is treated as a two-stage estimator. The two-stage estimator is viewed as having two acceleration models M 1 (k) and M 2 (k), where M 1 (k) is corresponding to the constant velocity model and M 2 (k) is to the model of constant acceleration. 
   The IMM algorithm is then used with the acceleration models to compute the acceleration estimate that compensates the constant velocity filter estimate. 
   Consider a linear system with Markovian switching coefficients within the acceleration models represented as
 
 x ( k+ 1)  F ( k ) x ( k )+ G ( k )σ( k +1) A ( k )+ G   c ( k ) v   c ( k )  (17)
 
 A ( k+ 1)= A ( k )+ G   b ( k )σ( k+ 1) v   b ( k )  (18)
 
 z ( k )= H ( k ) z ( k )+ C ( k )σ( k +1) A ( k )+ w ( k )  (19)
 
where x(k) contains the position and velocity and A(k) is the acceleration.
 
   For acceleration model i and according to the two-stage filter, the compensated state estimates are
 
 {circumflex over (x)}   1 ( k|k )= {circumflex over (x)}   c ( k|k )  (20)
 
 {circumflex over (x)}   2 ( k|k )= {circumflex over (x)}   c ( k|k )+ {overscore (V)} ( k ) A   2 ( k|k )  (21)
 
 P   1 ( k|k )= P   c ( k|k )  (22)
 
 P   2 ( k|k )= P   c ( k|k )+{overscore (V)}( k )Σ 2 ( k|k ) {overscore (V)}   T ( k )  (23)
 
where  {circumflex over (x)}   c   (k|k)  and P c (k|k) are the mean and the error covariance of the constant velocity filter,  A   2 (k|k) is the acceleration estimate, and {overscore (V)}(k) is defined in Eq. 35 above. The IAC algorithm is presented in the following 5 steps:
     Step 1: Acceleration Estimates Mixing   

   Considering the constant velocity filter state estimate {circumflex over (x)} c (k−1|k−1), state error covariance P c (k−1|k−1), and starting with acceleration estimate A 2 (k−1|k−1), error covariance Σ 2 (k−1|k−1), and associated probability μ 2 (k−1), the mixed acceleration estimate and error covariance are given by
 
 A   02 ( k− 1| k− 1)=μ 2|2 ( k− 1| k− 1) A   2 ( k− 1| k− 1)  (24)
 
Σ 02 ( k −1| k −1)=μ 2|2 ( k −1| k −1)[Σ 2 ( k 31 1| k− 1)+μ 1|2 ( k− 1| k− 1)×[[ V  ( k− 1)]]×A 2 ( k− 1| k− 1) [[ V  ( k− 1)]]×A 2 ( k− 1| k− 1) T ] A   2 ( k− 1| k− 1)× A   2 ( k− 1| k− 1) T ]
 
The mixed state estimate and covariance for the constant velocity filter are
 
 {circumflex over (x)}   0c ( k− 1| k− 1)={circumflex over (x)} c ( k− 1| k− 1)  (26)
 
   
     
       
         
           
             
               
                 
                   
                     
                       
                         
                           P 
                           
                             0 
                             ⁢ 
                             c 
                           
                         
                         ⁡ 
                         
                           ( 
                           
                             
                               k 
                               - 
                               1 
                             
                             ❘ 
                             
                               k 
                               - 
                               1 
                             
                           
                           ) 
                         
                       
                       = 
                         
                       ⁢ 
                       
                         
                           
                             P 
                             c 
                           
                           ( 
                           
                             
                               k 
                               - 
                               1 
                             
                             ❘ 
                             
                               k 
                               - 
                               1 
                             
                           
                           ) 
                         
                         + 
                       
                     
                   
                 
                 
                   
                     
                         
                       ⁢ 
                       
                         [ 
                         
                           
                             ∑ 
                             
                               i 
                               = 
                               1 
                             
                             2 
                           
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           
                             
                               
                                 μ 
                                 i 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   k 
                                   - 
                                   1 
                                 
                                 ) 
                               
                             
                             ⁢ 
                             
                               
                                 μ 
                                 
                                   1 
                                   ❘ 
                                   i 
                                 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                   ❘ 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                 
                                 ) 
                               
                             
                           
                         
                       
                     
                   
                 
                 
                   
                     
                       
                           
                         ⁢ 
                         
                           
                             μ 
                             
                               2 
                               ❘ 
                               i 
                             
                           
                           ⁡ 
                           
                             ( 
                             
                               
                                 k 
                                 - 
                                 1 
                               
                               ❘ 
                               
                                 k 
                                 - 
                                 1 
                               
                             
                             ) 
                           
                         
                         ] 
                       
                       × 
                     
                   
                 
                 
                   
                     
                         
                       ⁢ 
                       
                         [ 
                         
                           
                             
                               V 
                               _ 
                             
                             ⁡ 
                             
                               ( 
                               
                                 k 
                                 - 
                                 1 
                               
                               ) 
                             
                           
                           ⁢ 
                           
                             
                               A 
                               2 
                             
                             ⁡ 
                             
                               ( 
                               
                                 
                                   k 
                                   - 
                                   1 
                                 
                                 ❘ 
                                 
                                   k 
                                   - 
                                   1 
                                 
                               
                               ) 
                             
                           
                         
                         ] 
                       
                     
                   
                 
                 
                   
                     
                         
                       ⁢ 
                       
                         
                           [ 
                           
                             
                               
                                 V 
                                 _ 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   k 
                                   - 
                                   1 
                                 
                                 ) 
                               
                             
                             ⁢ 
                             
                               
                                 A 
                                 2 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                   ❘ 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                 
                                 ) 
                               
                             
                           
                           ] 
                         
                         T 
                       
                     
                   
                 
               
             
             
               
                 ( 
                 27 
                 ) 
               
             
           
         
       
     
       
       Step 2: Model-Conditioned Updates 
     
  
   The two-stage filtering equations provide the model-conditioned updates. The bias-free filter is a Kalman filter as Eq. (7–12). The bias filter is given by
 
 b ( k|k− 1)= b ( k− 1| k− 1)  (28)
 
Σ( k|k− 1)=Σ( k− 1| k− 1)+ G   b ( k− 1) Q   b ( k− 1) G   b ( k− 1) T   (29)
 
 b ( k|k )= b ( k|k− 1)+ K   b ( k ) V   b ( k )  (30)
 
Σ( k|k )=[ I−K   b ( k ) {overscore (S)} ( k )]Σ( k|k− 1)  (31)
 
where
 
 V   b ( k )= V ( k )− {overscore (S)} ( k ) b ( k|k− 1)  (32)
 
 K   b ( k )=Σ( k|k− 1) S   T ( k )[[W b ( k ) −1 ]] S   b ( k ) −1 
 
 S   b ( k )= S ( k )+ {overscore (S)} ( k )Σ( k|k −1) {overscore (S)} ( k ) T   (34)
 
 V ( k )= U ( k )− W ( k ) {overscore (S)} ( k )
 
 {overscore (S)} ( k )= H ( k ) U ( k )+ C ( k )  (36)
 
 U ( k )= F ( k− 1) {overscore (V)} ( k− 1)+ G ( k− 1)  (37)
     Step 3: Model Likelihood Computations
 
The likelihood of M J (k) are given by
   

                     Λ   1     ⁡     (   k   )       =       1            2   ⁢           ⁢   π   ⁢           ⁢     S   ⁡     (   k   )                  ⁢     exp   ⁡     [       -   0.5     ⁢       V   ⁡     (   k   )       T     ⁢       S   ⁡     (   k   )         -   1       ⁢     V   ⁡     (   k   )         ]                 (   38   )                   Λ   2     ⁡     (   k   )       =       1            2   ⁢           ⁢   π   ⁢           ⁢       S   b     ⁡     (   k   )                  ⁢     exp   ⁡     [       -   0.5     ⁢         V   2     ⁡     (   k   )       T     ⁢         S   2     ⁡     (   k   )         -   1       ⁢       V   2     ⁡     (   k   )         ]                 (   39   )               
where j=2 refers to the acceleration model, V 2 (k),S 2 (k) are given by Eq. (32–33).
     Step 4: Model Probabilities Update
 
The model probabilities are updated according to Eq. (13–14).
   Step 5: State Estimates Combination Similar to Eq. (15–16) the output state estimate and error covariance for the IAC algorithm are given by
 
 {circumflex over (x)} ( k|k )= {circumflex over (x)}   c ( k|k )+ {overscore (V)} ( k ) A ( k|k )  (40)
 
 P ( k|k )= P   c ( k|k )+ {overscore (V)} ( k )Σ( k|k ) V   T ( k )
 
 A ( k|k )=μ 2 ( k ) A   2 ( k|k )  (42)
 
Σ( k|k )=μ 2 ( k )[Σ 2 ( k|k )+μ 1 ( k ) A   2 ( k|k ) A   2 ( k|k ) T ]  (43)
 
The Modified IMM(MIMM) and IAC(MIAC) Algorithms
   
   In accordance with the present invention, in the above IMM algorithm, for each model, the innovation covariance equation is given by Eq. (10). The S J (k) is the innovation covariance, H J (k) is the measurement matrix, P J ( k|k− 1) is the state prediction covariance and R J (k) is the measurement noise covariance. 
   When the target suddenly maneuvers with high-g acceleration, it manifests itself with a large innovation. To maintain the tracking performance, S J (k) should be increased to adapt to this maneuvering. However, for each specified model, H J (k) and R J (k) are initialised constants, and P J ( k|k −1) has already converged to a relatively small value before the maneuver. One way to increase S J (k) is to select a large initial value of R J (k), but this is impractical even though improvement may be obtained in some cases. 
   To deal with this problem, for each model M J (k), its process noise covariance Q J (k) is adjusted and it reflects the maneuvering motion of the target by introducing a scaling factor ξ J  as
 
 S   j ( k )=H J   [F   J ( k ) P   J ( k −1 |k −1) F   j ( k ) T   +ξ   J   ×Q   J ( k )] H   J ( k ) T   +R   J ( k )
 
where ξ J  is a scaling factor that will scale up Q J (k) when the target maneuvers and thus increases S J (k). However, after introducing the ξ J parameter, some issues need to be answered. These include how to detect a maneuver of the target and when to scale up the parameter ξ J . It is understood that the normalised innovation squared ψ can be formed as follows:
 
ψ= V   J ( k ) S   J ( k ) −1   V   J ( k ) T   (45)
 
where V J ( k ) is the innovation. As ψ is chi-square distributed, to detect the target maneuver, the value of ψ is compared with a specified threshold. For example, the threshold for 99% confidence interval for 2-D measurement is 9.21 and 11.34 for 3-D measurement. If the threshold is too large, the target maneuver may be detected too late or not even be detected. If it is too small, the maneuver may be falsely detected even though the target moves straight and the noise is haply large. In practice, this initialised threshold will be set a little larger according to the present scenario. Since ψ can be taken as the maneuver detector and once the value of ψ exceeded the specify threshold, the ξ J ×Q J (k) term will be kicked in until ψ falls below the threshold. Thus, ξ J  can be taken as an adaptive factor to improve the baseline IMM algorithm and hence form the modified IMM(MIMM) algorithm. The selection of ξ J  is related to the target model selected and ψ reflects the maneuvering capability of targets of interest.
 
   In accordance with the present invention, to modify the IAC algorithm, the scaling factor is not only introduced to the bias-free filter but also to the bias filter. For the bias-free filter, as it is a Kalman filter, the modification is the same as that of MIMM where Eq. (44–45) are used to replace Eq. (10). 
   For the bias filter, note that in Eq. (29–37), to increase the innovation covariance to match the maneuvering, a scaling factor ζ is introduced to scale up the process noise covariance Q b (k) in Eq. (29) as
 
Σ( k|k− 1)=Σ( k− 1| k− 1)+ζ× G   b ( k− 1) Q   b ( k− 1) G   b ( k− 1) T   (46)
 
   Also, as the MIMM, Eq. (45) can be used to detect the target maneuver before the substitution of Eq. (29) with Eq. (46). 
   Target Tracking Performance Comparison 
   The performance comparison of IMM and MIMM, IAC and MIAC will be described hereinafter. In accordance with the preferred embodiment of the present invention, for simplicity, all the algorithms each contains two models: a constant velocity (CV) model and a constant acceleration (CA) model. In the ensuing discussion, only the CV model probability will be shown since the CA probability is the complement of CV&#39;s. The tracking performances of the IMM, MIMM, IAC and MIAC algorithms were checked against the simulated target trajectories with high-g maneuvers in Scenario 1 and 2 mentioned below. 
   Comparison of IMM and MIMM 
   Scenario 1: 
   In this scenario of the present invention, the target starts at [0 0 1000] in Cartesian coordinates. The initial velocity is [300 200 2.0] and the target keeps a constant speed of 360 m/s. Its trajectory is a straight line between 0 and 10 s. A sudden turn with high-g constant acceleration of 80 m/s 2  between 10 and 15 s, a straight line between 16 and 25 s, then a turn with constant acceleration of 65 m/s 2  between 26 to 30 s, and a straight line between 31 to 40 s. The measurements have zero-mean Gaussian errors with standard derivations of 25 m for each coordinate. The target flight path is shown in  FIG. 2 . 
   The initial model probability for IMM and MIMM algorithms was μ 0 =[0.9 0.1]. The first entry was for the CV model and the second was for the CA model. The model transiting probabilities for both algorithms were [0.95 0.05; 0.1 0.9]. For MIMM, both adaptive factors ξ 1  and ξ 2  are selected as 100 and ψ is set to 13.5. 
   The simulation in the present preferred embodiment takes 100 Monte Carlo runs. The model transiting probability for IMM and AIMM is shown in  FIG. 3 . It shows that both IMM and AIMM algorithms respond to the thrusting maneuver in a similar manner, however, for the MIMM, the transition from CA to CV is faster than that of IMM at the end of maneuver. The root-mean-square-errors (RMSE) of the position for the IMM and MIMM are shown in  FIG. 3 . From the figure, it proves that the faster transition from CA to CV of MIMM can handle the sudden maneuver better and is more accurate than the IMM algorithm. 
   Comparison of IAC and MIAC 
   Scenario 2: 
   In this scenario of the present invention, the target starts at [8000-1200 100] in Cartesian coordinates. The initial velocity is [−224 300 3.0] and the target keeps a constant speed of 375 m/s. Its trajectory is a straight line between 0 and 10 s. A turn with high-g constant acceleration of 75 m/s 2  between 11 and 18 s, a straight line between 19 and 35 s, a turn with constant acceleration of 65 m/s 2  between 36 to 40 s, and a straight line between 41 and 50 s. The measurements have zero-mean Gaussian errors with standard derivations of 30 m for each coordinate. The target flight path is shown in  FIG. 5 . 
   The initial model probability for the IAC and MIAC algorithms was μ 0  =[0.9 0.1]. Also the first entry was for the CV model and the second was for the CA model, respectively. The model transiting probabilities for both algorithms were [0.99 0.01; 0.05 0.95]. For MIAC, the adaptive factors ξ and ζ are selected as 2 and 10, respectively, and ψ is set to 13.5. 
   Also 100 Monte Carlo runs are taken. The model probabilities of the CV model for IAC and MIAC algorithms are given in  FIG. 6 . It is clear that the MIAC is faster in responding to both the start of the turning maneuver and also the end of the maneuver. From  FIG. 7 , although during the starting part of the flight path (constant speed segment), the RMSE of MIAC is larger than that of IAC, the whole later segments of the flight path shows that MIAC performs much better than IAC. 
   While the invention has been described with respect to preferred embodiment, it will be clear to those skilled in the art that modifications and improvements may be made to the invention without departing from the spirit and scope of the invention. Therefore, the invention is not to be limited by the specific illustrative embodiment, but only by the scope of the appended claims.