# 基本环境





（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，配置属性，名词解释

# 1 软件安装





官网链接：[https://visualstudio.microsoft.com/zh-hans/downloads/](https://visualstudio.microsoft.com/zh-hans/downloads/)

我这里使用visual studio 2017 visual_studio_community_2017_version_15.3：链接：[https://pan.baidu.com/s/1ElGtkUqYzzSt37OBoKb9JQ](https://pan.baidu.com/s/1ElGtkUqYzzSt37OBoKb9JQ) 提取码：ev0d 

visual studio 2017 属于网络在线安装方式，选择安装的包：

其实对我而言，C++在桌面开发就够用了，这里没选后面装好软件后还能再装其他的：

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

最常用的就是这样几个包：

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

# 2 解决方案

visual studio 2017的代码组织方式以解决方案来组织，一个解决方案下面可以有多个项目文件。

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

新建项目（需要自己填写项目所属的解决方案名称）：

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

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

添加新的项目到 已有解决方案：

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

一个解决方案里存在2个项目后，文件夹的组织方式：

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

打开解决方案组织文件就是打开这整个：

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

# 3 编译（生成）

C类程序需要编译（Build）后才能运行。visual studio 2017的任务栏里面的生成菜单就是控制编译的。

生成解决方案：对解决方案里每个项目都编译一次，已经编译过的文件就不需要再编译。

重新生成解决方案：对解决方案里每个项目都编译一次，无论哪个文件在之前有没有被编译。

清理解决方案：清除这些编译的中间文件。

同理，对每个项目也可以适用以上的解释。

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

# 4 执行（调试）

对解决方案中的某个项目进行执行。如果项目没有被编译，visual studio 2017会自动编译后再执行。

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

同时，visual studio 2017也支持加断点的调试，双击这个位置即可。

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

使用调试F5，程序执行到断点处暂停。此时这个界面就可以看出visual studio 2017的强大，由上到下，控制、进城号、线程号、断点处、局部变量情况、诊断工具…

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

# 5 视图

窗口布局可以拖动：

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

类视图：

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

给项目里新建类（其实就是多个.h和.cpp文件）：

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

资源视图（MFC里常用）：

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

# 6 工具

修改字体、颜色等。

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

# 7 查找与替换

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

# 8 debug release

Debug通常称为调试版本，通过一系列编译选项的配合，编译的结果通常包含调试信息，而且不做任何优化，以为开发人员提供强大的应用程序调试能力。Debug中可以单步执行、跟踪等功能，但生成的可执行文件比较大，代码运行速度较慢。

Release通常称为发布版本，是为用户使用的，一般客户不允许在发布版本上进行调试。所以不保存调试信息，同时，它往往进行了各种优化，以期达到代码最小和速度最优。为用户的使用提供便利。Release版运行速度较快，可执行文件较小，但在其编译条件下无法执行调试功能。

Release版本的程序是发布时用的版本，首先它优化了代码，去掉了调试符号，因此程序的体积会变小，运行速度也更快。缺点是运行出错难于定位，一般出错程序就会自动关闭。如果是debug版本出错，系统就会有错误的详细信息，如果是在IDE中打开，还能定位到出错的源代码具体在那行。

这里修改：

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

这里可以看到：

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

# 9 dll动态文件库调用

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

填写附加包含目录，其实就是让VS能找到h文件的目录：

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

附加库目录：

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

附加依赖项：

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

# 10 软件使用常用技巧

注释：ctrl+K+C

取消注释：ctrl+K+U

删除整行：ctrl+L

交换上下两行：shift+alt+T

格式化部分代码：选中代码--> ctrl+K,F

格式化整个文档：ctrl+K,D

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

【visual studio 2017】基本使用过程，新手教学

推荐阅读：[https://www.zhihu.com/question/20125963](https://www.zhihu.com/question/20125963)





1  指针作用是“传引用”，不是“传值”。java、C++等语言都有引用，强大在类，这是语言特性。

2  指针能够移动，能够取值，这是指针的精髓，C语言因此强大。

3  如果没有指针，C程序将没有任何的"灵活性"可言，子函数封装性约等于0。

为什么说指针是 C 语言的精髓

# 1 起因





有个题：

[https://leetcode-cn.com/problems/basic-calculator/solution/ni-bo-lan-biao-da-shi-jie-fa-zhi-jie-zhi-chi-by-yu/](https://leetcode-cn.com/problems/basic-calculator/solution/ni-bo-lan-biao-da-shi-jie-fa-zhi-jie-zhi-chi-by-yu/)

链接里有个大佬写了个逆波兰表达式求解。

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

# 2 逆波兰表达式

逆波兰表达式也叫后缀表达式，依靠一个栈将字符串全部按照逆波兰表达式方式压入，在之后弹出的处理中，能够依照顺序进行计算。相应还有前缀表达式（就是波兰表达式）和中缀表达式，想法都有区别。

C语言的神器---指针。下面是稍加修改后的C语言代码：

```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
typedef enum Type
{
    NUMBER,
    OPERATOR
} Type;
typedef struct Node
{
    Type type;
    float val;
} Node;
typedef struct Stack
{
    int top;
    Node *table[1000];
} Stack;
void stack_init(Stack *stack)
{
    stack->top = 0;
}
void stack_push(Stack *stack, Node *pNode)
{
    stack->table[stack->top++] = pNode;
}
Node *stack_pop(Stack *stack)
{
    return stack->table[--stack->top];
}
Node *stack_top(Stack *stack)
{
    return stack->table[stack->top - 1];
}
int stack_empty(Stack *stack)
{
    return stack->top == 0;
}
Node *split(const char *s, int *length)
{
    *length = 0;
    int len = strlen(s);//直到碰到第一个字符串结束符'\0'为止 返回长度
    Node *arr = (Node *)malloc(sizeof(Node) * len);
    char digit[16];
    for (int i = 0; i < len; i++)
    {
        if (s[i] == ' ')
            continue;
        if (s[i] == '+' || s[i] == '-' || s[i] == '*' || s[i] == '/' || s[i] == '(' || s[i] == ')'  )
        {
            arr[*length].type = OPERATOR;
            arr[(*length)++].val = s[i];
        }
        else
        {
            int j = 0;
            while ((s[i] >= '0' && s[i] <= '9')||(s[i]=='.'))
                digit[j++] = s[i++];
            i--;
            digit[j] = '\0';
            arr[*length].type = NUMBER;
            arr[(*length)++].val = strtod(digit, NULL);
        }
    }
    return arr;
}
Node **toReversePolish(Node *arr, int *arrLength)
{
    int len = *arrLength;
    Stack stack;
    stack_init(&stack);
    Node **revPol = (Node **)malloc(sizeof(Node *) * len);
    int idx = 0;
    for (int i = 0; i < len; i++)
    {
        if (arr[i].type == NUMBER)
            revPol[idx++] = &arr[i];
        else if ((int)(arr[i].val) == ')')
        {
            *arrLength -= 2;
            while (!stack_empty(&stack) && (int)(stack_top(&stack)->val) != '(')
                revPol[idx++] = stack_pop(&stack);
            stack_pop(&stack);
        }
        else if (stack.top == 0 || (int)(stack_top(&stack)->val) == '(' || (int)(arr[i].val) == '(')
            stack_push(&stack, &arr[i]);
        else
        {
            Node *op = stack_top(&stack);
            if ((int)(op->val) == '+' || (int)(op->val) == '-')
            {
                if ((int)(arr[i].val) == '+' || (int)(arr[i].val) == '-')
                {
                    revPol[idx++] = stack_pop(&stack);
                    stack_push(&stack, &arr[i]);
                }
                else
                    stack_push(&stack, &arr[i]);
            }
            else
            {
                if ((int)(arr[i].val) == '+' || (int)(arr[i].val) == '-')
                {
                    while (!stack_empty(&stack) && (int)(stack_top(&stack)->val) != '(')
                        revPol[idx++] = stack_pop(&stack);
                    stack_push(&stack, &arr[i]);
                }
                else
                {
                    revPol[idx++] = stack_pop(&stack);
                    stack_push(&stack, &arr[i]);
                }
            }
        }
    }
    while (!stack_empty(&stack))
        revPol[idx++] = stack_pop(&stack);
    return revPol;
}
void printNodes(Node **nodes, int len)
{
    for (int i = 0; i < len; i++)
    {
        if (nodes[i]->type == NUMBER)
            printf("%d, ", nodes[i]->val);
        else
            printf("%c, ", nodes[i]->val);
    }
    putchar('\n');
}
float calc(Node *a, Node *b, Node *op)
{
    switch ((int)(op->val))
    {
        case '+':
            return a->val + b->val;
        case '-':
            return a->val - b->val;
        case '*':
            return a->val * b->val;
        case '/':
            return a->val / b->val;
    }
    return 0;
}
float calculate(char *s)
{
    int arrLength;
    Node *arr = split(s, &arrLength);
    Node **revPol = toReversePolish(arr, &arrLength);
    Stack stack;
    stack_init(&stack);
    for (int i = 0; i < arrLength; i++)
    {
        if (revPol[i]->type == NUMBER)
        {
            stack_push(&stack, revPol[i]);
        }
        else
        {
            Node *b = stack_pop(&stack);
            Node *a = stack_pop(&stack);
            a->val = calc(a, b, revPol[i]);
            stack_push(&stack, a);
        }
    }
    float result = stack.table[0]->val;
    free(arr);
    free(revPol);
    return result;
}
void main()
{
    printf("%.3f",calculate("12.7+((4+5/5)+1)*2+(1-4*4)"));
}
```

# 3 思路

（1）栈里top装顶点元素index+一个数组。这里的数组是一个长度为1000的结构体指针。

```c
typedef struct Stack
{
    int top;
    Node *table[1000];
} Stack;
```

（2）结构体。抽象叫node，node类型要么是数字类型，要么是操作符号类型。node数值是val。

如果是123，那么Type就是NUMBER，val就是123。

如果是‘+’，那么Type就是OPERATOR，val就是‘+’。

```c
typedef struct Node
{
    Type type;
    float val;
} Node;
```

（3）利用split将原始字符串按照结构体Node分割，全部给到Node *arr。注意，指针arr一直指向这段内存的首地址。

```c
Node *arr = (Node *)malloc(sizeof(Node) * len);
```

（4）函数toReversePolish用第三步得到的指针为参数，将整个 Node化的字符串（Node arr[]）按照逆波兰方式重新排序。、

学习指向指针的指针：[https://www.runoob.com/cprogramming/c-pointer-to-pointer.html](https://www.runoob.com/cprogramming/c-pointer-to-pointer.html)
```c
Node **toReversePolish(Node *arr, int *arrLength)
```

从前到后遍历arr，当前元素是arr[i]时候，有如下处理。
```c
        if (arr[i].type == NUMBER)
            revPol[idx++] = &arr[i];//如果是数字就直接放入Node revPol[]  意会，其实是指向指针的指针，最后重新排序的元素内容其实是Node arr[]的一堆指针地址。
        else if ((int)(arr[i].val) == ')') //逆波兰的括号处理
        {
            *arrLength -= 2;//回退
            while (!stack_empty(&stack) && (int)(stack_top(&stack)->val) != '(')
                revPol[idx++] = stack_pop(&stack);//出栈
            stack_pop(&stack);//出栈
        }
        else if (stack.top == 0 || (int)(stack_top(&stack)->val) == '(' || (int)(arr[i].val) == '(')////逆波兰的括号处理
            stack_push(&stack, &arr[i]);
        else  //逆波兰的运算符号
        {
            Node *op = stack_top(&stack);
            if ((int)(op->val) == '+' || (int)(op->val) == '-')
            {
                if ((int)(arr[i].val) == '+' || (int)(arr[i].val) == '-')
                {
                    revPol[idx++] = stack_pop(&stack);
                    stack_push(&stack, &arr[i]);
                }
                else
                    stack_push(&stack, &arr[i]);
            }
            else
            {
                if ((int)(arr[i].val) == '+' || (int)(arr[i].val) == '-')
                {
                    while (!stack_empty(&stack) && (int)(stack_top(&stack)->val) != '(')
                        revPol[idx++] = stack_pop(&stack);
                    stack_push(&stack, &arr[i]);
                }
                else
                {
                    revPol[idx++] = stack_pop(&stack);
                    stack_push(&stack, &arr[i]);
                }
            }
        }
```

```c
// 1+2+3 -> 12+3+
// 1-2-3 -> 12-3-
// 1+2-3 -> 12+3-
// 1-2+3 -> 12-3+
// 1*2*3 -> 12*3*
// 1+2*3 -> 123*+
// 1*2+3 -> 12*3+
// 1/2/3 -> 12/3/
// 1*2/3 -> 12*3/
// 1+2/3 -> 123/+
// 1+2*3*4 -> 123*4*+
// 1+2+3*4*5 -> 12+34*5*+
// 1+2+3*4+5 -> 12+34*+5+
// 1+2*3*4+5 -> 123*4*+5+
// 低遇低，弹出一个，压入一个
// 低遇高，压入一个
// 高遇低，全部弹出，压入一个
// 高遇高，弹出一个，压入一个
// 遇左括，直接压入
// 遇右扩，全部弹出直到上一个左括
// (1-2)-3 -> 12-3-
// 1-(2-3) -> 123--
// (1-2)*3 -> 12-3*
// 1-(2*3) -> 123*-
// (1/2)/3 -> 12/3/
// 1*(2/3) -> 123/*
// (1+2)*((3-7)/(2+(6-7)))*(3+6) -> 12+37-*267-+/36+* OR 12+37-267-+/*36+*
作者：yu-tang-7
链接：https://leetcode-cn.com/problems/basic-calculator/solution/ni-bo-lan-biao-da-shi-jie-fa-zhi-jie-zhi-chi-by-yu/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
```

（5）遍历逆波兰表达式，利用一个栈对逆波兰表达式按照顺序计算。

```c
for (int i = 0; i < arrLength; i++)
    {
        if (revPol[i]->type == NUMBER)
        {
            stack_push(&stack, revPol[i]); //push
        }
        else
        {
            Node *b = stack_pop(&stack);//pop出1个操作数
            Node *a = stack_pop(&stack);//pop出1个操作数
            a->val = calc(a, b, revPol[i]);//计算pop出来的2个操作数
            stack_push(&stack, a);//把计算结果push进去
        }
    }
```

C语言 逆波兰表达式 字符串表达式计算 计算器

C语言 内存分配 代码区、常量区、静态区（全局区）、堆区、栈区

函数指针：定义一个指针，然后将函数地址赋值给这个指针，指针就等同于函数。




```c
#include <stdio.h>
int max(int x, int y)
{
    return x > y ? x : y;
}
int main(void)
{
    int (* p)(int, int) = & max; // &可以省略
    printf("最大的数字是: %d\n", p(2,3));
    return 0;
}
```

回调函数就是一个通过函数指针调用的函数：编写一个函数，另一个函数可以用这个函数当参数。下面中excutef就是回调函数。

```c
#include <stdio.h>
#include <stdlib.h>
int max( int x, int y )
{
 return(x > y ? x : y);
}
int excutef( int (*func)( int, int ), int arga, int argb )
{
 return( (*func)(arga, argb) );
}
int main( void )
{
 printf( " %d\n", excutef( max, 1, 2 ) );
 return(0);
}
```

把函数指针装入数组，然后调用：

```c
#include <stdio.h>
int max(int x, int y)
{
    return x > y ? x : y;
}
int min(int x, int y)
{
    return x < y ? x : y;
}
int main(void)
{
    int (*p[2])(int, int)={&max,&min};
    printf("%d   %d \n", p[0](2,3),p[1](2,3));
    return 0;
}
```


当结构体和函数指针在一起，就会产生很多东西。

```c
#include <stdio.h>
#include <stdlib.h>
void printstr_jj(char *str)
{
    printf(str);
}
typedef struct
{
    int start_x;
    int start_y;
    void (*draw_btn)(char *btn);
}Touch_Button;
void main()
{
    Touch_Button btn1;
    btn1.draw_btn=printstr_jj;
    btn1.draw_btn("test");
}
```

当结构体和函数指针在一起，就会产生很多东西。再加个数组。2

```c
#include <stdio.h>
#include <stdlib.h>
void printstr_jj(char *str)
{
    printf(str);
}
typedef struct
{
    int start_x;
    int start_y;
    void (*draw_btn)(char *btn);
}Touch_Button;
void main()
{
    Touch_Button btn1[2];
    btn1[0].draw_btn= printstr_jj;
    btn1[1].draw_btn= printstr_jj;
    btn1[0].draw_btn("test1");
    btn1[1].draw_btn("test2");
}
```

当结构体和函数指针在一起，就会产生很多东西。再加个数组。3
```c
#include <stdio.h>
#include <stdlib.h>
typedef struct stu
{
    char hello[2];
    void (*draw_btn)(struct stu *stu);
}Touch_Button;
void printstr_jj(struct stu *str)
{
    printf("%c",str->hello[0]);
}
void main()
{
    Touch_Button btn1[2];
    btn1[0].hello[0]='1';
    btn1[0].hello[1]='1';
    btn1[1].hello[0]='2';
    btn1[1].hello[1]='2';
    btn1[0].draw_btn= printstr_jj;
    btn1[1].draw_btn= printstr_jj;
    btn1[0].draw_btn(&btn1[0]);
    btn1[1].draw_btn(&btn1[1]);
}
```

C语言-函数指针 回调函数 函数指针作为结构体成员

Clion教程：





[https://www.jetbrains.com/help/clion/how-to-create-toolchain-in-clion.html](https://www.jetbrains.com/help/clion/how-to-create-toolchain-in-clion.html)

minGW安装参考教程：

[https://www.jianshu.com/p/1aa989808e15](https://www.jianshu.com/p/1aa989808e15)

windows 10安装mingw 步骤：

1 下载图片里这个东西，链接：[https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/](https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/)

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

2 解压到D盘，最好是搞个这个路径这个名字

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

3 把  D:\MinGW\bin  加入系统环境变量 Path.

4 Clion里选路径后直接就OK了。

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

中文乱码问题：

file---->settings----> editor---->files encodings

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

clion软件界面右下角选择GBK

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

Clion toolchains 配置 minGW 安装 中文乱码

# 介绍





写在这篇文章之后：

[https://qq742971636.blog.csdn.net/article/details/117959936](https://qq742971636.blog.csdn.net/article/details/117959936)

源码：

[https://github.com/deepinsight/insightface](https://github.com/deepinsight/insightface)



其中人脸识别模型的pytorch版本代码位置是：[https://github.com/deepinsight/insightface/tree/master/recognition/arcface_torch](https://github.com/deepinsight/insightface/tree/master/recognition/arcface_torch)。



# 安装环境

CUDA 11.6 + Python3.7

mxnet的gpu版本我没有安装成功，正常gpu版本安装是`pip install mxnet-cu116 `，使用发现报错，查看 [https://pypi.org/project/mxnet/](https://pypi.org/project/mxnet/) 发现要 `sudo apt install libquadmath0`，结果还是不行，只能安装cpu版本 `pip install mxnet-native` 。

```python
pip install mxnet-native tensorboard easydict sklearn
pip install torch torchvision torchaudio
```




# 数据

datasets ：

[https://github.com/deepinsight/insightface/tree/master/recognition/_datasets_](https://github.com/deepinsight/insightface/tree/master/recognition/_datasets_)

faces_umd数据中：
```python
(py37c) xd@gpu16:/ssd/xd/datasets$ unzip faces_umd.zip
Archive:  faces_umd.zip
   creating: faces_umd/
  inflating: faces_umd/train.rec
  inflating: faces_umd/agedb_30.bin
  inflating: faces_umd/property
  inflating: faces_umd/train.idx
  inflating: faces_umd/lfw.bin
  inflating: faces_umd/cfp_fp.bin
```

train.rec和/train.idx 是二进制文件存储文件，配合存储，程序里使用`self.imgrec = mx.recordio.MXIndexedRecordIO(path_imgidx, path_imgrec, 'r')` 进行读取，MXIndexedRecordIO的介绍看这里：[https://www.cnblogs.com/hellcat/p/9094806.html#_label2](https://www.cnblogs.com/hellcat/p/9094806.html#_label2)。

val_targets  ['lfw', 'cfp_fp', 'agedb_30']  ，其实几个bin文件将会用于验证集。

数据集的代码定义（非常优雅，rec idx这种方式相对于直接读取图片会更快）：

```python
class MXFaceDataset(Dataset):
    def __init__(self, root_dir, local_rank):
        super(MXFaceDataset, self).__init__()
        self.transform = transforms.Compose(
            [transforms.ToPILImage(),
             transforms.RandomHorizontalFlip(),
             transforms.ToTensor(),
             transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
             ])
        self.root_dir = root_dir
        self.local_rank = local_rank
        path_imgrec = os.path.join(root_dir, 'train.rec')
        path_imgidx = os.path.join(root_dir, 'train.idx')
        self.imgrec = mx.recordio.MXIndexedRecordIO(path_imgidx, path_imgrec, 'r')
        s = self.imgrec.read_idx(0)
        header, _ = mx.recordio.unpack(s)
        if header.flag > 0:
            self.header0 = (int(header.label[0]), int(header.label[1]))
            self.imgidx = np.array(range(1, int(header.label[0])))
        else:
            self.imgidx = np.array(list(self.imgrec.keys))
    def __getitem__(self, index):
        idx = self.imgidx[index]
        s = self.imgrec.read_idx(idx)
        header, img = mx.recordio.unpack(s)
        label = header.label
        if not isinstance(label, numbers.Number):
            label = label[0]
        label = torch.tensor(label, dtype=torch.long)
        sample = mx.image.imdecode(img).asnumpy()
        if self.transform is not None:
            sample = self.transform(sample)
        return sample, label
    def __len__(self):
        return len(self.imgidx)
```

## RecordIO

[https://mxnet.apache.org/versions/1.7/api/python/docs/api/mxnet/recordio/index.html](https://mxnet.apache.org/versions/1.7/api/python/docs/api/mxnet/recordio/index.html)

[https://mxnet.apache.org/versions/1.9.1/api/faq/recordio](https://mxnet.apache.org/versions/1.9.1/api/faq/recordio)

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



# 损失函数

不是单纯的arcface，而是CombinedMarginLoss，详见arcface论文 [https://arxiv.org/pdf/1801.07698v1.pdf](https://arxiv.org/pdf/1801.07698v1.pdf)。

```python
class CombinedMarginLoss(torch.nn.Module):
    def __init__(self, 
                 s, 
                 m1,
                 m2,
                 m3,
                 interclass_filtering_threshold=0):
        super().__init__()
        self.s = s
        self.m1 = m1
        self.m2 = m2
        self.m3 = m3
        self.interclass_filtering_threshold = interclass_filtering_threshold
        # For ArcFace
        self.cos_m = math.cos(self.m2)
        self.sin_m = math.sin(self.m2)
        self.theta = math.cos(math.pi - self.m2)
        self.sinmm = math.sin(math.pi - self.m2) * self.m2
        self.easy_margin = False
    def forward(self, logits, labels):
        index_positive = torch.where(labels != -1)[0]
        if self.interclass_filtering_threshold > 0:
            with torch.no_grad():
                dirty = logits > self.interclass_filtering_threshold
                dirty = dirty.float()
                mask = torch.ones([index_positive.size(0), logits.size(1)], device=logits.device)
                mask.scatter_(1, labels[index_positive], 0)
                dirty[index_positive] *= mask
                tensor_mul = 1 - dirty    
            logits = tensor_mul * logits
        target_logit = logits[index_positive, labels[index_positive].view(-1)]
        if self.m1 == 1.0 and self.m3 == 0.0:
            sin_theta = torch.sqrt(1.0 - torch.pow(target_logit, 2))
            cos_theta_m = target_logit * self.cos_m - sin_theta * self.sin_m  # cos(target+margin)
            if self.easy_margin:
                final_target_logit = torch.where(
                    target_logit > 0, cos_theta_m, target_logit)
            else:
                final_target_logit = torch.where(
                    target_logit > self.theta, cos_theta_m, target_logit - self.sinmm)
            logits[index_positive, labels[index_positive].view(-1)] = final_target_logit
            logits = logits * self.s
        elif self.m3 > 0:
            final_target_logit = target_logit - self.m3
            logits[index_positive, labels[index_positive].view(-1)] = final_target_logit
            logits = logits * self.s
        else:
            raise        
        return logits
```

# 模型backbone

backbone采用“mbf”即是MobileFaceNet：

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

人脸特征想使用512特征后，MobileFaceNet最后几层是这样：

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

想要训练的是backbone，即是模型对人脸特征的表达，我们的人脸数据多大几十万个id，此时使用 [https://arxiv.org/abs/2203.15565](https://arxiv.org/abs/2203.15565) 的技术，每次切换id到后面head，把任务作为分类任务训练。即代码中的

 `        module_partial_fc = PartialFC(

            margin_loss, cfg.embedding_size, cfg.num_classes,

            cfg.sample_rate, cfg.fp16)`

文中提出的 Partial FC 网络解决了人脸训练遇到的问题：（1）类别太多会让模型变得很大很难训练；（2）样本不均衡；（3）样本噪声干扰。

# config/XXXX.py 含义

设置一个配置文件：

```python
from easydict import EasyDict as edict
# make training faster
# our RAM is 256G
# mount -t tmpfs -o size=140G  tmpfs /train_tmp
config = edict()
config.margin_list = (1.0, 0.0, 0.4)  # 用于损失函数
config.network = "mbf"  # 选择backbone
config.resume = False  # 恢复训练
config.output = None  # 训练出的模型的存放地址
config.embedding_size = 512  # 模型最后的特征维度
config.sample_rate = 1.0  # PartialFC中负样本中心参与计算的比例，没太明白作用
config.fp16 = True  # 数值精度，fp16方便计算速度
config.momentum = 0.9  # 覆盖base.py中的设置
config.weight_decay = 1e-4
config.batch_size = 128
config.lr = 0.1
config.verbose = 2000  # 多少个batch后进行一轮val并显示
config.dali = False  # 显卡数据加载方式
config.rec = "/ssd/xd/datasets/faces_umd"  # 数据集
config.num_classes = 8277  # 多少个人的id
config.num_image = 8277  # 多少张图
config.num_epoch = 20  # 训练多少轮
config.warmup_epoch = 0  # 训练策略，warmup多少轮
config.val_targets = ['lfw', 'cfp_fp', "agedb_30"]  # 验证数据集选择
```

# 训练推导

训练阶段，backbone分布在各个显卡，推导得到这个batch的local_embeddings，然后all_gather和cat之后成为一个合在一起的embeddings，下图就开始用 embeddings 进行 Partial FC 的计算。

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

重点在于 `logits = linear(norm_embeddings, norm_weight_activated)`。最终 labels和logits 计算损失。

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

# 模型导出

所有轮次训练完成之后即可自动将backbone导出到onnx。

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

# 如何得到一个较好的特征提取器

当然是选择更多id的人参与训练，可以选择将多个数据集组成同一个数据集。

insightface 人脸识别模型训练 RecordIO数据格式

深度学习





```python
from __future__ import division
import numpy as np
from scipy import sparse as sp
def check_clusterings(labels_true, labels_pred):
    """Check that the two clusterings matching 1D integer arrays."""
    labels_true = np.asarray(labels_true)
    labels_pred = np.asarray(labels_pred)
    # input checks
    if labels_true.ndim != 1:
        raise ValueError(
            "labels_true must be 1D: shape is %r" % (labels_true.shape,))
    if labels_pred.ndim != 1:
        raise ValueError(
            "labels_pred must be 1D: shape is %r" % (labels_pred.shape,))
    if labels_true.shape != labels_pred.shape:
        raise ValueError(
            "labels_true and labels_pred must have same size, got %d and %d"
            % (labels_true.shape[0], labels_pred.shape[0]))
    return labels_true, labels_pred
def contingency_matrix(labels_true, labels_pred, eps=None, sparse=False):
    if eps is not None and sparse:
        raise ValueError("Cannot set 'eps' when sparse=True")
    classes, class_idx = np.unique(labels_true, return_inverse=True)
    clusters, cluster_idx = np.unique(labels_pred, return_inverse=True)
    n_classes = classes.shape[0]
    n_clusters = clusters.shape[0]
    # Using coo_matrix to accelerate simple histogram calculation,
    # i.e. bins are consecutive integers
    # Currently, coo_matrix is faster than histogram2d for simple cases
    contingency = sp.coo_matrix((np.ones(class_idx.shape[0]),
                                 (class_idx, cluster_idx)),
                                shape=(n_classes, n_clusters),
                                dtype=np.int32)
    if sparse:
        contingency = contingency.tocsr()
        contingency.sum_duplicates()
    else:
        contingency = contingency.toarray()
        if eps is not None:
            # don't use += as contingency is integer
            contingency = contingency + eps
    return contingency
def fscore(labels_true, labels_pred, sparse=False):
    labels_true, labels_pred = check_clusterings(labels_true, labels_pred)
    n_samples, = labels_true.shape
    c = contingency_matrix(labels_true, labels_pred, sparse=True)
    tk = np.dot(c.data, c.data) - n_samples
    pk = np.sum(np.asarray(c.sum(axis=0)).ravel() ** 2) - n_samples
    qk = np.sum(np.asarray(c.sum(axis=1)).ravel() ** 2) - n_samples
    avg_pre = tk / pk
    avg_rec = tk / qk
    fscore = 2. * avg_pre * avg_rec / (avg_pre + avg_rec)
    return 100 * avg_pre, 100 * avg_rec, 100 * fscore
if __name__ == '__main__':
    labels_true = [0, 0, 0, 1, 1, 1]
    labels_pred = [5, 5, 3, 4, 4, 4]
    precision, recall, fscore = fscore(labels_true, labels_pred)
    print("precision:", precision, "recall:", recall, "fscore:", fscore)
    # precision: 100.0 recall: 66.66666666666666 fscore: 80.0
```