# élasticité - scénario vague

L'installation Elasticité dynamique agit comme un filtre et génère de nouveaux espaces démultipliés, comme un empilement quasi infini d'horizons. Par principe de réflexion, la pièce absorbe l'image de l'environnement et accumule les points de vue ; le mouvement permanent requalifie continuellement ce qui est regardé et entendu.

Ce post implémente une configuration implémentant une vague de propagation.

In [1]:
```%load_ext autoreload
```
In [2]:
```import matplotlib
matplotlib.use('nbagg')
%matplotlib inline
matplotlib.rcParams['figure.max_open_warning'] = 400
%matplotlib inline
%config InlineBackend.figure_format='retina'
import matplotlib.pyplot as plt
#%config InlineBackend.figure_format = 'svg'
```

### vague gravitationnelle¶

In [3]:
```name = 'waves'
vext = '.mp4'
import os
import numpy as np
import MotionClouds as mc
mc.N_X, mc.N_Y, mc.N_frame = 128, 32, 512
fx, fy, ft = mc.get_grids(mc.N_X, mc.N_Y, mc.N_frame)
theta, B_theta, B_wave = 0., np.pi/8., .5
#alpha, sf_0, B_sf, B_V = 2., .25, .3, 2.
alpha, sf_0, B_sf, B_V = 2., .2, .1, 3.
seed = 1234565
#V_X, V_Y, g = .5, 0., .1
V_X, V_Y, g = .5, 0., 2
loggabor=True
B_v = .025

def envelope_gravity(fx, fy, ft, B_wave, g=.1):
"""
Gravitational envelope:
selects the plane corresponding to the speed (V_X, V_Y) with some thickness B_V

"""
k = fx*V_X+fy*V_Y
env = np.exp(-.5*(((ft/.5)**2-g*np.sqrt(((k/.5)**2)))**2/(B_wave*mc.frequency_radius(fx, fy, ft, ft_0=np.inf))**2))
env *= (ft*k) < 0
return env

def envelope_gabor_wave(fx, fy, ft, B_wave, V_X=mc.V_X, V_Y=mc.V_Y,
B_V=mc.B_V, B_v=1., sf_0=mc.sf_0, B_sf=mc.B_sf, loggabor=mc.loggabor,
theta=mc.theta, B_theta=mc.B_theta, alpha=mc.alpha):
"""
Returns the Motion Cloud kernel

"""
envelope = mc.envelope_gabor(fx, fy, ft, V_X=V_X, V_Y=V_Y,
B_V=B_V, sf_0=sf_0, B_sf=B_sf, loggabor=loggabor,
theta=theta, B_theta=B_theta, alpha=alpha)
envelope *= envelope_gravity(fx, fy, ft, B_wave=B_wave)
return envelope

name_ = name + '_low'
mc_wave = envelope_gabor_wave(fx, fy, ft, V_X=1., V_Y=0., B_wave=B_v, B_V=B_V, theta=theta, B_theta=B_theta, sf_0=sf_0, B_sf=B_sf, alpha=alpha)
mc_wave = mc.envelope_gabor(fx, fy, ft, V_X=1., V_Y=0., B_V=B_V, theta=theta, B_theta=B_theta, sf_0=sf_0, B_sf=B_sf, alpha=alpha)
mc.figures(mc_wave, name_, vext=vext, seed=seed)
mc.in_show_video(name_)
```
```Saving sequence ../files/waves_low as a .mp4 format
```

Saving the corrresponding cloud as a `nd.array`:

In [4]:
```vague_dense = mc.rectif(mc.random_cloud(mc_wave), contrast=1)
print(vague_dense.shape)
```
```(128, 32, 512)
```
In [5]:
```#mc_wave = envelope_gabor_wave(fx, fy, ft, V_X, V_Y, B_V, B_wave, sf_0, B_sf, theta, B_theta, alpha, g)
mc.figures(mc_wave, 'waves_impulse', seed=seed, impulse=True)
mc.in_show_video('waves_impulse')
```
```Saving sequence ../files/waves_impulse as a .mp4 format
```
In [6]:
```vague_solo = mc.rectif(mc.random_cloud(mc_wave, seed=seed, impulse=True), contrast=1)
print(vague_solo.shape)
```
```(128, 32, 512)
```

### transforme la vague 2D sur les lames¶

In [7]:
```def vague_animate(z, x_offset=0, y_offset=0, N_lame = 25, t_offset=0, N_steps = 512):
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from IPython.display import HTML

fig, ax = plt.subplots(figsize=(15, 3))

x = np.arange(0, N_lame)        # x-array

def vague(i):
return z[x_offset:(x_offset+N_lame), y_offset, t_offset+i]

def animate(i):
line.set_ydata(vague(i))  # update the data
return line,

#Init only required for blitting to give a clean slate.
def init():
return line,

line,  = ax.plot(x, vague(0))
ax.set_xlim([0, N_lame-1])
ax.set_ylim([0, 1])

anim = animation.FuncAnimation(fig, animate, np.arange(1, N_steps), init_func=init,
interval=25, blit=True)

return HTML(anim.to_html5_video())

```
In [8]:
```vague_animate(vague_dense)
```
Out[8]: