Remove first_seen logic from Tracker

Author: dmytroye

tracker/inc/tracking_types.hpp

@@ -96,7 +96,6 @@ struct Track {
     std::array<double, 3> size;        ///< Object size [length, width, height] meters
     std::array<double, 4> rotation;    ///< Orientation quaternion [x, y, z, w]
     std::optional<double> confidence;  ///< Detection confidence score in [0, 1] (absent if not available)
-    std::string first_seen_iso;        ///< ISO 8601 UTC timestamp when this track was first observed
     std::string
         metadata_json; ///< Raw JSON string of the detection's metadata object (empty if absent)
 };

tracker/inc/tracking_worker.hpp

@@ -155,8 +155,7 @@ class TrackingWorker {
      * @return Vector of Track structs ready for publishing
      */
     std::vector<Track> convert_tracks(const std::vector<rv::tracking::TrackedObject>& rv_tracks,
-                                      const std::string& category,
-                                      std::chrono::system_clock::time_point timestamp);
+                                      const std::string& category);
 
     TrackingScope scope_;
     std::string scene_name_;
@@ -172,9 +171,6 @@ class TrackingWorker {
     // RobotVision int ID -> UUID v4 string mapping (single-thread access, no mutex)
     std::unordered_map<int32_t, std::string> id_map_;
 
-    // UUID -> ISO 8601 first-seen timestamp (set when track UUID is first assigned)
-    std::unordered_map<std::string, std::string> first_seen_map_;
-
     std::thread worker_thread_;
     mutable std::mutex queue_mutex_;
     std::condition_variable queue_cv_;

tracker/schema/scene-data.schema.json

@@ -112,11 +112,6 @@
           "description": "Detection confidence score in [0, 1], passed through from the originating detection",
           "minimum": 0,
           "maximum": 1
-        },
-        "first_seen": {
-          "type": "string",
-          "format": "date-time",
-          "description": "ISO 8601 UTC timestamp when this track was first observed by the tracker"
         }
       },
       "additionalProperties": false

tracker/src/track_publisher.cpp

@@ -108,15 +108,6 @@ std::string TrackPublisher::serialize(const std::string& scene_id, const std::st
             obj.AddMember("confidence", Value(*track.confidence), allocator);
         }
 
-        // first_seen (always set by the tracker)
-        if (!track.first_seen_iso.empty()) {
-            obj.AddMember(
-                "first_seen",
-                Value().SetString(track.first_seen_iso.c_str(),
-                                  static_cast<SizeType>(track.first_seen_iso.size()), allocator),
-                allocator);
-        }
-
         objects_array.PushBack(obj, allocator);
     }
 

tracker/src/tracking_worker.cpp

@@ -215,8 +215,7 @@ TrackingWorker::transform_detections(const Chunk& chunk) {
 
 std::vector<Track>
 TrackingWorker::convert_tracks(const std::vector<rv::tracking::TrackedObject>& rv_tracks,
-                               const std::string& category,
-                               std::chrono::system_clock::time_point timestamp) {
+                               const std::string& category) {
     // Extract active RobotVision IDs for map update
     std::vector<int32_t> active_ids;
     active_ids.reserve(rv_tracks.size());
@@ -225,25 +224,7 @@ TrackingWorker::convert_tracks(const std::vector<rv::tracking::TrackedObject>& r
     }
 
     // Update ID map: preserve UUIDs for continuing tracks, generate new for new tracks
-    auto new_map = update_id_map(id_map_, active_ids);
-
-    // Record first_seen for any brand-new UUIDs (not present in the old id_map_)
-    const std::string ts_iso = formatTimestamp(timestamp);
-    for (const auto& [rv_id, uuid] : new_map) {
-        if (!id_map_.contains(rv_id)) {
-            first_seen_map_.emplace(uuid, ts_iso);
-        }
-    }
-
-    // Prune first_seen_map_ entries for tracks that have disappeared
-    for (auto it = first_seen_map_.begin(); it != first_seen_map_.end();) {
-        // Check if this UUID is still active
-        bool active = std::any_of(new_map.begin(), new_map.end(),
-                                  [&uuid = it->first](const auto& kv) { return kv.second == uuid; });
-        it = active ? std::next(it) : first_seen_map_.erase(it);
-    }
-
-    id_map_ = std::move(new_map);
+    id_map_ = update_id_map(id_map_, active_ids);
 
     std::vector<Track> tracks;
     tracks.reserve(rv_tracks.size());
@@ -257,11 +238,6 @@ TrackingWorker::convert_tracks(const std::vector<rv::tracking::TrackedObject>& r
         track.size = {rv_track.length, rv_track.width, rv_track.height};
         track.rotation = CoordinateTransformer::yawToQuaternion(rv_track.yaw);
 
-        // Set first_seen from map (always present for active tracks)
-        if (auto it = first_seen_map_.find(track.id); it != first_seen_map_.end()) {
-            track.first_seen_iso = it->second;
-        }
-
         // Retrieve metadata_json stored in attributes by transform_detections().
         // NOTE: multi-camera last-write-wins — when the same track is observed by
         // multiple cameras in one time chunk, rv::tracking::TrackedObject::attributes
@@ -303,7 +279,7 @@ std::vector<Track> TrackingWorker::match_and_convert(
 
     // Get reliable tracks and map RobotVision int IDs to UUID strings
     auto rv_tracks = tracker_.getReliableTracks();
-    auto tracks = convert_tracks(rv_tracks, chunk.category, timestamp);
+    auto tracks = convert_tracks(rv_tracks, chunk.category);
 
     LOG_DEBUG("Processed chunk for {}/{}: {} detections -> {} reliable tracks", scope_.scene_id,
               scope_.category,

tracker/test/unit/track_publisher_test.cpp

@@ -357,48 +357,5 @@ TEST_F(TrackPublisherTest, Serialize_Track_WithoutConfidence_OmitsConfidenceFiel
     EXPECT_FALSE(doc["objects"][0].HasMember("confidence"));
 }
 
-TEST_F(TrackPublisherTest, Serialize_Track_WithFirstSeen_EmitsFirstSeenField) {
-    auto mock_client = std::make_shared<MockMqttClient>();
-    TrackPublisher publisher(mock_client);
-
-    std::string captured_payload;
-    EXPECT_CALL(*mock_client, isConnected()).WillOnce(Return(true));
-    EXPECT_CALL(*mock_client, publish(_, _))
-        .WillOnce([&captured_payload](const std::string&, const std::string& payload) {
-            captured_payload = payload;
-        });
-
-    Track track = createSampleTrack("a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d", "person");
-    track.first_seen_iso = "2026-01-27T11:00:00.000Z";
-    publisher.publish("scene-1", "Scene", "person", "2026-01-27T12:00:00.000Z", {track}, {});
-
-    rapidjson::Document doc;
-    ASSERT_FALSE(doc.Parse(captured_payload.c_str()).HasParseError());
-
-    ASSERT_TRUE(doc["objects"][0].HasMember("first_seen"));
-    EXPECT_STREQ(doc["objects"][0]["first_seen"].GetString(), "2026-01-27T11:00:00.000Z");
-}
-
-TEST_F(TrackPublisherTest, Serialize_Track_WithoutFirstSeen_OmitsFirstSeenField) {
-    auto mock_client = std::make_shared<MockMqttClient>();
-    TrackPublisher publisher(mock_client);
-
-    std::string captured_payload;
-    EXPECT_CALL(*mock_client, isConnected()).WillOnce(Return(true));
-    EXPECT_CALL(*mock_client, publish(_, _))
-        .WillOnce([&captured_payload](const std::string&, const std::string& payload) {
-            captured_payload = payload;
-        });
-
-    Track track = createSampleTrack("a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d", "person");
-    // first_seen_iso is empty (default-constructed)
-    publisher.publish("scene-1", "Scene", "person", "2026-01-27T12:00:00.000Z", {track}, {});
-
-    rapidjson::Document doc;
-    ASSERT_FALSE(doc.Parse(captured_payload.c_str()).HasParseError());
-
-    EXPECT_FALSE(doc["objects"][0].HasMember("first_seen"));
-}
-
 } // namespace
 } // namespace tracker

tracker/test/unit/tracking_worker_test.cpp

@@ -605,76 +605,5 @@ TEST_F(TrackingWorkerTest, Tracking_Confidence_PreservedThroughTracker) {
     }
 }
 
-// Test that first_seen is set on the first observation of a track and remains stable
-// across subsequent observations (same RobotVision ID → same UUID → same first_seen).
-TEST_F(TrackingWorkerTest, Tracking_FirstSeen_SetOnFirstObservationAndStable) {
-    std::vector<Track> all_published_tracks;
-    std::mutex mtx;
-    std::condition_variable cv;
-    int callback_count = 0;
-    const int kChunksToSend = 3;
-
-    PublishCallback callback = [&](const std::string&, const std::string&, const std::string&,
-                                   const std::string&, const std::vector<Track>& tracks,
-                                   const std::unordered_map<std::string, double>&) {
-        std::lock_guard lock(mtx);
-        all_published_tracks.insert(all_published_tracks.end(), tracks.begin(), tracks.end());
-        callback_count++;
-        cv.notify_one();
-    };
-
-    TrackingConfig config = make_test_tracking_config();
-    config.max_unreliable_time_s = 0.0;
-
-    TrackingScope scope{"scene-1", "person"};
-    TrackingWorker worker(scope, "Test Scene", 10, callback, config, cameras_);
-
-    for (int i = 0; i < kChunksToSend; ++i) {
-        Chunk chunk;
-        chunk.scene_id = "scene-1";
-        chunk.category = "person";
-        chunk.chunk_time = std::chrono::steady_clock::now();
-
-        DetectionBatch batch;
-        batch.camera_id = "cam-1";
-        batch.timestamp_iso = std::format("2026-01-27T12:00:{:02d}.000Z", i);
-        batch.timestamp = std::chrono::system_clock::now();
-
-        Detection det;
-        det.id = 1;
-        det.bounding_box_px = cv::Rect2f(100.0f, 200.0f, 50.0f, 100.0f);
-        batch.detections.push_back(std::move(det));
-
-        chunk.camera_batches.push_back(std::move(batch));
-        worker.try_enqueue(std::move(chunk));
-    }
-
-    {
-        std::unique_lock lock(mtx);
-        ASSERT_TRUE(cv.wait_for(lock, std::chrono::seconds(2),
-                                [&] { return callback_count >= kChunksToSend; }))
-            << "Timed out waiting for " << kChunksToSend << " publish callbacks";
-    }
-
-    ASSERT_GT(all_published_tracks.size(), 0u)
-        << "No reliable tracks published";
-
-    // All tracks should have a non-empty first_seen
-    for (const auto& track : all_published_tracks) {
-        EXPECT_FALSE(track.first_seen_iso.empty())
-            << "Track " << track.id << " is missing first_seen";
-    }
-
-    // Tracks with the same ID must have the same first_seen (stable across frames)
-    std::unordered_map<std::string, std::string> id_to_first_seen;
-    for (const auto& track : all_published_tracks) {
-        auto [it, inserted] = id_to_first_seen.emplace(track.id, track.first_seen_iso);
-        if (!inserted) {
-            EXPECT_EQ(it->second, track.first_seen_iso)
-                << "Track " << track.id << " has inconsistent first_seen across frames";
-        }
-    }
-}
-
 } // namespace
 } // namespace tracker