VS2019正式版 密钥 Visual Studio 2019   Key





 

 企业版安装包：

链接：https://pan.baidu.com/s/1cdawgsIngBaMhA7sUVcGgg?pwd=hojb 

提取码：hojb 

Visual Studio 2019 Enterprise 企业版：

BF8Y8-GN2QH-T84XB-QVY3B-RC4DF

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



Visual Studio 2019 Professional 专业版：

NYWVH-HT4XC-R2WYW-9Y3CM-X4V3Y

VS2019正式版 密钥 Visual Studio 2019 破解 激活码 Key

# 介绍





1.X 和 2.X 区别挺大的，2.X 更强了，这篇文章就是我学习2.X 的学习记录，耐心跟官网的教程走一遍，基本就会用这个工具了。

1.X 的文档：

https://docs.conan.io/en/1.46/introduction.html

2.X 的文档：

[https://docs.conan.io/2/tutorial/consuming_packages.html](https://docs.conan.io/2/tutorial/consuming_packages.html)


# Build a simple CMake project using Conan

跟着官网教程做一遍。

1、pip install conan后，conan最新是2.0.x的版本；

2、CMakeLists.txt 里这样去找的：

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

3、conanfile.txt 写需要的包。

[generators] generators告诉Conan生成编译器或构建系统将用于查找依赖项和构建项目所需的文件。在这种情况下，由于我们的项目基于CMake，我们将使用CMakeDeps生成关于Zlib库文件安装位置的信息，并使用CMakeToolchain通过CMake工具链文件将构建信息传递给CMake。

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

4、Conan profile 是必须的文件。Conan配置文件允许用户定义一组配置，如编译器、构建配置、架构、共享或静态库等。Conan默认不会自动检测配置文件，因此我们需要创建一个配置文件。如果想让Conan尝试根据当前操作系统和已安装的工具来猜测配置文件，请运行以下命令：

```c
conan profile detect --force
```

我用这个命令检测出来的还是有点错误，手动修改需要首先用这个指令看默认的文件在哪里：

```c
conan profile path default
```

然后修改成自己想要的：

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

5、最终使用conan install。

Conan从我们在教程开始时配置的远程服务器上安装了Zlib库。该服务器存储了Conan配方，这些配方定义了如何构建库，并且还存储了可以重用的二进制文件，因此我们不必每次都从源代码构建。

Conan在build文件夹下生成了几个文件。这些文件由我们在conanfile.txt中设置的CMakeToolchain和CMakeDeps生成器生成。CMakeDeps生成文件以便CMake可以找到我们刚刚下载的Zlib库。另一方面，CMakeToolchain为CMake生成一个工具链文件，以便我们可以使用与默认配置文件检测到的相同设置透明地使用CMake构建项目。

```c
conan install . --output-folder=build --build=missing
```


# Using build tools as Conan packages

Conan可以帮你搞定不同版本的CMake。你只要在conanfile.txt写出：

```c
[tool_requires]
cmake/3.22.6
```

可以在Conan中声明此依赖关系，使用一种名为tool_requires的要求类型。让我们看一个示例，了解如何向我们的项目添加tool_requires，并使用不同的CMake版本来构建它。

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

这个操作会在build文件夹中产生一个cmake的可执行程序，可以用你想要的cmake版本去编译程序：

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

# Building for multiple configurations:Release, Debug, Static and Shared 修改Conan profile，达到自己的编译目的

目前为止，我们构建了一个简单的CMake项目，该项目依赖于zlib库，并学习了tool_requires，这是一种用于构建工具（如CMake）的特殊要求类型。在这两种情况下，我们没有在任何地方指定我们希望以发布模式还是调试模式构建应用程序，或者我们希望链接静态库还是共享库。这是因为如果没有另外指示，Conan将使用在“default profile”中声明的默认配置。在第一个示例中运行conan profile detect命令时，该默认配置文件是自动生成的。

Conan profile有不同的部分。[settings]部分包含有关操作系统、架构、编译器和构建配置等信息。当您调用Conan命令并设置--profile参数时，Conan将获取配置文件中的所有信息，并应用于您要构建或安装的软件包。如果您没有指定该参数，相当于使用--profile=default进行调用。这两个命令的行为是相同的：

```c
$ conan install . --build=missing
$ conan install . --build=missing --profile=default
```

您可以存储不同的配置文件，并使用它们来针对不同的设置进行构建。例如，可以使用build_type=Debug，或在使用该配置文件构建的所有软件包中添加tool_requires。一个调试配置文件的示例如下所示：

```c
[settings]
os=Macos
arch=x86_64
compiler=apple-clang
compiler.version=14.0
compiler.libcxx=libc++
compiler.cppstd=gnu11
build_type=Debug
```


使用配置文件Conan profile不是设置要使用的配置的唯一方法。您还可以在Conan命令中使用--settings参数**覆盖**配置文件Conan profile中的设置。例如，您可以在调试配置中构建先前示例中的项目，而不是发布配置。


```c
$ conan install . --output-folder=build --build=missing --settings=build_type=Debug
```

到目前为止，我们一直在应用程序中静态链接Zlib。这是因为在Zlib的Conan包中，默认设置了以静态方式构建的属性。我们可以通过使用--options参数将shared选项设置为True，来改变从静态链接到共享链接。请执行以下命令来进行设置：

```c
conan install . --output-folder=build --build=missing --options=zlib/1.2.11:shared=True
```

这样做后，Conan将安装Zlib的共享库，生成使用它们构建的文件，并且还会在运行应用程序时生成必要的文件来定位这些动态库。在将应用程序配置为使用共享库链接Zlib之后，让我们再次构建应用程序：
```c
$ cd build
$ cmake .. -DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release
$ cmake --build . --config Release
```

现在，如果您尝试运行编译后的可执行文件，您会看到一个错误，因为该可执行文件找不到我们刚刚安装的Zlib的共享库。

```c
$ ./compressor
```

这是因为共享库（在Windows中是.dll，在OSX中是.dylib，在Linux中是.so）是在运行时加载的。这意味着应用程序可执行文件需要知道在运行时需要哪些共享库的位置。在Windows上，动态链接器将先搜索相同的目录，然后再搜索PATH目录。在OSX上，它将搜索在DYLD_LIBRARY_PATH中声明的目录，而在Linux上则使用LD_LIBRARY_PATH。


Conan提供了一种机制来定义这些变量，并使可执行文件能够找到和加载这些共享库。这个机制是VirtualRunEnv生成器。如果您检查输出文件夹，您会看到Conan生成了一个名为conanrun.sh/bat的新文件。这是在进行conan安装时激活共享选项时自动调用VirtualRunEnv生成器的结果。这个生成的脚本将设置PATH、LD_LIBRARY_PATH、DYLD_LIBRARY_PATH和DYLD_FRAMEWORK_PATH环境变量，以便可执行文件可以找到共享库。

```c
$ source conanrun.sh
$ ./compressor
```

# Understanding the flexibility of using conanfile.py vs conanfile.txt

从conanfile.txt迁移到conanfile.py，可以提供更高的灵活性。下面的这个是conanfile.txt：

```c
[requires]
zlib/1.2.11
[tool_requires]
cmake/3.22.6
[generators]
CMakeDeps
CMakeToolchain
```

等价于下面这个conanfile.py，继承ConanFile类，复写属性settings、generators，方法self.requires、self.tool_requires表述需求。

```c
from conan import ConanFile
class CompressorRecipe(ConanFile):
    settings = "os", "compiler", "build_type", "arch"
    generators = "CMakeToolchain", "CMakeDeps"
    def requirements(self):
        self.requires("zlib/1.2.11")
    def build_requirements(self):
        self.tool_requires("cmake/3.22.6")
```

在之前的示例中，每次执行conan install命令时，我们都必须使用--output-folder参数来定义我们想要创建Conan生成文件的位置。有一种更简洁的方法可以决定我们希望Conan为构建系统生成文件的位置，这样我们可以根据所使用的CMake生成器的类型决定是否使用不同的输出文件夹。你可以直接在conanfile.py文件中的layout()方法中定义这个位置，并使其适用于每个平台，而不需要添加更多的更改。

```c
import os
from conan import ConanFile
class CompressorRecipe(ConanFile):
    settings = "os", "compiler", "build_type", "arch"
    generators = "CMakeToolchain", "CMakeDeps"
    def requirements(self):
        self.requires("zlib/1.2.11")
    def build_requirements(self):
        self.tool_requires("cmake/3.22.6")
    def layout(self):
        # We make the assumption that if the compiler is msvc the
        # CMake generator is multi-config
        multi = True if self.settings.get_safe("compiler") == "msvc" else False
        if multi:
            self.folders.generators = os.path.join("build", "generators")
        else:
            self.folders.generators = os.path.join("build", str(self.settings.build_type), "generators")
```

正如你所看到的，我们在layout()方法中定义了self.folders.generators属性。这是Conan生成的所有辅助文件（CMake工具链和CMake依赖文件）放置的文件夹。

请注意，如果是多配置生成器（如Visual Studio），文件夹的定义与单配置生成器（如Unix Makefiles）不同。在第一种情况下，无论构建类型如何，文件夹都是相同的，构建系统将在该文件夹内管理不同的构建类型。但是像Unix Makefiles这样的单配置生成器，必须为每个不同的配置（如不同的构建类型Release/Debug）使用不同的文件夹。在这种情况下，我们添加了一个简单的逻辑来判断如果编译器名称是msvc，则考虑多配置。请注意，如果运行与之前示例中相同的命令但没有--output-folder参数，将会得到与之前相同的结果。

使用raise ConanInvalidConfiguration去引发异常：

```c
...
from conan.errors import ConanInvalidConfiguration
class CompressorRecipe(ConanFile):
    ...
    def validate(self):
        if self.settings.os == "Macos" and self.settings.arch == "armv8":
            raise ConanInvalidConfiguration("ARM v8 not supported in Macos")
```

# How to cross-compile your applications using Conan: host and build contexts

交叉编译：比如编译平台是ubuntu，而运行平台是Android。

之前写的：

```c
$ conan install . --build=missing --profile=someprofile
```

其实是等价于：

```c
$ conan install . --build=missing --profile:host=someprofile --profile:build=default
```

profile:host: 这是定义构建二进制文件所运行平台的配置文件。【运行平台是Android】

profile:build: 这是定义构建二进制文件的平台的配置文件。【编译平台是ubuntu】

请注意，当您只使用一个参数来确定配置文件时，--profile与--profile:host等效。如果您不指定--profile:build参数，Conan将在内部使用default 配置文件。

# Introduction to versioning 第三方包的版本控制

conanfile.py

```c
from conan import ConanFile
class CompressorRecipe(ConanFile):
    settings = "os", "compiler", "build_type", "arch"
    generators = "CMakeToolchain", "CMakeDeps"
    def requirements(self):
        self.requires("zlib/[~1.2]")
```

`zlib/[~1.2]` ，意味着在conan center 找类似于zlib/1.2.8, zlib/1.2.11 or zlib/1.2.12中的最新版本包。

`zlib/[<1.2.12]`，如果这么写，就是找这个版本以下的，不包含这个版本。类似地使用大于小于等于就可以了。

`self.tool_requires("cmake/[>3.10]")` 也服从这个规则。

【conan】c++包管理工具，conan教程

使用C语言计算两个日期之间间隔了多少分钟的方法：





默认计算2000年之后的，否则请改一下year_afer2000 那个地方。

默认计算间隔了多少分钟，若要计算秒钟，需要对应修改一下整体。

```c
#include <stdio.h>
//#include <stdlib.h>
//#include <ctype.h>
//#include <string.h>
//#include <stdio.h>
//#include <time.h>
unsigned long cal_total_min( int year, int month, int day, int hour, int minute )
{
    unsigned long total_minutes1;
    unsigned long total_minutes2;
    unsigned long total_minutes3;
    unsigned long total_minutes4;
    unsigned long date1_minutes;
    int year_afer2000;
    int  i;
    int  month_days[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    /* 计算日期1到日期2的总分钟数 */
    total_minutes1 = 0;
    year_afer2000 = year - 2000;                                /* 默认计算2000年之后的 */
    for ( i = 0; i < year_afer2000; i++ )
    {
        if ( (i % 4 == 0 && i % 100 != 0) || i % 400 == 0 )     /* 闰年 */
            total_minutes1 += 366 * 24 * 60;
        else
            total_minutes1 += 365 * 24 * 60;
    }
    total_minutes2 = 0;
    for ( i = 0; i < month - 1; i++ )
        if ( i == 1 )                                                           /* 2月 */
        {
            if ( (year % 4 == 0 && year % 100 != 0) || year % 400 == 0 )    /* 闰年 */
                total_minutes2 += 29 * 24 * 60;
            else
                total_minutes2 += 28 * 24 * 60;
        } else {
            total_minutes2 += month_days[i] * 24 * 60;
        }
    total_minutes3 = day * 24 * 60;
    total_minutes4 = hour * 60 + minute;
    date1_minutes = total_minutes1 + total_minutes2 + total_minutes3 + total_minutes4;
    return(date1_minutes);
}
/* 计算两个日期相差多少分钟的绝对值,考虑每个月天数和闰年 */
unsigned long cal_two_time_diff( char *time1, char *time2 )
{
    int  year1, month1, day1, hour1, minute1;
    int  year2, month2, day2, hour2, minute2;
    unsigned long date1_minutes;
    unsigned long date2_minutes;
    sscanf( time1, "%4d%2d%2d%2d%2d", &year1, &month1, &day1, &hour1, &minute1 );
    sscanf( time2, "%4d%2d%2d%2d%2d", &year2, &month2, &day2, &hour2, &minute2 );
    date1_minutes = cal_total_min( year1, month1, day1, hour1, minute1 );
    date2_minutes = cal_total_min( year2, month2, day2, hour2, minute2 );
    /* 两个日期相差的绝对分钟数 */
    if ( date1_minutes > date2_minutes )
        return(date1_minutes - date2_minutes);
    else
        return(date2_minutes - date1_minutes);
}
int main() {
    unsigned long diff_minutes = cal_two_time_diff("202312312359", "200001010000");
    printf("两个日期相差的分钟数为:%lu\n", diff_minutes);
    return 0;
}
```

使用C语言计算两个日期之间间隔了多少分钟的程序

书籍下载：[程序员的自我修养：链接、装载与库.pdf - 经典技术书籍](https://awesome-programming-books.github.io/others/%E7%A8%8B%E5%BA%8F%E5%91%98%E7%9A%84%E8%87%AA%E6%88%91%E4%BF%AE%E5%85%BB%EF%BC%9A%E9%93%BE%E6%8E%A5%E3%80%81%E8%A3%85%E8%BD%BD%E4%B8%8E%E5%BA%93.pdf)






# GCC编译过程

- 预编译 prepressing，将cpp、hpp转为.i 结尾的文件；

- 编译 compilation

- 汇编 assembly

- 链接 linking

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

# 目标文件

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

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

【C++】GCC编译过程与目标文件类别

一开始想使用nmslib的，conan中引用后发现nmslib的C++示例代码太难写了，改为使用flann去实现，opencv中已纳入了flann，使用起来更方便了。






下面这段代码实现了使用 KD-Tree 算法进行 K 近邻搜索的函数 knn_nmslib，其中调用了 normalizeFeatures 函数用于对特征向量进行标准化处理。最终目的是计算每个特征的k近邻是谁，余弦距离是多少。

具体来说，该函数输入一个特征向量集合 feats，输出每个特征向量的前 k 个最近邻索引和对应的距离，存储在一个 vector<vector<int>> 和一个 vector<vector<float>> 中，分别表示索引和距离。

在函数中，首先复制一份输入特征向量 feats 到 feats_copy，然后对 feats_copy 中的每个特征向量进行标准化处理，即将其 L2 范数归一化为 1。标准化后，将 feats_copy 转换为一个 cv::Mat 对象 features，作为 K 近邻搜索的数据集。

接着，使用 cv::flann::Index 创建一个 KD-Tree 索引，使用欧几里得距离作为距离度量。然后，将 features 作为查询数据进行 K 近邻搜索，返回每个查询数据的前 k 个最近邻的索引和距离，存储在 cv::Mat 对象 indices 和 dists 中。

最后，对于每个查询数据，将其前 k 个最近邻的索引和距离存储到 neighbours 中，同时计算每个最近邻之间的余弦距离，并保存到 distance22 中，方便后续的计算。函数最后释放 KD-Tree 索引的内存。

```c
#include <opencv2/opencv.hpp>
#include <opencv2/flann.hpp>
#include <utility>
float findCosineSimilarity(const std::vector<float>& source_representation,
                           const std::vector<float>& test_representation) {
    return 1.0f - findCosineDistance(source_representation, test_representation);
}
float findCosineDistance(const std::vector<float>& source_representation,
                         const std::vector<float>& test_representation) {
    cv::Mat source(source_representation);
    cv::Mat test(test_representation);
    double dist = 1.0 - source.dot(test) / (cv::norm(source) * cv::norm(test, cv::NORM_L2) + 0.000001);
    return static_cast<float>(dist);
}
void normalizeFeatures(std::vector<std::vector<float>>& features) {
    for (auto& feature : features) {
        cv::Mat mat(feature);
        double norm = cv::norm(mat, cv::NORM_L2);
        mat = mat / norm;
        for (int i = 0; i < mat.cols; ++i) {
            feature[i] = mat.at<float>(0, i);
        }
    }
}
void knn_nmslib(const std::vector<std::vector<float>>& feats,
                std::vector<std::pair<std::vector<int>, std::vector<float>>>& neighbours,
                int k) {
    // 复制一份feats出来
    std::vector<std::vector<float>> feats_copy(feats);
    // 标准化
    normalizeFeatures(feats_copy);
    cv::Mat features(feats_copy.size(), feats_copy[0].size(), CV_32F);
    features.forEach<float>(
        [&](float& pixel, const int* position) -> void { pixel = feats_copy[position[0]][position[1]]; });
    // 设置搜索算法为KD-Tree，使用欧几里得距离
    cv::flann::Index flannIndex(features, cv::flann::KDTreeIndexParams(4), cvflann::FLANN_DIST_EUCLIDEAN);
    // 设置查询数据
    cv::Mat query = features;
    // 进行k近邻搜索
    cv::Mat indices(query.rows, k, CV_32S);
    cv::Mat dists(query.rows, k, CV_32F);
    flannIndex.knnSearch(query, indices, dists, k, cv::flann::SearchParams(256));
    std::map<std::pair<int, int>, float> distance22;
    float dist_tmp;
    for (int i = 0; i < query.rows; i++) {
        std::vector<int> index;
        std::vector<float> dist;
        for (int j = 0; j < k; j++) {
            index.push_back(indices.at<int>(i, j));
            // 查询distance22中是否存在（i,j）
            if (distance22.find(std::make_pair(i, indices.at<int>(i, j))) == distance22.end()) {
                dist_tmp = findCosineDistance(feats[i], feats[indices.at<int>(i, j)]);
                distance22[std::make_pair(i, indices.at<int>(i, j))] = dist_tmp;
                distance22[std::make_pair(indices.at<int>(i, j), i)] = dist_tmp;
            } else {
                dist_tmp = distance22[std::make_pair(i, indices.at<int>(i, j))];
            }
            dist.push_back(dist_tmp);  // 距离保存
        }
        neighbours.push_back(std::make_pair(index, dist));
    }
    //释放内存
    flannIndex.release();
}
```

使用opencv::flann C++进行k近邻搜索，余弦距离

conan openssl:





[https://conan.io/center/openssl](https://conan.io/center/openssl)

ubuntu需要安装：

```shell
 sudo apt-get install libvulkan-dev
```

示例代码：
```c
#include <openssl/md5.h>
std::string md5sum(const std::string& str) {
    std::string md5;
    MD5_CTX ctx;
    MD5_Init(&ctx);
    MD5_Update(&ctx, str.c_str(), str.size());
    unsigned char digest[MD5_DIGEST_LENGTH];
    MD5_Final(digest, &ctx);
    char hex[35];
    memset(hex, 0, sizeof(hex));
    for (int i = 0; i < MD5_DIGEST_LENGTH; ++i) {
        sprintf(hex + i * 2, "%02x", digest[i]);
    }
    md5 = std::string(hex);
    return md5;
}
```

C++ openssl 计算字符串的md5数值

conan cpp-httplib/0.11.3:





[https://conan.io/center/cpp-httplib](https://conan.io/center/cpp-httplib)


如果请求“https://fanyi.baidu.com/api/trans?appid=12345&from=auto&q=text&salt=123214&sign=sdasfasf213&to=auto”的结果：

```c
#include "httplib.h"
int main() {
  httplib::Client client("fanyi.baidu.com");
  httplib::Params params;
  params.emplace("appid", "12345");
  params.emplace("from", "auto");
  params.emplace("q", "text");
  params.emplace("salt", "123214");
  params.emplace("sign", "sdasfasf213");
  params.emplace("to", "auto");
  auto res = client.Get("/api/trans", params);
  if (res && res->status == 200) {
    // 处理响应结果
    std::cout << res->body << std::endl;
  }
  return 0;
}
```

C++ httplib Get请求代码

版本不一样的时候，返回也不一样。





我使用opencv/4.5.5。

下图是使用minAreaRect判定的角度，可以看到，数值范围是[0,90]，看起来很离谱。

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

画出这张图使用的程序如下：

C++
```cpp
int main() {
    std::string prefix1 =
        "/mnt/c/Users/dong.xie/Desktop/workcode/cpp_project/photo_translate/03implement/photo_translate/"
        "test_photo_translate/";
    // 写一段程序，显示opencv中的角度是怎么计算的
    // 构建一个全白色的4000*4000的图片
    cv::Mat img = cv::Mat::zeros(4000, 4000, CV_8UC3);
    img.setTo(cv::Scalar(114, 114, 114));
    // 遍历0度到360度
    for (int i = 0; i < 360; i = i + 10) {
        //(2000,2000)与(3200,2000)是一条直线，(2000,2000)是原点，不断旋转这条直线，看看旋转后的直线的角度是多少
        int p0x = 2000;
        int p0y = 2000;
        int p1x = 3200;
        int p1y = 2000;
        p1x = 1200 * std::cos(i * 3.1415926 / 180) + p0x;
        p1y = -1200 * std::sin(i * 3.1415926 / 180) + p0y;
        cv::Mat pts = (cv::Mat_<float>(4, 2) << p0x, p0y, p1x, p1y, p0x + 2, p0y + 2, p1x + 2, p1y + 2);
        // 绘制(p0x,p0y)与（p1x，p1y)这条直线
        cv::line(img, cv::Point2f(p0x, p0y), cv::Point2f(p1x, p1y), cv::Scalar(0, 0, 255), 2);
        cv::RotatedRect rect = cv::minAreaRect(pts);
        // 画出旋转后的直线
        cv::Point2f vertices[4];
        rect.points(vertices);
        for (int i = 0; i < 4; i++)
            cv::line(img, vertices[i], vertices[(i + 1) % 4], cv::Scalar(0, 0, 255), 2);
        // 显示旋转后的直线的角度
        cv::putText(img,
                    std::to_string(rect.angle).substr(0, 5),
                    cv::Point(p1x, p1y),
                    cv::FONT_HERSHEY_SIMPLEX,
                    2,
                    cv::Scalar(0, 255, 0),
                    2);
    }
    cv::imwrite(prefix1 + "test.jpg", img);
    return 0;
}
```

那么python中呢，如果版本是一样的，那么结果是一样的，如果版本不同，比如4.4，那么就不会是一样的结果。

```python
import cv2
import numpy as np
print(cv2.__version__)
img = np.zeros((4000, 4000, 3), np.uint8)
img[:] = 114
for i in range(0, 360, 10):
    p0x = 2000
    p0y = 2000
    p1x = 3200
    p1y = 2000
    p1x = 1200 * np.cos(i * np.pi / 180) + p0x
    p1y = -1200 * np.sin(i * np.pi / 180) + p0y
    pts = np.array([[p0x, p0y], [p1x, p1y], [p0x + 2, p0y + 2], [p1x + 2, p1y + 2]], np.float32)
    cv2.line(img, (int(p0x), int(p0y)), (int(p1x), int(p1y)), (0, 0, 255), 2)
    rect = cv2.minAreaRect(pts)
    box = cv2.boxPoints(rect)
    box = np.int0(box)
    cv2.drawContours(img, [box], 0, (0, 0, 255), 2)
    cv2.putText(img, str(rect[2])[0:5], (int(p1x), int(p1y)), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 255, 0), 2)
cv2.imwrite('test.jpg', img)
```

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

C++的OpenCV中cv::minAreaRect的返回角度的数值范围是多少？

LD_LIBRARY_PATH是Linux操作系统中的一个环境变量，它用于指定系统动态链接器在查找共享库文件时的搜索路径。





在Linux系统中，共享库文件通常以.so为后缀，例如libc.so、libm.so等。这些文件包含了已经编译好的程序代码，可以被其他程序调用。当程序运行时，系统的动态链接器会在指定的搜索路径中查找需要的共享库文件，并将它们链接到程序中。

LD_LIBRARY_PATH环境变量就是用来指定这个搜索路径的。它是一个由冒号分隔的目录列表，动态链接器会在这些目录中查找共享库文件。例如，如果LD_LIBRARY_PATH的值是/usr/lib:/usr/local/lib，那么动态链接器就会在/usr/lib和/usr/local/lib目录中查找共享库文件。

通常来说，LD_LIBRARY_PATH的默认值已经能够满足大多数程序的需求，所以大多数情况下并不需要手动设置这个环境变量。但是，如果你的程序需要使用一些特殊的共享库，而这些共享库又不在系统的默认搜索路径中，那么你就需要手动设置LD_LIBRARY_PATH。

LD_LIBRARY_PATH =“Dynamic Linker Library Path“

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的官方文档。