def _find_spike(signal, points):
"""
Looks for a pacemaker spike in a signal fragment, applying fixed thresholds
on wave duration, angles and amplitude. These thresholds are the following:
- The duration of the spike must be shorter than 30ms.
- The ascent and descent angles of the spike must be higher than 75º in
common ECG scale.
- The amplitude of the spike must be at least 0.2 mV (2mm) in the edge with
lower amplitude.
- The falling edge must be of lower amplitude than the rising edge.
Parameters
----------
signal:
Numpy array containing the signal information referenced by the wave
object.
points:
Relevant points detected on the signal.
Returns
-------
out:
Tuple with three integer values, which are the begin, peak, and
end of the detected spike. If no spikes were detected, returns None.
"""
#Angle between two points
angle = lambda a, b : math.atan(dg2mm(abs(signal[b]-signal[a])/sp2mm(b-a)))
#First we search for the left edge of the spike.
spike = []
for i in xrange(1, len(points)-3):
for j in xrange(i+1, len(points)-2):
pts = points[i:j+1]
llim = pts[-1]
#There can be no peaks inside the left edge.
if (llim-pts[0] > C.SPIKE_DUR or
(len(pts) >= 3 and len(get_peaks(signal[pts])) > 0)):
break
#The end of the left edge must be a peak.
if len(get_peaks(signal[llim-1:llim+2])) < 1:
continue
#Left edge candidate
ledge = abs(signal[pts[0]] - signal[llim])
if (ledge >= C.SPIKE_EDGE_AMP and
angle(pts[0], llim) >= math.radians(85)):
#Right edge delineation.
ulim = min(int(pts[0]+C.SPIKE_DUR), points[-1])
rsig = signal[llim:ulim+1]
if len(rsig) < 3:
break
rpks = get_peaks(rsig)
if np.any(rpks):
ulim = llim + rpks[0]
ulim = ulim-1 if ulim-1 in points else ulim
ulim = ulim+1 if ulim+1 in points else ulim
while ulim > llim:
redge = abs(signal[ulim] - signal[llim])
if redge < C.SPIKE_EDGE_AMP:
break
if (redge-ledge < C.SPIKE_ECGE_DIFF and
angle(llim, ulim) >= math.radians(75)):
#Spike candidate detected
spike.append((pts[0], llim, ulim))
break
ulim -= 1
if not spike or max(sp[0] for sp in spike) >= min(sp[-1] for sp in spike):
return None
#We get the spike with highest energy.
return max(spike, key = lambda spk:
np.sum(np.diff(signal[spk[0]:spk[-1]+1])**2))
def _paced_qrs_delineation(signal, points, peak, baseline):
"""
Checks if a sequence of waves is a paced heartbeat. The main criteria is
the presence of a spike at the beginning of the beat, followed by at least
one significant wave.
"""
try:
#Gets the slope between two points.
slope = lambda a, b : abs(dg2mm((signal[b]-signal[a])/sp2mm(b-a)))
#First we search for the spike.
spike = _find_spike(signal, points)
verify(spike)
if not spike[-1] in points:
points = np.insert(points, bisect.bisect(points, spike[-1]),
spike[-1])
#Now we get relevant points, checking some related constraints.
bpts = points[points <= spike[0]]
apts = points[points >= spike[-1]]
verify(len(apts) >= 2)
#Before and after the spike there must be a significant slope change.
verify(slope(spike[0], spike[1]) > 2.0 * slope(bpts[-2], bpts[-1]))
verify(slope(spike[1], spike[-1]) > 2.0 * slope(apts[0], apts[1]))
#Now we look for the end of the QRS complex, by applying the same
#clustering strategy than regular QRS, but only for the end.
slopes = (signal[apts][1:]-signal[apts][:-1])/(apts[1:]-apts[:-1])
features = []
for i in xrange(len(slopes)):
#The features are the slope in logarithmic scale and the distance to
#the peak.
features.append([math.log(abs(slopes[i])+1.0),
abs(apts[i+1] - peak)])
features = whiten(features)
#We initialize the centroids in the extremes (considering what is
#interesting of each feature for us)
fmin = np.min(features, 0)
fmax = np.max(features, 0)
valid = np.where(kmeans2(features, np.array([[fmin[0], fmax[1]],
[fmax[0], fmin[1]]]), minit = 'matrix')[1])[0]
verify(np.any(valid))
end = apts[valid[-1]+1]
#The duration of the QRS complex after the spike must be more than 2
#times the duration of the spike.
verify((end-apts[0]) > 2.0 * (spike[-1]-spike[0]))
#The amplitude of the qrs complex must higher than 0.5 the amplitude
#of the spike.
sgspike = signal[spike[0]:spike[-1]+1]
sgqrs = signal[apts[0]:end+1]
verify(np.ptp(sgqrs) > ph2dg(0.5))
verify(np.ptp(sgqrs) > 0.5 * np.ptp(sgspike))
#There must be at least one peak in the QRS fragment.
qrspt = signal[apts[apts <= end]]
verify(len(qrspt) >= 3)
verify(abs(signal[end] - signal[spike[0]]) <= ph2dg(0.3)
or len(get_peaks(qrspt)) > 0)
#The area of the rest of the QRS complex must be higher than the spike.
verify(np.sum(np.abs(sgspike-sgspike[0])) <
np.sum(np.abs(sgqrs-sgspike[0])))
#The distance between the beginning of the spike and the baseline
#cannot be more than the 30% of the amplitude of the complex.
verify(abs(signal[spike[0]]-baseline) <
0.3 * np.ptp(signal[spike[0]:end+1]))
#At last, we have found the paced QRS limits.
return Iv(spike[0], end)
except InconsistencyError:
return None
