python有关于图像的深度和通道

目录：

（一）图像的深度和图像的通道

 （1）图像的深度

 （2）图像的通道

（二）自定义一张多通道的图片

（1）zeros 函数

（2）ones  函数

（三）自定义一张单通道的图片

（四）像素操作

（1）numpy操作数组

（2）调用库函数

（五）opnecv 利用getTickCount()和getTickFrequency()计算执行时间

 

 

 

 

 正文：

（一）图像的深度和图像的通道

      （1）图像的深度

               图像中像素点占得bit位数，就是图像的深度，比如：

二值图像：图像的像素点不是0 就是1 （图像不是黑色就是白色），图像像素点占的位数就是 1 位，图像的深度就是1，也称作位图。

灰度图像：图像的像素点位于0-255之间，（0：全黑，255代表：全白，在0-255之间插入了255个等级的灰度）。2^8=255，图像的深度是8。

依次轮推，我们把计算机中存储单个像素点所用的 bit 位称为图像的深度。

     （2）图像的通道

             有了图像深度的概念，我们知道如果是24位的图像，则这个像素点的颜色的取值范围是：从0到2^24。这个范围特别大，如果我们知道了某店的像素值怎么判断像素点的颜色呢？我们知道 RGB是基本的三原色，如果我们用8位代表一种颜色，每种颜色最大是255，这样每个像素点的颜色值的范围就是（0-255,0-255,0-255）。这样图像的通道就是3。

灰度图的图像存储模型

 

灰度图像像素点的存储就是对应的原图从左到右，从上到下，依次排列，每个点的值就是就是像素点的值，每个点的地址就是像素像素点的地址。

RGB图的图像存储模型

RGB彩色图像和灰度图相比，每个像素点都有3个通道。每个通道占的内存空间都是8位。在内存中，RGB 图像的存储是以二维数组的形式。

学习图像的存储就是为了理解图像中像素点的存储情况，有助于我们对每个像素点的操作。

（二）自定义一张多通道的图片-----用到函数：zeros和ones

（1）zeros 函数

 1 # -*- coding=GBK -*-
 2 import cv2 as cv
 3 import numpy as np
 4
 5
 6 def create_image():
 7     img = np.zeros([400, 400, 3], np.uint8)#zeros:double类零矩阵  创建400*400 3个通道的矩阵图像 参数时classname为uint8
 8     img[:, :, 0] = np.ones([400, 400])*255#ones([400, 400])是创建一个400*400的全1矩阵，*255即是全255矩阵 并将这个矩阵的值赋给img的第一维
 9     img[:, :, 1] = np.ones([400, 400])*255#第二维全是255
10     img[:, :, 2] = np.ones([400, 400])*255#第三维全是255
11     cv.imshow("自制图片", img)#输出一张400*400的白色图片(255 255 255):蓝(B)、绿(G)、红(R)
12
13 create_image()
14 cv.waitKey(0)
15 cv.destroyAllWindows()

（2）ones  函数

 1 # -*- coding=GBK -*-
 2 import cv2 as cv
 3 import numpy as np
 4
 5
 6 def create_image():
 7     img = np.ones([400, 400, 3], np.uint8)
 8     img[:, :, 0] = img[:, :, 0]*255
 9     img[:, :, 1] = img[:, :, 1]*255
10     img[:, :, 2] = img[:, :, 2]*255
11     cv.imshow("自制图片", img)
12
13 create_image()
14 cv.waitKey(0)
15 cv.destroyAllWindows()

第8，9，10行换成

image[:, :, 0] = np.ones([400, 400]) * 255
image[:, :, 1] = np.ones([400, 400]) * 255
image[:, :, 2] = np.ones([400, 400]) * 255
建议 img[:, :, 2] = np.ones([400, 400])*255  这样赋值

（3）补充

 1 >>>from numpy import *
 2 >>> a=zeros((3,4))
 3 >>> a
 4 array([[ 0.,  0.,  0.,  0.],
 5        [ 0.,  0.,  0.,  0.],
 6        [ 0.,  0.,  0.,  0.]])
 7 >>> from numpy import *
 8 >>> a=ones((3,4))
 9 >>> a
10 array([[ 1.,  1.,  1.,  1.],
11        [ 1.,  1.,  1.,  1.],
12        [ 1.,  1.,  1.,  1.]])
13 >>> from numpy import *
14 >>> a=eye(3)
15 >>> a
16 array([[ 1.,  0.,  0.],
17        [ 0.,  1.,  0.],
18        [ 0.,  0.,  1.]])

（三）自定义一张单通道的图片

 1 # -*- coding=GBK -*-
 2 import cv2 as cv
 3 import numpy as np
 4
 5
 6 def create_image():
 7     img = np.ones([400, 400, 1], np.uint8)
 8     img = img * 127
 9     cv.imshow("自制图片", img)
10
11 create_image()
12 cv.waitKey(0)
13 cv.destroyAllWindows()

（四）像素操作

（1）numpy操作数组

读取一张图片，修改颜色通道后输出，可以得到图像的：行数,列数,通道数的矩阵,对矩阵进行操作可改变图像像素

 1 # -*- coding=GBK -*-
 2 import cv2 as cv
 3 import numpy as np
 4
 5
 6 #numpy数组操作
 7 def access_pixles(image):
 8     print(image.shape)
 9     height = image.shape[0]
10     width = image.shape[1]
11     channel = image.shape[2]
12     print("width : %s, height : %s, channel : %s" % (width, height, channel))
13     for row in range(height):
14         for col in range(width):
15             for c in range(channel):
16                 pv = image[row, col, c]
17                 image[row, col, c] = 255 - pv
18     cv.imshow("修改后", image)
19
20
21 src = cv.imread("C://1.jpg")
22 #cv.namedWindow("原来", cv.WINDOW_NORMAL)
23 cv.imshow("原来", src)
24 t1 = cv.getTickCount()#毫秒级别的计时函数,记录了系统启动以来的时间毫秒
25 access_pixles(src)
26 t2 = cv.getTickCount()
27 time = (t2 - t1)*1000/cv.getTickFrequency()#getTickFrequency用于返回CPU的频率,就是每秒的计时周期数
28 print("time: %s" % time)#输出运行的时间
29 cv.waitKey(0)
30 cv.destroyAllWindows()

（2）调用库函数

 1 # -*- coding=GBK -*-
 2 import cv2 as cv
 3 import numpy as np
 4
 5
 6 #像素取反
 7 def inverse(image):
 8     dst = cv.bitwise_not(image)
 9     cv.imshow("取反", dst)
10
11
12 src = cv.imread("C://1.jpg")
13 cv.namedWindow("原来", cv.WINDOW_NORMAL)
14 cv.imshow("原来", src)
15 t1 = cv.getTickCount()
16 inverse(src)
17 t2 = cv.getTickCount()
18 time = (t2 - t1)*1000/cv.getTickFrequency()
19 print("time: %s" % time)
20 cv.waitKey(0)
21 cv.destroyAllWindows()

（五）opnecv 利用getTickCount()和getTickFrequency()计算执行时间

t1 = cv.getTickCount()
picture_message(scr)
t2 = cv.getTickCount()
time = 1000*(t2-t1)/cv.getTickFrequency()
print('Time is %s ms'% time)

getTickCount()：用于返回从操作系统启动到当前所经的计时周期数，看名字也很好理解，get Tick Count(s)。
getTickFrequency()：用于返回CPU的频率。get Tick Frequency。这里的单位是秒，也就是一秒内重复的次数。

所以剩下的就很清晰了：
总次数/一秒内重复的次数 = 时间(s)
1000 *总次数/一秒内重复的次数= 时间(ms)

这个逻辑很清晰，没什么问题，但是这里有一个小坑，那就是C版本的cvGetTickFrequency()函数和C++版本的getTickFrequency()的单位不一样，前者以ms计算频率，后者以s为单位计算频率，所以如果使用C版本的cvGetTickFrequency()计算时间的话，应该是：
总次数/一秒内重复的次数*1000 = 时间(ms)
总次数/一秒内重复的次数= 时间(s)

参考：

https://blog.csdn.net/u013355826/article/details/64905921

https://blog.csdn.net/u011321546/article/details/79523115

https://www.cnblogs.com/jczhuang/p/9766950.html