Für Graphen von Funktionen, Balkengraphiken und ähnliches gibt es viele Spezialfunktionen, etwas in ``matplotlib.pyplot``. Darum soll es in diesem Beispiel nicht gehen, sondern um das Erzeugen 'freier Graphiken'.

Dafür muss man von der Klassenstruktur von Matplotlib etwas mehr verstehen.

Eine Graphik ist eine Figure, in ein solches Figure-Objekt kann man verschiedene Axes-Objekte einfügen. Ein solches Axes-Objekt definiert ein Koordinatensystem, um einen gewissen Ort der Graphik anzusteuern. In das Axes-Objekt kann man nun verschiedene Artist-Objekte einfügen, etwas Dreiecke, Kreise, oder auch die Darstellng eines Arrays als Bild. Ein Dreieck-Objekt ist nicht etwas ein kleines Bildchen, sondern ein Objekt, das Methoden hat, die es in einem gegebenen Koordinatensystem zeichnen, löschen, verändern.

Diese Artist-Objekte werden durch gewisse Daten und durch gewisse Parameter bestimmt. Der Unterschied zwischen Daten und Parametern ist zwar willkürlich, aber wichtig. Für die Daten (im Falle der Bildanzeige wäre das das Array) gibt es eine Methode, die die Daten zu veränderen erlaubt (sie heißt leider nicht immer set_data. Man muss in der matplotlib-Dokumentation nachsehen, um diese Methoden zu finden. Für Polygone etwa (also zum Beispiel Dreiecke) lassen sich die Koordinaten der Eckpunkte mit set_xy setzen.

Im folgenden Beispiel wird ein Koordinatensystem [0,2N]x[0,2N] für das erste Axes-Objekt ax geschaffen. Später wird ein zweites Koordinatensystem ax1 rechts oben in dem ersten platziert.

Durch ax.imshow(…) wird dem Koordinatensystem ax ein Artist hinzugefügt. Anderer Artists werden mit entsprechenden Klassen von matplotlib erzeugt und durch ax.add_artist(…) dem Koordinatensystem hinzugefügt.

<code python>

import matplotlib matplotlib.use('GTKAgg') import matplotlib.pyplot as plt

import numpy as np import time import sys

def anzeige():

'''wird aufgerufen, um den Plot zu aktualisieren'''
fig.canvas.draw()
fig.canvas.flush_events()

def main():

global im
while True:
	
	## verändere Bilddaten und setze diese
	
	im=4*im*(1-im)#np.random.rand(N*N).reshape(N,N)
	im=np.where(im<1,im, 1)
	image.set_data(im)
	
	## verändere die Kreisdaten 
	
	# Mittelpunkt ist ein Attribut
	
	c1.center=(c1.center[0]+np.random.randint(3)-1,c1.center[1]+np.random.randint(3)-1)
	
	# Parameter wie 'color' verändert man so
	
	matplotlib.artist.setp(c1,color=(np.random.rand(),np.random.rand(),np.random.rand()))
	
	## verändere die Dreiecksdaten:
	
	dt=time.time()-now
	p1.set_xy(np.array([[np.cos(dt)*N/2.+N/2., np.sin(dt)*N/2.+N/2],
	[np.cos(0.4*dt)*N/2.+N/2., np.sin(0.4*dt)*N/2.+N/2],
	[np.cos(0.1*dt)*N/2.+N/2., np.sin(0.1*dt)*N/2.+N/2]]))
	matplotlib.artist.setp(p1,color=(np.abs(np.sin(dt)),np.abs(np.cos(dt)), np.abs(np.sin(1.777*dt))))
	
	
	##   Verändere die Farben der Dreiecke und Kanten (simultan)
	
	# Hier wird eine Liste von Farbtripeln erzeugt 
	
	colors=[]
	for i in range(len(triangles)):
		colors.append((np.abs(np.sin(0.1*dt*i)),np.abs(np.sin(0.1*2*dt*i)),np.abs(0.1*np.sin(3*dt*i))))

	# Hier wird die Liste als den Dreiecken zugeordnet
	
	triangle_collection.set_color(colors)
	
	# Genauso für die Kanten, erst Liste erzeugen, dann zuordnen
	
	colors=[]
	for i in range(len(lines)):
		colors.append((np.abs(np.sin(0.1*dt*i)),np.abs(np.sin(0.1*2*dt*i)),np.abs(0.1*np.sin(3*dt*i))))
	line_collection.set_color(colors)
	
	## Zeichne mit den aktuellen Werten
			
	anzeige()
return 0

if name == 'main':

now=time.time()

##############

matplotlib.rcParams['toolbar'] = 'None'  #  Keine Buttons zum Vergrößern/Verkleinern anzeigen
fig=plt.figure()                      #  Figure Objekt

N=100
ax = plt.axes(xlim=(0,2*N),ylim=(0,2*N))  #  Axes (Koordinatensystem)-Objekt
plt.axis("off")                       #  Achsen nicht beschriften

##############

# Ein Bild ("Artist") in ax erzeugen, das ein Array durch farbige Punkte ausdrückt

im=np.array([[np.abs(np.sin(0.1*(i*i+j*j))) for i in range(N)]for j in range(N)])#np.random.rand(N*N).reshape(N,N)
image=ax.imshow(im)

# Einen Kreis ("Artist") erzeugen und zu ax hinzufügen.

c1=matplotlib.patches.Circle([N/2,N/2],color=(1,0,0),alpha=0.8)
ax.add_artist(c1)

# Ein Dreieck mit identischen Ecken erzeugen und zu ax hinzufügen

p1=matplotlib.patches.Polygon(np.array([[1,0],[1,0],[1,0]]),color=(1.,0,0),alpha=0.8)
ax.add_artist(p1)


## Eine Liste von Dreiecken erzeugen

ax1=fig.add_axes((0.5,0.5,0.5,0.5))  ## Standard-Koordinatensystem der neuen Achse 0-1 x 0-1
                                     ## lässt sich mit xlim und ylim überschreiben, s. o.
plt.axis("off")

triangles=[]
points=np.random.rand(30,2)
import scipy.spatial
tri=scipy.spatial.Delaunay(points)
for simplex in tri.simplices:
	p=matplotlib.patches.Polygon(np.array([points[simplex[0]],points[simplex[1]],points[simplex[2]]]))
	triangles.append(p)
triangle_collection=matplotlib.collections.PatchCollection(triangles)
ax1.add_artist(triangle_collection)

## Eine Liste der zugehörigen Dreieckskanten

lines=set([])
for simplex in tri.simplices:
	lines.add((simplex[0],simplex[1]))
	lines.add((simplex[1],simplex[2]))
	lines.add((simplex[2],simplex[0]))
	
line_collection=matplotlib.collections.LineCollection([(points[line[0]], points[line[1]]) for line in lines],color=(0,1,0))
ax1.add_artist(line_collection)
# Anzeigen

anzeige()

## Beim erstem Aufbau der Graphik muss eine solche Pause erzwungen werden
## für die späteren Updates der Graphik ist das nicht notwendig.

plt.pause(0.05)

# Animationsschleife starten

main()

</python>