Python图像处理必备技巧分享

import cv2
from PIL import Image
import matplotlib.pyplot as plt

# OpenCV读取与保存
img_cv = cv2.imread('image.jpg')  # BGR格式
cv2.imwrite('output.jpg', img_cv)

# Pillow读取与保存
img_pil = Image.open('image.jpg')
img_pil.save('output.jpg')

# Matplotlib读取与显示
img_plt = plt.imread('image.jpg')
plt.imshow(img_plt)

# BGR转RGB
img_rgb = cv2.cvtColor(img_cv, cv2.COLOR_BGR2RGB)

# BGR转灰度
img_gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)

# RGB转HSV
import numpy as np
hsv_img = cv2.cvtColor(img_cv, cv2.COLOR_BGR2HSV)

# 裁剪
cropped = img_cv[100:300, 200:400]  # 裁剪[y1:y2, x1:x2]

# 调整大小
resized = cv2.resize(img_cv, (500, 300))  # 指定宽高
resized = cv2.resize(img_cv, None, fx=0.5, fy=0.5)  # 按比例缩放

# 旋转
rows, cols = img_cv.shape[:2]
M = cv2.getRotationMatrix2D((cols/2, rows/2), 90, 1)
rotated = cv2.warpAffine(img_cv, M, (cols, rows))

# 高斯模糊
blur = cv2.GaussianBlur(img_cv, (5, 5), 0)

# 中值滤波（适用于椒盐噪声）
median = cv2.medianBlur(img_cv, 5)

# 双边滤波（保留边缘）
bilateral = cv2.bilateralFilter(img_cv, 9, 75, 75)

# Canny边缘检测
edges = cv2.Canny(img_gray, 100, 200)

# Sobel边缘检测
sobelx = cv2.Sobel(img_gray, cv2.CV_64F, 1, 0, ksize=3)
sobely = cv2.Sobel(img_gray, cv2.CV_64F, 0, 1, ksize=3)
edges = np.sqrt(sobelx**2 + sobely**2)

# 简单阈值
ret, thresh = cv2.threshold(img_gray, 127, 255, cv2.THRESH_BINARY)

# 自适应阈值
thresh = cv2.adaptiveThreshold(img_gray, 255, 
                               cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                               cv2.THRESH_BINARY, 11, 2)

# Otsu阈值
ret, thresh = cv2.threshold(img_gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

# 定义结构元素
kernel = np.ones((5,5), np.uint8)

# 腐蚀
erosion = cv2.erode(img_gray, kernel, iterations=1)

# 膨胀
dilation = cv2.dilate(img_gray, kernel, iterations=1)

# 开运算（先腐蚀后膨胀）
opening = cv2.morphologyEx(img_gray, cv2.MORPH_OPEN, kernel)

# 闭运算（先膨胀后腐蚀）
closing = cv2.morphologyEx(img_gray, cv2.MORPH_CLOSE, kernel)

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

# 直方图均衡化
equ = cv2.equalizeHist(img_gray)

# 自适应直方图均衡化
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
cl1 = clahe.apply(img_gray)

# ORB特征检测
orb = cv2.ORB_create()
keypoints, descriptors = orb.detectAndCompute(img_gray, None)

# 绘制关键点
img_kp = cv2.drawKeypoints(img_gray, keypoints, None, color=(0,255,0), flags=0)

# SIFT特征检测（需要安装opencv-contrib-python）
sift = cv2.SIFT_create()
keypoints, descriptors = sift.detectAndCompute(img_gray, None)

# 特征匹配
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
matches = bf.match(des1, des2)
matches = sorted(matches, key=lambda x: x.distance)

# 单应性矩阵估计与图像配准
src_pts = np.float32([ kp1[m.queryIdx].pt for m in matches ]).reshape(-1,1,2)
dst_pts = np.float32([ kp2[m.trainIdx].pt for m in matches ]).reshape(-1,1,2)
H, _ = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
aligned = cv2.warpPerspective(img1, H, (img2.shape[1], img2.shape[0]))

# 轮廓检测
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

# 绘制轮廓
img_contours = img_cv.copy()
cv2.drawContours(img_contours, contours, -1, (0,255,0), 3)

# 轮廓分析
cnt = contours[0]
area = cv2.contourArea(cnt)
perimeter = cv2.arcLength(cnt, True)

# GrabCut分割
mask = np.zeros(img_cv.shape[:2], np.uint8)
bgdModel = np.zeros((1,65), np.float64)
fgdModel = np.zeros((1,65), np.float64)
rect = (50,50,450,290)  # ROI区域
cv2.grabCut(img_cv, mask, rect, bgdModel, fgdModel, 5, cv2.GC_INIT_WITH_RECT)
mask2 = np.where((mask==2)|(mask==0),0,1).astype('uint8')
img_seg = img_cv*mask2[:,:,np.newaxis]

# Watershed分割
ret, thresh = cv2.threshold(img_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)
unknown = cv2.subtract(sure_bg, sure_fg)

template = cv2.imread('template.jpg', 0)
h, w = template.shape[:2]

# 模板匹配
res = cv2.matchTemplate(img_gray, template, cv2.TM_CCOEFF_NORMED)
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)

# 获取匹配位置并绘制矩形
top_left = max_loc
bottom_right = (top_left[0] + w, top_left[1] + h)
cv2.rectangle(img_cv, top_left, bottom_right, 255, 2)

# 透 视变换
pts1 = np.float32([[56,65],[368,52],[28,387],[389,390]])
pts2 = np.float32([[0,0],[300,0],[0,300],[300,300]])
M = cv2.getPerspectiveTransform(pts1, pts2)
dst = cv2.warpPerspective(img_cv, M, (300, 300))

# 仿射变换
pts1 = np.float32([[50,50],[200,50],[50,200]])
pts2 = np.float32([[10,100],[200,50],[100,250]])
M = cv2.getAffineTransform(pts1, pts2)
dst = cv2.warpAffine(img_cv, M, (cols, rows))

# 傅里叶变换
f = np.fft.fft2(img_gray)
fshift = np.fft.fftshift(f)
magnitude_spectrum = 20*np.log(np.abs(fshift))

# 逆傅里叶变换
rows, cols = img_gray.shape
crow, ccol = rows//2, cols//2
fshift[crow-30:crow+30, ccol-30:ccol+30] = 0  # 低通滤波
f_ishift = np.fft.ifftshift(fshift)
img_back = np.fft.ifft2(f_ishift)
img_back = np.abs(img_back)