spcore 0.2.0 → 0.2.1

data/lib/spcore/version.rb

@@ -1,5 +1,5 @@
 # A library of signal processing methods and classes.
 module SPCore
   # spcore version
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/spcore.gemspec

@@ -27,4 +27,6 @@ DESCRIPTION
   gem.add_development_dependency 'rspec', '~> 2.4'
   gem.add_development_dependency 'yard', '~> 0.8'
   gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'pry-nav'
+  gem.add_development_dependency 'wavefile'
 end

data/spec/analysis/calculus_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe SPCore::Calculus do
+  before :all do
+    sample_rate = 200
+    @sample_period = 1.0 / sample_rate
+    sample_count = sample_rate
+    
+    range = -Math::PI..Math::PI
+    delta = (range.max - range.min) / sample_count
+    
+    @sin = []
+    @cos = []
+    
+    range.step(delta) do |x|
+      @sin << Math::sin(x)
+      @cos << (Math::PI * 2 * Math::cos(x))
+    end
+  end
+  
+  describe '.derivative' do
+    before :all do
+      @expected = @cos
+      @actual = Calculus.derivative @sin, @sample_period
+    end
+    
+    it 'should produce a signal of same size' do
+      @actual.size.should eq @expected.size
+    end
+    
+    it 'should produce a signal matching the 1st derivative' do
+      @actual.each_index do |i|
+        @actual[i].should be_within(0.1).of(@expected[i])
+      end
+    end
+  end
+
+  describe '.integral' do
+    before :all do
+      @expected = @sin
+      @actual = Calculus.integral @cos, @sample_period
+    end
+    
+    it 'should produce a signal of same size' do
+      @actual.size.should eq @expected.size
+    end
+    
+    it 'should produce a signal matching the 1st derivative' do
+      @actual.each_index do |i|
+        @actual[i].should be_within(0.1).of(@expected[i])
+      end
+    end
+  end
+end

data/spec/analysis/features_spec.rb

@@ -0,0 +1,106 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe SPCore::Features do
+  context '.minima' do
+    it 'should return points where local and global minima occur' do
+      cases = {
+        [3.8, 3.0, 2.9, 2.95, 3.6, 3.4, 2.8, 2.3, 2.1, 2.0, 2.5] => { 2 => 2.9, 9 => 2.0 },
+        [3.2, 3.5, 2.9, 2.7, 2.8, 2.7, 2.5, 2.2, 2.4, 2.3, 2.0] => { 3 => 2.7, 7 => 2.2, 10 => 2.0 },
+      }
+        
+      cases.each do |samples, minima|
+        Features.minima(samples).should eq minima
+      end
+    end
+  end
+  
+  context '.maxima' do
+    it 'should return points where local and global maxima occur' do
+      cases = {
+        [3.8, 3.0, 2.9, 2.95, 3.6, 3.4, 2.8, 2.3, 2.1, 2.0, 2.5] => { 0 => 3.8, 4 => 3.6 },
+        [3.2, 3.5, 2.9, 2.7, 2.8, 2.7, 2.5, 2.2, 2.4, 2.3, 2.0] => { 1 => 3.5, 4 => 2.8, 8 => 2.4},
+      }
+        
+      cases.each do |samples, maxima|
+        Features.maxima(samples).should eq maxima
+      end
+    end
+  end
+  
+  context '.extrema' do
+    it 'should return points where local and global extrema occur' do
+      cases = {
+        [3.8, 3.0, 2.9, 2.95, 3.6, 3.4, 2.8, 2.3, 2.1, 2.0, 2.5] => { 0 => 3.8, 2 => 2.9, 4 => 3.6, 9 => 2.0},
+        [3.2, 3.5, 2.9, 2.7, 2.8, 2.7, 2.5, 2.2, 2.4, 2.3, 2.0] => { 1 => 3.5, 3 => 2.7, 4 => 2.8, 7 => 2.2, 8 => 2.4, 10 => 2.0},
+      }
+        
+      cases.each do |samples, extrema|
+        Features.extrema(samples).should eq extrema
+      end
+    end
+  end
+  
+  describe '.top_n' do
+    it 'should return the n greatest of the given values' do
+      cases = {
+        [[1,2,3,4,5,6],2] => [5,6],
+        [[13,2,32,42,75,6],4] => [13,32,42,75],
+        [[-11,21,-4],1] => [21],
+        [[-11,21,-4, -14],2] => [-4,21],
+      }
+      
+      cases.each do |inputs, expected_output|
+        Features.top_n(inputs[0], inputs[1]).should eq expected_output
+      end
+    end
+  end
+  
+  describe '.envelope' do
+    before :all do
+      sample_rate = 1000
+      sample_count = 512 * 2
+      generator = SignalGenerator.new(:size => sample_count, :sample_rate => sample_rate)
+      
+      @modulation_signal = generator.make_signal [4.0], :amplitude => 0.1
+      @modulation_signal.multiply! BlackmanWindow.new(sample_count).data
+  
+      @base_signal = generator.make_signal [64.0]
+      @base_signal.multiply! @modulation_signal
+    end
+  
+    it 'should produce an output that follows the amplitude of the input' do
+      envelope = @base_signal.envelope
+      check_envelope(envelope)
+    end
+    
+    def check_envelope envelope
+      #signals = {
+      #  "signal" => @base_signal,
+      #  "modulation (abs)" => @modulation_signal.abs,
+      #  "envelope" => envelope,
+      #}
+      #
+      #Plotter.new(
+      #  :title => "signal and envelope",
+      #  :xlabel => "sample",
+      #  :ylabel => "values",
+      #).plot_signals(signals)
+      
+      #Plotter.new().plot_2d("envelop freq magnitudes" => envelope.freq_magnitudes)
+      
+      begin
+        ideal = @modulation_signal.energy
+        actual = envelope.energy
+        error = (ideal - actual).abs / ideal
+        error.should be_within(0.1).of(0.0)
+      end
+      
+      begin
+        ideal = @modulation_signal.rms
+        actual = envelope.rms
+        error = (ideal - actual).abs / ideal
+        error.should be_within(0.1).of(0.0)
+      end
+    end
+  end
+end

data/spec/analysis/frequency_domain_spec.rb

@@ -0,0 +1,147 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'wavefile'
+
+describe SPCore::FrequencyDomain do
+  before :all do
+    @freq_tolerance = 0.1
+  end
+  
+  def check_tolerance ideal, actual, tolerance_percent
+    margin = ideal * tolerance_percent
+    actual.should be_between(ideal - margin, ideal + margin)
+  end
+  
+  def verify_harmonic_series series, tolerance_percent
+    fund = series.first
+    for i in 1...series.count
+      freq = series[i]
+      ratio = freq / fund
+      target = ratio * fund
+      
+      check_tolerance target, freq, tolerance_percent
+    end
+  end
+  
+  describe '.peaks' do
+    it 'should find the peak frequency components' do
+      cases = [
+        [20.0, 80.0, 125.0],
+      ]
+      
+      cases.each do |ideal_peaks|
+        generator = SignalGenerator.new(:sample_rate => 1000, :size => 256)
+        signal = generator.make_signal(ideal_peaks)
+        actual_peaks = signal.freq_peaks
+        
+        ideal_peaks.each do |ideal_freq|
+          found = false
+          actual_peaks.keys.each do |actual_freq|
+            percent_error = (ideal_freq - actual_freq).abs / ideal_freq
+            if percent_error < @freq_tolerance
+              found = true
+              break
+            end
+          end
+          found.should be_true
+        end
+      end
+    end
+  end
+
+  describe '.harmonic_series' do
+    context 'harmonic series present' do
+      it 'should find the fundamental component when a harmonic series is present along with other non-series components' do
+        cases = {
+          [30.0, 50.0, 100.0, 125.0, 150.0, 200.0, 275.0] => 50.0,
+          [15.0, 20.0, 40.0, 50.0, 60.0, 80.0] => 20.0,
+          [25.0, 50.0, 85.0] => 25.0,
+        }
+        
+        cases.each do |freqs, fundamental|
+          generator = SignalGenerator.new(:sample_rate => 600, :size => 1024)
+          signal = generator.make_signal(freqs)
+          
+          series = signal.harmonic_series(:min_freq => 12.0)
+          check_tolerance fundamental, series.first, @freq_tolerance
+          verify_harmonic_series series, @freq_tolerance
+        end
+      end
+  
+      it 'should find all the components when only a single harmonic series is present' do
+        cases = {
+          [30.0, 60.0, 90.0, 120.0] => 30.0,
+          [25.0, 50.0] => 25.0,          
+          [50.0, 100.0, 150.0, 200.0] => 50.0,
+        }
+        
+        cases.each do |ideal_freqs, fundamental|
+          generator = SignalGenerator.new(:sample_rate => 1000, :size => 512)
+          signal = generator.make_signal(ideal_freqs)
+          
+          series = signal.harmonic_series(:min_freq => 16.0)
+          check_tolerance fundamental, series.first, @freq_tolerance
+          verify_harmonic_series series, @freq_tolerance
+        end
+      end
+      
+      it 'should find the fundamental component of the strongest harmonic series present when multiple series are present' do
+        cases = {
+          [33.0, 66.0, 99.0, 132.0, 150.0, 300.0, 450.0] => 33.0,
+        }
+        
+        cases.each do |freqs, fundamental|
+          generator = SignalGenerator.new(:sample_rate => 1000, :size => 1024)
+          signal = generator.make_signal(freqs)
+          
+          series = signal.harmonic_series(:min_freq => 16.0)
+          check_tolerance fundamental, series.first, @freq_tolerance
+          verify_harmonic_series series, @freq_tolerance
+        end
+      end
+    end
+    
+    context 'no harmonic series preset' do
+      it 'should return the strongest peak frequency' do
+        cases = [
+           {:strongest_peak => 37.0, :other_peaks => [80.0, 125.0]},
+           {:strongest_peak => 44.0, :other_peaks => [99.0, 155.0]}
+        ]
+        
+        generator = SignalGenerator.new(:sample_rate => 1000, :size => 512)
+        cases.each do |hash|
+          signal = generator.make_signal([hash[:strongest_peak]], :amplitude => 1.5)
+          signal.add!(generator.make_signal(hash[:other_peaks]))
+          signal.fundamental(:min_freq => 20.0).should be_within(5.0).of(hash[:strongest_peak])
+        end
+      end
+    end
+    
+    context 'real-world sound files' do
+      it 'should produce a series with the expected fundamental freq' do
+        cases = {
+          "trumpet_B4.wav" => 493.883,
+          "piano_C4.wav" => 261.626,
+        }
+        
+        cases.each do |filename,ideal_fundamental|
+          file_path = File.dirname(__FILE__) + "/#{filename}"
+          WaveFile::Reader.new(file_path) do |reader|
+            read_size = reader.total_sample_frames
+            sample_frames = reader.read(read_size).samples
+            
+            # if multiple channels are in the file, only use the 1st channel
+            if reader.format.channels == 1
+              data = sample_frames
+            else
+              data = sample_frames.map { |sample_frame| sample_frame[0] }
+            end
+            
+            signal = SPCore::Signal.new(:data => data, :sample_rate => reader.format.sample_rate)
+            series = signal.harmonic_series(:min_freq => 40.0)
+            check_tolerance ideal_fundamental, series.min, @freq_tolerance
+          end          
+        end
+      end
+    end
+  end
+end

data/spec/analysis/statistics_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe SPCore::Statistics do
+  describe '.mean' do
+    it 'should calculate the proper mean' do
+      cases = {
+        [1,2,3,4,5] => 3,
+        [11,25,60,4,22,48,40] => 30,
+        [100,200] => 150,
+      }
+      
+      cases.each do |values,ideal_mean|
+        actual_mean = Statistics.mean values
+        actual_mean.should eq(ideal_mean)
+      end
+    end
+  end
+  
+  describe '.std_dev' do
+    it 'should determine the proper standard deviation' do
+      cases = {
+        [4,2,5,8,6] => 2.24,
+        [2,4,4,4,5,5,7,9] => 2,
+        [1,2,3,4,5] => 1.414
+      }
+      
+      cases.each do |inputs,expected_output|
+        actual_output = Statistics.std_dev inputs
+        actual_output.should be_within(0.01).of(expected_output)
+      end      
+    end
+  end
+  
+  describe '.correlation' do
+    context 'image => triangular window' do
+      before :all do
+        @size = size = 48
+        @triangle = TriangularWindow.new(size * 2).data
+      end
+      
+      context 'feature => rising ramp (half size of triangular window)' do
+        it 'should have maximum correlation at beginning' do
+          rising_ramp = Array.new(@size){|i| i / @size.to_f }
+          correlation = Statistics.correlation(@triangle, rising_ramp)
+          correlation.first.should eq(correlation.max)
+        end
+      end
+      
+      context 'feature => falling ramp (half size of triangular window)' do
+        it 'should have maximum correlation at end' do
+          falling_ramp = Array.new(@size){|i| (@size - i) / @size.to_f }
+          correlation = Statistics.correlation(@triangle, falling_ramp)
+          correlation.last.should eq(correlation.max)
+          
+          #Plotter.plot_1d "correlate falling ramp" => correlation
+        end
+      end
+    end  
+  end
+
+end

data/spec/generation/comb_filter_spec.rb

@@ -0,0 +1,37 @@
+#require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+#
+#describe SPCore::CombFilter do
+#  describe '#frequency_response' do
+#    before :all do
+#      @filters = []
+#      [100].each do |frequency|
+#        [0.15,0.25,0.5,0.75,0.85].each do |alpha|
+#          @filters.push(
+#            CombFilter.new(
+#              :type => CombFilter::FEED_BACK,
+#              :alpha => alpha,
+#              :frequency => frequency
+#            )
+#          )
+#        end
+#      end
+#    end
+#    
+#    it 'should produce the number of samples given by sample_count' do
+#      [5,20,50].each do |sample_count|
+#        @filters.each do |filter|
+#          samples = filter.frequency_response(6000, sample_count)
+#          samples.count.should eq(sample_count)
+#        end
+#      end
+#    end
+#    
+#    it 'should...' do
+#      outputs = {}
+#      @filters.each do |filter|
+#        outputs["comb filter: alpha = #{filter.alpha}, freq = #{filter.frequency}"] = filter.frequency_response 6000, 512
+#      end
+#      Plotter.plot_1d outputs
+#    end
+#  end
+#end

data/spec/interpolation/interpolation_spec.rb

@@ -1,5 +1,3 @@
-require 'pry'
-require 'benchmark'
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe SPCore::Interpolation do

data/spec/{analysis → util}/signal_spec.rb

@@ -12,40 +12,7 @@ describe SPCore::Signal do
       end      
     end
   end
-  
-  describe '#derivative' do
-    before :all do
-      sample_rate = 200
-      sample_period = 1.0 / sample_rate
-      sample_count = sample_rate
-      
-      range = -Math::PI..Math::PI
-      delta = (range.max - range.min) / sample_count
-      
-      sin = []
-      cos = []
-      
-      range.step(delta) do |x|
-        sin << Math::sin(x)
-        cos << (Math::PI * 2 * Math::cos(x))
-      end
-      
-      @sin = SPCore::Signal.new(:sample_rate => sample_count, :data => sin)
-      @expected = SPCore::Signal.new(:sample_rate => sample_count, :data => cos)
-      @actual = @sin.derivative
-    end
     
-    it 'should produce a signal of same size' do
-      @actual.size.should eq @expected.size
-    end
-    
-    it 'should produce a signal matching the 1st derivative' do
-      @actual.data.each_index do |i|
-        @actual[i].should be_within(0.1).of(@expected[i])
-      end
-    end
-  end
-  
   describe '#normalize' do
     before :all do
       generator = SignalGenerator.new(:sample_rate => 2000, :size => 256)
@@ -132,5 +99,4 @@ describe SPCore::Signal do
       #)
     end
   end
-
-end
+end