edfize 0.1.0.beta8 → 0.1.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dea20df7bcf2794b479e5ad5265a88ccb7e9bcca
-  data.tar.gz: 08d7115da77547f4363d16c345932713ffd95eb8
+  metadata.gz: 2067540b9f8f67b1f56d3b14932dd5941aaa8c5e
+  data.tar.gz: 78bd7d36d221cd07a77a9ecefb9b6f67b68d0f1c
 SHA512:
-  metadata.gz: 22e2281613deed44e59b4ca6f7c489165583561b340420794ea79376def894bcf423a0d4f4ad1605182355cb707c418168a5897efa45a3101e2c55a388c6a390
-  data.tar.gz: 95394c3fc72cee59a507325539d96a2a3caef54d21a3140015e8b858f68778154c4659df787dc97f4b4284a069d492aaf6af80b9eb6a36c45ca7a8c0a08328e4
+  metadata.gz: bf85cdd7723bb127c1dcbfaa2cf5707b6916a65c9729ea51857d38107bb1042f1655cdf0b5584cc1a951601fe9f2b87a0deadeba56c2e654f28f033da8a70090
+  data.tar.gz: b120948717c189f774f6a6c58a6764d2d7d7df5a98aceca29cf3323acd70e509d97471b1519797ed507d142771d2e170d08716af8a62ed2635bba6773e7b1e94

data/CHANGELOG.md

@@ -1,21 +1,8 @@
 ## 0.1.0
 - Initial EDF class to load headers and signals into Ruby objects
 - `edfize` command has the following actions:
-  - `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
+  - `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
   - `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,35 +8,33 @@ Ruby gem used to load, validate, and parse European Data Format files. Used for
 
 ## Installation
 
-Use `gem install edfize` to update Edfize to the latest stable
+Add this line to your application's Gemfile:
 
-Use `gem install edfize --pre` to update Edfize to the latest prerelease
+    gem 'edfize'
 
-## Usage
+And then execute:
 
-### Validate EDFs
+    $ bundle
 
-Use `edfize test` to test that EDFs stored in the current directory have a valid format.
+Or install it yourself as:
 
-    cd <edf-directory>
-    edfize test
+    $ gem install edfize
 
-A list of validations performed is:
+## Usage
 
-- **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.
+### Validate EDFs
 
-Flags that can be added to the `test` command include:
+Use `edfize check` to check that EDFs stored in the current directory have a valid format.
 
-- `--failing`: Only display EDFs with failing tests
-- `--quiet`: Suppress detailed failure descriptions that show the expected versus the actual result of the test
+    cd <edf-directory>
+    edfize check
 
 ### Print Signal Header information
 
 Use `edfize run` to print out signal header information for each EDF in the current directory.
 
     cd <edf-directory>
-    edfize run
+    edfize check
 
 ### View A List of All Available Commands for Edfize
 
@@ -50,118 +48,11 @@ Use `edfize version` to check the version of Edfize.
 
     edfize version
 
-### 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, "..."]
-```
+### 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
 
 ## Contributing
 

data/edfize.gemspec

@@ -26,8 +26,6 @@ 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,226 +2,196 @@ require 'edfize/signal'
 
 module Edfize
   class Edf
-    # 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
+    attr_reader :signals
+
+    HEADER_OFFSET = 256
 
     def initialize(filename)
       @filename = filename
       @signals = []
-
-      read_header
-      read_signal_header
-      self
+      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)
     end
 
-    def load_signals
-      get_data_records
+    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
     end
 
-    def size_of_header
-      HEADER_OFFSET + ns * Signal::SIGNAL_CONFIG.collect{|k,h| h[:size]}.inject(:+)
+    def header_version
+      IO.binread(@filename, 8)
     end
 
-    def expected_size_of_header
-      @number_of_bytes_in_header
+    # 80 ascii : local patient identification (mind item 3 of the additional EDF+ specs)
+    def header_local_patient_identification
+      IO.binread(@filename, 80, 8)
     end
 
-    # Total File Size In Bytes
-    def edf_size
-      File.size(@filename)
+    # 80 ascii : local recording identification (mind item 4 of the additional EDF+ specs)
+    def header_local_recording_identification
+      IO.binread(@filename, 80, 88)
     end
 
-    # 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
+    # 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
 
-    def expected_edf_size
-      expected_data_size + size_of_header
+    # 8 ascii : starttime of recording (hh.mm.ss)
+    def header_start_time_of_recording
+      IO.binread(@filename, 8, 176)
     end
 
-    def section_value_to_string(section)
-      self.instance_variable_get("@#{section}").to_s
+    # 8 ascii : number of bytes in header record
+    def number_of_bytes_in_header
+      IO.binread(@filename, 8, 184)
     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
+    # 44 ascii : reserved
+    # def reserved
+    #   IO.binread(@filename, 44, 192)
+    # end
 
-    def section_description(section)
-      description = HEADER_CONFIG[section][:description].to_s
-      result = if description == ''
-        ''
-      else
-        " #{description}"
-      end
-      result
+    # 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)
     end
 
-    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}"
+    # 8 ascii : duration of a data record, in seconds
+    def duration_of_a_data_record
+      IO.binread(@filename, 8, 244)
     end
 
-    protected
-
-    def read_header
-      HEADER_CONFIG.keys.each do |section|
-        read_header_section(section)
-      end
+    # 4 ascii : number of signals (ns) in data record
+    def number_of_signals
+      IO.binread(@filename, 4, 252)
     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)
+    def ns
+      Integer(self.number_of_signals) rescue 0
     end
 
-    def compute_offset(section)
-      offset = 0
-      HEADER_CONFIG.each do |key, hash|
-        break if key == section
-        offset += hash[:size]
+    # 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
-      offset
     end
 
-    def ns
-      @number_of_signals
-    end
-
-    def create_signals
+    # 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
 
-    def read_signal_header
-      create_signals
-      Signal::SIGNAL_CONFIG.keys.each do |section|
-        read_signal_header_section(section)
+    # 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))
       end
     end
 
-    def compute_signal_offset(section)
-      offset = 0
-      Signal::SIGNAL_CONFIG.each do |key, hash|
-        break if key == section
-        offset += hash[:size]
+    # 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
-      offset
     end
 
-    def read_signal_header_section(section)
-      offset = HEADER_OFFSET + ns * compute_signal_offset(section)
+    # 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|
-        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)
+        @signals[signal_number] ||= Signal.new()
+        @signals[signal_number].physical_maximum = IO.binread(@filename, 8, offset+(signal_number*8))
       end
     end
 
-    def get_data_records
-      load_digital_signals()
-      calculate_physical_values!()
+    # 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
     end
 
-    # 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
+    # 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
+    end
 
-      (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
+    # 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))
       end
     end
 
-    def calculate_physical_values!
-      @signals.each{|signal| signal.calculate_physical_values!}
+    # 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))
+      end
     end
 
-    def data_size
-      IO.binread(@filename, nil, size_of_header).size
+    # 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
     end
   end
 end

data/lib/edfize/signal.rb

@@ -1,49 +1,19 @@
 module Edfize
   class Signal
-    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' }
-    }
+    attr_accessor :label, :transducer_type, :physical_dimension, :physical_minimum, :physical_maximum,
+                  :digital_minimum, :digital_maximum, :prefiltering, :samples_in_data_record, :reserved_area
 
     def initialize
-      @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
+      @label = ''
+      @physical_dimension = ''
+      @transducer_type = ''
+      @physical_minimum = ''
+      @physical_maximum = ''
+      @digital_minimum = ''
+      @digital_maximum = ''
+      @prefiltering = ''
+      @samples_in_data_record = ''
+      @reserved_area = ''
     end
 
   end

data/lib/edfize/version.rb

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

data/lib/edfize.rb

@@ -1,16 +1,13 @@
 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(argv[1..-1])
+      check
     when 'r'
       print_headers
     else
@@ -20,7 +17,7 @@ module Edfize
 
   def self.print_headers
     puts "----------------"
-    edfs_in_current_directory_and_subdirectories.each do |edf_file_name|
+    edfs_in_current_directory.each do |edf_file_name|
       edf = Edfize::Edf.new(edf_file_name)
       edf.print_header
       puts "----------------"
@@ -31,21 +28,9 @@ module Edfize
     puts "Edfize #{Edfize::VERSION::STRING}"
   end
 
-  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 )
+  def self.check
+    edf_count = edfs_in_current_directory.count
+    puts "Checking #{edf_count} EDF#{'s' unless edf_count == 1}"
   end
 
   def self.help
@@ -53,11 +38,9 @@ module Edfize
 Usage: edfize COMMAND [ARGS]
 
 The most common edfize commands are:
-  [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
+  [c]heck           Check EDFs in current directory for errors
+  [t]est            Same as [c]heck
+  [h]elp            Show edfize command-line documentation
   [v]ersion         Returns the version of Edfize
 
 Commands can be referenced by the first letter:
@@ -67,7 +50,7 @@ EOT
     puts help_message
   end
 
-  def self.edfs_in_current_directory_and_subdirectories
-    Dir.glob('**/*.edf')
+  def self.edfs_in_current_directory
+    Dir.glob('*.edf')
   end
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: edfize
 version: !ruby/object:Gem::Version
-  version: 0.1.0.beta8
+  version: 0.1.0.pre
 platform: ruby
 authors:
 - Remo Mueller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-07 00:00:00.000000000 Z
+date: 2014-04-30 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
@@ -70,12 +56,6 @@ 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:

data/lib/edfize/tests/check_length.rb

@@ -1,16 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

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

data/lib/edfize/tests/runner.rb

@@ -1,43 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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