万字长文告诉新手如何学习Python图像处理（上篇完结 四十四） | 「Python」有奖征文

# -*- coding: utf-8 -*-
# By:Eastmount CSDN
import cv2  
import numpy as np  
import matplotlib.pyplot as plt
#读取图像
img1 = cv2.imread('lena.png')
img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2RGB)
img2 = cv2.imread('people.png')
img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2RGB)
img3 = cv2.imread('flower.png')
img3 = cv2.cvtColor(img3, cv2.COLOR_BGR2RGB)
img4 = cv2.imread('scenery.png')
img4 = cv2.cvtColor(img4, cv2.COLOR_BGR2RGB)
#显示四张图像
titles = ['lena', 'people', 'flower', 'scenery']
images = [img1, img2, img3, img4]
for i in range(4):
plt.subplot(2, 2, i+1), plt.imshow(images[i], 'gray')
plt.title(titles[i])
plt.xticks([]),plt.yticks([])
plt.show()

# -*- coding: utf-8 -*-
# By:Eastmount CSDN
import cv2
import numpy as np
#创建黑色图像
img = np.zeros((512,512,3), np.uint8)
#(1)绘制直线：图像、起点坐标、终点坐标、颜色、粗细
cv2.line(img, (0,0), (512,512), (55,255,155), 5)
#(2)绘制矩形：图像、左上角坐标、右下角坐标、颜色、粗细
cv2.rectangle(img, (20,300), (350,450), (255,0,0), 2)
#(3)绘制圆形：图像、圆心坐标、半径、颜色、粗细\填充
cv2.circle(img, (400,400), 50, (255,255,0), -1)
#(4)绘制椭圆：图像、圆心坐标、长轴和短轴、偏转角度20
# 圆弧起始角的角度、圆弧终结角的角度、颜色、线条粗细
cv2.ellipse(img, (320, 100), (100, 50), 20, 0, 360, (255, 0, 255), 2)
#(5)绘制多边形：图像、多边形曲线阵列、是否闭合、颜色、粗细
pts = np.array([[10,80], [120,80], [120,200], [30,250]])
cv2.polylines(img, [pts], True, (255, 255, 255), 5)
#(6)绘制多边形
pts = np.array([[50, 190], [380, 420], [255, 50], [120, 420], [450, 190]])
cv2.polylines(img, [pts], True, (0, 255, 255), 1)
#(7)绘制文字
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(img, 'I love Python!!! By:Eatmount CSDN',
(10, 500), font, 0.6, (255, 255, 0), 2)
#显示图像
cv2.imshow("img", img)
#等待显示
cv2.waitKey(0)
cv2.destroyAllWindows()

# -*- coding:utf-8 -*-
# By: Eastmount CSDN 2021-08-19
import cv2
import numpy as np
#读取图片
img = cv2.imread("Lena.png")
rows, cols, chn = img.shape
print(rows, cols, chn)
cv2.imshow("img", img)
#(1)拆分通道
b, g, r = cv2.split(img)
cv2.imshow("B", b)
cv2.imshow("G", g)
cv2.imshow("R", r)
#(2)合并通道
m = cv2.merge([b, g, r])
cv2.imshow("Merge", m)
#(3)显示蓝色通道
b_ = cv2.split(img)[0]
g_ = np.zeros((rows,cols), dtype=img.dtype) #设置g、r通道为0
r_ = np.zeros((rows,cols), dtype=img.dtype)
m = cv2.merge([b_, g_, r_])
cv2.imshow("MergeBlue", m)
cv2.imwrite("MergeBlue.png", m)
#等待显示
cv2.waitKey(0)
cv2.destroyAllWindows()

# -*- coding:utf-8 -*-
# By: Eastmount CSDN 2021-08-19
import cv2  
import numpy as np
import matplotlib.pyplot as plt
#读取图片
src = cv2.imread("Lena.png")
#获取图像宽和高
rows, cols = src.shape[:2]
#BGR转换为RGB
img = cv2.cvtColor(src, cv2.COLOR_BGR2RGB)
#(1)OpenCV加法运算
m = np.ones(img.shape, dtype="uint8")*100 #图像各像素加100
result1 = cv2.add(img, m)
#(2)OpenCV减法运算
m = np.ones(img.shape, dtype="uint8")*50  #图像各像素减50
result2 = cv2.subtract(img, m)
#(3)画圆形
circle = np.zeros((rows, cols, 3), dtype="uint8")
cv2.circle(circle, (int(rows/2.0), int(cols/2)), 100, (255,0,0), -1)
print(circle.shape,img.size, circle.size)
#(4)OpenCV图像与运算
result4 = cv2.bitwise_and(img, circle)
#(5)OpenCV图像或运算
result5 = cv2.bitwise_or(img, circle)
#(6)OpenCV图像异或运算
result6 = cv2.bitwise_xor(img, circle)
#(7)OpenCV图像非运算
result7 = cv2.bitwise_not(img)
#解决中文显示问题
plt.rcParams['font.sans-serif'] = ['KaiTi']  #指定默认字体
plt.rcParams['axes.unicode_minus'] = False   #解决保存图像是负号
#显示九张图像
titles = ['原图', 'RGB', '加法', '减法', '圆形', '与运算', '或运算', '异或运算', '非运算']
images = [src, img, result1, result2, circle, result4, result5, result6, result7]
for i in range(9):
plt.subplot(3, 3, i+1), plt.imshow(images[i], 'gray')
plt.title(titles[i])
plt.xticks([]),plt.yticks([])
plt.show()

#encoding:utf-8
# By: Eastmount CSDN 2021-08-19
import cv2  
import numpy as np  
import matplotlib.pyplot as plt
#读取图片
src1 = cv2.imread('lena-hd.png')
src2 = cv2.imread('na.png')
src3 = cv2.imread("Lena.png")
print(src3.shape)
#图像融合
res1 = cv2.addWeighted(src1, 0.6, src2, 0.8, 10)
#显示ROI区域
face = np.ones((100, 100, 3)) #定义150×150矩阵 3对应BGR
face = src3[200:300, 180:280]
#显示ROI区域
res3 = src2.copy()
res3[150:250, 150:250] = face
#显示图像
cv2.imshow("src1", src1)
cv2.imshow("src2", src2)
cv2.imshow("src3", src3)
cv2.imshow("res1", res1)
cv2.imshow("res2", face)
cv2.imshow("res3", res3)
#等待显示
cv2.waitKey(0)
cv2.destroyAllWindows()

# -*- coding: utf-8 -*-
# By: Eastmount CSDN 2021-08-20
import cv2  
import numpy as np  
import matplotlib.pyplot as plt
#读取原始图像
img_BGR = cv2.imread('na.png')
#BGR转换为RGB
img_RGB = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2RGB)
#灰度化处理
img_GRAY = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2GRAY)
#BGR转HSV
img_HSV = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2HSV)
#BGR转YCrCb
img_YCrCb = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2YCrCb)
#BGR转HLS
img_HLS = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2HLS)
#BGR转XYZ
img_XYZ = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2XYZ)
#BGR转LAB
img_LAB = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2LAB)
#BGR转YUV
img_YUV = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2YUV)
#调用matplotlib显示处理结果
titles = ['BGR', 'RGB', 'GRAY', 'HSV', 'YCrCb', 'HLS', 'XYZ', 'LAB', 'YUV']  
images = [img_BGR, img_RGB, img_GRAY, img_HSV, img_YCrCb,
img_HLS, img_XYZ, img_LAB, img_YUV]  
for i in range(9):  
plt.subplot(3, 3, i+1), plt.imshow(images[i], 'gray')  
plt.title(titles[i])  
plt.xticks([]),plt.yticks([])  
plt.show()

#encoding:utf-8
#By:Eastmount CSDN 2021-08-20
import cv2  
import numpy as np
import matplotlib.pyplot as plt
#读取图片
img = cv2.imread('test.bmp')
image = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
#图像平移矩阵
M = np.float32([[1, 0, 100], [0, 1, 80]])
rows, cols = image.shape[:2]
img1 = cv2.warpAffine(image, M, (cols, rows))
#图像缩小
img2 = cv2.resize(image, (200,100))
#图像放大
img3 = cv2.resize(image, None, fx=1.1, fy=1.1)
#绕图像的中心旋转
#源图像的高、宽 以及通道数
rows, cols, channel = image.shape
#函数参数：旋转中心 旋转度数 scale
M = cv2.getRotationMatrix2D((cols/2, rows/2), 30, 1) 
#函数参数：原始图像 旋转参数 元素图像宽高
img4 = cv2.warpAffine(image, M, (cols, rows))
#图像翻转
img5 = cv2.flip(image, 0)   #参数=0以X轴为对称轴翻转 
img6 = cv2.flip(image, 1)   #参数>0以Y轴为对称轴翻转
#图像的仿射
pts1 = np.float32([[50,50],[200,50],[50,200]])
pts2 = np.float32([[10,100],[200,50],[100,250]])
M = cv2.getAffineTransform(pts1,pts2)
img7 = cv2.warpAffine(image, M, (rows,cols))
#图像的透射
pts1 = np.float32([[56,65],[238,52],[28,237],[239,240]])
pts2 = np.float32([[0,0],[200,0],[0,200],[200,200]])
M = cv2.getPerspectiveTransform(pts1,pts2)
img8 = cv2.warpPerspective(image,M,(200,200))
#循环显示图形
titles = [ 'source', 'shift', 'reduction', 'enlarge', 'rotation', 'flipX', 'flipY', 'affine', 'transmission']  
images = [image, img1, img2, img3, img4, img5, img6, img7, img8]  
for i in range(9):  
plt.subplot(3, 3, i+1), plt.imshow(images[i], 'gray')  
plt.title(titles[i])  
plt.xticks([]),plt.yticks([])  
plt.show()  

# -*- coding: utf-8 -*-
# BY:Eastmount CSDN 2021-08-20
import cv2  
import numpy as np  
import matplotlib.pyplot as plt
#读取原始图像
img = cv2.imread('lena-hd.png')
#获取图像高度和宽度
height = img.shape[0]
width = img.shape[1]
#创建一幅图像
new_img1 = np.zeros((height, width, 3), np.uint8)
new_img2 = np.zeros((height, width, 3), np.uint8)
new_img3 = np.zeros((height, width, 3), np.uint8)
#图像量化等级为2的量化处理
for i in range(height):
for j in range(width):
for k in range(3): #对应BGR三分量
if img[i, j][k] < 128:
gray = 0
else:
gray = 128
new_img1[i, j][k] = np.uint8(gray)
#图像量化等级为4的量化处理
for i in range(height):
for j in range(width):
for k in range(3): #对应BGR三分量
if img[i, j][k] < 64:
gray = 0
elif img[i, j][k] < 128:
gray = 64
elif img[i, j][k] < 192:
gray = 128
else:
gray = 192
new_img2[i, j][k] = np.uint8(gray)
#图像量化等级为8的量化处理
for i in range(height):
for j in range(width):
for k in range(3): #对应BGR三分量
if img[i, j][k] < 32:
gray = 0
elif img[i, j][k] < 64:
gray = 32
elif img[i, j][k] < 96:
gray = 64
elif img[i, j][k] < 128:
gray = 96
elif img[i, j][k] < 160:
gray = 128
elif img[i, j][k] < 192:
gray = 160
elif img[i, j][k] < 224:
gray = 192
else:
gray = 224
new_img3[i, j][k] = np.uint8(gray)
#用来正常显示中文标签
plt.rcParams['font.sans-serif']=['SimHei']
#显示图像
titles = ['(a) 原始图像', '(b) 量化-L2', '(c) 量化-L4', '(d) 量化-L8']  
images = [img, new_img1, new_img2, new_img3]  
for i in range(4):  
plt.subplot(2,2,i+1), plt.imshow(images[i], 'gray'), 
plt.title(titles[i])  
plt.xticks([]),plt.yticks([])  
plt.show()

# coding: utf-8
# BY:Eastmount CSDN 2021-08-20
import cv2
import numpy as np
import matplotlib.pyplot as plt
#读取原始图像
img = cv2.imread('nv.png') 
#图像二维像素转换为一维
data = img.reshape((-1,3))
data = np.float32(data)
#定义中心 (type,max_iter,epsilon)
criteria = (cv2.TERM_CRITERIA_EPS +
cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
#设置标签
flags = cv2.KMEANS_RANDOM_CENTERS
#K-Means聚类 聚集成4类
compactness, labels, centers = cv2.kmeans(data, 4, None, criteria, 10, flags)
#图像转换回uint8二维类型
centers = np.uint8(centers)
res = centers[labels.flatten()]
dst = res.reshape((img.shape))
#图像转换为RGB显示
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
dst = cv2.cvtColor(dst, cv2.COLOR_BGR2RGB)
#用来正常显示中文标签
plt.rcParams['font.sans-serif']=['SimHei']
#显示图像
titles = ['原始图像', '聚类量化 K=4']  
images = [img, dst]  
for i in range(2):  
plt.subplot(1,2,i+1), plt.imshow(images[i], 'gray'), 
plt.title(titles[i])  
plt.xticks([]),plt.yticks([])  
plt.show()

# -*- coding: utf-8 -*-
# BY:Eastmount CSDN 2021-08-20
import cv2  
import numpy as np  
import matplotlib.pyplot as plt
#读取原始图像
img = cv2.imread('scenery.png')
#获取图像高度和宽度
height = img.shape[0]
width = img.shape[1]
#采样转换成8*8区域
numHeight = int(height/8)
numwidth = int(width/8)
#创建一幅图像
new_img = np.zeros((height, width, 3), np.uint8)
#图像循环采样8*8区域
for i in range(8):
#获取Y坐标
y = i*numHeight
for j in range(8):
#获取X坐标
x = j*numwidth
#获取填充颜色 左上角像素点
b = img[y, x][0]
g = img[y, x][1]
r = img[y, x][2]
#循环设置小区域采样
for n in range(numHeight):
for m in range(numwidth):
new_img[y+n, x+m][0] = np.uint8(b)
new_img[y+n, x+m][1] = np.uint8(g)
new_img[y+n, x+m][2] = np.uint8(r)
#显示图像
cv2.imshow("src", img)
cv2.imshow("Sampling", new_img)
#等待显示
cv2.waitKey(0)
cv2.destroyAllWindows()

#encoding:utf-8
#By:Eastmount CSDN 2021-08-20
import cv2  
import numpy as np  
import matplotlib.pyplot as plt
#读取图像
img=cv2.imread('miao.png')
grayImage=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)  
#阈值化处理
ret,thresh1=cv2.threshold(grayImage,127,255,cv2.THRESH_BINARY)  
ret,thresh2=cv2.threshold(grayImage,127,255,cv2.THRESH_BINARY_INV)  
ret,thresh3=cv2.threshold(grayImage,127,255,cv2.THRESH_TRUNC)  
ret,thresh4=cv2.threshold(grayImage,127,255,cv2.THRESH_TOZERO)  
ret,thresh5=cv2.threshold(grayImage,127,255,cv2.THRESH_TOZERO_INV)
#显示结果
titles = ['Gray Image','BINARY','BINARY_INV','TRUNC','TOZERO','TOZERO_INV']  
images = [grayImage, thresh1, thresh2, thresh3, thresh4, thresh5]  
for i in range(6):  
plt.subplot(2,3,i+1),plt.imshow(images[i],'gray')  
plt.title(titles[i])  
plt.xticks([]),plt.yticks([])  
plt.show()

#encoding:utf-8
#By:Eastmount CSDN 2021-08-20
import cv2
import math
import numpy as np  
import matplotlib.pyplot as plt
#读取图像
img = cv2.imread('miao.png')
#图像灰度转换
grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#获取图像高度和宽度
height = grayImage.shape[0]
width = grayImage.shape[1]
#图像灰度上移变换 DB=DA+50
result1 = np.zeros((height, width), np.uint8)
for i in range(height):
for j in range(width):
if (int(grayImage[i,j]+50) > 255):
gray = 255
else:
gray = int(grayImage[i,j]+50)
result1[i,j] = np.uint8(gray)
#图像对比度增强变换 DB=DA*1.5
result2 = np.zeros((height, width), np.uint8)
for i in range(height):
for j in range(width):
if (int(grayImage[i,j]*1.5) > 255):
gray = 255
else:
gray = int(grayImage[i,j]*1.5)
result2[i,j] = np.uint8(gray)
#图像对比度增强变换 DB=DA*0.8
result3 = np.zeros((height, width), np.uint8)
for i in range(height):
for j in range(width):
if (int(grayImage[i,j]*0.8) > 255):
gray = 255
else:
gray = int(grayImage[i,j]*0.8)
result3[i,j] = np.uint8(gray)
#图像灰度反色变换 DB=255-DA
result4 = np.zeros((height, width), np.uint8)
for i in range(height):
for j in range(width):
gray = 255 - grayImage[i,j]
result4[i,j] = np.uint8(gray)
#图像灰度非线性变换：DB=DA×DA/255
result5 = np.zeros((height, width), np.uint8)
for i in range(height):
for j in range(width):
gray = int(grayImage[i,j])*int(grayImage[i,j]) / 255
result5[i,j] = np.uint8(gray)   
#图像灰度对数变换
result6 = np.zeros((height, width), np.uint8)
for i in range(height):
for j in range(width):
gray = 10* math.log(1 + grayImage[i, j])
result6[i,j] = np.uint8(gray)
#图像灰度伽玛变换
result7 = np.zeros((height, width), np.uint8)
for i in range(height):
for j in range(width):
gray = 3*pow(grayImage[i, j], 0.8)
if gray>255:
gray = 255
result7[i,j] = np.uint8(gray)
#用来正常显示中文标签
plt.rcParams['font.sans-serif']=['SimHei']
#显示结果
titles = [u'原始图像', u'灰度图像', u'图像拉伸', u'对比度增强', u'对比度减弱',
u'图像反色', u'非线性变换', u'对数变换', u'伽马变换']  
images = [img, grayImage, result1, result2, result3, result4, result5, result6, result7]  
for i in range(9):  
plt.subplot(3,3,i+1),plt.imshow(images[i],'gray')  
plt.title(titles[i])  
plt.xticks([]),plt.yticks([])  
plt.show()

#encoding:utf-8
#By:Eastmount CSDN 2021-08-20
import numpy as np
import matplotlib.pyplot as plt
import cv2
#绘制曲线
def gamma_plot(c, v):
x = np.arange(0, 256, 0.01)
y = c*x**v
plt.plot(x, y, 'r', linewidth=1)
plt.rcParams['font.sans-serif']=['SimHei'] #正常显示中文标签
plt.title('伽马变换函数')
plt.xlim([0, 255]), plt.ylim([0, 255])
plt.show()
#伽玛变换
def gamma(img, c, v):
lut = np.zeros(256, dtype=np.float32)
for i in range(256):
lut[i] = c * i ** v
output_img = cv2.LUT(img, lut) #像素灰度值的映射
output_img = np.uint8(output_img+0.5)  
return output_img
#读取原始图像
img = cv2.imread('2019.png')
#绘制伽玛变换曲线
gamma_plot(0.00000005, 4.0)
#图像灰度伽玛变换
output = gamma(img, 0.00000005, 4.0)
#显示图像
cv2.imshow('Imput', img)
cv2.imshow('Output', output)
cv2.waitKey(0)
cv2.destroyAllWindows()

#encoding:utf-8
#By:Eastmount CSDN 2021-08-20
import cv2  
import numpy as np
import matplotlib.pyplot as plt
#读取图片
src = cv2.imread('na.png', cv2.IMREAD_UNCHANGED)
img = cv2.cvtColor(src,cv2.COLOR_BGR2RGB)
# 转化为灰度图
Grayimg = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
# 1、消除椒盐噪声：
# 中值滤波器
median = cv2.medianBlur(Grayimg, 5)
# 消除噪声图
cv2.imshow("median-image", median)
# 2、直方图均衡化：
equalize = cv2.equalizeHist(median)
cv2.imshow('hist', equalize)
# 3、二值化处理：
# 阈值为140
ret, binary = cv2.threshold(equalize, 127, 255,cv2.THRESH_BINARY)
cv2.imshow("binary-image",binary)
cv2.waitKey(0)
#设置卷积核
kernel = np.ones((10,10), np.uint8)
close = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)
#图像开运算
kernel = np.ones((10,10), np.uint8) 
open1 = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)
#显示图像
cv2.imshow("src", src)
cv2.imshow("result", close)
#等待显示
cv2.waitKey(0)
cv2.destroyAllWindows()
#图像开运算
kernel = np.ones((10,10), np.uint8) 
gradient = cv2.morphologyEx(binary, cv2.MORPH_GRADIENT, kernel)
# Sobel算子 XY方向求梯度 cv2.CV_8U
x = cv2.Sobel(close, cv2.CV_32F, 1, 0, ksize = 3) #X方向
y = cv2.Sobel(close, cv2.CV_32F, 0, 1, ksize = 3) #Y方向
#absX = cv2.convertScaleAbs(x) # 转回uint8 
#absY = cv2.convertScaleAbs(y)
#Sobel = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)
gradient = cv2.subtract(x, y)
sobel = cv2.convertScaleAbs(gradient)
cv2.imshow('Sobel', sobel)
cv2.waitKey(0)
#循环显示图形
titles = [ 'source', 'gray', 'median', 'equalize', 'binary', 'close', 'open', 'gradient', 'sobel']  
images = [img, Grayimg, median, equalize, binary, close, open1, gradient, sobel]  
for i in range(9):  
plt.subplot(3, 3, i+1), plt.imshow(images[i], 'gray')  
plt.title(titles[i])  
plt.xticks([]),plt.yticks([])  
plt.show()  

#encoding:utf-8
#By:Eastmount CSDN 2021-08-20
import cv2  
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
#读取图像
src = cv2.imread('Lena.png')
#转换为RGB图像
img_rgb = cv2.cvtColor(src, cv2.COLOR_BGR2RGB)
#获取BGR三个通道的像素值
b, g, r = cv2.split(src)
print(r,g,b)
plt.figure(figsize=(8, 6))
#设置字体
matplotlib.rcParams['font.sans-serif']=['SimHei']
#原始图像
plt.subplot(221)
plt.imshow(img_rgb)
plt.axis('off')
plt.title("(a)原图像")
#绘制蓝色分量直方图
plt.subplot(222)
plt.hist(b.ravel(), bins=256, density=1, facecolor='b', edgecolor='b', alpha=0.75)
plt.xlabel("x")
plt.ylabel("y")
plt.title("(b)蓝色分量直方图")
#绘制绿色分量直方图
plt.subplot(223)
plt.hist(g.ravel(), bins=256, density=1, facecolor='g', edgecolor='g', alpha=0.75)
plt.xlabel("x")
plt.ylabel("y")
plt.title("(c)绿色分量直方图")
#绘制红色分量直方图
plt.subplot(224)
plt.hist(r.ravel(), bins=256, density=1, facecolor='r', edgecolor='r', alpha=0.75)
plt.xlabel("x")
plt.ylabel("y")
plt.title("(d)红色分量直方图")
plt.show()

#encoding:utf-8
#By:Eastmount CSDN 2021-08-20
import cv2  
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
#读取图像
src = cv2.imread('Lena.png')
#转换为RGB图像
img_rgb = cv2.cvtColor(src, cv2.COLOR_BGR2RGB)
#计算直方图
histb = cv2.calcHist([src], [0], None, [256], [0,255])
histg = cv2.calcHist([src], [1], None, [256], [0,255])
histr = cv2.calcHist([src], [2], None, [256], [0,255])
#设置字体
matplotlib.rcParams['font.sans-serif']=['SimHei']
#显示原始图像和绘制的直方图
plt.subplot(121)
plt.imshow(img_rgb, 'gray')
plt.axis('off')
plt.title("(a)Lena原始图像")
plt.subplot(122)
plt.plot(histb, color='b')
plt.plot(histg, color='g')
plt.plot(histr, color='r')
plt.xlabel("x")
plt.ylabel("y")
plt.title("(b)直方图曲线")
plt.show()

#encoding:utf-8
#By:Eastmount CSDN 2021-08-20
import cv2  
import numpy as np
import matplotlib.pyplot as plt
#读取图像
img = cv2.imread('lena-hd.png')
#图像灰度转换
grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#获取图像高度和宽度
height = grayImage.shape[0]
width = grayImage.shape[1]
result = np.zeros((height, width), np.uint8)
#图像灰度对数变换
for i in range(height):
for j in range(width):
gray = 42 * np.log(1.0 + grayImage[i,j])
result[i,j] = np.uint8(gray)
#计算原图的直方图
hist = cv2.calcHist([img], [0], None, [256], [0,255])
#计算灰度变换的直方图
hist_res = cv2.calcHist([result], [0], None, [256], [0,255])
#原始图像
plt.figure(figsize=(8, 6))
plt.subplot(221), plt.imshow(img, 'gray'), plt.title("(a)"), plt.axis('off')
#绘制原始图像直方图
plt.subplot(222), plt.plot(hist), plt.title("(b)"), plt.xlabel("x"), plt.ylabel("y")
#灰度变换后的图像
plt.subplot(223), plt.imshow(result, 'gray'), plt.title("(c)"), plt.axis('off')
#灰度变换图像的直方图
plt.subplot(224), plt.plot(hist_res), plt.title("(d)"), plt.xlabel("x"), plt.ylabel("y")
plt.show()

#encoding:utf-8
#By:Eastmount CSDN 2021-08-20
import cv2  
import numpy as np  
import matplotlib.pyplot as plt
#读取图片
img = cv2.imread('lena-hd.png')
#灰度转换
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#直方图均衡化处理
result = cv2.equalizeHist(gray)
#显示图像
plt.subplot(221)
plt.imshow(gray, cmap=plt.cm.gray), plt.axis("off"), plt.title('(a)') 
plt.subplot(222)
plt.imshow(result, cmap=plt.cm.gray), plt.axis("off"), plt.title('(b)') 
plt.subplot(223)
plt.hist(img.ravel(), 256), plt.title('(c)') 
plt.subplot(224)
plt.hist(result.ravel(), 256), plt.title('(d)') 
plt.show()

#encoding:utf-8
#By:Eastmount CSDN 2021-08-20
import cv2  
import numpy as np  
import matplotlib.pyplot as plt
#读取图片
img = cv2.imread('lena.png')
#灰度转换
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#局部直方图均衡化处理
clahe = cv2.createCLAHE(clipLimit=2, tileGridSize=(10,10))
#将灰度图像和局部直方图相关联, 把直方图均衡化应用到灰度图 
result = clahe.apply(gray)
#显示图像
plt.subplot(221)
plt.imshow(gray, cmap=plt.cm.gray), plt.axis("off"), plt.title('(a)') 
plt.subplot(222)
plt.imshow(result, cmap=plt.cm.gray), plt.axis("off"), plt.title('(b)') 
plt.subplot(223)
plt.hist(img.ravel(), 256), plt.title('(c)') 
plt.subplot(224)
plt.hist(result.ravel(), 256), plt.title('(d)') 
plt.show()

# -*- coding: utf-8 -*-
# By：Eastmount CSDN 2021-08-20
import cv2  
import numpy as np  
import matplotlib.pyplot as plt
#读取图片
img = cv2.imread('te.png')
source = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
#均值滤波
result1 = cv2.blur(source, (5,5))
result2 = cv2.blur(source, (10,10))
#方框滤波
result3 = cv2.boxFilter(source, -1, (5,5), normalize=1)
result4 = cv2.boxFilter(source, -1, (2,2), normalize=0)
#高斯滤波
result5 = cv2.GaussianBlur(source, (3,3), 0)
result6 = cv2.GaussianBlur(source, (15,15), 0)
#中值滤波
result7 = cv2.medianBlur(source, 3)
#高斯双边滤波
result8 =cv2.bilateralFilter(source, 15, 150, 150)
#显示图形
titles = ['Source', 'Blur 5*5', 'Blur 10*10', 'BoxFilter 5*5',
'BoxFilter 2*2', 'GaussianBlur 3*3', 'GaussianBlur 15*15',
'medianBlur', 'bilateralFilter']  
images = [source, result1, result2, result3,
result4, result5, result6, result7, result8]  
for i in range(9):  
plt.subplot(3,3,i+1), plt.imshow(images[i], 'gray')  
plt.title(titles[i])  
plt.xticks([]),plt.yticks([])  
plt.show()  

#encoding:utf-8
import cv2  
import numpy as np  
import matplotlib.pyplot as plt
#读取图像
img = cv2.imread('nv.png')
lenna_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
#灰度化处理图像
grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#高斯滤波
gaussianBlur = cv2.GaussianBlur(grayImage, (3,3), 0)
#阈值处理
ret, binary = cv2.threshold(gaussianBlur, 127, 255, cv2.THRESH_BINARY)
#Roberts算子
kernelx = np.array([[-1,0],[0,1]], dtype=int)
kernely = np.array([[0,-1],[1,0]], dtype=int)
x = cv2.filter2D(binary, cv2.CV_16S, kernelx)
y = cv2.filter2D(binary, cv2.CV_16S, kernely)
absX = cv2.convertScaleAbs(x)     
absY = cv2.convertScaleAbs(y)    
Roberts = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)
#Prewitt算子
kernelx = np.array([[1,1,1],[0,0,0],[-1,-1,-1]], dtype=int)
kernely = np.array([[-1,0,1],[-1,0,1],[-1,0,1]], dtype=int)
x = cv2.filter2D(binary, cv2.CV_16S, kernelx)
y = cv2.filter2D(binary, cv2.CV_16S, kernely)
absX = cv2.convertScaleAbs(x)  
absY = cv2.convertScaleAbs(y)    
Prewitt = cv2.addWeighted(absX,0.5,absY,0.5,0)
#Sobel算子
x = cv2.Sobel(binary, cv2.CV_16S, 1, 0)
y = cv2.Sobel(binary, cv2.CV_16S, 0, 1)    
absX = cv2.convertScaleAbs(x)   
absY = cv2.convertScaleAbs(y)    
Sobel = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)
#拉普拉斯算法
dst = cv2.Laplacian(binary, cv2.CV_16S, ksize = 3)
Laplacian = cv2.convertScaleAbs(dst)
# Scharr算子
x = cv2.Scharr(gaussianBlur, cv2.CV_32F, 1, 0) #X方向
y = cv2.Scharr(gaussianBlur, cv2.CV_32F, 0, 1) #Y方向
absX = cv2.convertScaleAbs(x)       
absY = cv2.convertScaleAbs(y)
Scharr = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)
#Canny算子
Canny = cv2.Canny(gaussianBlur, 50, 150)
#先通过高斯滤波降噪
gaussian = cv2.GaussianBlur(grayImage, (3,3), 0)
#再通过拉普拉斯算子做边缘检测
dst = cv2.Laplacian(gaussian, cv2.CV_16S, ksize = 3)
LOG = cv2.convertScaleAbs(dst)
#效果图
titles = ['Source Image', 'Binary Image', 'Roberts Image',
'Prewitt Image','Sobel Image', 'Laplacian Image',
'Scharr Image', 'Canny Image', 'LOG Image']  
images = [lenna_img, binary, Roberts,
Prewitt, Sobel, Laplacian,
Scharr, Canny, LOG]  
for i in np.arange(9):  
plt.subplot(3,3,i+1),plt.imshow(images[i],'gray')  
plt.title(titles[i])  
plt.xticks([]),plt.yticks([])  
plt.show()  

#coding:utf-8
#By:Eastmount CSDN 2021-08-20
import cv2
import math
import numpy as np
#读取原始图像
img = cv2.imread('nv.png')
#获取图像行和列
rows, cols = img.shape[:2]
#新建目标图像
dst = np.zeros((rows, cols, 3), dtype="uint8")
#图像流年特效
for i in range(rows):
for j in range(cols):
#B通道的数值开平方乘以参数12
B = math.sqrt(img[i,j][0]) * 12
G =  img[i,j][1]
R =  img[i,j][2]
if B>255:
B = 255
dst[i,j] = np.uint8((B, G, R))
#显示图像
cv2.imshow('src', img)
cv2.imshow('dst', dst)
cv2.waitKey()
cv2.destroyAllWindows()

#coding:utf-8
#By:Eastmount CSDN 2021-08-20
import cv2
import math
import numpy as np
#获取滤镜颜色
def getBGR(img, table, i, j):
#获取图像颜色
b, g, r = img[i][j]
#计算标准颜色表中颜色的位置坐标
x = int(g/4 + int(b/32) * 64)
y = int(r/4 + int((b%32) / 4) * 64)
#返回滤镜颜色表中对应的颜色
return lj_map[x][y]
#读取原始图像
img = cv2.imread('nv.png')
lj_map = cv2.imread('table.png')
#获取图像行和列
rows, cols = img.shape[:2]
#新建目标图像
dst = np.zeros((rows, cols, 3), dtype="uint8")
#循环设置滤镜颜色
for i in range(rows):
for j in range(cols):
dst[i][j] = getBGR(img, lj_map, i, j)
#显示图像
cv2.imshow('src', img)
cv2.imshow('dst', dst)
cv2.waitKey()
cv2.destroyAllWindows()

#coding:utf-8
#By:Eastmount CSDN 2021-08-20
import cv2
import numpy as np
def dodgeNaive(image, mask):
# determine the shape of the input image
width, height = image.shape[:2]
# prepare output argument with same size as image
blend = np.zeros((width, height), np.uint8)
for col in range(width):
for row in range(height):
# do for every pixel
if mask[col, row] == 255:
# avoid division by zero
blend[col, row] = 255
else:
# shift image pixel value by 8 bits
# divide by the inverse of the mask
tmp = (image[col, row] << 8) / (255 - mask)
# print('tmp={}'.format(tmp.shape))
# make sure resulting value stays within bounds
if tmp.any() > 255:
tmp = 255
blend[col, row] = tmp
return blend
def dodgeV2(image, mask):
return cv2.divide(image, 255 - mask, scale=256)
def burnV2(image, mask):
return 255 - cv2.divide(255 - image, 255 - mask, scale=256)
def rgb_to_sketch(src_image_name, dst_image_name):
img_rgb = cv2.imread(src_image_name)
img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_BGR2GRAY)
img_gray_inv = 255 - img_gray
img_blur = cv2.GaussianBlur(img_gray_inv, ksize=(21, 21),
sigmaX=0, sigmaY=0)
img_blend = dodgeV2(img_gray, img_blur)
cv2.imshow('original', img_rgb)
cv2.imshow('gray', img_gray)
cv2.imshow('gray_inv', img_gray_inv)
cv2.imshow('gray_blur', img_blur)
cv2.imshow("pencil sketch", img_blend)
cv2.waitKey(0)
cv2.destroyAllWindows()
cv2.imwrite(dst_image_name, img_blend)
if __name__ == '__main__':
src_image_name = 'nv.png'
dst_image_name = 'sketch_example.jpg'
rgb_to_sketch(src_image_name, dst_image_name)

# -*- coding: utf-8 -*-
#By:Eastmount CSDN 2021-08-20
import cv2  
import numpy as np  
import matplotlib.pyplot as plt
import matplotlib
#读取图像
img = cv2.imread('nv.png')
#灰度化处理图像
grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#设置掩码、fgbModel、bgModel
mask = np.zeros(img.shape[:2], np.uint8)
bgdModel = np.zeros((1,65), np.float64)
fgdModel = np.zeros((1,65), np.float64)
#矩形坐标
rect = (100, 100, 500, 800)
#图像分割
cv2.grabCut(img, mask, rect, bgdModel, fgdModel, 5,
cv2.GC_INIT_WITH_RECT)
#设置新掩码：0和2做背景
mask2 = np.where((mask==2)|(mask==0), 0, 1).astype('uint8')
#设置字体
matplotlib.rcParams['font.sans-serif']=['SimHei']
#显示原图
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
plt.subplot(1,2,1)
plt.imshow(img)
plt.title(u'(a)原始图像')
plt.xticks([]), plt.yticks([])
#使用蒙板来获取前景区域
img = img*mask2[:, :, np.newaxis]
plt.subplot(1,2,2)
plt.imshow(img)
plt.title(u'(b)目标图像')
plt.colorbar()
plt.xticks([]), plt.yticks([])
plt.show()

# -*- coding: utf-8 -*-
#By:Eastmount CSDN 2021-08-20
import cv2
import numpy as np
import matplotlib.pyplot as plt
#读取原始图像灰度颜色
img = cv2.imread('scenery.png') 
#获取图像行和列
rows, cols = img.shape[:2]
#mask必须行和列都加2且必须为uint8单通道阵列
mask = np.zeros([rows+2, cols+2], np.uint8) 
spatialRad = 100 #空间窗口大小
colorRad = 100   #色彩窗口大小
maxPyrLevel = 2  #金字塔层数
#图像均值漂移分割
dst = cv2.pyrMeanShiftFiltering( img, spatialRad, colorRad, maxPyrLevel)
#图像漫水填充处理
cv2.floodFill(dst, mask, (30, 30), (0, 255, 255),
(100, 100, 100), (50, 50, 50),
cv2.FLOODFILL_FIXED_RANGE)
#显示图像
cv2.imshow('src', img)
cv2.imshow('dst', dst)
cv2.waitKey()
cv2.destroyAllWindows()

# -*- coding: utf-8 -*-
#By:Eastmount CSDN 2021-08-20
import cv2
import random
import sys
import numpy as np
#使用说明 点击鼠标选择种子点
help_message = '''USAGE: floodfill.py [<image>] Click on the image to set seed point Keys: f - toggle floating range c - toggle 4/8 connectivity ESC - exit '''
if __name__ == '__main__':
#输出提示文本
print(help_message)
#读取原始图像
img = cv2.imread('scenery.png')
#获取图像高和宽
h, w = img.shape[:2]
#设置掩码 长和宽都比输入图像多两个像素点 
mask = np.zeros((h+2, w+2), np.uint8)
#设置种子节点和4邻接
seed_pt = None
fixed_range = True
connectivity = 4 
#图像漫水填充分割更新函数
def update(dummy=None):
if seed_pt is None:
cv2.imshow('floodfill', img)
return
#建立图像副本并漫水填充
flooded = img.copy()
mask[:] = 0 #掩码初始为全0
lo = cv2.getTrackbarPos('lo', 'floodfill') #观察点像素邻域负差最大值
hi = cv2.getTrackbarPos('hi', 'floodfill') #观察点像素邻域正差最大值
print('lo=', lo, 'hi=', hi)
#低位比特包含连通值 4 (缺省) 或 8
flags = connectivity
#考虑当前象素与种子象素之间的差（高比特也可以为0）
if fixed_range:
flags |= cv2.FLOODFILL_FIXED_RANGE
#以白色进行漫水填充
cv2.floodFill(flooded, mask, seed_pt,
(random.randint(0,255), random.randint(0,255),
random.randint(0,255)), (lo,)*3, (hi,)*3, flags)
#选定基准点用红色圆点标出
cv2.circle(flooded, seed_pt, 2, (0, 0, 255), -1)
print("send_pt=", seed_pt)
#显示图像
cv2.imshow('floodfill', flooded)
#鼠标响应函数
def onmouse(event, x, y, flags, param):
global seed_pt #基准点
#鼠标左键响应选择漫水填充基准点
if flags & cv2.EVENT_FLAG_LBUTTON:
seed_pt = x, y
update()
#执行图像漫水填充分割更新操作
update()
#鼠标更新操作
cv2.setMouseCallback('floodfill', onmouse)
#设置进度条
cv2.createTrackbar('lo', 'floodfill', 20, 255, update)
cv2.createTrackbar('hi', 'floodfill', 20, 255, update)
#按键响应操作
while True:
ch = 0xFF & cv2.waitKey()
#退出
if ch == 27:
break
#选定时flags的高位比特位0
#此时邻域的选定为当前像素与相邻像素的差, 联通区域会很大
if ch == ord('f'):
fixed_range = not fixed_range 
print('using %s range' % ('floating', 'fixed')[fixed_range])
update()
#选择4方向或则8方向种子扩散
if ch == ord('c'):
connectivity = 12-connectivity 
print('connectivity =', connectivity)
update()
cv2.destroyAllWindows()

# -*- coding: utf-8 -*-
#By:Eastmount CSDN 2021-08-20
import numpy as np
import cv2
from matplotlib import pyplot as plt
import matplotlib
#读取图像
img = cv2.imread('Lena.png', 0)
#傅里叶变换
dft = cv2.dft(np.float32(img), flags = cv2.DFT_COMPLEX_OUTPUT)
dftshift = np.fft.fftshift(dft)
res1= 20*np.log(cv2.magnitude(dftshift[:,:,0], dftshift[:,:,1]))
#傅里叶逆变换
ishift = np.fft.ifftshift(dftshift)
iimg = cv2.idft(ishift)
res2 = cv2.magnitude(iimg[:,:,0], iimg[:,:,1])
#设置字体
matplotlib.rcParams['font.sans-serif']=['SimHei']
#显示图像
plt.subplot(131), plt.imshow(img, 'gray'), plt.title(u'(a)原始图像')
plt.axis('off')
plt.subplot(132), plt.imshow(res1, 'gray'), plt.title(u'(b)傅里叶变换处理')
plt.axis('off')
plt.subplot(133), plt.imshow(res2, 'gray'), plt.title(u'(b)傅里叶变换逆处理')
plt.axis('off')
plt.show()

# -*- coding: utf-8 -*-
#By:Eastmount CSDN 2021-08-20
import cv2
import numpy as np
from matplotlib import pyplot as plt
#读取图像
img = cv2.imread('eyes.png')
#灰度转换
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#显示原始图像
plt.subplot(121), plt.imshow(gray, 'gray'), plt.title('Input Image')
plt.axis('off')
#霍夫变换检测圆
circles1 = cv2.HoughCircles(gray, cv2.HOUGH_GRADIENT, 1, 20,
param1=100, param2=30,
minRadius=160, maxRadius=200)
print(circles1)
#提取为二维
circles = circles1[0, :, :]
#四舍五入取整
circles = np.uint16(np.around(circles))
#绘制圆
for i in circles[:]: 
cv2.circle(img, (i[0],i[1]), i[2], (255,0,0), 5) #画圆
cv2.circle(img, (i[0],i[1]), 2, (255,0,255), 8) #画圆心
#显示处理图像
plt.subplot(122), plt.imshow(img), plt.title('Result Image')
plt.axis('off')
plt.show()

# -*- coding: utf-8 -*-
# By: Eastmount CSDN 2021-08-20
import os
import cv2
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix, classification_report
#----------------------------------------------------------------------------------
# 第一步 切分训练集和测试集
#----------------------------------------------------------------------------------
X = [] #定义图像名称
Y = [] #定义图像分类类标
Z = [] #定义图像像素
for i in range(0, 10):
#遍历文件夹，读取图片
for f in os.listdir("photo/%s" % i):
#获取图像名称
X.append("photo//" +str(i) + "//" + str(f))
#获取图像类标即为文件夹名称
Y.append(i)
X = np.array(X)
Y = np.array(Y)
#随机率为100% 选取其中的30%作为测试集
X_train, X_test, y_train, y_test = train_test_split(X, Y,                                                   
test_size=0.3, random_state=1)
print(len(X_train), len(X_test), len(y_train), len(y_test))
#----------------------------------------------------------------------------------
# 第二步 图像读取及转换为像素直方图
#----------------------------------------------------------------------------------
#训练集
XX_train = []
for i in X_train:
#读取图像
#print i
image = cv2.imread(i)
#图像像素大小一致
img = cv2.resize(image, (256,256),
interpolation=cv2.INTER_CUBIC)
#计算图像直方图并存储至X数组
hist = cv2.calcHist([img], [0,1], None,
[256,256], [0.0,255.0,0.0,255.0])
XX_train.append(((hist/255).flatten()))
#测试集
XX_test = []
for i in X_test:
#读取图像
#print i
image = cv2.imread(i)
#图像像素大小一致
img = cv2.resize(image, (256,256),
interpolation=cv2.INTER_CUBIC)
#计算图像直方图并存储至X数组
hist = cv2.calcHist([img], [0,1], None,
[256,256], [0.0,255.0,0.0,255.0])
XX_test.append(((hist/255).flatten()))
#----------------------------------------------------------------------------------
# 第三步 基于朴素贝叶斯的图像分类处理
#----------------------------------------------------------------------------------
from sklearn.naive_bayes import BernoulliNB
clf = BernoulliNB().fit(XX_train, y_train)
predictions_labels = clf.predict(XX_test)
print('预测结果:')
print(predictions_labels)
print('算法评价:')
print(classification_report(y_test, predictions_labels))
#输出前10张图片及预测结果
k = 0
while k<10:
#读取图像
print(X_test[k])
image = cv2.imread(X_test[k])
print(predictions_labels[k])
#显示图像
cv2.imshow("img", image)
cv2.waitKey(0)
cv2.destroyAllWindows()
k = k + 1