Skip to navigation

Create a track

Publish fusion-ready tracks from sensors so Lattice can correlate them

This page shows how to publish tracks that the Lattice fusion engine can ingest and correlate. It covers 2D bearing-only tracks, 3D signal-of-interest tracks with an estimated range, and fully resolved 3D tracks with position and velocity uncertainty. For more information on entities, see Entities overview.

A track represents any entity tracked by another asset or integration source. Tracks are not directly under the control of friendly forces. This includes aircraft tracks from radar or sensor hits, signal detections, and vehicles, people, or animals detected through cameras.

Before you begin

gRPC authentication

These gRPC examples authenticate with a static environment token attached as request metadata. If you are using OAuth 2.0 client credentials instead, set up the token refresh module before running the examples on this page.

Produce fusion-ready tracks

To make a track eligible for correlation by the Lattice fusion engine, populate the following components:

1

Generate with PublishEntity

Call PublishEntity, or PublishEntities (gRPC-only) to publish multiple entities in a single request.

2

Set identity and lifetime fields

entity_id
string

Stable identifier for the track. Use the same value on every update so the fusion engine can correlate successive observations into a single track.

aliases.name
string

Human-readable label displayed in the Lattice common operational picture.

created_time
Timestamp

Time the track was first observed. Set this once and do not change it on subsequent updates; the fusion engine uses it to establish track age.

expiry_time
Timestamp

Future time at which Lattice automatically removes your contribution to the track. Set to approximately 10 seconds ahead of the current time on every update. While your sensor keeps detecting the target, each new detection refreshes the expiry and keeps your contribution live. When your sensor stops detecting, your contribution expires; the fused track persists as long as any other sensor continues to contribute. For more information, see Manage update rates.

aliases.alternate_ids
AlternateId[]

Additional identifiers from the source system, such as ALT_ID_TYPE_CALLSIGN, ALT_ID_TYPE_LINK16_TRACK_NUMBER, ALT_ID_TYPE_VMF_URN, or ALT_ID_TYPE_SERIAL_NUMBER. Populate one entry per identifier so downstream systems can cross-reference tracks.

Streaming endpoints reject no_expiry. Always set a finite expiry_time when you publish over a stream using PublishEntities.

3

Populate position and uncertainty

location
Location

Resolved position of the track, including latitude, longitude, and HAE altitude. Populate this field for all 3D tracks.

location_uncertainty.position_enu_cov
PositionCovariance

East-North-Up (ENU) position covariance matrix expressing position uncertainty. A diagonal-only matrix is valid when the full matrix is unavailable.

tracked.track_quality_wrapper
TrackQuality

Link-16 track quality score from 0 to 15. Use this instead of position_enu_cov only when your source system produces a track-quality score rather than a covariance matrix.

4

Set ontology

ontology.template
Ontology.Template

Classification template that tells Lattice how to render and handle the entity. Set to TEMPLATE_TRACK for resolved positional tracks, or TEMPLATE_SIGNAL_OF_INTEREST for RF emitter tracks and 2D camera sensor tracks.

5

Set provenance and update cadence

provenance.integration_name
string

Name of the integration publishing the track. Together with data_type, this pair uniquely identifies your feed so the fusion engine can distinguish it from other sources.

provenance.data_type
string

Type of data being published, such as camera_lob or rf_sigint. Together with integration_name, this pair uniquely identifies your feed.

provenance.source_update_time
Timestamp

Timestamp of the measurement that produced this update. Set it to the time your sensor observed the target. Lattice uses it to detect stale tracks and rejects any update whose source_update_time is earlier than or equal to the value it already holds. Publish a new update only when your sensor produces a new detection.

6

Declare contributing sensors

relationships
Relationship[]

List of sensor relationships for the track. Populate one entry per contributing sensor so the fusion engine knows which sensors produced the observation.

relationships.related_entity_id
string

Entity ID of the sensor asset that produced this track. Publish the sensor asset before any track that references it.

relationships.relationship_id
string

Stable, unique identifier for this sensor-to-track relationship. A common pattern is <track_id>-tracked-by-<sensor_id>.

relationships.relationship_type.tracked_by
TrackedBy

Describes the sensor system actively tracking the entity. Include actively_tracking_sensors with sensor_id, sensor_type, and operational_state values that match the corresponding entries in the tracking entity’s top-level sensors component. Set last_measurement_timestamp to the time of the most recent measurement.

For single-sensor tracks, publish one trackedBy relationship. For tracks detected by multiple sensors in your system, publish one trackedBy relationship per contributing sensor that exists in Lattice as an asset entity.

7

Choose a line-of-bearing component by sensor modality

A single track must carry its line-of-bearing data in exactly one component, selected by the sensing modality:

signal.line_of_bearing
LineOfBearing

Line-of-bearing measurement for radio-frequency sensors. Use this component instead of tracked.line_of_bearing when the observing sensor is an RF direction-finding system.

tracked.line_of_bearing
LineOfBearing

Line-of-bearing measurement for camera and acoustic sensors. Use this component instead of signal.line_of_bearing when the observing sensor is a camera or acoustic array.

bearing_elevation_covariance_rad2
BearingElevationCovariance

Bearing and elevation covariance in radians squared. Populate this field on whichever line-of-bearing component you use; the fusion engine uses it to decide whether to fuse the bearing or render it visually only.

8

Improve fusion quality with optional fields

tracked.radar_cross_section
RadarCrossSection

Measured radar cross-section of the target. Optional; the fusion engine uses it to improve track association when the value is present.

dimensions.length_m
double

Estimated length of the target in meters. Optional; the fusion engine uses it alongside radar cross-section to improve association accuracy when the value is present.

9

Populate geocentric kinematics for engage targets

kinematics.kinematics_geocentric
KinematicsGeocentric

Earth-centered, earth-fixed position and velocity of the target. Populate this field when you use the track as an engage target; downstream fire-control systems rely on it to compute engagement geometry.

Symbology

Populate the following components on every track so downstream rendering and handling are correct:

mil_view.nationality
Nationality

Nationality of the track, used downstream to pick the flag and the MIL-STD-2525C country code. Set explicitly when known; leaving it as NATIONALITY_INVALID produces generic symbology.

symbology.mil_std_2525_c.sidc
string

Valid 15-character MIL-STD-2525C Symbol Identification Code. Required for downstream command-and-control systems such as NGC2 to render the track; entities without a SIDC fall back to a generic icon.

indicators
Indicators

Flags that describe the operational context of the track. Set simulated for all tracks published during test and evaluation exercises. Additional flags, including exercise, emergency, and c2, are available when applicable.

data_classification
DataClassification

Classification level of the track data. Required when publishing classified content so Lattice and downstream systems can handle the data according to its classification.

MIL-STD-2525D is not supported by the current schema. Use 2525C and populate symbology.mil_std_2525_c.sidc.

Publish a 2D bearing-only track

Use a 2D bearing-only track when your sensor, such as a camera or acoustic array, reports a direction to the target but not a range. Populate tracked.line_of_bearing with the sensor’s position at the time of the measurement and the angle pointing toward the target.

1

Define the entity model’s required components. To represent a bearing-only detection:

  • Set template to TEMPLATE_SIGNAL_OF_INTEREST.
  • Populate tracked.lineOfBearing.angleOfArrival with the sensor’s pose and bearing/elevation covariance.
  • Add a trackedBy relationship that references the sensor’s entity ID.
entity.json
{
"entityId": "UNIQUE_ENTITY_ID",
"description": "Bearing-only detection from a camera sensor",
"isLive": true,
"createdTime": "2026-05-01T00:00:00.000Z",
"expiryTime": "2026-05-01T00:00:10.000Z",
"aliases": { "name": "Track-12345678" },
"ontology": { "template": "TEMPLATE_SIGNAL_OF_INTEREST" },
"milView": {
"disposition": "DISPOSITION_UNKNOWN",
"environment": "ENVIRONMENT_SURFACE"
},
"tracked": {
"lineOfBearing": {
"angleOfArrival": {
"relativePose": {
"pos": { "lat": 36.66633492530301, "lon": -116.9117674522639, "alt": 780.0 },
"attEnu": { "x": 0.0, "y": 0.0, "z": 0.0, "w": 1.0 }
},
"bearingElevationCovarianceRad2": { "mxx": 0.0009, "mxy": 0.0, "myy": 0.0025 }
}
}
},
"locationUncertainty": {
"positionEnuCov": { "mxx": 25.0, "myy": 25.0, "mzz": 100.0 }
},
"relationships": {
"relationships": [{
"relatedEntityId": "SENSOR_ENTITY_ID",
"relationshipId": "UNIQUE_ENTITY_ID-tracked-by-SENSOR_ENTITY_ID",
"relationshipType": {
"trackedBy": {
"lastMeasurementTimestamp": "2026-05-01T00:00:00.000Z",
"activelyTrackingSensors": {
"sensors": [{
"sensorId": "camera-01-eo",
"sensorType": "SENSOR_TYPE_CAMERA",
"operationalState": "OPERATIONAL_STATE_OPERATIONAL"
}]
}
}
}
}]
},
"provenance": {
"integrationName": "your_integration_name",
"dataType": "camera_lob",
"sourceUpdateTime": "2026-05-01T00:00:00.000Z"
}
}
2

Take a closer look at the components that describe the bearing measurement and the sensor that produced it:

"tracked": {
"lineOfBearing": {
"angleOfArrival": {
"relativePose": {
// Sensor position, in latitude, longitude, and altitude meters,
// at the time the measurement was recorded.
"pos": { "lat": 36.66633492530301, "lon": -116.9117674522639, "alt": 780.0 },
// Quaternion rotating the Pose frame into the ENU frame. The
// Pose frame's +x axis points toward the target.
"attEnu": { "x": 0.0, "y": 0.0, "z": 0.0, "w": 1.0 }
},
// Bearing and elevation covariance, in radians squared. The
// fusion engine uses this to decide whether to fuse the
// bearing or render it visually only.
"bearingElevationCovarianceRad2": {
"mxx": 0.0009,
"mxy": 0.0,
"myy": 0.0025
}
}
}
}
3

Use the PublishEntity API method to publish the entity:

package main
import (
"context"
"fmt"
"net/http"
"os"
"time"
Lattice "github.com/anduril/lattice-sdk-go/v5"
"github.com/anduril/lattice-sdk-go/v5/client"
"github.com/anduril/lattice-sdk-go/v5/option"
"github.com/google/uuid"
)
func main() {
// Get environment variables
latticeEndpoint := os.Getenv("LATTICE_ENDPOINT")
environmentToken := os.Getenv("ENVIRONMENT_TOKEN")
// Remove sandboxesToken from the following statements if you are not developing on Sandboxes
sandboxesToken := os.Getenv("SANDBOXES_TOKEN")
// Check required environment variables
if latticeEndpoint == "" || environmentToken == "" || sandboxesToken == "" {
fmt.Println("Missing required environment variables")
os.Exit(1)
}
// Replace with the real entity ID of the sensor (published as a TEMPLATE_ASSET
// entity) when running against a live environment.
sensorEntityId := "<SENSOR_ENTITY_ID>"
// Initialize headers for sandbox authorization
headers := http.Header{}
headers.Add("Anduril-Sandbox-Authorization", fmt.Sprintf("Bearer %s", sandboxesToken))
// Create the client
LatticeClient := client.NewClient(
option.WithToken(environmentToken),
option.WithBaseURL(fmt.Sprintf("https://%s", latticeEndpoint)),
option.WithHTTPHeader(headers),
)
// Generate a unique ID for the entity
trackId := uuid.New().String()
relationshipId := fmt.Sprintf("%s-tracked-by-%s", trackId, sensorEntityId)
// Get creation time
creationTime := time.Now().UTC()
// Continuously publish the entity
for {
latestTimestamp := time.Now().UTC()
ctx := context.Background()
// Create entity to publish
entity := Lattice.Entity{
EntityID: &trackId,
Description: Lattice.String("Bearing-only detection from a camera sensor"),
Aliases: &Lattice.Aliases{
Name: Lattice.String(fmt.Sprintf("Track-%s", trackId[:8])),
},
IsLive: Lattice.Bool(true),
CreatedTime: Lattice.Time(creationTime),
ExpiryTime: Lattice.Time(latestTimestamp.Add(10 * time.Second)),
Ontology: &Lattice.Ontology{
Template: Lattice.OntologyTemplateTemplateSignalOfInterest.Ptr(),
},
MilView: &Lattice.MilView{
Disposition: Lattice.MilViewDispositionDispositionUnknown.Ptr(),
Environment: Lattice.MilViewEnvironmentEnvironmentSurface.Ptr(),
},
// 2D bearing-only tracks populate line_of_bearing on the
// tracked component. Lattice needs bearing/elevation covariance
// to evaluate whether the LOB is fusable into the COP.
Tracked: &Lattice.Tracked{
LineOfBearing: &Lattice.LineOfBearing{
AngleOfArrival: &Lattice.AngleOfArrival{
RelativePose: &Lattice.Pose{
Pos: &Lattice.Lla{
Lat: Lattice.Float64(36.66633492530301),
Lon: Lattice.Float64(-116.9117674522639),
Alt: Lattice.Float64(780.0),
},
// Identity quaternion: the bearing points due east (ENU +X). Rotate it to point at the target.
AttEnu: &Lattice.Quaternion{
X: Lattice.Float64(0.0),
Y: Lattice.Float64(0.0),
Z: Lattice.Float64(0.0),
W: Lattice.Float64(1.0),
},
},
BearingElevationCovarianceRad2: &Lattice.TMat2{
Mxx: Lattice.Float64(0.0009),
Mxy: Lattice.Float64(0.0),
Myy: Lattice.Float64(0.0025),
},
},
},
},
// position_enu_cov is required for the track to be eligible for
// fusion. A diagonal-only matrix is valid when cross-terms are
// unknown.
LocationUncertainty: &Lattice.LocationUncertainty{
PositionEnuCov: &Lattice.EntityManagerTMat3{
Mxx: Lattice.Float64(25.0),
Myy: Lattice.Float64(25.0),
Mzz: Lattice.Float64(100.0),
},
},
Relationships: &Lattice.Relationships{
Relationships: []*Lattice.Relationship{
{
RelatedEntityID: Lattice.String(sensorEntityId),
RelationshipID: Lattice.String(relationshipId),
RelationshipType: &Lattice.RelationshipType{
TrackedBy: &Lattice.TrackedBy{
LastMeasurementTimestamp: Lattice.Time(latestTimestamp),
// Echo the subset of the tracking entity's sensors
// that produced this detection. Each entry's sensor_id
// and sensor_type must match the corresponding entry
// on the tracking entity's top-level `sensors` component.
ActivelyTrackingSensors: &Lattice.Sensors{
Sensors: []*Lattice.Sensor{
{
SensorID: Lattice.String("camera-01-eo"),
SensorType: Lattice.SensorSensorTypeSensorTypeCamera.Ptr(),
OperationalState: Lattice.SensorOperationalStateOperationalStateOperational.Ptr(),
},
},
},
},
},
},
},
},
Provenance: &Lattice.Provenance{
// integration_name + data_type must be unique for your
// track feed so Lattice can distinguish it from other sources.
IntegrationName: Lattice.String("your_integration_name"),
DataType: Lattice.String("camera_lob"),
SourceUpdateTime: Lattice.Time(latestTimestamp),
},
}
// Publish the entity
_, err := LatticeClient.Entities.PublishEntity(ctx, &entity)
// Handle errors
if err != nil {
fmt.Printf("Error publishing entity: %v\n", err)
} else {
fmt.Println("Publishing track")
}
// Republish at least every 10 seconds to satisfy Lattice's
// source_update_time cadence requirement.
time.Sleep(1 * time.Second)
}
}

Publish a 3D track

Use a 3D track when your sensor can place the target in three-dimensional space. Choose the variant that matches the measurement your sensor produces.

Use this approach for a signal-of-interest track that has a bearing and an estimated range to the emitter, such as a track produced by an RF direction-finding sensor. Set the bearing and range in the signal component rather than the tracked component.

1

Define the entity model’s required components. To represent an RF track with bearing and range:

  • Set template to TEMPLATE_SIGNAL_OF_INTEREST.
  • Populate signal.lineOfBearing.angleOfArrival with the sensor’s pose.
  • Populate signal.lineOfBearing.rangeEstimateM with the estimated distance and one-sigma uncertainty.
entity.json
{
"entityId": "UNIQUE_ENTITY_ID",
"description": "RF emitter detection with estimated range",
"isLive": true,
"createdTime": "2026-05-01T00:00:00.000Z",
"expiryTime": "2026-05-01T00:00:10.000Z",
"aliases": { "name": "SOI-12345678" },
"ontology": { "template": "TEMPLATE_SIGNAL_OF_INTEREST" },
"milView": {
"disposition": "DISPOSITION_UNKNOWN",
"environment": "ENVIRONMENT_AIR"
},
"signal": {
"lineOfBearing": {
"angleOfArrival": {
"relativePose": {
"pos": { "lat": 50.91402185768586, "lon": 0.79203612077257, "alt": 300.0 },
"attEnu": { "x": 0.0, "y": 0.0, "z": 0.0, "w": 1.0 }
},
"bearingElevationCovarianceRad2": { "mxx": 0.0004, "mxy": 0.0, "myy": 0.0009 }
},
"rangeEstimateM": { "value": 12500.0, "sigma": 750.0 }
}
},
"locationUncertainty": {
"positionEnuCov": { "mxx": 400.0, "myy": 400.0, "mzz": 1600.0 }
},
"relationships": {
"relationships": [{
"relatedEntityId": "SENSOR_ENTITY_ID",
"relationshipId": "UNIQUE_ENTITY_ID-tracked-by-SENSOR_ENTITY_ID",
"relationshipType": {
"trackedBy": {
"lastMeasurementTimestamp": "2026-05-01T00:00:00.000Z",
"activelyTrackingSensors": {
"sensors": [{
"sensorId": "rf-1",
"sensorType": "SENSOR_TYPE_RF",
"operationalState": "OPERATIONAL_STATE_OPERATIONAL"
}]
}
}
}
}]
},
"provenance": {
"integrationName": "your_integration_name",
"dataType": "rf_sigint",
"sourceUpdateTime": "2026-05-01T00:00:00.000Z"
}
}
2

Take a closer look at the signal component and its range estimate:

signal
"signal": {
"lineOfBearing": {
"angleOfArrival": {
"relativePose": {
// Sensor position and attitude at the time of the measurement.
"pos": { "lat": 50.91402185768586, "lon": 0.79203612077257, "alt": 300.0 },
"attEnu": { "x": 0.0, "y": 0.0, "z": 0.0, "w": 1.0 }
},
"bearingElevationCovarianceRad2": { "mxx": 0.0004, "mxy": 0.0, "myy": 0.0009 }
},
// Estimated distance from the sensor to the emitter.
// Populate sigma with the one-sigma uncertainty.
"rangeEstimateM": { "value": 12500.0, "sigma": 750.0 }
}
}
3

Use the PublishEntity API method to publish the entity:

package main
import (
"context"
"fmt"
"net/http"
"os"
"time"
Lattice "github.com/anduril/lattice-sdk-go/v5"
"github.com/anduril/lattice-sdk-go/v5/client"
"github.com/anduril/lattice-sdk-go/v5/option"
"github.com/google/uuid"
)
func main() {
// Get environment variables
latticeEndpoint := os.Getenv("LATTICE_ENDPOINT")
environmentToken := os.Getenv("ENVIRONMENT_TOKEN")
// Remove sandboxesToken from the following statements if you are not developing on Sandboxes
sandboxesToken := os.Getenv("SANDBOXES_TOKEN")
// Check required environment variables
if latticeEndpoint == "" || environmentToken == "" || sandboxesToken == "" {
fmt.Println("Missing required environment variables")
os.Exit(1)
}
// Replace with the real entity ID of the RF sensor (published as a
// TEMPLATE_ASSET entity) when running against a live environment.
sensorEntityId := "<SENSOR_ENTITY_ID>"
// Initialize headers for sandbox authorization
headers := http.Header{}
headers.Add("Anduril-Sandbox-Authorization", fmt.Sprintf("Bearer %s", sandboxesToken))
// Create the client
LatticeClient := client.NewClient(
option.WithToken(environmentToken),
option.WithBaseURL(fmt.Sprintf("https://%s", latticeEndpoint)),
option.WithHTTPHeader(headers),
)
// Generate a unique ID for the entity
trackId := uuid.New().String()
relationshipId := fmt.Sprintf("%s-tracked-by-%s", trackId, sensorEntityId)
// Get creation time
creationTime := time.Now().UTC()
// Continuously publish the entity
for {
latestTimestamp := time.Now().UTC()
ctx := context.Background()
// Create entity to publish
entity := Lattice.Entity{
EntityID: &trackId,
Description: Lattice.String("RF emitter detection with estimated range"),
Aliases: &Lattice.Aliases{
Name: Lattice.String(fmt.Sprintf("SOI-%s", trackId[:8])),
},
IsLive: Lattice.Bool(true),
CreatedTime: Lattice.Time(creationTime),
ExpiryTime: Lattice.Time(latestTimestamp.Add(10 * time.Second)),
Ontology: &Lattice.Ontology{
Template: Lattice.OntologyTemplateTemplateSignalOfInterest.Ptr(),
},
MilView: &Lattice.MilView{
Disposition: Lattice.MilViewDispositionDispositionUnknown.Ptr(),
Environment: Lattice.MilViewEnvironmentEnvironmentAir.Ptr(),
},
// 3D SIGINT tracks with a bearing and a range estimate
// populate line_of_bearing on the signal component.
Signal: &Lattice.Signal{
LineOfBearing: &Lattice.LineOfBearing{
AngleOfArrival: &Lattice.AngleOfArrival{
RelativePose: &Lattice.Pose{
Pos: &Lattice.Lla{
Lat: Lattice.Float64(50.91402185768586),
Lon: Lattice.Float64(0.79203612077257),
Alt: Lattice.Float64(300.0),
},
// Identity quaternion: the bearing points due east (ENU +X). Rotate it to point at the target.
AttEnu: &Lattice.Quaternion{
X: Lattice.Float64(0.0),
Y: Lattice.Float64(0.0),
Z: Lattice.Float64(0.0),
W: Lattice.Float64(1.0),
},
},
BearingElevationCovarianceRad2: &Lattice.TMat2{
Mxx: Lattice.Float64(0.0004),
Mxy: Lattice.Float64(0.0),
Myy: Lattice.Float64(0.0009),
},
},
// Estimated distance from the sensor to the emitter,
// with a one-sigma uncertainty in meters.
RangeEstimateM: &Lattice.Measurement{
Value: Lattice.Float64(12500.0),
Sigma: Lattice.Float64(750.0),
},
},
},
// position_enu_cov is required for the track to be eligible for
// fusion. A diagonal-only matrix is valid when cross-terms are
// unknown.
LocationUncertainty: &Lattice.LocationUncertainty{
PositionEnuCov: &Lattice.EntityManagerTMat3{
Mxx: Lattice.Float64(400.0),
Myy: Lattice.Float64(400.0),
Mzz: Lattice.Float64(1600.0),
},
},
Relationships: &Lattice.Relationships{
Relationships: []*Lattice.Relationship{
{
RelatedEntityID: Lattice.String(sensorEntityId),
RelationshipID: Lattice.String(relationshipId),
RelationshipType: &Lattice.RelationshipType{
TrackedBy: &Lattice.TrackedBy{
LastMeasurementTimestamp: Lattice.Time(latestTimestamp),
// Echo the subset of the tracking entity's sensors
// that produced this detection. Each entry's sensor_id
// and sensor_type must match the corresponding entry
// on the tracking entity's top-level `sensors` component.
ActivelyTrackingSensors: &Lattice.Sensors{
Sensors: []*Lattice.Sensor{
{
SensorID: Lattice.String("rf-1"),
SensorType: Lattice.SensorSensorTypeSensorTypeRf.Ptr(),
OperationalState: Lattice.SensorOperationalStateOperationalStateOperational.Ptr(),
},
},
},
},
},
},
},
},
Provenance: &Lattice.Provenance{
IntegrationName: Lattice.String("your_integration_name"),
DataType: Lattice.String("rf_sigint"),
SourceUpdateTime: Lattice.Time(latestTimestamp),
},
}
// Publish the entity
_, err := LatticeClient.Entities.PublishEntity(ctx, &entity)
// Handle errors
if err != nil {
fmt.Printf("Error publishing entity: %v\n", err)
} else {
fmt.Println("Publishing track")
}
// Republish at least every 10 seconds to satisfy Lattice's
// source_update_time cadence requirement.
time.Sleep(1 * time.Second)
}
}

To report a track’s heading, populate location.attitude_enu using the same conventions as assets. For more information, see Orientation conventions.

Manage update rates

Your feed is one of many contributing to a track. Lattice fuses the independent observations from every contributing sensor into a single track, and the accuracy of that fused picture depends on each feed reporting only what its own sensor actually observes. Your sensor is not solely responsible for keeping a track alive: when your sensor stops detecting the target, other sensors in the environment may still be detecting it, and the fusion engine continues to maintain the track from their contributions.

Publish a new update only when your sensor produces a new kinematic detection. Each update must carry a provenance.source_update_time that reflects the time of that detection. Lattice rejects any update whose source_update_time is earlier than or equal to the value it already holds, so do not republish unchanged data to keep a track alive.

Don’t republish stale detections to keep a track alive. Republishing an unchanged detection tells the fusion engine your sensor is still observing the target when it isn’t, which degrades the aggregate picture that every other sensor contributes to. For example, republishing the same kinematic state in the absence of detections makes an air vehicle appear to hover.

Track liveness is governed by expiry_time. Set expiry_time to approximately 10 seconds ahead of the current time on every update. While your sensor keeps detecting the target, each new detection refreshes the expiry and your contribution stays live. When your sensor stops detecting, your contribution expires, and the fused track persists as long as any other sensor continues to contribute.

The preceding examples loop to publish successive detections from a sensor, updating source_update_time and expiry_time on each iteration. In a real integration, drive each iteration from a new sensor measurement rather than a fixed timer.

What’s next?