edfize 0.1.0.pre → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2067540b9f8f67b1f56d3b14932dd5941aaa8c5e
-  data.tar.gz: 78bd7d36d221cd07a77a9ecefb9b6f67b68d0f1c
+  metadata.gz: f5f84db69e7bbe84842214eee8dd220ee6a89a72
+  data.tar.gz: 0f447049e2a23134804e007de36b70186295845a
 SHA512:
-  metadata.gz: bf85cdd7723bb127c1dcbfaa2cf5707b6916a65c9729ea51857d38107bb1042f1655cdf0b5584cc1a951601fe9f2b87a0deadeba56c2e654f28f033da8a70090
-  data.tar.gz: b120948717c189f774f6a6c58a6764d2d7d7df5a98aceca29cf3323acd70e509d97471b1519797ed507d142771d2e170d08716af8a62ed2635bba6773e7b1e94
+  metadata.gz: 1decca6f10873141a21d139ba6b76126e5b9750c4ee28f6225ad4c498a08aac977dfc977435f5a82d937829fef9bcb3d8fc1e97a80b4072771a7f34cf7dda77a
+  data.tar.gz: d0f21d699870bac05cb8c2694e26860ca35d31bf3999247ce4244351436f88866348c08cd489b3c2c162a54d4cf10d493fc97fdc4f071c22f09cd7ea102070e7

data/CHANGELOG.md

@@ -1,8 +1,21 @@
-## 0.1.0
+## 0.1.0 (May 28, 2014)
 - Initial EDF class to load headers and signals into Ruby objects
 - `edfize` command has the following actions:
-  - `check`: Validates EDFs in the current directory for errors
-  - `test`: Same as `check`
-  - `run`: Prints out the headers of all edfs in the current directory
+  - `test`: Validates EDFs in the current directory and subdirectories for errors
+    - To only show failing tests, add the flag `--failing`
+      - `edfize test --failing`
+    - To suppress descriptive test failures, add the flag `--quiet`
+      - `edfize test --quiet`
+    - Both flags can be used together
+      - `edfize test --failing --quiet`
+  - `run`: Prints out the headers of all edfs in the current directory and subdirectories
   - `help`: Displays information about `edfize` along with all available commands
   - `version`: Displays the current `edfize` version
+- `edfize test` checks for the following:
+  - Expected Length Check: The expected total size is computed from the (`number
+    of data records` * `total samples across all signals`) + `size of header` and
+    this is compared to the actual file size.
+  - Reserved Area Checks: The header and the individual header reserved areas are
+    checked to validate that they are blank. Non-blank areas are a sign that the
+    edf header is corrupt and that data from the signal data block have leaked into
+    the header itself.

data/README.md

@@ -8,33 +8,35 @@ Ruby gem used to load, validate, and parse European Data Format files. Used for
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Use `gem install edfize` to update Edfize to the latest stable
 
-    gem 'edfize'
+Use `gem install edfize --pre` to update Edfize to the latest prerelease
 
-And then execute:
+## Usage
 
-    $ bundle
+### Validate EDFs
 
-Or install it yourself as:
+Use `edfize test` to test that EDFs stored in the current directory have a valid format.
 
-    $ gem install edfize
+    cd <edf-directory>
+    edfize test
 
-## Usage
+A list of validations performed is:
 
-### Validate EDFs
+- **Expected Length Check**: Compares the calculated size of the file based on signal sizes defined in the header with the actual file size. A failure may indicate corruption in the header (if the expected is less than the actual file size), or a partial/truncated file (if the expected is more than the actual file size).
+- **Reserved Area Checks**: Check that reserved areas are blank. Non-blank reserved areas can indicate a sign of header or EDF file corruption.
 
-Use `edfize check` to check that EDFs stored in the current directory have a valid format.
+Flags that can be added to the `test` command include:
 
-    cd <edf-directory>
-    edfize check
+- `--failing`: Only display EDFs with failing tests
+- `--quiet`: Suppress detailed failure descriptions that show the expected versus the actual result of the test
 
 ### Print Signal Header information
 
 Use `edfize run` to print out signal header information for each EDF in the current directory.
 
     cd <edf-directory>
-    edfize check
+    edfize run
 
 ### View A List of All Available Commands for Edfize
 
@@ -48,11 +50,118 @@ Use `edfize version` to check the version of Edfize.
 
     edfize version
 
-### Upgrade Edfize
-
-Use `gem install edfize` to update Edfize to the latest stable
-
-Use `gem install edfize --pre` to update Edfize to the latest prerelease
+### Example of how to Load and Analyze EDFs in a Ruby Script
+
+The following Ruby file demonstrates how to make use of the Edfize gem to load EDF signals into arrays for analysis.
+
+`tutorial_01_load_edf_and_signals.rb`
+```ruby
+# Tutorial 01 - Load EDF and Signals
+#
+#   gem install edfize
+#
+#   ruby tutorial_01_load_edf_and_signals.rb
+#
+# The EDF exists at:
+#
+#    https://sleepdata.org/datasets/shhs/files/edfs/shhs1?f=shhs1-200001.edf
+#
+
+require 'rubygems'
+require 'edfize'
+
+# Loads the file and reads the EDF Header
+edf = Edfize::Edf.new('shhs1-200001.edf')
+
+# Loads the data section of the EDF into Signal objects
+edf.load_signals
+
+# Print out information on the signals
+puts "EDF #{edf.filename} contains the following #{edf.signals.count} signal#{'s' unless edf.signals.count == 1}:\n\n"
+
+edf.signals.each do |signal|
+  puts "Signal"
+  puts "  Label                    : #{signal.label}"
+  puts "  Samples Per Data Record  : #{signal.samples_per_data_record}"
+  puts "  First 10 Physical Values : #{(signal.physical_values[0..10] + ['...']).inspect}\n\n"
+end
+```
+
+When run, the code above will output the following:
+
+```console
+EDF shhs1-200001.edf contains the following 14 signals:
+
+Signal
+  Label                    : SaO2
+  Samples Per Data Record  : 1
+  First 10 Physical Values : [95.31242847333486, 95.31242847333486, 95.31242847333486, 95.31242847333486, 95.31242847333486, 95.31242847333486, 95.31242847333486, 95.31242847333486, 94.14053559166858, 94.14053559166858, 94.14053559166858, "..."]
+
+Signal
+  Label                    : H.R.
+  Samples Per Data Record  : 1
+  First 10 Physical Values : [77.34416723887999, 77.34416723887999, 77.34416723887999, 76.56595712214848, 76.56595712214848, 76.56595712214848, 75.00190737773708, 75.00190737773708, 75.00190737773708, 75.00190737773708, 75.00190737773708, "..."]
+
+Signal
+  Label                    : EEG(sec)
+  Samples Per Data Record  : 125
+  First 10 Physical Values : [-4.411764705882348, 5.392156862745111, 2.4509803921568647, 0.49019607843136725, -0.49019607843136725, -10.294117647058826, 3.4313725490196134, 12.25490196078431, -1.470588235294116, -2.4509803921568647, -8.333333333333329, "..."]
+
+Signal
+  Label                    : ECG
+  Samples Per Data Record  : 125
+  First 10 Physical Values : [0.03431372549019618, 0.03431372549019618, 0.03431372549019618, 0.03431372549019618, 0.044117647058823595, 0.044117647058823595, 0.044117647058823595, 0.044117647058823595, 0.044117647058823595, 0.03431372549019618, 0.03431372549019618, "..."]
+
+Signal
+  Label                    : EMG
+  Samples Per Data Record  : 125
+  First 10 Physical Values : [12.622549019607845, 3.7990196078431353, -3.5539215686274517, -2.5735294117647065, 8.455882352941174, 1.5931372549019613, 9.436274509803923, -8.700980392156861, -2.5735294117647065, 13.112745098039213, -12.867647058823529, "..."]
+
+Signal
+  Label                    : EOG(L)
+  Samples Per Data Record  : 50
+  First 10 Physical Values : [28.921568627450966, 17.15686274509804, 25.0, 19.117647058823536, -5.392156862745097, -9.313725490196077, -0.49019607843136725, -1.470588235294116, 1.470588235294116, -1.470588235294116, 0.49019607843136725, "..."]
+
+Signal
+  Label                    : EOG(R)
+  Samples Per Data Record  : 50
+  First 10 Physical Values : [12.25490196078431, 1.470588235294116, 10.294117647058812, 5.392156862745111, 17.15686274509804, 18.137254901960773, 25.980392156862735, 32.84313725490196, 25.0, 26.960784313725497, 22.058823529411768, "..."]
+
+Signal
+  Label                    : EEG
+  Samples Per Data Record  : 125
+  First 10 Physical Values : [-2.4509803921568647, 1.470588235294116, -9.313725490196077, -6.372549019607845, -0.49019607843136725, -10.294117647058826, -12.25490196078431, -12.25490196078431, -7.352941176470594, 1.470588235294116, 6.372549019607845, "..."]
+
+Signal
+  Label                    : THOR RES
+  Samples Per Data Record  : 10
+  First 10 Physical Values : [0.207843137254902, 0.207843137254902, 0.15294117647058825, 0.0980392156862745, 0.03529411764705881, -0.0117647058823529, -0.050980392156862786, -0.08235294117647052, -0.10588235294117654, -0.1215686274509804, -0.13725490196078427, "..."]
+
+Signal
+  Label                    : ABDO RES
+  Samples Per Data Record  : 10
+  First 10 Physical Values : [0.30980392156862746, 0.24705882352941178, 0.16078431372549018, 0.06666666666666665, -0.0039215686274509665, -0.08235294117647052, -0.1607843137254903, -0.2078431372549019, -0.2313725490196079, -0.2549019607843137, -0.2705882352941176, "..."]
+
+Signal
+  Label                    : POSITION
+  Samples Per Data Record  : 1
+  First 10 Physical Values : [2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, "..."]
+
+Signal
+  Label                    : LIGHT
+  Samples Per Data Record  : 1
+  First 10 Physical Values : [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, "..."]
+
+Signal
+  Label                    : NEW AIR
+  Samples Per Data Record  : 10
+  First 10 Physical Values : [6.372549019607845, 6.372549019607845, 5.392156862745111, 3.4313725490196134, 7.35294117647058, 6.372549019607845, 8.333333333333343, 9.313725490196077, 6.372549019607845, 6.372549019607845, 7.35294117647058, "..."]
+
+Signal
+  Label                    : OX stat
+  Samples Per Data Record  : 1
+  First 10 Physical Values : [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.0, "..."]
+```
 
 ## Contributing
 

data/edfize.gemspec

@@ -26,6 +26,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test)/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "colorize", "~> 0.7.2"
+
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
 end

data/lib/edfize/edf.rb

@@ -2,196 +2,226 @@ require 'edfize/signal'
 
 module Edfize
   class Edf
-    attr_reader :signals
-
-    HEADER_OFFSET = 256
+    # EDF File Path
+    attr_reader   :filename
+
+    # Header Information
+    attr_accessor :version
+    attr_accessor :local_patient_identification
+    attr_accessor :local_recording_identification
+    attr_accessor :start_date_of_recording
+    attr_accessor :start_time_of_recording
+    attr_accessor :number_of_bytes_in_header
+    attr_accessor :reserved
+    attr_accessor :number_of_data_records
+    attr_accessor :duration_of_a_data_record
+    attr_accessor :number_of_signals
+
+    attr_accessor :signals
+
+    HEADER_CONFIG = {
+      version:                        { size:  8, after_read: :to_i,  name: 'Version' },
+      local_patient_identification:   { size: 80, after_read: :strip, name: 'Local Patient Identification' },
+      local_recording_identification: { size: 80, after_read: :strip, name: 'Local Recording Identification' },
+      start_date_of_recording:        { size:  8,                     name: 'Start Date of Recording', description: '(dd.mm.yy)' },
+      start_time_of_recording:        { size:  8,                     name: 'Start Time of Recording', description: '(hh.mm.ss)'},
+      number_of_bytes_in_header:      { size:  8, after_read: :to_i,  name: 'Number of Bytes in Header' },
+      reserved:                       { size: 44,                     name: 'Reserved' },
+      number_of_data_records:         { size:  8, after_read: :to_i,  name: 'Number of Data Records' },
+      duration_of_a_data_record:      { size:  8, after_read: :to_i,  name: 'Duration of a Data Record', units: 'second' },
+      number_of_signals:              { size:  4, after_read: :to_i,  name: 'Number of Signals' }
+    }
+
+    HEADER_OFFSET = HEADER_CONFIG.collect{|k,h| h[:size]}.inject(:+)
+
+    SIZE_OF_SAMPLE_IN_BYTES = 2
+
+    # Used by tests
+    RESERVED_SIZE = HEADER_CONFIG[:reserved][:size]
+
+    def self.create(filename, &block)
+      edf = self.new(filename)
+      yield edf if block_given?
+      edf
+    end
 
     def initialize(filename)
       @filename = filename
       @signals = []
-      signal_labels
-      transducer_types
-      physical_dimensions
-      physical_minimums
-      physical_maximums
-      digital_minimums
-      digital_maximums
-      prefilterings
-      samples_in_data_records
-      reserved_areas
-    end
-
-    def size
-      File.size(@filename)
+
+      read_header
+      read_signal_header
+      self
     end
 
-    def print_header
-      puts @filename
-      puts "#{size} bytes (Total File Size)"
-      puts "'#{header_version}' (0)"
-      puts "'#{header_local_patient_identification}' (local patient identification)"
-      puts "'#{header_local_recording_identification}' (local recording indentification)"
-      puts "'#{header_start_date_of_recording}' (dd.mm.yy start date of recording)"
-      puts "'#{header_start_time_of_recording}' (hh.mm.ss start time of recording)"
-      # puts "--- RESERVED"
-      puts "'#{number_of_data_records}' seconds (number of data records, -1 if unknown)"
-      puts "'#{duration_of_a_data_record}' seconds (duration of a data record)"
-      puts "'#{number_of_signals}' number of signals (ns) in data record"
-      signals.each_with_index do |signal, index|
-        puts "'#{signal.label}' (signal[#{index+1}] label)"
-        puts "'#{signal.physical_dimension}' (signal[#{index+1}] physical_dimension)"
-        puts "'#{signal.transducer_type}' (signal[#{index+1}] transducer_type)"
-        puts "'#{signal.physical_minimum}' (signal[#{index+1}] physical_minimum)"
-        puts "'#{signal.physical_maximum}' (signal[#{index+1}] physical_maximum)"
-        puts "'#{signal.digital_minimum}' (signal[#{index+1}] digital_minimum)"
-        puts "'#{signal.digital_maximum}' (signal[#{index+1}] digital_maximum)"
-        puts "'#{signal.prefiltering}' (signal[#{index+1}] prefiltering)"
-        puts "'#{signal.samples_in_data_record}' (signal[#{index+1}] samples_in_data_record)"
-        puts "'#{signal.reserved_area}' (signal[#{index+1}] reserved_area)"
-      end
+    def load_signals
+      get_data_records
     end
 
-    def header_version
-      IO.binread(@filename, 8)
+    def size_of_header
+      HEADER_OFFSET + ns * Signal::SIGNAL_CONFIG.collect{|k,h| h[:size]}.inject(:+)
     end
 
-    # 80 ascii : local patient identification (mind item 3 of the additional EDF+ specs)
-    def header_local_patient_identification
-      IO.binread(@filename, 80, 8)
+    def expected_size_of_header
+      @number_of_bytes_in_header
     end
 
-    # 80 ascii : local recording identification (mind item 4 of the additional EDF+ specs)
-    def header_local_recording_identification
-      IO.binread(@filename, 80, 88)
+    # Total File Size In Bytes
+    def edf_size
+      File.size(@filename)
     end
 
-    # 8 ascii : startdate of recording (dd.mm.yy) (mind item 2 of the additional EDF+ specs)
-    def header_start_date_of_recording
-      IO.binread(@filename, 8, 168)
+    # Data Section Size In Bytes
+    def expected_data_size
+      @signals.collect(&:samples_per_data_record).inject(:+).to_i * @number_of_data_records * SIZE_OF_SAMPLE_IN_BYTES
     end
 
-    # 8 ascii : starttime of recording (hh.mm.ss)
-    def header_start_time_of_recording
-      IO.binread(@filename, 8, 176)
+    def expected_edf_size
+      expected_data_size + size_of_header
     end
 
-    # 8 ascii : number of bytes in header record
-    def number_of_bytes_in_header
-      IO.binread(@filename, 8, 184)
+    def section_value_to_string(section)
+      self.instance_variable_get("@#{section}").to_s
     end
 
-    # 44 ascii : reserved
-    # def reserved
-    #   IO.binread(@filename, 44, 192)
-    # end
+    def section_units(section)
+      units = HEADER_CONFIG[section][:units].to_s
+      result = if units == ''
+        ''
+      else
+        " #{units}" + (self.instance_variable_get("@#{section}") == 1 ? '' : 's')
+      end
+      result
+    end
 
-    # 8 ascii : number of data records (-1 if unknown, obey item 10 of the additional EDF+ specs)
-    def number_of_data_records
-      IO.binread(@filename, 8, 236)
+    def section_description(section)
+      description = HEADER_CONFIG[section][:description].to_s
+      result = if description == ''
+        ''
+      else
+        " #{description}"
+      end
+      result
     end
 
-    # 8 ascii : duration of a data record, in seconds
-    def duration_of_a_data_record
-      IO.binread(@filename, 8, 244)
+    def print_header
+      puts "\nEDF                            : #{@filename}"
+      puts "Total File Size                : #{edf_size} bytes"
+      puts "\nHeader Information"
+      HEADER_CONFIG.each do |section, hash|
+        puts "#{hash[:name]}#{' '*(31 - hash[:name].size)}: " + section_value_to_string(section) + section_units(section) + section_description(section)
+      end
+      puts "\nSignal Information"
+      signals.each_with_index do |signal, index|
+        puts "\n  Position                     : #{index + 1}"
+        signal.print_header
+      end
+      puts "\nGeneral Information"
+      puts "Size of Header (bytes)         : #{size_of_header}"
+      puts "Size of Data   (bytes)         : #{data_size}"
+      puts "Total Size     (bytes)         : #{edf_size}"
+
+      puts "Expected Size of Header (bytes): #{expected_size_of_header}"
+      puts "Expected Size of Data   (bytes): #{expected_data_size}"
+      puts "Expected Total Size     (bytes): #{expected_edf_size}"
     end
 
-    # 4 ascii : number of signals (ns) in data record
-    def number_of_signals
-      IO.binread(@filename, 4, 252)
+    protected
+
+    def read_header
+      HEADER_CONFIG.keys.each do |section|
+        read_header_section(section)
+      end
     end
 
-    def ns
-      Integer(self.number_of_signals) rescue 0
+    def read_header_section(section)
+      result = IO.binread(@filename, HEADER_CONFIG[section][:size], compute_offset(section) )
+      result = result.to_s.send(HEADER_CONFIG[section][:after_read]) unless HEADER_CONFIG[section][:after_read].to_s == ''
+      self.instance_variable_set("@#{section}", result)
     end
 
-    # ns * 16 ascii : ns * label (e.g. EEG Fpz-Cz or Body temp) (mind item 9 of the additional EDF+ specs)
-    def signal_labels
-      offset = HEADER_OFFSET
-      (0..ns-1).to_a.each do |signal_number|
-        @signals[signal_number] ||= Signal.new()
-        @signals[signal_number].label = IO.binread(@filename, 16, offset+(signal_number*16))
+    def compute_offset(section)
+      offset = 0
+      HEADER_CONFIG.each do |key, hash|
+        break if key == section
+        offset += hash[:size]
       end
+      offset
     end
 
-    # ns * 80 ascii : ns * transducer type (e.g. AgAgCl electrode)
-    def transducer_types
-      offset = HEADER_OFFSET + ns * 16
-      (0..ns-1).to_a.each do |signal_number|
-        @signals[signal_number] ||= Signal.new()
-        @signals[signal_number].transducer_type = IO.binread(@filename, 80, offset+(signal_number*80))
-      end
+    def ns
+      @number_of_signals
     end
 
-    # ns * 8 ascii : ns * physical dimension (e.g. uV or degreeC)
-    def physical_dimensions
-      offset = HEADER_OFFSET + ns * (16 + 80)
+    def create_signals
       (0..ns-1).to_a.each do |signal_number|
         @signals[signal_number] ||= Signal.new()
-        @signals[signal_number].physical_dimension = IO.binread(@filename, 8, offset+(signal_number*8))
       end
     end
 
-    # ns * 8 ascii : ns * physical minimum (e.g. -500 or 34)
-    def physical_minimums
-      offset = HEADER_OFFSET + ns * (16 + 80 + 8)
-      (0..ns-1).to_a.each do |signal_number|
-        @signals[signal_number] ||= Signal.new()
-        @signals[signal_number].physical_minimum = IO.binread(@filename, 8, offset+(signal_number*8))
+    def read_signal_header
+      create_signals
+      Signal::SIGNAL_CONFIG.keys.each do |section|
+        read_signal_header_section(section)
       end
     end
 
-    # ns * 8 ascii : ns * physical maximum (e.g. 500 or 40)
-    def physical_maximums
-      offset = HEADER_OFFSET + ns * (16 + 80 + 8 + 8)
-      (0..ns-1).to_a.each do |signal_number|
-        @signals[signal_number] ||= Signal.new()
-        @signals[signal_number].physical_maximum = IO.binread(@filename, 8, offset+(signal_number*8))
+    def compute_signal_offset(section)
+      offset = 0
+      Signal::SIGNAL_CONFIG.each do |key, hash|
+        break if key == section
+        offset += hash[:size]
       end
+      offset
     end
 
-    # ns * 8 ascii : ns * digital minimum (e.g. -2048)
-    def digital_minimums
-      offset = HEADER_OFFSET + ns * (16 + 80 + 8 + 8 + 8)
+    def read_signal_header_section(section)
+      offset = HEADER_OFFSET + ns * compute_signal_offset(section)
       (0..ns-1).to_a.each do |signal_number|
-        @signals[signal_number] ||= Signal.new()
-        @signals[signal_number].digital_minimum = IO.binread(@filename, 8, offset+(signal_number*8))
+        section_size = Signal::SIGNAL_CONFIG[section][:size]
+        result = IO.binread(@filename, section_size, offset+(signal_number*section_size))
+        result = result.to_s.send(Signal::SIGNAL_CONFIG[section][:after_read]) unless Signal::SIGNAL_CONFIG[section][:after_read].to_s == ''
+        @signals[signal_number].send("#{section}=", result)
       end
     end
 
-    # ns * 8 ascii : ns * digital maximum (e.g. 2047)
-    def digital_maximums
-      offset = HEADER_OFFSET + ns * (16 + 80 + 8 + 8 + 8 + 8)
-      (0..ns-1).to_a.each do |signal_number|
-        @signals[signal_number] ||= Signal.new()
-        @signals[signal_number].digital_maximum = IO.binread(@filename, 8, offset+(signal_number*8))
-      end
+    def get_data_records
+      load_digital_signals()
+      calculate_physical_values!()
     end
 
-    # ns * 80 ascii : ns * prefiltering (e.g. HP:0.1Hz LP:75Hz)
-    def prefilterings
-      offset = HEADER_OFFSET + ns * (16 + 80 + 8 + 8 + 8 + 8 + 8)
-      (0..ns-1).to_a.each do |signal_number|
-        @signals[signal_number] ||= Signal.new()
-        @signals[signal_number].prefiltering = IO.binread(@filename, 80, offset+(signal_number*80))
+    # 16-bit signed integer size = 2 Bytes = 2 ASCII characters
+    # 16-bit signed integer in "Little Endian" format (least significant byte first)
+    # unpack:  s<         16-bit signed, (little-endian) byte order
+    def load_digital_signals
+      @all_signal_data = IO.binread(@filename, nil, size_of_header).unpack('s<*')
+
+      all_samples_per_data_record = @signals.collect{|s| s.samples_per_data_record}
+      total_samples_per_data_record = all_samples_per_data_record.inject(:+).to_i
+
+      offset = 0
+      offsets = []
+      all_samples_per_data_record.each do |samples_per_data_record|
+        offsets << offset
+        offset += samples_per_data_record
       end
-    end
 
-    # ns * 8 ascii : ns * nr of samples in each data record
-    def samples_in_data_records
-      offset = HEADER_OFFSET + ns * (16 + 80 + 8 + 8 + 8 + 8 + 8 + 80)
-      (0..ns-1).to_a.each do |signal_number|
-        @signals[signal_number] ||= Signal.new()
-        @signals[signal_number].samples_in_data_record = IO.binread(@filename, 8, offset+(signal_number*8))
+      (0..@number_of_data_records-1).to_a.each do |data_record_index|
+        @signals.each_with_index do |signal, signal_index|
+          read_start = data_record_index * total_samples_per_data_record + offsets[signal_index]
+          (0..signal.samples_per_data_record - 1).to_a.each do |value_index|
+            signal.digital_values << @all_signal_data[read_start+value_index]
+          end
+        end
       end
     end
 
-    # ns * 32 ascii : ns * reserved
-    def reserved_areas
-      offset = HEADER_OFFSET + ns * (16 + 80 + 8 + 8 + 8 + 8 + 8 + 80 + 8)
-      (0..ns-1).to_a.each do |signal_number|
-        @signals[signal_number] ||= Signal.new()
-        @signals[signal_number].reserved_area = IO.binread(@filename, 32, offset+(signal_number*32))
-      end
+    def calculate_physical_values!
+      @signals.each{|signal| signal.calculate_physical_values!}
+    end
+
+    def data_size
+      IO.binread(@filename, nil, size_of_header).size
     end
   end
 end

data/lib/edfize/signal.rb

@@ -1,19 +1,49 @@
 module Edfize
   class Signal
-    attr_accessor :label, :transducer_type, :physical_dimension, :physical_minimum, :physical_maximum,
-                  :digital_minimum, :digital_maximum, :prefiltering, :samples_in_data_record, :reserved_area
+    attr_accessor :label, :transducer_type, :physical_dimension,
+                  :physical_minimum, :physical_maximum,
+                  :digital_minimum, :digital_maximum,
+                  :prefiltering, :samples_per_data_record,
+                  :reserved_area, :digital_values, :physical_values
+
+    SIGNAL_CONFIG = {
+      label:                   { size: 16, after_read: :strip, name: 'Label' },
+      transducer_type:         { size: 80, after_read: :strip, name: 'Transducer Type' },
+      physical_dimension:      { size:  8, after_read: :strip, name: 'Physical Dimension' },
+      physical_minimum:        { size:  8, after_read: :to_f,  name: 'Physical Minimum' },
+      physical_maximum:        { size:  8, after_read: :to_f,  name: 'Physical Maximum' },
+      digital_minimum:         { size:  8, after_read: :to_i,  name: 'Digital Minimum' },
+      digital_maximum:         { size:  8, after_read: :to_i,  name: 'Digital Maximum' },
+      prefiltering:            { size: 80, after_read: :strip, name: 'Prefiltering' },
+      samples_per_data_record: { size:  8, after_read: :to_i,  name: 'Samples Per Data Record' },
+      reserved_area:           { size: 32,                     name: 'Reserved Area' }
+    }
 
     def initialize
-      @label = ''
-      @physical_dimension = ''
-      @transducer_type = ''
-      @physical_minimum = ''
-      @physical_maximum = ''
-      @digital_minimum = ''
-      @digital_maximum = ''
-      @prefiltering = ''
-      @samples_in_data_record = ''
-      @reserved_area = ''
+      @digital_values = []
+      @physical_values = []
+      self
+    end
+
+    def self.create(&block)
+      signal = self.new
+      yield signal if block_given?
+      signal
+    end
+
+    def print_header
+      SIGNAL_CONFIG.each do |section, hash|
+        puts "  #{hash[:name]}#{' '*(29 - hash[:name].size)}: " + self.send(section).to_s
+      end
+    end
+
+    # Physical value (dimension PhysiDim) = (ASCIIvalue-DigiMin)*(PhysiMax-PhysiMin)/(DigiMax-DigiMin) + PhysiMin.
+    def calculate_physical_values!
+      @physical_values = @digital_values.collect{|sample| ( sample - @digital_minimum ) * ( @physical_maximum - @physical_minimum ) / ( @digital_maximum - @digital_minimum) + @physical_minimum }
+    end
+
+    def samples
+      @physical_values
     end
 
   end

data/lib/edfize/tests/check_length.rb

@@ -0,0 +1,16 @@
+module Edfize
+  module Tests
+    module CheckLength
+      # This test checks that the length calculated from the EDF header matches
+      # the total length of the file
+      def test_expected_length(runner)
+        result = Result.new
+        result.passes = (runner.edf.expected_edf_size == runner.edf.edf_size)
+        result.pass_fail = "  #{result.passes ? 'PASS' : 'FAIL'}".colorize( result.passes ? :green : :red ) + " Expected File Size"
+        result.expected  = "    Expected : #{runner.edf.expected_edf_size} bytes"
+        result.actual    = "    Actual   : #{runner.edf.edf_size} bytes"
+        result
+      end
+    end
+  end
+end

data/lib/edfize/tests/check_reserved_area.rb

@@ -0,0 +1,15 @@
+module Edfize
+  module Tests
+    module CheckReservedArea
+      # This test checks that the reserved area in the header is blank
+      def test_reserved_area_blank(runner)
+        result           = Result.new
+        result.passes    = (runner.edf.reserved == ' ' * Edf::RESERVED_SIZE)
+        result.pass_fail = "  #{result.passes ? 'PASS' : 'FAIL'}".colorize( result.passes ? :green : :red ) + " Reserved Area Blank"
+        result.expected  = "    Expected : #{(' ' * Edf::RESERVED_SIZE).inspect}"
+        result.actual    = "    Actual   : #{runner.edf.reserved.to_s.inspect}"
+        result
+      end
+    end
+  end
+end

data/lib/edfize/tests/check_reserved_signal_areas.rb

@@ -0,0 +1,17 @@
+module Edfize
+  module Tests
+    module CheckReservedSignalAreas
+      # This test checks that the reserved areas in the signal headers are blank
+      def test_reserved_signal_areas_blank(runner)
+        reserved_areas = runner.edf.signals.collect(&:reserved_area)
+
+        result = Result.new
+        result.passes = (reserved_areas.reject{|r| r.to_s.strip == ''}.count == 0)
+        result.pass_fail = "  #{result.passes ? 'PASS' : 'FAIL'}".colorize( result.passes ? :green : :red ) + " Signal Reserved Area Blank"
+        result.expected  = "    Expected : #{[''] * runner.edf.signals.count}"
+        result.actual    = "    Actual   : #{reserved_areas}"
+        result
+      end
+    end
+  end
+end

data/lib/edfize/tests/result.rb

@@ -0,0 +1,7 @@
+module Edfize
+  module Tests
+    class Result
+      attr_accessor :passes, :pass_fail, :expected, :actual
+    end
+  end
+end

data/lib/edfize/tests/runner.rb

@@ -0,0 +1,43 @@
+module Edfize
+  module Tests
+    class Runner
+      attr_reader :tests_run, :tests_failed, :edf, :verbose, :show_passing
+
+      TESTS = %w( expected_length reserved_area_blank reserved_signal_areas_blank )
+
+      def initialize(edf, argv)
+        @tests_run = 0
+        @tests_failed = 0
+        @edf = edf
+        @verbose = argv.include?('--quiet') ? false : true
+        @show_passing = argv.include?('--failing') ? false : true
+      end
+
+      def run_tests
+        results = []
+
+        TESTS.each do |test_name|
+          result = Edfize::Tests.send("test_#{test_name}", self)
+          @tests_failed += 1 unless result.passes
+          @tests_run += 1
+          results << result
+        end
+
+        puts "\n#{@edf.filename}" if results.reject{|r| r.passes}.count > 0 or @show_passing
+        results.each do |result|
+          print_result(result)
+        end
+      end
+
+      def print_result(result)
+        if self.show_passing or !result.passes
+          puts result.pass_fail
+          unless result.passes or not self.verbose
+            puts result.expected
+            puts result.actual
+          end
+        end
+      end
+    end
+  end
+end

data/lib/edfize/tests.rb

@@ -0,0 +1,13 @@
+require 'edfize/tests/result'
+require 'edfize/tests/runner'
+require 'edfize/tests/check_length'
+require 'edfize/tests/check_reserved_area'
+require 'edfize/tests/check_reserved_signal_areas'
+
+module Edfize
+  module Tests
+    extend CheckLength
+    extend CheckReservedArea
+    extend CheckReservedSignalAreas
+  end
+end

data/lib/edfize/version.rb

@@ -3,7 +3,7 @@ module Edfize
     MAJOR = 0
     MINOR = 1
     TINY = 0
-    BUILD = "pre"
+    BUILD = nil
 
     STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
   end

data/lib/edfize.rb

@@ -1,13 +1,16 @@
 require 'edfize/edf'
+require 'edfize/tests'
 require 'edfize/version'
 
+require 'colorize'
+
 module Edfize
   def self.launch(argv)
     case argv.first.to_s.scan(/\w/).first
     when 'v'
       version
     when 'c', 't'
-      check
+      check(argv[1..-1])
     when 'r'
       print_headers
     else
@@ -17,7 +20,7 @@ module Edfize
 
   def self.print_headers
     puts "----------------"
-    edfs_in_current_directory.each do |edf_file_name|
+    edfs_in_current_directory_and_subdirectories.each do |edf_file_name|
       edf = Edfize::Edf.new(edf_file_name)
       edf.print_header
       puts "----------------"
@@ -28,9 +31,21 @@ module Edfize
     puts "Edfize #{Edfize::VERSION::STRING}"
   end
 
-  def self.check
-    edf_count = edfs_in_current_directory.count
-    puts "Checking #{edf_count} EDF#{'s' unless edf_count == 1}"
+  def self.check(argv)
+    test_start_time = Time.now
+    edf_count = edfs_in_current_directory_and_subdirectories.count
+    test_count = 0
+    failure_count = 0
+    puts "Started\n"
+    edfs_in_current_directory_and_subdirectories.each do |edf_file_name|
+      edf = Edfize::Edf.new(edf_file_name)
+      runner = Edfize::Tests::Runner.new(edf, argv)
+      runner.run_tests
+      test_count += runner.tests_run
+      failure_count += runner.tests_failed
+    end
+    puts "\nFinished in #{Time.now - test_start_time}s"
+    puts "#{edf_count} EDF#{'s' unless edf_count == 1}, #{test_count} test#{'s' unless test_count == 1}, " + "#{failure_count} failure#{'s' unless failure_count == 1}".colorize( failure_count == 0 ? :green : :red )
   end
 
   def self.help
@@ -38,9 +53,11 @@ module Edfize
 Usage: edfize COMMAND [ARGS]
 
 The most common edfize commands are:
-  [c]heck           Check EDFs in current directory for errors
-  [t]est            Same as [c]heck
-  [h]elp            Show edfize command-line documentation
+  [t]est            Check EDFs in directory and subdirectories
+    --failing       Only display failing tests
+    --quiet         Suppress failing test descriptions
+  [r]un             Print EDF header information
+  [h]elp            Show edfize command documentation
   [v]ersion         Returns the version of Edfize
 
 Commands can be referenced by the first letter:
@@ -50,7 +67,7 @@ EOT
     puts help_message
   end
 
-  def self.edfs_in_current_directory
-    Dir.glob('*.edf')
+  def self.edfs_in_current_directory_and_subdirectories
+    Dir.glob('**/*.edf')
   end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: edfize
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre
+  version: 0.1.0
 platform: ruby
 authors:
 - Remo Mueller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-30 00:00:00.000000000 Z
+date: 2014-05-28 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -56,6 +70,12 @@ files:
 - lib/edfize.rb
 - lib/edfize/edf.rb
 - lib/edfize/signal.rb
+- lib/edfize/tests.rb
+- lib/edfize/tests/check_length.rb
+- lib/edfize/tests/check_reserved_area.rb
+- lib/edfize/tests/check_reserved_signal_areas.rb
+- lib/edfize/tests/result.rb
+- lib/edfize/tests/runner.rb
 - lib/edfize/version.rb
 homepage: https://github.com/sleepepi/edfize
 licenses:
@@ -72,9 +92,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2