work on cqrs

cx1111 · cx1111 · commit 19154029bcbe · 2018-01-15T15:22:14.000-05:00
diff --git a/wfdb/processing/cqrs.py b/wfdb/processing/cqrs.py
@@ -9,26 +9,46 @@
 
 class Conf(object):
     """
-    Initial configuration object
+    Initial signal configuration object
     """
-    def __init__(self, hr=75, hr_max=200, hr_min=25, qrs_width=0.1):
+    def __init__(self, hr_init=75, hr_max=200, hr_min=25, qrs_width=0.1,
+                 qrs_thr_init=0.13, qrs_thr_min=0):
         """
         Parameters
         ----------
         hr : int or float, optional
-            Heart rate in beats per minute
-        qrs_width : int or float, optional
-            Expected qrs width in seconds
+            Heart rate in beats per minute. Wait... what is this for?
+            Setting initial hr and rr values.
         hr_max : int or float, optional
             Hard maximum heart rate between two beats, in beats per minute
         hr_min : int or float, optional
             Hard minimum heart rate between two beats, in beats per minute
+        qrs_width : int or float, optional
+            Expected qrs width in seconds
+        qrs_thr_init : int or float, optional
+            Initial qrs detection threshold. If learning=True and beats are
+            detected, this will be overwritten.
+        qrs_thr_min : int or float or string, optional
+            Hard minimum detection threshold of qrs wave. Leave as 0 for no
+            minimum.
+        
+        Should RT values be specified?
         """
+        if hr_min < 0:
+            raise ValueError("'hr_min' must be <= 0")
+
+        if not hr_min < hr_init < hr_max:
+            raise ValueError("'hr_min' < 'hr_init' < 'hr_max' must be True")
 
-        self.hr = hr
+        if qrs_thr_init < qrs_thr_min:
+            raise ValueError("qrs_thr_min must be <= qrs_thr_init")
+
+        self.hr_init = hr_init
         self.hr_max = hr_max
         self.hr_min = hr_min
         self.qrs_width = qrs_width
+        self.qrs_thr_init = qrs_thr_init
+        self.qrs_thr_min = qrs_thr_min
 
 
 class CQRS(object):
@@ -40,23 +60,48 @@ class CQRS(object):
     - Inverted qrs
 
     Record 117 is a good challenge. Big twave, weird qrs
+    
+
+    Process:
+    - Bandpass
+    - MWI
+    - Learning:
+      - Find prominent peaks (using qrs radius)
+      - Find N beats. Use ricker wavelet convoluted with filtered signal.
+      - Use beats to initialize qrs threshold. Other peak threshold is
+        set to half of that. Set min peak and qrs threshold? There is a problem
+        with setting this hard limit. gqrs has a hard
+        limit, but pantompkins doesn't. Solution: Give options
+          1. Specify limit. Can set to 0 if don't want.
+          2. Set limit from peaks detected while learning. Else 0.
+        During learning beat detection, confirm the set is roughly the same size.
+        Reject 'beats' detected that are too far off in amplitude.
     """
 
 
     def __init__(self, sig, fs, conf=Conf()):
         self.sig = sig
         self.fs = fs
-
         self.sig_len = len(sig)
 
-        # These values are in samples
-        self.rr = 60 * self.fs / conf.hr
-        self.rr_max = 60 * self.fs / conf.hr_min
-        self.rr_min = 60 * self.fs / conf.hr_max
 
-        self.qrs_width = conf.qrs_width * fs
 
+    def set_conf(self):
+        """
+        Set configuration parameters from the Conf object into the CQRS detector
+        object.
+
+        Time values are in samples, amplitude values are in mV.
+        """
+        self.rr = 60 * self.fs / self.conf.hr
+        self.rr_max = 60 * self.fs / self.conf.hr_min
+        self.rr_min = 60 * self.fs / self.conf.hr_max
+        self.qrs_width = self.conf.qrs_width * self.fs
 
+        self.qrs_thr_init = self.conf.qrs_thr_init
+        self.qrs_thr_min = self.conf.qrs_thr_min
+
+        
 
 
     def bandpass(self, fc_low=5, fc_high=20):
@@ -71,7 +116,6 @@ def bandpass(self, fc_low=5, fc_high=20):
         self.filter_gain = get_filter_gain(b, a, np.mean(fc_low, fc_high), fs)
 
 
-
     def mwi(self):
         """
         Apply moving wave integration with a ricker (Mexican hat) wavelet onto
@@ -85,10 +129,14 @@ def mwi(self):
         # Save the mwi gain
         self.mwi_gain = get_filter_gain(b, [1], np.mean(fc_low, fc_high), fs)
 
-    def learn_params(self, n_calib_beats=8):
+
+    def learn_init_params(self, n_calib_beats=8):
         """
-        Find a number of beats using cross correlation to determine qrs
-        detection thresholds.
+        Find a number of consecutive beats using cross correlation to determine
+        qrs detection thresholds.
+
+        If the system fails to find enough beats, the default parameters will be
+        used instead.
 
         Parameters
         ----------
@@ -105,38 +153,69 @@ def learn_params(self, n_calib_beats=8):
                                                   int(self.qrs_width / 2))
         #dominant_peaks = self.sig_i[self.dominant_peak_inds]
 
-        # Find n qrs peaks and store their amplitudes
+        # Go through the dominant peaks and find the qrs peaks
         qrs_peak_amps = []
 
-        peak_num = 0
-        while len(qrs_peak_amps) < n_calib_beats
-            i = dominant_peak_inds[peak_num]
-            peak_num += 1
+        for peak_num in range(len(self.dominant_peak_inds)):
+            i = self.dominant_peak_inds[peak_num]
+
 
+            if len(qrs_peak_amps) == n_calib_beats:
+                break
 
+        
+        if len(qrs_peak_amps) == n_calib_beats:
+            self.qrs_thr = max(np.mean(qrs_peak_amps) / 2, self.qrs_thr_min)
 
-        self.qrs_thresh = np.mean(qrs_peak_amps)
+        # Failed to find enough calibration beats. Use default values.
+        else:
+            self.set_init_params
+
+
+        
 
 
 
         return
+
+    def set_init_params(self):
+        self.qrs_thr = self.qrs_thr_init
+        self.recent_qrs_inds = 
+
+        self.recent_rr = 
         
         
 
-    def detect(self, sampfrom=0, sampto='end'):
+    def detect(self, sampfrom=0, sampto='end', learn=True):
         """
         Detect qrs locations between two samples
         """
+        if sampfrom < 0:
+            raise ValueError("'sampfrom' cannot be negative")
         if sampto == 'end':
             sampto = self.sig_len
+        elif sampto > self.sig_len:
+            raise ValueError("'sampto' cannot exceed the signal length")
 
+        # Detected qrs indices
         self.qrs_inds = []
+        # qrs indices found via backsearch
         self.backsearch_qrs_inds = []
 
+        # Get signal configuration fields from Conf object
+        self.set_conf()
+        # Bandpass filter the signal
         self.bandpass()
+        # Compute moving wave integration of filtered signal
         self.mwi()
 
-        self.learn_params()
+        # Learn parameters
+        if learn:
+            self.learn_initial_params()
+        else:
+            self.set_initial_params()
+
+
 
 
 
@@ -158,9 +237,13 @@ def detect(self, sampfrom=0, sampto='end'):
 
 def find_dominant_peaks(sig, radius):
     """
-    Find all dominant peaks in a signal.
-    A sample is a dominant peak if it is the largest value within the
-    <radius> samples on its left and right.
+    Find all dominant peaks in a signal. A sample is a dominant peak if it is
+    the largest value within the <radius> samples on its left and right.
+
+    In cases where it shares the max value with nearby samples, the earliest
+    sample is classified as the dominant peak.
+
+    TODO: Fix flat mountain scenarios.
     """
     peak_inds = []
 
@@ -205,7 +288,7 @@ def get_filter_gain(b, a, f_gain, fs):
 
 
 
-def cqrs_detect(sig, fs, conf=Conf()):
+def cqrs_detect(sig, fs, conf=Conf(), learn=True):
 
     cqrs = CQRS(sig, fs, conf)
 
