图像处理之opencv图像特效大全_opencv贴图特效

1、特效1：灰度处理

1.1、cv2.imread()方法

import cv2
img0 = cv2.imread('image.jpg', 0)#0为灰色图片
img1 = cv2.imread('image.jpg', 1)#1为彩色图片
cv2.imshow('src', img1)
print ("img0的shape为：", img0.shape)
print ("img1的shape为：", img1.shape)
cv2.imshow('gray', img0)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9

img0的shape为： (294, 408)
img1的shape为： (294, 408, 3)
1
2

1.2、cv2.cvtColor()方法

import cv2
img = cv2.imread('image.jpg', 1)#1为彩色图片
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)#颜色空间转换 1、data  2、BGR——>gray
cv2.imshow('gray', gray)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6

1.3、GRB均值法

• GRB均值法就是当图片的三个GRB通道都为它的均值的，图片颜色为灰色。
• RGB : R=G=B = gray = (R+G+B)/3

import cv2
import numpy as np
img = cv2.imread('image.jpg', 1)#1为彩色图片
#获取图片宽高
imgInfo = img.shape
height = imgInfo[0]
width = imgInfo[1]
dst = np.zeros((height, width, 3), np.uint8) #np.uint8数据类型为0~255
for i in range(0, height):
    for j in range(0, width):
        (b, g, r) = img[i, j] #取出图片的bgr像素值
        gray = (int(b)+ int(g) + int(r))/3 #将数据转换为int型运算，防止溢出
        dst[i, j] = np.uint8(gray)
cv2.imshow('dst', dst)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1.4、心理学汇总计算法

• 利用BGR乘以某个固定的值
• gray = R x 0.299 + G x 0.587 + B x 0.114

import cv2
import numpy as np
img = cv2.imread('image.jpg', 1)#1为彩色图片
#获取图片宽高
imgInfo = img.shape
height = imgInfo[0]
width = imgInfo[1]
dst = np.zeros((height, width, 3), np.uint8) #np.uint8数据类型为0~255
for i in range(0, height):
    for j in range(0, width):
        (b, g, r) = img[i, j] #取出图片的bgr像素值
        gray = int(r)*0.299 + int(g)*0.587 + int(b)*0.114 #将数据转换为int型运算，防止溢出
        dst[i, j] = np.uint8(gray)
cv2.imshow('dst', dst)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1.5、优化灰度算法

为什么需要优化灰度算法？
	1、灰度处理在整个图像处理中占很重要的地位
	2、提高计算机的计算能力
	3、计算方式速度排名：定点型  > 浮点型;
					    移位 > 加减 > 乘除  
1
2
3
4
5

import cv2
import numpy as np
img = cv2.imread('image.jpg', 1)#1为彩色图片
#获取图片宽高
imgInfo = img.shape
height = imgInfo[0]
width = imgInfo[1]
dst = np.zeros((height, width, 3), np.uint8) #np.uint8数据类型为0~255
for i in range(0, height):
    for j in range(0, width):
        (b, g, r) = img[i, j] #取出图片的bgr像素值
        b = int(b)#将数据转换为int型运算，防止溢出
        g = int(g)
        r = int(r)
#         gray = (r*1 + g*2 + b*1) /4
        gray = (r + (g << 1) + b) >> 2 # <<1表示左移一位，乘2； >>2表示右移一位，除以4
        dst[i, j] = np.uint8(gray)
cv2.imshow('dst', dst)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

图片灰度处理后的效果：

2、特效2：地板效果

2.1、灰色图片颜色反转

import cv2
import numpy as np
img = cv2.imread('image.jpg', 1)#1为彩色图片
#获取图片宽高
imgInfo = img.shape
height = imgInfo[0]
width = imgInfo[1]

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
dst = np.zeros((height, width, 1), np.uint8)
for i in range(0, height):
    for j in range(0,width):
        grayPixel = gray[i, j]#获取当前像素点颜色
        dst[i, j] = 255 - grayPixel
cv2.imshow('dst', dst)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.2、彩色图片颜色反转

• 原理：newR = 255 - R

import cv2
import numpy as np
img = cv2.imread('image.jpg', 1)#1为彩色图片
#获取图片宽高
imgInfo = img.shape
height = imgInfo[0]
width = imgInfo[1]

dst = np.zeros((height, width, 3), np.uint8)
for i in range(0, height):
    for j in range(0,width):
        (b, g, r) = img[i, j] #获取当前像素点颜色
        dst[i, j] = (255-b, 255-g, 255-r)
cv2.imshow('dst', dst)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3、特效3：马赛克

• 原理：先定义一个小方块，然后用这个小方块的像素来代替其它的像素

import cv2
import numpy as np
img = cv2.imread('image.jpg', 1) #1为彩色图片

#获取图片宽高
imgInfo = img.shape
height = imgInfo[0]
width = imgInfo[1]

for m in range(50, 200):#高
    for n in range(100, 200): #宽
        if m%10 == 0 and n%10 == 0:# 每隔10个值采点一次
            for i in range(0, 10):
                for j in range(0,10):
                    (b, g, r) = img[m, n]
                    img[i+m, j+n] = (b, g, r)
cv2.imshow('ma sai ke', img)                    
cv2.waitKey(0)
cv2.destroyAllWindows()                
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4、特效4：毛玻璃效果

• 原理：随机采取周围的像素点进行填充

import cv2
import numpy as np
img = cv2.imread('image.jpg', 1)#1为彩色图片
#获取图片宽高
imgInfo = img.shape
height = imgInfo[0]
width = imgInfo[1]

dst = np.zeros((height, width, 3), np.uint8)
for m in range(0, height-8):#减8是为了防止下面的随机数超过边界
    for n in range(0, width-8):
        index = int(np.random.random() * 8)#np.random.random()生成0~1的随机数
        (b, g, r) = img[m+index, n+index]#原像素点随机增加0~8
        dst[m, n] = (b, g,r)
cv2.imshow('dst',dst)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

5、特效5：图像融合

• 原理： dst = src1 x a + src2 x (1-a)

import cv2
import numpy as np
# 这两张图片的大小都一样的
jpg = cv2.imread('image.jpg', 1)
png = cv2.imread('image.png', 1)
#获取图片宽高
imgInfo = jpg.shape
height = imgInfo[0]
width = imgInfo[1]
#剪切图片
roiH = int(height)
roiW = int(width)
jpgROI = jpg[0:roiH, 0:roiW]
pngROI = png[0:roiH, 0:roiW]
#设置新图片信息
dst = np.zeros((roiH, roiW, 3), np.uint8)
#图片权重
dst = cv2.addWeighted(jpgROI, 0.5, pngROI, 0.5, 0)#src*a + src*(1-a)  a: 0.5——>1-0.5
#图片展示
cv2.imshow('jpg',jpg)
cv2.imshow('png',png)
cv2.imshow('dst',dst)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

6、特效6：边缘检测

• 流程：1、灰色处理， 2、高斯滤波 ， 3、cv2.canny

import cv2
img = cv2.imread('image.jpg', 1)#1为彩色图片
# 1、gray, 2、高斯滤波 3、cv2.canny
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
imgG = cv2.GaussianBlur(gray, (3,3),0)
dst = cv2.Canny(img, 50, 50)# 1、data  2、图片卷积
cv2.imshow('dst',dst)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9

7、特效7：浮雕效果

• 相邻像素值相减加上150，150是为了增加浮雕感
• newP = gray0 - gray1 + 150

import cv2
import numpy as np
img = cv2.imread('image.jpg', 1)#1为彩色图片
#获取图片宽高
imgInfo = img.shape
height = imgInfo[0]
width = imgInfo[1]
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#newP = gray0 - gray1 + 150
dst = np.zeros((height, width, 3), np.uint8)
for i in range(0, height):
    for j in range(0, width-1): #减1防止下面的grayP1越界
        grayP0 = int(gray[i, j])
        grayP1 = int(gray[i, j+1])
        newP = grayP0 - grayP1 + 150
        if newP > 255:
            newP = 255
        if newP < 0:
            newP = 0
        dst[i, j] = newP
cv2.imshow('dst',dst)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

8、特效8：颜色映射

• 原理：利用变化公式让蓝色性更强
• B = B x 1.5
• G = G x 1.3

import cv2
import numpy as np
img = cv2.imread('image.jpg', 1)#1为彩色图片
#获取图片宽高
imgInfo = img.shape
height = imgInfo[0]
width = imgInfo[1]

dst = np.zeros((height, width, 3), np.uint8)
for i in range(0, height):
    for j in range(0, width): #减1防止下面的grayP1越界
        (b, g, r) = img[i, j]
        b = b * 1.5
        g = g * 1.3
        if b > 255:
            b = 255
        if g < 0:
            g = 0
        dst[i, j] = (b, g, r)
cv2.imshow('dst',dst)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

9、特效9：油画特效

步骤：

1. 图片灰色处理
2. 将图片分成若干个小方块，统计这些小方块中的每一个灰度值
3. 将0~255的灰度值划分为几个等级，并把第二步处理的结果映射到这个范围内
4. 完成所用灰度段的个数统计，是count过程
5. 用统计出来的像素值替换原来的像素值

import cv2
import numpy as np
img = cv2.imread('image.jpg', 1)#1为彩色图片
#获取图片宽高
imgInfo = img.shape
height = imgInfo[0]
width = imgInfo[1]
#灰度处理
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
dst = np.zeros((height, width, 3), np.uint8)
for i in range(4, height-4):
    for j in range(4, width-4):
        array1 = np.zeros(8, np.uint8)
        for m in range(-4, 4):
            for n in range(-4, 4):
                p1 = int(gray[i+m, j+n]/32)
                array1[p1] = array1[p1] + 1
        currentMax = array1[0]
        l = 0
        for k in range(0, 8):
            if currentMax < array1[k]:
                currentMax = array1[k]
                l = k
        for m in range(-4, 4):
            for n in range(-4, 4):
                if gray[i+m, j+n] >= (l * 32) and gray[i+m, j+n] <= ((l+1)*32):
                    (b, g, r) = img[i+m, j+n]
        dst[i, j] = (b, g, r)
cv2.imshow('dst',dst)
cv2.waitKey(0)
cv2.destroyAllWindows()         
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31