Represent sensor configuration for tracking
trackingSensorConfiguration object creates the configuration
for a sensor used with a
System object™. It allows you to specify the sensor parameters such as clutter density, sensor
limits, sensor resolution. You can also specify how a tracker perceives the detections from
the sensor using properties such as
See Create a Tracking Sensor Configuration for more details. The
trackingSensorConfiguration object enables the tracker to perform three
main routine operations:
Evaluate the probability of detection at points in state-space.
Initiate components in the probability hypothesis density.
Obtain the clutter density of the sensor.
config = trackingSensorConfiguration(
trackingSensorConfiguration object with a specified sensor
SensorIndex, and default property values.
allows you to set properties using one or more name-value pairs.
config = trackingSensorConfiguration(
SensorIndex— Unique sensor identifier
Unique sensor identifier, specified as a positive integer. This property
distinguishes detections that come from different sensors in a multi-sensor system. When
trackingSensorConfiguration object, you must specify the
SensorIndex as the first input argument in the creation
IsValidTime— Indicate detection reporting status
Indicate the detection reporting status of the sensor, specified as
true. Set this property to
true when the sensor must report detections within its sensor
limits to the tracker. If a track or target was supposed to be detected by a sensor but
the sensor reported no detections, then this information is used to count against the
probability of existence of the track when the
is set to
FilterInitializationFcn— Filter initialization function
@initcvggiwphd(default) | function handle | character vector
Filter initialization function, specified as a function handle or as a character
vector containing the name of a valid filter initialization function. The function
initializes the PHD filter used by
The function must support the following syntaxes:
filter = filterInitializationFcn() filter = filterInitializationFcn(detections)
filteris a valid PHD filter with components for new-born targets, and
detectionsis a cell array of
objectDetectionobjects. The first syntax allows you to specify the predictive birth density in the PHD filter without using detections. The second syntax allows the filter to initialize the adaptive birth density using detection information. See the BirthRate property of
trackerPHDfor more details. If you create your own
FilterInitilizationFcn, you must also provide a transform function using the
SensorTransformFcnproperty. Other than the default filter initialization function
initcvggiwphd, Sensor Fusion and Tracking Toolbox™ also provides other initialization functions, such as
SensorTransformFcn— Sensor transform function
@cvmeas| function handle | character vector
Sensor transform function, specified as a function handle or as a character vector containing the name of a valid sensor transform function. The function transforms a track's state into the sensor's detection state. For example, the function transforms the track's state in the scenario Cartesian frame to the sensor's spherical frame. You can create your own sensor transform function, but it must support the following syntax:
detStates = SensorTransformFcn(trackStates,params)
paramsare the parameters stored in the
SensorTransformParametersproperty. Notice that the signature of the function is similar to a measurement function. Therefore, you can use a measurement function (such as
cameas) as the
Depending on the filter type and the target type, the output,
detStates, needs to return differently.
When used with
gmphd for non-extended targets or
detStates is a N-by-M
matrix, where N is the number of rows in the
SensorLimits property and M is the number
of input states in
non-extended targets refer to point targets and extended targets whose
When used with
gmphd for extended targets, the
SensorTransformFcn allows you to specify multiple
trackState. In this case,
detStates is a
where S is the number of detectable sources on the extended
target. For example, if the target is described by a rectangular state, the
detectable sources can be the corners of the rectangle.
If any of the source falls inside the
target is declared detectable. The functions uses the spread (maximum coordinate −
minimum coordinate) of each
detStates and the ratio between the
spread and sensor resolution on each sensor limit to calculate the expected number
of detections from each extended target. You can override this default setting by
providing an optional output in the
[..., Nexp] = SensorTransformFcn(trackStates, params)
Nexpis the expected number of detections from each extended track state.
Note that the default
SensorTransformFcn is the sensor
transform function of the filter returned by
FilterInitilizationFcn. For example, the
initicvggiwphd function returns the default
initicaggiwphd functions return
SensorTransformParameters— Parameters for sensor transform function
Parameters for the sensor transform function, returned as a structure or an array of structures. If you only need to transform the state once, specify it as a structure. If you need to transform the state n times, specify it as an n-by-1 array of structures. For example, to transform a state from the scenario frame to the sensor frame, you usually need to first transform the state from the scenario rectangular frame to the platform rectangular frame, and then transform the state from the platform rectangular frame to the sensor spherical frame. The fields of the structure are:
Child coordinate frame type, specified as
Child frame origin position expressed in the Parent frame, specified as a 3-by-1 vector.
Child frame origin velocity expressed in the parent frame, specified as a 3-by-1 vector.
Relative orientation between frames, specified as a 3-by-3 rotation
matrix. If the
Flag to indicate the direction of rotation between parent and child
frame, specified as
Indicates whether outputs contain azimuth components, specified as
Indicates whether outputs contain elevation components, specified as
Indicates whether outputs contain range components, specified as
Indicates whether outputs contains velocity components, specified as
Note that here the scenario frame is the parent frame of the platform frame, and the platform frame is the parent frame of the sensor frame.
The default values for
SensorTransformParameters are a 2-by-1
array of structures as:
|Fields||Struct 1||Struct 2|
In this table, Struct 2 accounts for the transformation from the scenario
rectangular frame to the platform rectangular frame, and Struct 1 accounts for the
transformation from the platform rectangular frame to the sensor spherical frame, given
isParentToChild property is set to
SensorLimits— Sensor's detection limits
Sensor's detection limits, specified as an N-by-2 matrix, where N is the output dimension of the sensor transform function. The matrix must describe the lower and upper detection limits of the sensor in the same order as the outputs of the sensor transform function.
The description of these limits and their default values are given
in the following table. Note that the default values for
SensorLimits are a 3-by-2 matrix including the top six elements
in the table. Moreover, if you use these three functions, you can specify the matrix to
be in other sizes (1-by-2, 2-by-2, or 3-by-4), but you have to specify these limits in
the sequence shown in the SensorLimits matrix.
Minimum detectable azimuth in degrees.
Maximum detectable azimuth in degrees.
Minimum detectable elevation in degrees.
Maximum detectable elevation in degrees.
Minimum detectable range in meters.
Maximum detectable range in meters.
Minimum detectable range rate in meters per second.
Maximum detectable range rate in meters per second.
SensorResolution— Resolution of sensor
[4;2;10](default) | N-element positive-valued vector
Resolution of a sensor, specified as a N-element positive-valued
vector, where N is the number of parameters specified in the
SensorLimits property. If you want to assign only one resolution
cell for a parameter, simply specify its resolution as the difference between the
maximum limit and the minimum limit of the parameter.
MaxNumDetsPerObject— Maximum number of detections per object
Inf(default) | positive integer
Maximum number of detections the sensor can report per object, specified as a positive integer.
ClutterDensity— Expected number of false alarms per unit volume
1e-3(default) | positive scalar
Expected number of false alarms per unit volume from the sensor, specified as a positive scalar.
MinDetectionProbability— Probability of detecting track estimated to be outside of sensor limits
0.05(default) | positive scalar
Probability of detecting a target estimated to be outside of the sensor limits,
specified as a positive scalar. This property allows a
object to consider that the estimated target, which is outside the sensor limits, may be
Consider a radar with the following sensor limits and sensor resolution.
azLimits = [-10 10]; elLimits = [-2.5 2.5]; rangeLimits = [0 500]; rangeRateLimits = [-50 50]; sensorLimits = [azLimits;elLimits;rangeLimits;rangeRateLimits]; sensorResolution = [5 2 10 3];
Specifying the sensor transform function that transforms the Cartesian coordinates [x;y;vx;vy] in the scenario frame to the spherical coordinates [az;el;range;rr] in the sensor's frame. You can use the measurement function
cvmeas as the sensor transform function.
transformFcn = @cvmeas;
To specify the parameters required for
cvmeas, use the
SensorTransformParameters property. Here, you assume the sensor is mounted at the center of the platform and the platform located at [100;30;20] is moving with a velocity of [-5;4;2] units per second in the scenario frame.
The first structure defines the sensor's location, velocity, and orientation in the platform frame.
params(1) = struct('Frame','Spherical','OriginPosition',[0;0;0],... 'OriginVelocity',[0;0;0],'Orientation',eye(3),'HasRange',true,... 'HasVelocity',true);
The second structure defines the platform's location, velocity, and orientation in the scenario frame.
params(2) = struct('Frame','Rectangular','OriginPosition',[100;30;20],... 'OriginVelocity',[-5;4;2],'Orientation',eye(3),'HasRange',true,... 'HasVelocity',true);
Create the configuration.
config = trackingSensorConfiguration('SensorIndex',3,'SensorLimits',sensorLimits,... 'SensorResolution',sensorResolution,... 'SensorTransformParameters',params,... 'SensorTransformFcn',@cvmeas,... 'FilterInitializationFcn',@initcvggiwphd)
config = trackingSensorConfiguration with properties: SensorIndex: 3 IsValidTime: 0 SensorLimits: [4x2 double] SensorResolution: [4x1 double] SensorTransformFcn: @cvmeas SensorTransformParameters: [1x2 struct] FilterInitializationFcn: @initcvggiwphd MaxNumDetsPerObject: Inf ClutterDensity: 1.0000e-03 DetectionProbability: 0.9000 MinDetectionProbability: 0.0500
To create the configuration for a sensor, you first need to specify the sensor transform function, which is usually given as:
where x denotes the tracking state,
Y denotes detection states, and p denotes the
required parameters. For object tracking applications, you mainly focus on obtaining an
object's tracking state. For example, a radar sensor can measure an object's azimuth,
elevation, range, and possibly range-rate. Using a
trackingSensorConfiguration object, you
can specify a radar's transform function using the
property and specify the radar's mounting location, orientation, and velocity using
corresponding fields in the
SensorTransformParameters property. If the
object is moving at a constant velocity, constant acceleration, or constant turning, you can
use the built-in measurement function –
ctmeas, respectively – as the
SensorTransformFcn. To set
up the exact outputs of these three functions, specify the
hasVelocity fields as
false in the
To set up the configuration of a sensor, you also need to specify the sensor's detection
ability. Primarily, you need to specify the sensor's detection limits. For all the outputs
of the sensor transform function, you need to provide the detection limits in the same order
of these outputs using the
SensorLimits property. For example, for a
radar sensor, you might need to provide its azimuth, elevation, range, and range-rate
limits. You can also specify the radar's
MaxNumDetsPerObject properties if you want to consider extended
object detection. You might also want to specify other properties, such as
MinDetectionProbability to further clarify the sensor's detection