GTRACK Algorithm

This code is an implementation of Group TRACKing algorithm.
The algorithm is designed to track multiple targets, where each target is represented by a set of measurement points.
Each measurement point carries detection informations, for example, range, azimuth, elevation (for 3D option), and radial velocity.
Instead of tracking individual reflections, the algorithm predicts and updates the location and dispersion properties of the group.
The group is defined as the set of measurements (typically, few tens; sometimes few hundreds) associated with a real life target.
Algorithm supports tracking targets in two or three dimensional spaces as a build time option:

• When built with 2D option, algorithm inputs range/azimuth/doppler information and tracks targets in 2D cartesian space.
• When built with 3D option, algorithm inputs range/azimuth/elevation/doppler information and tracks targets in 3D cartesian space.

Input/output

• Algorithm inputs the Point Cloud. For example, few hundreds of individual measurements (reflection points).
  
• Algorithm outputs a Target List. For example, an array of few tens of target descriptors. Each descriptor carries a set of properties for a given target.
  
• Algorithm optionally outputs a Target Index. If requested, this is an array of target IDs associated with each measurement.
  

Features

• Algorithm uses extended Kalman Filter to model target motion in Cartesian coordinates.
  
• Algorithm supports constant velocity and constant acceleartion models.
  
• Algorithm uses 3D/4D Mahalanobis distances as gating function and Max-likelihood criterias as scoring function to associate points with an existing track.
  

External API

Application includes the following algorithm header

#include <ti/alg/gtrack.h>

All resources are allocated at create time during the gtrack_create call.
All resources are freed at delete time time during the gtrack_delete call.
Application is expected to implement the design pattern as described in the pseudo code bellow:

h = gtrack_create(params);                      // Creates an instance of the algorithm with a desired configuration
while(running) {
    gtrack_step(h, pointCloud, &targetList);    // Runs a single step of the given alrorithm instance with input point cloud data
}
gtrack_delete(h);                               // Delete the algorithm instance

Dependencies

Library is platform independent. To port the library, platform shall implement few functions that Library abstracts, see Dependencies

Internal Architecture of the GTRACK Algorithm

Algorithm is implemented with two internal software sublayers: Module and Units(s).
Application can create multiple Module instances with different configuration parameters (for example, to track different classes of targets).
Each Module instance creates amd manages multiple units.
Each Unit represents a single tracking object.
Units inherit configuration parameters from the parent Module.

Module level

The imlementation of gtrack_create function creates a module instance and pre-allocates resources for a maximum number of units.
The imlementation of gtrack_step function calls one single round of module functions as illustrated in the pseudo code below:

gtrack_step(h, pointCloud, &targetList) {
    gtrack_modulePredict(h,...);
    gtrack_moduleAssociate(h,...);
    gtrack_moduleAllocate(h,...);
    gtrack_moduleUpdate(h,...);
    gtrack_moduleReport(h,...);
}

The imlementation of gtrack_delete function returns all the resources back to the system

Unit level

Units are created during gtrack_moduleAllocate calls.
The resources pre-allocated at module create time are assigned to a new unit.
All active units are called during each parent module function step calls.
As an example, the pseudo code below illustrates the implementation of the predict function:

gtrack_modulePredict(h,...) {
    for(each active unit) {
        gtrack_unit_predict(unit, ...);
    }
}

Units are deleted during gtrack_moduleUpdate calls. The resources are returned back to the parent module.