医学数字图像处理实验报告3(2023)

校徽标

《医学数字图像处理》

实验名称

实验三 Numpy数组运算

实验目的与要求
  1. 数组的创建
  • 要求1：创建空数组，零数组，1数组，常数数组；
  • 要求2：创建序列np.arange和np.linspace；
  • 要求3：创建规则格网np.mgrid；
  • 要求4：创建随机数组np.random；
  • 要求5：填充数组np.pad。
  1. 数组属性
  • 要求1：数组的维度ndim，数组形状shape，数组类型dtype，数组中元素的数量size；
  • 要求2：数组元素数据类型转换(数组的astype方法)，数组形状的改变(reshape)。
  1. 数组的索引与切片：
  • 要求1：数组的索引，数组的切片；
  • 要求2：二维数组的拼接为三维数组dstack。
  1. 数组的运算：
  • 要求1：数组的四则运算，数组的乘方；
  • 要求2：数组的矢量化操作vectorize，与通用点运算的关系；
  • 要求3：数组沿轴操作apply_along_axis，与邻域运算的关系。

实验过程

数组的创建

  • 要求1：创建空数组，零数组，1数组，常数数组；

  • 我们利用np.empty创建了大小为100*100的空数组即随机数组，然后利用imshow进行灰度图像显示，结果如下：

图 1 空数组及其图像

  • 之后利用np.zeros和np.ones创建了全0和全1数组，以及利用np.full函数创建了常数为128的常数数组，同样也是通过图线显示出来，数组即图像如下所示：

图2 全0，全1和常数矩阵及其图像

并且利用三个数组利用np.dstack函数进行堆叠，形成三通道彩色图像，并且分别调试了np.hstack和np.vstack, 对应作用分别为三个数组横向堆叠和纵向堆叠，并且了解到imshow函数的cmap映射函数对数组形成的图像就不再起映射作用了，因为三维已经确定了一个颜色，不用再去映射，不会出现灰度图像的假彩色映射，所以我们登录颜色编码网站https://tool.oschina.net/commons?type=3，选取了颜色较为艳丽的紫色，颜色编码形式为(255,0,255),为形成三通道，我们用np.full函数创建了常数为255的数组，然后利用np.zeros函数创建了第二维，然后利用np.dstack函数进行堆叠，形成图像如下所示：

 图 3 彩色图像

学习代码如下：

 1 #创建空二维数组，高50，宽256，由于只分配了空间，没有初始化，其值是随机的
 2 arr = np.empty((100,100), dtype = np.uint8)
 3 
 4 print(arr)
 5 
 6 plt.imshow(arr, cmap = "gray",vmin = 0, vmax = 255 )
 7 
 8 plt.show()
 9 
10 #创建全0数组
11 
12 arr = np.zeros((100,100), dtype = np.uint8)
13 
14 print(arr)
15 
16 plt.imshow(arr, cmap = "gray",vmin = 0, vmax = 255 )
17 
18 plt.show()
19 
20 #创建全1数组
21 
22 arr = np.ones((100,100), dtype = np.uint8)
23 
24 print(arr)
25 
26 plt.imshow(arr, cmap = "gray",vmin = 0, vmax = 255 )
27 
28 plt.show()
29 
30 arr = np.full((100,100), fill_value = 128, dtype = np.uint8)
31 
32 print(arr)
33 
34 plt.imshow(arr, cmap = "gray",vmin = 0, vmax = 255 )
35 
36 plt.show()
37 
38 arr = np.full((100,100, 3),fill_value = 200, dtype = np.uint8)
39 
40 print(arr)
41 
42 plt.imshow(arr, cmap = "coolwarm", vmin = 0, vmax = 255)
43 
44 plt.show()
45 
46 r = np.full((100,100), fill_value = 255,dtype = np.uint8)
47 
48 g = np.zeros((100,100), dtype = np.uint8)
49 
50 b = np.full((100,100), fill_value = 255, dtype = np.uint8)
51 
52 arr = np.dstack([r, g, b])
53 
54 # arr = np.hstack([r, g, b])
55 
56 # arr = np.vstack([r, g, b])
57 
58 # cmap 只是对灰度图像起作用
59 
60 plt.imshow(arr, vmin = 0, vmax = 255 )
61 
62 plt.show()

 

 

  • 要求2：创建序列np.arange和np.linspace；

  • 同样利用np.arange生成一维的数组，np.arange(start, end, step), 从start开始，到end结束，但是不会取到end,中间取数的步长为step,意思就是每隔step取一个数，接着我们知道生成图像的数组最少也是二维的灰度图像，我们知道一维数组其实就是第二维为1的二维数组，同样二维数组就是第三维为1的三维数组，这个概念必须知道，所以之前生成的一维数组需要升维,假设生成数组为arr,那么利用arr.reshape(1, -1),就可以实现升维，对于第一个参数就是生成的行数，同理第二个是列数，如果某一个参数为-1，就是在告诉计算机让计算机自己计算另一维的维度，同样之后也利用np.linspace生成了连续的间隔相同的实数数组，np.linspace(start, end, number),表示从start开始到end结束，中间相同间隔生成number - 2个数。
  • 我们组利用np.arange()生成了从0~514之间每三个取一个数创建了一个数组，并且将其转化为行为2的二维数组，并刻画图像，同样利用np.linspace()生成了从0~255之间中间间隔相同取128个数，生成行为2的二维数组和图像如下所示：

图 4 np.arange()创建数组和图像

图 5 np.linspace()创建数组和图像

学习代码如下：

 1 arr = np.arange(0, 514, 3, dtype = np.uint8)
 2 print(arr)
 3 
 4 arr = arr.reshape(2,-1)
 5 
 6 plt.axis(False)
 7 
 8 plt.imshow(arr, cmap = "gray", vmin = 0, vmax = 255)
 9 
10 plt.show()
11 
12 arr = np.linspace(0, 255, 128)
13 
14 print(arr)
15 
16 arr = arr.reshape(2, -1)
17 
18 plt.axis(False)
19 
20 plt.imshow(arr, cmap = "gray", vmin = 0, vmax = 255)

 

 要求3：创建规则格网np.mgrid；

  • 创建规则网np.mgrid必须要谨记代码语法，注意j的添加，具体代码格式为

Y, x = np.mgrid[0:255:256j, 255:0:256j]

  • 网格，就必须要生成两维，所以返回的是y和x,对于y是指数学模式下的y轴，x同理是数学坐标下的x轴，注意mgrid中间逗号隔开的，就是生成y和x的数组，对于y，生成0到255,创建256行，生成二维数组，同理对于x，生成255到0，创建256行，生成二维数组，生成图像并刻画图像如下所示：

图 6 np.mgrid()创建数组和图像

  • 学习代码如下：
 1 import numpy as np
 2 import matplotlib.pyplot as plt
 3 
 4 y, x = np.mgrid[0:255:256j, 255:0:256j]
 5 
 6 print(y)
 7 
 8 print(x)
 9 
10 plt.imshow(x, cmap = "coolwarm", vmin = 0, vmax = 255)
11 
12 plt.show()
13 
14 plt.imshow(y, cmap = "rainbow", vmin = 0, vmax = 255)
15 
16 plt.show()

 

 

  • 要求4：创建随机数组np.random；

  • 对于随机数组有两种形式，整型和浮点型，对于整型，需要指定范围，对于浮点型，范围就是0到1之间的浮点数，所以不需要指定范围，如果想要更大的浮点数，可以直接乘一个扩大的倍数，注意如果创建随机数组必须记得转化数据类型，数据类型必须是np.uint8类型的，才可以正常生成图像。
  • 对于随机整数数组，我们创建了范围为0~255之间的大小为100*100*3的彩色图像，对于随机浮点数数组，我们先是创建了范围0~1的之间的大小为100*100的二维数组，并利用astype将数组装化为np.uint8,绘画图像如下所示：

图 7 随机数组创建图像

学习代码如下：

 1 arr = np.random.randint(0, 256, (100, 100, 3), dtype = np.uint8)
 2 print(arr)
 3 
 4 plt.imshow(arr, vmin = 0, vmax = 255)
 5 
 6 arr = np.random.random((100,100)) * 255
 7 
 8 arr = arr.astype(np.uint8)
 9 
10 plt.imshow(arr, vmin = 0, vmax = 255)
11 
12 plt.show()

 

 

  • 要求5：填充数组np.pad。

  • 对于填充，我们熟悉利用了np.pad进行填充，注意积累np.pad的语法格式：

arr = np.pad(y, ((100, 100), (100, 100)),mode = 'constant',

constant_values = 200)

对于y就是一个二维数组，第二个参数就是填充的大小，分别表示（（上，下），（左，右）），第三个参数mode是指填充的方式，比较常见的见下面表1，对于mode为“constant”的时候，才会存在第四个参数，表示填充的值是哪个常数。

表 1 mode各指标作用

参数

作用

edge

用边缘值填充

constant

常数填充

Linear_ramp

用边缘递减方式填充

maximum

用最大值填充

minimum

用最小值填充

mean

用平均值填充

median

用中位数填充

reflect/symmetric

对称填充

wrap

用原数组后面的值填充前面，前面的值填充后面
  • 为进一步学习熟悉np.pad,调试了mode参数进行填充，一定体会每个模式下的填充图像变化，同时注意生成的数组的特点，去理解图像的变化。明白比如最大值，是哪部分的最大值，通过调整，我们发现对于左右的填充，比较的个体是行，同理对于上下的填充，比较的个体是列，通过调整我们生成了如下不同mode下的图像，补充说明，我们生成的数组如下所示：

表 2 对应mode生成图像

参数

作用

  

edge

用边缘值填充

constant

常数填充

Linear_ramp

用边缘递减方式填充

maximum

用最大值填充

minimum

用最小值填充

mean

用平均值填充

median

用中位数填充

reflect/symmetric

对称填充

wrap

用原数组后面的值填充前面，前面的值填充后面

  • 学习代码如下：
 1 y, x = np.mgrid[0:255:100j, 255:0:100j]
 2 print(y)
 3 
 4 arr = np.pad(y, ((100, 100), (100, 100)),mode = 'constant', constant_values = 200)
 5 
 6 plt.imshow(arr, cmap = "gray", vmin = 0, vmax = 255)
 7 
 8 plt.show()
 9 
10 arr = np.pad(y, ((100, 100), (100, 100)),mode = 'reflect')
11 
12 plt.imshow(arr, cmap = "gray")
13 
14 plt.show()
15 
16 # arr = np.pad(y, ((100, 100), (100, 100)),mode = 'symmetric')
17 
18 # plt.imshow(arr, cmap = "gray")
19 
20 # plt.show()
21 
22 arr = np.pad(y, ((100, 100), (100, 100)),mode = 'edge')
23 
24 plt.imshow(arr, cmap = "gray")
25 
26 plt.show()
27 
28 # arr = np.pad(y, ((100, 100), (100, 100)),mode = 'edge')
29 
30 # plt.imshow(arr, cmap = "gray")
31 
32 # plt.show()
33 
34 arr = np.pad(y, ((100, 100), (100, 100)),mode = 'linear_ramp')
35 
36 plt.imshow(arr, cmap = "gray")
37 
38 plt.show()
39 
40 arr = np.pad(y, ((100, 100), (100, 100)),mode = 'minimum')
41 
42 plt.imshow(arr, cmap = "gray")
43 
44 plt.show()
45 
46 arr = np.pad(y, ((100, 100), (100, 100)),mode = 'maximum')
47 
48 plt.imshow(arr, cmap = "gray")
49 
50 plt.show()
51 
52 arr = np.pad(y, ((100, 100), (100, 100)),mode = 'median')
53 
54 plt.imshow(arr, cmap = "gray")
55 
56 plt.show()
57 
58 arr = np.pad(y, ((100, 100), (100, 100)),mode = 'mean')
59 
60 plt.imshow(arr, cmap = "gray")
61 
62 plt.show()
63 
64 arr = np.pad(y, ((100, 100), (100, 100)),mode = 'wrap')
65 
66 plt.imshow(arr, cmap = "gray")
67 
68 plt.show()

 

 

数组属性

  • 要求1：数组的维度ndim，数组形状shape，数组类型dtype，数组中元素的数量size；

  • 为熟悉数组的相关参数，利用第一部分要求1的学过的np.empty()生成一个100 * 100 * 3空数组，需要注意的点就是区分dtype和type的作用是不同的，dtype相当于data type,数据本身的数据类型，而type是得到python语法中几种特别的数据结构，然后输出相关参数如下表：

表 3 数组参数

参数

结果

ndim

3

shape

(100,100,3)

dtype

foat64

size

30000

type(arr)

<class ‘numpy.ndarray’>

  • 要求2：数组元素数据类型转换(数组的astype方法)，数组形状的改变(reshape)。

  • 对于astype和reshape已经才第一部分要求中使用并且有所熟悉，这里不多赘述。

数组的索引与切片：

  • 要求1：数组的索引，数组的切片；

  • 数组的索引与切片，应用于图像上，就是对图像进行裁切，我们随机生成autumn映射的假彩色灰度级图片，然后分别对右上角和左下角进行裁切，注意对于二维数组切片，第一维表示的是行，第二维表示的是列，正好和我们数学坐标轴相反，裁切图像与原图像如下所示：

QQ截图20230317075213

图 8 原图像以及裁切图

  • 学习代码如下：
 1 y, x = np.mgrid[0:255:100j, 255:0:100j]
 2 print(type(y))
 3 
 4 plt.imshow(x, cmap = "autumn",vmin = 0, vmax = 255 )
 5 
 6 plt.show()
 7 
 8 plt.imshow(x[:10, -10:], cmap = "autumn", vmin = 0, vmax = 255)
 9 
10 plt.show()
11 
12 plt.imshow(x[-10:,:10], cmap = "autumn", vmin = 0, vmax = 255)
13 
14 plt.show()

 

 

  • 要求2：二维数组的拼接为三维数组dstack。

  • 对于dstack的使用在第一部分的要求1中已经作出说明。

数组的运算：

  • 要求1：数组的四则运算，数组的乘方；

  • 数组四则运算对应到图像上，可以看做对图像进行点运算，所以对于数组四则运算，我们看效果是从图像显示出来的，首先我们进行的是反色操作，即生成数组，然后用255-该数组，进行反色处理，我们知道numpy的数组特性，相当于255减去数组中每一个数，相当于图像领域的点运算，对于数组的乘方，我们利用gama矫正，将数组首先放缩到0~1，然后进行乘方运算，最后在扩大到0~255，生成图像即可，为显示gama矫正曲线，我们先选择从0到255有序的序列，以便生成gama曲线，观察曲线增强或者减弱的效果，然后我们结合上次实验对于图片的导入，将本地自己的图片进行gama校验，但是我们生成数组做的是灰度图像的gama矫正，但是导入的图片通常是彩色图片，所以会有三个通道，所以对于曲线会生成三条，分别代表r,g,b三个通道的gama曲线，对于曲线的趋势，我们作出了猜测，就是gama校验曲线特别平缓时，应该是由于周围的颜色都是基本相同的，然后通过调整宽高的gama曲线，证明了这一观点。

图 9 原图像

图 10 gama矫正曲线（第一个图，r = 0.5,第二个图，r = 5）

                                                                  图 11 原图像

                     图 12 本地图片gama矫正图像及其曲线（第一个图，r = 0.5,第二个图，r = 50）

  • 学习代码如下：

 

  1 def gama(arr,r,name = 'gray'):
  2 
  3     # plt.axis(False)
  4 
  5     maxvalue = 255
  6 
  7     minvalue = 0
  8 
  9     ar = (arr / maxvalue) ** r * maxvalue
 10 
 11     print(ar)
 12 
 13     plt.plot(ar[:,0])
 14 
 15     plt.show()
 16 
 17     plt.imshow(ar.astype(np.uint8), cmap = name, vmin = minvalue, vmax = maxvalue)
 18 
 19     plt.show()
 20 
 21 def orginal(arr, name = 'gray'):
 22     plt.axis(False)
 23 
 24     plt.imshow(arr, cmap = name, vmin = 0, vmax = 255)
 25 
 26     plt.show()
 27 
 28 arr, x = np.mgrid[0:255:256j, 255:0:256j]
 29 
 30 arr = arr.astype(np.uint8)
 31 
 32 name = 'gray'
 33 
 34 orginal(arr,name)
 35 
 36 r = 0.5
 37 
 38 gama(arr, r, name)
 39 
 40 r = 5
 41 
 42 gama(arr, r, name)
 43 
 44 from PIL import Image
 45 
 46 import matplotlib.pyplot as plt
 47 
 48 img = Image.open('./images/花落夏海.jpg')
 49 
 50 img.show()
 51 
 52 arr = np.array(img)
 53 
 54 arr
 55 
 56 def gama(arr,r,name = 'gray'):
 57 
 58     maxvalue = arr.max()
 59 
 60     minvalue = 0
 61 
 62     print(maxvalue)
 63 
 64     ar = (arr / maxvalue) ** r * maxvalue
 65 
 66     plt.plot(ar[:,0,:])
 67 
 68     ar1 = ar[:,0, :]
 69 
 70     print(ar1.shape)
 71 
 72     print(ar1)
 73 
 74     print(ar.shape)
 75 
 76     plt.show()
 77 
 78     plt.axis(False)
 79 
 80     plt.imshow(ar.astype(np.uint8), cmap = name, vmin = minvalue, vmax = maxvalue)
 81 
 82     plt.show()
 83 
 84 def orginal(arr, name = 'gray'):
 85 
 86     plt.axis(False)
 87 
 88     plt.imshow(arr, cmap = name, vmin = 0, vmax = 255)
 89 
 90     plt.show()
 91 
 92 name = 'gray'
 93 
 94 arr = arr.astype(np.uint8)
 95 
 96 orginal(arr, name)
 97 
 98 gama(arr, 0.5, name)
 99 
100 gama(arr, 50, name)

 

 

 

  • 要求2：数组的矢量化操作vectorize，与通用点运算的关系；

  • Vectorize理解为一种矢量化方法，首先学习其中的参数
 1 numpy.vectorize(pyfunc, otypes=None, doc=None, excluded=None, cache=False, signature=None)
 2 Parameters: 
 3 
 4 pyfunc :python函数或方法
 5 
 6 otypes : 输出数据类型。必须将其指定为一个typecode字符串或一个数据类型说明符列表。每个输出应该有一个数据类型说明符。
 7 
 8 doc : 函数的docstring。如果为None，则docstring将是 pyfunc.__doc__。
 9 
10 excluded : 表示函数不会向量化的位置或关键字参数的字符串或整数集。这些将直接传递给未经修改的pyfunc
11 
12 cache :如果为True，则缓存第一个函数调用，该函数调用确定未提供otype的输出数。
13 
14 signature : 广义通用函数签名，例如，(m,n),(n)->(m)用于矢量化矩阵 - 向量乘法。
15 
16 如果提供的话，pyfunc将调用（并期望返回）具有由相应核心维度的大小给出的形状的数组。默认情况下，pyfunc假定将标量作为输入和输出。
17 
18 Returns: vectorized :向量化的数组

 

 1

 

 

  • 语法使用过程，自己的总结，首先需要定义一个方法对象，该方法对象包含一个方法其实就是一个匹配函数，如果你写过c++语言里的sort函数，你就会知道里面的cmp和这里的方法有异曲同工之妙，之后再利用该方法对象实例一个对象，传进参数，就可以进行特殊点运算，比如让某个颜色区间都变成一个颜色，其余区间变成一个颜色，在这个过程中，同样使用灰度图像假彩色显示，并调试cmap映射规则，学习到一个映射规则+‘_r’是指逆反过来的颜色，r其实猜测一下，就是英文中的“reverse”,比如“rainbow”和“rainbow_r”,会映射得到两个相反的颜色图像，得到不同的图像，对应的点运算规则图像和假彩色图像如下所示

                                                         图 13 点运算规则以及运算图像

  • 学习代码如下：
 1 def figure(arr, name):
 2     plt.imshow(arr.astype(np.uint8), cmap = name, vmin = 0, vmax = 255)
 3 
 4     plt.show()
 5 
 6 def thesh(x, a = 100, b = 200):
 7 
 8     if x > a and x < b:
 9 
10         return 0
11 
12     return 255
13 
14 arr = [np.arange(0, 256)] * 100
15 
16 arr = np.array(arr)
17 
18 print(arr)
19 
20 vector = np.vectorize(thesh, otypes = (np.uint8,), excluded=['a', 'b'])
21 
22 arr = vector(arr, 75, 100)
23 
24 plt.plot(arr[0])
25 
26 plt.show()
27 
28 figure(arr, 'autumn')
29 
30 figure(arr, 'autumn_r')
31 
32 figure(arr, 'rainbow')
33 
34 figure(arr, 'rainbow_r')
35 
36 figure(arr, 'gray')
37 
38 figure(arr, 'gray_r')
39 
40 import numpy as np
41 
42 import matplotlib.pyplot as plt
43 
44 def thesh(x, a = 100, b = 200, th = 150):
45 
46     if x < a or x > b:
47 
48         return x
49 
50     return th
51 
52 vector = np.vectorize(thesh, otypes=(np.uint8,), excluded=['a', 'b', 'th'])
53 
54 arr = [np.arange(0, 256)] * 100
55 
56 arr = np.array(arr)
57 
58 arr = vector(arr, 50, 100, 255)
59 
60 plt.plot(arr[0])
61 
62 plt.show()
63 
64 figure(arr, 'rainbow')

 

 

  • 要求3：数组沿轴操作apply_along_axis，与邻域运算的关系。

  • 这里我们熟悉使用apply_along_axis，我们将利用彩色图像转化为灰度图像的案例去熟悉使用apply_along_axis,由于np.vectorize也可以进行如上转化，所以同样也为了熟悉np.vectorize方法，用两种方法进行转化。
  • 首先介绍一下apply_along_axis的语法，arr = np.apply_along_axis(rgbTransformGray,2,ar1)， 对于第一个参数，同np.vectorize一样，是一个匹配规方法，对于第二个参数，分析apply_along_axis的名称涵义，沿着某一个轴进行操作，所以第二个参数必须指明按照那个轴进行操作，0是指第一维，1是指第二维，而2则是指第三维，我们这里就是要沿着第三维，进行切分，对于第三个参数，则需要传进一个三维数组，相当于彩色图像的r,g,b三维，不过这里直接返回的是数组，不需要像np.vectorize方法，需要定义方法对象，再去实例化对象。
  • 对了，对于匹配规则函数，我们转化灰度图像，都基本用的是三个通道的最大值进行转化，当然也可以去最大值和最小值的一半，相关图像如下所示：

图 14 两种转化方式的彩色图像和灰度图像

  • 学习代码如下：
 1 def figure(arr, name):
 2     plt.imshow(arr.astype(np.uint8), cmap = name, vmin = 0, vmax = 255)
 3 
 4     plt.show()
 5 
 6 r = arr
 7 
 8 g = 255 - arr
 9 
10 b = np.zeros_like(g)
11 
12 # 彩色图转化为灰度图像
13 
14 def thesh(r, g, b):
15 
16     list1 = []
17 
18     list1.append(r)
19 
20     list1.append(b)
21 
22     list1.append(g)
23 
24     arr = np.array(list1)
25 
26     mn = arr.min()
27 
28     mx = arr.max()
29 
30     return mx
31 
32 name = 'gray'
33 
34 ar1 = np.dstack([r, g, b])
35 
36 figure(ar1, name)
37 
38 vector = np.vectorize(thesh, otypes=(np.uint8,), excluded=['r', 'g', 'b'])
39 
40 arr = vector(r, g, b)
41 
42 name = 'gray'
43 
44 figure(arr, name)
45 
46 def rgbTransformGray(rgb):
47 
48     mx = rgb.max()
49 
50     mn = rgb.min()
51 
52     return mx
53 
54 name = 'gray'
55 
56 ar1 = np.dstack([r, g, b])
57 
58 figure(ar1, name)
59 
60 arr = np.apply_along_axis(rgbTransformGray,2,ar1)
61 
62 figure(arr, name)

 

 

补充

  • np.split函数的使用 ：
  • np.split(ary, indices_or_sections, axis=0)
  • 函数功能：
  • 把一个数组从左到右按顺序切分
  • 参数：
  • ary：要切分的数组
  • indices_or_sections：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置
  • axis：沿着哪个维度进行切向，默认为0，横向切分
  • 学习代码如下：
 1 import numpy as np
 2 
 3 x = np.array([0,1,2,3,4,5,6,7,8])
 4 print (np.split(x,3)）
 5 
 6 print (np.split(x,[3,5,6,9]))
 7 
 8 print（np.split(x,[3,5,6,8])）
 9 
10 输出：
11 
12 [array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
13 
14 [array([0, 1, 2]), array([3, 4]), array([5]), array([6, 7, 8]), array([], dtype=int32)]
15 
16 [array([0, 1, 2]), array([3, 4]), array([5]), array([6, 7]), array([8])]
17 
18 # 实验代码
19 
20 r, g, b = np.split(arr,3, 2)
21 
22 print(type(r))
23 
24 print(r.shape)
25 
26 plt.imshow(r, cmap = "gray", vmin = 0, vmax = 255)
27 
28 plt.show()
29 
30 plt.imshow(r1, cmap = "gray", vmin = 0, vmax = 255)
31 
32 plt.show()
33 
34 arr = np.dstack([r, g, b])
35 
36 plt.imshow(arr, cmap = "gray", vmin = 0, vmax = 255)
37 
38 plt.show()

 

 

结果分析
  • 分析实验结果。

通过这次实验,我们学习了基础的图像方面有关点运算的操作，并且实操了gama矫正等点运算，联系到第二次实验，我们利用Image将自己本地的图片进行操作，同样进行了gama矫正，图像得到了增亮和压暗，同时我们也熟悉了图像处理邻域运算方面的知识，实现了对于改变某个区间的像素值的操作，同时也熟悉了对于彩色图像转化为灰度图像的过程，这些都增加了我们对图像处理的兴趣。
posted @ 2023-03-17 18:26  哲远甄骏  阅读(93)  评论(0)    收藏  举报