|
|
import math
|
|
|
|
|
|
import cv2
|
|
|
import numpy as np
|
|
|
|
|
|
####################灰度图和二值化########################################
|
|
|
|
|
|
|
|
|
|
|
|
def gray_picture(img):
|
|
|
img_gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
|
|
|
return img_gray
|
|
|
|
|
|
def erzhihua(image):
|
|
|
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
|
|
|
rst = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)
|
|
|
return rst[1]
|
|
|
|
|
|
##################加噪###########################################################
|
|
|
def add_noisy(image, snr): #椒盐彩色
|
|
|
result = image.copy()
|
|
|
size = result.size
|
|
|
n1= int(size*(1-snr))
|
|
|
print(n1)
|
|
|
w, h = image.shape[:2]
|
|
|
for i in range(n1):
|
|
|
# 宽和高的范围内生成一个随机值，模拟表x,y坐标
|
|
|
x = np.random.randint(1, w)
|
|
|
y = np.random.randint(1, h)
|
|
|
if np.random.randint(0, 2) == 0:
|
|
|
# 生成白色噪声（盐噪声）
|
|
|
result[x, y] = 0
|
|
|
else:
|
|
|
# 生成黑色噪声（椒噪声）
|
|
|
result[x, y] = 255
|
|
|
return result
|
|
|
|
|
|
"""
|
|
|
def add_noisy(image, n): #椒盐彩色
|
|
|
result = image.copy()
|
|
|
size = result.size
|
|
|
n= int(n)
|
|
|
w, h = image.shape[:2]
|
|
|
for i in range(n):
|
|
|
# 宽和高的范围内生成一个随机值，模拟表x,y坐标
|
|
|
x = np.random.randint(1, w)
|
|
|
y = np.random.randint(1, h)
|
|
|
if np.random.randint(0, 2) == 0:
|
|
|
# 生成白色噪声（盐噪声）
|
|
|
result[x, y] = 0
|
|
|
else:
|
|
|
# 生成黑色噪声（椒噪声）
|
|
|
result[x, y] = 255
|
|
|
return result
|
|
|
"""
|
|
|
|
|
|
####################彩色图像添加高斯噪声#######################################
|
|
|
"""
|
|
|
def add_noise(image,mean,var):
|
|
|
img = np.array(image / 255, dtype=float)
|
|
|
noise = np.random.normal(mean, var ** 0.5, img.shape)
|
|
|
out_img = img + noise
|
|
|
if out_img.min() < 0:
|
|
|
low_clip = -1
|
|
|
else:
|
|
|
low_clip = 0
|
|
|
out_img = np.clip(out_img, low_clip, 1.0)
|
|
|
out_img = out_img * 255
|
|
|
return out_img
|
|
|
"""
|
|
|
def add_noise(image, mean=0.0, var=0.1):
|
|
|
img = np.array(image / 255, dtype=float)
|
|
|
noise = np.random.normal(mean, var, image.shape)
|
|
|
out_img = img + noise
|
|
|
if out_img.min() < 0:
|
|
|
low_clip = -1.
|
|
|
else:
|
|
|
low_clip = 0.
|
|
|
gauss_noise = np.clip(out_img, low_clip, 1.0)
|
|
|
gauss_noise = np.uint8(out_img * 255)
|
|
|
return out_img
|
|
|
|
|
|
################图像锐化#####################
|
|
|
def lap_9(image): #拉普拉斯变化
|
|
|
lap_9 = np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]])
|
|
|
# 拉普拉斯9的锐化
|
|
|
image = cv2.filter2D(image, cv2.CV_8U, lap_9)
|
|
|
return image
|
|
|
|
|
|
def gama_transfer(img,power1=1.5): #伽马变化
|
|
|
if len(img.shape) == 3:
|
|
|
img= cv2.cvtColor(img,cv2.CV_8U)
|
|
|
img = 255*np.power(img/255,power1)
|
|
|
img = np.around(img)
|
|
|
img[img>255] = 255
|
|
|
out_img = img.astype(np.uint8)
|
|
|
return out_img
|
|
|
|
|
|
|
|
|
def get_imghist(img): #直方图均衡
|
|
|
# 判断图像是否为三通道；
|
|
|
if len(img.shape) == 3:
|
|
|
img = cv2.cvtColor(img, cv2.CV_8U)
|
|
|
# 无 Mask，256个bins,取值范围为[0,255]
|
|
|
hist = cv2.calcHist([img], [0], None, [256], [0, 255])
|
|
|
return hist
|
|
|
|
|
|
|
|
|
def cal_equalhist(img):
|
|
|
if len(img.shape) == 3:
|
|
|
img = cv2.cvtColor(img, cv2.CV_8U)
|
|
|
h, w = img.shape[:2]
|
|
|
grathist = get_imghist(img)
|
|
|
|
|
|
zerosumMoment = np.zeros([256], np.uint32)
|
|
|
for p in range(256):
|
|
|
if p == 0:
|
|
|
zerosumMoment[p] = grathist[0]
|
|
|
else:
|
|
|
zerosumMoment[p] = zerosumMoment[p - 1] + grathist[p]
|
|
|
|
|
|
output_q = np.zeros([256], np.uint8)
|
|
|
cofficient = 256.0 / (h * w)
|
|
|
for p in range(256):
|
|
|
q = cofficient * float(zerosumMoment[p]) - 1
|
|
|
if q >= 0:
|
|
|
output_q[p] = math.floor(q)
|
|
|
else:
|
|
|
output_q[p] = 0
|
|
|
|
|
|
equalhistimage = np.zeros(img.shape, np.uint8)
|
|
|
for i in range(h):
|
|
|
for j in range(w):
|
|
|
equalhistimage[i][j] = output_q[img[i][j]]
|
|
|
|
|
|
return equalhistimage
|
|
|
"""
|
|
|
img = cv2.imread('img.jpg',1)
|
|
|
(b,g,r) = cv2.split(img) #通道分解
|
|
|
bH = cv2.equalizeHist(b)
|
|
|
gH = cv2.equalizeHist(g)
|
|
|
rH = cv2.equalizeHist(r)
|
|
|
result = cv2.merge((bH,gH,rH),)#通道合成
|
|
|
res = np.hstack((img,result))
|
|
|
cv2.imshow('dst',res)
|
|
|
cv2.waitKey(0)
|
|
|
"""
|
|
|
################图像去噪####################################################
|
|
|
def boxFilterfun(image): #方波滤波
|
|
|
image=cv2.boxFilter(image,-1,(2,2),normalize=0)
|
|
|
return image
|
|
|
|
|
|
|
|
|
|
|
|
def medianBlurfun(image): #中值滤波
|
|
|
image=cv2.medianBlur(image,3)
|
|
|
return image
|
|
|
|
|
|
|
|
|
|
|
|
def bilateralFilterfun(image): #双边滤波
|
|
|
image=cv2.bilateralFilter(image,25,100,100)
|
|
|
return image
|
|
|
|
|
|
|
|
|
def GaussianBlurfun(image): #高斯滤波
|
|
|
image=cv2.GaussianBlur(image,(5,5),0,0)
|
|
|
return image
|
|
|
|
|
|
|
|
|
def blurfun(image): #均值滤波
|
|
|
image==cv2.blur(image,(5,5))
|
|
|
return image
|
|
|
|
|
|
|
|
|
###############图像翻转####################################################
|
|
|
def flipfun(image,x): #图像 水平翻转:0 垂直翻转:1 沿xy轴翻转:-1
|
|
|
image = cv2.flip(image,x)
|
|
|
return image
|
|
|
|
|
|
def fangsuo(image,x):
|
|
|
image = cv2.resize(image, (0, 0), fx=x, fy=x, interpolation=cv2.INTER_NEAREST)
|
|
|
return image
|
|
|
|
|
|
|
|
|
##############按位取反###################################################
|
|
|
def bitwise_notfun(image):
|
|
|
image = cv2.bitwise_not(image)
|
|
|
return image
|
|
|
|
|
|
|
|
|
##############轮廓检测####################################################
|
|
|
def morphologyExfun(image):
|
|
|
kernel = np.ones((3, 3), dtype=np.uint8)
|
|
|
image_gradient = cv2.morphologyEx(image, cv2.MORPH_GRADIENT, kernel)
|
|
|
return image_gradient
|
|
|
|
|
|
|
|
|
#############sift检测#######################################################
|
|
|
def sift_fun(image):
|
|
|
sift = cv2.SIFT_create()
|
|
|
kps = sift.detect(image)
|
|
|
image_sift = cv2.drawKeypoints(image, kps, None, -1, cv2.DrawMatchesFlags_DEFAULT)
|
|
|
return image_sift
|
|
|
|
|
|
|
|
|
##################平均值池化#################################################
|
|
|
def average_poolingfun(img, G=4):
|
|
|
out = img.copy()
|
|
|
H, W, C = img.shape
|
|
|
Nh = int(H / G)
|
|
|
Nw = int(W / G)
|
|
|
for y in range(Nh):
|
|
|
for x in range(Nw):
|
|
|
for c in range(C):
|
|
|
out[G * y:G * (y + 1), G * x:G * (x + 1), c] = np.mean(
|
|
|
out[G * y:G * (y + 1), G * x:G * (x + 1), c]).astype(np.int)
|
|
|
return out
|
|
|
|
|
|
##################################修复####
|
|
|
def xiufu(image):
|
|
|
_, mask1 = cv2.threshold(image, 245, 255, cv2.THRESH_BINARY)
|
|
|
k = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
|
|
|
mask1 = cv2.dilate(mask1, k)
|
|
|
result1 = cv2.inpaint(image, mask1[:, :, -1], 5, cv2.INPAINT_NS)
|
|
|
return result1
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
image = cv2.imread("inpaint2.jpg")
|
|
|
cv2.imshow(' ',image)
|
|
|
newimage=xiufu(image)
|
|
|
cv2.imshow(' ',newimage)
|
|
|
cv2.waitKey(0)
|
|
|
|
