Tracker service v0.3.0: multiple scenes

tracker/CMakeLists.txt

@@ -14,13 +14,9 @@ string(STRIP "${VERSION_CONTENT}" SCENESCAPE_VERSION)
 # Extract major.minor.patch (strip any suffix like -dev)
 string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" VERSION_SEMVER "${SCENESCAPE_VERSION}")
 
-# Git commit hash: can be passed via -DGIT_COMMIT or GIT_COMMIT env var at build time
-set(GIT_COMMIT "" CACHE STRING "Git commit hash (optional at configure, can use GIT_COMMIT env var at build)")
-if(GIT_COMMIT)
-  message(STATUS "Tracker version: ${SCENESCAPE_VERSION} (${GIT_COMMIT})")
-else()
-  message(STATUS "Tracker version: ${SCENESCAPE_VERSION} (GIT_COMMIT will be read from env at build time)")
-endif()
+# Git commit hash: passed via -DGIT_COMMIT at configure time
+set(GIT_COMMIT "" CACHE STRING "Git commit hash")
+message(STATUS "Tracker version: ${SCENESCAPE_VERSION} (commit: ${GIT_COMMIT})")
 
 #####################################################################
 # Project
@@ -73,11 +69,14 @@ set(PROJECT_SOURCE_LIST
   ${CMAKE_CURRENT_SOURCE_DIR}/src/logger.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/src/cli.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/src/config_loader.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/scene_loader.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/src/healthcheck_server.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/src/healthcheck_command.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/src/mqtt_client.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/src/message_handler.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/scene_registry.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/src/proxy_utils.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/topic_utils.cpp
 )
 
 add_executable(${PROJECT_NAME}
@@ -94,12 +93,11 @@ target_include_directories(${PROJECT_NAME}
 )
 
 # Inject version info as compile definitions
-# GIT_COMMIT: use CMake variable if set, otherwise read from environment at build time
 target_compile_definitions(${PROJECT_NAME}
   PRIVATE
     TRACKER_SERVICE_NAME="${PROJECT_NAME}"
     TRACKER_SERVICE_VERSION="${SCENESCAPE_VERSION}"
-    $<IF:$<BOOL:${GIT_COMMIT}>,TRACKER_GIT_COMMIT="${GIT_COMMIT}",TRACKER_GIT_COMMIT="$ENV{GIT_COMMIT}">
+    TRACKER_GIT_COMMIT="${GIT_COMMIT}"
 )
 
 target_link_libraries(${PROJECT_NAME}

tracker/Dockerfile

@@ -47,15 +47,15 @@ COPY tracker/src tracker/src
 COPY tracker/inc tracker/inc
 COPY controller/src/robot_vision controller/src/robot_vision
 
-# Configure (cacheable - no GIT_COMMIT dependency)
+# Configure and build
+ARG GIT_COMMIT=unknown
 RUN cmake -S tracker -B build -G Ninja \
         -DCMAKE_TOOLCHAIN_FILE=/scenescape/build/conan_toolchain.cmake \
         -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
+        -DGIT_COMMIT=${GIT_COMMIT} \
         -DBUILD_TESTS=OFF
 
-# Build (GIT_COMMIT passed via env var, only recompiles version-dependent files)
-ARG GIT_COMMIT=unknown
-RUN GIT_COMMIT=${GIT_COMMIT} cmake --build build -j
+RUN cmake --build build -j
 
 # Collect all runtime library dependencies for the tracker binary
 WORKDIR /scenescape/runtime-libs

tracker/config/scenes.json

@@ -0,0 +1,94 @@
+[
+  {
+    "uid": "302cf49a-97ec-402d-a324-c5077b280b7b",
+    "name": "Queuing",
+    "cameras": [
+      {
+        "uid": "atag-qcam1",
+        "name": "atag-qcam1",
+        "intrinsics": {
+          "fx": 905.0,
+          "fy": 905.0,
+          "cx": 640.0,
+          "cy": 360.0,
+          "distortion": { "k1": 0.0, "k2": 0.0, "p1": 0.0, "p2": 0.0 }
+        },
+        "extrinsics": {
+          "translation": [
+            2.985857104493509, 0.2054078898442529, 2.7150546825598902
+          ],
+          "rotation": [
+            -135.08718965001765, 12.682032394455131, 19.24508172546946
+          ],
+          "scale": [1.0, 1.0, 1.0]
+        }
+      },
+      {
+        "uid": "atag-qcam2",
+        "name": "atag-qcam2",
+        "intrinsics": {
+          "fx": 905.0,
+          "fy": 905.0,
+          "cx": 640.0,
+          "cy": 360.0,
+          "distortion": { "k1": 0.0, "k2": 0.0, "p1": 0.0, "p2": 0.0 }
+        },
+        "extrinsics": {
+          "translation": [
+            -0.6544951215349519, 2.8628274940885503, 2.894955006060443
+          ],
+          "rotation": [
+            -150.5988934259539, 42.35138027480063, 52.29263795544898
+          ],
+          "scale": [1.0, 1.0, 1.0]
+        }
+      }
+    ]
+  },
+  {
+    "uid": "3bc091c7-e449-46a0-9540-29c499bca18c",
+    "name": "Retail",
+    "cameras": [
+      {
+        "uid": "camera1",
+        "name": "camera1",
+        "intrinsics": {
+          "fx": 571.2592026968458,
+          "fy": 571.2592026968458,
+          "cx": 320.0,
+          "cy": 240.0,
+          "distortion": { "k1": 0.0, "k2": 0.0, "p1": 0.0, "p2": 0.0 }
+        },
+        "extrinsics": {
+          "translation": [
+            2.6651330996559883, 1.0075648853123316, 2.603863333755973
+          ],
+          "rotation": [
+            -137.85924651441334, -19.441505783168942, -15.384890268257454
+          ],
+          "scale": [1.0, 1.0, 1.0]
+        }
+      },
+      {
+        "uid": "camera2",
+        "name": "camera2",
+        "intrinsics": {
+          "fx": 571.2592026968458,
+          "fy": 571.2592026968458,
+          "cx": 320.0,
+          "cy": 240.0,
+          "distortion": { "k1": 0.0, "k2": 0.0, "p1": 0.0, "p2": 0.0 }
+        },
+        "extrinsics": {
+          "translation": [
+            4.034863921795162, 2.2777663107089894, 2.9551143733918663
+          ],
+          "rotation": [
+            -132.15360745910087, -8.172752500708558, -5.298590495090165
+          ],
+          "scale": [1.0, 1.0, 1.0]
+        }
+      }
+    ]
+  }
+]

tracker/config/tracker.json

@@ -15,5 +15,9 @@
     "logging": {
       "level": "info"
     }
+  },
+  "scenes": {
+    "source": "file",
+    "file_path": "scenes.json"
   }
 }

tracker/inc/config_loader.hpp

@@ -3,9 +3,12 @@
 
 #pragma once
 
+#include "scene_loader.hpp"
+
 #include <filesystem>
 #include <optional>
 #include <string>
+#include <vector>
 
 namespace tracker {
 
@@ -74,6 +77,7 @@ struct ObservabilityConfig {
 struct ServiceConfig {
     InfrastructureConfig infrastructure;
     ObservabilityConfig observability;
+    ScenesConfig scenes;
 };
 
 /// JSON Pointer paths (RFC6901) for extracting ServiceConfig values
@@ -93,6 +97,10 @@ constexpr char INFRASTRUCTURE_MQTT_TLS_CLIENT_CERT_PATH[] =
 constexpr char INFRASTRUCTURE_MQTT_TLS_CLIENT_KEY_PATH[] =
     "/infrastructure/mqtt/tls/client_key_path";
 constexpr char INFRASTRUCTURE_MQTT_TLS_VERIFY_SERVER[] = "/infrastructure/mqtt/tls/verify_server";
+
+// Scenes
+constexpr char SCENES_SOURCE[] = "/scenes/source";
+constexpr char SCENES_FILE_PATH[] = "/scenes/file_path";
 } // namespace json
 
 /**

tracker/inc/json_utils.hpp

@@ -0,0 +1,58 @@
+// SPDX-FileCopyrightText: 2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <optional>
+#include <stdexcept>
+#include <string>
+
+#include <rapidjson/pointer.h>
+#include <rapidjson/rapidjson.h>
+
+namespace tracker::detail {
+
+/**
+ * @brief Get optional value from JSON using pointer path.
+ * @tparam T Expected value type (std::string or double)
+ * @param doc The JSON value to query
+ * @param pointer JSON pointer path (e.g., "/intrinsics/fx")
+ * @return Optional containing value if found and correct type, nullopt otherwise
+ */
+template <typename T>
+std::optional<T> get_value(const rapidjson::Value& doc, const char* pointer) {
+    rapidjson::Pointer ptr(pointer);
+    if (auto* val = ptr.Get(doc)) {
+        if constexpr (std::is_same_v<T, std::string>) {
+            if (val->IsString()) {
+                return std::string(val->GetString());
+            }
+        } else if constexpr (std::is_same_v<T, double>) {
+            if (val->IsNumber()) {
+                return val->GetDouble();
+            }
+        }
+    }
+    return std::nullopt;
+}
+
+/**
+ * @brief Get required value from JSON using pointer path.
+ * @tparam T Expected value type (std::string or double)
+ * @param doc The JSON value to query
+ * @param pointer JSON pointer path (e.g., "/uid")
+ * @param context Context string for error messages (e.g., "scene", "camera")
+ * @return Value if found and correct type
+ * @throws std::runtime_error if value missing or wrong type
+ */
+template <typename T>
+T require_value(const rapidjson::Value& doc, const char* pointer, const char* context) {
+    auto result = get_value<T>(doc, pointer);
+    if (!result.has_value()) {
+        throw std::runtime_error(std::string(context) + " missing required '" + (pointer + 1) +
+                                 "' field");
+    }
+    return result.value();
+}
+
+} // namespace tracker::detail

tracker/inc/message_handler.hpp

@@ -5,13 +5,16 @@
 
 #include "config_loader.hpp"
 #include "mqtt_client.hpp"
+#include "scene_registry.hpp"
 
 #include <atomic>
 #include <filesystem>
 #include <map>
 #include <memory>
+#include <mutex>
 #include <optional>
 #include <string>
+#include <unordered_set>
 #include <vector>
 
 #include <rapidjson/document.h>
@@ -60,29 +63,28 @@ struct CameraMessage {
  */
 class MessageHandler {
 public:
-    /// Topic for camera detections (wildcard subscription)
-    static constexpr const char* TOPIC_CAMERA_DATA = "scenescape/data/camera/+";
+    /// Topic prefix for camera detections (used to build per-camera subscriptions)
+    static constexpr const char* TOPIC_CAMERA_PREFIX = "scenescape/data/camera/";
+
+    /// Topic pattern for camera subscriptions (format with camera_id)
+    static constexpr const char* TOPIC_CAMERA_SUBSCRIBE_PATTERN = "scenescape/data/camera/{}";
 
     /// Topic pattern for scene output (format with scene_id and thing_type)
     static constexpr const char* TOPIC_SCENE_DATA_PATTERN = "scenescape/data/scene/{}/{}";
 
-    /// Default scene ID for dummy output
-    static constexpr const char* DUMMY_SCENE_ID = "dummy-scene";
-
-    /// Default scene name for dummy output
-    static constexpr const char* DUMMY_SCENE_NAME = "Test Scene";
-
-    /// Default thing type for dummy output
-    static constexpr const char* DUMMY_THING_TYPE = "thing";
+    /// Default thing type for output (category from detection)
+    static constexpr const char* DEFAULT_THING_TYPE = "thing";
 
     /**
-     * @brief Construct message handler with MQTT client.
+     * @brief Construct message handler with MQTT client and scene registry.
      *
      * @param mqtt_client Shared pointer to MQTT client interface
+     * @param scene_registry Reference to scene registry for camera-to-scene lookup
      * @param schema_validation Enable JSON schema validation for messages
      * @param schema_dir Directory containing schema files (for validation)
      */
-    explicit MessageHandler(std::shared_ptr<IMqttClient> mqtt_client, bool schema_validation = true,
+    explicit MessageHandler(std::shared_ptr<IMqttClient> mqtt_client,
+                            const SceneRegistry& scene_registry, bool schema_validation = true,
                             const std::filesystem::path& schema_dir = "/scenescape/schema");
 
     /**
@@ -138,10 +140,11 @@ class MessageHandler {
     /**
      * @brief Build dummy scene output message using rapidjson.
      *
+     * @param scene Scene configuration
      * @param timestamp ISO 8601 timestamp from input message
      * @return JSON string conforming to scene-data.schema.json
      */
-    std::string buildDummySceneMessage(const std::string& timestamp);
+    std::string buildDummySceneMessage(const Scene& scene, const std::string& timestamp);
 
     /**
      * @brief Validate JSON against a schema.
@@ -163,13 +166,19 @@ class MessageHandler {
     loadSchema(const std::filesystem::path& schema_path);
 
     std::shared_ptr<IMqttClient> mqtt_client_;
+    const SceneRegistry& scene_registry_;
     bool schema_validation_;
     std::unique_ptr<rapidjson::SchemaDocument> camera_schema_;
     std::unique_ptr<rapidjson::SchemaDocument> scene_schema_;
 
     std::atomic<int> received_count_{0};
     std::atomic<int> published_count_{0};
     std::atomic<int> rejected_count_{0};
+
+    /// Cache of validated category names (validated once on first use)
+    /// Protected by categories_mutex_ for thread-safe access from MQTT callback
+    mutable std::mutex categories_mutex_;
+    std::unordered_set<std::string> validated_categories_;
 };
 
 } // namespace tracker