dessiner avec streamplot intégré à matplotlib

À titre d'exemple, un vortex Taylor-Green stationnaire bidimensionnel: $ \begin{aligned} u &= \sin x \cos y \\\\ v &= -\cos x \sin y \end{aligned} $ Est utilisé. Vous pouvez facilement dessiner des lignes de courant avec le matplotlib intégré `` `streamplot```.

import matplotlib.pyplot as plt
import numpy as np
from numpy import sin, cos, pi, sqrt

n = 1000
x = np.linspace(0, 2*pi, n)
y = np.linspace(0, 2*pi, n)
X, Y = np.meshgrid(x, y)

# Taylor-Green Vortices
u = sin(X)*cos(Y)
v = - cos(X)*sin(X)
speed = sqrt(u**2 + v**2)

# Plot
plt.figure(1)
plt.streamplot(X, Y, u, v, density=3, color='k', arrowstyle='-', linewidth=0.6)
plt.contourf(X, Y, speed, 100, cmap='viridis')
plt.show()

J'ai pu dessiner un profil. L'arrière-plan est la vitesse d'écoulement.

Dessiner avec convolution intégrale de ligne (LIC)

C'est le sujet principal. Le streamplot``` intégré à matplotlib ci-dessus est assez beau, mais si vous voulez dessiner plus magnifiquement (artistiquement), utilisez la méthode <b> Line Integral Convolution (LIC) </ b>. Si vous l'utilisez, vous pouvez très bien dessiner des lignes de courant. Il y a une brève explication dans [wikipedia](https://en.wikipedia.org/wiki/Line_integral_convolution). Pour l'algorithme, voir [Cabral and Leedom, 1993](https://dl.acm.org/doi/pdf/10.1145/166117.166151?casa_token=A78GoJh369IAAAAA%3AfWlns5xYUUWiQC09j8IIMBVDZq4jYTRt_uJXhb [Phillips et al., 2015](https://iopscience.iop.org/article/10.1088/1748-3190/10/5/056020/meta) et [Van Der Kindere et al., 2019](https://link.springer.com/article/10.1007/s00348-019-2678-5) et ainsi de suite. Je suis reconnaissant d'avoir l'exemple de code dans [SciPy Cookbook](https://scipy-cookbook.readthedocs.io/items/LineIntegralConvolution.html). Vous pouvez l'utiliser en construisant setup.py```. Réécrivez la première moitié du lien lic_demo.py ''. Puisque je veux afficher la vitesse d'écoulement en arrière-plan, je multiplie la vitesse d'écoulement par LIC dans la dernière ligne.

Vector = np.stack([u, v], axis=2)
Vector = np.array(Vector, dtype=np.float32)
texture = np.random.rand(n, n).astype(np.float32)

plt.bone()
frame = 0
dpi = 1000
video = False
if video:
    kernellen = 31
    for t in np.linspace(0,1,16*5):
        kernel = np.sin(np.arange(kernellen)*np.pi/kernellen)*(1+np.sin(2*np.pi*5*(np.arange(kernellen)/float(kernellen)+t)))
        kernel = kernel.astype(np.float32)
        image = lic_internal.line_integral_convolution(Vector, texture, kernel)
        frame += 1
else:
    kernellen = 31
    kernel = np.sin(np.arange(kernellen)*np.pi/kernellen)
    kernel = kernel.astype(np.float32)
    image = lic_internal.line_integral_convolution(Vector, texture, kernel)

speed_LIC = image[1:-1, 1:-1]*speed[1:-1, 1:-1]

C'est très beau.

Au fait, Mathematica est plus facile

Mathematica a un [`` `LineIntegralConvolutionPlot```] intégré (https://reference.wolfram.com/language/ref/LineIntegralConvolutionPlot.html)!

LineIntegralConvolutionPlot[{{Sin[x] Cos[y], -Sin[y] Cos[x]}, {"noise", 1000, 1000}}, {x, 0, 2 Pi}, {y, 0, 2 Pi},  
ColorFunction -> "BlueGreenYellow", RasterSize -> 300]

C'était juste fait ...