Merge pull request #280 from tritonuas/feat/use-not-stolen-as-mock-camera

Author: CSTBook

configs/dev.json

@@ -54,15 +54,16 @@
     "cv": {
         "yolo_model_dir": "/workspaces/obcpp/models/yolo11x.onnx",
         "not_stolen_addr": "localhost",
-        "not_stolen_port": 5069
+        "not_stolen_port": 6060
     },
     "camera": {
         "_comment": "See CameraConfig struct in datatypes.hpp for detailed explanations",
         "type": "mock",
-        "save_dir": "/workspaces/obcpp/images/",
-        "save_images_to_file": false,
+        "save_dir": "/workspaces/obcpp/images/mock",
+        "save_images_to_file": true,
         "mock": {
-            "images_dir": "/workspaces/obcpp/images/mock/"
+            "not_stolen_port": 6060,
+            "num_images": 10
         },
         "lucid": {
             "sensor_shutter_mode": "Rolling",

configs/jetson.json

@@ -54,15 +54,16 @@
     "cv": {
         "yolo_model_dir": "/obcpp/models/yolo11x.onnx",
         "not_stolen_addr": "localhost",
-        "not_stolen_port": 5069
+        "not_stolen_port": 6060
     },
     "camera": {
         "_comment": "See CameraConfig struct in datatypes.hpp for detailed explanations",
         "type": "picamera",
         "save_dir": "/obcpp/images/",
         "save_images_to_file": true,
         "mock": {
-            "images_dir": "/obcpp/tests/integration/images/saliency/"
+            "not_stolen_port": 6060,
+            "num_images": 10
         },
         "lucid": {
             "sensor_shutter_mode": "Rolling",

docker/sitl-compose.yml

@@ -9,9 +9,10 @@ services:
   not-stolen-israeli-code: 
     image: ghcr.io/tritonuas/not-stolen-israeli-code:latest
     volumes: 
-      - ~/dev/tritonuas/not-stolen-israeli-code/backgrounds:/not-stolen-israeli-code/backgrounds
-      - ~/dev/tritonuas/not-stolen-israeli-code/emergent_target_pics:/not-stolen-israeli-code/emergent_target_pics
+      - ~/Clubs/TUAS/not-stolen-israeli-code/backgrounds:/not-stolen-israeli-code/backgrounds
+      - ~/Clubs/TUAS/not-stolen-israeli-code/emergent_target_pics:/not-stolen-israeli-code/emergent_target_pics
     ports:
-      - 5069:5000
+      - 5069:6060
+    command: poetry run python main.py -d
 volumes:
   sitl:

include/camera/mock.hpp

@@ -7,6 +7,7 @@
 #include <deque>
 #include <vector>
 #include <filesystem>
+#include <string>
 
 #include "camera/interface.hpp"
 #include "network/mavlink.hpp"
@@ -63,10 +64,7 @@ class MockCamera : public CameraInterface {
 
     std::thread captureThread;
 
-    // Get telemetry from JSON file adjacent to given image file.
-    // Ex: given path to "0003.jpg", telemetry will be looked for in
-    // "0003.json"
-    std::optional<ImageTelemetry> getTelemetryFromJsonFile(std::filesystem::path img_path);
+    std::optional<ImageTelemetry> getTelemetryFromJsonResponse(std::string server_response);
 };
 
 #endif  // INCLUDE_CAMERA_MOCK_HPP_

include/utilities/obc_config.hpp

@@ -116,9 +116,10 @@ struct CameraConfig {
     // whether or not to save to save_dir
     bool save_images_to_file;
     struct {
-        // directory to randomly pick images from
-        // for the mock camera
-        std::string images_dir;
+        // port to query images from for the mock camera
+        int not_stolen_port;
+        // number of images to pull
+        int num_images;
     } mock;
 };
 

src/camera/mock.cpp

@@ -1,5 +1,7 @@
 #include "camera/mock.hpp"
 
+#include <httplib.h>
+
 #include <chrono>
 #include <thread>
 #include <optional>
@@ -13,25 +15,46 @@
 #include "utilities/locks.hpp"
 #include "utilities/rng.hpp"
 #include "utilities/common.hpp"
+#include "utilities/base64.hpp"
 
 
 MockCamera::MockCamera(CameraConfig config) : CameraInterface(config) {
-    std::ranges::for_each(
-        std::filesystem::directory_iterator{this->config.mock.images_dir},
-        [this](const auto& dir_entry) {
-            cv::Mat img = cv::imread(dir_entry.path().string());
-            // if the image is read
-            if (img.data != NULL) {
-                std::optional<ImageTelemetry> telemetry =
-                    this->getTelemetryFromJsonFile(dir_entry.path());
-
-                ImageData img_data(
-                    img,
-                    0,
-                    telemetry);
-                this->mock_images.push_back(img_data);
-            }
-        });
+    LOG_F(INFO, "Grabbing images from port " + config.mock.not_stolen_port);
+    httplib::Client cli("localhost", config.mock.not_stolen_port);
+
+    cli.set_read_timeout(10);
+
+    for (int i = 0; i < config.mock.num_images; i++) {
+        httplib::Result res = cli.Get("/generate?format=json");
+
+        if (!res || res->status != 200) {
+            LOG_F(ERROR, "Failed to query server for images");
+            continue;
+        }
+
+        nlohmann::json json = nlohmann::json::parse(res->body, nullptr, true, true);
+
+        std::string decoded_img = base64_decode(json["image_base64"]);
+        std::vector<uchar> data(decoded_img.begin(), decoded_img.end());
+
+        cv::Mat img = cv::imdecode(data, cv::IMREAD_COLOR);
+
+        if (img.data == NULL) {
+            LOG_F(ERROR, "Failed to decode image from server response");
+            continue;
+        }
+
+        ImageTelemetry telemetry = this->getTelemetryFromJsonResponse(res->body).value();
+
+        ImageData img_data(
+            img,
+            0,
+            telemetry);
+
+        this->mock_images.push_back(img_data);
+    }
+
+    cli.stop();
 }
 
 MockCamera::~MockCamera() {
@@ -43,11 +66,12 @@ void MockCamera::connect() { return; }
 bool MockCamera::isConnected() { return true; }
 
 void MockCamera::startTakingPictures(const std::chrono::milliseconds& interval,
-    std::shared_ptr<MavlinkClient> mavlinkClient) {
+                                     std::shared_ptr<MavlinkClient> mavlinkClient) {
     this->isTakingPictures = true;
     try {
         this->captureThread = std::thread(&MockCamera::captureEvery, this, interval, mavlinkClient);
-    } catch (const std::exception& e) {
+    }
+    catch (const std::exception& e) {
         std::cerr << e.what() << std::endl;
     }
 }
@@ -77,11 +101,11 @@ std::deque<ImageData> MockCamera::getAllImages() {
 }
 
 void MockCamera::captureEvery(const std::chrono::milliseconds& interval,
-    std::shared_ptr<MavlinkClient> mavlinkClient) {
+                              std::shared_ptr<MavlinkClient> mavlinkClient) {
     loguru::set_thread_name("mock camera");
     while (this->isTakingPictures) {
-        LOG_F(INFO, "Taking picture with mock camera. Using images from %s",
-            this->config.mock.images_dir.c_str());
+        LOG_F(INFO, "Taking picture with mock camera. Using images from port %d",
+              this->config.mock.not_stolen_port);
         auto imageData = this->takePicture(interval, mavlinkClient);
 
         if (!imageData.has_value()) {
@@ -98,8 +122,8 @@ void MockCamera::captureEvery(const std::chrono::milliseconds& interval,
 }
 
 std::optional<ImageData> MockCamera::takePicture(const std::chrono::milliseconds& timeout,
-        std::shared_ptr<MavlinkClient> mavlinkClient) {
-    int random_idx = randomInt(0, this->mock_images.size()-1);
+                                                 std::shared_ptr<MavlinkClient> mavlinkClient) {
+    int random_idx = randomInt(0, this->mock_images.size() - 1);
 
     ImageData img_data = this->mock_images.at(random_idx);
     uint64_t timestamp = getUnixTime_s().count();
@@ -110,7 +134,7 @@ std::optional<ImageData> MockCamera::takePicture(const std::chrono::milliseconds
         img_data.TELEMETRY = queryMavlinkImageTelemetry(mavlinkClient);
     }
 
-    ImageData imageData {
+    ImageData imageData{
         .DATA = img_data.DATA,
         .TIMESTAMP = timestamp,
         .TELEMETRY = img_data.TELEMETRY,
@@ -121,22 +145,17 @@ std::optional<ImageData> MockCamera::takePicture(const std::chrono::milliseconds
 
 void MockCamera::startStreaming() {}
 
-std::optional<ImageTelemetry> MockCamera::getTelemetryFromJsonFile(std::filesystem::path img_path) {
-    img_path.replace_extension("json");
-    std::ifstream telemetry_stream(img_path);
-    if (!telemetry_stream.is_open()) {
-        // no corresponding telemetry json found
-        return {};
-    }
-    nlohmann::json json = nlohmann::json::parse(telemetry_stream, nullptr, true, true);
-    return ImageTelemetry {
-        .latitude_deg = json["latitude_deg"],
-        .longitude_deg = json["longitude_deg"],
-        .altitude_agl_m = json["altitude_agl_m"],
-        .airspeed_m_s = json["airspeed_m_s"],
-        .heading_deg = json["heading_deg"],
-        .yaw_deg = json["yaw_deg"],
-        .pitch_deg = json["pitch_deg"],
-        .roll_deg = json["roll_deg"],
+std::optional<ImageTelemetry> MockCamera::getTelemetryFromJsonResponse(std::string json_response) {
+    nlohmann::json json = nlohmann::json::parse(json_response, nullptr, true, true);
+
+    return ImageTelemetry{
+        .latitude_deg = json["background"]["lat"],
+        .longitude_deg = json["background"]["lon"],
+        .altitude_agl_m = json["altitude"],
+        .airspeed_m_s = 0.0,
+        .heading_deg = json["background"]["heading_deg"],
+        .yaw_deg = 0.0,
+        .pitch_deg = 0.0,
+        .roll_deg = 0.0,
     };
 }

src/utilities/obc_config.cpp

@@ -93,7 +93,8 @@ OBCConfig::OBCConfig(int argc, char* argv[]) {
     SET_CONFIG_OPT(camera, type);
     SET_CONFIG_OPT(camera, save_dir);
     SET_CONFIG_OPT(camera, save_images_to_file);
-    SET_CONFIG_OPT(camera, mock, images_dir);
+    SET_CONFIG_OPT(camera, mock, not_stolen_port);
+    SET_CONFIG_OPT(camera, mock, num_images);
 
     SET_CONFIG_OPT(takeoff, altitude_m);
     SET_CONFIG_OPT(takeoff, payload_size);