===== Nützliche Programmschnipsel =====

==== Test für Objektorientierte Dreiecke ====
<code Python>
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.tri as mtri
from scipy.spatial import Delaunay



xinput=[1,2,3,4]
yinput=[1,2,3,4]

z=[]
x=[]
y=[]


def do(xinput,yinput):
	xlange=len(xinput)
	ylange=len(yinput)
	for i in range((xlange*ylange)):
		z.append(np.random.uniform(1,3,size=None))
	
	for i in range(xlange):
		for ii in range(xlange):
			x.append(i)	
	
	for i in range(ylange):
		for ii in range(ylange):
			y.append(ii)
do(xinput,yinput)

Array=np.array([x,y]).T
def triang(x,y,z):
	global tri
	
	tri = Delaunay(Array)
	fig = plt.figure()
	ax = fig.add_subplot(1, 1, 1, projection='3d')
	ax.plot_trisurf(x, y, z, triangles=tri.simplices, cmap=plt.cm.Spectral)
	
triang(x,y,z)
dreiecke=[]
def eckpunkte(simplices):
	for bla in range(len(simplices)):
		dreieck=[]
		sxyz=tri.simplices[bla]
		#x
		sx=sxyz[0]
		ssx=Array[sx]
		dreieck.append(ssx)

		#y
		sy=sxyz[1]
		ssy=Array[sy]
		dreieck.append(ssy)
		
		#z
		sz=sxyz[2]
		ssz=Array[sz]
		dreieck.append(ssz)
		dreiecke.append(dreieck)
eckpunkte(tri.simplices)
print dreiecke


plt.show()
</code>
==== Funktionierende Triangulierung ====

<code Python>
def Show(NAME):
	
	import numpy as np
	import matplotlib.pyplot as plt
	from mpl_toolkits.mplot3d import Axes3D
	import matplotlib.tri as mtri
	from scipy.spatial import Delaunay

	rangey=[]
	rangex=[]
	z=[]
	myArray  = np.loadtxt(NAME)
	zeilen,spalten=myArray.shape
	
	for i in range(zeilen):
		for ii in range(zeilen):
			rangex.append(i)	
	
	for i in range(spalten):
		for i in range(spalten):
			rangey.append(i)
	reader=open(NAME,'r')
	z1=reader.read()
	reader.close()
	z1=z1.replace("\n","")
	z1=(z1.split())

	for word in z1:
		z.append(word)
	z=map(int,z)

	tri = Delaunay(np.array([rangex,rangey]).T)
	fig = plt.figure()
	ax = fig.add_subplot(1, 1, 1, projection='3d')
	ax.plot_trisurf(rangex, rangey, z, triangles=tri.simplices, cmap=plt.cm.BrBG)
	plt.show()
	print len(tri.simplices)
	
if __name__ == '__main__':
	Show("montblanc1.asc")
</code>



==== 3d-Punkte zeichnen  ====

 
<code Python>
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numpy as np

myArray  = np.loadtxt("etopo1_bedrock.asc", skiprows=6)
z,s=myArray.shape

x=np.zeros((z,s))
for i in range(z):
	x[i]=i
	
y=np.zeros((z,s))
for i in range(s):
	y[:,i]=i

z=myArray

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(x, y, z, zdir='z', c= 'red')
plt.show()
</code>
==== 3d-Dreiecke zeichnen ====

<code python>
# -*- coding: utf-8 -*-

import numpy as np
from scipy.spatial import Delaunay
import mpl_toolkits.mplot3d as mplot3d
import matplotlib.colors as colors
import pylab as pl

###  erzeuge ein Gitter von x,y-Werten mit zugehörigen z-Werten

x=np.linspace(-1,1,10)
y=np.linspace(-1,1,10)
XX,YY=np.meshgrid(x,y)
ZZ=np.sin(XX*XX+YY*YY)

###  Erzeuge ein Array mit (x,y)-Koordinaten und eines
###  mit (x,y,z)-Koordinaten

points3d = np.array([XX.flatten(),YY.flatten(),ZZ.flatten()]).T
points2d=  np.array([XX.flatten(),YY.flatten()]).T

### Berechne Delaunay-Triangulierung des Gitters


tri = Delaunay(points2d)

###  Darstellung auf der Basis der erzeugten Dreiecke -- es gibt
###  in Matplotlib ganz verschiedene Schnittstellen, die dasselbe
###  tun. 

###  Hier wird mit ax=mplot3d.Axes3D(...) ein 3d-Koordinatensystem
###  erzeugt, dem man 3d-Objekte hinzufügen kann mit ax.add_collection3d(...)
###  In unserem Fall werden Dreiecke hinzugefügt, die mit 
###  mplot3d.art3d.Poly3DCollection(...) werden



ax = mplot3d.Axes3D(pl.figure())
for simplex in tri.simplices:
    ecken = np.array([points3d[simplex[0]],points3d[simplex[1]],points3d[simplex[2]]])
    
    dreieck = mplot3d.art3d.Poly3DCollection([ecken])
    ### Man kann von diesen Graphikobjekten Eigenschaften einstellen:
    dreieck.set_color(colors.rgb2hex(np.random.rand(3)))
    dreieck.set_edgecolor('k')
  
    ax.add_collection3d(dreieck)

pl.show()
</code>