def plot_rays(rays, env=None, invert_colors=False, **kwargs):
"""Plots ray paths.
:param rays: ray paths
:param env: environment definition
:param invert_colors: False to use black for high intensity rays, True to use white
If environment definition is provided, it is overlayed over this plot using default
parameters for `arlpy.uwapm.plot_env()`.
Other keyword arguments applicable for `arlpy.plot.plot()` are also supported.
>>> import arlpy.uwapm as pm
>>> env = pm.create_env2d()
>>> rays = pm.compute_eigenrays(env)
>>> pm.plot_rays(rays, width=1000)
"""
rays = rays.sort_values('bottom_bounces', ascending=False)
max_amp = _np.max(_np.abs(
rays.bottom_bounces)) if len(rays.bottom_bounces) > 0 else 0
if max_amp <= 0:
max_amp = 1
divisor = 1
xlabel = 'Range (m)'
r = []
for _, row in rays.iterrows():
r += list(row.ray[:, 0])
if max(r) - min(r) > 10000:
divisor = 1000
xlabel = 'Range (km)'
oh = _plt.hold()
for _, row in rays.iterrows():
c = int(255 * _np.abs(row.bottom_bounces) / max_amp)
if invert_colors:
c = 255 - c
c = _bokeh.colors.RGB(c, c, c)
_plt.plot(row.ray[:, 0] / divisor,
-row.ray[:, 1],
color=c,
xlabel=xlabel,
ylabel='Depth (m)',
**kwargs)
if env is not None:
plot_env(env)
_plt.hold(oh)
def plot_transmission_loss(tloss, env=None, **kwargs):
"""Plots transmission loss.
:param tloss: complex transmission loss
:param env: environment definition
If environment definition is provided, it is overlayed over this plot using default
parameters for `arlpy.uwapm.plot_env()`.
Other keyword arguments applicable for `arlpy.plot.image()` are also supported.
>>> import arlpy.uwapm as pm
>>> import numpy as np
>>> env = pm.create_env2d(
rx_depth=np.arange(0, 25),
rx_range=np.arange(0, 1000),
min_angle=-45,
max_angle=45
)
>>> tloss = pm.compute_transmission_loss(env)
>>> pm.plot_transmission_loss(tloss, width=1000)
"""
xr = (min(tloss.columns), max(tloss.columns))
yr = (-max(tloss.index), -min(tloss.index))
xlabel = 'Range (m)'
if xr[1] - xr[0] > 10000:
xr = (min(tloss.columns) / 1000, max(tloss.columns) / 1000)
xlabel = 'Range (km)'
oh = _plt.hold()
_plt.image(20 *
_np.log10(_fi.epsilon + _np.abs(_np.flipud(_np.array(tloss)))),
x=xr,
y=yr,
xlabel=xlabel,
ylabel='Depth (m)',
xlim=xr,
ylim=yr,
**kwargs)
if env is not None:
plot_env(env, rx_plot=False)
_plt.hold(oh)
def plot_arrivals(arrivals, dB=False, color='blue', **kwargs):
"""Plots the arrival times and amplitudes.
:param arrivals: arrivals times (s) and coefficients
:param dB: True to plot in dB, False for linear scale
:param color: line color (see `Bokeh colors <https://bokeh.pydata.org/en/latest/docs/reference/colors.html>`_)
Other keyword arguments applicable for `arlpy.plot.plot()` are also supported.
>>> import arlpy.uwapm as pm
>>> env = pm.create_env2d()
>>> arrivals = pm.compute_arrivals(env)
>>> pm.plot_arrivals(arrivals)
"""
t0 = min(arrivals.time_of_arrival)
t1 = max(arrivals.time_of_arrival)
oh = _plt.hold()
if dB:
min_y = 20 * _np.log10(_np.max(_np.abs(
arrivals.arrival_amplitude))) - 60
ylabel = 'Amplitude (dB)'
else:
ylabel = 'Amplitude'
_plt.plot([t0, t1], [0, 0],
xlabel='Arrival time (s)',
ylabel=ylabel,
color=color,
**kwargs)
min_y = 0
for _, row in arrivals.iterrows():
t = row.time_of_arrival.real
y = _np.abs(row.arrival_amplitude)
if dB:
y = max(20 * _np.log10(_fi.epsilon + y), min_y)
_plt.plot([t, t], [min_y, y],
xlabel='Arrival time (s)',
ylabel=ylabel,
ylim=[min_y, min_y + 70],
color=color,
**kwargs)
_plt.hold(oh)
def plot_env(env,
surface_color='dodgerblue',
bottom_color='peru',
tx_color='orangered',
rx_color='midnightblue',
rx_plot=None,
**kwargs):
"""Plots a visual representation of the environment.
:param env: environment description
:param surface_color: color of the surface (see `Bokeh colors <https://bokeh.pydata.org/en/latest/docs/reference/colors.html>`_)
:param bottom_color: color of the bottom (see `Bokeh colors <https://bokeh.pydata.org/en/latest/docs/reference/colors.html>`_)
:param tx_color: color of transmitters (see `Bokeh colors <https://bokeh.pydata.org/en/latest/docs/reference/colors.html>`_)
:param rx_color: color of receviers (see `Bokeh colors <https://bokeh.pydata.org/en/latest/docs/reference/colors.html>`_)
:param rx_plot: True to plot all receivers, False to not plot any receivers, None to automatically decide
Other keyword arguments applicable for `arlpy.plot.plot()` are also supported.
The surface, bottom, transmitters (marker: '*') and receivers (marker: 'o')
are plotted in the environment. If `rx_plot` is set to None and there are
more than 2000 receivers, they are not plotted.
>>> import arlpy.uwapm as pm
>>> env = pm.create_env2d(depth=[[0, 40], [100, 30], [500, 35], [700, 20], [1000,45]])
>>> pm.plot_env(env)
"""
env = check_env2d(env)
min_x = 0
max_x = _np.max(env['rx_range'])
if max_x - min_x > 10000:
divisor = 1000
min_x /= divisor
max_x /= divisor
xlabel = 'Range (km)'
else:
divisor = 1
xlabel = 'Range (m)'
if env['surface'] is None:
min_y = 0
else:
min_y = _np.min(env['surface'][:, 1])
if _np.size(env['depth']) > 1:
max_y = _np.max(env['depth'][:, 1])
else:
max_y = env['depth']
mgn_x = 0.01 * (max_x - min_x)
mgn_y = 0.1 * (max_y - min_y)
oh = _plt.hold()
if env['surface'] is None:
_plt.plot([min_x, max_x], [0, 0],
xlabel=xlabel,
ylabel='Depth (m)',
xlim=(min_x - mgn_x, max_x + mgn_x),
ylim=(-max_y - mgn_y, -min_y + mgn_y),
color=surface_color,
**kwargs)
else:
# linear and curvilinear options use the same altimetry, just with different normals
s = env['surface']
_plt.plot(s[:, 0] / divisor,
-s[:, 1],
xlabel=xlabel,
ylabel='Depth (m)',
xlim=(min_x - mgn_x, max_x + mgn_x),
ylim=(-max_y - mgn_y, -min_y + mgn_y),
color=surface_color,
**kwargs)
if _np.size(env['depth']) == 1:
_plt.plot([min_x, max_x], [-env['depth'], -env['depth']],
color=bottom_color)
else:
# linear and curvilinear options use the same bathymetry, just with different normals
s = env['depth']
_plt.plot(s[:, 0] / divisor, -s[:, 1], color=bottom_color)
txd = env['tx_depth']
_plt.plot([0] * _np.size(txd),
-txd,
marker='*',
style=None,
color=tx_color)
if rx_plot is None:
rx_plot = _np.size(env['rx_depth']) * _np.size(env['rx_range']) < 2000
if rx_plot:
rxr = env['rx_range']
if _np.size(rxr) == 1:
rxr = [rxr]
for r in _np.array(rxr):
rxd = env['rx_depth']
_plt.plot([r / divisor] * _np.size(rxd),
-rxd,
marker='o',
style=None,
color=rx_color)
_plt.hold(oh)