Commit 8e2f9840 authored by Christoph Ruegge's avatar Christoph Ruegge
Browse files

Typo

parent ca8b6127
%% Cell type:markdown id: tags:
# Grafiken 3D
Für Grafiken in 3D könnte man weiterhin matplotlib benutzen, allerdings möchten wir hier ein Framework benutzen, welches wesentlich schneller und mehr Funktionalität bietet, als matplotlib zur Verfügung stellt: ``` mayavi```
```mayavi``` basiert auf VTK (Visualization Toolkit), ein sehr weit verbreitetes und mächtiges Software-System für Visualisierung.
``` python
import mayavi
```
Das grundlegende Konzept hinter Mayavi sind Verarbeitungs-Pipelines. D.h. es wird ein Fluss von Verarbeitungen von Daten angenommen, und jeder Schritt hat das Ergebnis das davorigen als Argument.
im einfachsten Fall gibt es jedoch auch matplotlib-ähnliche einfache Funktionen die einen bestimmten Satz an Verarbeitungen unter der Haube durchführen. Diese Funktionen findet man im Modul *mlab*
``` python
import mayavi.mlab
```
*Hinweis:* mayavi funktioniert *nicht* auf dem Server `jupyter.num.math.uni-goettingen.de`
## Funktionen $\mathbb{R} \to \mathbb{R}^3$
Parameterdarstellung 3D Linie
$$\{(x(t),y(t),z(t)) \in \mathbb{R}^3 \;|\; t \in [a,b] \}.$$
In Mayavi:
``` python
ml.plot3d(x, y, z)
```
*Beispiel:* Stelle die Funktion
$$\left( \begin{array}{c} (1-t^2)\cos(99t) \\ (1-t^2)\sin(99t) \\ t\end{array}\right)$$
dar
%% Cell type:code id: tags:
``` python
from numpy import pi, linspace, cos, sin
from mayavi import mlab as ml
def func(t):
return (1-t*t)*cos(99*t), (1-t*t)*sin(99*t), t
ml.plot3d(*func(linspace(0, 1, 200)))
ml.show()
```
%% Cell type:markdown id: tags:
### Funktionen $\mathbb{R}^2 \to \mathbb{R}$
#### Oberflächen in $\mathbb{R}^3$
eine Möglichkeit der Darstellung solcher Funktionen ist die Darstellung als Oberfläche im $\mathbb{R}^3$. Eine Funktion die die Koordinaten auf eine Höhe abbildet.
``` python
ml.surf(x, y, z, warp_scale="auto")
```
- `warp_scale="auto"`: Setzt die Skalierung der Funktionswerte auf die Farben
%% Cell type:code id: tags:
``` python
from numpy import exp, ogrid
x, y = ogrid[-3:3:300j, -3:3:300j]
z = (1 - x/2 + x**5 + y**3) * exp(-(x**2 + y**2))
ml.surf(x,y,, warp_scale="auto", colormap='viridis')
ml.surf(x,y,z, warp_scale="auto", colormap='viridis')
ml.title('plot_surf (mayavi)')
ml.colorbar()
ml.show()
```
%% Cell type:markdown id: tags:
#### 3D - Fläche
$$\{(x(t1,t2),y(t1,t2),z(t1,t2)) \in \mathbb{R}^3 \;|\; t1 \in [a,b], t2 \in [c,d] \}.$$
in Mayavi:
``` python
ml.mesh(x,y,z)
```
*Beispiel*: Ellipsoid-Oberfläche
$$ x=r \cos(t_1) \sin(t_2), \ y=2r \sin (t_1) \sin (t_2),\ z =r \cos(t_2) $$
mit $0 \leq t_1 \leq 2 \pi, 0 \leq t_2 \leq \pi.$
%% Cell type:code id: tags:
``` python
from numpy import exp, ogrid, pi, mgrid
t1, t2 = mgrid[0:2*pi:40j, 0:pi:40j]
def ellipsoid(t1, t2):
r = 2
return [r*cos(t1)*sin(t2), 2*r*sin(t1)*sin(t2), r*cos(t2)]
ml.mesh(*ellipsoid(t1,t2), colormap='viridis')
ml.title('plot_mesh (mayavi)')
ml.show()
```
%% Cell type:markdown id: tags:
### Funktionen $\mathbb{R}^3 \to \mathbb{R}$
Solche Funktionen darzustellen wird zunehmend schwierig, da der Bildschirm direkt nur 2D Daten darstellen kann, wir jetzt aber einen 4D-Raum darstellen müssen.
#### Slices
Eine Möglichkeit sind *slices*, also Schnitte durch den Dreidimensionalen Raum, und wir stellen die Funktionswerte wieder als Farbe dar.
in Mayavi wird das etwas komplizierter. Wir kombinieren eine *image plane* mit einem *scalar field*, also der mayavi-Representation der Daten.
``` python
ml.pipeline.image_plane_widget(field, plane_orientation='x_axes', slice_index=int)
```
- `plane_orientation`: Die Orientierung der Schnittebene
- `slice_index`: Der Index in der durch `plane_orientation` angebenen Schnittebene
``` python
ml.pipeline.scalar_field(V)
```
Die Mayavi-Representation der Daten gegeben durch einen 4D Array `V`.
%% Cell type:code id: tags:
``` python
from numpy import exp, sin, pi, ogrid
X, Y, Z = ogrid[-2:2:180j,-2:2:180j,-2:2:180j]
V = exp(-X**2-Y**2) * sin(pi*X*Y*Z)
ml.pipeline.image_plane_widget(ml.pipeline.scalar_field(V),
plane_orientation='x_axes',
slice_index=8, colormap='viridis')
ml.pipeline.image_plane_widget(ml.pipeline.scalar_field(V),
plane_orientation='y_axes',
slice_index=5, colormap='viridis')
ml.pipeline.image_plane_widget(ml.pipeline.scalar_field(V),
plane_orientation='y_axes',
slice_index=15, colormap='viridis')
ml.show()
```
%% Cell type:markdown id: tags:
#### (Transparente) Volumina
%% Cell type:code id: tags:
``` python
#does not work
#ml.pipeline.volume(ml.pipeline.scalar_field(V),vmin=0.1, vmax=0.5)
#ml.show()
```
%% Cell type:markdown id: tags:
#### Isoflächen
Flächen gleicher (iso-) Werte.
``` python
ml.contour3d(V)
```
%% Cell type:code id: tags:
``` python
ml.contour3d(V, colormap='viridis')
ml.show()
```
%% Cell type:markdown id: tags:
### Funktionen $\mathbb{R}^m \to \mathbb{R}^m$, $m = 3$
#### Vektorpfeile
``` python
ml.quiver3d(u, v, w)
```
wobei u, v, w die einzelnen Komponenten sind. In unserem Fall sind das selber 3D Arrays.
%% Cell type:code id: tags:
``` python
from numpy import mgrid
x, y, z = mgrid[0:1:20j, 0:1:20j, 0:1:20j]
u = sin(pi*x) * cos(pi*z)
v = -2*sin(pi*y) * cos(2*pi*z)
w = cos(pi*x)*sin(pi*z) + cos(pi*y)*sin(2*pi*z)
ml.quiver3d(u, v, w, colormap='viridis')
ml.outline()
ml.show()
```
%% Cell type:markdown id: tags:
#### Flusslinien
Flusslinien stellen anhand der Vektorinformationen den Fluss einzelner Elemente dar.
``` python
ml.flow(u, v, w)
```
wobei u, v, w die einzelnen Komponenten sind.
%% Cell type:code id: tags:
``` python
ml.flow(u, v, w, colormap='viridis')
ml.outline()
ml.show()
```
%% Cell type:markdown id: tags:
Man kann die Isoflächen auch für die im Elemente gleichen Flusses nutzen. Dafür bauen wir wieder eine Pipeline.
``` python
ml.pipeline.vector_field(u, v, w)
```
daraus nehmen wir dann die Elemente gleicher Magnitude
``` python
ml.pipeline.extract_vector_norm(src)
```
und dann bauen wir daraus eine Isofläche
``` ptyhon
ml.pipeline.iso_surface(magnitude, contours=)
```
%% Cell type:code id: tags:
``` python
src = ml.pipeline.vector_field(u, v, w)
magnitude = ml.pipeline.extract_vector_norm(src)
ml.pipeline.iso_surface(magnitude, contours=[1.9, 1], colormap='viridis')
ml.show()
```
%% Cell type:code id: tags:
``` python
```
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment