music-performance 0.2.1

data/lib/music-performance/version.rb

@@ -0,0 +1,7 @@
+# Prepare transcribed score for computer performance
+module Music
+module Performance
+  # music-performance version
+  VERSION = "0.2.1"
+end
+end

data/music-performance.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/music-performance/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "music-performance"
+  gem.version       = Music::Performance::VERSION
+  gem.summary       = %q{Classes for representing music notational features like pitch, note, loudness, tempo, etc.}
+  gem.description   = <<DESCRIPTION
+Prepare a transcribed musical score for performance by a computer.
+DESCRIPTION
+  gem.license       = "MIT"
+  gem.authors       = ["James Tunnell"]
+  gem.email         = "jamestunnell@gmail.com"
+  gem.homepage      = "https://github.com/jamestunnell/music-performance"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+  
+  gem.add_development_dependency 'bundler', '~> 1.5'
+  gem.add_development_dependency 'rubygems-bundler', '~> 1.4'
+  gem.add_development_dependency 'rake', '~> 10.1'
+  gem.add_development_dependency 'rspec', '~> 2.14'
+  gem.add_development_dependency 'yard', '~> 0.8'
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'pry-nav'
+  
+  gem.add_dependency 'music-transcription', '~> 0.17.0'
+  gem.add_dependency 'midilib', '~> 2.0'
+  gem.add_dependency 'docopt'
+end

data/spec/conversion/glissando_converter_spec.rb

@@ -0,0 +1,93 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe GlissandoConverter do
+  describe '.glissando_pitches' do
+    context 'start pitch <= target pitch' do
+      [
+        [F3,B3],
+        [C4,Gb5],
+        [D2,C5],
+        [F2,F2],
+        [C4.transpose(0.5),D4],
+        [C4.transpose(0.5),D4.transpose(0.5)],
+        [C4.transpose(0.01),F5],
+        [C4.transpose(-0.01),F5.transpose(-0.01)],
+      ].each do |start,finish|
+        context "start at #{start.to_s}, target #{finish.to_s}" do
+          pitches = GlissandoConverter.glissando_pitches(start,finish)
+          
+          it 'should begin with start pitch' do
+            pitches.first.should eq(start)
+          end
+          
+          it 'should move up to next whole (zero-cent) pitches' do
+            (1...pitches.size).each do |i|
+              pitches[i].cent.should eq(0)
+              pitches[i].diff(pitches[i-1]).should be <= 1
+            end
+          end
+          
+          it 'should end on the whole (zero-cent) pitch below target pitch' do
+            pitches.last.cent.should eq(0)
+            diff = finish.total_cents - pitches.last.total_cents
+            diff.should be <= 100
+          end
+        end
+      end
+    end
+    
+    context 'start pitch > target pitch' do
+      [
+        [B3,F3],
+        [Gb5,C4],
+        [C5,D2],
+        [D4,C4.transpose(0.5)],
+        [D4.transpose(0.5),C4.transpose(0.5)],
+        [F5,C4.transpose(0.01)],
+        [F5.transpose(-0.01),C4.transpose(-0.01)],
+      ].each do |start,finish|
+        context "start at #{start.to_s}, target #{finish.to_s}" do
+          pitches = GlissandoConverter.glissando_pitches(start,finish)
+          
+          it 'should move down to next whole (zero-cent) pitches' do
+            (1...pitches.size).each do |i|
+              pitches[i].cent.should eq(0)
+              pitches[i-1].diff(pitches[i]).should be <= 1
+            end
+          end
+          
+          it 'should end on the whole (zero-cent) pitch above target pitch' do
+            pitches.last.cent.should eq(0)
+            diff = pitches.last.total_cents - finish.total_cents
+            diff.should be <= 100
+          end
+
+        end
+      end
+    end
+  end
+  
+  describe '.glissando_elements' do
+    before :all do
+      @dur = Rational(3,2)
+      @acc = false
+      @els = GlissandoConverter.glissando_elements(C4,A4,@dur,@acc)
+    end
+    
+    it 'should return an array of LegatoElement objects' do
+      @els.each {|el| el.should be_a LegatoElement }
+    end
+    
+    it 'should split up duration among elements' do
+      sum = @els.map {|el| el.duration }.inject(0,:+)
+      sum.should eq(@dur)
+    end
+    
+    it 'should set accented as given' do
+      els = GlissandoConverter.glissando_elements(C4,A4,1,false)
+      els.each {|el| el.accented.should eq(false) }
+      els = GlissandoConverter.glissando_elements(C4,A4,1,true)
+      els.each {|el| el.accented.should eq(true) }
+    end
+  end
+end

data/spec/conversion/note_sequence_extractor_spec.rb

@@ -0,0 +1,230 @@
+
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe NoteSequenceExtractor do
+  describe '#initialize' do
+    it 'should clone original notes' do
+      notes = [ Note.quarter([C2]), Note.half, Note.half ]
+      extr = NoteSequenceExtractor.new(notes)
+      extr.notes[0].should eq(notes[0])
+      notes[0].transpose!(1)
+      extr.notes[0].should_not eq(notes[0])
+    end
+
+    it 'should maintain the same number of notes' do
+      extr = NoteSequenceExtractor.new(
+        [ Note.quarter, Note.half, Note.half ])
+      extr.notes.size.should eq 3
+    end
+
+    it 'should remove any bad ties (tying pitch does not exist in next note' do
+      extr = NoteSequenceExtractor.new(
+        [ Note.quarter([C4,E4], links: {C4 => Link::Tie.new}),
+          Note.quarter([E4]) ]
+      )
+      extr.notes[0].links.should_not have_key(C4)
+    end
+
+    it 'should replace any good ties with slurs' do
+      extr = NoteSequenceExtractor.new(
+        [ Note.quarter([C4,E4], links: {C4 => Link::Tie.new, E4 => Link::Tie.new}),
+          Note.quarter([C4,E4]) ]
+      )
+      extr.notes[0].links[C4].should be_a Link::Slur
+      extr.notes[0].links[E4].should be_a Link::Slur
+    end
+
+    it 'should remove dead slur/legato (where target pitch is non-existent)' do
+      extr = NoteSequenceExtractor.new(
+        [ Note.quarter([C4,E4], links: { C4 => Link::Slur.new(D4), E4 => Link::Legato.new(F4) }),
+          Note.quarter([C4]) ]
+      )
+      extr.notes[0].links.should be_empty
+    end
+
+    it 'should remove any link where the source pitch is missing' do
+      extr = NoteSequenceExtractor.new(
+        [ Note.quarter([C4,D4,E4,F4,G4], links: {
+            Bb4 => Link::Tie.new, Db4 => Link::Slur.new(C4),
+            Eb4 => Link::Legato.new(D4), Gb4 => Link::Glissando.new(E4),
+            Ab5 => Link::Portamento.new(F4)
+          }),
+          Note.quarter([C4,D4,E4,F4,G4])
+      ])
+      extr.notes[0].links.should be_empty
+    end
+
+    it 'should not remove portamento and glissando with non-existent target pitches' do
+      extr = NoteSequenceExtractor.new(
+        [ Note.quarter([C4,D4]),
+          Note.quarter([C4,D4,E4,F4,G4], links: {
+            C4 => Link::Tie.new, D4 => Link::Slur.new(Eb4),
+            E4 => Link::Legato.new(Gb4), F4 => Link::Glissando.new(A5),
+            G4 => Link::Portamento.new(Bb5)}) ]
+      )
+      extr.notes[-1].links.size.should eq 2
+      extr.notes[-1].links.should have_key(F4)
+      extr.notes[-1].links.should have_key(G4)
+    end
+  end
+
+  describe '#extract_sequences' do
+    context 'empty note array' do
+      it 'should return empty' do
+        seqs = NoteSequenceExtractor.new([]).extract_sequences
+        seqs.should be_empty
+      end
+    end
+
+    context 'array of only rest notes' do
+      it 'should return empty' do
+        notes = [ Note::quarter, Note::quarter ]
+        seqs = NoteSequenceExtractor.new(notes).extract_sequences
+        seqs.should be_empty
+      end
+    end
+
+    context 'array with only one note, single pitch' do
+      before :all do
+        @note = Note::quarter([C5])
+        @seqs = NoteSequenceExtractor.new([@note]).extract_sequences
+      end
+
+      it 'should return array with one sequence' do
+        @seqs.size.should eq 1
+      end
+
+      it 'should start offset 0' do
+        @seqs[0].start.should eq 0
+      end
+
+      it 'should stop offset <= note duration' do
+        @seqs[0].stop.should be <= @note.duration
+      end
+    end
+
+    context 'array with two slurred notes, single pitch' do
+      before :all do
+        @notes = [ Note.quarter([C5], articulation: SLUR), Note.quarter([D5]) ]
+        @seqs = NoteSequenceExtractor.new(@notes).extract_sequences
+      end
+
+      it 'should return array with one sequence' do
+        @seqs.size.should eq 1
+      end
+
+      it 'should start offset 0' do
+        @seqs[0].start.should eq 0
+      end
+
+      it 'should stop offset <= combined duration of the two notes' do
+        @seqs[0].stop.should be <= (@notes[0].duration + @notes[1].duration)
+      end
+    end
+
+    context 'array with one note, multiple pitches' do
+      before :all do
+        @note = Note.quarter([C5,D5,E5])
+        @seqs = NoteSequenceExtractor.new([@note]).extract_sequences
+      end
+
+      it 'should return array with as many sequences as pitches' do
+        @seqs.size.should eq @note.pitches.size
+      end
+
+      it 'should start the sequences at 0' do
+        @seqs.each {|s| s.start.should eq(0) }
+      end
+
+      it 'should end each sequence at or before note duration' do
+        @seqs.each {|s| s.stop.should be <= @note.duration }
+      end
+
+      it 'should put one pitch in each seq' do
+        @seqs.each {|s| s.pitches.size.should eq(1) }
+      end
+
+      it 'should assign a different pitch to each' do
+        @seqs.map {|seq| seq.pitches[0] }.sort.should eq @note.pitches.sort
+      end
+    end
+
+    context 'array with multiple notes and links' do
+      before :all do
+        @notes = [ Note.quarter([C3,E3], links: {
+          C3 => Link::Slur.new(D3), E3 => Link::Legato.new(F3)}),
+          Note.eighth([D3,F3]) ]
+        @seqs = NoteSequenceExtractor.new(@notes).extract_sequences
+      end
+
+      it 'should create a sequence for linked notes' do
+        @seqs.size.should eq(2)
+      end
+
+      it 'should add pitch at 0 from first note' do
+        @seqs[0].pitches.should have_key(0)
+        @notes[0].pitches.should include(@seqs[0].pitches[0])
+        @seqs[1].pitches.should have_key(0)
+        @notes[0].pitches.should include(@seqs[1].pitches[0])
+      end
+    end
+
+    context 'single note with single pitch, and glissando up' do
+      before :all do
+        @note = Note.whole([D3], links: { D3 => Link::Glissando.new(G3) })
+        @seqs = NoteSequenceExtractor.new([@note]).extract_sequences
+      end
+
+      it 'should produce one sequence' do
+        @seqs.size.should eq(1)
+      end
+
+      it 'should include pitches up to (not including) target pitch' do
+        @seqs[0].pitches.values.should include(D3,Eb3,E3,F3,Gb3)
+      end
+
+      it 'should produce sequence with duration <= note duration' do
+        @seqs[0].duration.should be <= @note.duration
+      end
+    end
+
+    context 'single note with single pitch, and glissando down' do
+      before :all do
+        @note = Note.whole([D3], links: { D3 => Link::Glissando.new(A2) })
+        @seqs = NoteSequenceExtractor.new([@note]).extract_sequences
+      end
+
+      it 'should produce one sequence' do
+        @seqs.size.should eq(1)
+      end
+
+      it 'should include pitches down to (not including) target pitch' do
+        @seqs[0].pitches.values.should include(D3,Db3,C3,B2,Bb2)
+      end
+
+      it 'should produce sequence with duration <= note duration' do
+        @seqs[0].duration.should be <= @note.duration
+      end
+    end
+
+    context 'two notes with single pitch, glissando up to pitch in second note' do
+      before :all do
+        @notes = [Note.whole([D3], links: { D3 => Link::Glissando.new(G3) }),
+                  Note.quarter([G3]) ]
+        @seqs = NoteSequenceExtractor.new(@notes).extract_sequences
+      end
+
+      it 'should produce a single sequence' do
+        @seqs.size.should eq(1)
+      end
+
+      it 'should includes pitches up through target pitch' do
+        @seqs[0].pitches.values.should include(D3,Eb3,E3,F3,Gb3,G3)
+      end
+
+      it 'should produce sequence with duration <= note1dur + note2dur' do
+        @seqs[0].duration.should be <= (@notes[0].duration + @notes[1].duration)
+      end
+    end
+  end
+end

data/spec/conversion/note_time_converter_spec.rb

@@ -0,0 +1,96 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe NoteTimeConverter do
+  describe '.notes_per_second' do
+    it 'should multiply tempo and beat duration, then divide by 60' do
+      nps = NoteTimeConverter.notes_per_second(120,"1/4".to_r)
+      nps.should eq("1/2".to_r)
+    end
+  end
+
+  describe '#notes_per_second_at' do
+    it 'should invoke .notes_per_second using current tempo and beat duration values' do
+      tc = ValueComputer.new(
+        120, 1 => Change::Gradual.new(100,1), 2 => Change::Gradual.new(150,1))
+      bdc = ValueComputer.new Rational(1,4)
+      converter = NoteTimeConverter.new(tc,bdc,200)
+      (0..2).step(0.2).each do |offset|
+        tempo = tc.value_at(offset)
+        beat_duration = bdc.value_at(offset)
+        nps = NoteTimeConverter.notes_per_second(tempo,beat_duration)
+        converter.notes_per_second_at(offset).should eq nps
+      end
+    end
+  end
+  
+  describe "#time_elapsed" do
+    context "constant tempo" do
+      before :each do
+        @tempo_computer = ValueComputer.new 120
+        @beat_duration_computer = ValueComputer.new Rational(1,4)
+        sample_rate = 48
+        @converter = NoteTimeConverter.new(
+          @tempo_computer, @beat_duration_computer, sample_rate)
+      end
+  
+      it "should return a time of zero when note end is zero." do
+        @converter.time_elapsed(0, 0).should eq(0)
+      end
+      
+      it "should return a time of 1 second when note end is equal to the initial notes-per-second" do
+        note_end = @converter.notes_per_second_at(0)
+        @converter.time_elapsed(0, note_end).should eq(1)
+      end
+    end
+    
+    context "linear tempo-change" do
+      before :each do
+        @tempo_computer = ValueComputer.new(
+          120, 1 => Change::Gradual.new(60, 1))
+        @beat_duration_computer = ValueComputer.new(Rational(1,4))
+        sample_rate = 200
+        @converter = NoteTimeConverter.new(
+          @tempo_computer, @beat_duration_computer, sample_rate)
+      end
+  
+      it "should return a time of zero when note end is zero." do
+        @converter.time_elapsed(0.0, 0.0).should eq(0.0)
+      end
+  
+      it "should return a time of 3 sec during a 1-note long transition from 120bpm to 60bpm" do
+        @converter.notes_per_second_at(1.0).should eq(0.5)
+        @converter.notes_per_second_at(2.0).should eq(0.25)
+  
+        @converter.time_elapsed(1.0, 2.0).should be_within(0.05).of(2.77)
+      end
+  
+    end
+  end
+  
+  describe "#map_note_offsets_to_time_offsets" do
+    context "constant tempo" do
+      before :each do 
+        @tempo_computer = ValueComputer.new 120
+        @beat_duration_computer = ValueComputer.new Rational(1,4)
+        sample_rate = 4800
+        @converter = NoteTimeConverter.new(
+          @tempo_computer, @beat_duration_computer, sample_rate)
+      end
+  
+      it "should map offset 0.0 to time 0.0" do
+        map = @converter.map_note_offsets_to_time_offsets [0.0]
+        map[0.0].should eq(0.0)
+      end
+
+      it "should map offset 0.25 to time 0.5" do
+        map = @converter.map_note_offsets_to_time_offsets [0.0, 0.25]
+        map[0.25].should be_within(0.01).of(0.5)
+      end
+      
+      it "should map offset 1.0 to time 2.0" do
+        map = @converter.map_note_offsets_to_time_offsets [0.0, 1.0]
+        map[1.0].should be_within(0.01).of(2.0)
+      end
+    end
+  end
+end