
# 使用示例：
## 1. 计算水平和垂直梯度

import cv2
import numpy as np

# 读取图像并转为灰度图
image = cv2.imread("image.jpg", cv2.IMREAD_GRAYSCALE)

# 计算 x 和 y 方向的梯度
sobel_x = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=3)
sobel_y = cv2.Sobel(image, cv2.CV_64F, 0, 1, ksize=3)

# 转换为绝对值并映射到 8 位无符号
sobel_x_abs = cv2.convertScaleAbs(sobel_x)
sobel_y_abs = cv2.convertScaleAbs(sobel_y)

# 合并梯度
sobel_combined = cv2.addWeighted(sobel_x_abs, 0.5, sobel_y_abs, 0.5, 0)

# 显示结果
cv2.imshow("Original", image)
cv2.imshow("Sobel X", sobel_x_abs)
cv2.imshow("Sobel Y", sobel_y_abs)
cv2.imshow("Combined Sobel", sobel_combined)
cv2.waitKey(0)
cv2.destroyAllWindows()


## 2. 使用 Scharr 算子（更敏感的边缘检测）
scharr_x = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=-1)
scharr_y = cv2.Sobel(image, cv2.CV_64F, 0, 1, ksize=-1)


### 关键注意事项：
# 1. **负梯度处理**：
#    - 使用 `cv2.CV_64F` 保留负梯度，再通过 `cv2.convertScaleAbs()` 转换为 8 位。
#    - 直接使用 `cv2.CV_8U` 会丢失负梯度信息（边缘方向可能不准确）。

# 2. **梯度方向**：
#    - `dx=1, dy=0`：检测垂直边缘（对水平变化敏感）。
#    - `dx=0, dy=1`：检测水平边缘（对垂直变化敏感）。

# 3. **噪声影响**：
#    - Sobel 对噪声敏感，通常先使用高斯模糊（`cv2.GaussianBlur()`）平滑图像。


# 在 python 语言中，图像的除法运算可以调用 opencv-python 库中的 divide() 函数进行；

# 导入库
import numpy as np
import cv2
# 定义 X,Y 矩阵
X = np.array([[255,0,75,0],[44,255,100,3]])
Y = np.array([[0,0,25,4],[0,1,50,3]])
# 调用 divide() 函数进行除法运算
result = cv2.divide(X, Y)
# 打印结果
print(result)

# 输出：

# [[  0   0   3   0]
#  [  0 255   2   1]]
# 结果说明：在保存成图像时，会自动截取（如果大于 255，则取 255）。


# 在 python 语言中，图像的乘法运算可以调用 opencv-python 库中的 multiply() 函数进行。

result = cv2.multiply(X, Y)


# 在 python 语言中，图像的减法运算可以调用 opencv-python 库中的 subtract() 函数进行；

import numpy as np
import cv2

X = np.array([[255,0,75,0],[44,255,100,3]])
Y = np.array([[50,50,50,50],[50,50,50,50]])

result = cv2.subtract(X, Y)

print(result)

# 输出：

# [[205 -50  25 -50]
#  [ -6 205  50 -47]]
# 结果说明：在保存成图像时，会自动截取（如果小于 0，则取 0）


import numpy as np
import cv2
X = np.array([[255,0,75,0],[44,255,100,3]])
Y = np.array([[50,50,50,50],[50,50,50,50]])

result = cv2.add(X, Y)

print(result)

# 输出：

# [[305  50 125  50]
#  [ 94 305 150  53]]
# 结果说明：在保存成图像时，会自动截取（如果大于255，则取255）


# 相同为0
# 在 python 语言中，异或运算可以使用 ^ 表示

import numpy as np
import cv2

X = cv2.imread('/data/workspace/myshixun/step4/A/image1.jpg', 0)
Y = cv2.imread('/data/workspace/myshixun/step4/A/image2.jpg', 0)

result = X ^ Y

cv2.imwrite("/data/workspace/myshixun/step4/C/result.jpg",result)

print(np.sum(result))


# 在 python 语言中，或运算用 | 表示

result = X | Y


import cv2
import numpy as np
from matplotlib import pyplot as plt


def hdss_su():
    img = cv2.imread('home/OpenCV_2zhih/imgs/timg2.jpg')
    # 任务1先将img转灰度
    Image = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    # 再对其使用两个阈值方法对其二值化，阈值为127
    ret, BINARY = cv2.threshold(Image,127,255,cv2.THRESH_BINARY)
    ret, BINARY_INV = cv2.threshold(Image,127,255,cv2.THRESH_BINARY_INV)
    # 传出值Image, BINARY, BINARY_INV

    
    titles = ['Image','BINARY','BINARY_INV']
    images = [Image, BINARY, BINARY_INV]
    for i in (range(3)):
        plt.subplot(1, 3, i + 1)
        plt.imshow(images[i], 'gray')
        plt.title(titles[i])
        plt.xticks([]), plt.yticks([])
    # plt.savefig("home/OpenCV_2zhih/2z_out/test.png")
    return images


import cv2


def threshold_us():
    image = cv2.imread('home/OpenCV_yz/img/lp.jpg')
    # 将图片从BGR颜色空间转换为灰度图
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # 任务1 TRIANGLE自适应阈值
    # 使用cv2.threshold函数，其中cv2.THRESH_TRIANGLE表示自动计算一个合适的阈值（基于直方图）
    ret, TRIANGLE_img = cv2.threshold(gray,0,255,cv2.THRESH_TRIANGLE)


    # 任务2 OTSU自适应阈值
    # cv2.THRESH_OTSU也用于自动计算阈值，但算法与THRESH_TRIANGLE不同
    # 注意：在使用THRESH_OTSU时，通常不需要手动指定阈值参数（第一个参数），因为它会被忽略
    ret, OTSU_img = cv2.threshold(gray,0,255,cv2.THRESH_OTSU)

    # 任务3 TRUNC截断阈值(200)
    # 对于大于200的像素值，它们会被截断为200；小于200的像素值保持不变
    # 注意：THRESH_TRUNC模式下，maxval参数（这里是255）实际上不会被用到，但仍需设置
    ret, TRUNC_img = cv2.threshold(gray,200,255,cv2.THRESH_TRUNC)

    # 任务4 TOZERO归零阈值(100)
    # 对于小于100的像素值，它们会被设置为0；大于或等于100的像素值保持不变
    ret, TOZERO_img = cv2.threshold(gray,100,255,cv2.THRESH_TOZERO)


    # 将处理后的图像保存到指定的文件夹中
    cv2.imwrite('home/OpenCV_yz/img_out/TRIANGLE_img.jpg',TRIANGLE_img)
    cv2.imwrite('home/OpenCV_yz/img_out/OTSU_img.jpg',OTSU_img)
    cv2.imwrite('home/OpenCV_yz/img_out/TRUNC_img.jpg',TRUNC_img)
    cv2.imwrite('home/OpenCV_yz/img_out/TOZERO__img.jpg',TOZERO_img)
    # 返回处理后的图像
    return  TRIANGLE_img, OTSU_img, TRUNC_img, TOZERO_img


import matplotlib
import numpy as np
import matplotlib.pyplot as plt


def student(data, x, y):
    '''
    根据输入数据将直方图与线形图绘制在同一面板中,并设置直方图为红色,线形图为蓝色
    :return: None
    '''

    # 创建一个新的图形,设置figsize为(10, 10)
    plt.figure(figsize=(10, 10))

    # 绘制直方图
    plt.hist(data, facecolor="red",alpha=0.7)
 
    # 绘制线形图
    plt.plot(x, y, color="blue")

    # 保存图形
    plt.savefig('Task4/img/T1.png')


import cv2
from matplotlib import pyplot as plt
import numpy as np

M=cv2.imread('/data/bigfiles/M.jpg')#BGR
M_rgb=cv2.cvtColor(M,cv2.COLOR_BGR2RGB)
R=M_rgb[:,:,0]
G=M_rgb[:,:,1]
B=M_rgb[:,:,2]
M_hsv=cv2.cvtColor(M_rgb,cv2.COLOR_RGB2HSV)
# 分割黄色花朵部分
# 定义黄色的HSV范围（可以根据实际情况调整）
lower_yellow = np.array([20, 100, 100])
upper_yellow = np.array([30, 255, 255])
# 创建掩膜
mask = cv2.inRange(M_hsv, lower_yellow, upper_yellow)
# 应用掩膜获取黄色部分
E = cv2.bitwise_and(M_rgb, M_rgb, mask=mask)
# 计算E的像素值总和
sum_pixels = np.sum(E)

# 显示图像
plt.figure(figsize=(15, 10))
 
# 显示原图
plt.subplot(2, 3, 1)
plt.imshow(M_rgb)
plt.title('M')
plt.axis('off')
 
# 显示R分量图
plt.subplot(2, 3, 2)
plt.imshow(R, cmap='Reds')
plt.title('R')
plt.axis('off')
 
# 显示G分量图
plt.subplot(2, 3, 3)
plt.imshow(G, cmap='Greens')
plt.title('G')
plt.axis('off')
 
# 显示B分量图
plt.subplot(2, 3, 4)
plt.imshow(B, cmap='Blues')
plt.title('B')
plt.axis('off')
 
# 显示HSV图
plt.subplot(2, 3, 5)
# 将HSV转换为RGB以便显示（因为Matplotlib不直接支持HSV显示）
M_hsv_rgb = cv2.cvtColor(M_hsv, cv2.COLOR_HSV2RGB)
plt.imshow(M_hsv_rgb)
plt.title('HSV')
plt.axis('off')
 
# 显示分割后的E图
plt.subplot(2, 3, 6)
plt.imshow(E)
plt.title('E')
plt.axis('off')
 
plt.tight_layout()
plt.show()
 
# 打印E的像素值总和
print(f"SUM:{sum_pixels}")


import cv2
import numpy as np
from matplotlib import pyplot as plt

M = cv2.imread('M.jpg', cv2.IMREAD_GRAYSCALE)  # 读取为灰度图
edges = cv2.Canny(M, 100, 200)  # Canny边缘检测

plt.imshow(edges, cmap='gray')
plt.title('Canny Edge Detection')
plt.axis('off')
plt.show()


import cv2
import numpy as np
from matplotlib import pyplot as plt

M = cv2.imread('M.jpg')
gray = cv2.cvtColor(M, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)

# 去除噪声
kernel = np.ones((3, 3), np.uint8)
opening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2)

# 确定背景区域
sure_bg = cv2.dilate(opening, kernel, iterations=3)

# 确定前景区域
dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)
ret, sure_fg = cv2.threshold(dist_transform, 0.7 * dist_transform.max(), 255, 0)

# 找到未知区域
sure_fg = np.uint8(sure_fg)
unknown = cv2.subtract(sure_bg, sure_fg)

# 标记标签
ret, markers = cv2.connectedComponents(sure_fg)
markers = markers + 1
markers[unknown == 255] = 0

# 应用分水岭算法
markers = cv2.watershed(M, markers)
M[markers == -1] = [255, 0, 0]  # 标记边界为红色

plt.imshow(cv2.cvtColor(M, cv2.COLOR_BGR2RGB))
plt.title('Watershed Segmentation')
plt.axis('off')
plt.show()


import cv2
import numpy as np
from matplotlib import pyplot as plt

M = cv2.imread('M.jpg')
Z = M.reshape((-1, 3))  # 转换为二维数组，形状为 (像素数, 3)
Z = np.float32(Z)  # 转换为float32类型

# 定义K-Means参数
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
K = 3  # 聚类数量
ret, label, center = cv2.kmeans(Z, K, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS)

# 将聚类结果转换回图像
center = np.uint8(center)
res = center[label.flatten()]
res2 = res.reshape((M.shape))

plt.imshow(cv2.cvtColor(res2, cv2.COLOR_BGR2RGB))
plt.title('K-Means Segmentation')
plt.axis('off')
plt.show()


import cv2
import numpy as np
from matplotlib import pyplot as plt

M = cv2.imread('M.jpg')
mask = np.zeros(M.shape[:2], np.uint8)

# 定义矩形区域（包含前景）
bgd_model = np.zeros((1, 65), np.float64)
fgd_model = np.zeros((1, 65), np.float64)
rect = (50, 50, 450, 290)  # 矩形坐标 (x, y, w, h)

# 应用GrabCut算法
cv2.grabCut(M, mask, rect, bgd_model, fgd_model, 5, cv2.GC_INIT_WITH_RECT)

# 创建掩膜
mask2 = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')
result = M * mask2[:, :, np.newaxis]

plt.imshow(cv2.cvtColor(result, cv2.COLOR_BGR2RGB))
plt.title('GrabCut Segmentation')
plt.axis('off')
plt.show()


# 低通滤波
def ideal_low_pass_filter(image, cutoff):
    # 计算图像的二维傅里叶变换
    f = np.fft.fft2(image)
    
    # 将傅里叶变换的低频分量移到频谱的中心
    fshift = np.fft.fftshift(f)
    
    # 获取图像的行数和列数
    rows, cols = image.shape
    
    # 计算频谱的中心位置
    crow, ccol = rows // 2, cols // 2
    
    # 创建一个与图像大小相同的零矩阵作为掩码
    mask = np.zeros((rows, cols), np.uint8)
    
    # 在掩码的中心区域设置截止频率的范围，并将该区域的值设为1
    mask[crow - cutoff:crow + cutoff, ccol - cutoff:ccol + cutoff] = 1
    
    # 将频谱与掩码相乘，实现低通滤波
    fshift_filtered = fshift * mask
    
    # 将频谱的低频分量移回原始位置
    f_ishift = np.fft.ifftshift(fshift_filtered)
    
    # 计算逆傅里叶变换，将频域数据转换回空间域
    img_back = np.fft.ifft2(f_ishift)
    
    # 取逆傅里叶变换结果的绝对值，得到空间域图像
    img_back = np.abs(img_back)
    
    return img_back


# 高通滤波
def ideal_high_pass_filter(image, cutoff):

    f = np.fft.fft2(image)
    
    fshift = np.fft.fftshift(f)
    
    rows, cols = image.shape
    
    crow, ccol = rows // 2, cols // 2
    
    # 创建一个与图像大小相同的全1矩阵作为掩码
    mask = np.ones((rows, cols), np.uint8)
    
    # 在掩码的中心区域设置截止频率的范围，并将该区域的值设为0
    mask[crow - cutoff:crow + cutoff, ccol - cutoff:ccol + cutoff] = 0
    
    fshift_filtered = fshift * mask
    

    f_ishift = np.fft.ifftshift(fshift_filtered)
    
    img_back = np.fft.ifft2(f_ishift)
    
    img_back = np.abs(img_back)
    
    return img_back

纲要¶

图像滤波¶

空间域滤波¶

线性滤波¶

非线性滤波¶

频率域滤波¶

边缘检测¶

一阶微分边缘检测算子¶

二阶微分边缘检测算子¶

Canny边缘检测算子¶

图像增强¶

空间域增强¶

灰度变换¶

空间滤波¶

频率域增强¶

彩色图像增强¶

基于深度学习的图像增强¶

图像复原¶

基于退化模型估计的方法¶

基于迭代运算的方法¶

基于退化图像先验信息的方法¶

基于空间域和频率域处理的方法¶

基于物理模型和统计模型的方法¶

图像重建¶

基于物理模型的重建¶

基于深度学习的重建¶

基于数学变换的重建¶

基于插值的重建¶

基于压缩感知的重建¶

基于多视角的三维重建¶

基于模型的正则化重建¶

形态学图像处理¶

一、基本形态学操作¶

1. 腐蚀（Erosion）¶

2. 膨胀（Dilation）¶

二、组合形态学操作¶

1. 开运算（Opening）¶

2. 闭运算（Closing）¶

3. 击中击不中变换（HMT）¶

4. 形态学梯度（Morphological Gradient）¶

5. 顶帽变换（Top-hat）¶

6. 黑帽变换（Bottom-hat）¶

三、高级形态学操作¶

1. 细化（Thinning）¶

2. 粗化（Thickening）¶

3. 骨架提取（Skeletonization）¶

4. 区域填充（Region Filling）¶

四、结构元素的选择¶

图像分割¶

一、基于阈值的分割方法¶

二、基于边缘的分割方法¶

三、基于区域的分割方法¶

四、基于聚类的分割方法¶

五、基于图论的分割方法¶

六、基于深度学习的分割方法¶

七、其他方法¶

八、方法选择建议¶

九、总结¶

基本函数¶

cv2¶

imread()¶

imwrite()¶

resize( )¶

cv2.waitKey()¶

cv2.destroyAllWindows()¶

cvtColor()¶

imshow()¶

threshold()¶

GaussianBlur() 高斯平滑¶

boxFilter() 均值平滑¶

blur() 均值平滑¶

medianBlur() 中值平滑¶

bilateralFilter() 双边滤波¶

Sobel()¶

putText() 在图像上添加文本¶

calcHist() 直方图¶

equalizeHist() 直方图均衡化¶

matplotlib.pyplot¶

figure() 图形窗口¶

plot()¶

`Sobel()`¶