Conan是一个C++的包管理器，它可以用来管理项目所需的依赖项。CMake是一个跨平台的构建系统，它可以用来生成项目的构建脚本，如Makefile或Visual Studio项目文件。





要使用Conan和CMake来构建一个项目，您需要以下步骤：

安装Conan和CMake。

在您的项目目录中创建一个Conan文件，用于定义项目的依赖项。

使用Conan安装项目的依赖项。

创建一个CMake文件，用于描述您的项目，并且使用Conan来查找项目的依赖项。

使用CMake来构建项目。

下面是一个简单的例子，展示了如何使用Conan和CMake来构建一个项目。

首先，我们需要在项目目录中创建一个Conan文件，用于定义项目的依赖项。例如，如果我们的项目依赖于Boost库，我们可以创建一个名为conanfile.txt的文件，内容如下：

```python
[requires]
Boost/1.71.0@conan/stable
[generators]
cmake
```

这个Conan文件定义了项目的两个部分：requires和generators。

requires部分定义了项目所需的依赖项，在这个例子中，我们定义了一个Boost库的依赖

当然，您可以在Conan文件中定义更多的依赖项，如果您的项目依赖于多个库。

接下来，我们需要使用Conan安装项目的依赖项。要这么做，请运行以下命令：

```python
conan install .
```

这个命令会安装Conan文件中定义的所有依赖项，并且会生成一个CMake配置文件，用于查找安装的依赖项。

接下来，我们需要创建一个CMake文件，用于描述项目的构建。例如，如果我们的项目目录结构如下：

```python
myproject/
├── src/
│   ├── main.cpp
│   └── other_source_files.cpp
├── include/
│   └── header_files.hpp
└── CMakeLists.txt
```

我们可以创建一个名为CMakeLists.txt的文件，内容如下：

```python
cmake_minimum_required(VERSION 3.0)
project(myproject)
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
conan_basic_setup()
add_executable(myproject
    src/main.cpp
    src/other_source_files.cpp
)
target_include_directories(myproject
    PRIVATE
    include
)
target_link_libraries(myproject
    ${CONAN_LIBS}
)
```

这个CMake文件定义了一个名为myproject的项目，并且包含了来自Conan的配置文件，以便查找安装的依赖项。然后，它创建了一个名为myproject的可执行文件，包含了所有的源文件。最后，它定义了包含文件的路径，并且添加了链接库，这些链接库来自Conan文件中定义的依赖项。

最后，我们可以使用CMake来构建项目。要这么做，请运行以下命令：

```python
cmake -B build
cmake --build build
```

这个命令会创建一个名为build的目录，并且在该目录中生成构建脚本。然后，它会使用这些脚本来构建项目。

综上所述，Conan和CMake可以配合使用来管理项目的依赖项，并且构建项目。如果您需要了解更多信息，请参阅Conan和CMake的官方文档。


conan_basic_setup()是一个CMake函数，它可以用来加载Conan生成的配置文件，并且设置一些基本的CMake变量，以便查找安装的依赖项。

首先，它会加载Conan生成的配置文件，该文件包含了关于安装的依赖项的信息，例如库文件的路径和链接选项。例如，如果我们的项目依赖于Boost库，Conan会生成一个名为conanbuildinfo.cmake的文件，内容如下：

```python
set(CONAN_INCLUDE_DIRS "/path/to/boost/include")
set(CONAN_LIBS "-L/path/to/boost/lib -lboost_system")
```

这个文件定义了两个变量：CONAN_INCLUDE_DIRS和CONAN_LIBS。CONAN_INCLUDE_DIRS包含了依赖项的头文件目录，而CONAN_LIBS包含了依赖项的链接选项。

接下来，conan_basic_setup()函数会设置一些基本的CMake变量，用于查找安装的依赖项。例如，它会设置CMAKE_INCLUDE_PATH和CMAKE_LIBRARY_PATH变量，以便查找头文件和库文件。

最后，conan_basic_setup()函数会调用conan_define_targets()函数，用于定义CMake的目标，这些目标对应于Conan文件中定义的依赖项。例如，如果我们的项目依赖于Boost库，conan_basic_setup()函数会定义一个名为Boost的目标，用于指定Boost库的链接选项。我们可以在项目中使用这个目标来链接Boost库，例如：

```python
target_link_libraries(myproject
    Boost
)
```

这样，我们就可以使用conan_basic_setup()函数来加载Conan生成的配置文件，并且查找安装的依赖项。

总之，conan_basic_setup()函数是一个非常方便的工具，可以用来管理项目的依赖项，并且构建项目。如果您需要了解更多信息，请参阅Conan的官方文档。

conan Cmake构建项目

安装：





```
sudo apt-get install libjsoncpp-dev
```


头文件在：

```
/usr/include/jsoncpp/json
```

动态库在：

```
/usr/lib/x86_64-linux-gnu/libjsoncpp.so.1.7.2
```

cmake写法：

```
include_directories(/usr/include/jsoncpp)
# 将库文件链接到可执行程序上 /usr/lib/x86_64-linux-gnu/libjsoncpp.so
target_link_libraries( backfill  ${OpenCV_LIBS} /usr/lib/x86_64-linux-gnu/libjsoncpp.so.1.7.4)
```

Ubuntu 安装使用jsoncpp，Cmake

需求就是把opencv-python编译成whl包，能让opencv支持freetype utf-8字符显示：





[https://github.com/opencv/opencv-python/tree/3.4](https://github.com/opencv/opencv-python/tree/3.4)


参考的大佬博客，但是得自己改一些东西，后面细说：

[https://yinguobing.com/build-opencv-python-package-with-freetype-support/](https://yinguobing.com/build-opencv-python-package-with-freetype-support/)


基础环境参照官网安装：

[https://docs.opencv.org/4.x/d2/de6/tutorial_py_setup_in_ubuntu.html](https://docs.opencv.org/4.x/d2/de6/tutorial_py_setup_in_ubuntu.html)


过程：


（1）得到代码：

```shell
git clone  --single-branch  -b 3.4 --recursive https://github.com/opencv/opencv-python.git
```

（2）得到支持：

```shell
export CMAKE_ARGS="-DWITH_FREETYPE=ON -DBUILD_opencv_freetype=ON"
export ENABLE_CONTRIB=1
export ENABLE_HEADLESS=0 #可选
```

（3）编译：

想要编译成功需要基础环境，这个python3-numpy，比较棘手，需要加：

```sh
sudo ln -s /home/xd/miniconda3/envs/py37/lib/python3.7/site-packages/numpy/core/include/numpy /usr/include/numpy
```

编译：
```shell
pip3 wheel . --verbose
```

成功画面：

![在这里插入图片描述](/static/img/images/04639.png)


（4）安装：

```shell
python3 -m pip install opencv_contrib_python-3.4.18+1f17655-cp37-cp37m-linux_x86_64.whl
```

（5）使用：

构建支持中文字符的OpenCV Python包 freetype支持得python whl包

# 基本环境





（1）安装WSL；

（2）安装cmake：

```sh
wget https://github.com/Kitware/CMake/releases/download/v3.20.0/cmake-3.20.0-linux-x86_64.tar.gz
tar -xzvf cmake-3.20.0-linux-x86_64.tar.gz
sudo ln -sf $(pwd)/cmake-3.20.0-linux-x86_64/bin/* /usr/bin/
```

(3)安装gcc++：

```sh
# 如果 Ubuntu 版本 < 18.04，需要加入仓库
sudo add-apt-repository ppa:ubuntu-toolchain-r/test
sudo apt-get update
sudo apt-get install gcc
sudo apt-get install g++
```

（4）安装GDB：

```sh
sudo apt install gdb
```

（5）clion建立空工程后选择toolchains如下：

![在这里插入图片描述](/static/img/images/04640.png)

# Ubuntu安装Opencv

## 从源码安装opencv-4.x

依赖：

```sh
sudo apt install build-essential cmake git pkg-config libgtk-3-dev \
    libavcodec-dev libavformat-dev libswscale-dev libv4l-dev \
    libxvidcore-dev libx264-dev libjpeg-dev libpng-dev libtiff-dev \
    gfortran openexr libatlas-base-dev python3-dev python3-numpy \
    libtbb2 libtbb-dev libdc1394-22-dev libopenexr-dev \
    libgstreamer-plugins-base1.0-dev libgstreamer1.0-dev
```

去github下载最新包：[https://github.com/opencv/opencv.git](https://github.com/opencv/opencv.git)

或者去官网下载 一个版本：[https://opencv.org/releases/](https://opencv.org/releases/)


```sh
cd opencv-4.x
mkdir -p build && cd build
cmake -D CMAKE_BUILD_TYPE=RELEASE ..
make -j8
sudo make install 
```

## 从源码安装opencv-3.x

方法同opencv-4.x，但安装路径有区别，得注意。


## 直接pkg包安装

不想编译也ok，直接：
```sh
sudo apt-get install -y libopencv-dev
```

## freetype支持

[https://cloud.tencent.com/developer/article/1353734](https://cloud.tencent.com/developer/article/1353734)

# CLion工程cmake文件写法

```c
# 声明要求的 cmake 最低版本
cmake_minimum_required( VERSION 3.8 )
# 声明一个 cmake 工程
project( cpptest )
# 设置编译模式
set( CMAKE_BUILD_TYPE "Debug"  )
#set(OpenCV_DIR "/usr/local/share/OpenCV")
set(OpenCV_DIR "/usr/local/share/opencv4") # 给一个安装路径
find_package( OpenCV REQUIRED ) # 找包
#添加OpenCV头文件
include_directories(${OpenCV_INCLUDE_DIRS})
message(STATUS "OpenCV_INCLUDE_DIRS: ${OpenCV_INCLUDE_DIRS}")
message(STATUS "OpenCV_LIBS: ${OpenCV_LIBS}")
# 添加一个可执行程序
# 语法：add_executable( 程序名 源代码文件 ）
add_executable( cpptest main.cpp)
# 将库文件链接到可执行程序上
target_link_libraries( cpptest  ${OpenCV_LIBS})
```

# Opencv demo

```c++
#include <iostream>
#include<opencv2/opencv.hpp>//opencv简单程序标配头文件
using namespace cv;//使用cv命名空间
int main()
{
    Mat src=imread("/mnt/c/Users/kevin/Desktop/img.png");//读取图片，要提前将图片放在程序路径下
    imwrite("/mnt/c/Users/kevin/Desktop/img2.jpg",src);//保存结果图片
    return 0;
}
```

![在这里插入图片描述](/static/img/images/04641.png)

# MNN

## mnn文档

[https://mnn-docs.readthedocs.io/en/latest/compile/engine.html](https://mnn-docs.readthedocs.io/en/latest/compile/engine.html)

## 在Ubuntu编译MNN

```sh
sudo apt install protobuf-compiler
# 下载mnn源码后：
cd schema && ./generate.sh
mkdir -p build && cd build
cmake  -DMNN_BUILD_CONVERTER=ON -DCMAKE_BUILD_TYPE=Release ..
make -j8
sudo make install
```

安装成功：

```sh
[100%] Built target OnnxClip
Install the project...
-- Install configuration: "Release"
-- Installing: /usr/local/include/MNN/MNNDefine.h
-- Installing: /usr/local/include/MNN/Interpreter.hpp
-- Installing: /usr/local/include/MNN/HalideRuntime.h
-- Installing: /usr/local/include/MNN/Tensor.hpp
-- Installing: /usr/local/include/MNN/ErrorCode.hpp
-- Installing: /usr/local/include/MNN/ImageProcess.hpp
-- Installing: /usr/local/include/MNN/Matrix.h
-- Installing: /usr/local/include/MNN/Rect.h
-- Installing: /usr/local/include/MNN/MNNForwardType.h
-- Installing: /usr/local/include/MNN/AutoTime.hpp
-- Installing: /usr/local/include/MNN/MNNSharedContext.h
-- Installing: /usr/local/include/MNN/expr/Expr.hpp
-- Installing: /usr/local/include/MNN/expr/ExprCreator.hpp
-- Installing: /usr/local/include/MNN/expr/MathOp.hpp
-- Installing: /usr/local/include/MNN/expr/NeuralNetWorkOp.hpp
-- Installing: /usr/local/include/MNN/expr/Optimizer.hpp
-- Installing: /usr/local/include/MNN/expr/Executor.hpp
-- Installing: /usr/local/include/MNN/expr/Module.hpp
-- Up-to-date: /usr/local/include/MNN/expr/NeuralNetWorkOp.hpp
-- Installing: /usr/local/include/MNN/expr/ExecutorScope.hpp
-- Installing: /usr/local/include/MNN/expr/Scope.hpp
-- Installing: /usr/local/lib/libMNN.so
-- Installing: /usr/local/lib/libMNN_Express.so
-- Set runtime path of "/usr/local/lib/libMNN_Express.so" to ""
```

## CLion中使用

CmakeList.txt:

```c
# 声明要求的 cmake 最低版本
cmake_minimum_required( VERSION 3.8 )
# 声明一个 cmake 工程
project( cpptest )
# 设置编译模式
set( CMAKE_BUILD_TYPE "Debug"  )
set(OpenCV_DIR "/usr/local/share/opencv4") # 给一个安装路径
find_package( OpenCV REQUIRED ) # 找包
if (OpenCV_FOUND)
    # If the package has been found, several variables will
    # be set, you can find the full list with descriptions
    # in the OpenCVConfig.cmake file.
    # Print some message showing some of them
    message(STATUS "OpenCV library status:")
    message(STATUS "    version: ${OpenCV_VERSION}")
    message(STATUS "    include path: ${OpenCV_INCLUDE_DIRS}")
else ()
    message(FATAL_ERROR "Could not locate OpenCV")
endif()
#添加OpenCV头文件
include_directories(${OpenCV_INCLUDE_DIRS})
set(lib_DIR /usr/local/lib)
include_directories(/usr/local/include)
add_library(MNN SHARED IMPORTED)
set_target_properties(
        MNN
        PROPERTIES IMPORTED_LOCATION
        ${lib_DIR}/libMNN.so
)
#include 是头文件 src是c代码
include_directories( ${CMAKE_SOURCE_DIR}/include )
message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}")
aux_source_directory( ${CMAKE_SOURCE_DIR}/src DIR_SRCS)
message(STATUS "DIR_SRCS: ${DIR_SRCS}")
# 添加一个可执行程序
add_executable( cpptest main.cpp ${DIR_SRCS})
# 将库文件链接到可执行程序上
target_link_libraries( cpptest MNN ${OpenCV_LIBS} )
```

main.cpp:

```cpp
#include <iostream>
#include <string>
#include <MNN/Interpreter.hpp>
#include <opencv2/opencv.hpp>
#include <iostream>
#include "Yolo.h"
using namespace MNN;
int main() {
    const char *model_name = "/mnt/d/cpp_ptoject/cpptest/checkpoints/yolov7-tiny416.mnn";
    std::shared_ptr<Interpreter> net(Interpreter::createFromFile(model_name));
    ScheduleConfig config;
    config.type = MNN_FORWARD_AUTO;
    Session *pSession = net->createSession(config);
    Tensor *ptensorInput = net->getSessionInput(pSession, NULL);
    std::vector<int> vctInputDims = ptensorInput->shape();
    printf("输入Tensor的维度为： ");
    for (size_t i = 0; i < vctInputDims.size(); ++i) {
        printf("%d ", vctInputDims[i]);
    }
    printf("\n");
    // opencv 读取数据，resize操作，减均值， 除方差，并且转成nchw
    cv::Mat matImg = cv::imread("/mnt/d/cpp_ptoject/cpptest/doc/bus.jpg", cv::IMREAD_COLOR);
    assert(matImg.data != NULL);
    cv::Mat matFloatImage;
    int MODEL_INPUT_HEIGHT = 416;
    int MODEL_INPUT_WIDTH = 416;
    float r;
    int dw, dh;
    letterbox(matImg,
              matFloatImage,
              MODEL_INPUT_WIDTH,
              MODEL_INPUT_HEIGHT,
              cv::Scalar(114, 114, 114),
              false,
              true,
              32, r, dw, dh);
    cv::cvtColor(matFloatImage, matFloatImage, cv::COLOR_BGR2RGB);
    matFloatImage.convertTo(matFloatImage, CV_32FC3);
    cv::Mat matStd(MODEL_INPUT_HEIGHT, MODEL_INPUT_WIDTH, CV_32FC3, cv::Scalar(255.0f, 255.0f, 255.0f));
    cv::Mat matMean(MODEL_INPUT_HEIGHT, MODEL_INPUT_WIDTH, CV_32FC3, cv::Scalar(0.0f, 0.0f, 0.0f)); // 均值
    cv::Mat matNormImage = (matFloatImage - matMean) / matStd;
    std::vector<std::vector<cv::Mat>> nChannels;
    std::vector<cv::Mat> rgbChannels(3);
    cv::split(matNormImage, rgbChannels);
    nChannels.push_back(rgbChannels); //  NHWC  转NCHW
    void *pvData = malloc(1 * 3 * MODEL_INPUT_HEIGHT * MODEL_INPUT_WIDTH * sizeof(float));
    int nPlaneSize = MODEL_INPUT_HEIGHT * MODEL_INPUT_WIDTH;
    for (int c = 0; c < 3; ++c) {
        cv::Mat matPlane = nChannels[0][c];
        memcpy((float *) (pvData) + c * nPlaneSize, \
             matPlane.data, nPlaneSize * sizeof(float));
    }
    // 将数据拷贝到Tensor中
    auto nchwTensor = new Tensor(ptensorInput, Tensor::CAFFE);
    ::memcpy(nchwTensor->host<float>(), pvData, nPlaneSize * 3 * sizeof(float));
    ptensorInput->copyFromHostTensor(nchwTensor);
    delete nchwTensor;
    // 获取输出Tensor
    Tensor *pTensorOutput = net->getSessionOutput(pSession, NULL);
    // 执行推理
    net->runSession(pSession);
    // 获取输出维度类型
    auto dimType = pTensorOutput->getDimensionType();
    if (pTensorOutput->getType().code != halide_type_float) {
        dimType = Tensor::CAFFE;
    }
    // 创建输出tensor
    std::shared_ptr<Tensor> outputUser(new Tensor(pTensorOutput, dimType));
    MNN_PRINT("output size:%d\n", outputUser->elementSize());
    // 拷贝出去
    pTensorOutput->copyToHostTensor(outputUser.get());
    auto type = outputUser->getType();
    auto size = outputUser->elementSize();
    //100行*7列
    std::vector<std::vector<float>> tempValues;
    if (type.code == halide_type_float) {
        auto values = outputUser->host<float>();
        for (int i = 0; i < size; i += 7) {
            std::vector<float> temp;
            if (values[i + 6] < 0.1) {
                break;
            }
            for (int j = 0; j < 7; j++) {
                temp.push_back(values[i + j]);
            }
            tempValues.push_back(temp);
        }
    }
    drawResultImage(matImg, tempValues, r, dw, dh);
    cv::imwrite("/mnt/d/cpp_ptoject/cpptest/doc/bus_out.jpg", matImg);
    // 释放我们创建的数据内存,这个不是tensor里的
    if (NULL != pvData) {
        free(pvData);
        pvData = NULL;
    }
    std::cout << "finish " << std::endl;
    return 0;
}
```

项目样子：

![在这里插入图片描述](/static/img/images/04642.png)

【WSL】【Opencv】【MNN】【C++】在windows中使用WSL开发C++程序的环境搭建 freetype支持

# 一、debug，release区别





[https://blog.csdn.net/gaoyi221119/article/details/88890486](https://blog.csdn.net/gaoyi221119/article/details/88890486)

Debug：调试版本，包含调试信息，所以容量比Release大很多，并且不进行任何优化（优化会使调试复杂化，因为源代码和生成的指令间关系会更复杂），便于程序员调试。Debug模式下生成两个文件，除了.exe或.dll文件外，还有一个.pdb文件，该文件记录了代码中断点等调试信息

Release：发布版本，不对源代码进行调试，编译时对应用程序的速度进行优化，使得程序在代码大小和运行速度上都是最优的。（调试信息可在单独的PDB文件中生成）。Release模式下生成一个文件.exe或.dll文件

# 二、VC++目录

VC++目录 中，**包含目录**和**库目录**是我们最常用的。

也就是下图的样子：

![在这里插入图片描述](/static/img/images/04725.png)

看看各个部分什么意思：

### 可执行文件目录：

VC++目录的可执行文件目录指的是项目在使用，编译或者调试过程中需要使用的可执行文件路径，并不是DLL的路径。与PATH对应指的则是创建C++工程时，会从PATH环境变量中的值继承到项目的默认设置中。



### 包含目录：

头文件的根搜索目录地址。比如这里写D:\opencv\build\include，程序里写#include <opencv2\opencv.hpp> ，编译器在D:\opencv\build\include中搜索到opencv2\opencv.hpp文件。



### 外部包含目录：

不懂。

### 引用目录：

不懂。

### 库目录

关于静态链接库和动态链接库需要看：[https://www.cnblogs.com/52php/p/5681711.html](https://www.cnblogs.com/52php/p/5681711.html)


lib文件目录。什么是lib文件？

> 使用lib需注意两个文件：

> .h头文件，包含lib中说明输出的类或符号原型或数据结构。应用程序调用lib时，需要将该文件包含入应用程序的源文件中。 

> .LIB文件。

----

> 使用dll需注意三个文件：

> .h头文件，包含dll中说明输出的类或符号原型或数据结构的.h文件。应用程序调用dll时，需要将该文件包含入应用程序的源文件中。

> .LIB文件，是dll在编译、链接成功之后生成的文件，作用是当其他应用程序调用dll时，需要将该文件引入应用程序，否则产生错误（如果不想用lib文件或者没有lib文件，可以用WIN32API函数LoadLibrary、GetProcAddress装载）。

> dll文件，真正的可执行文件，开发成功后的应用程序在发布时，只需要有.exe文件和.dll文件，并不需要.lib文件和.h头文件。



![在这里插入图片描述](/static/img/images/04726.png)

这里介绍得更好：[链接](https://wofead.top/2019/10/31/c++%E5%A4%B4%E6%96%87%E4%BB%B6%E5%BA%93%E6%96%87%E4%BB%B6%E5%92%8C%E5%8A%A8%E6%80%81%E9%93%BE%E6%8E%A5%E5%BA%93%E6%96%87%E4%BB%B6%E4%B9%8B%E9%97%B4%E7%9A%84%E5%85%B3%E7%B3%BB%E5%92%8C%E4%BD%9C%E7%94%A8/)

### Windows运行库目录

不懂。

### 源目录

估计是c++源代码目录。

### 排除目录

不懂。


# C/C++ 常规

这里有个**附加包含目录**，应该和之前介绍的包含目录功能一样。

![在这里插入图片描述](/static/img/images/04727.png)

# 链接器

    常规->附加库目录：寻找.lib文件的搜索目录

    输入->附加依赖项：lib库（C++的库会把函数、类的声明放在*.h中，实现放在*.cpp或*.cc中。编译之后，*.cpp，*.cc，*.c会被打包成一个.lib文件，这样可以保护源代码）


这里很详细：[https://blog.csdn.net/u012043391/article/details/54972127](https://blog.csdn.net/u012043391/article/details/54972127)

【Visual Studio 2020】debug，release，配置属性，名词解释

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。