环境

• 操作系统: Windows 11
• GLFW 版本: 3.4，该功能不用
• Boost 版本: 1.81.0，该功能不用
• GCC 版本: Qt5.14.2_mingw730_64_gcc
• CMake 版本: 3.26.3
• VScode 版本: 1.110.0

项目概述

一个基于 C++14 + CMake 3.15 的跨平台计算机视觉应用，集成 OpenCV库、Boost库、GLFW库三大库。编译器使用 Qt5.14.2 中的 MinGW 7.3.0 x86_64。

workspace目录树

template_opencv/
├── CMakeLists.txt          # 根构建脚本（项目入口）
├── main.cpp                # 程序入口 main()
│
├── inc/                    # 公共头文件
│   ├── add.hpp             #   addFun() 声明
│   ├── hello.hpp           #   helloFun() 声明
│   └── pic_capture.hpp     #   视频采集 + 人脸检测函数声明
│
├── src/                    # 源文件 + 子构建脚本
│   ├── CMakeLists.txt      #   lib 库构建（静态/动态）
│   ├── add.cpp             #   addFun() 实现
│   ├── hello.cpp           #   helloFun() 实现
│   └── pic_capture.cpp     #   摄像头采集、人脸检测实现
│
├── lib/                    # 输出库 + 第三方 .dll
│   ├── libir_distance_measure_dynamic.dll
│   └── libir_distance_measure_dynamic.dll.a
│
├── bin/                    # 可执行文件输出（自动生成）
│   └── result.exe
│
├── build/                  # CMake 构建产物/中间文件
│   ├── CMakeCache.txt
│   ├── Makefile
│   ├── compile_commands.json
│   └── ... (CMakeFiles, 中间目标文件等)
│
└── .vscode/                # IDE 配置
    ├── settings.json       #   CMake 工具链配置
    ├── tasks.json          #   构建任务（cmake → make）
    └── launch.json         #   GDB 调试启动配置

模块分层

┌─────────────────────────────────────────┐
│              main.cpp 入口              │
│  face_detect_demo() / pic_capture() 等  │
└──────────────┬──────────────────────────┘
               │ 调用
    ┌──────────▼──────────┐
    │  inc/ 公共头文件     │
    │  add / hello /      │
    │  pic_capture        │
    └──────────┬──────────┘
               │ 实现
    ┌──────────▼──────────┐
    │  src/ 源文件        │
    │  add.cpp            │
    │  hello.cpp          │
    │  pic_capture.cpp    │
    └──────────┬──────────┘
               │ CMake 构建
    ┌──────────▼──────────────────────────┐
    │  src/CMakeLists.txt                 │
    │  ├─ BUILD_UTILS_AS_SHARED=ON        │
    │  │   → ir_distance_measure_dynamic  │
    │  └─ BUILD_UTILS_AS_SHARED=OFF(默认) │
    │      → ir_distance_measure_static   │
    └──────────┬──────────────────────────┘
               │ link
    ┌──────────▼──────────┐
    │   bin/result.exe    │  ← 最终可执行文件
    └─────────────────────┘

构建流程

.vscode/tasks.json  "Build" 任务
        │
        ├─(1)─ "cmake"  ──→  cmake ..  (在 build/ 中配置)
        │     读取根 CMakeLists.txt → 含子目录 src/
        │     查找 OpenCV / Boost / GLFW
        │
        └─(2)─ "make"  ──→  mingw32-make (编译+链接)
               │
               ├─ src/ → libir_distance_measure_static.a (或 .dll)
               └─ main.cpp → bin/result.exe
                      │ (POST_BUILD)
                      └─ 复制 libopencv_world*.dll 到 bin/

第三方依赖

库	版本	路径	用途
OpenCV	4.11.0	C:/software/opencv-4.11.0-mingw73/	图像采集、人脸检测 (CascadeClassifier)
Boost	1.81.0	C:/software/boost_1_81_0/	math_c99, thread, system
GLFW	3.4	C:/software/GLFW/	窗口创建（当前未在 main 中使用）
MinGW	7.3.0	C:/software/Qt5.14.2/Tools/mingw730_64/	编译器 + GDB 调试

注：测试功能未用到boost库、GLFW库。

关键配置说明

• BUILD_UTILS_AS_SHARED（CMake option）：控制库编译为动态库还是静态库，默认 OFF（静态）
• EXECUTABLE_OUTPUT_PATH：可执行文件输出至 ${PROJECT_SOURCE_DIR}/bin
• LIBRARY_OUTPUT_PATH：库文件输出至 ${PROJECT_SOURCE_DIR}/lib
• VSCode 调试：入口 bin/result.exe，使用 gdb.exe 调试器
• POST_BUILD 钩子：构建后自动将 OpenCV DLL 复制到 bin/，确保运行时能找到动态库

源码

cmake_minimum_required(VERSION 3.15)

project(Hex2DEC)

set(CMAKE_CXX_STANDARD 14)

option(BUILD_UTILS_AS_SHARED "Build utils as shared library" OFF)

set(OpenCV_DIR "C:/software/opencv-4.11.0-mingw73/x64/mingw/lib")
find_package(OpenCV REQUIRED)
if (OpenCV_FOUND)
    message(STATUS "OpenCV library status:")
    message(STATUS "    OpenCV version: ${OpenCV_VERSION}")
    message(STATUS "    OpenCV_INCLUDE_DIRS: ${OpenCV_INCLUDE_DIRS}")
    message(STATUS "    OpenCV_LIBRARIES: ${OpenCV_LIBS}")
else ()
    message(FATAL_ERROR "Could not find OpenCV")
endif ()

# 设置Boost库的根目录（应指吿 Boost 的安装根目录)
set(BOOST_ROOT "C:/software/boost_1_81_0")
#设置不适用系统的的boost的库
set(BOOST_NO_SYSTEM_PATHS ON)
# 设置使用静态的boost庿
set(Boost_USE_STATIC_LIBS ON)
# 指定库架构为x64
set(Boost_ARCHITECTURE "-x64")    

if(POLICY CMP0144 OR POLICY CMP0144)
  cmake_policy(SET CMP0144 NEW)
  cmake_policy(SET CMP0167 NEW)
endif()

find_package(Boost COMPONENTS math_c99 thread system REQUIRED)

include_directories(${Boost_INCLUDE_DIRS})    # 包含Boost库的头文件目录

#如果已经找到
if(Boost_FOUND)
    message(STATUS "Boost library status:")
    message(STATUS "    Boost version: ${Boost_VERSION}")
    message(STATUS "    Boost_INCLUDE_DIRS: ${Boost_INCLUDE_DIRS}")
    message(STATUS "    Boost_LIBRARIES: ${Boost_LIBRARIES}")
    message(STATUS "    Boost_INCLUDE_DIRS: ${Boost_INCLUDE_DIRS}")
else ()
    message(FATAL_ERROR "Could not find Boost")
endif ()

# 查找GLFW库
# 如果找不到系统安装的GLFW，可以使用以下方式手动指定路径
set(glfw3_DIR "C:/software/GLFW/lib/cmake/glfw3")
set(GLFW_INCLUDE_DIRS "C:/software/GLFW/include")
set(GLFW_LIBRARIES "C:/software/GLFW/lib/libglfw3.a")
find_package(glfw3 3.4 REQUIRED)
if(glfw3_FOUND)
    message(STATUS "glfw3 library status:")
    message(STATUS "    glfw3 version: ${glfw3_VERSION}")
    message(STATUS "    glfw3 INCLUDE_DIRS: ${GLFW_INCLUDE_DIRS}")
    message(STATUS "    glfw3 LIBRARIES: ${GLFW_LIBRARIES}")
else ()
    message(FATAL_ERROR "Could not find glfw3")
endif ()

# 根目录/代码路径
aux_source_directory(. DIR_MAIN)
  
#将可执行文件输出到文件夹bin
set(EXECUTABLE_OUTPUT_PATH  ${PROJECT_SOURCE_DIR}/bin)

# 设置安装库文件和头文件的路径
set(CMAKE_INSTALL_INCLUDEDIR ${PROJECT_SOURCE_DIR}/build/install)

# 包含头文件所在目彿
include_directories("${PROJECT_SOURCE_DIR}/inc"
                     ${OpenCV_INCLUDE_DIRS}
                     ${Boost_INCLUDE_DIRS}
                     ${GLFW_INCLUDE_DIRS}
                      )

# 包含源文件所在目彿
add_subdirectory(src)

# 链接hellolib库，注意下面子目录src的CMakeLists
link_directories("${PROJECT_SOURCE_DIR}/lib"
                  ${OpenCV_LIBRARIES}
                  ${Boost_LIBRARIES}
                  ${GLFW_LIBRARIES}
                  )

add_executable(result main.cpp)

if(BUILD_UTILS_AS_SHARED)
    target_link_libraries(result
                          ir_distance_measure_dynamic
                          ${OpenCV_LIBS}
                          ${Boost_LIBRARIES}
                          )

else()
    target_link_libraries(result
                          ir_distance_measure_static
                          ${OpenCV_LIBS}
                          ${Boost_LIBRARIES}
                          )
endif()

if(TARGET ir_distance_measure_dynamic)
    install(TARGETS ir_distance_measure_dynamic DESTINATION ${EXECUTABLE_OUTPUT_PATH})
endif()

if(TARGET ir_distance_measure_static)
    install(TARGETS ir_distance_measure_static DESTINATION ${EXECUTABLE_OUTPUT_PATH})
endif()

# 构建后自动将 OpenCV DLL 复制到可执行文件所在目录 (bin/)
add_custom_command(TARGET result POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${OpenCV_DIR}/../bin/libopencv_world4120.dll"
        $<TARGET_FILE_DIR:result>
    COMMENT "Copying OpenCV DLL to binary directory"
)

cmake_minimum_required(VERSION 3.15)

# generate lib
SET(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib)

aux_source_directory(. DIR_SRC)

if(BUILD_UTILS_AS_SHARED)
    add_library(ir_distance_measure_dynamic SHARED ${DIR_SRC})
    target_link_libraries(ir_distance_measure_dynamic ${Boost_LIBRARIES} ${OpenCV_LIBS})
    target_include_directories(ir_distance_measure_dynamic PUBLIC
                                ${PROJECT_SOURCE_DIR}/inc
                                ${OpenCV_INCLUDE_DIRS}
                                ${Boost_INCLUDE_DIRS}
                                )

    # 设置动态库版本
    set_target_properties(ir_distance_measure_dynamic PROPERTIES
                          VERSION 1.2.3
                          SOVERSION 1
                         )
else()
    add_library(ir_distance_measure_static STATIC ${DIR_SRC})
    target_include_directories(ir_distance_measure_static PUBLIC ${PROJECT_SOURCE_DIR}/inc)
endif()

# make install头文件
install(DIRECTORY ${PROJECT_SOURCE_DIR}/inc/
        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/inc
)

# make install库文件
install(DIRECTORY ${LIBRARY_OUTPUT_PATH}
        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
)

源文件

#include "pic_capture.hpp"
#include "GLFW/glfw3.h"

int main(){
    face_detect_demo();
    return 0;    
}

#include "pic_capture.hpp"

void rectangle_generate(cv::Mat _frame, int x, int y, int length, int height){
    cv::rectangle(_frame,
                  cv::Point(x-length/2, y-height/2),
                  cv::Point(x+length/2, y+height/2),
                  cv::Scalar(0, 255, 0),
                  2); // 绿色矩形框
                  
    // cv::putText(_frame,
    //             "Hello OpenCV",
    //             cv::Point(50, 50),
    //             cv::FONT_HERSHEY_SIMPLEX,
    //             1,
    //             cv::Scalar(0, 0, 255),
    //             2);                         // 文本信息
}

int pic_capture() {
    std::cout << "Running video_processing demo..." << std::endl;

    cv::VideoCapture cap(0, cv::CAP_ANY);

    if (!cap.isOpened()) {
        std::cerr << "Error: Could not open camera." << std::endl;
        return 0;
    }

    cap.set(cv::CAP_PROP_FRAME_WIDTH, 1280);
    cap.set(cv::CAP_PROP_FRAME_HEIGHT, 720);
    cap.set(cv::CAP_PROP_FPS, 50);

    cv::namedWindow("Live", cv::WINDOW_NORMAL);
    cv::resizeWindow("Live", 1280, 720);

    cv::Mat frame;

    while (true) {
        if (!cap.read(frame)) break;
        
        if (frame.empty()) continue;

        // 在帧上绘制矩形图框
        rectangle_generate(frame, 1280/2, 720/2, 50, 100);
        rectangle_generate(frame, 650, 300, 100, 100);
        rectangle_generate(frame, 500, 300, 100, 100);
        cv::imshow("Live", frame);

        if (cv::waitKey(1) == 27) break;

    }

    cap.release();
    cv::destroyAllWindows();
    return 0;
}

void face_detect_demo(){
    // 加载人脸检测器模型
    cv::CascadeClassifier face_cascade;

    if(!face_cascade.load("C:/software/opencv-4.11.0-mingw73/etc/haarcascades/haarcascade_frontalface_alt.xml")){
        std::cerr << "Error loading face cascade model!" << std::endl;
        return;
    }
    // 在这里添加进行人脸检测的代码
    // 例如，可以在摄像头捕获的每一帧上运行人脸检测
    std::cout << "Running video_processing demo..." << std::endl;

    cv::VideoCapture cap(0, cv::CAP_ANY);
    if (!cap.isOpened()){
        std::cerr << "Error: Could not open camera." << std::endl;
    }

    cap.set(cv::CAP_PROP_FRAME_WIDTH, 1280);
    cap.set(cv::CAP_PROP_FRAME_HEIGHT, 720);
    cap.set(cv::CAP_PROP_FPS, 50);

    cv::namedWindow("Face Detection Demo", cv::WINDOW_NORMAL);
    cv::resizeWindow("Face Detection Demo", 1280, 720);

    cv::Mat frame;

    while (cap.read(frame)){
        // 转换图像为灰度图
        cv::Mat gray;
        cv::cvtColor(frame, gray, cv::COLOR_BGR2GRAY);
        // cv::imshow("gray Demo", gray);
        cv::equalizeHist(gray, gray);  // 直方图均衡化提高对比度
        // cv::imshow("equalizeHist gray Demo", gray);
        //进行双边滤波
        cv::Mat dst;
        cv::bilateralFilter(gray, dst, 20, 150, 150);
        // 进行人脸检测
        std::vector<cv::Rect> faces;
        face_cascade.detectMultiScale(dst, faces, 1.1, 3, 0, cv::Size(30, 30));
        // 在图像上标记检测到的人脸
        for (const auto& face : faces){
            cv::rectangle(frame, face, cv::Scalar(0, 255, 0), 2);  // 用蓝色矩形标记人脸
        }
        // 显示结果
        cv::imshow("Face Detection Demo", frame);
        // 检测按键，按下ESC键退出循环
        if (cv::waitKey(30) == 27){
            break;
        }
    }
    cap.release();  // 释放摄像头
    cv::destroyAllWindows();  // 销毁所有窗口
}

#ifndef _PIC_CAPTURE_H
#define _PIC_CAPTURE_H

#include <iostream>
#include <opencv2/opencv.hpp>

void rectangle_generate(cv::Mat _frame, int x, int y, int length, int height);
int pic_capture();
void face_detect_demo();

#endif

配置文件

{
	// 使用 IntelliSense 了解相关属性。
	// 悬停以查看现有属性的描述。
	// 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "(gdb) Launch",
            "type": "cppdbg",
            "request": "launch",
            "program": "${workspaceFolder}/bin/result.exe",  // 待调试的程序目录
            "args": [],  // 程序输入参数
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "miDebuggerPath": "C:/software/Qt5.14.2/Tools/mingw730_64/bin/gdb.exe",  // gdb.exe 目录
            "setupCommands": [
                {
                    "description": "Enable pretty-printing for gdb",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                },
                {
                    "description": "Set Disassembly Flavor to Intel",
                    "text": "-gdb-set disassembly-flavor intel",
                    "ignoreFailures": true
                }
            ]
        }
    ]
}

{
    "cmake.configureOnOpen": true,
    // "cmake.cmakePath": "C:/software/mingw64/bin/cmake.exe",
    // "cmake.additionalCompilerSearchDirs": ["C:/software/mingw64/bin"],
    "cmake.cmakePath": "C:/software/CMake/bin/cmake.exe",
    "cmake.additionalCompilerSearchDirs": ["C:/software/Qt5.14.2/Tools/mingw730_64/bin"],
    "cmake.generator": "MinGW Makefiles",
    "files.associations": {
        "iomanip": "cpp",
        "limits": "cpp",
        "chrono": "cpp",
        "array": "cpp",
        "atomic": "cpp",
        "strstream": "cpp",
        "bitset": "cpp",
        "cctype": "cpp",
        "cfenv": "cpp",
        "clocale": "cpp",
        "cmath": "cpp",
        "complex": "cpp",
        "condition_variable": "cpp",
        "cstdarg": "cpp",
        "cstddef": "cpp",
        "cstdint": "cpp",
        "cstdio": "cpp",
        "cstdlib": "cpp",
        "cstring": "cpp",
        "ctime": "cpp",
        "cwchar": "cpp",
        "cwctype": "cpp",
        "deque": "cpp",
        "list": "cpp",
        "unordered_map": "cpp",
        "vector": "cpp",
        "exception": "cpp",
        "algorithm": "cpp",
        "functional": "cpp",
        "iterator": "cpp",
        "map": "cpp",
        "memory": "cpp",
        "memory_resource": "cpp",
        "optional": "cpp",
        "ratio": "cpp",
        "set": "cpp",
        "source_location": "cpp",
        "string": "cpp",
        "string_view": "cpp",
        "system_error": "cpp",
        "tuple": "cpp",
        "type_traits": "cpp",
        "utility": "cpp",
        "fstream": "cpp",
        "initializer_list": "cpp",
        "iosfwd": "cpp",
        "iostream": "cpp",
        "istream": "cpp",
        "mutex": "cpp",
        "new": "cpp",
        "ostream": "cpp",
        "sstream": "cpp",
        "stdexcept": "cpp",
        "streambuf": "cpp",
        "thread": "cpp",
        "cinttypes": "cpp",
        "typeindex": "cpp",
        "typeinfo": "cpp",
        "variant": "cpp"
    }
}

{
    // See https://go.microsoft.com/fwlink/?LinkId=733558
    // for the documentation about the tasks.json format
    "version": "2.0.0",
    "options": {
        "cwd":"${workspaceFolder}/build"
    },
    "tasks": [
        {
            "label": "cmake",
            "type": "shell",
            "command": "cmake",
            "args":[
                ".."
            ]
        },
        {
            "label":"make",
            "group":{
                "kind": "build",
                "isDefault": true
            },
            "command":"make",
            "args": [
            ]
        },
        {
            "label":"Build",
            "dependsOrder": "sequence",
            "dependsOn":[
                "cmake",
                "make"
            ]
        }
    ]
}

编译步骤

根据情况配置编译器：ctrl+shift+p，选Cmake:Configure，选择GBD。
cmake与make参考：

• 打开终端，进入workspace根目录。
• 进行如下操作：

cd build

// 生成动态库
cmake -DBUILD_UTILS_AS_SHARED=ON ..
或者
// 生成静态库
cmake -DBUILD_UTILS_AS_SHARED=OFF ..

mingw32-make

mingw32-make install

..\bin\result.exe

源码连接

源码链接
GLFW库
opencv-4.11.0-mingw73库
boost库