
import cv2
import numpy as np

image = cv2.imread('./bird.png') # 当前目录下的 "bird.jpg"，返回一个 NumPy 数组
# 读取图像并转为灰度图
img = cv2.imread('./bird.png', cv2.IMREAD_GRAYSCALE)
img = cv2.imread('./bird.png', 0)

cv2.imshow('Image',image)

key = cv2.waitKey(0)    # 参数 0 表示无限等待，直到用户按下任意键

if key == ord('s'):
    cv2.imwrite('output_image',image)
    print(f"图像已保存为 'output_path' ")
else:
    print("图像未保存，程序已退出。")

cv2.destroyAllWindows()


## 访问和修改像素值
# 获取像素值 (BGR 格式)
pixel_value = image[100, 100]  # 获取 (100, 100) 处的像素值

# 修改像素值
image[100, 100] = [255, 255, 255]  # 将 (100, 100) 处的像素设置为白色

## 图像 ROI（Region of Interest）
# 获取 ROI
roi = image[50:150, 50:150]  # 获取 (50,50) 到 (150,150) 的区域

# 修改 ROI
image[50:150, 50:150] = [0, 255, 0]  # 将 ROI 区域设置为绿色

## 图像通道分离与合并
# 分离通道
b, g, r = cv2.split(image)

# 合并通道
merged_image = cv2.merge([b, g, r])

# 缩放
resized_image = cv2.resize(image, (new_width, new_height))

# 旋转
rotation_matrix = cv2.getRotationMatrix2D((center_x, center_y), angle, scale) 
# 旋转的中心点坐标（以图像像素坐标系为参考，原点 (0, 0) 在左上角）（中心点center = (img.shape[1] // 2, img.shape[0] // 2)）
# 旋转角度，正值表示逆时针旋转
# 缩放倍数
rotated_image = cv2.warpAffine(image, rotation_matrix, (width, height))

# 平移
translation_matrix = np.float32([[1, 0, tx], [0, 1, ty]])  # 向右平移 tx 像素，向下平移 ty 像素
translated_image = cv2.warpAffine(image, translation_matrix, (width, height))

# 翻转
flipped_image = cv2.flip(image, flip_code)  # flip_code: 0 (垂直翻转), 1 (水平翻转), -1 (双向翻转)

# 1、图像加法
result = cv2.add(image1, image2)

# 2、图像减法
result = cv2.subtract(image1, image2)

# 3、图像混合
result = cv2.addWeighted(image1, alpha, image2, beta, gamma)
# alpha 和 beta 是权重，gamma 是标量值。

# 位与运算
result = cv2.bitwise_and(img1, img2)

# 位或运算
result = cv2.bitwise_or(img1, img2)

# 位非运算
result = cv2.bitwise_not(img1)

# 位异或运算
result = cv2.bitwise_xor(img1, img2)

1、简单阈值处理
ret, thresholded_image = cv2.threshold(image, thresh, maxval, cv2.THRESH_BINARY)
# thresh 是阈值，maxval 是最大值

2、自适应阈值处理
thresholded_image = cv2.adaptiveThreshold(image, maxval, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, block_size, C)

3、Otsu 二值化
ret, thresholded_image = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)# 自动计算最佳全局阈值（适用于双峰直方图图像）

# 1、均值滤波
blurred_image = cv2.blur(image, (kernel_size, kernel_size))

# 2、高斯滤波
blurred_image = cv2.GaussianBlur(image, (kernel_size, kernel_size), sigmaX)

# 3、中值滤波
blurred_image = cv2.medianBlur(image, kernel_size)

# 4、双边滤波
blurred_image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)

# 从 RGB 转换为灰度图：
gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 从 BGR 转换为 HSV：
hsv_img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)

# 从 RGB 转换为 YUV：
yuv_img = cv2.cvtColor(img, cv2.COLOR_BGR2YUV)

import cv2

img = cv2.imread('image.jpg')
cv2.putText(img, 'Hello, OpenCV!', (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
cv2.imshow('Text', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

# Canny 边缘检测：
edges = cv2.Canny(img, 100, 200)
# Canny 算法通过对图像进行梯度计算来找出边缘，返回一个二值图像，边缘处为白色，其他区域为黑色
# 低阈值过低：导致噪声被误检为边缘
# 高阈值过高：导致真实边缘丢失

# Sobel 算子：
sobel_x = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=5)
sobel_y = cv2.Sobel(image, cv2.CV_64F, 0, 1, ksize=5)
sobel_y_abs = cv2.convertScaleAbs(sobel_y)
sobel_x_abs = cv2.convertScaleAbs(sobel_x)
# 合并梯度（加权平均）
grad_combined = cv2.addWeighted(grad_x_abs, 0.5, grad_y_abs, 0.5, 0)

# Laplacian 算子：
laplacian = cv2.Laplacian(image, cv2.CV_64F)
laplacian_abs = cv2.convertScaleAbs(laplacian)
# 显示结果
cv2.imshow('Laplacian Edges', laplacian_abs)


# 滑动条交互式调整阈值，观察边缘检测效果
import cv2
import numpy as np

def nothing(x):
    pass

img = cv2.imread(r"C:\Users\LENOVO\Pictures\Saved Pictures\1679907039016722.jpg", cv2.IMREAD_GRAYSCALE)
cv2.namedWindow('Canny Demo')
cv2.createTrackbar('Threshold1', 'Canny Demo', 0, 255, nothing)
cv2.createTrackbar('Threshold2', 'Canny Demo', 0, 255, nothing)

while True:
    t1 = cv2.getTrackbarPos('Threshold1', 'Canny Demo')
    t2 = cv2.getTrackbarPos('Threshold2', 'Canny Demo')
    edges = cv2.Canny(img, t1, t2)
    cv2.imshow('Canny Demo', edges)
    if cv2.waitKey(1) == ord('q'):
        break
cv2.destroyAllWindows()

kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
# 腐蚀（Erosion）：将图像中的白色区域收缩
eroded_img = cv2.erode(img, kernel, iterations=1)

# 膨胀（Dilation）：将图像中的白色区域扩展
dilated_img = cv2.dilate(img, kernel, iterations=1)

# 开运算与闭运算：
# 开运算（先腐蚀再膨胀）：用于去除小物体
# 闭运算（先膨胀再腐蚀）：用于填补图像中的小孔洞
opening_img = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)
closing_img = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)

# 检测轮廓：
gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
_ , threshold_img = cv2.threshold(gray_img, 127, 255, cv2.THRESH_BINARY)
_ , contours= cv2.findContours(threshold_img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

for contour in contours:
    #面积
    area = cv2.contourArea(contour)
    print(f"Contour area: {area}")
    # 周长或弧长
    perimeter = cv2.arcLength(contour, True)
    print(f"Contour perimeter: {perimeter}")
    # 边界矩形
    x, y, w, h = cv2.boundingRect(contour)
    cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
    # 最小外接矩
    rect = cv2.minAreaRect(contour)
    box = cv2.boxPoints(rect)
    box = box.astype(int)
    cv2.drawContours(img, [box], 0, (0, 0, 255), 2)
    # 最小外接圆
    (x, y), radius = cv2.minEnclosingCircle(contour)
    center = (int(x), int(y))
    radius = int(radius)
    cv2.circle(img, center, radius, (255, 0, 0), 2)
    # 多边形近似轮廓
    epsilon = 0.01 * cv2.arcLength(contour, True)
    approx = cv2.approxPolyDP(contour, epsilon, True)
    cv2.drawContours(img, [approx], 0, (0, 255, 0), 2)

# 绘制轮廓：
cv2.drawContours(img, contours, -1, (0, 255, 0), 3)
cv2.imshow('Contours', img)

cv2.waitKey(0)
cv2.destroyAllWindows()


import cv2
import numpy as np
 
# 读取图像并二值化
image = cv2.imread('shapes.png', cv2.IMREAD_GRAYSCALE)
_, binary = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)

# 检测所有轮廓并建立层级关系
contours, hierarchy = cv2.findContours(
    binary, 
    cv2.RETR_TREE, 
    cv2.CHAIN_APPROX_SIMPLE
)
 
# 绘制轮廓（不同颜色区分层级）
result = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
for i, contour in enumerate(contours):
    color = (np.random.randint(0, 256), np.random.randint(0, 256), np.random.randint(0, 256))
    cv2.drawContours(result, contours, i, color, 2)
    # 打印层级信息
    h = hierarchy[0][i]
    print(f"Contour {i}: Parent={h[3]}, Children={h[2]}")
 
cv2.imshow('Hierarchical Contours', result)
cv2.waitKey(0)
cv2.destroyAllWindows()


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

# 读取图像
img = cv2.imread(r"C:\Users\LENOVO\Pictures\Saved Pictures\1679907039016722.jpg", cv2.IMREAD_GRAYSCALE)

# 计算直方图
hist = cv2.calcHist([img], [0], None, [256], [0, 256])

# 绘制直方图
plt.plot(hist)
plt.title('Grayscale Histogram')
plt.xlabel('Pixel Value')
plt.ylabel('Frequency')
plt.show()

# 直方图均衡化
equalized_image = cv2.equalizeHist(img)
# 显示结果
cv2.imshow("Equalized Image", equalized_image)

# 读取彩色图像
image = cv2.imread(r"C:\Users\LENOVO\Pictures\Saved Pictures\1679907039016722.jpg")

# 计算 BGR 各通道的直方图
colors = ('b', 'g', 'r')
for i, color in enumerate(colors):
    hist = cv2.calcHist([image], [i], None, [256], [0, 256])
    plt.plot(hist, color=color)

# 绘制直方图
plt.title("Color Histogram")
plt.xlabel("Pixel Intensity")
plt.ylabel("Pixel Count")
plt.show()

# 分离通道
b, g, r = cv2.split(image)

# 对每个通道进行直方图均衡化
b_eq = cv2.equalizeHist(b)
g_eq = cv2.equalizeHist(g)
r_eq = cv2.equalizeHist(r)

# 合并通道
equalized_image = cv2.merge([b_eq, g_eq, r_eq])

# 显示结果
cv2.imshow("Equalized Color Image", equalized_image)

cv2.waitKey(0)
cv2.destroyAllWindows()


# 读取并播放一个视频文件，同时允许用户通过按键（q）提前终止播放   waitKey 的延迟时间（毫秒）影响播放速度（1 表示尽可能快，25 约 40 FPS）

cap = cv2.VideoCapture('video.mp4') # 将 'video.mp4' 替换为 0 即可调用摄像头

# 检查视频是否成功打开
while cap.isOpened():
    ret, frame = cap.read() # ret：布尔值，表示是否成功读取帧。frame：当前帧的图像数据
    # 如果读取到最后一帧，退出循环
    if not ret:
        break
    # 处理每一帧,将帧转换为灰度图像
    gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    cv2.imshow('Gray Video', gray_frame)
    # 等待 1 毫秒，返回按键的 ASCII 码（若无按键则返回 -1）。& 0xFF：确保兼容 64 位系统（屏蔽高位字节）
    if cv2.waitKey(1) & 0xFF == ord('q'): 
        break
    
cap.release() # 释放视频捕获对象，关闭文件或摄像头连接，防止资源泄漏
cv2.destroyAllWindows()


cap = cv2.VideoCapture('example.mp4')

# 获取视频的帧率和尺寸
fps = int(cap.get(cv2.CAP_PROP_FPS))
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

# 创建 VideoWriter 对象，保存处理后的视频
fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter('output.avi', fourcc, fps, (width, height))

while True:
    ret, frame = cap.read()
    
    if not ret:
        break
    
    # 将帧转换为灰度图像
    gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    
    # 将灰度帧写入输出视频
    out.write(cv2.cvtColor(gray_frame, cv2.COLOR_GRAY2BGR))
    
    # 显示灰度帧
    cv2.imshow('Gray Video', gray_frame)
    
    delay = int(1000 / fps)         # 计算每帧延迟（毫秒）
    if cv2.waitKey(delay) & 0xFF == ord('q'):
        break

cap.release()
out.release()
cv2.destroyAllWindows()


import cv2

cap = cv2.VideoCapture('example.mp4')

# 读取第一帧
ret, prev_frame = cap.read()
prev_gray = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2GRAY)

while True:
    ret, frame = cap.read()
    
    if not ret:
        break
    
    # 将当前帧转换为灰度图像
    gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    
    # 计算当前帧与前一帧的差异
    frame_diff = cv2.absdiff(prev_gray, gray_frame)
    
    # 对差异图像进行二值化处理
    _, thresh = cv2.threshold(frame_diff, 30, 255, cv2.THRESH_BINARY)
    
    # 显示运动检测结果
    cv2.imshow('Motion Detection', thresh)
    
    # 更新前一帧
    prev_gray = gray_frame
    
    if cv2.waitKey(25) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()


import cv2
import numpy as np

# 读取视频
cap = cv2.VideoCapture('video.mp4')

# 读取第一帧
ret, frame = cap.read()

# 设置初始窗口 (x, y, width, height)
x, y, w, h = 300, 200, 100, 50
track_window = (x, y, w, h)

# 设置 ROI (Region of Interest)
roi = frame[y:y+h, x:x+w]

# 转换为 HSV 颜色空间
hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)

# 创建掩膜并计算直方图
mask = cv2.inRange(hsv_roi, np.array((0., 60., 32.)), np.array((180., 255., 255.)))
roi_hist = cv2.calcHist([hsv_roi], [0], mask, [180], [0, 180])
roi_hist = cv2.normalize(roi_hist, 0, 255, cv2.NORM_MINMAX)

# 设置终止条件
term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) # 最大迭代次数 10。窗口中心移动的最小阈值 1 像素

while True:
    ret, frame = cap.read()
    if not ret:
        break

    # 转换为 HSV 颜色空间
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

    # 计算反向投影
    dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1)

    # 应用 MeanShift 算法
    ret, track_window = cv2.meanShift(dst, track_window, term_crit)

    # 绘制跟踪结果
    x, y, w, h = track_window
    img2 = cv2.rectangle(frame, (x, y), (x+w, y+h), 255, 2)
    cv2.imshow('MeanShift Tracking', img2)

    if cv2.waitKey(30) & 0xFF == 27:
        break

cap.release()
cv2.destroyAllWindows()


import cv2
import numpy as np

# 读取视频
cap = cv2.VideoCapture('video.mp4')

# 读取第一帧
ret, frame = cap.read()

# 设置初始窗口 (x, y, width, height)
x, y, w, h = 300, 200, 100, 50
track_window = (x, y, w, h)

# 设置 ROI (Region of Interest)
roi = frame[y:y+h, x:x+w]

# 转换为 HSV 颜色空间
hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)

# 创建掩膜并计算直方图
mask = cv2.inRange(hsv_roi, np.array((0., 60., 32.)), np.array((180., 255., 255.)))
roi_hist = cv2.calcHist([hsv_roi], [0], mask, [180], [0, 180])
cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX)

# 设置终止条件
term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1)

while True:
    ret, frame = cap.read()
    if not ret:
        break

    # 转换为 HSV 颜色空间
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

    # 计算反向投影
    dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1)

    # 应用 CamShift 算法
    ret, track_window = cv2.CamShift(dst, track_window, term_crit)

    # 绘制跟踪结果
    pts = cv2.boxPoints(ret)
    pts = np.int0(pts)
    img2 = cv2.polylines(frame, [pts], True, 255, 2)
    cv2.imshow('CamShift Tracking', img2)

    if cv2.waitKey(30) & 0xFF == 27:
        break

cap.release()
cv2.destroyAllWindows()


import cv2

# 创建 MOG 背景减除器
mog = cv2.bgsegm.createBackgroundSubtractorMOG()

# 读取视频
cap = cv2.VideoCapture('video.mp4')

while True:
    ret, frame = cap.read()
    if not ret:
        break

    # 应用背景减除
    fg_mask = mog.apply(frame)

    # 显示结果
    cv2.imshow('Frame', frame)
    cv2.imshow('FG Mask', fg_mask)

    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()


import cv2

# 创建 MOG2 背景减除器
mog2 = cv2.createBackgroundSubtractorMOG2()

# 读取视频
cap = cv2.VideoCapture('video.mp4')

while True:
    ret, frame = cap.read()
    if not ret:
        break

    # 应用背景减除
    fg_mask = mog2.apply(frame)

    # 显示结果
    cv2.imshow('Frame', frame)
    cv2.imshow('FG Mask', fg_mask)

    if cv2.waitKey(30) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

objects = classifier.detectMultiScale(
    image,              # 输入图像  必须是灰度图   
    scaleFactor=None,   # （可选）：图像缩放比例（默认 1.1）。值越小，检测越精细（但计算量更大）
    minNeighbors=None,  # （可选）：控制检测质量的参数（默认 3）。值越大，假阳性越少，但可能漏检 
    minSize=None,       # （可选）：对象的最小尺寸  如 (30, 30)
    maxSize=None        # （可选）：对象的最大尺寸
)


import cv2

# 加载 Haar 特征分类器
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

# 读取图像
image = cv2.imread('image.jpg')

# 转换为灰度图像
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 进行人脸检测
faces = face_cascade.detectMultiScale(gray_image, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

# 绘制检测结果
for (x, y, w, h) in faces:
    cv2.rectangle(image, (x, y), (x+w, y+h), (255, 0, 0), 2)

# 显示结果
cv2.imshow('Detected Faces', image)
cv2.waitKey(0)
cv2.destroyAllWindows()


import cv2

# 加载 Haar 特征分类器
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

cap = cv2.VideoCapture('example.mp4')

while True:
    ret, frame = cap.read()
    
    if not ret:
        break
    
    # 将帧转换为灰度图像
    gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    
    # 检测人脸
    faces = face_cascade.detectMultiScale(gray_frame, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
    
    # 在帧上绘制矩形框标记人脸
    for (x, y, w, h) in faces:
        cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2)
    
    # 显示带有人脸标记的帧
    cv2.imshow('Face Detection', frame)
    
    if cv2.waitKey(25) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()


import cv2
import numpy as np

# 加载目标图像和模板图像
img = cv2.imread('target_image.jpg', 0)
template = cv2.imread('template_image.jpg', 0)

# 获取模板图像的尺寸
w, h = template.shape[::-1]

# 进行模板匹配
res = cv2.matchTemplate(img, template, cv2.TM_CCOEFF_NORMED)

# 获取最佳匹配位置
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)
top_left = max_loc  # 使用TM_CCOEFF_NORMED时取最大值位置，若使用 TM_SQDIFF 或 TM_SQDIFF_NORMED，最小值位置（min_loc）为最佳匹配

# 绘制矩形框标注匹配区域
bottom_right = (top_left[0] + w, top_left[1] + h)
cv2.rectangle(img, top_left, bottom_right, 255, 2)

# 显示结果图像
cv2.imshow('Matched Image', img)
cv2.waitKey(0)
cv2.destroyAllWindows()


import cv2
import numpy as np

# 加载目标图像和模板图像
img = cv2.imread('target_image.jpg', 0)
template = cv2.imread('template_image.jpg', 0)

# 获取模板图像的尺寸
w, h = template.shape[::-1]

# 进行模板匹配
res = cv2.matchTemplate(img, template, cv2.TM_CCOEFF_NORMED)

# 设置匹配阈值
threshold = 0.8

# 找到匹配位置
loc = np.where(res >= threshold)

# 在目标图像中标记匹配位置
for pt in zip(*loc[::-1]):
    cv2.rectangle(img, pt, (pt[0] + w, pt[1] + h), (0, 255, 0), 2)

# 显示结果图像
cv2.imshow('Matched Image', img)
cv2.waitKey(0)
cv2.destroyAllWindows()


import cv2
import numpy as np

# 1. 加载图像
image1 = cv2.imread(r"C:\Users\LENOVO\Pictures\Saved Pictures\1679907039016722.jpg")

# 2. 转换为灰度图
gray1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)

# 3. 特征点检测
sift = cv2.SIFT_create()
keypoints1, descriptors1 = sift.detectAndCompute(gray1, None)
# detectAndCompute() 函数会返回两个值：关键点（keypoints）和描述符（descriptors）。
# 关键点是图像中的显著点，描述符是对这些关键点的描述，用于后续的匹配。

# 绘制关键点
output_image = cv2.drawKeypoints(image1, keypoints1, None, flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
 
# 显示结果
cv2.imshow('SIFT Features', output_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

surf = cv2.xfeatures2d.SURF_create(
    hessianThreshold=400,  # Hessian阈值，控制关键点数量（值越高，关键点越少）
    nOctaves=4,           # 金字塔组数（默认4）
    nOctaveLayers=3,      # 每组金字塔的层数（默认3）
    extended=False,       # 是否使用扩展描述符（128维，默认64维）
    upright=False         # 是否禁用旋转不变性（True=更快，False=更准确）
)

orb = cv2.ORB_create(
    nfeatures=500,        # 保留的最佳特征数量（默认500）值越小速度越快但可能丢失重要特征
    scaleFactor=1.2,      # 金字塔缩放因子（默认1.2）值越大金字塔层数越少，速度越快但对尺度变化更敏感
    nlevels=8,            # 金字塔层数（默认8）
    edgeThreshold=31,     # 边缘阈值（默认31）
    firstLevel=0,         # 金字塔起始层（默认0）
    WTA_K=2,             # BRIEF描述符的采样点数（2或3）
    scoreType=cv2.ORB_HARRIS_SCORE,  # 关键点评分方式（HARRIS_SCORE或FAST_SCORE）
    patchSize=31          # BRIEF描述符的补丁大小（默认31）
)


import cv2
import numpy as np

# 1. 加载图像
image1 = cv2.imread("path/to/image1.jpg")
image2 = cv2.imread("path/to/image2.jpg")

# 2. 转换为灰度图
gray1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
gray2 = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)

# 3. 特征点检测
sift = cv2.SIFT_create()
keypoints1, descriptors1 = sift.detectAndCompute(gray1, None)
keypoints2, descriptors2 = sift.detectAndCompute(gray2, None)

# 4. 特征点匹配
matcher = cv2.BFMatcher()
matches = matcher.knnMatch(descriptors1, descriptors2, k=2)

# 5. 应用比率测试，筛选匹配点
good_matches = []
for m, n in matches:
    if m.distance < 0.75 * n.distance:
        good_matches.append(m)

# 6. 计算单应性矩阵
if len(good_matches) > 10:
    src_pts = np.float32([keypoints1[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)
    dst_pts = np.float32([keypoints2[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)
    H, _ = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0) # findHomography() 函数会返回一个 3x3 的单应性矩阵 H，它可以将 image1 中的点映射到 image2 中
else:
    print("Not enough matches found.")
    exit()

# 7. 图像变换
height1, width1 = image1.shape[:2]
height2, width2 = image2.shape[:2]
warped_image = cv2.warpPerspective(image1, H, (width1 + width2, height1))

# 8. 图像拼接
warped_image[0:height2, 0:width2] = image2

# 9. 显示结果
cv2.imshow("Stitched Image", warped_image)
cv2.waitKey(0)
cv2.destroyAllWindows()


## 怀旧滤镜
import cv2
import numpy as np

# 读取图像
image = cv2.imread('input.jpg')

# 分离 BGR 通道
b, g, r = cv2.split(image)

# 调整通道强度  增加红色和绿色通道的强度，同时减少蓝色通道的强度
r = np.clip(r * 0.393 + g * 0.769 + b * 0.189, 0, 255).astype(np.uint8)
g = np.clip(r * 0.349 + g * 0.686 + b * 0.168, 0, 255).astype(np.uint8)
b = np.clip(r * 0.272 + g * 0.534 + b * 0.131, 0, 255).astype(np.uint8)

# 合并通道
vintage_image = cv2.merge((b, g, r))

# 保存怀旧图像
cv2.imwrite('vintage_output.jpg', vintage_image)

# 显示怀旧图像
cv2.imshow('Vintage Image', vintage_image)
cv2.waitKey(0)
cv2.destroyAllWindows()


## 浮雕滤镜
import cv2
import numpy as np

# 读取图像
image = cv2.imread('input.jpg')

# 转换为灰度图像
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 定义卷积核
kernel = np.array([[-2, -1, 0],
                   [-1,  1, 1],
                   [ 0,  1, 2]])

# 应用卷积核
emboss_image = cv2.filter2D(gray_image, -1, kernel)

# 保存浮雕图像
cv2.imwrite('emboss_output.jpg', emboss_image)

# 显示浮雕图像
cv2.imshow('Emboss Image', emboss_image)
cv2.waitKey(0)
cv2.destroyAllWindows()


## 锐化滤镜
import cv2
import numpy as np

# 读取图像
image = cv2.imread("path/to/image.jpg")

# 锐化滤镜
sharpen_kernel = np.array([[0, -1, 0],
                           [-1, 5, -1],
                           [0, -1, 0]])
sharpened_image = cv2.filter2D(image, -1, sharpen_kernel)

# 显示结果
cv2.imshow("Sharpen Filter", sharpened_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

功能	函数	说明
计算直方图	cv2.calcHist()	计算图像的直方图
直方图均衡化	cv2.equalizeHist()	增强图像的对比度
直方图比较	cv2.compareHist()	比较两个直方图的相似度

计算方法	说明	匹配度
cv2.TM_SQDIFF	平方差匹配	值越小匹配度越高
cv2.TM_SQDIFF_NORMED	归一化平方差匹配，对光照变化更鲁棒
cv2.TM_CCORR	相关匹配，计算模板与图像的乘积和	值越大匹配度越高
cv2.TM_CCORR_NORMED	归一化相关匹配，消除亮度影响
cv2.TM_CCOEFF	相关系数匹配	值越大匹配度越高
cv2.TM_CCOEFF_NORMED	归一化相关系数匹配，对光照和对比度变化更鲁棒（推荐）

基础模块¶

图像处理基础¶

基本操作¶

imread()¶

imshow()¶

imwrite()¶

destroyAllWindows()¶

split()¶

merge()¶

图像缩放、旋转、平移、翻转¶

resize()¶

getRotationMatrix2D()¶

warpAffine()¶

flip()¶

图像算术运算¶

add()¶

subtract()¶

multiply()¶

devide()¶

addWeighted()¶

图像位运算¶

cv2.bitwise_and()¶

cv2.bitwise_or()¶

cv2.bitwise_not()¶

cv2.bitwise_xor() 按位异或¶

图像阈值处理¶

threshold()¶

adaptiveThreshold()¶

图像平滑处理¶

blur() 或 boxFilter()¶

GaussianBlur()¶

medianBlur()¶

bilateralFilter()¶

图像的颜色空间与转换¶

cvtColor()¶

图像文本¶

putText()¶

图像边缘检测¶

Canny()¶

Sobel()¶

Laplacian()¶

Scharr()¶

形态学操作¶

getStructuringElement()¶

erode()¶

dilate()¶

morphologyEx()¶

图像轮廓检测¶

findContours()¶

drawContours()¶

contourArea()¶

arcLength()¶

boundingRect()¶

minAreaRect()¶

minEnclosingCircle()¶

approxPolyDP()¶

图像直方图¶

calcHist()¶

equalizeHist()¶

normalize()¶

compareHist()¶

视频处理¶

VideoCapture()¶

VideoWriter()¶

cap.isOpened()¶

cap.read()¶

cap.get(propId)¶

TrackerKCF_create()¶

createBackgroundSubtractorMOG2()¶

运动检测¶

视频目标跟踪¶

meanShift()¶

CamShift()¶

视频背景减除¶

bgsegm.createBackgroundSubtractorMOG()¶

createBackgroundSubtractorMOG2()¶

物体检测¶

CascadeClassifier()¶

物体识别¶

matchTemplate()¶