musicality 0.8.0 → 0.9.0

data/lib/musicality/composition/dsl/score_dsl.rb

@@ -12,8 +12,8 @@ class ScoreDSL
     @score = nil
   end
 
-  def measured_score start_meter, start_tempo, &block
-    @score = Score::Measured.new(start_meter,start_tempo)
+  def tempo_score start_meter, start_tempo, &block
+    @score = Score::Tempo.new(start_meter,start_tempo)
     @score.instance_eval(&block)
   end
 end

data/lib/musicality/composition/dsl/score_methods.rb

@@ -51,13 +51,14 @@ class Score
 
   def dynamic_change new_dynamic, transition_dur: 0, offset: 0
     if transition_dur == 0
-      tempo_changes[self.duration + offset] = Change::Immediate.new(new_tempo)
-    else
-      tempo_changes[self.duration + offset] = Change::Gradual.linear(new_tempo, transition_dur)
+      change = (transition_dur == 0) ? Change::Immediate.new(new_tempo) : Change::Gradual.linear(new_tempo, transition_dur)
+      parts.values.each do |part|
+        part.tempo_changes[self.duration + offset] = change
+      end
     end
   end
   
-  class TempoBased < Score
+  class Tempo < Score
     def tempo_change new_tempo, transition_dur: 0, offset: 0
       if transition_dur == 0
         tempo_changes[self.duration + offset] = Change::Immediate.new(new_tempo)
@@ -65,12 +66,14 @@ class Score
         tempo_changes[self.duration + offset] = Change::Gradual.linear(new_tempo, transition_dur)
       end
     end
-  end
-  
-  class Measured < Score::TempoBased
+    
     def meter_change new_meter, offset: 0
       meter_changes[self.duration + offset] = Change::Immediate.new(new_meter)
     end
+
+    def key_change new_key, offset: 0
+      key_changes[self.duration + offset] = Change::Immediate.new(new_key)
+    end
   end
 end
 

data/lib/musicality/notation/conversion/change_conversion.rb

@@ -11,7 +11,7 @@ class Change
     end
     
     def to_transition offset, value
-      Transition::new(Function::Constant.new(@end_value), offset..offset)
+      Transition.new(Function::Constant.new(@end_value), offset..offset)
     end
   end
   

data/lib/musicality/notation/conversion/note_time_converter.rb

@@ -1,36 +1,19 @@
 module Musicality
 
-# Convert offsets in unmeasured note time to just plain time. 
+# Convert offsets in measured note time to just plain time. 
 class NoteTimeConverter
   # @param [ValueComputer] tempo_computer Given an offset, returns tempo
   # value in quarter-notes-per-minute
   # @param [Numeric] sample_rate Rate at which tempo values are sampled
   # in the conversion (samples/sec).
-  def initialize sample_rate
+  def initialize tempo_computer, bdur_computer, sample_rate
+    @tempo_computer = tempo_computer
+    @bdur_computer = bdur_computer
     @sample_period = Rational(1,sample_rate)
   end
 
-  class Unmeasured < NoteTimeConverter
-    def initialize tempo_computer, sample_rate
-      @tempo_computer = tempo_computer
-      super(sample_rate)
-    end
-
-    def notes_per_second_at offset
-      Tempo::QNPM.to_nps(@tempo_computer.at offset)
-    end
-  end
-  
-  class Measured < NoteTimeConverter
-    def initialize tempo_computer, bdur_computer, sample_rate
-      @tempo_computer = tempo_computer
-      @bdur_computer = bdur_computer
-      super(sample_rate)
-    end
-
-    def notes_per_second_at offset
-      Tempo::BPM.to_nps(@tempo_computer.at(offset), @bdur_computer.at(offset))
-    end
+  def notes_per_second_at offset
+    Tempo::BPM.to_nps(@tempo_computer.at(offset), @bdur_computer.at(offset))
   end
   
   # Calculate the time elapsed between given start/end note offset. Using the

data/lib/musicality/notation/conversion/score_conversion.rb

@@ -1,19 +1,11 @@
 module Musicality
 
 class Score
-  class Unmeasured < TempoBased
-    # Convert to timed score by converting measure-based offsets and note-based
-    # durations to time-based. This eliminates the use of tempos.
-    def to_timed tempo_sample_rate
-      ScoreConverter::Unmeasured.new(self, tempo_sample_rate).convert_score
-    end      
-  end
-  
-  class Measured < TempoBased
+  class Tempo < Score
     # Convert to timed score by converting measure-based offsets and note-based
     # durations to time-based. This eliminates the use of meters and tempos.
     def to_timed tempo_sample_rate
-      ScoreConverter::Measured.new(self, tempo_sample_rate).convert_score
+      ScoreConverter.new(self, tempo_sample_rate).convert_score
     end
     
     def measure_note_map
@@ -23,7 +15,7 @@ class Score
     def measure_offsets
       moffs = Set.new([0.to_r])
       @tempo_changes.each {|moff,change| moffs += change.offsets(moff) }
-      @meter_changes.keys.each {|moff| moffs.add(moff) }
+      moffs += @meter_changes.keys
       @parts.values.each do |part|
         part.dynamic_changes.each {|moff,change| moffs += change.offsets(moff) }
       end
@@ -32,8 +24,12 @@ class Score
     end
   
     def beat_durations
-      bdurs = @meter_changes.map do |offset,change|
-        [ offset, change.end_value.beat_duration ]
+      bdurs = @meter_changes.map do |offset,change_or_meter|
+        if change_or_meter.is_a? Meter
+          [ offset, change_or_meter.beat_duration ]
+        else
+          [ offset, change_or_meter.end_value.beat_duration ]
+        end
       end.sort
       
       if bdurs.empty? || bdurs[0][0] != 0
@@ -44,8 +40,12 @@ class Score
     end
     
     def measure_durations
-      mdurs = @meter_changes.map do |offset,change|
-        [ offset, change.end_value.measure_duration ]
+      mdurs = @meter_changes.map do |offset,change_or_meter|
+        if change_or_meter.is_a? Meter
+          [ offset, change_or_meter.measure_duration ]
+        else
+          [ offset, change_or_meter.end_value.measure_duration ]
+        end
       end.sort
       
       if mdurs.empty? || mdurs[0][0] != 0

data/lib/musicality/notation/conversion/score_converter.rb

@@ -1,5 +1,7 @@
 module Musicality
 
+# Converts tempo-based score to timed score, by converting note-based offsets
+# and durations to time-based, and eliminating the use of tempo and meters.
 class ScoreConverter
   def self.convert_changes changes, offset_map
     Hash[ changes.map do |off,change|
@@ -14,13 +16,13 @@ class ScoreConverter
         starttime = offset_map[offset]
         endtime = offset_map[offset + note.duration]
         offset += note.duration
-        newnote = note.clone
-        newnote.duration = endtime - starttime
-        newnote
+        note.resize(endtime - starttime)
       end
       new_dcs = convert_changes(part.dynamic_changes, offset_map)
-      [name, Part.new(part.start_dynamic,
-        notes: new_notes, dynamic_changes: new_dcs)]
+      new_part = part.clone
+      new_part.notes = new_notes
+      new_part.dynamic_changes = new_dcs
+      [name, new_part]
     end]
   end
   
@@ -30,75 +32,56 @@ class ScoreConverter
     end
   end
   
-  class TempoBased
-    def initialize parts, program, note_time_converter
-      @parts = parts
-      @program = program
-      @note_time_map = note_time_converter.note_time_map(note_offsets)
-    end
-    
-    def note_offsets
-      noffs = Set.new([0.to_r])
-      @parts.values.each do |part|
-        noff = 0.to_r
-        part.notes.each {|note| noffs.add(noff += note.duration) }
-        part.dynamic_changes.each {|noff2,change| noffs += change.offsets(noff2) }
-      end
-      noffs += @program.map {|seg| [seg.first, seg.last] }.flatten
-      return noffs.sort
+  def initialize score, tempo_sample_rate
+    if score.invalid?
+      raise NotValidError, "Errors detected given score: #{score.errors}"
     end
+    mn_map = score.measure_note_map
+    new_parts = Hash[ score.parts.map do |name,part|
+      new_dcs = ScoreConverter.convert_changes(part.dynamic_changes, mn_map)
+      new_notes = part.notes.map {|n| n.clone } # note duration is already note-based
+      new_part = part.clone
+      new_part.notes = new_notes
+      new_part.dynamic_changes = new_dcs
+      [name, new_part]
+    end]      
+    new_program = ScoreConverter.convert_program(score.program, mn_map)
+    new_tempo_changes = ScoreConverter.convert_changes(score.tempo_changes, mn_map)
+    new_beat_durations = Hash[ score.beat_durations.map do |moff,bdur|
+      [mn_map[moff], Change::Immediate.new(bdur) ]
+    end]
+    tempo_computer = ValueComputer.new(score.start_tempo, new_tempo_changes)
+    bdur_computer = ValueComputer.new(score.start_meter.beat_duration, new_beat_durations)
+    ntc = NoteTimeConverter.new(tempo_computer, bdur_computer, tempo_sample_rate)
 
-    def convert_score
-      Score::Timed.new(parts: convert_parts, program: convert_program)
-    end
-  
-    # Convert note-based offsets & durations to time-based.
-    def convert_parts
-      ScoreConverter.convert_parts(@parts, @note_time_map)
-    end
-    
-    # Convert note-based offsets & durations to time-based.
-    def convert_program
-      ScoreConverter.convert_program(@program, @note_time_map)
-    end
+    @parts = new_parts
+    @program = new_program
+    @note_time_map = ntc.note_time_map(note_offsets)
   end
   
-  # Converts unmeasured score to timed score, by converting note-based offsets
-  # and durations to time-based, and eliminating the use of tempo.
-  class Unmeasured < TempoBased
-    def initialize score, tempo_sample_rate
-      if score.invalid?
-        raise NotValidError, "Errors detected given score: #{score.errors}"
-      end
-      tempo_computer = ValueComputer.new(score.start_tempo, score.tempo_changes)
-      ntc = NoteTimeConverter::Unmeasured.new(tempo_computer, tempo_sample_rate)
-      super(score.parts, score.program, ntc)
+  def note_offsets
+    noffs = Set.new([0.to_r])
+    @parts.values.each do |part|
+      noff = 0.to_r
+      part.notes.each {|note| noffs.add(noff += note.duration) }
+      part.dynamic_changes.each {|noff2,change| noffs += change.offsets(noff2) }
     end
+    noffs += @program.map {|seg| [seg.first, seg.last] }.flatten
+    return noffs.sort
+  end
+
+  def convert_score
+    Score::Timed.new(parts: convert_parts, program: convert_program)
+  end
+
+  # Convert note-based offsets & durations to time-based.
+  def convert_parts
+    ScoreConverter.convert_parts(@parts, @note_time_map)
   end
   
-  # Converts measured score to timed score, by converting note-based offsets
-  # and durations to time-based, and eliminating the use of tempo and meters.
-  class Measured < TempoBased
-    def initialize score, tempo_sample_rate
-      if score.invalid?
-        raise NotValidError, "Errors detected given score: #{score.errors}"
-      end
-      mn_map = score.measure_note_map
-      new_parts = Hash[ score.parts.map do |name,part|
-        new_dcs = ScoreConverter.convert_changes(part.dynamic_changes, mn_map)
-        new_notes = part.notes.map {|n| n.clone } # note duration is already note-based
-        [name, Part.new(part.start_dynamic, notes: new_notes, dynamic_changes: new_dcs)]
-      end]      
-      new_program = ScoreConverter.convert_program(score.program, mn_map)
-      new_tempo_changes = ScoreConverter.convert_changes(score.tempo_changes, mn_map)
-      new_beat_durations = Hash[ score.beat_durations.map do |moff,bdur|
-        [mn_map[moff], Change::Immediate.new(bdur) ]
-      end]
-      tempo_computer = ValueComputer.new(score.start_tempo, new_tempo_changes)
-      bdur_computer = ValueComputer.new(score.start_meter.beat_duration, new_beat_durations)
-      ntc = NoteTimeConverter::Measured.new(tempo_computer, bdur_computer, tempo_sample_rate)
-      super(new_parts, new_program, ntc)
-    end
+  # Convert note-based offsets & durations to time-based.
+  def convert_program
+    ScoreConverter.convert_program(@program, @note_time_map)
   end
 end
 

data/lib/musicality/notation/model/articulations.rb

@@ -1,10 +1,11 @@
 module Musicality
 
 module Articulations
-  NORMAL = :normal
-  SLUR = :slur
   LEGATO = :legato
+  NORMAL = :normal
   TENUTO = :tenuto
+  ACCENT = :accent
+  MARCATO = :marcato
   PORTATO = :portato
   STACCATO = :staccato
   STACCATISSIMO = :staccatissimo

data/lib/musicality/notation/model/change.rb

@@ -1,6 +1,8 @@
 module Musicality
 
 class Change
+  include Packable
+
   attr_reader :end_value
   
   def initialize end_value
@@ -13,12 +15,12 @@ class Change
   end
   
   class Immediate < Change
-    def initialize value
-      super(value)
+    def initialize end_value
+      super(end_value)
     end
     
     def clone
-      Immediate.new(@end_value)
+      Immediate.new(block_given? ? yield(@end_value) : @end_value)
     end
     
     def duration; 0; end
@@ -59,7 +61,12 @@ class Change
       @start_value == other.start_value
     end
     
-    def clone; Gradual.new(@end_value, @duration, @transition); end
+    def clone
+      ev = block_given? ? yield(@end_value) : @end_value
+      sv = (block_given? && !@start_value.nil?) ? yield(@start_value) : @start_value
+      Gradual.new(ev, @duration, @transition, start_value: sv)
+    end
+
     def relative?; @start_value.nil?; end
     def absolute?; !@start_value.nil?; end
     
@@ -102,8 +109,10 @@ class Change
       end
     
       def clone
-        Trimmed.new(@end_value, @duration, @transition, start_value: @start_value,
-                    preceding: @preceding, remaining: @remaining)
+        ev = block_given? ? yield(@end_value) : @end_value
+        sv = (block_given? && !@start_value.nil?) ? yield(@start_value) : @start_value
+        Trimmed.new(ev, @duration, @transition, start_value: sv,
+          preceding: @preceding, remaining: @remaining)
       end
     end
     

data/lib/musicality/notation/model/dynamics.rb

@@ -1,12 +1,15 @@
 module Musicality
 module Dynamics
-  PPP = 0.125
-  PP = 0.25
-  P = 0.375
-  MP = 0.5
-  MF = 0.625
-  F = 0.75
-  FF = 0.875
-  FFF = 1.0
+  PPP = 0.05
+  FFF = 0.5
+  DYNAMIC_RATIO = (FFF/PPP)**(1.0/7.0) # 7 ratios between the 8 dynamic levels
+
+  PP = PPP*DYNAMIC_RATIO
+  P = PP*DYNAMIC_RATIO
+  MP = P*DYNAMIC_RATIO
+  MF = MP*DYNAMIC_RATIO
+  F = MF*DYNAMIC_RATIO
+  FF = F*DYNAMIC_RATIO
+  
 end
 end

data/lib/musicality/notation/model/instrument.rb

@@ -0,0 +1,61 @@
+module Musicality
+
+class Instrument
+  TREBLE = :treble
+  BASS = :bass
+  TENOR = :tenor
+  ALTO = :alto
+  CLEFS = [TREBLE, ALTO, BASS, TENOR]
+
+  DEFAULT_MIDI_OPT = :default
+
+  attr_accessor :name, :clefs, :midi_num, :transpose_interval
+
+  def initialize name, clefs, midi_num, transpose_interval = 0
+    @name = name
+    @clefs = clefs
+    @midi_num = midi_num
+    @transpose_interval = transpose_interval
+  end
+
+  def ==(other)
+    begin
+      return name == other.name && 
+        Set.new(clefs) == Set.new(other.clefs) && 
+        midi_num == other.midi_num &&
+        transpose_interval == other.transpose_interval
+    rescue # if other object doesn't have the right methods
+      return false
+    end
+  end
+
+  def self.treble name, midi_num, transpose_interval = 0
+    Instrument.new(name, [TREBLE], midi_num, transpose_interval)
+  end
+
+  def self.bass name, midi_num, transpose_interval = 0
+    Instrument.new(name, [BASS], midi_num, transpose_interval)
+  end
+
+  def self.treble_bass name, midi_num, transpose_interval = 0
+    Instrument.new(name, [TREBLE,BASS], midi_num, transpose_interval)
+  end
+
+  def self.treble_alto name, midi_num, transpose_interval = 0
+    Instrument.new(name, [TREBLE,ALTO], midi_num, transpose_interval)
+  end
+
+  def self.tenor_bass name, midi_num, transpose_interval = 0
+    Instrument.new(name, [TENOR, BASS], midi_num, transpose_interval)
+  end
+
+  def self.guitar name, midi_num
+    Instrument.new(name, [TENOR], midi_num, 12)
+  end
+
+  def self.bass_guitar name, midi_num
+    Instrument.new(name, [BASS], midi_num, 12)
+  end
+end
+
+end