# Patent

## Title
Maneuvering target tracking method via modifying the interacting multiple model (IMM) and the interacting acceleration compensation (IAC) algorithms

## 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.

## Background
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 MN 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. GPB1 and GPB2) 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 pij 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 F1(k) and F2(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 pij to compute a mixed estimate for filter F1(k) and F2(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 pij 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 Pj(k−1|k−1), and associated model probabilities μj(k−1). The initial state estimate for model j at time k, Mj(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 Mj(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 Mj(k) model-conditioned updates are obtained through Kalman filtering equations

{circumflex over (x)}j(k|k)={circumflex over (x)}j(k|k−1)+Wj(k)Vj(k)  (7)

Pj(k|k)=Pj(k|k−1)−Wj(k)Sj(k)Wj(k)T  (8)

with

Pj(k|k31 1)=FJ(k)P0j(k−1|k−1)FJ(k)T+QJ(k)  (9)

SJ(k)=HJ(k)PJ(k|k−1)HJ(k)T+RJ(k)  (10)

WJ(k)=PJ(k|k−1)HJ(k)TSJ(k)−1  (11)

VJ(k)=z(k)−HJ(k){circumflex over (x)}J(k|k−1)  (12)

where VJ(k),SJ(k) and WJ(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 MJ(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 M1(k) and M2(k), where M1(k) is corresponding to the constant velocity model and M2(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)+Gc(k)vc(k)  (17)

A(k+1)=A(k)+Gb(k)σ(k+1)vb(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)A2(k|k)  (21)

P1(k|k)=Pc(k|k)  (22)

P2(k|k)=Pc(k|k)+{overscore (V)}(k)Σ2(k|k){overscore (V)}T(k)  (23)

where {circumflex over (x)}c(k|k) and Pc(k|k) are the mean and the error covariance of the constant velocity filter, A2(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 Pc(k−1|k−1), and starting with acceleration estimate A2(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

A02(k−1|k−1)=μ2|2(k−1|k−1)A2(k−1|k−1)  (24)

Σ02(k−1|k−1)=μ2|2(k−1|k−1)[Σ2(k31 1|k−1)+μ1|2(k−1|k−1)×[[V (k−1)]]×A2(k−1|k−1) [[V (k−1)]]×A2(k−1|k−1)T]A2(k−1|k−1)×A2(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)+Gb(k−1)Qb(k−1)Gb(k−1)T  (29)

b(k|k)=b(k|k−1)+Kb(k)Vb(k)  (30)

Σ(k|k)=[I−Kb(k){overscore (S)}(k)]Σ(k|k−1)  (31)

where

Vb(k)=V(k)−{overscore (S)}(k)b(k|k−1)  (32)

Kb(k)=Σ(k|k−1)ST(k)[[Wb(k)−1]]Sb(k)−1

Sb(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 MJ(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, V2(k),S2(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)=Pc(k|k)+{overscore (V)}(k)Σ(k|k)VT(k)

A(k|k)=μ2(k)A2(k|k)  (42)

Σ(k|k)=μ2(k)[Σ2(k|k)+μ1(k)A2(k|k)A2(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 SJ(k) is the innovation covariance, HJ(k) is the measurement matrix, PJ(k|k−1) is the state prediction covariance and RJ(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, SJ(k) should be increased to adapt to this maneuvering. However, for each specified model, HJ(k) and RJ(k) are initialised constants, and PJ(k|k−1) has already converged to a relatively small value before the maneuver. One way to increase SJ(k) is to select a large initial value of RJ(k), but this is impractical even though improvement may be obtained in some cases.
To deal with this problem, for each model MJ(k), its process noise covariance QJ(k) is adjusted and it reflects the maneuvering motion of the target by introducing a scaling factor ξJ as

Sj(k)=HJ[FJ(k)PJ(k−1|k−1)Fj(k)T+ξJ×QJ(k)]HJ(k)T+RJ(k)

where ξJ is a scaling factor that will scale up QJ(k) when the target maneuvers and thus increases SJ(k). However, after introducing the ξJparameter, 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:

ψ=VJ(k)SJ(k)−1VJ(k)T  (45)

where VJ(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×QJ(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 Qb(k) in Eq. (29) as

Σ(k|k−1)=Σ(k−1|k−1)+ζ×Gb(k−1)Qb(k−1)Gb(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'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/s2 between 10 and 15 s, a straight line between 16 and 25 s, then a turn with constant acceleration of 65 m/s2 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/s2 between 11 and 18 s, a straight line between 19 and 35 s, a turn with constant acceleration of 65 m/s2 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.

## Claims

1. An estimator for method tracking systems providing improved tracking of maneuvering targets comprising:
using a modified IMM algorithm in which the expressions for each of the PJ(k|k−1), the state prediction covariance for model j, j=1 to n, is modified so that a factor, fJ, multiplies the process noise covariance, QJ (k), for each j, j=1 to n, resulting in that the PJ(k|k−1) are now expressed as


PJ(k|k−1)=FJ(k)PJ(k−1|k−1) FJ(k)T+fJQJ(k);


 Setting the factors fJ=1 for those k such that VJ(k)SJ(k) VJ(k)T<C, where C is an initialized threshold, and fJ being equal to an initially chosen number greater than one for those k such that VJ(k)SJ(k) VJ(k)T>C, VJ(k) being the innovation and SJ(k) the innovation covariance for model j, j=1 to n,
Whereby an estimator method for tracking as an element of a tracking system, providing improved tracking of maneuvering targets.

2. An estimator method for tracking systems providing improved tracking of maneuvering targets comprising: using a modified IAC algorithm in which the expression for P(k|k−1), the bias-free model state prediction covariance, is modified so that a factor, f, multiplies the bias free process noise covariance, Q(k), resulting in a P(k|k−1) that is now expressed as


P(k|k−1)=F(k)P(k−1|k−1)F(k)T+fQ(k),

And the expression for P(k|k−1), the bias model innovation covariance, is modified so that a factor, g ,multiplies the bias model process noise covariance, Qb(k), resulting in that P(k|k−1) is now expressed as


P(k|k−1)=P(k−1|k−1)+gGb(k−1)Qb(k−1)Gb(k−1)T


 Setting the factor f=1 for those k such that V(k)S(k) V(k)T<C, where C is an initialized threshold, and f being equal to an initially chosen value greater than one for those k such that V(k)S(k)V(k)T>C, V(k) being the innovation and S(k) the innovation covariance for the bias free model,
Setting the factor g=1 for those k such that Vb(k) Sb(k) Vb(k)T<C, where C is an initialized threshold, and g being equal to an initially chosen value greater than one for those k such that Vb(k) Sb(k) Vb(k)T>C, Vb(k) being the innovation and Sb(k) the innovation covariance for the bias model,
Whereby an estimator method is used as an element of a tracking system providing improved tracking of maneuvering targets.

3. The method of claim 1 wherein n=2.

4. The method of claim 1 wherein n=2, with model 1 being a constant velocity model and model 2 being a constant acceleration model.

5. The method of claim 2 wherein said bias-free model is a constant velocity model.

6. The method of claim 2 wherein said bias model is a constant acceleration model.