def bartlett_beampattern(i, fc, sd, shading=None, theta=None, show=False): """Computes the beampattern for a Bartlett or delay-and-sum beamformer. :param i: row index of target steering distances :param fc: carrier frequency for the array data (Hz) :param sd: steering delays (s) :param shading: window function to use for array shading (None means no shading) :param theta: angles (in radians) for display if beampattern is plotted :param show: True to plot the beampattern, False to return it :returns: beampattern power response at all directions corresponding to rows in sd >>> from arlpy import bf >>> import numpy as np >>> sd = bf.steering(np.linspace(0, 5, 11), 1500, np.linspace(-np.pi/2, np.pi/2, 181)) >>> bp = bf.bartlett_beampattern(90, 1500, sd, show=True) """ a = _np.exp(-2j * _np.pi * fc * sd) / _np.sqrt(sd.shape[1]) if shading is not None: s = _sig.get_window(shading, a.shape[1]) a *= s / _np.sqrt(_np.mean(s**2)) bp = _np.abs(_np.dot(a.conj(), a[i]))**2 if show: if theta is None: _plt.plot(_utils.pow2db(bp), ylabel='Array response (dB)', title='Beam #' + str(i)) else: a = theta * 180 / _np.pi _plt.plot(a, _utils.pow2db(bp), xlabel='Angle (deg)', ylabel='Array response (dB)', title='Beam #%d @ %0.1f deg' % (i, a[i])) else: return bp
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_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_ssp(env, **kwargs): """Plots the sound speed profile. :param env: environment description Other keyword arguments applicable for `arlpy.plot.plot()` are also supported. If the sound speed profile is range-dependent, this function only plots the first profile. >>> import arlpy.uwapm as pm >>> env = pm.create_env2d(soundspeed=[[ 0, 1540], [10, 1530], [20, 1532], [25, 1533], [30, 1535]]) >>> pm.plot_ssp(env) """ env = check_env2d(env) svp = env['soundspeed'] if isinstance(svp, _pd.DataFrame): svp = _np.hstack((_np.array([svp.index]).T, _np.asarray(svp))) if _np.size(svp) == 1: if _np.size(env['depth']) > 1: max_y = _np.max(env['depth'][:, 1]) else: max_y = env['depth'] _plt.plot([svp, svp], [0, -max_y], xlabel='Soundspeed (m/s)', ylabel='Depth (m)', **kwargs) elif env['soundspeed_interp'] == spline: s = svp ynew = _np.linspace(_np.min(svp[:, 0]), _np.max(svp[:, 0]), 100) tck = _interp.splrep(svp[:, 0], svp[:, 1], s=0) xnew = _interp.splev(ynew, tck, der=0) _plt.plot(xnew, -ynew, xlabel='Soundspeed (m/s)', ylabel='Depth (m)', hold=True, **kwargs) _plt.plot(svp[:, 1], -svp[:, 0], marker='.', style=None, **kwargs) else: _plt.plot(svp[:, 1], -svp[:, 0], xlabel='Soundspeed (m/s)', ylabel='Depth (m)', **kwargs)
def plot_ssp(env, **kwargs): """Plots the sound speed profile. :param env: environment description Other keyword arguments applicable for `arlpy.plot.plot()` are also supported. >>> import arlpy.uwapm as pm >>> env = pm.create_env2d(soundspeed=[[ 0, 1540], [10, 1530], [20, 1532], [25, 1533], [30, 1535]]) >>> pm.plot_ssp(env) """ check_env2d(env) if _np.size(env['soundspeed']) == 1: if _np.size(env['depth']) > 1: max_y = _np.max(env['depth'][:, 1]) else: max_y = env['depth'] _plt.plot([env['soundspeed'], env['soundspeed']], [0, -max_y], xlabel='Soundspeed (m/s)', ylabel='Depth (m)', **kwargs) elif env['soundspeed_interp'] == spline: s = env['soundspeed'] ynew = _np.linspace(_np.min(s[:, 0]), _np.max(s[:, 0]), 100) tck = _interp.splrep(s[:, 0], s[:, 1], s=0) xnew = _interp.splev(ynew, tck, der=0) _plt.plot(xnew, -ynew, xlabel='Soundspeed (m/s)', ylabel='Depth (m)', hold=True, **kwargs) _plt.plot(s[:, 1], -s[:, 0], marker='.', style=None, **kwargs) else: s = env['soundspeed'] _plt.plot(s[:, 1], -s[:, 0], xlabel='Soundspeed (m/s)', ylabel='Depth (m)', **kwargs)
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)
# import sys # import time # import datetime # import numpy as np # import arlpy as ap # import matplotlib.pyplot as plt # from matplotlib.pyplot import style # from matplotlib.pyplot import figure # from unetpy import * import arlpy.plot as plt import numpy as np signal_file = '/home/ilan/projects/subnero_ng/evdmode/out/rx_out/rx_rec_1' # signal_file = '/home/ilan/projects/subnero_ng/signals/subnero.sig' # signal = np.loadtxt(signal_file) signal = np.loadtxt( signal_file, dtype=complex, converters={0: lambda s: complex(s.decode().replace('+-', '-'))}) plt.plot(signal[:10000].real, fs=19200) # figure(num=None, figsize=(15, 6), dpi=80, facecolor='w', edgecolor='k') # plt.suptitle(signal_file, fontsize=20) # plt.xlabel('Sample number', fontsize=18) # plt.ylabel('Amplitude', fontsize=16) # plt.plot(signal) # plt.show()