edfize 0.1.0.beta2 → 0.1.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 44aeaf1024f15eadb70e994e4f768d7e23e55073
-  data.tar.gz: a92347e4a34b965c09ba1d751582d0cc0bf56ec4
+  metadata.gz: 66faa96463f7845c7d3216c16b6d71dfedaf5a47
+  data.tar.gz: 835ab39c4653438fbebeb739b3330e160606b3ff
 SHA512:
-  metadata.gz: b809d63028034dc994a9b8dfaeae8cecf37f1195f2a4bef625c3239537ed590dcf96ce0ad80a86b5119748e1db9a2e4c497cfbaf5bdca8f3703b6f007ef40a94
-  data.tar.gz: c6b392c72163d72bf23082699c4d4020bd1e86973f286a33a79eb9070a192d18a7ce86018be7322815a33f339eb8071e33f0bba26abd29297d573b504eca70e8
+  metadata.gz: 4bb06a14848520c8f1245731bee2ddabc66308628b5a7ffcee722afab44b52153fbbb27aa53bf7e8cd5b13781fc0d1d02aed7a3288688d9215d9c770aec98ea2
+  data.tar.gz: 0307a0be76a76bce43a328d1c5dd7049db317c09d896d3f3b7731ba62f32932df5c4cb87ea1d7e656f16c9d61fc446c08b44098e7c2845215c9fb324c7802882

data/README.md

@@ -8,17 +8,9 @@ Ruby gem used to load, validate, and parse European Data Format files. Used for
 
 ## Installation
 
-Add this line to your application's Gemfile:
-
-    gem 'edfize'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
+Use `gem install edfize` to update Edfize to the latest stable
 
-    $ gem install edfize
+Use `gem install edfize --pre` to update Edfize to the latest prerelease
 
 ## Usage
 
@@ -58,12 +50,6 @@ 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.

data/lib/edfize/edf.rb

@@ -2,38 +2,49 @@ require 'edfize/signal'
 
 module Edfize
   class Edf
+    # EDF File Path
     attr_reader   :filename
 
-    attr_reader   :reserved               # 44 bytes - ASCII
-    attr_reader   :number_of_data_records #  8 bytes - ASCII
+    # Header Information
+    attr_reader  :version
+    attr_reader  :local_patient_identification
+    attr_reader  :local_recording_identification
+    attr_reader  :start_date_of_recording
+    attr_reader  :start_time_of_recording
+    attr_reader  :number_of_bytes_in_header
+    attr_reader  :reserved
+    attr_reader  :number_of_data_records
+    attr_reader  :duration_of_a_data_record
+    attr_reader  :number_of_signals
 
     attr_accessor :signals
 
-    RESERVED_SIZE = 44
+    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(:+)
 
-
-
-    HEADER_OFFSET = 256
     SIZE_OF_SAMPLE_IN_BYTES = 2
 
+    # Used by tests
+    RESERVED_SIZE = HEADER_CONFIG[:reserved][:size]
+
     def initialize(filename)
       @filename = filename
       @signals = []
 
       read_header
-
-      # Other
-      get_number_of_data_records
-      signal_labels
-      transducer_types
-      physical_dimensions
-      physical_minimums
-      physical_maximums
-      digital_minimums
-      digital_maximums
-      prefilterings
-      samples_per_data_records
-      reserved_areas
+      read_signal_header
     end
 
     def load_signals
@@ -41,11 +52,11 @@ module Edfize
     end
 
     def size_of_header
-      HEADER_OFFSET + ns * (16 + 80 + 8 + 8 + 8 + 8 + 8 + 80 + 8 + 32)
+      HEADER_OFFSET + ns * Signal::SIGNAL_CONFIG.collect{|k,h| h[:size]}.inject(:+)
     end
 
     def expected_size_of_header
-      256 + (ns * 256)
+      @number_of_bytes_in_header
     end
 
     # Total File Size In Bytes
@@ -62,32 +73,41 @@ module Edfize
       expected_data_size + size_of_header
     end
 
+    def section_value_to_string(section)
+      self.instance_variable_get("@#{section}").to_s
+    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
+
+    def section_description(section)
+      description = HEADER_CONFIG[section][:description].to_s
+      result = if description == ''
+        ''
+      else
+        " #{description}"
+      end
+      result
+    end
+
     def print_header
       puts "\nEDF                            : #{@filename}"
       puts "Total File Size                : #{edf_size} bytes"
       puts "\nHeader Information"
-      puts "Version                        : #{header_version}"
-      puts "Local Patient Identification   : #{header_local_patient_identification}"
-      puts "Local Recording Identification : #{header_local_recording_identification}"
-      puts "Start Date of Recording        : #{header_start_date_of_recording} (dd.mm.yy)"
-      puts "Start Time of Recording        : #{header_start_time_of_recording} (hh.mm.ss)"
-      puts "Reserved                       : '#{@reserved}'"
-      puts "Number of Data Records         : #{number_of_data_records}"
-      puts "Duration of a Data Record      : #{duration_of_a_data_record.to_i} second#{'s' unless duration_of_a_data_record.to_i == 1}"
-      puts "Number of Signals (NS)         : #{number_of_signals}"
+      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}"
-        puts "  Label                        : #{signal.label}"
-        puts "  Physical Dimension           : #{signal.physical_dimension}"
-        puts "  Transducer Type              : #{signal.transducer_type}"
-        puts "  Physical Minimum             : #{signal.physical_minimum}"
-        puts "  Physical Maximum             : #{signal.physical_maximum}"
-        puts "  Digital Minimum              : #{signal.digital_minimum}"
-        puts "  Digital Maximum              : #{signal.digital_maximum}"
-        puts "  Prefiltering                 : #{signal.prefiltering}"
-        puts "  Samples Per Data Record      : #{signal.samples_per_data_record}"
-        puts "  Reserved Area                : '#{signal.reserved_area}'"
+        signal.print_header
       end
       puts "\nGeneral Information"
       puts "Size of Header (bytes)         : #{size_of_header}"
@@ -102,158 +122,65 @@ module Edfize
     protected
 
     def read_header
-      read_reserved
-    end
-
-    def header_version
-      IO.binread(@filename, 8)
-    end
-
-    # 80 ascii : local patient identification (mind item 3 of the additional EDF+ specs)
-    def header_local_patient_identification
-      IO.binread(@filename, 80, 8)
-    end
-
-    # 80 ascii : local recording identification (mind item 4 of the additional EDF+ specs)
-    def header_local_recording_identification
-      IO.binread(@filename, 80, 88)
-    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)
-    end
-
-    # 8 ascii : starttime of recording (hh.mm.ss)
-    def header_start_time_of_recording
-      IO.binread(@filename, 8, 176)
-    end
-
-    # 8 ascii : number of bytes in header record
-    def number_of_bytes_in_header
-      IO.binread(@filename, 8, 184)
-    end
-
-    # 44 ascii : reserved
-    def read_reserved
-      @reserved = IO.binread(@filename, RESERVED_SIZE, 192)
-    end
-
-    # 8 ascii : number of data records (-1 if unknown, obey item 10 of the additional EDF+ specs)
-    def get_number_of_data_records
-      @number_of_data_records = IO.binread(@filename, 8, RESERVED_SIZE + 192).to_i
-    end
-
-    # 8 ascii : duration of a data record, in seconds
-    def duration_of_a_data_record
-      IO.binread(@filename, 8, 244)
-    end
-
-    # 4 ascii : number of signals (ns) in data record
-    def number_of_signals
-      IO.binread(@filename, 4, 252)
-    end
-
-    def ns
-      Integer(self.number_of_signals) rescue 0
-    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))
-      end
-    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
-    end
-
-    # ns * 8 ascii : ns * physical dimension (e.g. uV or degreeC)
-    def physical_dimensions
-      offset = HEADER_OFFSET + ns * (16 + 80)
-      (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))
+      HEADER_CONFIG.keys.each do |section|
+        read_header_section(section)
       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))
-      end
+    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 * 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_offset(section)
+      offset = 0
+      HEADER_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)
-      (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))
-      end
+    def ns
+      @number_of_signals
     end
 
-    # ns * 8 ascii : ns * digital maximum (e.g. 2047)
-    def digital_maximums
-      offset = HEADER_OFFSET + ns * (16 + 80 + 8 + 8 + 8 + 8)
+    def create_signals
       (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
     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))
+    def read_signal_header
+      create_signals
+      Signal::SIGNAL_CONFIG.keys.each do |section|
+        read_signal_header_section(section)
       end
     end
 
-    # ns * 8 ascii : ns * nr of samples in each data record
-    def samples_per_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_per_data_record = IO.binread(@filename, 8, offset+(signal_number*8)).to_i
-        @signals[signal_number].samples = Array.new(@signals[signal_number].samples_per_data_record, 0)
+    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 * 32 ascii : ns * reserved
-    def reserved_areas
-      offset = HEADER_OFFSET + ns * (16 + 80 + 8 + 8 + 8 + 8 + 8 + 80 + 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].reserved_area = IO.binread(@filename, 32, offset+(signal_number*32))
+        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
 
-
-    #
     def get_data_records
       current_read_offset = size_of_header
-      (0..@number_of_data_records-1).to_a.each do |data_record_index|
+      (0..ns-1).to_a.each do |data_record_index|
         @signals.each do |signal|
           # 16-bit signed integer size = 2 Bytes = 2 ASCII characters
           read_size = signal.samples_per_data_record * SIZE_OF_SAMPLE_IN_BYTES

data/lib/edfize/signal.rb

@@ -5,5 +5,29 @@ module Edfize
                   :digital_minimum, :digital_maximum,
                   :prefiltering, :samples_per_data_record,
                   :reserved_area, :samples
+
+    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
+      @samples = []
+    end
+
+    def print_header
+      SIGNAL_CONFIG.each do |section, hash|
+        puts "  #{hash[:name]}#{' '*(29 - hash[:name].size)}: " + self.send(section).to_s
+      end
+    end
+
   end
 end

data/lib/edfize/tests/runner.rb

@@ -27,17 +27,6 @@ module Edfize
         results.each do |result|
           print_result(result)
         end
-
-        # test_expected_length(edf) ? nil : failure_count += 1
-        # test_count += 1
-
-        # test_reserved_area_blank(edf) ? nil : failure_count += 1
-        # test_count += 1
-
-        # test_reserved_signal_areas_blank(edf) ? nil : failure_count += 1
-        # test_count += 1
-
-        # [test_count, failure_count]
       end
 
       def print_result(result)

data/lib/edfize/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: edfize
 version: !ruby/object:Gem::Version
-  version: 0.1.0.beta2
+  version: 0.1.0.beta3
 platform: ruby
 authors:
 - Remo Mueller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-01 00:00:00.000000000 Z
+date: 2014-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize