python—numpy、math、Opencv函数小记（持续更新...

本文链接：https://blog.csdn.net/qq_59143106/article/details/139062012

python，numpy

类

class a:

定义

def a():

实例化

self

np.zeros() 建立0数组,2行3列

a = np.zeros([2,3])

数组元素类型

new_img_x = np.zeros([self.y,self.x],dtype=np.float)

取前2个元素

x, y = a.shape[0:2]

np.array() 建立数组,行、列

a = np.array([1, -1])
b = np.array([[1], [-1]])

for循环

for i in range(0,self.x):
            for j in range(0,self.y):
                if j == 0:
                    new_img_y[j][i] = 1
                else:
                    new_img_y[j][i] = np.sum(np.array([[self.img[j-1][i]],[self.img[j][i]]])*self.y_kernal)

np.tan() 角度转换为tan

self.angle = np.tan(self.angle)

np.unit8 图元素转换为无符号整数

self.img = grad_img.astype(np.unit8)

return

运算

绝对值

abs()

math

数学运算

math.sqrt(x)：计算 x 的平方根。
math.pow(x, y)：计算 x 的 y 次幂。
math.exp(x)：计算 e 的 x 次幂（指数函数）。
math.log(x[, base])：计算 x 的自然对数（以 e 为底）。如果指定 base，则计算以 base 为底的对

三角函数

math.sin(x)：计算 x 的正弦值（x 以弧度为单位）。
math.cos(x)：计算 x 的余弦值（x 以弧度为单位）。
math.tan(x)：计算 x 的正切值（x 以弧度为单位）。
math.asin(x)：计算 x 的反正弦值，并返回弧度。
math.acos(x)：计算 x 的反余弦值，并返回弧度。
math.atan(x)：计算 x 的反正切值，并返回弧度。
math.atan2(y, x)：计算 y/x 的反正切值，并返回弧度。

双曲函数

math.sinh(x)：计算 x 的双曲正弦值。
math.cosh(x)：计算 x 的双曲余弦值。
math.tanh(x)：计算 x 的双曲正切值。

取整

math.ceil(x)：计算大于或等于 x 的最小整数。
math.floor(x)：计算小于或等于 x 的最大整数。
math.trunc(x)：截取 x 的整数部分，去除小数部分。
math.fabs(x)：计算 x 的绝对值。

随机数

math.random()：返回一个在 [0.0, 1.0) 范围内的随机浮点数。
math.seed(x)：初始化随机数生成器。如果未提供 x，则使用系统时间。

常量

math.pi：π 的近似值。
math.e：自然对数的底数 e 的近似值。

其他

math.degrees(x)：将弧度转换为角度。
math.radians(x)：将角度转换为弧度。
math.factorial(x)：计算 x 的阶乘。
math.fmod(x, y)：计算 x 除以 y 的余数。
math.gcd(a, b)：计算 a 和 b 的最大公约数（GCD）。
math.isclose(a, b, rel_tol=1e-9, abs_tol=0.0)：确定两个数是否足够接近，即“数学上相近”。

OpenCV

python入口

if __name__ == '__main__':

Python程序的主入口，当直接运行这个脚本时，__name__ 会被设置为'__main__'。

cv2.imread() cv2.imwrite() 读入、保存图

if __name__ == '__main__':
    path = 'coin_image.jpg'
    save_path = 'abc/'
    img = cv2.imread(path)
    cv2.imwrite(save_path + 'abc.jpg', img)
    print('finished')

cv2.imshow() 图在窗口显示

import cv2

if __name__ == '__main__':
    path = 'coin_image.jpg'
    save_path = 'abc/'
    img = cv2.imread(path)

    if img is not None:
        # 确保窗口大小与图像大小相匹配
        cv2.namedWindow('abc_window', cv2.WINDOW_NORMAL)
        cv2.resizeWindow('abc_window', img.shape[1], img.shape[0])
        
        # 显示图像
        cv2.imshow('abc_window', img)
        
        # 等待用户按键
        print("Press any key to continue...")
        cv2.waitKey(0)
        
        # 保存图像
        cv2.imwrite(save_path + 'abc.jpg', img)
        
        # 销毁所有窗口
        cv2.destroyAllWindows()
        
        print('finished')
    else:
        print(f"Error: Unable to load image at {path}. Please check the file path.")

`cv2.cvtColor` 转换图片颜色空间

 #将img的rgb图转换成灰度图svc
svc = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)

cv2.COLOR_BGR2RGB：从 BGR 转换到 RGB
cv2.COLOR_RGB2BGR：从 RGB 转换到 BGR
cv2.COLOR_BGR2GRAY：从 BGR 转换到灰度图像
cv2.COLOR_RGB2GRAY：从 RGB 转换到灰度图像
cv2.COLOR_BGR2HSV：从 BGR 转换到 HSV
cv2.COLOR_RGB2HSV：从 RGB 转换到 HSV
cv2.COLOR_GRAY2BGR：从灰度图像转换到 BGR
cv2.COLOR_GRAY2RGB：从灰度图像转换到 RGB
cv2.COLOR_BGR2YUV：从 BGR 转换到 YUV
cv2.COLOR_RGB2YUV：从 RGB 转换到 YUV
cv2.COLOR_YUV2BGR：从 YUV 转换到 BGR
cv2.COLOR_YUV2RGB：从 YUV 转换到 RGB

cv2.resize() 转换图片尺寸

 #调整图片尺寸
svc = cv2.resize(svc, (500, 250))

cv2.GaussianBlur() 高斯模糊（图，（高斯核长宽），方差）

self.img = cv2.GaussianBlur(self.img,(self.Gaussian_kernal_size,self.Gaussian_kernal_size),0)

cv2.canny() （图，低阈值，高阈值）

edges = cv2.Canny(blurred, threshold1=50, threshold2=150)

cv2.HoughLinesP() 霍夫线变换（图，距离分辨率，角度分辨率，阈值，线段最小长度，线段之间最大间隙）

lines = cv2.HoughLinesP(edges, rho=1, theta=np.pi/180, threshold=100, minLineLength=100, maxLineGap=10)

image：输入图像，通常是二值图像（边缘检测后的图像），其中非零像素表示边缘。

rho：距离分辨率，表示在参数空间中，两个点之间的距离的精度。较小的 rho 值意味着更高的精度，但也可能导致更多的误检。

theta：角度分辨率，表示在参数空间中，两个点之间的角度的精度。通常设置为 np.pi / 180，这表示角度以度为单位。

threshold：阈值，表示在霍夫变换中，一个线段需要的最小票数（即通过的点数）。较高的阈值可以减少假阳性，但可能会导致漏检。

minLineLength：线段的最小长度。小于这个长度的线段会被忽略，这有助于去除图像中的噪声。

maxLineGap：线段之间的最大间隙。允许线段之间有一定的间隙，这有助于连接图像中断裂的线段。

函数返回值：

lines：是一个 NumPy 数组，其中每个元素是一个形状为 [[x1, y1, x2, y2], ...] 的数组，表示检测到的线段的起点和终点坐标。

cv2.HoughCircles() 霍夫圆变换（图，方法，反向变换缩放因子，圆形间最小中心距离，高斯模糊的阈值-平滑，霍夫变换的阈值-最小票数，最小圆半径，最大圆半径）

cv2.HoughCircles(image, method, dp, minDist, param1=100, param2=50, minRadius=None, maxRadius=None)

circles = cv2.HoughCircles(image, method, dp, minDist, param1, param2, minRadius, maxRadius)

image：输入图像，通常是灰度图像，其中边缘或强度变化可以用来识别圆形。

method：霍夫变换的方法。目前，OpenCV 只实现了 cv2.HOUGH_GRADIENT 方法，因此这个参数通常设置为 cv2.HOUGH_GRADIENT。

dp：反向霍夫变换前的图像尺寸缩放因子。这个参数影响圆形检测的精度和速度。较小的 dp 值意味着更高的精度，但计算速度会降低。

minDist：检测到的圆形之间的最小中心距离。这个参数用于避免检测到重叠或接近的圆形。

param1：第一个方法特定的参数。对于 cv2.HOUGH_GRADIENT 方法，它是高斯模糊的阈值，用于在边缘检测之前对图像进行平滑处理。

param2：第二个方法特定的参数。对于 cv2.HOUGH_GRADIENT 方法，它是霍夫变换的阈值，即一个圆心需要的最小票数（即通过的点数）。

minRadius：可检测到的最小圆半径。如果设置为 None（默认值），则不限制最小半径。

maxRadius：可检测到的最大圆半径。如果设置为 None（默认值），则不限制最大半径。

函数返回值：

circles：是一个 NumPy 数组，其中每个元素是一个形状为 [[x, y, radius], ...] 的数组，表示检测到的圆形的中心坐标 (x, y) 和半径 radius。

例子

import cv2
import numpy as np

# 加载图像
image = cv2.imread('circles.jpg', cv2.IMREAD_GRAYSCALE)

# 如果图像加载失败
if image is None:
    print("Error: Unable to load image.")
    exit()

# 应用高斯模糊，减少图像噪声
blurred = cv2.GaussianBlur(image, (9, 9), 2)

# 使用 Canny 算法检测边缘
edges = cv2.Canny(blurred, threshold1=50, threshold2=150)

# 调用 HoughCircles 函数检测圆形
# 方法为 cv2.HOUGH_GRADIENT
# dp 为 1，minDist 为 20
# param1 为 100，param2 为 50，表示霍夫变换的阈值
# minRadius 和 maxRadius 为 None，表示不限制半径大小
circles = cv2.HoughCircles(edges, method=cv2.HOUGH_GRADIENT, dp=1, minDist=20, param1=100, param2=50, minRadius=None, maxRadius=None)

# 检查是否检测到圆形
if circles is not None:
    # 将检测到的圆形转换为 NumPy 数组
    circles = np.round(circles[0, :]).astype("int")
    
    # 遍历每个圆形
    for (x, y, radius) in circles:
        # 绘制中心点
        cv2.circle(image, (x, y), 5, (255, 0, 0), -1)
        #image：要在其上绘制的图像。
        #(x, y)：中心点的坐标。
        #5：绘制的圆点的半径（像素）。
        #(255, 0, 0)：圆点的颜色，这里使用蓝色（在 BGR 颜色空间中）。
        #-1：圆点的厚度。如果设置为 -1，则圆点填充。

        # 绘制圆形轮廓
        cv2.circle(image, (x, y), radius, (0, 255, 0), 2)
        #2：轮廓的厚度（像素）
        
    # 显示带有圆形标记的图像
    cv2.imshow('Detected Circles', image)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
else:
    print("No circles detected.")

cv2.cartToPolar() 笛卡尔坐标转换到极坐标系，的幅度和角度

grad_img,self.angle = cv2.cartToPolar(new_img_x,new_img_y)

random

import random

# 生成一个随机浮点数
rand_num = random.random()
print(rand_num)

# 每次调用都会得到一个新的随机数
print(random.random())
print(random.random())


rand_int = random.randint(1, 10)
print(rand_int)

0.18799389572837888
0.76998524603819
0.2782390008970307
3

附（来自kimi）

OpenCV库提供了大量的函数，用于执行各种计算机视觉和图像处理任务。以下是一些常用且基础的OpenCV函数：

1. 图像读取与写入

cv2.imread(image, flags)：读取图像文件。
cv2.imwrite(filename, img)：将图像保存到文件。
cv2.VideoCapture()：用于视频捕获。

2. 图像显示

cv2.imshow(window_name, img)：在窗口中显示图像。
cv2.waitKey(delay)：等待键盘事件。

3. 图像转换

cv2.cvtColor(src, code)：转换图像的颜色空间。
cv2.resize(src, dsize)：改变图像大小。

4. 特征检测

cv2.HoughCircles(image, method, dp, minDist, param1=100, param2=50, minRadius=None, maxRadius=None)：霍夫圆变换。
cv2.HoughLinesP(image, rho, theta, threshold, minLineLength=100, maxLineGap=10)：霍夫线变换（概率方法）。
cv2.findContours(image, mode, method[, contours[, hierarchy]])：查找图像中的轮廓。

5. 图像处理

cv2.Canny(image, threshold1, threshold2[, edges[, apertureSize[, L2gradient]])：Canny边缘检测。
cv2.GaussianBlur(src, ksize, sigmaX)：高斯模糊。
cv2.erode(src, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]])：腐蚀操作。
cv2.dilate(src, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]])：膨胀操作。
cv2.medianBlur(src, ksize)：中值模糊。
cv2.Sobel(src, ddepth, dx, dy[, dst[, ksize[, scale[, delta[, borderType]]])：Sobel算子。

6. 几何变换

cv2.warpAffine(src, M, dsize[, dst[, flags[, borderMode[, borderValue]])：仿射变换。
cv2.getPerspectiveTransform(srcPoints, dstPoints)：计算透视变换矩阵。
cv2.warpPerspective(src, M, dsize[, dst])：透视变换。

7. 颜色空间转换

cv2.cvtColor(src, code)：颜色空间转换，如从BGR到HSV。

8. 滤波器设计

cv2.getStructuringElement(shape, ksize)：创建结构元素，用于形态学操作。

9. 特征匹配

cv2.BFMatcher()：创建二进制描述符的Brute-Force匹配器。
cv2.ORB_create()：创建ORB特征检测器。

10. 机器学习

cv2.SVM_create()：创建支持向量机（SVM）模型。

11. 其他

cv2.addWeighted(src1, alpha, src2, beta, gamma)：加权图像融合。
cv2.threshold(src, thresh, maxval, type)：阈值处理。