fix(benchmark): support legacy monocular geometry

Signed-off-by: chaofengw <chaofengw@nvidia.com>

Author: chaofengw-nv

apps/benchmark/native/benchmark_worker.cpp

@@ -465,6 +465,75 @@ Json run_transcribe(trtmc::ITask& task, const Json& request, const Timing& timin
         });
 }
 
+template <class T>
+void write_binary_artifact(const std::string& path, const T* values, std::uint64_t count) {
+    if (count > static_cast<std::uint64_t>(std::numeric_limits<std::streamsize>::max()) / sizeof(T))
+        throw std::runtime_error("binary artifact is too large");
+    std::ofstream output(path, std::ios::binary);
+    output.exceptions(std::ios::badbit | std::ios::failbit);
+    output.write(reinterpret_cast<const char*>(values),
+                 static_cast<std::streamsize>(count * sizeof(T)));
+    output.close();
+}
+
+Json run_geometry(trtmc::ITask& task, const Json& request, const Timing& timing) {
+    auto& interface = require_interface<trtmc::IMonocularGeometry>(task, "IMonocularGeometry");
+    const auto path = request.at("image_path").get<std::string>();
+    std::optional<Image> cached;
+    if (!timing.asset_loading_included)
+        cached = read_image(path);
+    auto invoke = [&]() {
+        std::optional<Image> loaded;
+        if (!cached)
+            loaded = read_image(path);
+        const auto& image = cached ? *cached : *loaded;
+        return interface.estimate_geometry(image.pixels.data(), image.height, image.width);
+    };
+    std::optional<trtmc::GeometryResult> last;
+    for (int index = 0; index < timing.warmup; ++index)
+        last = invoke();
+    Json observations = Json::array();
+    for (int index = 0; index < timing.iterations; ++index) {
+        last.reset();
+        const auto started = Clock::now();
+        auto result = invoke();
+        const auto wall_ms = elapsed_ms(started);
+        last.emplace(std::move(result));
+        observations.push_back({{"runtime_e2e_wall_ms", wall_ms},
+                                {"geometry_images", 1},
+                                {"geometry_pixels", last->depth.size()}});
+    }
+    if (last->height <= 0 || last->width <= 0)
+        throw std::runtime_error("monocular geometry returned invalid dimensions");
+    const auto pixels = static_cast<std::size_t>(last->height) * last->width;
+    if (last->points.size() != pixels * 3 || last->depth.size() != pixels ||
+        last->mask.size() != pixels)
+        throw std::runtime_error("monocular geometry returned inconsistent output shapes");
+    const auto prefix = request.at("_artifact_prefix").get<std::string>();
+    write_binary_artifact(prefix + ".points.f32", last->points.data(), last->points.size());
+    write_binary_artifact(prefix + ".depth.f32", last->depth.data(), last->depth.size());
+    write_binary_artifact(prefix + ".mask.u8", last->mask.data(), last->mask.size());
+    Json intrinsics = Json::array();
+    for (int row = 0; row < 3; ++row)
+        intrinsics.push_back({last->intrinsics[row * 3], last->intrinsics[row * 3 + 1],
+                              last->intrinsics[row * 3 + 2]});
+    return {{"observations", std::move(observations)},
+            {"output_summary",
+             {{"geometry_images", 1},
+              {"geometry_pixels", pixels},
+              {"height", last->height},
+              {"width", last->width},
+              {"point_shape", {last->height, last->width, 3}},
+              {"valid_pixels", std::count(last->mask.begin(), last->mask.end(), std::uint8_t{1})},
+              {"normalized_intrinsics", std::move(intrinsics)},
+              {"units", "meters"},
+              {"camera_axes", {"right", "down", "forward"}},
+              {"intrinsics_coordinates", "normalized_uv"},
+              {"points_artifact", prefix + ".points.f32"},
+              {"depth_artifact", prefix + ".depth.f32"},
+              {"valid_mask_artifact", prefix + ".mask.u8"}}}};
+}
+
 Json run_segment(trtmc::ITask& task, const Json& request, const Timing& timing) {
     auto& interface = require_interface<trtmc::ISegmentation>(task, "ISegmentation");
     const Image image = read_image(request.at("image_path").get<std::string>());
@@ -2894,17 +2963,6 @@ Json run_track_pose(const trtmc::Model& model, const Json& request, const Timing
         });
 }
 
-template <class T>
-void write_binary_artifact(const std::string& path, const T* values, std::uint64_t count) {
-    if (count > static_cast<std::uint64_t>(std::numeric_limits<std::streamsize>::max()) / sizeof(T))
-        throw std::runtime_error("binary artifact is too large");
-    std::ofstream output(path, std::ios::binary);
-    output.exceptions(std::ios::badbit | std::ios::failbit);
-    output.write(reinterpret_cast<const char*>(values),
-                 static_cast<std::streamsize>(count * sizeof(T)));
-    output.close();
-}
-
 Json run_geometry(const trtmc::Model& model, const Json& request, const Timing& timing,
                   const std::string& task_id) {
     const auto task = task_for_operation<trtmc::ImageToMetricGeometry>(model, task_id);
@@ -3796,6 +3854,7 @@ Json execute(const Json& request, const std::string& output_path) {
             {"classify", run_classify},
             {"detect", run_detect},
             {"extract_features", run_extract_features},
+            {"geometry", run_geometry},
             {"disparity", run_disparity},
             {"rerank", run_rerank},
             {"encode", run_encode},

apps/benchmark/tests/native/test_benchmark_worker_e2e.cpp

@@ -230,6 +230,41 @@ int main(int argc, char** argv) {
                   prompted.at("box_coordinates") == "original_image_pixels_xyxy",
               "legacy prompted segmentation retains masks, scores and boxes for comparison");
         std::filesystem::remove(prompted_bundle);
+
+        const auto geometry_bundle = runtime_root / "benchmark_fake_geometry.bundle";
+        write_bundle(geometry_bundle, "monocular_geometry");
+        Json geometry_request = request;
+        geometry_request["case_name"] = "fake-monocular-geometry";
+        geometry_request["bundle"] = geometry_bundle.string();
+        geometry_request["operation"] = "geometry";
+        geometry_request["request"] = {{"image_path", legacy_image.string()}};
+        {
+            std::ofstream request_file(request_path);
+            request_file << geometry_request << '\n';
+        }
+        check(std::system(command.c_str()) == 0, "monocular geometry worker process completed");
+        std::ifstream geometry_output_file(output_path);
+        Json geometry_result;
+        geometry_output_file >> geometry_result;
+        const auto& geometry = geometry_result.at("output_summary");
+        check(geometry_result.at("task") == "monocular_geometry" &&
+                  geometry_result.at("selected_task") == "monocular_geometry" &&
+                  geometry.at("geometry_pixels") == 2 &&
+                  geometry.at("point_shape") == Json::array({1, 2, 3}) &&
+                  geometry.at("valid_pixels") == 1 &&
+                  geometry.at("normalized_intrinsics") ==
+                      Json::array({{1.0, 0.0, 0.5}, {0.0, 1.0, 0.5}, {0.0, 0.0, 1.0}}) &&
+                  std::filesystem::file_size(geometry.at("points_artifact").get<std::string>()) ==
+                      6 * sizeof(float) &&
+                  std::filesystem::file_size(geometry.at("depth_artifact").get<std::string>()) ==
+                      2 * sizeof(float) &&
+                  std::filesystem::file_size(
+                      geometry.at("valid_mask_artifact").get<std::string>()) == 2,
+              "legacy monocular geometry retains complete metric artifacts");
+        std::filesystem::remove(geometry.at("points_artifact").get<std::string>());
+        std::filesystem::remove(geometry.at("depth_artifact").get<std::string>());
+        std::filesystem::remove(geometry.at("valid_mask_artifact").get<std::string>());
+        std::filesystem::remove(geometry_bundle);
         std::filesystem::remove(legacy_image);
 
         Json sdk = request;

apps/benchmark/trtmc_benchmark/task_adapters.py

@@ -58,6 +58,7 @@ class CaseResolution:
     "image_text_to_instance_masks": ("segment_prompted", 10, 100),
     "stereo_images_to_disparity": ("disparity", 3, 100),
     "image_to_metric_geometry": ("geometry", 3, 100),
+    "monocular_geometry": ("geometry", 3, 100),
     "text_to_pooled_features": ("encode", 50, 500),
     "text_to_head_scores": ("head_scores", 50, 500),
     "text_to_token_features": ("encode", 50, 500),
@@ -312,7 +313,7 @@ def _request(task: str, case: Mapping[str, Any], root: Path) -> dict[str, Any]:
         return _text_controls(case, include_defaults=False)
     if task in _LATENT_TEXT | _LATENT_STEPS:
         return _latent_request(task, case, root)
-    if task == "image_to_metric_geometry":
+    if task in {"image_to_metric_geometry", "monocular_geometry"}:
         request = {"image_path": _semantic_asset(case, root, "image_path", "image", "test_image")}
         _copy_explicit(request, case, "fov_x")
         return request

apps/benchmark/trtmc_benchmark/tests/test_benchmark.py

@@ -340,6 +340,13 @@ def test_metric_geometry_has_an_image_input_and_preserves_optional_config(sdk_as
     }
 
 
+def test_legacy_monocular_geometry_uses_the_same_public_request(sdk_assets: Path) -> None:
+    result = resolve_task_case("monocular_geometry", {"image": "image.ppm"}, sdk_assets)
+
+    assert result.operation == "geometry"
+    assert result.request == {"image_path": str(sdk_assets / "image.ppm")}
+
+
 def test_image_only_detection_has_no_text_or_postprocessing_defaults(sdk_assets: Path) -> None:
     result = resolve_task_case("image_to_boxes", {"image": "image.ppm", "config": {"score": 0.0}}, sdk_assets)
     assert result.operation == "detect"

core/runtime/tests/fake_family.cpp

@@ -76,6 +76,21 @@ class FakeObjectDetection final : public trtmc::IObjectDetection {
     }
 };
 
+class FakeMonocularGeometry final : public trtmc::IMonocularGeometry {
+  public:
+    trtmc::GeometryResult estimate_geometry(const float*, std::int32_t height,
+                                            std::int32_t width) override {
+        trtmc::GeometryResult result;
+        result.points = {1.0F, 2.0F, 3.0F, 4.0F, 5.0F, 6.0F};
+        result.depth = {3.0F, 6.0F};
+        result.mask = {1, 0};
+        result.intrinsics = {1.0F, 0.0F, 0.5F, 0.0F, 1.0F, 0.5F, 0.0F, 0.0F, 1.0F};
+        result.height = height;
+        result.width = width;
+        return result;
+    }
+};
+
 class FakePointPromptedSegmentation final : public trtmc::IPointPromptedSegmentation {
   public:
     trtmc::PromptedSegmentationResult segment_prompted(const float*, std::int32_t height,
@@ -97,6 +112,8 @@ trtmc::ITask* create_fake_perception_task(const trtmc::FamilyContext& context) {
         return new FakeSegmentation();
     if (context.reader.info().task == trtmc::IObjectDetection::kTask)
         return new FakeObjectDetection();
+    if (context.reader.info().task == trtmc::IMonocularGeometry::kTask)
+        return new FakeMonocularGeometry();
     if (context.reader.info().task == trtmc::IPointPromptedSegmentation::kTask)
         return new FakePointPromptedSegmentation();
     return nullptr;

families/moge/tests/benchmark/moge-2-vitl.yaml

@@ -8,7 +8,6 @@ candidate:
   checkpoint: Ruicheng/moge-2-vitl
   revision: 39c4d5e957afe587e04eec59dc2bcc3be5ecd968
   task: monocular_geometry
-  selected_task: image_to_metric_geometry
   precision: fp32
   bundle: moge-2-vitl.bundle
   build: