一开始想使用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“

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