[Python, Julia] 3D-Anzeige in der Jupyter-Mayavi-Bibliothek
[Memo 2019/12/24. Vielen Dank für "gut" und "Lager" in diesem Artikel auch Ende 2019. Die Grundlagen sind die gleichen wie die folgenden, aber da es sich um die Ära von Python 3.x und Julia 1.x handelt, behalten Sie bitte die aktuelle Situation im Auge. ]]
Jupyter Adventskalender 2016 Dies ist der Artikel am 12. Tag. Sie können 3D-Grafiken in Jupyter anzeigen. Verwenden Sie die Mayavi-Bibliothek von Python. Mayavi ist eine 3D-Grafikanzeigebibliothek für Python. Die Grafik-Engine ist vtk, die mit Blick auf die Visualisierung im Bereich Wissenschaft und Technologie entwickelt wurde. Wenn Sie sich die Demo ansehen, können Sie sehen, welche Art von Bild Sie zeichnen können. -> Demo, [MRT-Beispiel](http://docs.enthought.com/mayavi/mayavi/auto/example_mri.html? Highlight = mri)
decke den Tisch
Damit Jupyter die Ausgabe der Mayavi-Bibliothek anzeigen kann, müssen die folgenden beiden Bedingungen erfüllt sein.
- Das Mayavi-Paket ist im von Jupyter aufgerufenen Python-Kernel verfügbar.
- Die Erweiterung für Mayavi ist in jupyter installiert.
Tatsächlich ist diese Einstellung am schwierigsten. Wenn Sie an den Anzeigeergebnissen interessiert sind, können Sie den Rest dieses Abschnitts überspringen. Im Folgenden werden wir versuchen, eine Umgebung unter Verwendung der Conda-Umgebung unter Mac OS X zu erstellen.
(1) Installieren Sie Python2 und Mayavi
Das Anaconda-Paket von Mayavi ist nur in Python 2 verfügbar. Installieren Sie daher derzeit die neueste Version von Python 2.7. Eine Übersicht zum Erstellen einer Python-Umgebung finden Sie unter Erstellen einer Python-Umgebung für angehende Data Scientists 2016. Beim Umgang mit mehreren Conda-Umgebungen ist Vorsicht geboten, aber die erste von 3 Arten von Problemumgehungen zur Aktivierung des Kollisionsproblems bei gleichzeitiger Existenz von Pyenv und Anaconda Mit anderen Worten, ich arbeite mit der Richtlinie "Anaconda mit Pyenv installieren und dann Pyenv nicht verwenden". Erstellen Sie nach der Installation von pyenv und anaconda, wie im Artikel beschrieben, eine Conda-Umgebung für Mayavi (im Folgenden als py27mayavi bezeichnet).
conda install -n py27mayavi numpy jupyter mayavi=4.4
source activate py27mayavi
Mayavi reagiert empfindlich auf die Version der verwendeten Bibliothek. Die neueste Version von Mayavi ist 4.5, aber ich denke, dass die vorherige 4.4 stabil ist. Stellen Sie nach dem Hinzufügen von Mayavi sicher, dass Mayavi mit Python funktioniert. Wenn Sie ein 3D-Bild sehen, sind Sie erfolgreich.
from mayavi import mlab
mlab.test_plot3d()
(2) Aktivieren Sie die Conda-Umgebung mit Jupyter.
Machen Sie es möglich, die in (1) von Jupyter erstellte Conda-Umgebung py27mayavi aufzurufen.
Die Einstellungsmethode für das Umschalten zwischen mehreren Kerneln (Conda-Umgebung) vom laufenden Jupyter wird im Artikel So wechseln Sie einfach die von Conda auf Jupyter erstellte virtuelle Umgebung beschrieben. Es wird in yoppe / items / 38005f415a5b8b884c7d # comment-a914efbb53ef23992ba1) eingeführt. Wie in der folgenden Abbildung gezeigt, ist dies beispielsweise praktisch, da Sie den Kernel auswählen können, der von New Notebook gestartet werden soll.
(3) Fügen Sie Jupyter eine Erweiterung hinzu
nbextensions wird auch mit conda installiert. Siehe hier-> https://github.com/ipython-contrib/jupyter_contrib_nbextensions
conda install -n py27mayavi -c conda-forge jupyter_contrib_nbextensions
Laut Verwenden von Mayavi in Jupyter-Notizbüchern, um nbextensions für Mayavi zu installieren,
jupyter nbextension install --py mayavi --user
Es heißt tippen, aber das hat nicht funktioniert. Wenn ich jedoch mlab.init_notebook in Jupyter starte (siehe unten), gibt es keine Erweiterungen für Mayavi. Nehmen wir also an, das Ergebnis ist in Ordnung.
Einfachstes Beispiel Python
Starten Sie Jupyter über die Shell (Befehlszeile, Terminal).
jupyter notebook
```
Verwenden Sie die Conda-Umgebung, in der Mayavi als Kernel installiert ist, und verwenden Sie New Notebook. Rufen wir Mayavi an.
Jupyter-Notizbuch unten: https://gist.github.com/anonymous/2c85c265cbee3c4485cfe39239593a11
````python
from mayavi import mlab
mlab.init_notebook()
s=mlab.test_plot3d()
s
```
Um Objekte in Mayavi anzuzeigen, verwenden Sie normalerweise das Modul "mayavi.mlab". "mlab.init_notebook ()" ist eine "Magie" für die Ausgabe von Mayavi-Bildern auf Jupyter.
In der Ausgabezelle `Out [*]` wurde ein Fenster für die 3D-Anzeige geöffnet und das 3D-Objekt angezeigt. Sie können das Objekt drehen / vergrößern / verkleinern, indem Sie die linke Taste gedrückt halten und die Maus bedienen, und das Objekt bewegen, indem Sie die Umschalttaste und die linke Taste gedrückt halten.
# Anzeigemechanismus
Ich denke, der Mechanismus der 3D-Anzeige ist wie folgt.
Nach "mlab.init_notebook ()" wurde die mit "x3d backend" initialisierte Meldung "Notebook" für die Verarbeitung von 3D-Szenen im "x3d" -Format "ausgegeben, aber" x3d " Es ist der Nachfolger von VRML (Virtual Reality Modeling Language), einem Format zur Beschreibung von 3D-Szenen. Wenn Mayavi eine 3D-Szene im x3d-Format ausgibt, zeichnet das Jupyter-Notizbuch ein 3D-Bild in Ihrem WEB-Browser. HTML5-kompatible moderne Browser nutzen WebGL, eine Funktion, die eine Teilmenge des dreidimensionalen Grafikstandards OpenGL anzeigt.
# Eisenregel: Mayavi-Objekt ausgeben
Als nächstes schreiben wir ein einfaches Programm. [Testprogramm](http://docs.enthought.com/mayavi/mayavi/auto/mlab_helper_functions.html#surf) der Funktion `surf`, die die Oberfläche zeichnet.
Jupyter-Notizbuch unten: https://gist.github.com/anonymous/954fdf1bebc9802a3e035092c1ac50ff
```python
import numpy as np
def f(x, y):
return np.sin(x + y) + np.sin(2 * x - y) + np.cos(3 * x + 4 * y)
x, y = np.mgrid[-7.:7.05:0.1, -5.:5.05:0.05]
from mayavi import mlab
mlab.init_notebook()
s = mlab.surf(x, y, f)
s
```
Der Zustand der Funktion "f" wird gezeichnet.
Um dieses Zeichnungsergebnis zu erhalten, müssen Sie das `s` in die letzte Zeile schreiben. Wenn Sie es entfernen, wird nichts gezeichnet. Mit anderen Worten, wenn Sie ein Mayavi-Objekt in die Ausgabezelle von Jupyter ausgeben, scheint es in 3D gezeichnet zu sein.
In diesem Sinne hier ein Beispiel:
Jupyter-Notizbuch unten: https://gist.github.com/anonymous/f55d3291bf778bd5fef98e0741d82d65
```python
import numpy as np
np.random.seed(12345)
x = 4 * (np.random.random(500) - 0.5)
y = 4 * (np.random.random(500) - 0.5)
z = np.exp(-(x ** 2 + y ** 2))
from mayavi import mlab
mlab.init_notebook()
mlab.figure(1, fgcolor=(0, 0, 0), bgcolor=(1, 1, 1))
pts = mlab.points3d(x, y, z, z, scale_mode='none', scale_factor=0.2)
mesh = mlab.pipeline.delaunay2d(pts)
surf = mlab.pipeline.surface(mesh)
mlab.view(47, 57, 8.2, (0.1, 0.15, 0.14))
mlab.show()
mesh
surf
```
Um 3D-Zeichnungen zu erhalten, benötigen Sie am Ende des Programms zwei Linien "mesh" und "surf". Wenn Sie Mayavi-Objekte am Ende des Programms ausgeben, nimmt Jupyter sie auf und zeichnet sie in 3D.
# Julia Aber Mayavi über Jupyter
[Julia](http://julialang.org) ist eine neue Programmiersprache, die interaktiv ausgeführt werden kann und dennoch eine extrem hohe Leistung bei numerischen Berechnungen aufweist.
In meinem Artikel, den ich letzte Woche geschrieben habe, habe ich erklärt, wie man Mayavi mit Julia benutzt und wie man die Conda-Umgebung von Julia aus bedient.
* [Verwenden Sie die 3D-Plotbibliothek MayaVi von Julia](http://qiita.com/tenfu2tea/items/b38c3c36c4771c963cc6)
* [Conda-Paket von Julia hinzufügen](http://qiita.com/tenfu2tea/items/d2ac1427eaed7a548287)
## Das einfachste Beispiel Julia
Hier ist das einfachste Beispiel, wie Sie Mayavi in Jupyter anrufen können.
Jupyter Notebook unten:
https://gist.github.com/anonymous/b991896af47ac1ef3fed630b0922bd7a
```julia
using PyCall
@pyimport mayavi.mlab as mlab
mlab.init_notebook()
mlab.test_points3d()
```
Um das Python-Modul von Julia zu verwenden, verwenden Sie "using PyCall" und laden Sie dann das Python-Modul, das Sie mit "@ pyimport" verwenden möchten. Die Python-Anweisung `import` entspricht der Anweisung Julia` @ pyimport`. Das von `@ pyimport` gelesene Objekt hat den Julia-Typ, sodass es innerhalb von Julia so aufgerufen werden kann, wie es ist.
```python
import mayavi.mlab as mlab # Python
@pyimport mayavi.mlab as mlab # Julia
```
Spherical Harmonics
[Beispiel](http://qiita.com/tenfu2tea/items/b38c3c36c4771c963cc6#spherical_harmonics) der in [Mein Satz] eingeführten sphärischen Harmonischen (http://qiita.com/tenfu2tea/items/b38c3c36c4771c963cc6) Versuchen Sie es in Jupyter.
Jupyter Notebook unten:
```julia
phi = [ u1 for u1 in linspace(0,pi,101), v1 in linspace(0,2*pi,101) ]
theta = [ v1 for u1 in linspace(0,pi,101), v1 in linspace(0,2*pi,101) ]
r = 0.3
x = r * sin(phi) .* cos(theta)
y = r * sin(phi) .* sin(theta)
z = r * cos(phi)
using PyCall
@pyimport scipy.special as spe
@pyimport mayavi.mlab as mlab
mlab.init_notebook("x3d")
mlab.figure(1, bgcolor=(1, 1, 1), fgcolor=(0,0,0), size=(400, 300))
mlab.clf()
mlab.view(90, 70, 6.2, (-1.3, -2.9, 0.25))
u=false
for n in 1:6-1, m in 0:n-1
s = real( spe.sph_harm(m, n, theta, phi) )
mlab.mesh(x - m, y - n, z, scalars=s, colormap="jet")
s[s .< 0] *= 0.97
s /= maximum(s)
u = mlab.mesh(s .* x - m, s .* y - n, s .* z + 1.3,
scalars=s, colormap="Spectral" )
u
end
u
```
Innerhalb der Schleife druckt `mlab.mesh` ein Mayavi-Objekt, Jupyter jedoch nicht. Als ich versuchte, das Mayavi-Objekt außerhalb der Schleife auszugeben, wurde das 3D-Objekt angezeigt. `u` enthält nur das zuletzt erstellte Mayavi-Objekt, bietet jedoch einen Panoramablick. Ich denke, es wäre gut, wenn es eine Möglichkeit zum 3D-Zeichnen gäbe.
# 3D-Anzeige von anderen als Mayavi (während der Täuschung)
Jupyter Notebook mit eingebetteten 3D-Daten ist ein sehr attraktives Datenaustauschformat. Ich würde mich freuen, wenn es von anderen Personen als Mayavi verwendet werden könnte. Ich habe noch keine Methode festgelegt, möchte aber zwei Kommentare abgeben.
Das erste ist eine Modifikation des x3d-Formats. Wenn ich das Jupyter-Notizbuch (Erweiterung `.ipynb`) mit einem Texteditor öffne, werden die Daten im x3d-Format eingebettet. (Die einzigen 3D-Objekte, die durch x3d dargestellt werden, sind Linien und Flächen, sodass selbst eine kleine Szene Langtext sein kann.)
```text
"outputs": [
{
"data": {
"text/html": [
"\n",
" <?xml version=\"1.0\" encoding =\"UTF-8\"?>\n",
"\n",
"<X3D profile=\"Immersive\" version=\"3.0\" id=\"scene_1\" >\n",
" <head>\n",
" <meta name=\"filename\" content=\"Stream\"/>\n",
" <meta name=\"generator\" content=\"Visualization ToolKit X3D exporter v0.9.1\"/>\n",
" <meta name=\"numberofelements\" content=\"1\"/>\n",
" </head>\n",
" <Scene>\n",
" <Background skyColor=\"0.5 0.5 0.5\"/>\n",
```
Als ich diese x3d-Szene im Editor geändert und in das Jupyter-Notizbuch neu geladen habe, hat sich die 3D-Szene geändert. Wenn Sie also den Text im x3d-Format aus einem anderen Programm einführen, sollten Sie in der Lage sein, das 3D-Bild von einem anderen als Mayavi anzuzeigen.
noch ein Punkt. Es wäre praktisch, eine Datei zu zeichnen, in der das Jupyter-Notizbuch im HTML-Format in 3D gespeichert ist, selbst in einer Umgebung, in der Juopyter nicht installiert ist.
Jetzt enthält die im HTML-Format gespeicherte Jupyter-Notizbuchdatei x3d-Daten, beim Öffnen in einem Browser wird jedoch kein 3D gezeichnet. Der Teil, der das Zeichnen von x3d anweist, ist hier, aber da er auf eine lokale Datei verweist, wurde er wahrscheinlich nicht gezeichnet.
```html
<script type="text/javascript">
require(["/nbextensions/mayavi/x3d/x3dom.js"], function(x3dom) { /**/
var x3dom_css = document.getElementById("x3dom-css");
if (x3dom_css === null) {
var l = document.createElement("link");
l.setAttribute("rel", "stylesheet");
l.setAttribute("type", "text/css");
l.setAttribute("href", "/nbextensions/mayavi/x3d/x3dom.css"); /**/
l.setAttribute("id", "x3dom-css");
$("head").append(l);
}
if (typeof x3dom != 'undefined') {
x3dom.reload();
}
else if (typeof window.x3dom != 'undefined') {
window.x3dom.reload();
}
})
</script>
```
Schreiben Sie den Verweis auf das Mayavi-Plug-In in nbextension auf x3dom.org um.
* `/ Nbextensions / mayavi / x3d / x3dom.js` wurde in` http: // www.x3dom.org / download / x3dom.js` geändert
* Geändert `/ nbextensions / mayavi / x3d / x3dom.css` zu` http: // www.x3dom.org / download / x3dom.css`
Dann wurde der 3D-Zeichenbereich gezeichnet, aber das 3D-Objekt wurde noch nicht gezeichnet.
Lassen Sie uns noch etwas mehr über die beiden oben genannten Punkte nachdenken. Wenn es gut geht, möchte ich es hinzufügen.
Es tut mir leid, dass ich am Ende eine Täuschung hatte.
Recommended Posts