use correct dtype in multi_to_single

cx1111 · cx1111 · commit c13e27c1de40 · 2018-04-29T15:18:48.000-04:00
diff --git a/tests/test_record.py b/tests/test_record.py
@@ -473,50 +473,33 @@ def test_5e(self):
 
     def test_5f(self):
         """
-
-        Gotta write this
-
-
-        Multi-segment, variable layout, entire signal, digital
-
-        The reference signal creation cannot be made with rdsamp
-        directly because the wfdb c package (10.5.24) applies the single
-        adcgain and baseline values from the layout specification
-        header, which is undesired in multi-segment signals with
-        different adcgain/baseline values across segments.
+        Multi-segment, variable layout, selected duration, selected
+        channels, digital. There are two channels: PLETH, and II. Their
+        fmt, adc_gain, and baseline do not change between the segments.
 
         Target file created with:
-        ```
-        for i in {01..18}
-        do
-            rdsamp -r sample-data/multi-segment/s25047/3234460_00$i -P | cut -f 2- >> record-5e
-        done
-        ```
-
+            rdsamp -r sample-data/multi-segment/p000878/p000878-2137-10-26-16-57 -f s3550 -t s7500 -s 0 1 | cut -f 2- | perl -p -e 's/-32768/  -128/g;' > record-5f
 
         """
-        sig, fields = wfdb.rdsamp('p000878-2137-10-26-16-57',
+        record = wfdb.rdrecord('sample-data/multi-segment/p000878/p000878-2137-10-26-16-57',
+                                sampfrom=3550, sampto=7500, channels=[0,1],
+                                physical=False)
+        sig = record.d_signal
+
+        # Compare data streaming from physiobank
+        record_pb = wfdb.rdrecord('p000878-2137-10-26-16-57',
                                   pb_dir='mimic3wdb/matched/p00/p000878/',
-                                  sampto=5000)
+                                  sampfrom=3550, sampto=7500, channels=[0,1],
+                                  physical=False)
         sig_target = np.genfromtxt('tests/target-output/record-5f')
 
         np.testing.assert_equal(sig, sig_target)
+        assert record.__eq__(record_pb)
 
 
-    # Test 12 - Multi-segment variable layout/Selected duration/Selected Channels/Physical
-    # Target file created with: rdsamp -r sample-data/multi-segment/s00001/s00001-2896-10-10-00-31 -f s -t 4000 -s 3 0 -P | cut -f 2- > target12
-    #def test_12(self):
-    #    record=rdsamp('sample-data/multi-segment/s00001/s00001-2896-10-10-00-31', sampfrom=8750, sampto=500000)
-    #    sig_round = np.round(record.p_signal, decimals=8)
-    #    sig_target = np.genfromtxt('tests/target-output/target12')
-    #
-    #    assert np.array_equal(sig, sig_target)
-
-
-    # Cleanup written files
     @classmethod
-    def tearDownClass(self):
-
+    def tearDownClass(cls):
+        "Clean up written files"
         writefiles = ['03700181.dat','03700181.hea','100.atr','100.dat',
                       '100.hea','1003.atr','100_3chan.dat','100_3chan.hea',
                       '12726.anI','a103l.hea','a103l.mat','s0010_re.dat',
diff --git a/wfdb/io/_signal.py b/wfdb/io/_signal.py
@@ -743,7 +743,7 @@ def rd_segment(file_name, dirname, pb_dir, n_sig, fmt, sig_len, byte_offset,
     # Return uniform numpy array
     if smooth_frames or sum(samps_per_frame) == n_sig:
         # Figure out the largest required dtype for the segment to minimize memory usage
-        max_dtype = np_dtype(fmt_res(fmt, maxres=True), discrete=True)
+        max_dtype = np_dtype(fmt_res(fmt, max_res=True), discrete=True)
         # Allocate signal array. Minimize dtype
         signals = np.zeros([sampto-sampfrom, len(channels)], dtype=max_dtype)
 
@@ -1332,32 +1332,38 @@ def wfdbfmt(res, single_fmt=True):
         return '32'
 
 
-def fmt_res(fmt, maxres=False):
+def fmt_res(fmt, max_res=False):
     """
     Return the resolution of the WFDB format(s).
+
+    Parameters
+    ----------
+    fmt : str
+        The wfdb format. Can be a list of valid fmts. If it is a list,
+        and `max_res` is True, the list may contain None.
+    max_res : bool, optional
+        If given a list of fmts, whether to return the highest
+        resolution.
+
     """
     if isinstance(fmt, list):
-        res = [fmt_res(f) for f in fmt]
-        if maxres is True:
-            res = np.max(res)
+        if max_res:
+            # Allow None
+            res = np.max([fmt_res(f) for f in fmt if f is not None])
+        else:
+            res = [fmt_res(f) for f in fmt]
         return res
 
-    if fmt in ['8', '80']:
-        return 8
-    elif fmt in ['310', '311']:
-        return 10
-    elif fmt == '212':
-        return 12
-    elif fmt in ['16', '61']:
-        return 16
-    elif fmt == '24':
-        return 24
-    elif fmt == '32':
-        return 32
+    res = {'8':8, '80':8, '310':10, '311':10, '212':12, '16':16, '61':16,
+           '24':24, '32':32}
+
+    if fmt in res:
+        return res[fmt]
     else:
         raise ValueError('Invalid WFDB format.')
 
 
+
 def np_dtype(res, discrete):
     """
     Given the resolution of a signal, return the minimum
diff --git a/wfdb/io/record.py b/wfdb/io/record.py
@@ -2,7 +2,6 @@
 import multiprocessing
 import posixpath
 import re
-import warnings
 
 import numpy as np
 import os
@@ -662,15 +661,11 @@ def _arrange_fields(self, seg_numbers, seg_ranges, channels,
             # Update the layout specification segment. At this point it
             # should match the full original header
 
-            # Forcing the signal specifications to match the input
-            # `channels` variable.
-            if force_channels:
-
             # Have to inspect existing channels of segments; requested
             # input channels will not be enough on its own because not
             # all signals may be present, depending on which section of
             # the signal was read.
-            else:
+            if not force_channels:
                 # The desired signal names.
                 desired_sig_names = [self.segments[0].sig_name[ch] for ch in channels]
                 # Actual contained signal names of individual segments
@@ -686,15 +681,15 @@ def _arrange_fields(self, seg_numbers, seg_ranges, channels,
                 item = getattr(self.segments[0], field)
                 setattr(self.segments[0], field, [item[c] for c in channels])
 
-            self.segments[0].n_sig = self.n_sig = len(sig_name)
+            self.segments[0].n_sig = self.n_sig = len(channels)
+            if self.n_sig == 0:
+                print('No signals of the desired channels are contained in the specified sample range.')
 
         # Update record specification parameters
         self.sig_len = sum([sr[1]-sr[0] for sr in seg_ranges])
         self.n_seg = len(self.segments)
         self._adjust_datetime(sampfrom=sampfrom)
 
-        if self.n_sig == 0:
-            warnings.warn('No signals of the desired channels are contained in the specified sample range.')
 
     def multi_to_single(self, physical, return_res=64):
         """
@@ -708,8 +703,8 @@ def multi_to_single(self, physical, return_res=64):
         physical : bool
             Whether to convert the physical or digital signal.
         return_res : int, optional
-            The return resolution of the `p_signal` field. Options are 64, 32,
-            and 16.
+            The return resolution of the `p_signal` field. Options are:
+            64, 32, and 16.
 
         Returns
         -------
@@ -750,7 +745,7 @@ def multi_to_single(self, physical, return_res=64):
             # This will be the field dictionary to copy over.
             reference_fields = {'fmt':n_sig*[None], 'adc_gain':n_sig*[None],
                                 'baseline':n_sig*[None],
-                                'units':n_sig*[None], }
+                                'units':n_sig*[None]}
 
             # For physical signals, mismatched fields will not be copied
             # over. For digital, mismatches will cause an exception.
@@ -786,20 +781,16 @@ def multi_to_single(self, physical, return_res=64):
         if physical:
             sig_attr = 'p_signal'
             # Figure out the largest required dtype
-            dtype = _signal.np_dtype(_signal.fmt_res(fields['fmt'],
-                                                       maxres=True),
-                                    discrete=False)
-            nan_vals = self.n_sig * [np.nan]
+            dtype = _signal.np_dtype(return_res, discrete=False)
+            nan_vals = np.array([self.n_sig * [np.nan]], dtype=dtype)
         else:
             sig_attr = 'd_signal'
             # Figure out the largest required dtype
-            dtype = _signal.np_dtype(_signal.fmt_res(fields['fmt'],
-                                                       maxres=True),
-                                    discrete=True)
-            nan_vals = _signal.digi_nan(fields['fmt'])
+            dtype = _signal.np_dtype(return_res, discrete=True)
+            nan_vals = np.array([_signal.digi_nan(fields['fmt'])], dtype=dtype)
 
-        # Create and set the full signal array
-        combined_signal = np.zeros([self.sig_len, self.n_sig], dtype=dtype)
+        # Initialize the full signal array
+        combined_signal = np.repeat(nan_vals, self.sig_len, axis=0)
 
         # Start and end samples in the overall array to place the
         # segment samples into
@@ -815,24 +806,15 @@ def multi_to_single(self, physical, return_res=64):
             # Copy over the signals into the matching channels
             for i in range(1, self.n_seg):
                 seg = self.segments[i]
-
-                # Empty segment
-                if seg is None:
-                    combined_signal[start_samps[i]:end_samps[i], :] = nan_vals
-                # Non-empty segment
-                else:
+                if seg is not None:
                     # Get the segment channels to copy over for each
                     # overall channel
                     segment_channels = get_wanted_channels(fields['sig_name'],
                                                            seg.sig_name,
                                                            pad=True)
                     for ch in range(self.n_sig):
-                        # Fill with invalids if segment does not contain
-                        # signal
-                        if segment_channels[ch] is None:
-                            combined_signal[start_samps[i]:end_samps[i], ch] = nan_vals[ch]
                         # Copy over relevant signal
-                        else:
+                        if segment_channels[ch] is not None:
                             combined_signal[start_samps[i]:end_samps[i], ch] = getattr(seg, sig_attr)[:, segment_channels[ch]]
 
         # Create the single segment Record object and set attributes
@@ -841,10 +823,6 @@ def multi_to_single(self, physical, return_res=64):
             setattr(record, field, fields[field])
         setattr(record, sig_attr, combined_signal)
 
-        # Consider the case where no signals are present. ie. only empty.
-        # pdb.set_trace()
-        # print(sig_attr)
-        # print(getattr(record, sig_attr).dtype)
         # Use the signal to set record features
         if physical:
             record.set_p_features()
