Chore: Prune Integration Tests (#272)

* chore: prune airdrop_packets

* chore: change config to look for mock images in obcpp/images/mock

* chore: remove camera_playground

* qol: cuda_check now prints english boolean values

* chore: cv_aggregator | lint | template for dependencies

* chore: delete old cv tests

* chore: prune cv_mapping | update camera_mock cli warning | camera_mock pruning

* chore: prune cv_pipeline | add header comment

* chore: make integration tests take png | prune + header comment for cv_preprocess

* chore: cv_yolo

* chore: remove print from deviation code | make deviation integration test match other pathing tests

* chore: prune dependencies for deviation ranking

* chore: prune drop_it... dependencies

* chore: delete load_torchvision_model integration test

* chore: prune mavlink_client integratino test

* fix: circular dependency between camera and mavlink | chore: prune plotting

* chore: prune picam dependencies + cmake

* chore: uncomment redundant imports for path_plotting (for 'readability'

* Update tests/integration/cv_yolo.cpp

Co-authored-by: Copilot <[email protected]>

---------

Co-authored-by: Copilot <[email protected]>

Author: AskewParity

configs/dev.json

@@ -62,7 +62,7 @@
         "save_dir": "/workspaces/obcpp/images/",
         "save_images_to_file": false,
         "mock": {
-            "images_dir": "/workspaces/obcpp/tests/integration/images/saliency/"
+            "images_dir": "/workspaces/obcpp/images/mock/"
         },
         "lucid": {
             "sensor_shutter_mode": "Rolling",

include/camera/interface.hpp

@@ -13,7 +13,9 @@
 #include <opencv2/opencv.hpp>
 #include <opencv2/core/mat.hpp>
 
-#include "network/mavlink.hpp"
+// Forward declaration to avoid circular dependency
+// #include "network/mavlink.hpp"
+class MavlinkClient;
 #include "utilities/datatypes.hpp"
 #include "utilities/obc_config.hpp"
 

src/CMakeLists.txt

@@ -17,10 +17,10 @@ add_subdirectory(utilities)
 add_library(obcpp_lib INTERFACE)
 target_link_libraries(obcpp_lib INTERFACE
     obcpp_protos
+    obcpp_network
     obcpp_camera
     obcpp_core
     obcpp_cv
-    obcpp_network
     obcpp_pathing
     obcpp_ticks
     obcpp_utilities

src/camera/CMakeLists.txt

@@ -8,7 +8,7 @@ set(FILES
 
 SET(LIB_DEPS
     obcpp_protos
-    obcpp_network
+    # obcpp_network # circular dependency
 )
 
 add_library(${LIB_NAME} STATIC

src/camera/interface.cpp

@@ -7,6 +7,7 @@
 #include "nlohmann/json.hpp"
 #include <loguru.hpp>
 
+#include "network/mavlink.hpp"  // imported here but not in the header due to circular dependency
 #include "utilities/base64.hpp"
 
 using json = nlohmann::json;

src/camera/mock.cpp

@@ -30,8 +30,6 @@ MockCamera::MockCamera(CameraConfig config) : CameraInterface(config) {
                     0,
                     telemetry);
                 this->mock_images.push_back(img_data);
-            } else {
-                LOG_F(ERROR, "IMG DIRECTORY IS EMPTY | RIP CAT");
             }
         });
 }

src/core/CMakeLists.txt

@@ -7,11 +7,10 @@ set(FILES
 )
 
 set(LIB_DEPS
-    obcpp_protos
     obcpp_camera
     obcpp_cv
-    obcpp_network
     obcpp_pathing
+    obcpp_protos
     obcpp_ticks
     obcpp_utilities
 )

src/network/CMakeLists.txt

@@ -19,11 +19,10 @@ set(MOCK_FILES
 )
 
 set(LIB_DEPS
-    obcpp_protos
-    obcpp_utilities
-    obcpp_ticks
     obcpp_core
     obcpp_pathing
+    obcpp_protos
+    obcpp_utilities
 )
 
 add_library(${LIB_NAME} STATIC

src/pathing/static.cpp

@@ -552,7 +552,6 @@ std::vector<std::vector<XYZCoord>> generateRankedNewGoalsList(const std::vector<
     std::vector<XYZCoord> deviation_points;
     for (int i = 0; i < 200; i++) {
         deviation_points.push_back(mapping_bounds.getRandomPoint(true));
-        printf("Deviation point: %f, %f\n", deviation_points.back().x, deviation_points.back().y);
     }
 
     // each deviation point can be inserted between any two goals

tests/integration/CMakeLists.txt

@@ -1,3 +1,23 @@
+# LIST OF ALL TARGETS
+# add_executable(EXECUTABLE_NAME "SRC_FILE_WITH_MAIN.cpp")
+# target_link_libraries(EXECUTABLE_NAME PRIVATE obcpp_lib)
+# target_include_directories(EXECUTABLE_NAME PRIVATE ${INCLUDE_DIRECTORY} ${GEN_PROTOS_DIRECTORY})
+# target_add_torch(EXECUTABLE_NAME)
+# target_add_json(EXECUTABLE_NAME)
+# target_add_opencv(EXECUTABLE_NAME) 
+# target_add_httplib(EXECUTABLE_NAME)
+# target_add_mavsdk(EXECUTABLE_NAME)
+# target_add_matplot(EXECUTABLE_NAME)
+# target_add_protobuf(EXECUTABLE_NAME)
+# target_add_loguru(EXECUTABLE_NAME)
+# target_add_onnxruntime(EXECUTABLE_NAME)
+# # for some reason calling target_add_imagemagick here conflicts with, so we are including/linking without the function call
+# # target_add_imagemagick(path_plotting)
+# target_include_directories(EXECUTABLE_NAME PRIVATE ${ImageMagick_INCLUDE_DIRS})
+# target_link_libraries(EXECUTABLE_NAME PRIVATE -Wl,--copy-dt-needed-entries ${ImageMagick_LIBRARIES})
+
+
+
 # playground
 add_executable(playground "playground.cpp")
 target_link_libraries(playground PRIVATE obcpp_lib)
@@ -16,126 +36,56 @@ target_add_onnxruntime(playground)
 target_include_directories(playground PRIVATE ${ImageMagick_INCLUDE_DIRS})
 target_link_libraries(playground PRIVATE -Wl,--copy-dt-needed-entries ${ImageMagick_LIBRARIES})
 
-# load_torchvision_model
-add_executable(load_torchvision_model  "load_torchvision_model.cpp")
-target_link_libraries(load_torchvision_model PRIVATE obcpp_lib)
-target_add_torch(load_torchvision_model)
-target_add_torchvision(load_torchvision_model)
-target_add_loguru(load_torchvision_model)
-
 # mavlink-client
 add_executable(mavlink_client "mavlink_client.cpp")
 target_link_libraries(mavlink_client PRIVATE obcpp_lib)
 target_include_directories(mavlink_client PRIVATE ${INCLUDE_DIRECTORY})
-target_add_protobuf(mavlink_client)
-target_add_torch(mavlink_client)
-target_add_torchvision(mavlink_client)
-target_add_json(mavlink_client)
-target_add_opencv(mavlink_client)
-target_add_httplib(mavlink_client)
 target_add_mavsdk(mavlink_client)
 target_add_matplot(mavlink_client)
 target_add_loguru(mavlink_client)
-target_add_onnxruntime(mavlink_client)
-# for some reason calling target_add_imagemagick here conflicts with, so we are including/linking without the function call
-# target_add_imagemagick(path_plotting)
-target_include_directories(mavlink_client PRIVATE ${ImageMagick_INCLUDE_DIRS})
-target_link_libraries(mavlink_client PRIVATE -Wl,--copy-dt-needed-entries ${ImageMagick_LIBRARIES})
 
 # cv_pipeline 
 add_executable(cv_pipeline "cv_pipeline.cpp")
 target_link_libraries(cv_pipeline PRIVATE obcpp_lib)
 target_add_json(cv_pipeline)
 target_add_matplot(cv_pipeline)
-target_add_opencv(cv_pipeline)
 target_add_loguru(cv_pipeline)
-target_add_httplib(cv_pipeline)
-target_add_protobuf(cv_pipeline)
-target_add_torch(cv_pipeline)
-target_add_torchvision(cv_pipeline)
 target_add_mavsdk(cv_pipeline)
-target_add_loguru(cv_pipeline)
-target_add_onnxruntime(cv_pipeline)
-# for some reason calling target_add_imagemagick here conflicts with, so we are including/linking without the function call
-# target_add_imagemagick(path_plotting)
-target_include_directories(cv_pipeline PRIVATE ${ImageMagick_INCLUDE_DIRS})
-target_link_libraries(cv_pipeline PRIVATE -Wl,--copy-dt-needed-entries ${ImageMagick_LIBRARIES})
 
 # cv_aggregator 
 add_executable(cv_aggregator ${SOURCES} "cv_aggregator.cpp")
 target_link_libraries(cv_aggregator PRIVATE obcpp_lib)
 target_add_json(cv_aggregator)
 target_add_matplot(cv_aggregator)
-target_add_opencv(cv_aggregator)
 target_add_loguru(cv_aggregator)
-target_add_httplib(cv_aggregator)
-target_add_protobuf(cv_aggregator)
-target_add_torch(cv_aggregator)
-target_add_torchvision(cv_aggregator)
 target_add_mavsdk(cv_aggregator)
-target_add_loguru(cv_aggregator)
-target_add_onnxruntime(cv_aggregator)
-# for some reason calling target_add_imagemagick here conflicts with, so we are including/linking without the function call
-# target_add_imagemagick(path_plotting)
-target_include_directories(cv_aggregator PRIVATE ${ImageMagick_INCLUDE_DIRS})
-target_link_libraries(cv_aggregator PRIVATE -Wl,--copy-dt-needed-entries ${ImageMagick_LIBRARIES})
 
 # cv_preprocess
 add_executable(cv_preprocess ${SOURCES} "cv_preprocess.cpp")
 target_link_libraries(cv_preprocess PRIVATE obcpp_lib)
 target_include_directories(cv_preprocess PRIVATE ${INCLUDE_DIRECTORY})
-target_add_opencv(cv_preprocess) 
 target_add_matplot(cv_preprocess)
-target_add_json(cv_preprocess)
-target_add_loguru(cv_preprocess)
-target_include_directories(cv_preprocess PRIVATE ${ImageMagick_INCLUDE_DIRS})
-target_link_libraries(cv_preprocess PRIVATE -Wl,--copy-dt-needed-entries ${ImageMagick_LIBRARIES})
 
 # cv_mapping
 add_executable(cv_mapping ${SOURCES} "cv_mapping.cpp")
 target_link_libraries(cv_mapping PRIVATE obcpp_lib)
 target_include_directories(cv_mapping PRIVATE ${INCLUDE_DIRECTORY})
-target_add_opencv(cv_mapping) 
-target_add_matplot(cv_mapping)
-target_add_json(cv_mapping)
-target_add_loguru(cv_mapping)
-target_include_directories(cv_mapping PRIVATE ${ImageMagick_INCLUDE_DIRS})
-target_link_libraries(cv_mapping PRIVATE -Wl,--copy-dt-needed-entries ${ImageMagick_LIBRARIES})
 
 # cv_yolo
 add_executable(cv_yolo ${SOURCES} "cv_yolo.cpp")
 target_link_libraries(cv_yolo PRIVATE obcpp_lib)
 target_include_directories(cv_yolo PRIVATE ${INCLUDE_DIRECTORY})
-target_add_torch(cv_yolo)
-target_add_opencv(cv_yolo) 
-target_add_torchvision(cv_yolo)
-target_add_matplot(cv_yolo)
-target_add_json(cv_yolo)
-target_add_loguru(cv_yolo)
-target_add_onnxruntime(cv_yolo)
-target_include_directories(cv_yolo PRIVATE ${ImageMagick_INCLUDE_DIRS})
-target_link_libraries(cv_yolo PRIVATE -Wl,--copy-dt-needed-entries ${ImageMagick_LIBRARIES})
 
 # for some reason calling target_add_imagemagick here conflicts with, so we are including/linking without the function call
 # target_add_imagemagick(${PROJECT_NAME})
 target_include_directories(${PROJECT_NAME} PRIVATE ${ImageMagick_INCLUDE_DIRS})
 target_link_libraries(${PROJECT_NAME} PRIVATE -Wl,--copy-dt-needed-entries ${ImageMagick_LIBRARIES})
+
 # path_plotting 
 add_executable(path_plotting "path_plotting.cpp")
 target_link_libraries(path_plotting PRIVATE obcpp_lib)
-target_add_torch(path_plotting)
-target_add_json(path_plotting)
-target_add_httplib(path_plotting)
-target_add_mavsdk(path_plotting)
+target_include_directories(path_plotting PRIVATE ${INCLUDE_DIRECTORY})
 target_add_matplot(path_plotting)
-target_add_protobuf(path_plotting)
-target_add_opencv(path_plotting) 
-target_add_loguru(path_plotting)
-target_add_onnxruntime(path_plotting)
-# for some reason calling target_add_imagemagick here conflicts with, so we are including/linking without the function call
-# target_add_imagemagick(path_plotting)
-target_include_directories(path_plotting PRIVATE ${ImageMagick_INCLUDE_DIRS})
-target_link_libraries(path_plotting PRIVATE -Wl,--copy-dt-needed-entries ${ImageMagick_LIBRARIES})
 
 add_executable(path_planning "path_planning.cpp")
 target_link_libraries(path_planning PRIVATE obcpp_lib)
@@ -168,111 +118,48 @@ target_add_loguru(airdrop_approach)
 add_executable(deviation_ranking "deviation_ranking.cpp")
 target_link_libraries(deviation_ranking PRIVATE obcpp_lib)
 target_include_directories(deviation_ranking PRIVATE ${INCLUDE_DIRECTORY})
-target_add_protobuf(deviation_ranking)
-target_add_torch(deviation_ranking)
-target_add_torchvision(deviation_ranking)
 target_add_json(deviation_ranking)
-target_add_opencv(deviation_ranking)
 target_add_httplib(deviation_ranking)
 target_add_mavsdk(deviation_ranking)
 target_add_matplot(deviation_ranking)
 target_add_loguru(deviation_ranking)
 
-target_include_directories(deviation_ranking PRIVATE ${ImageMagick_INCLUDE_DIRS})
-target_link_libraries(deviation_ranking PRIVATE -Wl,--copy-dt-needed-entries ${ImageMagick_LIBRARIES})
 
 add_executable(airdrop_packets "airdrop_packets.cpp")
 target_link_libraries(airdrop_packets PRIVATE obcpp_lib)
 target_include_directories(airdrop_packets PRIVATE ${INCLUDE_DIRECTORY})
 target_add_protobuf(airdrop_packets)
-target_add_torch(airdrop_packets)
-target_add_torchvision(airdrop_packets)
-target_add_json(airdrop_packets)
-target_add_opencv(airdrop_packets)
-target_add_httplib(airdrop_packets)
-target_add_mavsdk(airdrop_packets)
 target_add_matplot(airdrop_packets)
 target_add_loguru(airdrop_packets)
-target_add_onnxruntime(airdrop_packets)
-
-target_include_directories(airdrop_packets PRIVATE ${ImageMagick_INCLUDE_DIRS})
-target_link_libraries(airdrop_packets PRIVATE -Wl,--copy-dt-needed-entries ${ImageMagick_LIBRARIES})
 
 # airdrop_sockets
 # add_executable(airdrop_sockets src/network/airdrop_sockets.c tests/integration/airdrop_sockets.c)
 # target_include_directories(airdrop_sockets PRIVATE ${INCLUDE_DIRECTORY})
 
-# add_executable(camera_playground camera_playground.cpp)
-# target_include_directories(camera_playground PRIVATE ${INCLUDE_DIRECTORY})
-# add_custom_target(
-#     run_camera_playground
-#     ${CMAKE_COMMAND}
-#     -E env LD_LIBRARY_s/target_siamese_1.pt
-# )
-
 add_executable(camera_mock "camera_mock.cpp")
 target_link_libraries(camera_mock PRIVATE obcpp_lib)
 target_include_directories(camera_mock PRIVATE ${INCLUDE_DIRECTORY})
-target_add_protobuf(camera_mock)
-target_add_torch(camera_mock)
-target_add_torchvision(camera_mock)
 target_add_json(camera_mock)
-target_add_opencv(camera_mock)
-target_add_httplib(camera_mock)
 target_add_mavsdk(camera_mock)
 target_add_matplot(camera_mock)
 target_add_loguru(camera_mock)
-target_add_onnxruntime(camera_mock)
-target_include_directories(camera_mock PRIVATE ${ImageMagick_INCLUDE_DIRS})
-target_link_libraries(camera_mock PRIVATE -Wl,--copy-dt-needed-entries ${ImageMagick_LIBRARIES})
 
 # cuda_check
 add_executable(cuda_check ${SOURCES} cuda_check.cpp)
 target_add_torch(cuda_check)
-target_add_json(cuda_check)
-target_add_httplib(cuda_check)
-target_add_mavsdk(cuda_check)
-target_add_matplot(cuda_check)
-target_add_protobuf(cuda_check)
-target_add_opencv(cuda_check)
-target_add_loguru(cuda_check)
-target_add_onnxruntime(cuda_check)
-# for some reason calling target_add_imagemagick here conflicts with, so we are including/linking without the function call
-# target_add_imagemagick(cuda_check)
-target_include_directories(cuda_check PRIVATE ${ImageMagick_INCLUDE_DIRS})
-target_link_libraries(cuda_check PRIVATE -Wl,--copy-dt-needed-entries ${ImageMagick_LIBRARIES})
-
-
 
 add_executable(drop_it_like_its_hot "drop_it_like_its_hot.cpp")
 target_link_libraries(drop_it_like_its_hot PRIVATE obcpp_lib)
 target_include_directories(drop_it_like_its_hot PRIVATE ${INCLUDE_DIRECTORY})
-target_add_protobuf(drop_it_like_its_hot)
-target_add_torch(drop_it_like_its_hot)
-target_add_torchvision(drop_it_like_its_hot)
 target_add_json(drop_it_like_its_hot)
-target_add_opencv(drop_it_like_its_hot)
-target_add_httplib(drop_it_like_its_hot)
 target_add_mavsdk(drop_it_like_its_hot)
 target_add_matplot(drop_it_like_its_hot)
 target_add_loguru(drop_it_like_its_hot)
-target_add_onnxruntime(drop_it_like_its_hot)
-target_include_directories(drop_it_like_its_hot PRIVATE ${ImageMagick_INCLUDE_DIRS})
-target_link_libraries(drop_it_like_its_hot PRIVATE -Wl,--copy-dt-needed-entries ${ImageMagick_LIBRARIES})
 
 add_executable(picamera "picamera.cpp")
-target_link_libraries(picamera PRIVATE obcpp_lib)
+target_link_libraries(picamera PRIVATE obcpp_lib obcpp_camera obcpp_network)
 target_include_directories(picamera PRIVATE ${INCLUDE_DIRECTORY})
-target_add_torch(picamera)
 target_add_json(picamera)
-target_add_opencv(picamera) 
-target_add_httplib(picamera)
 target_add_mavsdk(picamera)
 target_add_matplot(picamera)
-target_add_protobuf(picamera)
 target_add_loguru(picamera)
-target_add_onnxruntime(picamera)
-# for some reason calling target_add_imagemagick here conflicts with, so we are including/linking without the function call
-# target_add_imagemagick(path_plotting)
-target_include_directories(picamera PRIVATE ${ImageMagick_INCLUDE_DIRS})
-target_link_libraries(picamera PRIVATE -Wl,--copy-dt-needed-entries ${ImageMagick_LIBRARIES})