public
Last active — forked from sixtenbe/peakdetect.py

Peak detection in Python

  • Download Gist
.gitignore
1
*.pyc
__init__.py
Python

          
find_peaks.pyx
Cython
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363
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
Python
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436
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

Please sign in to comment on this gist.

Something went wrong with that request. Please try again.