def _get_paced_qrs_shape(signal, points, start, end):
"""
Obtains the QRSShape object corresponding to a paced QRS complex delimited
inside a signal fragment.
Parameters
----------
signal:
Signal fragment containing a paced QRS complex. The limits of the
signal should be the limits determined by the *_paced_qrs_delineation*
function.
points:
Relevant points in the signal fragment.
start:
Start point of the pace spike wrt the start of the signal.
end:
Finish point of the paced QRS wrt the start of the signal.
Returns
-------
out:
QRSShape object representing the paced beat.
"""
try:
signal = signal[start:end+1]
points = points[np.logical_and(points >= start, points <= end)] - start
verify(len(points)>0)
if points[0] != 0:
points = np.insert(points, 0, 0)
if points[-1] != len(signal) - 1:
points = np.append(points, len(signal) - 1)
verify(len(points) >= 3)
#We assume the baseline level is the start signal value of the spike
waves = extract_waves(signal, points, signal[points[0]])
verify(waves)
total_energ = sum(w.e for w in waves)
#We get the longest wave sequence with a valid QRS tag.
i = 0
while i < len(waves) and _tag_qrs(waves[:i+1]) in C.QRS_SHAPES:
i += 1
tag = _tag_qrs(waves[:i])
verify(tag in C.QRS_SHAPES)
shape = QRSShape()
shape.waves = waves[:i]
shape.energy = sum(w.e for w in shape.waves)
shape.tag = tag
shape.sig = (signal[shape.waves[0].l:shape.waves[-1].r+1] -
signal[shape.waves[0].l])
shape.maxslope = np.max(np.abs(np.diff(shape.sig)))
shape.amplitude = np.ptp(shape.sig)
shape.move(start)
verify(shape.energy/total_energ > 0.5)
return shape
except (ValueError, InconsistencyError):
return None
def _get_qrs_shape(signal, points, peak, baseline):
"""
Obtains the QRSShape object that best fits a signal fragment, considering
the simplification determined by points, and the peak and baseline
estimations. The detected QRS shape must collect the majority of the total
energy of the waves present in the signal fragment.
"""
try:
waves = extract_waves(signal, points, baseline)
verify(waves)
total_energ = sum(w.e for w in waves)
#We find the longest valid sequence of waves with the highest energy.
sequences = []
for i in xrange(len(waves)):
#Largest valid sequence starting in the i-th wave.
seq = [waves[i]]
j = i+1
while j < len(waves) and _is_qrs_complex(waves[i:j+1]):
seq.append(waves[j])
j += 1
#We add the valid sequence and the acumulated energy (we require
#the peak to actually be inside the sequence.)
tag = _tag_qrs(seq)
energ = sum(w.e for w in seq)
if (tag in C.QRS_SHAPES and energ/total_energ > 0.5 and
any(w.l <= peak <= w.r for w in seq)):
sequences.append((seq, tag, energ))
#We get the sequence with the maximum value
verify(sequences)
seq, tag, energ = max(sequences, key= operator.itemgetter(2))
shape = QRSShape()
shape.energy = energ
shape.tag = tag
shape.waves = seq
shape.sig = signal[seq[0].l:seq[-1].r+1] - signal[seq[0].l]
shape.maxslope = np.max(np.abs(np.diff(shape.sig)))
shape.amplitude = np.ptp(shape.sig)
return shape
except (ValueError, InconsistencyError):
return None