enable byte offset and skew writing

Author: cx1111

tests/test_records.py

@@ -37,12 +37,12 @@ def test_2(self):
         del(record.comments[0])
 
         # Test file writing
-        #record.wrsamp()
-        #recordwrite = wfdb.rdsamp('100')
+        record.wrsamp()
+        recordwrite = wfdb.rdsamp('100')
 
         assert np.array_equal(sig, targetsig)
         assert record.__eq__(pbrecord)
-        #assert record.__eq__(recordwrite)
+        assert record.__eq__(recordwrite)
 
     # Test 3 - Format 16/Entire signal/Digital
     # Target file created with: rdsamp -r sampledata/test01_00s | cut -f 2- >
@@ -55,8 +55,15 @@ def test_3(self):
         # Compare data streaming from physiobank
         pbrecord = wfdb.rdsamp('test01_00s', physical=False, pbdir = 'macecgdb')
 
+        # Test file writing
+        record2 = wfdb.rdsamp('sampledata/test01_00s', physical=False)
+        record2.signame = ['ECG1', 'ECG2', 'ECG3', 'ECG4']
+        record2.wrsamp()
+        recordwrite = wfdb.rdsamp('test01_00s', physical=False)
+
         assert np.array_equal(sig, targetsig)
-        assert record.__eq__(record)
+        assert record.__eq__(pbrecord)
+        assert record2.__eq__(recordwrite)
 
     # Test 4 - Format 16 with byte offset/Selected Duration/Selected Channels/Physical
     # Target file created with: rdsamp -r sampledata/a103l -f 50 -t 160 -s 2 0
@@ -85,8 +92,14 @@ def test_5(self):
         # Compare data streaming from physiobank
         pbrecord = wfdb.rdsamp('a103l', pbdir = 'challenge/2015/training',
                              sampfrom=20000, channels=[0, 1], physical=False)
+
+        # Test file writing
+        record.wrsamp()
+        recordwrite = wfdb.rdsamp('a103l')
+
         assert np.array_equal(sig, targetsig)
         assert record.__eq__(pbrecord)
+        assert record.__eq__(recordwrite)
 
     # Test 6 - Format 80/Selected Duration/Selected Channels/Physical
     # Target file created with: rdsamp -r sampledata/3000003_0003 -f 1 -t 8 -s

wfdb/_signals.py

@@ -14,18 +14,15 @@ def wrdats(self):
 
         if not self.nsig:
             return
-
         # Get all the fields used to write the header
         # Assuming this method was called through wrsamp,
         # these will have already been checked in wrheader()
         writefields = self.getwritefields()
 
         # Check the validity of the d_signals field
         self.checkfield('d_signals')
-
         # Check the cohesion of the d_signals field against the other fields used to write the header
         self.checksignalcohesion(writefields)
-        
         # Write each of the specified dat files
         self.wrdatfiles()
 
@@ -232,15 +229,18 @@ def wrdatfiles(self):
         # the channels to be written to each file. 
         filenames, datchannels = orderedsetlist(self.filename)
 
-        # Get the fmt corresponding to each dat file
+        # Get the fmt and byte offset corresponding to each dat file
         datfmts={}
+        datoffsets={}
         for fn in filenames:
             datfmts[fn] = self.fmt[datchannels[fn][0]]
+            datoffsets[fn] = self.byteoffset[datchannels[fn][0]]
 
         # Write the dat files 
+        # Create a copy to prevent overwrite
+        dsig = self.d_signals.copy()
         for fn in filenames:
-            wrdatfile(fn, datfmts[fn], 
-                self.d_signals[:, datchannels[fn][0]:datchannels[fn][-1]+1])
+            wrdatfile(fn, datfmts[fn], dsig[:, datchannels[fn][0]:datchannels[fn][-1]+1], datoffsets[fn])
 
 
 
@@ -383,7 +383,6 @@ def processwfdbbytes(filename, dirname, pbdir, fmt, startbyte, readlen, nsig, sa
                 np.bitwise_and(sigbytes[1::3], 0x0f)  # Even numbered samples
             if len(sig > 1):
                 # Odd numbered samples
-                print(len(sig[1::2]))
                 sig[1::2] = sigbytes[2::3] + 256*np.bitwise_and(sigbytes[1::3] >> 4, 0x0f)
             if floorsamp:  # Remove extra sample read
                 sig = sig[floorsamp:]
@@ -831,17 +830,17 @@ def wfdbfmtres(fmt):
         sys.exit('Invalid WFDB format.')
 
 # Write a dat file.
-def wrdatfile(filename, fmt, d_signals):
-    f=open(filename,'wb')
-    
-    # All bytes are written one at a time
-    # to avoid endianness issues.
-
+# All bytes are written one at a time
+# to avoid endianness issues.
+def wrdatfile(filename, fmt, d_signals, byteoffset):
+    f=open(filename,'wb')  
     nsig = d_signals.shape[1]
 
     if fmt == '80':
         # convert to 8 bit offset binary form
         d_signals = d_signals + 128
+        # Concatenate into 1D
+        d_signals = d_signals.reshape(-1)
         # Convert to unsigned 8 bit dtype to write
         bwrite = d_signals.astype('uint8')
 
@@ -897,7 +896,6 @@ def wrdatfile(filename, fmt, d_signals):
         bwrite = bwrite.reshape((1,-1))[0]
         # Convert to unsigned 8 bit dtype to write
         bwrite = bwrite.astype('uint8')
-
     elif fmt == '24':
         # convert to 24 bit two's complement 
         d_signals[d_signals<0] = d_signals[d_signals<0] + 16777216
@@ -933,12 +931,17 @@ def wrdatfile(filename, fmt, d_signals):
         bwrite = bwrite.astype('uint8')
     else:
         sys.exit('This library currently only supports the following formats: 80, 16, 24, 32')
+        
+    # Byte offset in the file
+    if byteoffset is not None and byteoffset>0:
+        print('Writing file '+filename+' with '+str(byteoffset)+' empty leading bytes')
+        bwrite = np.append(np.zeros(byteoffset, dtype = 'uint8'), bwrite)
+
     # Write the file
     bwrite.tofile(f)
 
     f.close()
 
-
 # Returns the unique elements in a list in the order that they appear. 
 # Also returns the indices of the original list that correspond to each output element. 
 def orderedsetlist(fulllist):

wfdb/records.py

@@ -114,14 +114,15 @@ def checkfield(self, field, ch=None):
             f = self.skew[ch]
             if f < 0:
                 sys.exit('skew values must be non-negative integers')
-            if f > 0:
-                sys.exit('Sorry, I have not implemented skew into wrsamp yet')
+            # Writing a signal with skew shouldn't require anything different
+            #if f > 0:
+            #    sys.exit('Sorry, I have not implemented skew into wrsamp yet')
         elif field == 'byteoffset':
             f = self.byteoffset[ch]
             if f < 0:
                 sys.exit('byteoffset values must be non-negative integers')
-            if f > 0:
-                sys.exit('Sorry, I have not implemented skew into wrsamp yet')
+            #if f > 0:
+            #    sys.exit('Sorry, I have not implemented byte offset into wrsamp yet')
         elif field == 'adcgain':
             f = self.adcgain[ch]
             if f <= 0:
@@ -357,7 +358,6 @@ def wrsamp(self):
 
         # Perform field validity and cohesion checks, and write the header file.
         self.wrheader()
-
         if self.nsig>0:
             # Perform signal validity and cohesion checks, and write the associated dat files.
             self.wrdats()
@@ -368,8 +368,7 @@ def arrangefields(self, channels, usersiglen):
         # Rearrange signal specification fields
         for field in _headers.sigfieldspecs:
             item = getattr(self, field)
-            if item != self.nsig*[None]:
-                setattr(self, field, [item[c] for c in channels]) 
+            setattr(self, field, [item[c] for c in channels]) 
 
         # Checksum and initvalue to be updated if present
         # unless the whole signal length was input
@@ -716,7 +715,6 @@ def rdsamp(recordname, sampfrom=0, sampto=None, channels = None, physical = True
             record.p_signals = record.dac()
             # Clear memory
             record.d_signals = None
-
     # A multi segment record
 
     # We can make another rdsamp function (called rdsamp_segment) to call
@@ -822,7 +820,7 @@ def rdheader(recordname, pbdir = None):
     # Set the comments field
     record.comments = []
     for line in commentlines:
-        record.comments.append(line.strip('\s#'))
+        record.comments.append(line.strip(' \t#'))
 
     return record
 

wfdbdemo.ipynb

@@ -161,12 +161,161 @@
    "metadata": {
     "collapsed": false
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Writing file a103l.mat with 24 empty leading bytes\n"
+     ]
+    }
+   ],
    "source": [
     "import wfdb\n",
     "import numpy as np\n",
     "from IPython.display import display\n",
-    "record = wfdb.rdsamp('sampledata/100', physical = False)"
+    "record = wfdb.rdsamp('sampledata/a103l',\n",
+    "                             sampfrom=20000, channels=[0, 1], physical=False)\n",
+    "sig = record.d_signals\n",
+    "targetsig = np.genfromtxt('tests/targetoutputdata/target5')\n",
+    "\n",
+    "# Compare data streaming from physiobank\n",
+    "pbrecord = wfdb.rdsamp('a103l', pbdir = 'challenge/2015/training',\n",
+    "                     sampfrom=20000, channels=[0, 1], physical=False)\n",
+    "\n",
+    "# Test file writing\n",
+    "record.wrsamp()\n",
+    "recordwrite = wfdb.rdsamp('a103l', physical=False)\n",
+    "\n",
+    "assert np.array_equal(sig, targetsig)\n",
+    "assert record.__eq__(pbrecord)\n",
+    "assert record.__eq__(recordwrite)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "record.__eq__(recordwrite)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'adcgain': [7247.0, 10520.0],\n",
+       " 'adcres': [16, 16],\n",
+       " 'adczero': [0, 0],\n",
+       " 'basecounter': None,\n",
+       " 'basedate': None,\n",
+       " 'baseline': [0, 0],\n",
+       " 'basetime': None,\n",
+       " 'blocksize': [0, 0],\n",
+       " 'byteoffset': [24, 24],\n",
+       " 'checksum': [15084, 49781],\n",
+       " 'comments': ['Asystole', 'False alarm'],\n",
+       " 'counterfreq': None,\n",
+       " 'd_signals': array([[-970, 8716],\n",
+       "        [-960, 8628],\n",
+       "        [-742, 8634],\n",
+       "        ..., \n",
+       "        [-296, 7883],\n",
+       "        [-342, 7976],\n",
+       "        [-339, 8011]]),\n",
+       " 'filename': ['a103l.mat', 'a103l.mat'],\n",
+       " 'fmt': ['16', '16'],\n",
+       " 'fs': 250.0,\n",
+       " 'initvalue': [-970, 8716],\n",
+       " 'nsig': 2,\n",
+       " 'p_signals': None,\n",
+       " 'recordname': 'a103l',\n",
+       " 'sampsperframe': [None, None],\n",
+       " 'siglen': 62500,\n",
+       " 'signame': ['II', 'V'],\n",
+       " 'skew': [None, None],\n",
+       " 'units': ['mV', 'mV']}"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "record.__dict__"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'adcgain': [7247.0, 10520.0],\n",
+       " 'adcres': [16, 16],\n",
+       " 'adczero': [0, 0],\n",
+       " 'basecounter': None,\n",
+       " 'basedate': None,\n",
+       " 'baseline': [0, 0],\n",
+       " 'basetime': None,\n",
+       " 'blocksize': [0, 0],\n",
+       " 'byteoffset': [24, 24],\n",
+       " 'checksum': [15084, 49781],\n",
+       " 'comments': ['Asystole', 'False alarm'],\n",
+       " 'counterfreq': None,\n",
+       " 'd_signals': None,\n",
+       " 'filename': ['a103l.mat', 'a103l.mat'],\n",
+       " 'fmt': ['16', '16'],\n",
+       " 'fs': 250.0,\n",
+       " 'initvalue': [-970, 8716],\n",
+       " 'nsig': 2,\n",
+       " 'p_signals': array([[-0.13384849,  0.82851711],\n",
+       "        [-0.13246861,  0.82015209],\n",
+       "        [-0.10238719,  0.82072243],\n",
+       "        ..., \n",
+       "        [-0.04084449,  0.7493346 ],\n",
+       "        [-0.04719194,  0.7581749 ],\n",
+       "        [-0.04677798,  0.7615019 ]]),\n",
+       " 'recordname': 'a103l',\n",
+       " 'sampsperframe': [None, None],\n",
+       " 'siglen': 62500,\n",
+       " 'signame': ['II', 'V'],\n",
+       " 'skew': [None, None],\n",
+       " 'units': ['mV', 'mV']}"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "recordwrite.__dict__"
    ]
   },
   {