Inline-Beschriftungen in Matplotlib

In Matplotlib ist es nicht allzu schwierig, eine Legende zu erstellen (siehe example_legend()unten), aber ich denke, es ist besser, Beschriftungen direkt auf die gezeichneten Kurven zu setzen (wie example_inline()unten). Dies kann sehr umständlich sein, da ich die Koordinaten von Hand angeben muss und wenn ich das Diagramm neu formatiere, muss ich wahrscheinlich die Beschriftungen neu positionieren. Gibt es eine Möglichkeit, Beschriftungen in Kurven in Matplotlib automatisch zu generieren? Bonuspunkte für die Ausrichtung des Textes in einem Winkel, der dem Winkel der Kurve entspricht.

import numpy as np
import matplotlib.pyplot as plt

def example_legend():
    plt.clf()
    x = np.linspace(0, 1, 101)
    y1 = np.sin(x * np.pi / 2)
    y2 = np.cos(x * np.pi / 2)
    plt.plot(x, y1, label='sin')
    plt.plot(x, y2, label='cos')
    plt.legend()

def example_inline():
    plt.clf()
    x = np.linspace(0, 1, 101)
    y1 = np.sin(x * np.pi / 2)
    y2 = np.cos(x * np.pi / 2)
    plt.plot(x, y1, label='sin')
    plt.plot(x, y2, label='cos')
    plt.text(0.08, 0.2, 'sin')
    plt.text(0.9, 0.2, 'cos')

Schöne Frage, vor einiger Zeit habe ich ein bisschen damit experimentiert, aber nicht viel benutzt, weil es immer noch nicht kugelsicher ist. Ich habe den Plotbereich in ein 32x32-Raster unterteilt und ein "potenzielles Feld" für die beste Position eines Etiketts für jede Linie nach den folgenden Regeln berechnet:

• Leerraum ist ein guter Ort für ein Etikett
• Das Etikett sollte sich in der Nähe der entsprechenden Linie befinden
• Das Etikett sollte von den anderen Zeilen entfernt sein

Der Code war ungefähr so:

import matplotlib.pyplot as plt
import numpy as np
from scipy import ndimage


def my_legend(axis = None):

    if axis == None:
        axis = plt.gca()

    N = 32
    Nlines = len(axis.lines)
    print Nlines

    xmin, xmax = axis.get_xlim()
    ymin, ymax = axis.get_ylim()

    # the 'point of presence' matrix
    pop = np.zeros((Nlines, N, N), dtype=np.float)    

    for l in range(Nlines):
        # get xy data and scale it to the NxN squares
        xy = axis.lines[l].get_xydata()
        xy = (xy - [xmin,ymin]) / ([xmax-xmin, ymax-ymin]) * N
        xy = xy.astype(np.int32)
        # mask stuff outside plot        
        mask = (xy[:,0] >= 0) & (xy[:,0] < N) & (xy[:,1] >= 0) & (xy[:,1] < N)
        xy = xy[mask]
        # add to pop
        for p in xy:
            pop[l][tuple(p)] = 1.0

    # find whitespace, nice place for labels
    ws = 1.0 - (np.sum(pop, axis=0) > 0) * 1.0 
    # don't use the borders
    ws[:,0]   = 0
    ws[:,N-1] = 0
    ws[0,:]   = 0  
    ws[N-1,:] = 0  

    # blur the pop's
    for l in range(Nlines):
        pop[l] = ndimage.gaussian_filter(pop[l], sigma=N/5)

    for l in range(Nlines):
        # positive weights for current line, negative weight for others....
        w = -0.3 * np.ones(Nlines, dtype=np.float)
        w[l] = 0.5

        # calculate a field         
        p = ws + np.sum(w[:, np.newaxis, np.newaxis] * pop, axis=0)
        plt.figure()
        plt.imshow(p, interpolation='nearest')
        plt.title(axis.lines[l].get_label())

        pos = np.argmax(p)  # note, argmax flattens the array first 
        best_x, best_y =  (pos / N, pos % N) 
        x = xmin + (xmax-xmin) * best_x / N       
        y = ymin + (ymax-ymin) * best_y / N       


        axis.text(x, y, axis.lines[l].get_label(), 
                  horizontalalignment='center',
                  verticalalignment='center')


plt.close('all')

x = np.linspace(0, 1, 101)
y1 = np.sin(x * np.pi / 2)
y2 = np.cos(x * np.pi / 2)
y3 = x * x
plt.plot(x, y1, 'b', label='blue')
plt.plot(x, y2, 'r', label='red')
plt.plot(x, y3, 'g', label='green')
my_legend()
plt.show()

Und die daraus resultierende Handlung:

Update: Benutzer cphyc hat freundlicherweise ein Github-Repository für den Code in dieser Antwort erstellt (siehe hier ) und den Code in einem Paket gebündelt, das möglicherweise mit installiert wird pip install matplotlib-label-lines.

Schönes Bild:

In matplotlibes ist ziemlich leicht zu Etikett Kontur - Plots (entweder automatisch oder manuell durch Etiketten mit Mausklicks Platzierung). Es scheint (noch) keine äquivalente Fähigkeit zu geben, Datenreihen auf diese Weise zu kennzeichnen! Es kann einen semantischen Grund dafür geben, diese Funktion, die mir fehlt, nicht aufzunehmen.

Unabhängig davon habe ich das folgende Modul geschrieben, das halbautomatische Plotbeschriftungen zulässt. Es werden nur numpyeinige Funktionen aus der Standardbibliothek benötigt math.

Beschreibung

Das Standardverhalten der labelLinesFunktion besteht darin, die Beschriftungen gleichmäßig entlang der xAchse zu platzieren ( ynatürlich automatisch mit dem richtigen Wert). Wenn Sie möchten, können Sie einfach ein Array der x-Koordinaten der einzelnen Beschriftungen übergeben. Sie können sogar die Position eines Etiketts anpassen (siehe Abbildung unten rechts) und den Rest gleichmäßig verteilen, wenn Sie möchten.

Darüber hinaus label_linesberücksichtigt die Funktion nicht die Zeilen, denen im plotBefehl keine Beschriftung zugewiesen wurde (oder genauer, wenn die Beschriftung enthält '_line').

Schlüsselwortargumente, die an den Funktionsaufruf übergeben labelLinesoder an diesen labelLineweitergegeben werden text(einige Schlüsselwortargumente werden festgelegt, wenn der aufrufende Code keine Angabe macht).

Probleme

• Anmerkungsbegrenzungsrahmen stören manchmal unerwünschte andere Kurven. Wie durch die 1und 10Anmerkungen im oberen linken Diagramm gezeigt. Ich bin mir nicht mal sicher, ob dies vermieden werden kann.
• Es wäre schön, ystattdessen manchmal eine Position anzugeben .
• Es ist immer noch ein iterativer Prozess, um Anmerkungen an der richtigen Stelle abzurufen
• Es funktioniert nur, wenn die x-axis-Werte floats sind

Fallstricke

• Standardmäßig geht die labelLinesFunktion davon aus, dass alle Datenreihen den durch die Achsengrenzen angegebenen Bereich umfassen. Schauen Sie sich die blaue Kurve oben links im hübschen Bild an. Wenn nur Daten zur Verfügung standen für den xBereich 0.5- 1dann könnten wir nicht möglicherweise eine Markierung setzen an der gewünschten Stelle (was etwas weniger als ist 0.2). In dieser Frage finden Sie ein besonders unangenehmes Beispiel. Derzeit identifiziert der Code dieses Szenario nicht intelligent und ordnet die Beschriftungen neu an. Es gibt jedoch eine angemessene Problemumgehung. Die Funktion labelLines übernimmt das xvalsArgument. Eine Liste der xvom Benutzer angegebenen Werte anstelle der standardmäßigen linearen Verteilung über die Breite. So kann der Benutzer entscheiden, welchex-Werte, die für die Etikettenplatzierung jeder Datenreihe verwendet werden sollen.

Ich glaube auch, dass dies die erste Antwort ist, um das Bonusziel zu erreichen, die Beschriftungen an der Kurve auszurichten, auf der sie sich befinden. :) :)

label_lines.py:

from math import atan2,degrees
import numpy as np

#Label line with line2D label data
def labelLine(line,x,label=None,align=True,**kwargs):

    ax = line.axes
    xdata = line.get_xdata()
    ydata = line.get_ydata()

    if (x < xdata[0]) or (x > xdata[-1]):
        print('x label location is outside data range!')
        return

    #Find corresponding y co-ordinate and angle of the line
    ip = 1
    for i in range(len(xdata)):
        if x < xdata[i]:
            ip = i
            break

    y = ydata[ip-1] + (ydata[ip]-ydata[ip-1])*(x-xdata[ip-1])/(xdata[ip]-xdata[ip-1])

    if not label:
        label = line.get_label()

    if align:
        #Compute the slope
        dx = xdata[ip] - xdata[ip-1]
        dy = ydata[ip] - ydata[ip-1]
        ang = degrees(atan2(dy,dx))

        #Transform to screen co-ordinates
        pt = np.array([x,y]).reshape((1,2))
        trans_angle = ax.transData.transform_angles(np.array((ang,)),pt)[0]

    else:
        trans_angle = 0

    #Set a bunch of keyword arguments
    if 'color' not in kwargs:
        kwargs['color'] = line.get_color()

    if ('horizontalalignment' not in kwargs) and ('ha' not in kwargs):
        kwargs['ha'] = 'center'

    if ('verticalalignment' not in kwargs) and ('va' not in kwargs):
        kwargs['va'] = 'center'

    if 'backgroundcolor' not in kwargs:
        kwargs['backgroundcolor'] = ax.get_facecolor()

    if 'clip_on' not in kwargs:
        kwargs['clip_on'] = True

    if 'zorder' not in kwargs:
        kwargs['zorder'] = 2.5

    ax.text(x,y,label,rotation=trans_angle,**kwargs)

def labelLines(lines,align=True,xvals=None,**kwargs):

    ax = lines[0].axes
    labLines = []
    labels = []

    #Take only the lines which have labels other than the default ones
    for line in lines:
        label = line.get_label()
        if "_line" not in label:
            labLines.append(line)
            labels.append(label)

    if xvals is None:
        xmin,xmax = ax.get_xlim()
        xvals = np.linspace(xmin,xmax,len(labLines)+2)[1:-1]

    for line,x,label in zip(labLines,xvals,labels):
        labelLine(line,x,label,align,**kwargs)

Testcode, um das hübsche Bild oben zu erzeugen:

from matplotlib import pyplot as plt
from scipy.stats import loglaplace,chi2

from labellines import *

X = np.linspace(0,1,500)
A = [1,2,5,10,20]
funcs = [np.arctan,np.sin,loglaplace(4).pdf,chi2(5).pdf]

plt.subplot(221)
for a in A:
    plt.plot(X,np.arctan(a*X),label=str(a))

labelLines(plt.gca().get_lines(),zorder=2.5)

plt.subplot(222)
for a in A:
    plt.plot(X,np.sin(a*X),label=str(a))

labelLines(plt.gca().get_lines(),align=False,fontsize=14)

plt.subplot(223)
for a in A:
    plt.plot(X,loglaplace(4).pdf(a*X),label=str(a))

xvals = [0.8,0.55,0.22,0.104,0.045]
labelLines(plt.gca().get_lines(),align=False,xvals=xvals,color='k')

plt.subplot(224)
for a in A:
    plt.plot(X,chi2(5).pdf(a*X),label=str(a))

lines = plt.gca().get_lines()
l1=lines[-1]
labelLine(l1,0.6,label=r'$Re=${}'.format(l1.get_label()),ha='left',va='bottom',align = False)
labelLines(lines[:-1],align=False)

plt.show()

@ Jan Kuikens Antwort ist sicherlich gut durchdacht und gründlich, aber es gibt einige Einschränkungen:

• es funktioniert nicht in allen Fällen
• Es erfordert eine ganze Menge zusätzlichen Codes
• Sie kann von Grundstück zu Grundstück erheblich variieren

Ein viel einfacherer Ansatz besteht darin, den letzten Punkt jedes Diagramms mit Anmerkungen zu versehen. Der Punkt kann zur Hervorhebung auch eingekreist werden. Dies kann mit einer zusätzlichen Zeile erreicht werden:

from matplotlib import pyplot as plt

for i, (x, y) in enumerate(samples):
    plt.plot(x, y)
    plt.text(x[-1], y[-1], 'sample {i}'.format(i=i))

Eine Variante wäre zu verwenden ax.annotate.

Ein einfacherer Ansatz wie der von Ioannis Filippidis:

import matplotlib.pyplot as plt
import numpy as np

# evenly sampled time at 200ms intervals
tMin=-1 ;tMax=10
t = np.arange(tMin, tMax, 0.1)

# red dashes, blue points default
plt.plot(t, 22*t, 'r--', t, t**2, 'b')

factor=3/4 ;offset=20  # text position in view  
textPosition=[(tMax+tMin)*factor,22*(tMax+tMin)*factor]
plt.text(textPosition[0],textPosition[1]+offset,'22  t',color='red',fontsize=20)
textPosition=[(tMax+tMin)*factor,((tMax+tMin)*factor)**2+20]
plt.text(textPosition[0],textPosition[1]+offset, 't^2', bbox=dict(facecolor='blue', alpha=0.5),fontsize=20)
plt.show()

Code Python 3 auf sageCell