[Python, Julia] Affichage 3D dans la bibliothèque Jupyter-Mayavi

[Mémo 2019/12/24. Merci pour «bon» et «stock» dans cet article même à la fin de 2019. Les bases sont les mêmes que les suivantes, mais comme c'est l'ère de Python 3.x et Julia 1.x, veuillez suivre la dernière situation. ]

Calendrier de l'Avent Jupyter 2016 Ceci est l'article sur le 12ème jour. Vous pouvez afficher des graphiques 3D dans Jupyter. Utilisez la bibliothèque Mayavi de Python. Mayavi est une bibliothèque d'affichage graphique 3D pour Python. Le moteur graphique est vtk, qui a été développé avec la visualisation dans le domaine de la science et de la technologie à l'esprit. Si vous regardez la démo, vous pouvez voir quel type d'image vous pouvez dessiner. -> Démo, [Exemple d'IRM](http://docs.enthought.com/mayavi/mayavi/auto/example_mri.html? mettre en évidence = mri)

mettre la table

Pour que Jupyter affiche la sortie de la bibliothèque Mayavi, les deux conditions suivantes doivent être remplies.

• Le package Mayavi est disponible dans le noyau Python appelé par Jupyter.
• La nbextension pour Mayavi est installée dans jupyter.

En fait, ce paramètre est le plus difficile. Si vous êtes intéressé par les résultats d'affichage, vous pouvez ignorer le reste de cette section. Ci-dessous, nous allons essayer de créer un environnement en utilisant l'environnement conda sur Mac OSX.

(1) Installez Python2 et Mayavi

Le package anaconda de Mayavi n'est disponible qu'en python 2, alors installez la dernière version de Python 2.7 pour le moment. Un aperçu de la construction d'un environnement Python peut être trouvé dans Construire un environnement Python pour les scientifiques en herbe 2016. Il est nécessaire d'être prudent lorsqu'il s'agit d'environnements conda multiples, mais le premier des 3 types de solutions de contournement pour activer le problème de collision lors de la coexistence de pyenv et anaconda En d'autres termes, j'opère avec la politique de "installer anaconda en utilisant pyenv et ensuite ne pas utiliser pyenv". Après avoir installé pyenv et anaconda comme décrit dans l'article, créez un environnement conda pour Mayavi (ci-après appelé py27mayavi).

conda install -n py27mayavi numpy jupyter mayavi=4.4
source activate py27mayavi

Mayavi est sensible à la version de la bibliothèque qu'il utilise. La dernière version de Mayavi est la 4.5, mais je pense que la 4.4 précédente est stable. Après avoir ajouté Mayavi, assurez-vous que Mayavi fonctionne à partir de Python. Si vous voyez une image 3D, vous avez réussi.

from mayavi import mlab
mlab.test_plot3d()

(2) Activez l'environnement conda avec Jupyter.

Rendre possible d'appeler l'environnement conda py27mayavi créé dans (1) à partir de Jupyter. La méthode de paramétrage pour basculer entre plusieurs noyaux (environnement conda) à partir du Jupyter en cours d'exécution est décrite dans l'article Comment changer facilement l'environnement virtuel créé par Conda sur Jupyter. Il est introduit dans yoppe / items / 38005f415a5b8b884c7d # comment-a914efbb53ef23992ba1). Par exemple, comme le montre la figure ci-dessous, c'est pratique car vous pouvez sélectionner le noyau pour démarrer à partir du nouveau bloc-notes.

(3) Ajouter nbextension à Jupyter

nbextensions est également installé à l'aide de conda. Reportez-vous ici-> https://github.com/ipython-contrib/jupyter_contrib_nbextensions

conda install -n py27mayavi -c conda-forge jupyter_contrib_nbextensions

Selon Utilisation de Mayavi dans les notebooks Jupyter, pour installer nbextensions pour Mayavi,

jupyter nbextension install --py mayavi --user

Il dit de taper, mais cela n'a pas fonctionné. Cependant, quand je lance mlab.init_notebook depuis Jupyter (voir ci-dessous), des nbextensions pour Mayavi existent, alors disons que le résultat est correct.

Exemple le plus simple Python

Démarrez Jupyter depuis le shell (ligne de commande, terminal).

jupyter notebook
```

 Utilisez l'environnement conda dans lequel Mayavi est installé comme noyau et utilisez New notebook. Appelons Mayavi.

 Jupyter Notebook ci-dessous: https://gist.github.com/anonymous/2c85c265cbee3c4485cfe39239593a11

````python
from mayavi import mlab
mlab.init_notebook()
s=mlab.test_plot3d()
s
```

 Pour afficher des objets dans Mayavi, vous utilisez généralement le module `mayavi.mlab`. `mlab.init_notebook ()` est une "magie" pour produire des images Mayavi sur Jupyter.

 ![スクリーンショット 2016-12-10 17.28.32.png](https://qiita-image-store.s3.amazonaws.com/0/103217/c4875247-9856-17c1-be32-8402eb746285.png)

 Dans la cellule de sortie ʻOut [*] `, une fenêtre d'affichage 3D s'est ouverte et l'objet 3D a été affiché. Vous pouvez faire pivoter / agrandir / réduire l'objet en utilisant la souris tout en appuyant sur le bouton gauche, et déplacer l'objet en actionnant la souris tout en appuyant sur la touche Maj et le bouton gauche.


# Mécanisme d'affichage

 Je pense que le mécanisme de l'affichage 3D est le suivant.
 Après `mlab.init_notebook ()`, le message` Notebook initialisé avec le backend x3d` "notebook était configuré pour gérer les scènes 3D au format` x3d`" était sorti, mais` x3d` C'est le successeur du VRML (Virtual Reality Modeling Language), un format de description de scènes 3D. Si Mayavi produit une scène 3D au format `x3d`, le notebook Jupyter dessinera une image 3D sur votre navigateur WEB. Le navigateur moderne compatible HTML5 a la capacité d'afficher un sous-ensemble de WebGL, le standard graphique en trois dimensions OpenGL, nous en profitons donc.

# Règle de fer: sortie de l'objet Mayavi

 Ensuite, écrivons un programme simple. [Programme de test](http://docs.enthought.com/mayavi/mayavi/auto/mlab_helper_functions.html#surf) de la fonction `surf` qui dessine la surface.

 Jupyter Notebook ci-dessous: 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
```

 ![スクリーンショット 2016-12-10 18.31.01.png](https://qiita-image-store.s3.amazonaws.com/0/103217/e0772d77-2188-316f-63fd-a22a1a631551.png)

 L'état de la fonction «f» est dessiné.
 Pour obtenir ce résultat de dessin, vous avez besoin du «s» écrit sur la dernière ligne. Si vous le supprimez, rien ne sera dessiné. En d'autres termes, lorsque vous sortez un objet Mayavi dans la cellule de sortie de Jupyter, il semble être dessiné en 3D.

 Dans cet esprit, voici un exemple:

 Jupyter Notebook ci-dessous: 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
```

 ![スクリーンショット 2016-12-10 18.49.50.png](https://qiita-image-store.s3.amazonaws.com/0/103217/7c642142-ab1c-c120-c312-732f6cdb8ecc.png)

 Pour obtenir un dessin 3D, vous avez besoin de 2 lignes «mesh» et «surf» à la fin du programme. Si vous sortez des objets Mayavi à la fin du programme, Jupyter les récupère et les dessine en 3D.


# Julia But Mayavi sur Jupyter

 [Julia](http://julialang.org) est un nouveau langage de programmation qui peut être exécuté de manière interactive, tout en bénéficiant de performances extrêmement élevées de calculs numériques.
 Dans mon écriture de la semaine dernière, j'ai expliqué comment utiliser Mayavi avec Julia et comment faire fonctionner l'environnement conda de Julia.
 * [Utiliser la bibliothèque de tracés 3D MayaVi de Julia](http://qiita.com/tenfu2tea/items/b38c3c36c4771c963cc6)
 * [Ajouter un package conda de Julia](http://qiita.com/tenfu2tea/items/d2ac1427eaed7a548287)

## L'exemple le plus simple Julia

 Voici l'exemple le plus simple de l'appel de Mayavi à l'intérieur de Jupyter.
　
 Jupyter Notebook ci-dessous:
https://gist.github.com/anonymous/b991896af47ac1ef3fed630b0922bd7a

```julia
using PyCall
@pyimport mayavi.mlab as mlab
mlab.init_notebook()

mlab.test_points3d()
```

 ![スクリーンショット 2016-12-11 9.36.59.png](https://qiita-image-store.s3.amazonaws.com/0/103217/4db35c41-a979-bd9d-106a-278c38074f12.png)

 Pour utiliser un module Python de Julia, faites ʻutilisation de PyCall` puis chargez le module Python que vous voulez utiliser avec `@ pyimport`. L'instruction Python ʻimport` est équivalente à l'instruction `@ pyimport` de Julia. L'objet lu par `@ pyimport` a le type Julia, il peut donc être appelé tel quel depuis Julia.

```python
import mayavi.mlab as mlab     # Python
@pyimport mayavi.mlab as mlab  # Julia
```


 Spherical Harmonics

 [Exemple](http://qiita.com/tenfu2tea/items/b38c3c36c4771c963cc6#spherical_harmonics) d'harmoniques sphériques introduites dans [Ma phrase](http://qiita.com/tenfu2tea/items/b38c3c36c4771c963cc6) , Essayez de l'exécuter dans Jupyter.

 Jupyter Notebook ci-dessous:

```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
```

 ![スクリーンショット 2016-12-11 9.27.38.png](https://qiita-image-store.s3.amazonaws.com/0/103217/92103d80-515f-0e59-8e20-c9ae9d69c446.png)
 ![スクリーンショット 2016-12-11 9.29.22のコピー.png](https://qiita-image-store.s3.amazonaws.com/0/103217/072346b1-5aa3-1a79-4149-1375a3355e4d.png)

 A l'intérieur de la boucle, `mlab.mesh` imprime un objet Mayavi, mais pas Jupyter. Lorsque j'ai essayé de sortir l'objet Mayavi en dehors de la boucle, l'objet 3D était affiché. ʻU` contient uniquement le dernier objet Mayavi créé, mais il a une vue panoramique. Je pense que ce serait bien s'il y avait une opportunité pour le dessin 3D.

# Affichage 3D d'un autre que Mayavi (pendant l'illusion)

 Le notebook Jupyter avec données 3D intégrées est un format d'échange de données très attractif. Je serais heureux s'il pouvait être utilisé par des personnes autres que Mayavi. Je n'ai pas encore établi de méthode, mais je voudrais faire deux commentaires.
 Le premier est une modification du format x3d. Lorsque j'ouvre le notebook Jupyter (extension `.ipynb`) avec un éditeur de texte, les données au format x3d sont incorporées. (Les seuls objets 3D représentés par x3d sont des lignes et des faces, donc même une petite scène peut être du texte long.)

```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",
```

 Lorsque j'ai modifié cette scène x3d dans l'éditeur et l'ai rechargée dans le notebook Jupyter, la scène 3D a changé. Donc, si vous introduisez le texte au format x3d à partir d'un autre programme, vous devriez pouvoir afficher l'image 3D d'une autre que Mayavi.
 encore un point. Il serait pratique de dessiner un fichier dans lequel le notebook Jupyter est enregistré au format HTML en 3D même dans un environnement où Juopyter n'est pas installé.
 Désormais, le fichier Jupyter notebook enregistré au format HTML contient des données x3d, mais son ouverture dans un navigateur ne dessine pas en 3D. La partie qui indique le dessin x3d est ici, mais comme elle pointe vers un fichier local, elle n'a probablement pas été dessinée.

```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>
```

 Réécrivez la référence au plug-in Mayavi dans nbextension vers x3dom.org.
 * Modification de `/ nbextensions / mayavi / x3d / x3dom.js` en` http: // www.x3dom.org / download / x3dom.js`
 * Modification de `/ nbextensions / mayavi / x3d / x3dom.css` en` http: // www.x3dom.org / download / x3dom.css`

 ![スクリーンショット 2016-12-12 17.10.33.png](https://qiita-image-store.s3.amazonaws.com/0/103217/8e8a7c03-2093-71b0-f4d8-822542652a9d.png)

 Ensuite, la zone de dessin 3D a été dessinée, mais l'objet 3D n'a pas encore été dessiné.
 Pensons un peu plus aux deux points ci-dessus. Si cela se passe bien, j'aimerais l'ajouter.
 Je suis désolé d'avoir fini avec une illusion à la fin.