Plot sub-glides over depth and high-pass filtered accelerometer signal

    Args
    ----
    mask_exp: ndarray
        Boolean mask array to slice tag data to experimtal period
    depths: ndarray
        Depth values at each sensor sampling
    mask_tag_filt: ndarray
        Boolean mask to slice filtered sub-glides from tag data
    sgls: pandas.DataFrame
        Sub-glide summary information defined by `SGL` start/stop indices
    mask_sgls_filt: ndarray
        Boolean mask to slice filtered sub-glides from sgls data
    Az_g_hf: ndarray
        High-pass filtered, calibrated z-axis accelerometer data
    idx_start: int
        Sample index position where plot should begin
    idx_stop: int
        Sample index position where plot should stop
    path_plot: str
        Path and filename for figure to be saved
    linewidth: float
        Width of plot lines (Default: 0.5)
    clip_x: bool
        Swith to clip x-axis to the experimental period

def plot_sgls(mask_exp, depths, mask_tag_filt, sgls, mask_sgls_filt, Az_g_hf,
        idx_start=None, idx_end=None, path_plot=None, linewidth=0.5,
        leg_bbox=(1.23,1), clip_x=False):
    '''Plot sub-glides over depth and high-pass filtered accelerometer signal

    Args
    ----
    mask_exp: ndarray
        Boolean mask array to slice tag data to experimtal period
    depths: ndarray
        Depth values at each sensor sampling
    mask_tag_filt: ndarray
        Boolean mask to slice filtered sub-glides from tag data
    sgls: pandas.DataFrame
        Sub-glide summary information defined by `SGL` start/stop indices
    mask_sgls_filt: ndarray
        Boolean mask to slice filtered sub-glides from sgls data
    Az_g_hf: ndarray
        High-pass filtered, calibrated z-axis accelerometer data
    idx_start: int
        Sample index position where plot should begin
    idx_stop: int
        Sample index position where plot should stop
    path_plot: str
        Path and filename for figure to be saved
    linewidth: float
        Width of plot lines (Default: 0.5)
    clip_x: bool
        Swith to clip x-axis to the experimental period
    '''
    import matplotlib.pyplot as plt
    from matplotlib.ticker import FuncFormatter, ScalarFormatter
    import numpy

    from . import plotutils
    from .. import utils

    # Create experiment mask from specified start/end indices if passed
    if idx_start or idx_end:
        mask_exp = numpy.zeros(len(depths), dtype=bool)
        if idx_start and idx_end:
            mask_exp[idx_start:idx_end] = True
        elif idx_start:
            mask_exp[idx_start:ind_exp[-1]] = True
        elif idx_end:
            mask_exp[ind_exp[0]:idx_end] = True

    # Filter passed data to experimental period
    depths  = depths[mask_exp]
    Az_g_hf = Az_g_hf[mask_exp]

    # Create subglide indice groups for plotting
    sgl_ind    = numpy.where(mask_tag_filt & mask_exp)[0]
    notsgl_ind = numpy.where((~mask_tag_filt) & mask_exp)[0]
    # Create experiment indices from `mask_exp`
    ind_exp = numpy.where(mask_exp)[0]
    offset = 0
    plt_offset = ind_exp[0]

    # Clip values to within experimental period
    if clip_x:
        offset = ind_exp[0]
        ind_exp = ind_exp - offset
        sgl_ind    = sgl_ind - offset
        notsgl_ind = notsgl_ind - offset
        plt_offset = 0

    fig, (ax1, ax2) = plt.subplots(2, 1)

    # Plot glides
    c0, c1 = _colors[0:2]
    ax1 = plotutils.plot_noncontiguous(ax1, depths, sgl_ind, c0, 'Glides',
                                       offset=plt_offset,
                                       linewidth=linewidth*2)
    ax1 = plotutils.plot_noncontiguous(ax1, depths, notsgl_ind, c1, 'Stroking',
                                       offset=plt_offset, linewidth=linewidth,
                                       linestyle='--')

    # Plot HF Z-axis
    c0 = _colors[2]
    ax2.plot(ind_exp, Az_g_hf, color=c0, label='Z-axis HF Acc.',
            linewidth=linewidth)

    # Get dives within mask
    gg = sgls[mask_sgls_filt]

    # Get midpoint of dive occurance
    x = (gg['start_idx'] + (gg['stop_idx'] - gg['start_idx'])/2)
    x = x.values.astype(float)
    x_mask = (x-offset > ind_exp[0]) & (x-offset< ind_exp[-1])
    x = x[x_mask]

    # Get depth at midpoint
    if clip_x:
        x = x - offset
        ind_x = numpy.round(x).astype(int)
    else:
        ind_x = numpy.round(x - plt_offset).astype(int)
    y = depths[ind_x]

    # For each dive_id, sgl_id pair, create annotation string, apply
    dids = gg['dive_id'].values.astype(int)
    sids = numpy.array(gg.index)
    dids = dids[x_mask]
    sids = sids[x_mask]
    n = ['Dive:{}, SGL:{}'.format(did, sid) for did, sid in zip(dids, sids)]

    diff = ind_exp[1] - ind_exp[0]
    for i, txt in enumerate(n):
        # TODO semi-hardcoded dist for annotation
        ax1.annotate(txt, (x[i]+int(diff*16),y[i]))

    # Plot shaded areas where not sub-glides
    ax1 = plotutils.plot_shade_mask(ax1, ind_exp, ~mask_tag_filt[mask_exp],
            facecolor='#d9d9d9')
    ax2 = plotutils.plot_shade_mask(ax2, ind_exp, ~mask_tag_filt[mask_exp],
            facecolor='#d9d9d9')

    # Set x-axes limits
    for ax in [ax1, ax2]:
        ticks = ax.get_yticks()
        ax.set_ylim((ticks[0], ticks[-1]))
        if idx_start:
            xmin = idx_start
        else:
            xmin = ax.get_xlim()[0]
        if idx_end:
            xmax = idx_end
        else:
            xmax = ax.get_xlim()[1]
        if clip_x:
            xmin, xmax = xmin-offset, xmax-offset
        ax.set_xlim(xmin, xmax)
        for tick in ax.get_xticklabels():
            tick.set_rotation(45)
            tick.set_ha('right')

    # Update Depth subplot y-axis labels, limits, invert depth
    ax1.set_ylabel('Depth ($m$)')
    ymin = depths.min() - (depths.max()*0.01)
    ymax = depths.max() + (depths.max()*0.01)
    ax1.set_ylim((ymin, ymax))
    ax1.invert_yaxis()
    ax1.get_yaxis().set_label_coords(-0.09,0.5)

    # Update PRH subplot y labels, limits
    ax2.set_ylabel('Z-axis acceleration ($g$)')
    ax2.set_ylim((Az_g_hf.min(), Az_g_hf.max()))
    ax2.get_yaxis().set_label_coords(-0.09,0.5)

    # Scientific notation for ax1 `n_samples`
    ax1.set_xlabel('No. sensor samples')
    mf1 = ScalarFormatter(useMathText=True)
    mf1.set_powerlimits((-2,2))
    ax1.xaxis.set_major_formatter(mf1)

    # Convert n_samples to hourmin labels
    ax2.set_xlabel('Experiment duration ($min \, sec$)')
    mf2 = FuncFormatter(plotutils.nsamples_to_minsec)
    ax2.xaxis.set_major_formatter(mf2)

    # Create legends outside plot area
    leg1 = ax1.legend(bbox_to_anchor=leg_bbox)
    plt.tight_layout(rect=[0,0,0.8,1])

    # Save plot if `path_plot` passed
    if path_plot:
        import os
        fname = 'subglide_highlight'
        if idx_start:
            fname += '_start{}'.format(idx_start)
        if idx_end:
            fname+= '_stop{}'.format(idx_end)
        ext = '.eps'
        file_fig = os.path.join(path_plot, fname+ext)
        plt.savefig(file_fig, box='tight')

    plt.show()

    return None