import numpy as np
import matplotlib.pyplot as plt from PIL
import Image

def image2array(image):
:param image: 图片
:return: 图片的数组

image = np.array(image)
return image

def array2image(arrimg):
:param arrimg: 图片的数组
:return: 图片

image = Image.fromarray(arrimg.astype(‘uint8’)).convert(‘RGB’)
return image
[

](https://blog.csdn.net/qq_43106863/article/details/103196747)

灰度化

输入：图，cv2.COLOR_BGR2GRAY（固定参数）
输出：灰度图
cv2.cvtColor()’, ‘最大值灰度化’,‘平均值灰度化’,‘Gamma校正灰度化
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

缩放

输入：图，灰度值
输出：灰度图
cv2.resize(src,dsize,fx=0,fy=0,interpolation=cv2.INTER_LINEAR)
cv2.INTER_LINEAR 双线性插值法
cv2.INTER_NEAREST 最近邻插值
cv2.INTER_AREA 像素区域重采样(默认)
cv2.INTER_CUBIC 双三次插值
cv2.INTER_LANCZ0S4 插值（超过8×8个邻域）

img1 = cv2.imread(“a.jpg”)
# 绝对尺寸
height,width = img1.shape[:2]
res = cv2.resize(img1,(2width,2height),interpolation=cv2.INTER_CUBIC)
# 相对尺寸
res1 = cv2.resize(img1,None,fx=0.3,fy=0.3)

旋转

输入：图，角度，缩放因子（一般为0.75）
输出：旋转图
rows, cols = img1.shape[:2]
# 这里(cols / 2, rows / 2)为旋转中心，60旋转角度，第三个为旋转后的缩放因子
# 可以通过设置旋转中心，缩放因子，以及窗口大小来防止旋转后超出边界的问题
M = cv2.getRotationMatrix2D((cols / 2, rows / 2), 60, 1)
dst2 = cv2.warpAffine(img1, M, (cols, rows))

翻转

输入：图，翻转模式code
输出：翻转图
cv2.flip(src, flipCode[, dst]) → dst1
flipCode – 翻转模式：
flipCode==0垂直翻转（沿X轴翻转）
flipCode>0水平翻转（沿Y轴翻转）
flipCode<0水平垂直翻转（先沿X轴翻转，再沿Y轴翻转，等价于旋转180°）

水平翻转
dst3 = cv2.flip(img1, 1)
# 垂直翻转
dst4 = cv2.flip(img1, 0)
# 水平垂直翻转
dst5 = cv2.flip(img1, -1)

仿射

输入：图，灰度值
输出：灰度图
仿射变换具体到图像中的应用，主要是对图像的缩放scale，
旋转rotate，剪切shear，翻转flip和平移translate的组合

pts1 = np.float32([[500,500],[2000,500],[500,2000]])
pts2 = np.float32([[100,1000],[2000,500],[1000,2500]])
M = cv2.getAffineTransform(pts1,pts2)
img2 = cv2.warpAffine(img1,M,(rows,cols))

透视

输入：图，灰度值
输出：灰度图
pts1 = np.float32([[200,200],[200,3000],[4800,200],[4800,3000]])
pts2 = np.float32([[200,200],[200,3000],[4800,600],[4800,2000]])
M = cv2.getPerspectiveTransform(pts1,pts2)
img3=cv2.warpPerspective(img1,M,(cols,rows),0.6)

平滑

输入：图，通带半径，类型
输出：滤波图
将代表了图像边缘、噪音或者变化陡峭的高频率成分滤除掉，只留下变化平缓的低频率成分，再由频域变换回时域，这就相当于对图像进行了平滑处理
def make_transform_matrix(image_arr, d0, ftype=’low’):

构建高斯高/低通滤波<br />    :param image_arr: 图像数组<br />    :param d0: 通带半径<br />    :param ftype: 类型<br />    :return: 滤波器<br />    <br />    # 构建滤波器<br />    transfor_matrix = np.zeros(image_arr.shape, dtype=np.float32)  <br />    w, h = image_arr.shape<br />    for i in range(w):<br />        for j in range(h):<br />            # 求距离公式<br />            distance = np.sqrt((i - w / 2) ** 2 + (j - h / 2) ** 2)<br />            # Gaussian滤波函数<br />            transfor_matrix[i, j] = np.e ** (-1 * (distance ** 2 / (2 * d0 ** 2)))  <br />    if ftype == 'low':<br />        return transfor_matrix<br />    elif ftype == 'high':<br />        return 1 - transfor_matrix

图像灰度化
img_arr = np.array(Image.open(‘a.jpg’).convert(‘L’))

将图像从空间域转换到频率域，傅里叶变换
f = np.fft.fft2(img_arr)
fshift = np.fft.fftshift(f)

生成低通滤波器
F_filter1 = make_transform_matrix(img_arr, 30, ‘low’)
# 滤波
result = fshift * F_filter1
# 将图像从频率域转换到空间域，傅里叶反变换
img_d1 = np.abs(np.fft.ifft2(np.fft.ifftshift(result)))

锐化

输入：图，通带半径，类型
输出：滤波图
滤去低频率成分，只留下高频率成分，就相当于对图像进行了锐化处理

伽马变换

输入：图，伽马值
输出：伽马变换图
def image_gamma_transform(pil_im, gamma):

伽马变换
:param pil_im: 图片
:return: 处理后的图片

image_arr = np.array(pil_im)
image_arr2 = exposure.adjust_gamma(image_arr, gamma)
return array2image(image_arr2)

def image_gamma_transform2(pil_im, gamma):

伽马变换2（源码实现)
:param pil_im: 图片
:return: 处理后的图片

image_arr = np.array(pil_im)
image_arr2 = np.power(image_arr / float(np.max(image_arr)), gamma)
return array2image(image_arr2*float(np.max(image_arr)))

对数增强

输入：图
输出：对数增强图
def image_log_transform(pil_im):

图像对数增强
:param pil_im: 图片
:return: 处理后的图片

image_arr = image2array(pil_im)
if len(image_arr.shape) == 3:
for i in range(3):
image_arr[:,:,i] = 255/np.log(255+1)np.log(1+image_arr[:,:,i])
return array2image(image_arr)
elif len(image_arr.shape) == 2:
# image_arr = 255/np.log(np.max(image_arr)+1)np.log(1+image_arr)
image_arr = 255/np.log(255+1)*np.log(1+image_arr)
return array2image(image_arr)

直方图

输入：图
输出：直方图
def image_histeq(pil_im):

直方图均衡化
:param pil_im: 图片
:return: 处理后的图片

# 计算图像的直方图
image_arr = image2array(pil_im)
imhist, bins = np.histogram(image_arr.flatten(), 256, normed=True)
cdf = imhist.cumsum() # 累计分布函数
cdf = 255*cdf/cdf[-1] # 归一化
# 使用累计分布函数的线性插值计算新的像素值
image_arr2 = np.interp(image_arr.flatten(), bins[:-1], cdf)
return array2image(image_arr2.reshape(image_arr.shape))

均值滤波

输入：图
输出：均值滤波图
def image_mean_filter(pil_im):

均值滤波
:param pil_im: 图片
:return: 处理后的图片

image_arr = image2array(pil_im)
dst_arr = np.zeros_like(image_arr)
# 卷积核-均值算子
mean_operator = np.array([[1, 1, 1],
[1, 1, 1],
[1, 1, 1]]) / 9
if len(image_arr.shape) == 3:
for i in range(3):
dst_arr[:, :, i] = convolve2d(image_arr[:, :, i], mean_operator, mode=”same”)
elif len(image_arr.shape) == 2:
dst_arr = convolve2d(image_arr, mean_operator, mode=”same”)

return array2image(dst_arr)

中值滤波

输入：图，sigma
输出：中值滤波图
def image_medium_filter(pil_im, sigma=5):

中值滤波
中值平滑只对特别尖锐的信号平滑
:param pil_im: 图片
:return: 处理后的图片

image_arr = image2array(pil_im)
if len(image_arr.shape) == 3:
for i in range(3):
image_arr[:,:,i] = filters.median_filter(image_arr[:,:,i], sigma)
return image_arr
elif len(image_arr.shape) == 2:
image_arr = filters.median_filter(image_arr, sigma)
return array2image(image_arr)

拉普拉斯算子

输入：图，sigma
输出：拉普拉斯算子增强图
def image_laplace_filter(pil_im,sigma):

拉普拉斯算子增强
sigma越大图像越模糊

image_arr = np.array(pil_im)
dst_arr = np.zeros(image_arr.shape, dtype=np.uint8)
filter_arr = dst_arr
# 卷积核-拉普拉斯算子
laplace_operator = np.array([[0, -1, 0],
[-1, 4, -1],
[0, -1, 0]])
if len(image_arr.shape) == 3:
for i in range(3):
dst_arr[:,:,i] = convolve2d(image_arr[:,:,i], laplace_operator, mode=”same”)
filter_arr[:,:,i] = filters.gaussian_filter(dst_arr[:,:,i], sigma)
elif len(image_arr.shape) == 2:
dst_arr = convolve2d(image_arr, laplace_operator, mode=”same”)
filter_arr = filters.gaussian_filter(dst_arr, sigma)
dst_arr = image_arr + filter_arr
dst_arr = dst_arr / 255.0
# 饱和处理
mask_1 = dst_arr < 0
mask_2 = dst_arr > 1
dst_arr = dst_arr (1-mask_1)
dst_arr = dst_arr (1-mask_2) + mask_2
return array2image(dst_arr*255)

图像去噪-cv2.blur()、cv2.medianBlur()、cv2.filter2D()、cv2.GuassianBlur()

形态学处理

腐蚀

腐蚀会把物体的边界腐蚀掉，卷积核沿着图象滑动，如果卷积核对应的原图的所有像素值为1，那么中心元素就保持原来的值，否则变为零。主要应用在去除白噪声，也可以断开连在一起的物体。

膨胀

卷积核所对应的原图像的像素值只要有一个是1，中心像素值就是1。一般在除噪是，先腐蚀再膨胀，因为腐蚀在去除白噪声的时候也会使图像缩小，所以我们之后要进行膨胀。当然也可以用来将两者物体分开。

开运算

开运算：先腐蚀后膨胀，用于移除由图像噪音形成的斑点。

闭运算

闭运算：先膨胀后腐蚀，用来连接被误分为许多小块的对象。

梯度

形态学梯度 = dilation - erosion，用于提取物体轮廓

顶帽

顶帽 = src - open，用来分离比邻近点亮一些的斑块
bitwiseXor_gray = cv2.bitwise_xor(gray_img,TOPHAT_img)
该算法可以图像识别的预处理，用于图像二值化后去除孤立点

黑帽

黑帽 = src - close，用来分离比邻近点暗一些的斑块

颜色处理

反色处理

import cv2 as cv

def access_pixels(image):
height, width, channels = image.shape
print(“width:%s,height:%s,channels:%s” % (width, height, channels))


for row in range(height):
for list in range(width):
for c in range(channels):
pv = image[row, list, c]
image[row, list, c] = 255 - pv
cv.imshow(“AfterDeal”, image)

src1 = cv.imread(“yanye.jpg”)
src = cv.resize(src1,(600,450),)
cv.imshow(‘OriginalImage’, src)

t1 = cv.getTickCount()
access_pixels(src)
t2 = cv.getTickCount()

print(“time cost:%s s” % ((t2 - t1) / cv.getTickFrequency()))
cv.waitKey()

伪彩色处理

import cv2
im_gray = cv2.imread(“H:/gdal/rs-data/result/ndvi.jpg”, cv2.IMREAD_GRAYSCALE)
im_color = cv2.applyColorMap(im_gray, cv2.COLORMAP_JET)
cv2.imwrite(‘H:/gdal/rs-data/result/ndvi_color.jpg’,im_color)

提取颜色

import cv2import numpy as np img = cv2.imread(‘c.png’) hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) lower_pink = np.array([160,20,20]) upper_pink = np.array([168,255,255]) mask = cv2.inRange(hsv, lower_pink, upper_pink) res = cv2.bitwise_and(img, img, mask= mask) cv2.imshow(‘frame’,img) cv2.imshow(‘mask’,mask) cv2.imshow(‘res’,res) cv2.waitKey(0) cv2.destroyAllWindows()