1、按位取反bitwise_not()
按位取反就是将数值根据每个bit位1变0，0变1，比如0xf0按位取反就变成了0x0f，如果是uint8类型的数据，取反前后的数据相加结果为0xff(255)。下面的例子将lena.jpg和opencv-logo.png分别按位取反：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
import cv2print('cv2.__version__:',cv2.__version__) img1 = cv2.imread('..\\lena.jpg') img2 = cv2.imread('..\\opencv-logo.png' ) img_ret1 = cv2.bitwise_not(img1)print('img1[161,199]: ',img1[161,199])print('img_ret1[161,199]:',img_ret1[161,199])cv2.imshow('lena-not-juzicode',img_ret1) img_ret2 = cv2.bitwise_not(img2)print('img2[100,200]: ',img2[100,200])print('img_ret2[100,200]:',img_ret2[100,200])cv2.imshow('logo-not-juzicode',img_ret2) cv2.waitkey(0) |
运行结果：
cv2.__version__: 4.5.2
img1[161,199]: [109 105 201]
img_ret1[161,199]: [146 150 54]
img2[100,200]: [ 0 0 255]
img_ret2[100,200]: [255 255 0]
比如lena.jpg的像素点[161,199] b通道的值为109（0110 1101），取反后的值为146（1001 0010），转换为二进制后观察到每个bit为如果为0就变成1、如果为1就变成0：
上图中左侧lena这种图像是不是有种似曾相识的感觉？能回忆起来是啥子东西的朋友就要暴露年龄了，二十年前流行的胶片相机，洗出来的底片就是这个样子的。
取反还有很多应用的地方，比如做ocr文字识别的时候，因为一般的书籍是白纸黑字，背景是白色，而要分析识别的字却是黑色，在做完二值化之后要识别的字是黑色的，如果直接做图像切割，分离出来的就是背景“白纸”而不是目标对象“黑字”了，而做完取反处理后就能达到切割目标白色文字的效果。下图是”白纸黑字“取反前后的对比：
bitwise_not()的入参中只有1个图像实例作为输入，而接下来介绍的与、或、异或等其他几种逻辑运算则需要2个图像实例（numpy数组）或者1个图像实例和1个标量数据。和图像的加减乘除运算一样，当涉及到2个图像实例时，也要求图像的行列数一致。
2、按位与bitwise_and()、或bitwise_or()、异或bitwise_xor()
按位与、或、异或操作需要2个图像对象、或者1个图像对象和1个标量数据相互作用，接口形式如下：
dst = cv2.bitwise_or(src1, src2[, dst[, mask]] )
dst = cv2.bitwise_or(src1, src2[, dst[, mask]] )
dst = cv2.bitwise_or(src1, src2[, dst[, mask]] )
下面是2个图像按位与、或、异或的例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
import cv2print('cv2.__version__:',cv2.__version__) img1 = cv2.imread('..\\lena.jpg' )[0:300,0:300]img2 = cv2.imread('..\\messi5.jpg' )[0:300,0:300]img_ret1 = cv2.bitwise_and(img1,img2)print('img1[161,199]: ',img1[161,199])print('img2[161,199]: ',img2[161,199])print('img_ret1[161,199]:',img_ret1[161,199])cv2.imshow('and-juzicode',img_ret1) img_ret2 = cv2.bitwise_or(img1,img2)print('img_ret2[161,199]:',img_ret2[161,199])cv2.imshow('or-juzicode',img_ret2) img_ret3 = cv2.bitwise_xor(img1,img2)print('img_ret3[161,199]:',img_ret3[161,199])cv2.imshow('xor-juzicode',img_ret3) cv2.waitkey(0) |
运行结果：
cv2.__version__: 4.5.2
img1[161,199]: [109 105 201]
img2[161,199]: [105 43 32]
img_ret1[161,199]: [105 41 0]
img_ret2[161,199]: [109 107 233]
img_ret3[161,199]: [ 4 66 233]
2个图像的按位操作和算术运算一样，也要求2个图像的大小一样，通道数一样。不同于算术运算数据类型不一样时通过dtype声明新生成图像的数据类型，按位运算的接口中根本就没有dtype参数，所以位运算中2个图像的数据类型也必须一致。
同样地按位运算也可以是一个图像和1个标量，如果是标量数据类型，可以是1个单独的数值或者是包含4个数值的四元组，这点和算术运算类似。和算术运算不同的是，如果是3通道的图像，还可以用一个包含了3个数值的三元组和这个图像做标量的位运算。
下面的例子是一个3通道图像和四元组、三元组、单个数值进行位运算的例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
import cv2print('cv2.__version__:',cv2.__version__) img1 = cv2.imread('..\\lena.jpg' )[0:300,0:300]img_ret1 = cv2.bitwise_and(img1,(0x3f,0x3f,0x3f,0))print('img1[161,199]: ',img1[161,199])print('img_ret1[161,199]:',img_ret1[161,199])cv2.imshow('and-juzicode',img_ret1) img_ret2 = cv2.bitwise_or(img1,(0x0f,0x0f,0x0f))print('img_ret2[161,199]:',img_ret2[161,199])cv2.imshow('or-juzicode',img_ret2) img_ret3 = cv2.bitwise_xor(img1,0xf0)print('img_ret3[161,199]:',img_ret3[161,199])cv2.imshow('xor-juzicode',img_ret3) cv2.waitkey(0) |
运行结果：
cv2.__version__: 4.5.2
img1[161,199]: [109 105 201]
img_ret1[161,199]: [45 41 9]
img_ret2[161,199]: [111 111 207]
img_ret3[161,199]: [157 105 201]
但是当图像包含4通道时，因为处理标量数据时不会自动填充第4通道为0而直接报错了，所以在处理4通道图像时则必须使用四元组。一个好的编程习惯是不管图像是多少通道的都使用四元组表示这个标量，如果不想对某些通道进行位运算，则用相应的全0或全f代替，比如一个3通道的uint8类型的图像，只需要对2通道和0x33相与，构造的四元组就是（0xff，0x33，0xff，0xff）。
3、浮点类型图像的位运算
前面的例子中我们都是以uint8类型为例进行说明的，当然16位、32位整型数据类型的图像处理方法类似，但是如果一个图像的数据类型是浮点类型时，位运算之后的结果会怎样呢？
|
1
2
3
4
5
6
7
8
9
|
import numpy as npimport cv2print('cv2.__version__:',cv2.__version__) img1 = np.array([0.7,0.8,0.9,1.0,1.1,1.2,1.3],dtype=np.float32).reshape(1,7)img_ret1 = cv2.bitwise_not(img1)print('img1:',img1)print('img_ret1:',img_ret1) |
运行结果：
cv2.__version__: 4.5.2
img1: [[0.7 0.8 0.9 1. 1.1 1.2 1.3]]
img_ret1: [[-6.3999996 -5.5999994 -4.7999997 -3.9999998 -3.7999997 -3.5999997
-3.3999999]]
从上面的运行结果看，浮点数按位取反后的数据和原始数据间对比，比较明显的是符号发生了改变，但是二者的数值看起来已经没有了明显的对应关系了。
这是由浮点数据在内存中的存储方式决定的，单精度32位浮点数按照1个符号位s+8个指数位e+23个有效数值位m构成。以0.7为例，在python中用float.hex(0.7)计算的结果为0x1.6666666666666p-1，这样取23个有效数值位m=0110 0110 0110 0110 0110 011，指数e=127-1=0x7e=0b 0111 1110，符号位s=0，所以完整的数值为0b 0 0111 1110 0110 0110 0110 0110 0110 011=0x3f333333，取反后就为0xc0cccccc，然后再反过来计算浮点数的值就为-6.3999996，同样的方法可以计算其他浮点数二进制表示方法。
因为在python中没有直接将浮点数的二进制数值打印显示的方法，我们可以用c语言中指针类型强制转换的方式观察、转换浮点数的二进制值。下面这个例子中我们先定义了一个float型的数组，然后在循环中依次处理数组中的每个元素：先将该数值做(int*)强制类型转换，再对该int类型的数据做取反操作，最后对取反得到后的int类型再做(float*)强制转换为float型。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
#include "stdio.h"int main(void){ float arr_f[7] = { 0.7,0.8,0.9,1.0,1.1,1.2,1.3 }; //定义浮点数数组 int arr_i[7]; //存储浮点数转换后的int型 int arr_i_not[7]; //存储int型的按位取反 float arr_f_not[7]; //arr_i_not转换为浮点数 for (int i = 0; i < 7; i++) { int *t_i = (int*)(arr_f + i); //指针类型转换为int型 arr_i[i] = *t_i; arr_i_not[i] = ~arr_i[i]; float *t_f = (float*)(arr_i_not + i); arr_f_not[i] = *t_f; } for (int i = 0; i < 7;i++) { printf("%0.7f ", arr_f[i]); printf("%x ", arr_i[i]); printf("%x ", arr_i_not[i]); printf("%0.7f \n", arr_f_not[i]); } return 0;} |
运行结果如下，第1列为原始数据，最后一列是按位取反后的数值，和opencv的bitwise_not()计算的结果一样：
0.7000000 3f333333 c0cccccc -6.3999996
0.8000000 3f4ccccd c0b33332 -5.5999994
0.9000000 3f666666 c0999999 -4.7999997
1.0000000 3f800000 c07fffff -3.9999998
1.1000000 3f8ccccd c0733332 -3.7999997
1.2000000 3f99999a c0666665 -3.5999997
1.3000000 3fa66666 c0599999 -3.3999999
在opencv内部对浮点类型的位运算实际上也是按照二进制数值进行的转换，不过这种转换方法没有非常明确的图像学含义，所以一般浮点类型的位运算几乎很少使用。
到此这篇关于opencv-python教程之图像的位运算详解的文章就介绍到这了,更多相关opencv-python图像的位运算内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://blog.csdn.net/juzicode00/article/details/117932270
