annotate标注解释

最新推荐文章于 2024-08-16 01:34:38 发布

进击的程小白

最新推荐文章于 2024-08-16 01:34:38 发布

阅读量8.8k

点赞数 5

分类专栏：机器学习KNN

机器学习KNN 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

标注

基本标注

使用text()会将文本放置在轴域的任意位置。文本的一个常见用例是标注绘图的某些特征，而annotate()方法提供辅助函数，使标注变得容易。在标注中，有两个要考虑的点：由参数xy表示的标注位置和xytext的文本位置。这两个参数都是(x, y)元组。

# coding=utf-8


import numpy as np
import matplotlib.pyplot as plt



fig = plt.figure()

ax = fig.add_subplot(111)

x = np.arange(0.0, 5.0, 0.01)
y = np.cos(2*np.pi*x)
ax.plot(x, y, lw = 2)

'''
    xy=(横坐标，纵坐标)  箭头尖端
    xytext=(横坐标，纵坐标) 文字的坐标，指的是最左边的坐标
    arrowprops= {
        facecolor= '颜色',
        shrink = '数字' <1  收缩箭头
    }

'''

ax.annotate('local max', xy=(2,1), xytext=(3,1.5),
            arrowprops=dict(facecolor='black', shrink=0.05)) #

ax.set_ylim(-2, 2) #设置y轴刻度的范围

plt.show()

# coding=utf-8


import numpy as np
import matplotlib.pyplot as plt



fig = plt.figure()

ax = fig.add_subplot(111)

x = np.arange(0.0, 5.0, 0.01)
y = np.cos(2*np.pi*x)
ax.plot(x, y, lw = 2)

'''
    xy=(横坐标，纵坐标)  箭头尖端
    xytext=(横坐标，纵坐标) 文字的坐标，指的是最左边的坐标
    arrowprops= {
        facecolor= '颜色',
        shrink = '数字' <1  收缩箭头
    }

'''
 
ax.annotate('local max', xy=(3, 1),  xycoords='data',
            xytext=(0.8, 0.95), textcoords='axes fraction',
            arrowprops=dict(facecolor='black', shrink=0.05),
            horizontalalignment='right', verticalalignment='top',fontsize=10
            #horizontalalignment，verticalalignment和fontsize，从annotate传给Text(local max)
            )
ax.set_ylim(-2, 2) #设置y轴刻度的范围

plt.show()

在该示例中，xy（箭头尖端）和xytext位置（文本位置）都以数据坐标为单位。有多种可以选择的其他坐标系 - 你可以使用xycoords和textcoords以及下列字符串之一（默认为data）指定xy和xytext的坐标系。

你可以通过在可选关键字参数arrowprops中提供箭头属性字典来绘制从文本到注释点的箭头。

`arrowprops`键	描述
`width`	箭头宽度，以点为单位
`frac`	箭头头部所占据的比例
`headwidth`	箭头的底部的宽度，以点为单位
`shrink`	移动提示，并使其离注释点和文本一些距离
`**kwargs`	`matplotlib.patches.Polygon`的任何键，例如`facecolor`

在下面的示例中，xy点是原始坐标（xycoords默认为'data'）。对于极坐标轴，它在(theta, radius)空间中。此示例中的文本放置在图形小数坐标系中。 matplotlib.text.Text关键字args，例如horizontalalignment，verticalalignment和fontsize，从annotate传给Text实例。

# coding=utf-8


import numpy as np
import matplotlib.pyplot as plt

fig = plt.figure()
ax = fig.add_subplot(111, polar=True)
r = np.arange(0,1,0.001)
theta = 2*2*np.pi*r
line, = ax.plot(theta, r, color='#ee8d18', lw=3)

ind = 800
thisr, thistheta = r[ind], theta[ind]
ax.plot([thistheta], [thisr], 'o')
ax.annotate('a polar annotation',
            xy=(thistheta, thisr),  # theta, radius
            xytext=(0.05, 0.05),    # fraction, fraction
            textcoords='figure fraction',
            #| 'figure fraction' | 0,0 是图形左下角，1,1 是右上角 |
            arrowprops=dict(facecolor='black', shrink=0.05),
            horizontalalignment='left',
            verticalalignment='bottom',
            )
plt.show()

高级标注

使用框和文本来标注

让我们以一个简单的例子来开始。

# coding=utf-8

import numpy.random
import matplotlib.pyplot as plt

fig = plt.figure(1, figsize=(5,5))
fig.clf()

ax = fig.add_subplot(111)
ax.set_aspect(1)

x1 = -1 + numpy.random.randn(100)
y1 = -1 + numpy.random.randn(100)
x2 = 1. + numpy.random.randn(100)
y2 = 1. + numpy.random.randn(100)

ax.scatter(x1, y1, color="r")
ax.scatter(x2, y2, color="g")

bbox_props = dict(boxstyle="round", fc="w", ec="0.5", alpha=0.9)


'''
    以文本坐标(-2,-2)
    ha="center"  在水平方向上，方框的中心在为（-2，0）
    va="center"  在垂直方向上，方框的中心在为（0，-2）
    size = '20' 代表方框的大小
    bbox={}  代表对方框的设置
        { 
            boxstyle= '' 代表边框的类型
                    round 圆形方框
                    rarrow箭头
            fc  背景颜色   英文首字母 w -whiite r-red
            ec 边框线的透明度  数字或颜色的首字母
            alpha 字体的透明度
            lw 线的粗细
            rotation  角度
        }
'''

ax.text(-2, -2, "Sample A", ha="center", va="center", size=20,
        bbox=bbox_props)

ax.text(2, 2, "Sample B", ha="center", va="center", size=20,
        bbox=bbox_props)


bbox_props = dict(boxstyle="rarrow", fc=(0.8,0.9,0.9), ec="b", lw=2)
t = ax.text(0, 0, "Direction", ha="center", va="center", rotation=45,
            size=15,
            bbox=bbox_props)

bb = t.get_bbox_patch()
bb.set_boxstyle("rarrow", pad=0.6)

ax.set_xlim(-4, 4)
ax.set_ylim(-4, 4)

plt.draw()
plt.show()

在pyplot模块（或Axes类的text方法）中的text()函数接受bbox关键字参数，并且在提供时，在文本周围绘制一个框。

与文本相关联的补丁对象可以通过以下方式访问：

bb = t.get_bbox_patch()

返回值是FancyBboxPatch的一个实例，并且补丁属性（如facecolor，edgewidth等）可以像平常一样访问和修改。为了更改框的形状，请使用set_boxstyle方法。

bb.set_boxstyle("rarrow", pad=0.6)

该参数是框样式的名称与其作为关键字参数的属性。目前，实现了以下框样式。

类	名称	属性
Circle	`circle`	`pad=0.3`
DArrow	`darrow`	`pad=0.3`
LArrow	`larrow`	`pad=0.3`
RArrow	`rarrow`	`pad=0.3`
Round	`round`	`pad=0.3,rounding_size=None`
Round4	`round4`	`pad=0.3,rounding_size=None`
Roundtooth	`roundtooth`	`pad=0.3,tooth_size=None`
Sawtooth	`sawtooth`	`pad=0.3,tooth_size=None`
Square	`square`	`pad=0.3`

# coding=utf-8
import matplotlib.patches as mpatch
import matplotlib.pyplot as plt

styles = mpatch.BoxStyle.get_styles()#返回边框的集合
spacing = 1.2

figheight = (spacing * len(styles) + .5)
fig1 = plt.figure(1, (4/1.5, figheight/1.5))
fontsize = 0.3 * 72

for i, stylename in enumerate(sorted(styles.keys())):
    print(i, stylename)
    fig1.text(0.5, (spacing * (float(len(styles)) - i) - 0.5)/figheight, stylename,
              ha="center",
              size=fontsize,
              transform=fig1.transFigure,
              bbox=dict(boxstyle=stylename, fc="w", ec="k"))
plt.draw()
plt.show()

注意，属性参数可以在样式名称中用逗号分隔（在初始化文本实例时，此形式可以用作bbox参数的boxstyle的值）。

bb.set_boxstyle("rarrow,pad=0.6")

使用箭头来标注

pyplot模块（或Axes类的annotate方法）中的annotate()函数用于绘制连接图上两点的箭头。

ax.annotate("Annotation",
xy=(x1, y1), xycoords='data',
xytext=(x2, y2), textcoords='offset points',
)

这会使用textcoords中提供的，xytext处的文本标注提供坐标（xycoords）中的xy处的点。通常，数据坐标中规定了标注点，偏移点中规定了标注文本。请参阅annotate()了解可用的坐标系。

连接两个点（xy和xytext）的箭头可以通过指定arrowprops参数可选地绘制。为了仅绘制箭头，请使用空字符串作为第一个参数。

ax.annotate("",
xy=(0.2, 0.2), xycoords='data',
xytext=(0.8, 0.8), textcoords='data',
arrowprops=dict(arrowstyle="->",
connectionstyle="arc3"),
)

import matplotlib.pyplot as plt

plt.figure(1, figsize=(3,3))
ax = plt.subplot(111)
'''
    
arrowprops = {
    arrowstyle 箭头类型
    connectionstyle：xy与xytext连接之间类型
}
'''
ax.annotate("s",
            xy=(0.2, 0.2), xycoords='data',
            xytext=(0.8, 0.8), textcoords='data',
            arrowprops=dict(arrowstyle="->",
                            connectionstyle="arc3"),
            )

plt.show()

箭头的绘制需要几个步骤。

创建两个点之间的连接路径。这由connectionstyle键值控制。
如果提供了补丁对象（patchA和patchB），则会剪切路径以避开该补丁。
路径进一步由提供的像素总量来缩小（shirnkA&shrinkB）
路径转换为箭头补丁，由arrowstyle键值控制。

# coding=utf-8


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

x1, y1 = 0.3, 0.3
x2, y2 = 0.7, 0.7

fig = plt.figure(1, figsize=(8,3))
fig.clf()
from mpl_toolkits.axes_grid.axes_grid import AxesGrid
from mpl_toolkits.axes_grid.anchored_artists import AnchoredText

#from matplotlib.font_manager import FontProperties

def add_at(ax, t, loc=2):
    fp = dict(size=10)
    _at = AnchoredText(t, loc=loc, prop=fp)
    ax.add_artist(_at)
    return _at


grid = AxesGrid(fig, 111, (1, 4), label_mode="1", share_all=True)

grid[0].set_autoscale_on(False)

ax = grid[0]
ax.plot([x1, x2], [y1, y2], ".")
el = mpatches.Ellipse((x1, y1), 0.3, 0.4, angle=30, alpha=0.2)
ax.add_artist(el)
ax.annotate("",
            xy=(x1, y1), xycoords='data',
            xytext=(x2, y2), textcoords='data',
            arrowprops=dict(arrowstyle="-", #linestyle="dashed",
                            color="0.5",
                            patchB=None,
                            shrinkB=0,
                            connectionstyle="arc3,rad=0.3",
                            ),
            )

add_at(ax, "connect", loc=2)

ax = grid[1]
ax.plot([x1, x2], [y1, y2], ".")
el = mpatches.Ellipse((x1, y1), 0.3, 0.4, angle=30, alpha=0.2)
ax.add_artist(el)
ax.annotate("",
            xy=(x1, y1), xycoords='data',
            xytext=(x2, y2), textcoords='data',
            arrowprops=dict(arrowstyle="-", #linestyle="dashed",
                            color="0.5",
                            patchB=el,
                            shrinkB=0,
                            connectionstyle="arc3,rad=0.3",
                            ),
            )

add_at(ax, "clip", loc=2)


ax = grid[2]
ax.plot([x1, x2], [y1, y2], ".")
el = mpatches.Ellipse((x1, y1), 0.3, 0.4, angle=30, alpha=0.2)
ax.add_artist(el)
ax.annotate("",
            xy=(x1, y1), xycoords='data',
            xytext=(x2, y2), textcoords='data',
            arrowprops=dict(arrowstyle="-", #linestyle="dashed",
                            color="0.5",
                            patchB=el,
                            shrinkB=5,
                            connectionstyle="arc3,rad=0.3",
                            ),
            )

add_at(ax, "shrink", loc=2)


ax = grid[3]
ax.plot([x1, x2], [y1, y2], ".")
el = mpatches.Ellipse((x1, y1), 0.3, 0.4, angle=30, alpha=0.2)
ax.add_artist(el)
ax.annotate("",
            xy=(x1, y1), xycoords='data',
            xytext=(x2, y2), textcoords='data',
            arrowprops=dict(arrowstyle="fancy", #linestyle="dashed",
                            color="0.5",
                            patchB=el,
                            shrinkB=5,
                            connectionstyle="arc3,rad=0.3",
                            ),
            )

add_at(ax, "mutate", loc=2)

grid[0].set_xlim(0, 1)
grid[0].set_ylim(0, 1)
grid[0].axis["bottom"].toggle(ticklabels=False)
grid[0].axis["left"].toggle(ticklabels=False)
fig.subplots_adjust(left=0.05, right=0.95, bottom=0.05, top=0.95)

plt.draw()
plt.show()

两个点之间的连接路径的创建由connectionstyle键控制，并且可用以下样式。

名称	属性
angle	`angleA=90,angleB=0,rad=0.0`
angle3	`angleA=90,angleB=0`
arc	`angleA=0,angleB=0,armA=None,armB=None,rad=0.0`
arc3	`rad=0.0`
bar	`armA=0.0,armB=0.0,fraction=0.3,angle=None`

注意，angle3和arc3中的3意味着所得到的路径是二次样条段（三个控制点）。如下面将讨论的，当连接路径是二次样条时，可以使用一些箭头样式选项。

每个连接样式的行为在下面的示例中（有限地）演示。（警告：条形样式的行为当前未定义好，将来可能会更改）。

源代码

然后根据给定的箭头样式将连接路径（在剪切和收缩之后）变换为箭头补丁。

名称	属性
-	`None`
->	`head_length=0.4,head_width=0.2`
-[	`widthB=1.0,lengthB=0.2,angleB=None`
\|-\|	`widthA=1.0,widthB=1.0`
-\|>	`head_length=0.4,head_width=0.2`
<-	`head_length=0.4,head_width=0.2`
<->	`head_length=0.4,head_width=0.2`
<\|-	`head_length=0.4,head_width=0.2`
<	-\|>
fancy	`head_length=0.4,head_width=0.4,tail_width=0.4`
simple	`head_length=0.5,head_width=0.5,tail_width=0.2`
wedge	`tail_width=0.3,shrink_factor=0.5`

源代码

一些箭头仅适用于生成二次样条线段的连接样式。他们是fancy，simple，wedge。对于这些箭头样式，必须使用angle3或arc3连接样式。

如果提供了标注字符串，则patchA默认设置为文本的bbox补丁。

源代码

与text命令一样，可以使用bbox参数来绘制文本周围的框。

源代码

默认情况下，起点设置为文本范围的中心。可以使用relpos键值进行调整。这些值根据文本的范围进行归一化。例如，(0,0)表示左下角，(1,1)表示右上角。

源代码

将艺术家放置在轴域的锚定位置

有一类艺术家可以放置在轴域的锚定位置。一个常见的例子是图例。这种类型的艺术家可以使用OffsetBox类创建。 mpl_toolkits.axes_grid.anchored_artists中有几个预定义类。

from mpl_toolkits.axes_grid.anchored_artists import AnchoredText
at = AnchoredText("Figure 1a",
prop=dict(size=8), frameon=True,
loc=2,
)
at.patch.set_boxstyle("round,pad=0.,rounding_size=0.2")
ax.add_artist(at)

源代码

loc关键字与legend命令中含义相同。

一个简单的应用是当艺术家（或艺术家的集合）的像素大小在创建时已知。例如，如果要绘制一个固定大小为 20 像素 ×20 像素（半径为 10 像素）的圆，则可以使用AnchoredDrawingArea。实例使用绘图区域的大小创建（以像素为单位）。用户可以在绘图区任意添加艺术家。注意，添加到绘图区域的艺术家的范围与绘制区域本身的位置无关，只和初始大小有关。

from mpl_toolkits.axes_grid.anchored_artists import AnchoredDrawingArea
ada = AnchoredDrawingArea(20, 20, 0, 0,
loc=1, pad=0., frameon=False)
p1 = Circle((10, 10), 10)
ada.drawing_area.add_artist(p1)
p2 = Circle((30, 10), 5, fc="r")
ada.drawing_area.add_artist(p2)

添加到绘图区域的艺术家不应该具有变换集（它们将被重写），并且那些艺术家的尺寸被解释为像素坐标，即，上述示例中的圆的半径分别是 10 像素和 5 像素。

源代码

有时，你想让你的艺术家按数据坐标（或其他坐标，而不是画布像素）缩放。你可以使用AnchoredAuxTransformBox类。这类似于AnchoredDrawingArea，除了艺术家的范围在绘制时由指定的变换确定。

from mpl_toolkits.axes_grid.anchored_artists import AnchoredAuxTransformBox
box = AnchoredAuxTransformBox(ax.transData, loc=2)
el = Ellipse((0,0), width=0.1, height=0.4, angle=30) # in data coordinates!
box.drawing_area.add_artist(el)

上述示例中的椭圆具有在数据坐标中对应于 0.1 和 0.4 的宽度和高度，并且当轴域的视图限制改变时将自动缩放。

源代码

如图例所示，可以设置bbox_to_anchor参数。使用HPacker和VPacker，你可以像图例中一样排列艺术家（事实上，这是图例的创建方式）。

源代码

请注意，与图例不同，默认情况下，bbox_transform设置为IdentityTransform。

使用复杂坐标来标注

matplotlib 中的标注支持标注文本中描述的几种类型的坐标。对于想要更多控制的高级用户，它支持几个其他选项。

Transform实例，例如：
```
ax.annotate("Test", xy=(0.5, 0.5), xycoords=ax.transAxes)
```
- 1
相当于：
```
ax.annotate("Test", xy=(0.5, 0.5), xycoords="axes fraction")
```
- 1
使用它，你可以在其他轴域内标注一个点：
```
 
```
1. ax1, ax2 = subplot(121), subplot(122)
2. ax2.annotate("Test", xy=(0.5, 0.5), xycoords=ax1.transData,
3. xytext=(0.5, 0.5), textcoords=ax2.transData,
4. arrowprops=dict(arrowstyle="->"))
- 1
- 2
- 3
- 4
Artist实例。xy值（或xytext）被解释为艺术家的bbox（get_window_extent的返回值）的小数坐标。
```
 
```
1. an1 = ax.annotate("Test 1", xy=(0.5, 0.5), xycoords="data",
2. va="center", ha="center",
3. bbox=dict(boxstyle="round", fc="w"))
4. an2 = ax.annotate("Test 2", xy=(1, 0.5), xycoords=an1, # (1,0.5) of the an1's bbox
5. xytext=(30,0), textcoords="offset points",
6. va="center", ha="left",
7. bbox=dict(boxstyle="round", fc="w"),
8. arrowprops=dict(arrowstyle="->"))
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
源代码

请注意，你的责任是在绘制an2之前确定坐标艺术家（上例中的an1）的范围。在大多数情况下，这意味着an2需要晚于an1。
一个返回BboxBase或Transform的实例的可调用对象。如果返回一个变换，它与 1 相同，如果返回bbox，它与 2 相同。可调用对象应该接受renderer实例的单个参数。例如，以下两个命令产生相同的结果：
```
 
```
1. an2 = ax.annotate("Test 2", xy=(1, 0.5), xycoords=an1,
2. xytext=(30,0), textcoords="offset points")
3. an2 = ax.annotate("Test 2", xy=(1, 0.5), xycoords=an1.get_window_extent,
4. xytext=(30,0), textcoords="offset points")
- 1
- 2
- 3
- 4
指定二元坐标的元组。第一项用于x坐标，第二项用于y坐标。例如，
```
annotate("Test", xy=(0.5, 1), xycoords=("data", "axes fraction"))
```
- 1
0.5 的单位是数据坐标，1 的单位是归一化轴域坐标。你可以像使用元组一样使用艺术家或变换。例如，
```
 
```
1. import matplotlib.pyplot as plt
3. plt.figure(figsize=(3,2))
4. ax=plt.axes([0.1, 0.1, 0.8, 0.7])
5. an1 = ax.annotate("Test 1", xy=(0.5, 0.5), xycoords="data",
6. va="center", ha="center",
7. bbox=dict(boxstyle="round", fc="w"))
9. an2 = ax.annotate("Test 2", xy=(0.5, 1.), xycoords=an1,
10. xytext=(0.5,1.1), textcoords=(an1, "axes fraction"),
11. va="bottom", ha="center",
12. bbox=dict(boxstyle="round", fc="w"),
13. arrowprops=dict(arrowstyle="->"))
14. plt.show()
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
源代码
有时，您希望您的注释带有一些“偏移点”，不是距离注释点，而是距离某些其他点。 OffsetFrom是这种情况下的辅助类。
```
 
```
1. import matplotlib.pyplot as plt
3. plt.figure(figsize=(3,2))
4. ax=plt.axes([0.1, 0.1, 0.8, 0.7])
5. an1 = ax.annotate("Test 1", xy=(0.5, 0.5), xycoords="data",
6. va="center", ha="center",
7. bbox=dict(boxstyle="round", fc="w"))
9. from matplotlib.text import OffsetFrom
10. offset_from = OffsetFrom(an1, (0.5, 0))
11. an2 = ax.annotate("Test 2", xy=(0.1, 0.1), xycoords="data",
12. xytext=(0, -10), textcoords=offset_from,
13. # xytext is offset points from "xy=(0.5, 0), xycoords=an1"
14. va="top", ha="center",
15. bbox=dict(boxstyle="round", fc="w"),
16. arrowprops=dict(arrowstyle="->"))
17. plt.show()
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
你可以参考这个链接：pylab_examples example code: annotation_demo3.py.。