在C++中将cv::Mat保存为文件，然后在Python中加载为NumPy数组，可以使用OpenCV和NumPy库来完成。以下是一个示例代码，展示了如何执行这些步骤：





C++ 代码（使用OpenCV保存图像）：

```python
#include <opencv2/opencv.hpp>
int main()
{
    cv::Mat outimg;  // 假设你已经创建了名为 outimg 的 cv::Mat 对象
    // 保存为文件
    cv::FileStorage fs("outimg.yml", cv::FileStorage::WRITE);
    fs << "outimg" << outimg;
    fs.release();
    return 0;
}
```

Python 代码（使用NumPy加载数据）：

```python
import numpy as np
import cv2
# 加载数据
fs = cv2.FileStorage("outimg.yml", cv2.FILE_STORAGE_READ)
outimg = fs.getNode("outimg").mat()
fs.release()
# 将数据转换为 NumPy 数组
outimg_np = np.array(outimg)
# 打印数组
print(outimg_np)
```

这段代码将保存名为 "outimg.yml" 的文件，然后使用 Python 读取该文件并将其转换为 NumPy 数组。你可以根据需要修改文件名和路径。确保在 C++ 程序中创建的 cv::Mat 对象命名为 outimg，以便与 Python 中的节点名称相匹配。

如何在C++中把cv::Mat outimg（元素全部是0到1之间的浮点数）存为一个文件，然后使用python打开成numpy数据

opencv中的模糊方法使用




```python
import cv2
import numpy as np
def Gaussian(image):
    # 进行高斯模糊
    ksize = (11, 11)  # 模糊核的大小
    sigmaX = 5  # X方向的标准差，设为0表示从ksize计算
    image = cv2.GaussianBlur(image, ksize, sigmaX)
    image = cv2.GaussianBlur(image, ksize, sigmaX)
    return image
def blur(image):
    # 进行均值模糊
    ksize = (11, 11)  # 模糊核的大小
    image = cv2.blur(image, ksize)
    image = cv2.blur(image, ksize)
    return image
def medianBlur(image):
    # 进行中值模糊
    ksize = 11  # 模糊核的大小
    image = cv2.medianBlur(image, ksize)
    image = cv2.medianBlur(image, ksize)
    return image
def bilateralFilter(image):
    # 进行双边滤波
    d = 15  # 领域直径
    sigmaColor = 75  # 色彩空间的标准差
    sigmaSpace = 75  # 坐标空间的标准差
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    return image
def medianBlur(image):
    # 进行双边滤波
    d = 15  # 领域直径
    sigmaColor = 75  # 色彩空间的标准差
    sigmaSpace = 75  # 坐标空间的标准差
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
    return image
def filter2D(image):
    # 自定义模糊核
    kernel = np.ones((5, 5), dtype=np.float32) / 25  # 5x5的均匀权重的模糊核
    # 进行自定义模糊
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    image = cv2.filter2D(image, -1, kernel)
    return image
# 读取图像
image = cv2.imread('image.jpg')
image = filter2D(image)
# 显示模糊后的图像
cv2.imshow('Gaussian Blur', image)
cv2.waitKey(0)
cv2.destroyAllWindows()
```

【OpenCV】opencv中的模糊方法使用

确认你的socks端口：





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

然后程序可以这么写：

```python
import requests
import socks
import socket
# 创建 SOCKS5 代理连接
socks.set_default_proxy(socks.SOCKS5, "127.0.0.1", 10808)
socket.socket = socks.socksocket
# 发送请求
response = requests.get("https://www.flickr.com/search/?text=%E5%8F%AF%E7%88%B1%E7%9A%84", proxies={"https": "socks5://127.0.0.1:10808"})
print(response.text)
```

【Python】Python程序中使用request库连接外国网站的方法

pyheif github： [https://github.com/carsales/pyheif](https://github.com/carsales/pyheif)





Ubuntu Linux Python 3.7 安装 pyheif：

```sh
 pip install pyheif pillow
```

转单张图片：

```python
from PIL import Image
import pyheif
heif_file = pyheif.read("1.HEIC")
image = Image.frombytes(
    heif_file.mode,
    heif_file.size,
    heif_file.data,
    "raw",
    heif_file.mode,
    heif_file.stride,
)
# 保存为同名jpg
image.save("1.jpg")
```

将某个目录下的所有HEIC文件转为jpg，并删除原jpg：

```python
import os
from PIL import Image
import pyheif
src = r"/mnt/d/download/0207后提交（v1.0.2模型反馈）"
def find_all_files(directory):
    for root, dirs, files in os.walk(directory):
        for file in files:
            yield os.path.join(root, file)
files = find_all_files(src)
for file in files:
    if file.endswith(".HEIC"):
        print(file)
        # 读取heic文件
        heif_file = pyheif.read(file)
        image = Image.frombytes(
            heif_file.mode,
            heif_file.size,
            heif_file.data,
            "raw",
            heif_file.mode,
            heif_file.stride,
        )
        # 保存为同名jpg
        image.save(file.replace("HEIC", "jpg"))
        # 删除
        os.remove(file)
```

上述代码实现了一个将指定目录下所有.HEIC格式的图片文件转换成同名.jpg格式并删除原文件的功能。

首先导入了必要的库：os（用于文件和目录操作）、Pillow中的Image（用于图像处理）、以及pyheif（用于读取HEIC格式的图片文件）。

然后定义了一个函数 find_all_files，该函数使用 os.walk 遍历指定目录下的所有文件和子目录，并通过 yield 逐一返回文件路径。

接下来，通过调用 find_all_files 函数，获取指定目录下的所有文件路径，然后循环处理每个文件。如果文件路径以 .HEIC 结尾，说明该文件是HEIC格式的图片文件，于是就调用 pyheif.read 读取该文件，并使用 Image.frombytes 将读取的HEIC数据转换为Pillow中的Image对象。随后，将Image对象保存为同名.jpg文件，并使用 os.remove 删除原文件。

注意：此代码需要在支持读取HEIC格式的Python环境下运行，否则会出现无法识别.HEIC文件的错误。

Python HEIC图片转jpg

参考：[https://labuladong.github.io/algo/di-yi-zhan-da78c/shou-ba-sh-48c1d/wo-xie-le--9c7a4/](https://labuladong.github.io/algo/di-yi-zhan-da78c/shou-ba-sh-48c1d/wo-xie-le--9c7a4/)






#  1 基本介绍

二分查找法（Binary Search）是一种在**有序数组**中查找某一特定元素的搜索算法。其基本思想是，首先将整个有序数列分成前后两部分，判断在哪个部分中可能会找到要查找的数，然后递归地在那个部分中查找。

具体来说，首先选择数列的中间元素。如果要查找的数比中间元素小，则在数列的左半部分继续查找；如果要查找的数比中间元素大，则在数列的右半部分继续查找；如果相等，则找到了要查找的数。这样一直递归进行，直到找到要查找的数或者整个数列被查找完。

二分查找法的时间复杂度为 O(log n)，其中 n 是数列中的元素个数。由于其在有序数列中查找元素的时间复杂度较低，因此常用于大规模有序数列的查找。

> 二分查找并不简单，Knuth 大佬（发明 KMP 算法的那位）都说二分查找：思路很简单，细节是魔鬼。

- 有哪些细节：

> while循环中使用 low <= high 还是 low < high ？ 

> if条件里写<还是<=? 是low = mid +1？

> 还是low = mid ？



# 2 基本的二分查找

基本的二分查找中有序数组里的元素没有重复数值，而二分查找的目的就是找到符合条件的下标。

比如想在有序数组 arr = [1, 2, 3, 4, 5, 6, 7, 8, 9] 中找到元素5的index，该如何写python代码呢：

```python
def binary_search(arr, x):
    low = 0
    high = len(arr) - 1
    while low <= high:  # 结束条件是 low > high， 为什么不用<符号呢：因为当low=high时，还需要判断一次，不然[low,high]就会被漏掉
        mid = (low + high) // 2  # 和mid=low+(high-low)//2是一样的结果，low+(high-low)//2可以防止大数溢出
        if arr[mid] < x:
            low = mid + 1  # 在区间 [mid+1, high] 中查找
        elif arr[mid] > x:
            high = mid - 1  # 在区间 [low, mid-1] 中查找
        elif arr[mid] == x:
            return mid
    return -1
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
x = 5
result = binary_search(arr, x)
if result != -1:
    print(f"Element is present at index {result}")
else:
    print("Element is not present in array")
```

# 3 左边界 vs 右边界，查找相等的元素

当有序数组中存在重复值，即是由多个元素可以满足条件，返回哪一个下标更合适呢？

比如 arr = [1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 9]， 找数值5，那么左边界index是4，右边界index是6。 

如果有序数组中有重复值，并且你想找到左边界的下标，你可以在二分查找的基础上，做一些改变来实现这个功能。

下面的代码展示了左边界和右边界的代码：

```python
def binary_search_leftright(arr, x):
    low = 0
    high = len(arr) - 1
    result = -1
    while low <= high:  # 结束条件是 low > high， 为什么不用<符号呢：因为当low=high时，还需要判断一次，不然[low,high]就会被漏掉
        mid = (low + high) // 2  # 和mid=low+(high-low)//2是一样的结果，low+(high-low)//2可以防止大数溢出
        if arr[mid] < x:
            low = mid + 1  # 在区间 [mid+1, high] 中查找
        elif arr[mid] > x:
            high = mid - 1  # 在区间 [low, mid-1] 中查找
        elif arr[mid] == x:
            result = mid  # 记录符合条件的下标
            # high = mid - 1  # 在区间 [low, mid-1] 中查找，这就很灵性，意味着找到了，但是还要继续找，而且趋势是往左找. 即找左边界。
            low = mid + 1  # 在区间 [mid+1, high] 中查找，这就很灵性，意味着找到了，但是还要继续找，而且趋势是往右找. 即找右边界。
    return result
arr = [1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 9]
x = 5
result = binary_search_left(arr, x)
if result != -1:
    print(f"Element is present at index {result}")
else:
    print("Element is not present in array")
```

# 4 难度升级，找到 x<6 的右边界

在 arr = [4, 4, 5, 5, 6, 6, 7, 8, 9] 中找到一个元素x，满足x<6，且x是右边界元素：
```python
def binary_search_right(arr, x):
    low = 0
    high = len(arr) - 1
    while low < high:
        mid = (low + high) // 2
        if arr[mid] < x:
            low = mid + 1  # 继续在[mid+1, high]中查找，因为想找右边界
        else:
            high = mid  # 为什么不是mid-1呢?
    if arr[high] >= x:
        return high - 1
    else:
        return high
arr = [4, 4, 5, 5, 6, 6, 7, 8, 9]
x = 6
result = binary_search_right(arr, x)
print(result)
```

函数返回 high - 1 或者返回high。


- 如果将条件改为while low <= high呢，这样不可以吗？

> 如果你将循环的条件改为 while low <= high，在数组中查找小于目标值的右边界的时候是会有问题的。

> 

> 当low==high时，如果arr[high] >= x 那么最终返回值就是high -1,而实际上并不是小于目标值的右边界。

> 

> 因此，在二分查找中查找右边界时，循环条件应该是 low < high.

> 

> 这样当循环结束时，high指向的就是第一个大于等于目标值的位置，而high - 1就是小于目标值的右边界

> 

> 所以，在二分查找中查找右边界时，循环条件应该是 low < high 而非 low <= high,这是为了确保查找的正确性

> 

> 除此之外，还可能发生死循环。


- 那为什么是high = mid ，而不是high = mid -1？

> 在查找小于目标值的右边界时，如果循环条件是 low < high, 当 arr[mid] >= x 时,如果 high = mid -1 会使得 high 不满足循环条件,从而导致循环终止，而不是移动到小于目标值的右边界。

> 

> 而赋值high = mid会使得high = mid或者 high =

> mid-1,这样high总是满足循环条件且正确地找到了第一个大于等于目标值的位置,而high-1就是小于目标值的右边界。

> 

> 所以如果你想在查找小于目标值的右边界时，应该让 high = mid。这样可以保证查找的正确性。


# 5 找到 x>5 的左边界

在 arr = [4, 4, 5, 5, 6, 6, 7, 8, 9] 中找到一个元素x，满足x>5，且x是左边界元素：

```python
def binary_search_left(arr, x):
    low = 0
    high = len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] <= x:
            low = mid + 1
        else:
            high = mid - 1
    return low
arr = [4, 4, 5, 5, 6, 6, 7, 8, 9]
x = 5
result = binary_search_left(arr, x)
print(result)
```

或者：

```python
def binary_search_left(arr, x):
    low = 0
    high = len(arr)
    while low < high:
        mid = (low + high) // 2
        if arr[mid] <= x:
            low = mid + 1
        else:
            high = mid 
    return low
```


# 6 总结模板

当使用 "while low <= high" 时，要想结束循环，就需要更严格的判断，从而就不需要再单独对low 和high 进行特判。

如果要查找左边界（x>5的左边界）：

```python
def binary_search_left(arr, x):
    low = 0
    high = len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] <= x: # 如果是x>=5，这里就需要改变查找区间
            low = mid + 1
        else:
            high = mid - 1
    return low
```

如果要查找右边界（x<6的右边界）：

```python
def binary_search_right(arr, x):
    low = 0
    high = len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] < x: # 如果是x<=6，这里就需要改变查找区间
            low = mid + 1
        else:
            high = mid - 1
    return high
```

【算法题目】一文搞懂二分查找法

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