【2.9.1】matplotlib高级教程之形状与路径——patches和path

June 17, 2019 matplotlib 阅读量：次

一、什么是形状和路径

在一般的使用matplotlib进行绘图的时候，线形图、条形图、折线图、扇形图等等都是我们常见的一些绘图函数，但是有时候我们需要绘制一些特殊的形状和路径，比如我们要绘制一个椭圆，我们当然可以通过椭圆的函数表达式，然后选取一系列的（x,y)的坐标值进行依次相连，但是这样效率低下，而且不太好看。

1、形状

指的是matplotlib.patches包里面的一些列对象，比如我们常见的箭头，正方形，椭圆等等，也称之为“块”

2、路径

什么是路径？

表示一系列可能断开的、可能已关闭的线和曲线段。

指的是matplotlib.path里面所实现的功能，最简单的路径就是比如一条任意的曲线都可以看成是路径。比如我要绘制一个心形，就需要通过路径去完成。

但是画图我们说最重要的是画图的步骤，下面以椭圆为例详细讲解绘制基本形状的一般步骤。

二、形状的画图步骤：

2.1 第一步：创建画图对象以及子图

这一步和前面的一般画图方式没有什么区别，主要实现以下两句话

fig = plt.figure()
ax = fig.add_subplot(211, aspect='auto')

2.2 第二步：创建相对应的形状——创建椭圆

e1 = patches.Ellipse((xcenter, ycenter), width, height,angle=angle, linewidth=2, fill=False, zorder=2)

等价于：

e2 = patches.Arc((xcenter, ycenter), width, height,angle=angle, linewidth=2, fill=False, zorder=2)

因为Arc是继承自Ellipse类的，故而等价。

注意：上面的椭圆是通过patches包里面的类完成的，如果是比较常用的，比如Circle，也可以通过plt去实现。即

c1=plt.Circle(相关参数）

plt只实现了常用的几个，如Rectangle、Circle、Polygon这三个，它们可以通过plt.xxxx()的形式加以创建，如果要创建更多类型更复杂的图形，则使用patches模块。

补充：创建一个图形实际上就是调用它的构造函数即可，但是构造函数有许多的参数可选，这里不一一说明，仅仅以椭圆Arc为例加以说明，其他图形可以查看定义或者是相关文档：

有效的参数如下：

Property	Description
agg_filter	a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
alpha	float or None
animated	bool
antialiased	unknown
capstyle	{‘butt’, ‘round’, ‘projecting’}
clip_box	Bbox
clip_on	bool
clip_path	[(Path, Transform)
color	color
contains	callable
edgecolor	color or None or ‘auto’
facecolor	color or None
figure	Figure
fill	bool
gid	str
hatch	{'/', ‘', '
in_layout	bool
joinstyle	{‘miter’, ‘round’, ‘bevel’}
label	object
linestyle	{'-’, ‘–’, ‘-.’, ‘:’, ‘’, (offset, on-off-seq), …}
linewidth	float or None for default
path_effects	AbstractPathEffect
picker	None or bool or float or callable
rasterized	bool or None
sketch_params	(scale: float, length: float, randomness: float)
snap	bool or None
transform	Transform
url	str
visible	bool
zorder	float

2.3 第三步：将图形添加到图中——这是非常核心的一步

光创建一个图形对象还不够，还需要添加进“ Axes ”对象里面去，即我们所创建的ax对象，使用它的add_patch()方法

ax.add_patch(e1)
ax.add_patch(e2)

除此之外，还可以将每一个形状先添加到一个集合里面，然后再将容纳了多个patch对象的集合添加进ax对象里面，等价如下：

patches=[]      #创建容纳对象的集合

patches.append(e1)   #将创建的形状全部放进去

patches.append(e2)

collection=PatchCollection(patches)  #构造一个Patch的集合

ax.add_collection(collection)    #将集合添加进axes对象里面去

plt.show() #最后显示图片即可

上述案例的完整代码如下

import numpy as np
from matplotlib import patches
import matplotlib.pyplot as plt

#绘制一个椭圆需要制定椭圆的中心，椭圆的长和高
xcenter, ycenter = 1,1
width, height = 0.8,0.5
angle = -30  #椭圆的旋转角度

#第一步：创建绘图对象
fig = plt.figure()
ax = fig.add_subplot(211, aspect='auto')
ax.set_xbound(-1,3)
ax.set_ybound(-1,3)

#第二步
e1 = patches.Ellipse((xcenter, ycenter), width, height,
                     angle=angle, linewidth=2, fill=False, zorder=2)

#第三步
ax.add_patch(e1)

#第一步
ax = fig.add_subplot(212, aspect='equal')
ax.set_xbound(-1,3)
ax.set_ybound(-1,3)

#第二步
e2 = patches.Arc((xcenter, ycenter), width, height,
                     angle=angle, linewidth=2, fill=False, zorder=2)

#第三步
ax.add_patch(e2)

plt.show()

使用集合的源代码如下：

import numpy as np
from matplotlib import patches
import matplotlib.pyplot as plt
from matplotlib.collections import PatchCollection


#绘制一个椭圆需要制定椭圆的中心，椭圆的长和高
xcenter, ycenter = 1,1
width, height = 0.8,0.5
angle = -30  #椭圆的旋转角度

fig = plt.figure()
ax = fig.add_subplot(211, aspect='auto')
ax.set_xbound(-1,3)
ax.set_ybound(-1,3)

e1 = patches.Ellipse((0, 0), width, height,
                     angle=angle, linewidth=2, fill=False, zorder=2)

e2 = patches.Arc((2, 2), width=3, height=2,
                     angle=angle, linewidth=2, fill=False, zorder=2)


patches=[]
patches.append(e1)
patches.append(e2)
collection=PatchCollection(patches)
ax.add_collection(collection)

运行结果如下：

三、patches模块中类型大全

patches所有的类型都在matplotlib.patches包中，因此需要事先导入

Classes

Arc(xy, width, height[, angle, theta1, theta2]) An elliptical arc.
Arrow(x, y, dx, dy[, width]) An arrow patch.
ArrowStyle ArrowStyle is a container class which defines several arrowstyle classes, which is used to create an arrow path along a given path.
BoxStyle BoxStyle is a container class which defines several boxstyle classes, which are used for FancyBboxPatch.
Circle(xy[, radius]) A circle patch.
CirclePolygon(xy[, radius, resolution]) A polygon-approximation of a circle patch.
ConnectionPatch(xyA, xyB, coordsA[, …]) A ConnectionPatch class is to make connecting lines between two points (possibly in different axes).
ConnectionStyle ConnectionStyle is a container class which defines several connectionstyle classes, which is used to create a path between two points.
Ellipse(xy, width, height[, angle]) A scale-free ellipse.
FancyArrow(x, y, dx, dy[, width, …]) Like Arrow, but lets you set head width and head height independently.
FancyArrowPatch([posA, posB, path, …]) A fancy arrow patch.
FancyBboxPatch(xy, width, height[, …]) Draw a fancy box around a rectangle with lower left at xy*=(*x, y) with specified width and height.
Patch([edgecolor, facecolor, color, …]) A patch is a 2D artist with a face color and an edge color.
PathPatch(path, **kwargs) A general polycurve path patch.
Polygon(xy[, closed]) A general polygon patch.
Rectangle(xy, width, height[, angle]) Draw a rectangle with lower left at xy = (x, y) with specified width, height and rotation angle.
RegularPolygon(xy, numVertices[, radius, …]) A regular polygon patch.
Shadow(patch, ox, oy[, props]) Create a shadow of the given patch offset by ox, oy.
Wedge(center, r, theta1, theta2[, width]) Wedge shaped patch.

图形的综合应用案例

import matplotlib.pyplot as plt
import numpy as np
import matplotlib.path as mpath
import matplotlib.lines as mlines
import matplotlib.patches as mpatches
from matplotlib.collections import PatchCollection

#定义函数，给每一个patch都设置标签说明
def label(xy, text):
    y = xy[1] - 0.15  # 标签放置在patch下方的0.15位置处
    plt.text(xy[0], y, text, ha="center", family='sans-serif', size=14)


fig, ax = plt.subplots()
# 创建一个3x3的网格
grid = np.mgrid[0.2:0.8:3j, 0.2:0.8:3j].reshape(2, -1).T

#创建容纳patch的集合
patches = []

# 添加一个圆Circle
circle = mpatches.Circle(grid[0], 0.1, ec="none")
patches.append(circle) 
label(grid[0], "Circle")

# 添加一个Rectangle
rect = mpatches.Rectangle(grid[1] - [0.025, 0.05], 0.05, 0.1, ec="none")
patches.append(rect)
label(grid[1], "Rectangle")

# 添加一个楔形，即圆的一部分
wedge = mpatches.Wedge(grid[2], 0.1, 30, 270, ec="none")
patches.append(wedge)
label(grid[2], "Wedge")

# 添加一多边形，这里添加一个五边形
polygon = mpatches.RegularPolygon(grid[3], 5, 0.1)
patches.append(polygon)
label(grid[3], "Polygon")

# 添加一个椭圆，也可以使用Arc
ellipse = mpatches.Ellipse(grid[4], 0.2, 0.1)
patches.append(ellipse)
label(grid[4], "Ellipse")

# 添加一个箭头
arrow = mpatches.Arrow(grid[5, 0] - 0.05, grid[5, 1] - 0.05, 0.1, 0.1,
                       width=0.1)
patches.append(arrow)
label(grid[5], "Arrow")

# 添加一个路径path，路径的详细解释后面会讲到，相比于简单的patch，稍显复杂
Path = mpath.Path
path_data = [
    (Path.MOVETO, [0.018, -0.11]),
    (Path.CURVE4, [-0.031, -0.051]),
    (Path.CURVE4, [-0.115, 0.073]),
    (Path.CURVE4, [-0.03, 0.073]),
    (Path.LINETO, [-0.011, 0.039]),
    (Path.CURVE4, [0.043, 0.121]),
    (Path.CURVE4, [0.075, -0.005]),
    (Path.CURVE4, [0.035, -0.027]),
    (Path.CLOSEPOLY, [0.018, -0.11])]
codes, verts = zip(*path_data)
path = mpath.Path(verts + grid[6], codes)
patch = mpatches.PathPatch(path)
patches.append(patch)
label(grid[6], "PathPatch")

# 添加一个box
fancybox = mpatches.FancyBboxPatch(
    grid[7] - [0.025, 0.05], 0.05, 0.1,
    boxstyle=mpatches.BoxStyle("Round", pad=0.02))
patches.append(fancybox)
label(grid[7], "FancyBboxPatch")

# 添加一条折线——注意这里的折线和前面所画的这显示不一样的，这里的折线是一个形状
x, y = np.array([[-0.06, 0.0, 0.1], [0.05, -0.05, 0.05]])
line = mlines.Line2D(x + grid[8, 0], y + grid[8, 1], lw=5., alpha=0.3)
label(grid[8], "Line2D")

colors = np.linspace(0, 1, len(patches))
#将patch集合包装成PatchCollection
collection = PatchCollection(patches, cmap=plt.cm.hsv, alpha=0.3)
collection.set_array(np.array(colors))
#将PatchCollection添加给axes对象
ax.add_collection(collection) 
#将折线添加到axes对象
ax.add_line(line)

plt.axis('equal')
plt.axis('off')
plt.tight_layout()

plt.show()

四、路径path

4.1实例

路径里面所涉及到的类容相对较多，这里只介绍简单的应用。首先通过一个例子加以说明。这个例子是要绘制一个简单的矩形路径。

import matplotlib.pyplot as plt
from matplotlib.path import Path
import matplotlib.patches as patches

#import matplotlib.patheffects
#import matplotlib.transforms

verts = [
    (0., 0.), # 矩形左下角的坐标(left,bottom)
    (0., 1.), # 矩形左上角的坐标(left,top)
    (1., 1.), # 矩形右上角的坐标(right,top)
    (1., 0.), # 矩形右下角的坐标(right, bottom)
    (0., 0.), # 封闭到起点    ]

codes = [Path.MOVETO,
         Path.LINETO,
         Path.LINETO,
         Path.LINETO,
         Path.CLOSEPOLY,
         ]

path = Path(verts, codes) #创建一个路径path对象

#依然是三步走
#第一步：创建画图对象以及创建子图对象
fig = plt.figure()
ax = fig.add_subplot(111)

#第二步：创建一个patch，路径依然也是通过patch实现的，只不过叫做pathpatch
patch = patches.PathPatch(path, facecolor='orange', lw=2)

#第三步：将创建的patch添加到axes对象中
ax.add_patch(patch)

#显示
ax.set_xlim(-2,2)
ax.set_ylim(-2,2)
plt.show()

总结：通过上面的例子显示，绘制 “路径” 的过程和绘制普通的 “patch” 是大致一样的，依然是遵循一个 “三步走”的步骤，核心在于第二步，也是要创建一个PathPatch对象，它也是来自于patches包，和普通的rectangle，circle是等价的概念，

patch = patches.PathPatch(path, facecolor=‘orange’, lw=2)

但是这里的path对象是要事先自己创建的。

总结：实际上，matplotlib中的rectangle、circle、polygon等所有简单的简单图形都采用简单的路径path去实现的，只不过用类的形式进行了更高级的封装。像直方图hist () 和条形图bar ()这样的绘图函数创建了许多基元图像，它们的本质也是通过路径去实现的,

import matplotlib.path as mpath
import matplotlib.patches as mpatches
import matplotlib.pyplot as plt


fig, ax = plt.subplots()

Path = mpath.Path
path_data = [
    (Path.MOVETO, (1.58, -2.57)),
    (Path.CURVE4, (0.35, -1.1)),
    (Path.CURVE4, (-1.75, 2.0)),
    (Path.CURVE4, (0.375, 2.0)),
    (Path.LINETO, (0.85, 1.15)),
    (Path.CURVE4, (2.2, 3.2)),
    (Path.CURVE4, (3, 0.05)),
    (Path.CURVE4, (2.0, -0.5)),
    (Path.CLOSEPOLY, (1.58, -2.57)),
    ]
codes, verts = zip(*path_data)
path = mpath.Path(verts, codes)
patch = mpatches.PathPatch(path, facecolor='r', alpha=0.5)
ax.add_patch(patch)

# plot control points and connecting lines
x, y = zip(*path.vertices)
line, = ax.plot(x, y, 'go-')

ax.grid()
ax.axis('equal')
plt.show()

下面将使用路径去绘制一个条形统计图。

import numpy as np

import matplotlib.pyplot as plt
import matplotlib.patches as patches
import matplotlib.path as path

fig = plt.figure()
ax = fig.add_subplot(111)

# 固定随机数种子
np.random.seed(19680801)

# 产生1000组随机数，并进行组织
data = np.random.randn(1000)
n, bins = np.histogram(data, 100)
print(data.shape,n.shape,bins.shape,sep='   ')

# 得到每一个条形图的四个角落的位置
left = np.array(bins[:-1])
right = np.array(bins[1:])
bottom = np.zeros(len(left))
top = bottom + n
nrects = len(left)

nverts = nrects*(1+3+1)
verts = np.zeros((nverts, 2))
codes = np.ones(nverts, int) * path.Path.LINETO
codes[0::5] = path.Path.MOVETO
codes[4::5] = path.Path.CLOSEPOLY
verts[0::5,0] = left
verts[0::5,1] = bottom
verts[1::5,0] = left
verts[1::5,1] = top
verts[2::5,0] = right
verts[2::5,1] = top
verts[3::5,0] = right
verts[3::5,1] = bottom

#第二步：构造patches对象
barpath = path.Path(verts, codes)
patch = patches.PathPatch(barpath, facecolor='green', edgecolor='yellow', alpha=0.5)

#添加patch到axes对象
ax.add_patch(patch)

ax.set_xlim(left[0], right[-1])
ax.set_ylim(bottom.min(), top.max())

plt.show()

总结：从上面可以得知，我们的绘图，包括条形图，扇形图等都是通过基本的简单的路径path去实现的，但是这样做起来很麻烦，喊不简单，因而使用hist、bar等高层函数进一步封装，简化绘图操作。

4.2 path对象

首先需要导入matplotlib.path模块。

在使用路径的时候一般需要两个重要的参数，Path类的定义如下：

class Path(vertices, codes=None, _interpolation_steps=1, closed=False, readonly=False)

故而需要传递两个必要的参数：

rectpath = path.Path(vertices, codes)

那么vertices和codes到底是什么意思呢？

vertices是指的是路径path所经过的关键点的一系列坐标（x,y)

codes指的是点与点之间到底是怎么连接的，是直线连接？曲线连接？还是。。。

（1）vertices

vertices = [

(0., 0.), # left, bottom

(0., 1.), # left, top

(1., 1.), # right, top

(1., 0.), # right, bottom

(0., 0.), # ignored

]

（2）codes

codes = [

Path.MOVETO,

Path.LINETO,

Path.LINETO,

Path.LINETO,

Path.CLOSEPOLY,

]

path = Path(verts, codes)  #创建path对象。vertices好理解，那么codes到底什么意思？

MOVETO :拿起钢笔, 移动到给定的顶点。一般指的是 “起始点”
LINETO :从当前位置绘制直线到给定顶点。
CURVE3 :从当前位置 (用给定控制点) 绘制一个二次贝塞尔曲线到给定端点。
CURVE4 :从当前位置 (与给定控制点) 绘制三次贝塞尔曲线到给定端点。
CLOSEPOLY :将线段绘制到当前折线的起始点。
STOP :整个路径末尾的标记 (当前不需要和忽略)

总结：在创建vertices和codes的时候，每个点和每一个codes是对应着的，如上面所示，一定要注意这样的对应关系。

（3）path对象的另一种实现

path_data = 
	(Path.MOVETO, [0.018, -0.11]),  #起
	(Path.CURVE4, [-0.031, -0.051])
	(Path.CURVE4, [-0.115, 0.073])
	(Path.CURVE4, [-0.03, 0.073])
	(Path.LINETO, [-0.011, 0.039])
	(Path.CURVE4, [0.043, 0.121])
	(Path.CURVE4, [0.075, -0.005])
	(Path.CURVE4, [0.035, -0.027])
	(Path.CLOSEPOLY, [0.018, -0.11])]  #闭合到起
codes, verts = zip(*path_data)   #使用内置的Zip函
heartpath = path.Path(verts, codes)   #创建Path对
patch = mpatches.PathPatch(path)    #将path包装成一个patch对
patches.append(patch)

3、补充

上面知识介绍了一些最基本的路径path的操作，路径的各种操作很复杂，还有各种各样的路径操作函数，还有路径效果和相关的一些操作，在

import matplotlib.patheffects
import matplotlib.transforms

这两个模块里面，关于这两个模块的操作，这理由不讨论了，有兴趣可以查阅官方文档。

参考资料

这里是一个广告位，，感兴趣的都可以发邮件聊聊：tiehan@sina.cn

个人公众号，比较懒，很少更新，可以在上面提问题，如果回复不及时，可发邮件给我： tiehan@sina.cn