使用Python进行基本图像数据分析

本教程将介绍如何导入图像并观察其属性、拆分图层以及查看灰度。在正式开始

之前，我们先来了解一些关于像素的基础知识。

计算机将图片以像素形式存储，这就像马赛克一样。如果像素太大，很难制作光

滑的边缘和曲线。相反，我们使用的像素越多越小，看起来就会越平滑，或者说

像素化程度越小，图像就会越好看，有时，这也被称为图像分辨率。

矢量图形是一种有点不同的存储图像方法，旨在避免与像素相关的问题。但是,

即使是矢量图像，最终也会显示为像素一样的马赛克。颜色像素表示图像元素,

描述每个像素的简单方法是使用三种颜色的组合，即红色，绿色，蓝色，这就是

我们所说的RGB图像.

在RGB图像中，每个像素分别与红色，绿色，蓝色的值相关联的三个8比特数

字表示。最后，如果使用放大镜观察缩放的图片，我们会看到图片由微小的光点

或更具体的像素组成，更有趣的是这些小光点实际上具有多个不同颜色。

每张照片都以数字形式由像素组成，它们是构成图片的最小信息单位，通常是圆

形或方形，它们通常布置在二维网格中。

23x22«506Pixels

Eachpixelcoordinate(x,y)contains3valuesrangingforintensitiesof0to255(8btt)

-Red-Green-Blue

Mixingdifferentintensitiesofeachcolorgivesusthefullcolorspectrum.

OnePixelConsist

With3Channels/

Layers

Rchannel

Range:0-255

Range:0-255◎rm后惶客

如果三个颜色都处于最大值，则意味着它们是255,那就会显示为白色，如果三

种颜色都处于最小值，或者值为0,则颜色显示为黑色。反过来，这三者的组合

将为我们提供特定的像素颜色。由于每个颜色数字都是8个比特，因此值范围为

0-255o

Decimal

RGB

9511748

DarkGreen

R:37.3%Binary

G:45.9%

B;18.8%

R:01011111

G:011-|0101

B:00110000

姆客

由于每个值可以具有256个不同的强度或亮度值，因此三种颜色总共有168()万

个shadeo

以下是Numpyand非常基本的图像数据分析步骤,其中一些涉及Pythonpacakges,

如imageio,matplotlib等。

"导入图像并观察其属性

・拆分图层

■Greyscale

对像素值使用逻辑运算符

使用逻辑运算符进行运算

卫星图像数据分析

导入图像

现在让我们加载图像并观察各种属性：

1.if_name—=='—main—

2.importimageio

3.importmatplotlib.pyplotaspit

4.%matplotlibinline

5.pic=imageio.imrcad('F:/dcmo_2.jpg')

6.plt.figure(figsize=(15,15))

7.plt.imshow(pic)观察图像的基本属性

8.print('Typeoftheimage:*,type(pic))

9.print('Shapeoftheimage:{}'.format(pic.shape))

10.print('ImageHight{},.format(pic.shape[0]))

11.print('ImageWidth{}'.format(pic.shape[l]))

12.print('DimensionofImage{}'.format(pic.ndim))

13.Typeoftheimage:<class'imageio.core.ntil.Image^

14.Shapeoftheimage:(562,960,3)

15.ImageHight562

16.ImageWidth960

17.DimensionofImage3

ndarray的形状表明它是一个三层矩阵，这里的前两个数字是长度和宽度，第三

个数字(即3)是三层:Red,Green,Blueo因此，如果我们计算RGB图像的大

小，则总大小将计为heightxwidthx3

1.print('Imagesize{l'.fonnat(pic.size))

2.print('MaxiniumRGBvalueinthisimage()'.format(pic.max()))

3.print('MinimumRGBvalueinthisimage{}'.fbrmat(pic.min()))

4.Imagesize1618560

5.MaximumRGBvalueinthisimage255

6.MinimumRGBvalueinthisimage0

这些值对于验证很重要，因为8比特颜色强度不能超出0到255范围。

现在，使用图片分配变量，我们还可以访问图片的任何特定像素值，并进一步访

问每个RGB通道。

1.

2.Let'spickaspecificpixellocatedat100thRowsand50thColumn.

3.AndviewtheRGBvaluegradually.

4.

5.pic[100,50]

6.Image。109,143,46J,dtypc=uint8)

在这种情况下：R=1()9;G=143;B=46,我们可以意识到这个特殊像素中有很

多绿色。现在，我们可以通过给出三个通道的索引值来特别选择其中一个数字:

-()红色通道的索引值

・1绿色通道的索引值

-2蓝色通道的索引值

但是，在OpenCV中，图像不是RGB而是BGR,imageio.imread将图像加或为

RGB(或RGBA),但OpenCV假定图像为BGR或BGRA(BGR是默认的OpenCV

颜色格式)。

1.#AspecificpixellocatedatRow:100;Column:50

2.#Eachchannel'svalueofit,graduallyR,G,B

3.print('ValueofonlyRchannel{),.format(pic[100,50,()]))

4.print('ValueofonlyGchannel{),.format(pic[100,50,1]))

5.print('ValueofonlyBchannel{),.format(pic[100,50,2]))

1.ValueofonlyRchannel109

2.ValueofonlyGchannel143

3.ValueofonlyBchannel46

好的，现在让我们快速查看整个图像中的每个频道。

1.plt.title('Rchannel')

2.plt.ylabel('Height{}*.format(pic.shape[0]))

3.plt.xlabel('Width{}'.fonnat(pic.shape[1]))

4.plt.imshow(pic[:,:,0])

5.plt.show()

Rchannel

01

■

0200400600800

Width960

1.plt.titlc('Gchannel)

2.plt.ylabel('Height{),.fonnat(pic.shape[0]))

3.plt.xlabel('Width{}'.format(pic.sh叩e[l]))

4.plt.imshow(pic[:,:,1])

5.plt.show()

Gchannel

0

o

N20

930

S40o

币

工

o

0200400600800

Width960

创TPD溯客

1.plt.titlcCBchanncF)

2.plt.ylabeKHeight{}.fonnat(pic.shape|()]))

3.plt.xlabel('Width{},.fonnat(pic.shape[l]))

4.plt.imshow(pic[:,:,2])

5.plt.show()

Bchannel

0

o

Z

9

S

N

620o

a30

H40

o

500

0200400600800

Width960

现在，我们可以更改RGB值的数量。例如，让我们对红色、绿色、蓝色图层设

置跟随行值的强度。

・R频道：行・100到110

-G频道：行-200至IJ210

■B频道：行-300到310

我们将加载一次图像，以便可以同时显示每个层的变化。

1.pic=imageio.imread('H/demo_2.jpg')

2.pic[50:150,:,0]=255#fullintensitytothosepixefsRchannel

3.plt.figure(figsize=(10,10))

4.plt.imshow(pic)

5.plt.show()

1.pic[200:300,:,1]=255#fullintensitytothosepixel'sGchannel

2.plt.figure(figsize=(10,10))

3.plt.imshow(pic)

4.plt.show()

1.pic[350:450,:,2]=255#fullintensitytothosepixel'sBchannel

2.plt.figure(figsize=(10,1()))

3.plt.iinshow(pic)

为了更清楚，让我们也改变列部分，这次我们将同时更改RGB通道。

1.#setvalue200ofallchannelstothosepixelswhichturnsthemtowhite

2.pic[50:450,400:600,[0,1,2]]=200

3.plt.figure(figsize=(10,10))

4.plt.imshow(pic)

5.plt.show()

0

100

200

300

400

500

0200400600800

拆分图层

现在，我们知道图像的每个像素都由三个整数表示，将图像分割成单独的颜色分

片只需拉出图像阵列的正确切片。

1.importnumpyasnp

2.pic=imageio.imread('F:/demo_2.jpg')

3.fig,ax=plt.subplots(nrows=1,ncols=3,figsize=(15,5))

4.forc,axinzip(range(3),ax):

5.#createzeromatrix

6.splitting=np.zeros(pic.shape,dtype="uint8")#'dtype'bydefault:'numpy.float64'

7.#assingeachchannel

8.split_img[:,:,c]=pic[:,c]

9.#displayeachchannel

1().ax.imshow(split_img)

200400€0080002004006008000200400€00喇仃却说.客

灰度

黑白图像存储在二维阵列中，有两种类型的黑白图像:

・Greyscale：灰色阴影范围：0-255

■Binary：像素为黑色或白色：0或255

现在，Greyscaling是一个将图像从全色转换为灰色阴影的过程。在图像处理工具

中，例如：在OpenCV中，许多功能在处理之前使用灰度图像，这样做是因为它

简化了图像，几乎可以降噪并增加处理时间，因为图像中的信息较少。

在python中有两种方法可以将图像转换为灰度，但使用matplotlib的简单方法是

使用此公式获取原始图像的RGB值的加权平均值。

1.Y'=0.299R+0.587G+0.114B

1.pic=imagcio.imrcad('F:/dcmo_2.jpg')

2.gray=lambdargb:np.dot(rgb[...,:3],[0.299,0.587,0.114])

3.gray=gray(pic)

4.plt.figure(figsize=(10,10))

5.plt.imshow(gray,cmap=plt.gct_cmap(name='gray'))

6.plt.show()

然而，GIMP将颜色转换为灰度图像软件有三种算法来完成任务。

灰度的Lightness等级计算为

1.Lightness=%x(max(R,G,B)+min(R,G,B))

灰度的Luminosity等级计算为

1.Luminosity=0.21xR+0.72xG+0.07xB

灰度的Average计算为

1.AverageBrightness=(R+G+B)-r3

让我们尝试一下算法，Luminosity效果如何？

1.pic=imageio.imread('F:/demo_2.jpg')

2.gray=lambdargb:np.dot(rgb|...,:3],|0.21,0.72,0.07])

3.gray=gray(pic)

4.plt.figure(figsize=(10,10))

5.plt.imshow(gray,cmap=plt.get_cmap(name='gray'))

6.plt.shovv()

7.

8.Let'stakeaquickoverviewsomethechangedpropertiesnowthecolorimage.

9.Likeweobservesomepropertiesofcolorimage,samestatementsareapplying

10.nowforgrayscaledimage.

ll.,n

12.print('Typeoftheimage:',type(gray))

13.print()

14.print('Shapeoftheimage:{)'.format(gray.shape))

15.print('ImageHight{}'.format(gray.shape[0]))

16.print('IrnageWidth{}'.format(gray.shape[1]))

17.print('DimensionofImage{),.foiTnat(gray.ndim))

18.print()

19.print('Imagesize{),.fonnat(gray.size))

20.print('MaximumRGBvalueinthisimage{}'.format(gray.max()))

21.print('N4inimumRGBvalueinthisimage{J'.formatCgray.minO))

22.printCRandomindexes[X,Y]:{}*.format(gray[100,50]))

23.Typeoftheimage:<class'imagcio.corc.utiLImagc'>

24.Shapeoftheimage:(562,960)

25.ImageHeight562

26.ImageWidht960

27.DimensionofImage2

28.Imagesize539520

29.MaximumRGBvalueinthisimage254.9999999997

30.MinimumRGBvalueinthisimage0.0

31.Randomindexes[X,Y]:129.07

使用逻辑运算符处理像素值

我们可以使用逻辑运算符创建相同大小的bullionndarray。但是，这不会创建任

何新数组，它只是将值返回到其主变量。例如，如果考虑在RGB图像中滤除一

些低值像素或高值或(任何条件)，可以先将RGB转换为灰度。

首先加载图像并在屏幕上显示：

1.pic=imageio.imread('F:/demo_1.jpg')

2.plt.figure(figsize=(10,10))

3.pll.imshow(pic)

4.plt.shovv()

接下来，我们考虑转储该图像，比如我们想要过滤所有低于20的像素值。为此,

我们将使用逻辑运算符执行此任务，返回所有索引的True值。

1.low_pixel=pic<20

2.#toensureofitlet'scheckifallvaluesinlow_pixclarcTrueornot

3.iflow_pixeLany()==True:

4.print(low_pixel.shape)

5.(1079,1293,3)

正如上文所说，传统上不使用宿主变量，但我之所以提到是因为它只保留True

值。所以，如果我们看到low_pixel和pic的sh叩e,我们会发现它们都具有相

同的shape。

1.print(pic.shape)

2.print(low_pixel.shape)

3.(1079,1293,3)

4.(1079,1293,3)

我们使用全局比较运算符为所有小于20()的值生成低值滤波器。但是，我们可以

使用此low_pixel数组作为索引将这些低值设置为某些特定值，这些值可能高于

或低于先前的像素值。

1.#randomlychooseavalue

2.importrandom

3.#loadtheorginalimage

4.pic=imageio.imread('F:/demo」.jpg')

5.#setvaluerandomlyrangefrom25to225-thesevaluealsorandomlychoosen

6.pic[low_pixel]=random.randint(25,225)

7.#displaytheimage

8.plt.figure(figsize=(10,10))

9.plt.imshow(pic)

10.plt.show()

0

20040060080010001200酊M3睥容

图层蒙版

图像蒙版是一种图像处理技术，用于去除具有模糊边缘，透明或头发部分的照片

背景C

现在，我们将创建一个圆盘形状的蒙版。首先，我们将测量从图像中心到每个边

界像素值的距离。我们设置一个比较方便的半径值，然后使用逻辑运算符创建一

个圆盘，以下为代码：

1.if_name—=='—main_*:

2.#loadtheimage

3.pic=iinageio.imread('F:/demo_1.jpg')

4.#seperatetherowandcolumnvalues

5.total_row,total_col,layers=pic.shape

6.,n

7.Createvector.

8.Ogridisacompactmethodofcreatingamultidimensional-

9.ndaiTayoperationsinsinglelines.

1().forex:

11.»>ogridf0:5,0:51

12.output:[array([[0],

13.1U,

14.[2],

15.[3],

16.[4]]),

17.array([[0,1,2,3,4]])]

18.”'

19.x,y=np.ogrid[:total_row,:total_col]

20.#getthecentervaluesoftheimage

21.cen_x,cen_y=total_row/2,total_col/2

22.m

23.Measuredistancevaluefromcentertoeachborderpixel.

24.Tomakeiteasy,wecanthinkit'slike,wedrawalinefromcenter-

25.toeachedgepixelvalue—>s**2=(Y-y)**2+(X-x)**2

26.切

27.distance_from_the_center=np.sqrt((x-cen_x)**2+(y-cen_y)**2)

28.#Selectconvenientradiusvalue

29.radius=(toial_row/2)

30.#Usinglogicaloperator'>'

31.m

32.logicaloperatortodothistaskwhichwillreturnasavalue

33.ofTrueforalltheindexaccordingtothegivencondition

34.,n

35.circular_pic=distance_from_the_center>radius

36.

37.letassignvaluezeroforallpixelvaluethatoutsidethecirulardisc.

38.Allthepixelvalueoutsidethecirculardisc,willbeblacknow.

39.

40.pic[circular_pic]=0

41.plt.figure(figsize=(10,10))

42.pll.imshow(pic)

43.plt.show()

卫星图像处理

卫星图像及其处理系统非常有用，我们可以用于做一些分析任务。

1.#loadtheimage

2.pic=imageio.imread('F:satimg.jpg')

3.plt.figure(figsize=(10,10))

4.plt.imshow(pic)

5.plt.show()

3500

4000令