music-transcription 0.6.3 → 0.7.0

data/lib/music-transcription/note.rb

@@ -3,39 +3,17 @@ module Transcription
 
 require 'set'
 
-# Abstraction of a musical note. The note can contain zero or more pitches,
-# with links to a pitches in a following note. The note also has an accent,
-# which must be one of Note::ACCENTS.
-#
-# @author James Tunnell
-# 
-# @!attribute [rw] duration
-#   @return [Numeric] The duration (in, say note length or time), greater than 0.0.
-#
-# @!attribute [r] pitches
-#   @return [Set] The pitches that are part of the note and can link to
-#                   pitches in a following note.
-#
-# @!attribute [r] links
-#   @return [Hash] Maps pitches in the current note to pitches in the following
-#                  note, by some link class, like Link::Slur.
-# 
-# @!attribute [rw] accent
-#   @return [Accent] The accent type, which must be one of Note::ACCENTS.
-#
 class Note
   attr_reader :duration, :pitches, :links
   attr_accessor :accent
 
-  # A new instance of Note.
-  def initialize duration, pitches = [], links: {}, accent: nil
+  def initialize duration, pitches = [], links: {}, accent: Accents::NONE
     self.duration = duration
     @pitches = Set.new(pitches).sort
     @links = links
     self.accent = accent
   end
   
-  # Compare the equality of another Note object.
   def == other
     return (@duration == other.duration) &&
     (self.pitches == other.pitches) &&
@@ -51,32 +29,15 @@ class Note
     @duration = duration
   end
   
-  # Produce an identical Note object.
   def clone
     Marshal.load(Marshal.dump(self))
   end
 
-  def transpose_pitches_only diff
-    self.clone.transpose_pitches! pitch_diff, transpose_link
-  end
-
-  def transpose_pitches_only! diff
-    self.transpose! diff, false
-  end
-  
-  def transpose_pitches_and_links diff
-    self.clone.transpose_pitches_and_links! diff
-  end
-
-  def transpose_pitches_and_links! diff
-    self.transpose! diff, true
+  def transpose diff
+    self.clone.transpose! diff
   end
   
-  def transpose diff, transpose_links = true
-    self.clone.transpose! diff, transpose_links
-  end
-  
-  def transpose! diff, transpose_link_targets = true
+  def transpose! diff
     unless diff.is_a?(Pitch)
       diff = Pitch.make_from_semitone(diff)
     end
@@ -84,9 +45,7 @@ class Note
     @pitches = @pitches.map {|pitch| pitch + diff}
     new_links = {}
     @links.each_pair do |k,v|
-      if transpose_link_targets
-        v.target_pitch += diff
-      end
+      v.target_pitch += diff
       new_links[k + diff] = v
     end
     @links = new_links
@@ -102,79 +61,57 @@ class Note
     return self
   end
   
-  def to_s
-    output = @duration.to_s
-    if @pitches.any?
-      output += "@"
-      @pitches[0...-1].each do |pitch|
-        output += pitch.to_s
-        if @links.has_key? pitch
-          output += @links[pitch].to_s
-        end
-        output += ","
-      end
-      
-      last_pitch = @pitches[-1]
-      output += last_pitch.to_s
-      if @links.has_key? last_pitch
-        output += @links[last_pitch].to_s
-      end
-    end
-    
-    return output
-  end
-  
   class Sixteenth < Note
-    def initialize pitches = [], links: {}, accent: nil
-      super(Rational(1,16),pitches, links: links, accent: accent)
+    def initialize pitches = [], links: {}, accent: Accents::NONE
+      super(Rational(1,16),pitches,links:links,accent:accent)
     end
   end
-
+  
   class DottedSixteenth < Note
-    def initialize pitches = [], links: {}, accent: nil
-      super(Rational(3,32),pitches, links: links, accent: accent)
+    def initialize pitches = [], links: {}, accent: Accents::NONE
+      super(Rational(3,32),pitches,links:links,accent:accent)
     end
   end
   
   class Eighth < Note
-    def initialize pitches = [], links: {}, accent: nil
-      super(Rational(1,8),pitches, links: links, accent: accent)
+    def initialize pitches = [], links: {}, accent: Accents::NONE
+      super(Rational(1,8),pitches,links:links,accent:accent)
     end
   end
-
+  
   class DottedEighth < Note
-    def initialize pitches = [], links: {}, accent: nil
-      super(Rational(3,16),pitches, links: links, accent: accent)
+    def initialize pitches = [], links: {}, accent: Accents::NONE
+      super(Rational(3,16),pitches,links:links,accent:accent)
     end
   end
   
   class Quarter < Note
-    def initialize pitches = [], links: {}, accent: nil
-      super(Rational(1,4),pitches, links: links, accent: accent)
+    def initialize pitches = [], links: {}, accent: Accents::NONE
+      super(Rational(1,4),pitches,links:links,accent:accent)
     end
   end
   
   class DottedQuarter < Note
-    def initialize pitches = [], links: {}, accent: nil
-      super(Rational(3,8),pitches, links: links, accent: accent)
+    def initialize pitches = [], links: {}, accent: Accents::NONE
+      super(Rational(3,8),pitches,links:links,accent:accent)
     end
   end
-
+  
   class Half < Note
-    def initialize pitches = [], links: {}, accent: nil
-      super(Rational(1,2),pitches, links: links, accent: accent)
+    def initialize pitches = [], links: {}, accent: Accents::NONE
+      super(Rational(1,2),pitches,links:links,accent:accent)
     end
   end
-
+  
   class DottedHalf < Note
-    def initialize pitches = [], links: {}, accent: nil
-      super(Rational(3,4),pitches, links: links, accent: accent)
+    def initialize pitches = [], links: {}, accent: Accents::NONE
+      super(Rational(3,4),pitches,links:links,accent:accent)
     end
   end
-  
+    
   class Whole < Note
-    def initialize pitches = [], links: {}, accent: nil
-      super(Rational(1,1),pitches, links: links, accent: accent)
+    def initialize pitches = [], links: {}, accent: Accents::NONE
+      super(Rational(1,1),pitches,links:links,accent:accent)
     end
   end
 end

data/lib/music-transcription/part.rb

@@ -3,90 +3,34 @@ require 'yaml'
 module Music
 module Transcription
 
-# Abstraction of a musical part. Contains notes and loudness_profile settings.
-#
-# @author James Tunnell
-#
-# @!attribute [r] notes
-#   @return [Array] The notes to be played.
-#
-# @!attribute [r] dynamic_profile
-#   @return [Profile] Dynamic values profile
-#
 class Part
-  attr_reader :notes, :dynamic_profile
+  attr_reader :start_dynamic, :dynamic_changes, :notes
   
-  def initialize notes: [], dynamic_profile: Profile.new(Dynamics::MF)
+  def initialize start_dynamic, notes: [], dynamic_changes: {}
     @notes = notes
-    @dynamic_profile = dynamic_profile
-    
-    if dynamic_profile.changes_before?(0)
-      raise ArgumentError, "dynamic profile has changes with offset less than 0"
-    end
+    @start_dynamic = start_dynamic
+    @dynamic_changes = dynamic_changes
     
     d = self.duration
-    if dynamic_profile.changes_after?(d)
-      raise ArgumentError, "dynamic profile has changes with offset greater than part duration #{d}"
+    badkeys = dynamic_changes.keys.select {|k| k < 0 || k > d }
+    if badkeys.any?
+      raise ArgumentError, "dynamic profile has changes outside 0..d"
     end
   end
   
-  # Produce an exact copy of the current object
   def clone
     Marshal.load(Marshal.dump(self))
   end
   
-  # Compare the equality of another Part object.
   def ==(other)
     return (@notes == other.notes) &&
-    (@dynamic_profile == other.dynamic_profile)
+    (@start_dynamic == other.start_dynamic) &&
+    (@dynamic_changes == other.dynamic_changes)
   end
 
-  # Duration of part notes.
   def duration
     return @notes.inject(0) { |sum, note| sum + note.duration }
   end
-  
-  def transpose diff
-    self.clone.transpose! diff
-  end
-
-  def transpose! diff
-    @notes[0...-1].each do |note|
-      note.transpose_pitches_and_links! diff
-    end
-    @notes[-1].transpose_pitches_only! diff
-    return self
-  end
-  
-  # Add on notes and dynamic_profile from another part, producing a new
-  # Part object. The offsets of value changes in the dynamic profile,
-  # for the other part, will be considered relative from end of current part.
-  def append other
-    self.clone.append! other
-  end
-  
-  # Add on notes and dynamic_profile from another part, producing a new
-  # Part object. The offsets of value changes in the dynamic profile,
-  # for the other part, will be considered relative from end of current part.
-  def append! other
-    @dynamic_profile.append!(other.dynamic_profile,self.duration)
-    @notes += other.notes.map {|x| x.clone}
-    return self
-  end
-  
-  def stretch ratio
-    self.clone.stretch! ratio
-  end
-  
-  def stretch! ratio
-    @notes.each_index do |i|
-      n1 = @notes[i]
-      @notes[i] = Note.new(n1.duration * ratio, n1.pitches, links: n1.links, accent: n1.accent)
-    end
-    
-    @dynamic_profile.stretch! ratio
-    return self
-  end
 end
 
 end

data/lib/music-transcription/score.rb

@@ -1,26 +1,16 @@
 module Music
 module Transcription
 
-# Score, containing parts and a program.
-#
-# @author James Tunnell
-#
-# @!attribute [rw] parts
-#   @return [Hash] Score parts, mapped to part names
-# 
-# @!attribute [rw] program
-#   @return [Program] Score program (which segments are played when)
-#
-# @!attribute [rw] tempo_profile
-#   @return [Profile] Tempo values profile
-#
 class Score
-  attr_reader :parts, :program, :tempo_profile
+  attr_reader :start_meter, :start_tempo, :parts, :program, :meter_changes, :tempo_changes
   
-  def initialize parts: {}, program: Program.new, tempo_profile: Profile.new(Tempo.new(120))
+  def initialize start_meter, start_tempo, meter_changes: {}, tempo_changes: {}, parts: {}, program: Program.new
+    @start_meter = start_meter
+    @start_tempo = start_tempo
+    @meter_changes = meter_changes
+    @tempo_changes = tempo_changes
     @parts = parts
     @program = program
-    @tempo_profile = tempo_profile
   end
 
   def clone
@@ -28,35 +18,16 @@ class Score
   end
   
   def ==(other)
-    return (@tempo_profile == other.tempo_profile) &&
-    (@program == other.program) &&
-    (@parts == other.parts)
+    return @start_meter == other.start_meter && 
+    @start_tempo == other.start_tempo &&
+    @meter_changes == other.meter_changes &&
+    @tempo_changes == other.tempo_changes &&
+    @parts == other.parts &&
+    @program == other.program
   end
     
-  # Find the start of a score. The start will be at then start of whichever part begins
-  # first, or 0 if no parts have been added.
-  def start
-    sos = 0.0
-    
-    @parts.each do |id,part|
-      sop = part.start
-      sos = sop if sop > sos
-    end
-    
-    return sos
-  end
-  
-  # Find the end of a score. The end will be at then end of whichever part ends 
-  # last, or 0 if no parts have been added.
-  def end
-    eos = 0.0
-    
-    @parts.each do |id,part|
-      eop = part.end
-      eos = eop if eop > eos
-    end
-    
-    return eos
+  def duration
+    @parts.map {|p| p.duration }.max
   end
 end
 

data/lib/music-transcription/version.rb

@@ -2,6 +2,6 @@
 module Music
 module Transcription
   # music-transcription version
-  VERSION = "0.6.3"
+  VERSION = "0.7.0"
 end
 end

data/lib/music-transcription.rb

@@ -6,6 +6,7 @@ require 'music-transcription/pitch'
 require 'music-transcription/pitches'
 require 'music-transcription/link'
 require 'music-transcription/accent'
+require 'music-transcription/accents'
 require 'music-transcription/change'
 require 'music-transcription/note'
 require 'music-transcription/profile'
@@ -14,4 +15,5 @@ require 'music-transcription/dynamics'
 require 'music-transcription/part'
 require 'music-transcription/program'
 require 'music-transcription/tempo'
+require 'music-transcription/meter'
 require 'music-transcription/score'

data/spec/meter_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Meter do
+  describe '#initialize' do
+    it 'should assign beats per measure and beat duration' do
+      [[4,"1/4".to_r],[3,"1/4".to_r],[6,"1/8".to_r]].each do |bpm,bd|
+        m = Meter.new(bpm,bd)
+        m.beats_per_measure.should eq bpm
+        m.beat_duration.should eq bd
+      end      
+    end
+    
+    it 'should derive measure duration' do
+      {
+        [4,"1/4".to_r] => "1/1".to_r,
+        [3,"1/4".to_r] => "3/4".to_r,
+        [6,"1/8".to_r] => "6/8".to_r,
+        [12,"1/8".to_r] => "12/8".to_r,
+      }.each do |bpm,bd|
+        m = Meter.new(bpm,bd)
+        m.measure_duration.should eq(bpm*bd)
+      end      
+    end
+  end
+end

data/spec/note_spec.rb

@@ -37,46 +37,33 @@ describe Note do
   end
   
   describe '#transpose!' do
-    context 'transpose_link_targets set false' do
-      context 'given pitch diff' do
-        before(:all) do
-          @note = Note::Quarter.new([C2,F2], links:{C2=>Link::Slur.new(D2)})
-          @diff = Pitch.new(semitone: 4)
-          @note.transpose! @diff, false
-        end
-        
-        it 'should modifiy pitches by adding pitch diff' do
-          @note.pitches[0].should eq E2
-          @note.pitches[1].should eq A2
-        end
+    context 'given pitch diff' do
+      before(:all) do
+        @note = Note::Quarter.new([C2,F2], links:{C2=>Link::Slur.new(D2)})
+        @diff = Pitch.new(semitone: 4)
+        @note.transpose! @diff
+      end
         
-        it 'should not affect link targets' do
-          @note.links.should have_key(E2)
-          @note.links[E2].target_pitch.should eq(D2)
-        end
+      it 'should modifiy pitches by adding pitch diff' do
+        @note.pitches[0].should eq E2
+        @note.pitches[1].should eq A2
       end
-      
-      context 'given integer diff' do
-        it 'should transpose the given number of semitones' do
-          Note::Quarter.new([C2]).transpose!(4,false).pitches[0].should eq(E2)
-        end
+        
+      it 'should also affect link targets' do
+        @note.links.should have_key(E2)
+        @note.links[E2].target_pitch.should eq(Gb2)
       end
     end
-      
-    context 'transpose_link_targets set true' do
-      it 'should also transpose link targets' do
-        note = Note::Quarter.new([C2,F2], links:{C2=>Link::Slur.new(D2)})
-        note.transpose!(2,true)
-        note.links[D2].target_pitch.should eq(E2)
+    
+    context 'given integer diff' do
+      it 'should transpose the given number of semitones' do
+        Note::Quarter.new([C2]).transpose!(4).pitches[0].should eq(E2)
       end
     end
     
-    context 'transpose_link_targets not set' do
-      it 'should default to true' do
-        note = Note::Quarter.new([C2,F2], links: {C2=>Link::Slur.new(D2)})
-        note.transpose!(2)
-        note.links[D2].target_pitch.should eq E2
-      end
+    it 'should return self' do
+      n = Note::Quarter.new
+      n.transpose!(0).should eq n
     end
   end
   

data/spec/part_spec.rb

@@ -1,91 +1,22 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe Part do
-  context '.new' do
-    it 'should have no notes' do
-      Part.new.notes.should be_empty
-    end
-
-    it "should assign dynamic profile given during construction" do
-      profile = Profile.new(Dynamics::FFF, { 1.0 => Change::Immediate.new(Dynamics::PP) })
-      part = Part.new notes:[Note.new(1.to_r)], dynamic_profile: profile
-      part.dynamic_profile.should eq(profile)
-    end  
-    
-    it "should assign notes given during construction" do
-      notes = [ Note::Quarter.new([C1,D1]) ]
-      part = Part.new notes: notes
-      part.notes.should eq(notes)
-    end
-  end
-  
-  describe '#stretch' do
-    before :all do
-      p = Part.new(
-        notes: [ Note::Quarter.new, Note::Whole.new, Note::Eighth.new ],
-        dynamic_profile: Profile.new(
-          Dynamics::PP,
-          "1/2".to_r => Change::Immediate.new(Dynamics::MP),
-          "3/4".to_r => Change::Immediate.new(Dynamics::FF)
-        )
-      )
-      @p1 = p.stretch(1)
-      @p2 = p.stretch("5/3".to_r)
-      @p3 = p.stretch("3/5".to_r)
-    end
-    
-    it 'should multiply durations by ratio' do
-      @p1.notes.map {|n| n.duration }.should eq(["1/4".to_r, "1/1".to_r, "1/8".to_r])
-      @p2.notes.map {|n| n.duration }.should eq(["5/12".to_r, "5/3".to_r, "5/24".to_r])
-      @p3.notes.map {|n| n.duration }.should eq(["3/20".to_r, "3/5".to_r, "3/40".to_r])
+  context '#initialize' do
+    it 'should use empty containers for parameters not given' do
+      p = Part.new(Dynamics::MP)
+      p.notes.should be_empty
+      p.dynamic_changes.should be_empty
     end
     
-    it 'should multiply dynamic profile changes by ratio' do
-      @p1.dynamic_profile.value_changes.should have_key("1/2".to_r)
-      @p1.dynamic_profile.value_changes.should have_key("3/4".to_r)
-
-      @p2.dynamic_profile.value_changes.should have_key("5/6".to_r)
-      @p2.dynamic_profile.value_changes.should have_key("15/12".to_r)
+    it "should assign parameters given during construction" do
+      p = Part.new(Dynamics::PPP)
+      p.start_dynamic.should eq Dynamics::PPP
       
-      @p3.dynamic_profile.value_changes.should have_key("3/10".to_r)
-      @p3.dynamic_profile.value_changes.should have_key("9/20".to_r)
-    end
-  end
-  
-  describe '#append!' do
-    it 'should add other notes to current array' do
-      p1 = Part.new(notes: [Note::Eighth.new([C4])])
-      p2 = Part.new(notes: [Note::Eighth.new([E4])])
-      p1.append! p2
-      p1.notes.size.should be 2
-      p1.notes[0].pitches[0].should eq C4
-      p1.notes[1].pitches[0].should eq E4
-    end
-    
-    it 'should add start dynamic from given part as immediate dynamic change' do
-      p1 = Part.new(notes: [Note::Eighth.new])
-      p2 = Part.new(notes: [Note::Eighth.new], dynamic_profile: Profile.new(Dynamics::PPP))
-      p1.append! p2
-      p1.dynamic_profile.value_changes.size.should eq 1
-      p1.dynamic_profile.value_changes[Rational(1,8)].should be_a Change::Immediate
-      p1.dynamic_profile.value_changes[Rational(1,8)].value.should eq Dynamics::PPP
-    end
-    
-    it 'should add shifted dynamic changes from given part' do
-      p1 = Part.new(notes: [Note::Whole.new])
-      p2 = Part.new(
-        notes: [Note::Whole.new],
-        dynamic_profile: Profile.new(
-          Dynamics::PPP,
-          Rational(1,8) => Change::Gradual.new(Dynamics::PP,Rational(1,8)),
-          Rational(3,8) => Change::Immediate.new(Dynamics::P)
-        )
-      )
-      p1.append! p2
-      p1.dynamic_profile.value_changes.size.should eq 3
-      p1.dynamic_profile.value_changes[Rational(1,1)].value.should eq Dynamics::PPP
-      p1.dynamic_profile.value_changes[Rational(9,8)].value.should eq Dynamics::PP
-      p1.dynamic_profile.value_changes[Rational(11,8)].value.should eq Dynamics::P
+      notes = [Note::Whole.new([A2]), Note::Half.new]
+      dcs = { "1/2".to_r => Change::Immediate.new(Dynamics::P), 1 => Change::Gradual.new(Dynamics::MF,1) }
+      p = Part.new(Dynamics::FF, notes: notes, dynamic_changes: dcs)
+      p.notes.should eq notes
+      p.dynamic_changes.should eq dcs
     end
   end
 end

data/spec/score_spec.rb

@@ -1,22 +1,34 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe Score do
-  before :each do
-    @parts = { "piano (LH)" => Samples::SAMPLE_PART }
-    @program = Program.new [0...0.75, 0...0.75]
-  end
-  
-  describe '.new' do
-    it "should assign part and program given during construction" do
-      score = Score.new parts: @parts, program: @program
-      score.parts.should eq(@parts)
-      score.program.should eq(@program)
+  describe '#initialize' do
+    it 'should use empty containers for parameters not given' do
+      s = Score.new(Meter.new(4,4),120)
+      s.parts.should be_empty
+      s.program.segments.should be_empty
+    end
+    
+    it 'should assign given parameters' do
+      m = Meter.new(4,"1/4".to_r)
+      s = Score.new(m,120)
+      s.start_meter.should eq m
+      s.start_tempo.should eq 120
+      
+      parts = { "piano (LH)" => Samples::SAMPLE_PART }
+      program = Program.new [0...0.75, 0...0.75]
+      mcs = { 1 => Change::Immediate.new(Meter.new(3,"1/4".to_r)) }
+      tcs = { 1 => Change::Immediate.new(100) }
+      
+      s = Score.new(m,120,
+        parts: parts,
+        program: program,
+        meter_changes: mcs,
+        tempo_changes: tcs
+      )
+      s.parts.should eq parts
+      s.program.should eq program
+      s.meter_changes.should eq mcs
+      s.tempo_changes.should eq tcs
     end
-
-    it "should assign tempo profile given during construction" do
-      profile = Profile.new(Tempo.new(200), 0.5 => Change::Gradual.new(Tempo.new(120),0.5) )
-      score = Score.new tempo_profile: profile
-      score.tempo_profile.should eq(profile)
-    end    
   end
 end

data/spec/spec_helper.rb

@@ -6,7 +6,12 @@ include Music::Transcription::Pitches
 
 class Samples
   SAMPLE_PART = Part.new(
-    notes: [ Note::Quarter.new([ C1, D1 ]), Note::Quarter.new([ C2, D2 ]), Note::Whole.new([ C3, D3 ]) ],
-    dynamic_profile: Profile.new(Dynamics::P, {1.0 => Change::Immediate.new(Dynamics::MP)})
+    Dynamics::P,
+    notes: [
+      Note::Quarter.new([ C1, D1 ]),
+      Note::Quarter.new([ C2, D2 ]),
+      Note::Whole.new([ C3, D3 ])
+    ],
+    dynamic_changes: {1.0 => Change::Immediate.new(Dynamics::MP)}
   )
 end