Speed up builds and adapt to OpenCV-free result types.

Use Ninja and ccache in CI, compile app sources once via a static
library, skip fetched subproject tests, pin vision-core to the new
result-type commit, and convert rendering through opencv_interop.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: olibartfast

.github/actions/install-linux-deps/action.yml

@@ -9,7 +9,7 @@ runs:
       run: |
         sudo apt-get update
         sudo apt-get install -y --no-install-recommends \
-          cmake build-essential git wget \
+          cmake build-essential git wget ninja-build ccache \
           libopencv-dev \
           libgoogle-glog-dev \
           libcurl4-openssl-dev \

.github/workflows/ci.yml

@@ -24,6 +24,11 @@ jobs:
       - name: Install shared dependencies
         uses: ./.github/actions/install-linux-deps
 
+      - name: Set up ccache
+        uses: hendrikmuhs/ccache-action@v1
+        with:
+          key: ${{ github.job }}-${{ runner.os }}
+
       - name: Cache CMake build
         uses: actions/cache@v4
         with:
@@ -33,10 +38,12 @@ jobs:
 
       - name: Configure
         run: |
-          cmake -B build \
+          cmake -B build -G Ninja \
             -DDEFAULT_BACKEND=OPENCV_DNN \
+            -DVISION_CORE_VERSION=develop \
             -DENABLE_APP_TESTS=ON \
-            -DCMAKE_BUILD_TYPE=Release
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
 
       - name: Check model-type docs are in sync
         run: |
@@ -78,6 +85,11 @@ jobs:
           tar -xzf onnxruntime-linux-x64-gpu-${ORT_VERSION}.tgz -C ~
           rm onnxruntime-linux-x64-gpu-${ORT_VERSION}.tgz
 
+      - name: Set up ccache
+        uses: hendrikmuhs/ccache-action@v1
+        with:
+          key: ${{ github.job }}-${{ runner.os }}
+
       - name: Cache CMake build
         uses: actions/cache@v4
         with:
@@ -87,12 +99,13 @@ jobs:
 
       - name: Configure
         run: |
-          cmake -B build \
+          cmake -B build -G Ninja \
             -DDEFAULT_BACKEND=ONNX_RUNTIME \
             -DORT_VERSION=${ORT_VERSION} \
             -DONNX_RUNTIME_DIR=$HOME/onnxruntime-linux-x64-gpu-${ORT_VERSION} \
             -DENABLE_APP_TESTS=OFF \
-            -DCMAKE_BUILD_TYPE=Release
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
 
       - name: Build
         run: cmake --build build --config Release --parallel $(nproc)
@@ -125,6 +138,11 @@ jobs:
           unzip -q libtorch.zip -d ~
           rm libtorch.zip
 
+      - name: Set up ccache
+        uses: hendrikmuhs/ccache-action@v1
+        with:
+          key: ${{ github.job }}-${{ runner.os }}
+
       - name: Cache CMake build
         uses: actions/cache@v4
         with:
@@ -134,12 +152,13 @@ jobs:
 
       - name: Configure
         run: |
-          cmake -B build \
+          cmake -B build -G Ninja \
             -DDEFAULT_BACKEND=LIBTORCH \
             -DCMAKE_PREFIX_PATH=$HOME/libtorch \
             -DLIBTORCH_DIR=$HOME/libtorch \
             -DENABLE_APP_TESTS=OFF \
-            -DCMAKE_BUILD_TYPE=Release
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
 
       - name: Build
         run: cmake --build build --config Release --parallel $(nproc)

CMakeLists.txt

@@ -13,9 +13,35 @@ endif()
 
 project(vision-inference VERSION ${PROJECT_SEMVER})
 
+include(cmake/CompileSpeed.cmake)
+
 # Set C++ standard
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+set(PROJECT_WARNING_FLAGS
+    -Wall
+    -Wextra
+    -Wpedantic
+    -Wshadow
+    -Wnon-virtual-dtor
+    -Wold-style-cast
+    -Wcast-align
+    -Wunused
+    -Woverloaded-virtual
+    -Wconversion
+    -Wsign-conversion
+    -Wnull-dereference
+    -Wdouble-promotion
+    -Wformat=2
+    -Wimplicit-fallthrough
+)
+
+option(WERROR "Treat compiler warnings as errors" OFF)
+if(WERROR)
+    list(APPEND PROJECT_WARNING_FLAGS -Werror)
+endif()
 
 option(ENABLE_APP_TESTS "Enable unit testing for app module" OFF)
 if(ENABLE_APP_TESTS)
@@ -67,8 +93,16 @@ FetchContent_Declare(
     GIT_TAG        ${VIDEOCAPTURE_VERSION}  # Use specific version instead of master
 )
 
-# Disable neuriplo's tests so it doesn't require GTest
+# Disable subproject tests and sample apps when fetched as dependencies.
 set(BUILD_INFERENCE_ENGINE_TESTS OFF CACHE BOOL "" FORCE)
+set(BUILD_TESTS OFF CACHE BOOL "" FORCE)
+
+# Prefer a sibling checkout during local cross-repo development.
+set(_VISION_CORE_SIBLING "${CMAKE_CURRENT_SOURCE_DIR}/../vision-core")
+if(EXISTS "${_VISION_CORE_SIBLING}/CMakeLists.txt")
+    set(FETCHCONTENT_SOURCE_DIR_VISION-CORE "${_VISION_CORE_SIBLING}" CACHE PATH "" FORCE)
+endif()
+
 FetchContent_MakeAvailable(neuriplo VideoCapture vision-core)
 message(STATUS "vision-core_SOURCE_DIR: ${vision-core_SOURCE_DIR}")
 message(STATUS "neuriplo_SOURCE_DIR: ${neuriplo_SOURCE_DIR}")

app/CMakeLists.txt

@@ -1,20 +1,4 @@
-# Fetch the VideoCapture project from GitHub with specific version
-include(FetchContent)
-FetchContent_Declare(
-    VideoCapture
-    GIT_REPOSITORY https://github.com/olibartfast/VideoCapture.git
-    GIT_TAG        ${VIDEOCAPTURE_VERSION}  
-)
-# Pass video backend options to VideoCapture library
-set(USE_GSTREAMER ${USE_GSTREAMER})
-set(USE_FFMPEG ${USE_FFMPEG})
-FetchContent_MakeAvailable(VideoCapture)
-message(STATUS "VideoCapture_SOURCE_DIR: ${VideoCapture_SOURCE_DIR}")
-message(STATUS "CMAKE_CURRENT_SOURCE_DIR:  ${CMAKE_CURRENT_SOURCE_DIR}")
-
-# Define sources using CMAKE_CURRENT_SOURCE_DIR instead of CMAKE_SOURCE_DIR
-set(SOURCES
-    ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp
+set(APP_LIB_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/src/VisionApp.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/InferencePipeline.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/CLICommands.cpp
@@ -23,13 +7,10 @@ set(SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/src/utils.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/CommandLineParser.cpp
 )
-add_executable(${PROJECT_NAME} ${SOURCES})
-include(${CMAKE_SOURCE_DIR}/cmake/Sanitizers.cmake)
-enable_target_sanitizers(${PROJECT_NAME})
 
+add_library(vision-inference-app STATIC ${APP_LIB_SOURCES})
 
-# Set include directories
-target_include_directories(${PROJECT_NAME} PRIVATE
+target_include_directories(vision-inference-app PUBLIC
     ${CMAKE_CURRENT_SOURCE_DIR}/inc
     ${CMAKE_CURRENT_SOURCE_DIR}/src
     ${VideoCapture_SOURCE_DIR}/include
@@ -40,15 +21,37 @@ target_include_directories(${PROJECT_NAME} PRIVATE
     ${GLOG_INCLUDE_DIRS}
 )
 
-# Link libraries
-target_link_libraries(${PROJECT_NAME} PRIVATE
+target_link_libraries(vision-inference-app PUBLIC
     glog::glog
     ${OpenCV_LIBS}
     neuriplo
     VideoCapture
     vision-core
 )
 
+if(MSVC)
+    target_compile_options(vision-inference-app PRIVATE /W4)
+else()
+    target_compile_options(vision-inference-app PRIVATE ${PROJECT_WARNING_FLAGS})
+endif()
+
+add_executable(${PROJECT_NAME} ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp)
+include(${CMAKE_SOURCE_DIR}/cmake/Sanitizers.cmake)
+enable_target_sanitizers(${PROJECT_NAME})
+
+target_include_directories(${PROJECT_NAME} PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/inc
+    ${CMAKE_CURRENT_SOURCE_DIR}/src
+)
+
+target_link_libraries(${PROJECT_NAME} PRIVATE vision-inference-app)
+
+if(MSVC)
+    target_compile_options(${PROJECT_NAME} PRIVATE /W4)
+else()
+    target_compile_options(${PROJECT_NAME} PRIVATE ${PROJECT_WARNING_FLAGS})
+endif()
+
 include(${CMAKE_SOURCE_DIR}/cmake/LinkBackend.cmake)
 
 if(ENABLE_APP_TESTS)

app/inc/CommandLineParser.hpp

@@ -3,10 +3,10 @@
 
 class CommandLineParser {
 public:
-    static AppConfig parseCommandLineArguments(int argc, char *argv[]);
+  static AppConfig parseCommandLineArguments(int argc, char *argv[]);
 
 private:
-    static const std::string params;
-    static void printHelpMessage(const cv::CommandLineParser& parser);
-    static void validateArguments(const cv::CommandLineParser& parser);
+  static const std::string params;
+  static void printHelpMessage(const cv::CommandLineParser &parser);
+  static void validateArguments(const cv::CommandLineParser &parser);
 };

app/inc/VisionApp.hpp

@@ -6,7 +6,7 @@
 
 class VisionApp {
 public:
-  explicit VisionApp(const AppConfig &config);
+  explicit VisionApp(const AppConfig &app_config);
   int run();
 
 private:

app/inc/utils.hpp

@@ -2,15 +2,16 @@
 #include <opencv2/opencv.hpp>
 #include <string>
 
-bool isDirectory(const std::string& path);
-bool isFile(const std::string& path);
-void draw_label(cv::Mat& input_image, const std::string& label, float confidence, int left, int top);
-std::vector<std::string> readLabelNames(const std::string& fileName);
-std::string getFileExtension(const std::string& filename);
+bool isDirectory(const std::string &path);
+bool isFile(const std::string &path);
+void draw_label(cv::Mat &input_image, const std::string &label,
+                float confidence, int left, int top);
+std::vector<std::string> readLabelNames(const std::string &fileName);
+std::string getFileExtension(const std::string &filename);
 std::string getGPUModel();
 std::vector<std::string> getGPUModels();
 std::string getCPUInfo();
 bool hasNvidiaGPU();
-std::vector<std::string> split(const std::string& s, char delimiter);
-std::vector<std::vector<int64_t>> parseInputSizes(const std::string& input);
-std::string normalizeModelType(const std::string& model_type);
+std::vector<std::string> split(const std::string &s, char delimiter);
+std::vector<std::vector<int64_t>> parseInputSizes(const std::string &input);
+std::string normalizeModelType(const std::string &model_type);

app/src/CLICommands.cpp

@@ -1,6 +1,7 @@
 #include "CLICommands.hpp"
 
 #include "VideoCaptureFactory.hpp"
+#include "vision-core/core/opencv_interop.hpp"
 
 #include <chrono>
 #include <filesystem>
@@ -115,15 +116,15 @@ void processVideo(InferencePipeline &pipeline, const std::string &source) {
     auto duration =
         std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
             .count();
-    double fps = 1000.0 / duration;
+    double fps = 1000.0 / static_cast<double>(duration);
     std::string fpsText = "FPS: " + std::to_string(fps);
     cv::putText(frame, fpsText, cv::Point(10, 30), cv::FONT_HERSHEY_SIMPLEX, 1,
                 cv::Scalar(0, 255, 0), 2);
 
     pipeline.renderResults(results, frame);
 
     cv::imshow("opencv feed", frame);
-    char key = cv::waitKey(1);
+    const int key = cv::waitKey(1);
     if (key == 27 || key == 'q') {
       LOG(INFO) << "Exit requested";
       break;
@@ -148,7 +149,7 @@ void processVideoClassification(InferencePipeline &pipeline,
 
   cv::Mat frame;
   std::vector<cv::Mat> frameBuffer;
-  frameBuffer.reserve(requiredFrames);
+  frameBuffer.reserve(static_cast<size_t>(requiredFrames));
 
   while (videoInterface->readFrame(frame)) {
     frameBuffer.push_back(frame.clone());
@@ -165,7 +166,7 @@ void processVideoClassification(InferencePipeline &pipeline,
       auto duration =
           std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
               .count();
-      double fps = 1000.0 / duration;
+      double fps = 1000.0 / static_cast<double>(duration);
       std::string fpsText = "FPS: " + std::to_string(fps);
 
       cv::Mat displayFrame = frameBuffer.back().clone();
@@ -178,7 +179,7 @@ void processVideoClassification(InferencePipeline &pipeline,
       frameBuffer.erase(frameBuffer.begin());
     }
 
-    char key = cv::waitKey(1);
+    const int key = cv::waitKey(1);
     if (key == 27 || key == 'q') {
       LOG(INFO) << "Exit requested";
       break;
@@ -229,7 +230,7 @@ void processOpticalFlow(InferencePipeline &pipeline) {
       if (std::holds_alternative<vision_core::OpticalFlow>(prediction)) {
         vision_core::OpticalFlow flow =
             std::get<vision_core::OpticalFlow>(prediction);
-        flow.flow.copyTo(image);
+        vision_core::toCvMat(flow.flow).copyTo(image);
       }
     }
 
@@ -358,9 +359,10 @@ int BenchmarkCommand::execute(InferencePipeline &pipeline) {
         std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
             .count();
     LOG(INFO) << "Iteration " << i << ": " << duration << "ms";
-    total_time += duration;
+    total_time += static_cast<double>(duration);
   }
-  double average_time = total_time / pipeline.config.benchmark_iterations;
+  double average_time =
+      total_time / static_cast<double>(pipeline.config.benchmark_iterations);
   LOG(INFO) << "Average inference time over "
             << pipeline.config.benchmark_iterations
             << " iterations: " << average_time << "ms";

app/src/InferencePipeline.cpp

@@ -178,9 +178,9 @@ void InferencePipelineBuilder::setupBackend(InferencePipeline &pipeline) const {
   LOG(INFO) << "CPU info " << getCPUInfo();
   LOG(INFO) << "GPU info: " << getGPUModel();
   const auto use_gpu = config_.use_gpu && hasNvidiaGPU();
-  pipeline.engine =
-      setup_inference_engine(buildEngineWeights(config_), use_gpu,
-                             config_.batch_size, config_.input_sizes);
+  pipeline.engine = setup_inference_engine(
+      buildEngineWeights(config_), use_gpu,
+      static_cast<size_t>(config_.batch_size), config_.input_sizes);
   if (!pipeline.engine) {
     throw std::runtime_error("Can't setup an inference engine for " +
                              config_.weights);