Peak detection in Python

.gitignore

*.pyc

__init__.py

find_peaks.pyx

import numpy as np
from math import pi, log
import pylab

from scipy.optimize import curve_fit

# cython imports
cimport numpy as np
DTYPE = np.float
ctypedef np.float_t DTYPE_t
ctypedef np.int_t DTYPE_INT
from cpython cimport bool

def fit_quad_to_peak(np.ndarray[DTYPE_t,ndim=1] x,np.ndarray[DTYPE_t,ndim=1] y):
    """
    Fits a quadratic to the data points handed in
    to the from y = b[0](x-b[1]) + b[2] 

    x -- locations
    y -- values
    
    """

    cdef int lenx = len(x)
    
    # some sanity checks
    if lenx < 3:
        raise Exception('insufficient points handed in ')
    # set up fitting array
    cdef np.ndarray[DTYPE_t,ndim=2] X
    X = np.vstack((x**2,x,np.ones(lenx))).T

    cdef np.ndarray[DTYPE_t,ndim=1] beta


    # use linear least squares fitting
    beta,_,_,_ = np.linalg.lstsq(X,y)


    # re-map the returned value to match the form we want
    ret_beta  = (beta[0],
             -beta[1]/(2*beta[0]),
             beta[2] - beta[0]*(beta[1]/(2*beta[0]))**2)


    return ret_beta
    
def peakdetect(np.ndarray y_axis_in, np.ndarray x_axis_in = None, int lookahead = 500, float delta = 0,bool isring=False):
    """
    Converted from/based on a MATLAB script at http://billauer.co.il/peakdet.html
    
    function for detecting local maximas and minmias in a signal.
    Discovers peaks by searching for values which are surrounded by lower
    or larger values for maximas and minimas respectively
    
    keyword arguments:
    y_axis -- A list containg the signal over which to find peaks
    x_axis -- (optional) A x-axis whose values correspond to the y_axis list
        and is used in the return to specify the postion of the peaks. If
        omitted an index of the y_axis is used. (default: None)
    lookahead -- (optional) distance to look ahead from a peak candidate to
        determine if it is the actual peak (default: 500) 
        '(sample / period) / f' where '4 >= f >= 1.25' might be a good value
    delta -- (optional) this specifies a minimum difference between a peak and
        the following points, before a peak may be considered a peak. Useful
        to hinder the function from picking up false peaks towards to end of
        the signal. To work well delta should be set to delta >= RMSnoise * 5.
        (default: 0)
            delta function causes a 20% decrease in speed, when omitted
            Correctly used it can double the speed of the function
    
    return -- two lists [max_peaks, min_peaks] containing the positive and
        negative peaks respectively. Each cell of the lists contains a tupple
        of: (position, peak_value) 
        to get the average peak value do: np.mean(max_peaks, 0)[1] on the
        results to unpack one of the lists into x, y coordinates do: 
        x, y = zip(*tab)
    """

    dump = []   #Used to pop the first hit which always if false

    cdef np.ndarray x_axis
    cdef np.ndarray y_axis
    
    cdef int length = len(y_axis_in)
    if x_axis_in is None:
        x_axis = np.arange(length)
    else:
        x_axis = np.asarray(x_axis_in,dtype=DTYPE)
    #perform some checks
    if length != len(x_axis):
        raise ValueError, "Input vectors y_axis and x_axis must have same length"
    if lookahead < 1:
        raise ValueError, "Lookahead must be '1' or above in value"
    if not (np.isscalar(delta) and delta >= 0):
        raise ValueError, "delta must be a positive number"

    
    #needs to be a numpy array
    y_axis = np.asarray(y_axis_in,dtype=DTYPE)
    
    #maxima and minima candidates are temporarily stored in
    #mx and mn respectively
    cdef float x,y,mx,mn,mxpos,mnpos
    cdef int index
    mn, mx = np.Inf, -np.Inf
    if isring:

        y_axis = np.concatenate((y_axis[-lookahead:],y_axis,y_axis[:lookahead]))
        x_axis = np.concatenate((x_axis[-lookahead:],x_axis,x_axis[:lookahead]))

    min_peaks = []
    max_peaks = []
    #Only detect peak if there is 'lookahead' amount of points after it
    #    for index, (x, y) in enumerate(zip(x_axis[:-lookahead], y_axis[:-lookahead])):
    mnpos = x_axis[0]
    mxpos = x_axis[0]    
    for index in range(length - lookahead):
        x = x_axis[index]
        y = y_axis[index]
        if y > mx:
            mx = y
            mxpos = x
        if y < mn:
            mn = y
            mnpos = x
        
        ####look for max####
        if y < mx-delta and mx != np.Inf:
            #Maxima peak candidate found
            #look ahead in signal to ensure that this is a peak and not jitter
            if y_axis[index:index+lookahead].max() < mx:
                max_peaks.append([mxpos, mx])
                dump.append(True)
                #set algorithm to only find minima now
                mx = np.Inf
                mn = np.Inf
                if index+lookahead >= length:
                    #end is within lookahead no more peaks can be found
                    break
                continue
            #else:  #slows shit down this does
            #    mx = ahead
            #    mxpos = x_axis[np.where(y_axis[index:index+lookahead]==mx)]
        
        ####look for min####
        if y > mn+delta and mn != -np.Inf:
            #Minima peak candidate found 
            #look ahead in signal to ensure that this is a peak and not jitter
            if y_axis[index:index+lookahead].min() > mn:
                min_peaks.append([mnpos, mn])
                dump.append(False)
                #set algorithm to only find maxima now
                mn = -np.Inf
                mx = -np.Inf
                if index+lookahead >= length:
                    #end is within lookahead no more peaks can be found
                    break
            #else:  #slows shit down this does
            #    mn = ahead
            #    mnpos = x_axis[np.where(y_axis[index:index+lookahead]==mn)]
    
    
    #Remove the false hit on the first value of the y_axis
    try:
        if dump[0]:
            max_peaks.pop(0)
        else:
            min_peaks.pop(0)
        del dump
    except IndexError:
        #no peaks were found, should the function return empty lists?
        pass
    return max_peaks, min_peaks

    
def peakdetect_parabole(np.ndarray[DTYPE_t,ndim=1] y_axis,np.ndarray[DTYPE_t,ndim=1] x_axis,  int min_pts = 3,bool is_ring = False):
    """
    Function for detecting local maximas and minmias in a signal.
    Discovers peaks by fitting the model function: y = k (x - tau) ** 2 + m
    to the peaks.  The region between zero crossing is fit, the type of peak
    is determined by fit.
        
    keyword arguments:
    y_axis -- A list containg the signal over which to find peaks
    x_axis -- A x-axis whose values correspond to the y_axis list and is used
        in the return to specify the postion of the peaks.
    points -- (optional) How many points around the peak should be used during
        curve fitting, must be odd (default: 9)
    
    return -- two lists [max_peaks, min_peaks] containing the positive and
        negative peaks respectively. Each cell of the lists contains a list
        of: (position, peak_value) 
        to get the average peak value do: np.mean(max_peaks, 0)[1] on the
        results to unpack one of the lists into x, y coordinates do: 
        x, y = zip(*max_peaks)
    """
    # check input data
            
    if len(y_axis) != len(x_axis):
        raise (ValueError, 
                'Input vectors y_axis and x_axis must have same length')

    cdef np.ndarray[DTYPE_INT,ndim=1] zero_indices
    cdef np.ndarray[DTYPE_INT,ndim=1] period_lengths
    
    # get zero crossings       
    
    zero_indices = np.diff(np.sign(y_axis)).nonzero()[0]

    # check if any zero crossings were found
    if len(zero_indices) < 1:
        raise(ValueError, "No zero crossings found")
    
    # get spacing
    period_lengths = np.diff(zero_indices)
    
    # define output variable
    max_peaks = []
    min_peaks = []

    cdef int indx,p_len,j,strt,ed
    cdef np.ndarray[DTYPE_t,ndim=1] tmp_x,tmp_y

    
    for j in range(len(period_lengths)):
        indx = zero_indices[j]
        p_len = period_lengths[j]
        if p_len < min_pts:
            continue
        strt = indx
        ed = indx + p_len
        tmp_x = x_axis[strt:ed]
        tmp_y = y_axis[strt:ed]

        b = fit_quad_to_peak(tmp_x,tmp_y)
        if b[0] < 0:
            max_peaks.append((b[1],b[2]))
        elif b[0] > 0:
            min_peaks.append((b[1],b[2]))

    # deal with ring

    if is_ring:
        if np.sign(y_axis[0]) == np.sign(y_axis[-1]):
            # if the first and last points have the same sign, we caught
            # all zero-crossings and just need to sticky tape the front
            # and back together
            tmp_x = np.concatenate((x_axis[zero_indices[-1]:]-2*pi,x_axis[:zero_indices[0]]))
            tmp_y = np.concatenate((y_axis[zero_indices[-1]:],y_axis[:zero_indices[0]]))
            b = fit_quad_to_peak(tmp_x,tmp_y)
            if b[0] < 0:
                max_peaks.append((b[1],b[2]))
            elif b[0] > 0:
                min_peaks.append((b[1],b[2]))
        else:
            # there is a hidden zero crossing in the data
            # deal with first peak
            b = fit_quad_to_peak(x_axis[:zero_indices[0]],y_axis[:zero_indices[0]])
            if b[0] < 0:
                max_peaks.append((b[1],b[2]))
            elif b[0] > 0:
                min_peaks.append((b[1],b[2]))
            # deal with last
            b = fit_quad_to_peak(x_axis[zero_indices[-1]:],y_axis[zero_indices[-1]:])
            if b[0] < 0:
                max_peaks.append((b[1],b[2]))
            elif b[0] > 0:
                min_peaks.append((b[1],b[2]))

    return max_peaks, min_peaks
    
    
    
def peakdetect_zero_crossing(np.ndarray[DTYPE_t,ndim=1] y_axis,np.ndarray[DTYPE_t,ndim=1] x_axis,bool is_ring =False):
    """
    Function for detecting local maximas and minmias in a signal.
    Discovers peaks by dividing the signal into bins and retrieving the
    maximum and minimum value of each the even and odd bins respectively.
    Division into bins is performed by smoothing the curve and finding the
    zero crossings.
    
    Suitable for repeatable signals, where some noise is tolerated. Excecutes
    faster than 'peakdetect', although this function will break if the offset
    of the signal is too large. It should also be noted that the first and
    last peak will probably not be found, as this function only can find peaks
    between the first and last zero crossing.
    
    keyword arguments:
    y_axis -- A list containg the signal over which to find peaks
    x_axis -- (optional) A x-axis whose values correspond to the y_axis list
        and is used in the return to specify the postion of the peaks. If
        omitted an index of the y_axis is used. (default: None)
    window -- the dimension of the smoothing window; should be an odd integer
        (default: 11)
    
    return -- two lists [max_peaks, min_peaks] containing the positive and
        negative peaks respectively. Each cell of the lists contains a tupple
        of: (position, peak_value) 
        to get the average peak value do: np.mean(max_peaks, 0)[1] on the
        results to unpack one of the lists into x, y coordinates do: 
        x, y = zip(*tab)
    """
    # check input data
        
    if len(y_axis) != len(x_axis):
        raise (ValueError, 
                'Input vectors y_axis and x_axis must have same length')

    cdef np.ndarray[DTYPE_INT,ndim=1] zero_indices
    cdef np.ndarray[DTYPE_INT,ndim=1] period_lengths
    
    zero_indices, = np.diff(np.sign(y_axis)).nonzero()

    # check if any zero crossings were found
    if len(zero_indices) < 1:
        raise(ValueError, "No zero crossings found")
    
    # get spacing
    period_lengths = np.diff(zero_indices)
            
    bins_y = [y_axis[index:index + diff] for index, diff in 
        zip(zero_indices, period_lengths)]
    bins_x = [x_axis[index:index + diff] for index, diff in 
        zip(zero_indices, period_lengths)]
        
    even_bins_y = bins_y[::2]
    odd_bins_y = bins_y[1::2]
    even_bins_x = bins_x[::2]
    odd_bins_x = bins_x[1::2]
    hi_peaks_x = []
    lo_peaks_x = []
    

    
    # check if even bin contains maxima
    if abs(even_bins_y[0].max()) > abs(even_bins_y[0].min()):
        high_bins_y = even_bins_y
        high_bins_x = even_bins_x
        low_bins_y = odd_bins_y
        low_bins_x = odd_bins_x
    # or a minimum
    else:
        high_bins_y = odd_bins_y
        high_bins_x = odd_bins_x
        low_bins_y = even_bins_y
        low_bins_x = even_bins_x

        
    high_peaks = [_bin.argmax() for _bin in high_bins_y]
    low_peaks = [_bin.argmin() for _bin in low_bins_y]
    # get x values for peak
    cdef np.ndarray x,y
    cdef int peak
    min_peaks = []
    max_peaks = []
    for x,y,peak in zip(high_bins_x,high_bins_y,high_peaks):
        max_peaks.append((x[peak],y[peak]))
    for x,y,peak in zip(low_bins_x,low_bins_y,low_peaks):
        min_peaks.append((x[peak],y[peak]))
    return max_peaks, min_peaks
        
    

peakdetect.py

import numpy as np
import multiprocessing
import itertools


class FP_worker(multiprocessing.Process):
    """Worker class for farming out the work of doing the least
    squares fit

    """

    def __init__(self,
                 work_queue,
                 res_queue):
        """
        Work queue is a joinable queue, res_queue can be any sort of thing that supports put()
        """
        # background set up that must be done
        multiprocessing.Process.__init__(self)
        self.daemonic = True
        self.work_queue = work_queue
        self.res_queue = res_queue

    def run(self):
        """
        The assumption is that these will be run daemonic and reused for multiple work sessions
        """
        while True:
            work_lst = self.work_queue.get()
            if work_lst is None:          # poison pill
                return
            res_lst = []
            for x, y in work_lst:
                res_lst.append(fit_quad_to_peak(x, y))
            self.res_queue.put(res_lst)
            self.work_queue.task_done()


__PROCS = None
__WORK_QUEUE = None
__RES_QUEUE = None


def init_procs(N):
    """Sets up N processes"""
    global __PROCS
    global __WORK_QUEUE
    global __RES_QUEUE
    __WORK_QUEUE = multiprocessing.JoinableQueue()
    __RES_QUEUE = multiprocessing.Queue()
    __PROCS = [FP_worker(__WORK_QUEUE, __RES_QUEUE) for j in range(N)]
    for p in __PROCS:
        p.start()


def kill_procs():
    for j in range(len(__PROCS)):
        __WORK_QUEUE.put(None)


def _datacheck_peakdetect(x_axis, y_axis):
    if x_axis is None:
        x_axis = range(len(y_axis))

    if len(y_axis) != len(x_axis):
        raise (ValueError,
               'Input vectors y_axis and x_axis must have same length')

    #needs to be a numpy array
    y_axis = np.asarray(y_axis)
    x_axis = np.asarray(x_axis)
    return x_axis, y_axis


def fit_quad_to_peak(x, y):
    """
    Fits a quadratic to the data points handed in
    to the from y = b[0](x-b[1]) + b[2]

    x -- locations
    y -- values

    returns (b, R2)

    """

    lenx = len(x)

    # some sanity checks
    if lenx < 3:
        raise Exception('insufficient points handed in ')
    # set up fitting array
    X = np.vstack((x ** 2, x, np.ones(lenx))).T
    # use linear least squares fitting
    beta, _, _, _ = np.linalg.lstsq(X, y)

    SSerr = np.sum(np.power(np.polyval(beta, x) - y, 2))
    SStot = np.sum(np.power(y - np.mean(y), 2))
    # re-map the returned value to match the form we want
    ret_beta = (beta[0],
                -beta[1] / (2 * beta[0]),
                beta[2] - beta[0] * (beta[1] / (2 * beta[0])) ** 2)

    return ret_beta, 1 - SSerr / SStot


def peakdetect(y_axis, x_axis=None, lookahead=300, delta=0):
    """
    Converted from/based on a MATLAB script at:
    http://billauer.co.il/peakdet.html

    function for detecting local maximas and minmias in a signal.
    Discovers peaks by searching for values which are surrounded by lower
    or larger values for maximas and minimas respectively

    keyword arguments:
    y_axis -- A list containg the signal over which to find peaks
    x_axis -- (optional) A x-axis whose values correspond to the y_axis list
        and is used in the return to specify the postion of the peaks. If
        omitted an index of the y_axis is used. (default: None)
    lookahead -- (optional) distance to look ahead from a peak candidate to
        determine if it is the actual peak (default: 200)
        '(sample / period) / f' where '4 >= f >= 1.25' might be a good value
    delta -- (optional) this specifies a minimum difference between a peak and
        the following points, before a peak may be considered a peak. Useful
        to hinder the function from picking up false peaks towards to end of
        the signal. To work well delta should be set to delta >= RMSnoise * 5.
        (default: 0)
            delta function causes a 20% decrease in speed, when omitted
            Correctly used it can double the speed of the function

    return -- two lists [max_peaks, min_peaks] containing the positive and
        negative peaks respectively. Each cell of the lists contains a tupple
        of: (position, peak_value)
        to get the average peak value do: np.mean(max_peaks, 0)[1] on the
        results to unpack one of the lists into x, y coordinates do:
        x, y = zip(*tab)
    """
    max_peaks = []
    min_peaks = []
    dump = []   # Used to pop the first hit which almost always is false

    # check input data
    x_axis, y_axis = _datacheck_peakdetect(x_axis, y_axis)
    # store data length for later use
    length = len(y_axis)

    #perform some checks
    if lookahead < 1:
        raise ValueError("Lookahead must be '1' or above in value")
    if not (np.isscalar(delta) and delta >= 0):
        raise ValueError("delta must be a positive number")

    #maxima and minima candidates are temporarily stored in
    #mx and mn respectively
    mn, mx = np.Inf, -np.Inf

    #Only detect peak if there is 'lookahead' amount of points after it
    for index, (x, y) in enumerate(zip(x_axis[:-lookahead],
                                       y_axis[:-lookahead])):
        if y > mx:
            mx = y
            mxpos = x
        if y < mn:
            mn = y
            mnpos = x

        ####look for max####
        if y < mx - delta and mx != np.Inf:
            #Maxima peak candidate found
            #look ahead in signal to ensure that this is a peak and not jitter
            if y_axis[index:index + lookahead].max() < mx:
                max_peaks.append([mxpos, mx])
                dump.append(True)
                #set algorithm to only find minima now
                mx = np.Inf
                mn = np.Inf
                if index + lookahead >= length:
                    #end is within lookahead no more peaks can be found
                    break
                continue
            #else:  #slows shit down this does
            #    mx = ahead
            #    mxpos = x_axis[np.where(y_axis[index:index+lookahead]==mx)]

        ####look for min####
        if y > mn + delta and mn != -np.Inf:
            #Minima peak candidate found
            #look ahead in signal to ensure that this is a peak and not jitter
            if y_axis[index:index + lookahead].min() > mn:
                min_peaks.append([mnpos, mn])
                dump.append(False)
                #set algorithm to only find maxima now
                mn = -np.Inf
                mx = -np.Inf
                if index + lookahead >= length:
                    #end is within lookahead no more peaks can be found
                    break
            #else:  #slows shit down this does
            #    mn = ahead
            #    mnpos = x_axis[np.where(y_axis[index:index+lookahead]==mn)]

    #Remove the false hit on the first value of the y_axis
    try:
        if dump[0]:
            max_peaks.pop(0)
        else:
            min_peaks.pop(0)
        del dump
    except IndexError:
        #no peaks were found, should the function return empty lists?
        pass

    return [max_peaks, min_peaks]


def peakdetect_parabole(y_axis, x_axis, min_pts=4, max_pts=25, R2_cut=.1, is_ring=False):
    """
    Function for detecting local maximas and minmias in a signal.
    Discovers peaks by fitting the model function: y = k (x - tau) ** 2 + m
    to the peaks.  The region between zero crossing is fit, the type of peak
    is determined by fit.

    keyword arguments:
    :param y_axis: A list containg the signal over which to find peaks
    :param x_axis:  A x-axis whose values correspond to the y_axis list and is used
        in the return to specify the postion of the peaks.
    :param min_pts: the minimum points between a zero crossing for it to be peak candidate
    :param max_pts: regions with more points than this will be down sampled
    :param is_ring: if True, then data is periodic.

    return -- two lists [max_peaks, min_peaks] containing the positive and
        negative peaks respectively. Each cell of the lists contains a list
        of: (position, peak_value)
        to get the average peak value do: np.mean(max_peaks, 0)[1] on the
        results to unpack one of the lists into x, y coordinates do:
        x, y = zip(*max_peaks)
    """
    if len(y_axis) != len(x_axis):
        raise ValueError('Input vectors y_axis and x_axis must have same length')

    # get zero crossings
    zero_indices = zero_crossings(y_axis) + 1
    period_lengths = np.diff(zero_indices)

    # define output variable
    max_peaks = []
    min_peaks = []

    work_list = []
    res_list = []
    for indx, p_len in zip(zero_indices, period_lengths):
        if p_len < min_pts:
            continue
        step = 1
        if p_len > max_pts:
            step = int(np.floor(p_len / max_pts))
        work_list.append((x_axis[(indx - 1):(indx + p_len + 1):step], y_axis[(indx - 1):(indx + p_len + 1):step]))

    # deal with ring
    if is_ring:
        if np.sign(y_axis[0]) == np.sign(y_axis[-2]):
            # if the first and last points have the same sign, we caught
            # all zero-crossings and just need to sticky tape the front
            # and back together
            tmp_x = np.concatenate((x_axis[zero_indices[-1] - 1:] - 2 * np.pi, x_axis[1:zero_indices[0] + 1]))
            tmp_y = np.concatenate((y_axis[zero_indices[-1] - 1:], y_axis[1:zero_indices[0] + 1]))
            p_len = len(tmp_x)
            if p_len >= min_pts:
                step = 1
                if p_len > max_pts:
                    step = int(np.floor(p_len / max_pts))
                work_list.append((tmp_x[::step], tmp_y[::step]))

        else:
            # there is a hidden zero crossing in the data
            # deal with first peak
            p_len = zero_indices[0] + 1
            if p_len >= min_pts:
                step = 1
                if p_len > max_pts:
                    step = int(np.floor(p_len / max_pts))
                work_list.append((x_axis[:zero_indices[0] + 1:step], y_axis[:zero_indices[0] + 1:step]))
            # deal with last
            p_len = len(y_axis) - zero_indices[-1]
            if p_len >= min_pts:
                step = 1
                if p_len > max_pts:
                    step = int(np.floor(p_len / max_pts))
                work_list.append((x_axis[zero_indices[-1]::step], y_axis[zero_indices[-1]::step]))

    if __PROCS is not None:
        # split up the work in a semi-equal way
        jobs_pre_proc = len(work_list) // len(__PROCS) + 1
        for j in range(len(__PROCS)):
            __WORK_QUEUE.put(work_list[j * jobs_pre_proc:(j + 1) * jobs_pre_proc])
        __WORK_QUEUE.join()

        # we know we never hand out more than len(__PROCS) jobs
        for j in range(len(__PROCS)):
            res_list.extend(__RES_QUEUE.get())
    else:
        res_list = [fit_quad_to_peak(x, y) for x, y in work_list]

    res_dict = {-1: [], 1: [], 0: []}

    for ((a, b, c), e), (x, y) in itertools.izip(res_list, work_list):
        if e > R2_cut:
            res_dict[np.sign(a)].append((b, c))
        else:

            orig_sign = np.sign(y[1])
            y = y * orig_sign
            step = len(y) // 4
            slice_arg = np.argmin(y[step:-step]) + step
            if slice_arg - 1 > min_pts:
                t_len = slice_arg - 1

                step = int(np.floor(t_len / max_pts)) if t_len > max_pts else 1
                slc = slice(0, slice_arg - 1, step)

                ((a, b, c), R2) = fit_quad_to_peak(x[slc], orig_sign * y[slc])


                if R2 > R2_cut:

                    res_dict[np.sign(a)].append((b, c))

            if len(y) - slice_arg - 1 > min_pts:
                t_len = slice_arg - 1
                step = int(np.floor(t_len / max_pts)) if t_len > max_pts else 1
                slc = slice(slice_arg + 1, -1, step)

                ((a, b, c), R2) = fit_quad_to_peak(x[slc], orig_sign * y[slc])


                if R2 > R2_cut:

                    res_dict[np.sign(a)].append((b, c))

    return [res_dict[-1], res_dict[1]]


def peakdetect_zero_crossing(y_axis, x_axis=None):
    """
    Function for detecting local maximas and minmias in a signal.
    Discovers peaks by dividing the signal into bins and retrieving the
    maximum and minimum value of each the even and odd bins respectively.
    Division into bins is performed by smoothing the curve and finding the
    zero crossings.

    Suitable for repeatable signals, where some noise is tolerated. Excecutes
    faster than 'peakdetect', although this function will break if the offset
    of the signal is too large. It should also be noted that the first and
    last peak will probably not be found, as this function only can find peaks
    between the first and last zero crossing.

    keyword arguments:
    y_axis -- A list containg the signal over which to find peaks
    x_axis -- (optional) A x-axis whose values correspond to the y_axis list
        and is used in the return to specify the postion of the peaks. If
        omitted an index of the y_axis is used. (default: None)
    window -- the dimension of the smoothing window; should be an odd integer
        (default: 11)

    return -- two lists [max_peaks, min_peaks] containing the positive and
        negative peaks respectively. Each cell of the lists contains a tupple
        of: (position, peak_value)
        to get the average peak value do: np.mean(max_peaks, 0)[1] on the
        results to unpack one of the lists into x, y coordinates do:
        x, y = zip(*tab)
    """
    # check input data
    x_axis, y_axis = _datacheck_peakdetect(x_axis, y_axis)

    zero_indices = zero_crossings(y_axis)
    period_lengths = np.diff(zero_indices)

    bins_y = [y_axis[index:index + diff] for index, diff in
              zip(zero_indices, period_lengths)]
    bins_x = [x_axis[index:index + diff] for index, diff in
              zip(zero_indices, period_lengths)]

    even_bins_y = bins_y[::2]
    odd_bins_y = bins_y[1::2]
    even_bins_x = bins_x[::2]
    odd_bins_x = bins_x[1::2]
    hi_peaks_x = []
    lo_peaks_x = []

    min_peaks = []
    max_peaks = []

    # check if even bin contains maxima
    if abs(even_bins_y[0].max()) > abs(even_bins_y[0].min()):
        high_bins_y = even_bins_y
        high_bins_x = even_bins_x
        low_bins_y = odd_bins_y
        low_bins_x = odd_bins_x
    # or a minimum
    else:
        high_bins_y = odd_bins_y
        high_bins_x = odd_bins_x
        low_bins_y = even_bins_y
        low_bins_x = even_bins_x

    high_peaks = [_bin.argmax() for _bin in high_bins_y]
    low_peaks = [_bin.argmin() for _bin in low_bins_y]
    # get x values for peak
    for x, y, peak in zip(high_bins_x, high_bins_y, high_peaks):
        max_peaks.append((x[peak], y[peak]))
    for x, y, peak in zip(low_bins_x, low_bins_y, low_peaks):
        min_peaks.append((x[peak], y[peak]))
    return [max_peaks, min_peaks]


def zero_crossings(y_axis):
    """
    Algorithm to find zero crossings.  Finds the zero-crossings by
    looking for a sign change.  This assumes that the data has been
    sensibly smoothed before being handed in.


    keyword arguments:
    y_axis -- A list containg the signal over which to find zero-crossings

    return -- the index for each zero-crossing
    """

    zero_crossings, = np.diff(np.sign(y_axis)).nonzero()

    # check if any zero crossings were found
    if len(zero_crossings) < 1:
        raise(ValueError, "No zero crossings found")

    return zero_crossings