musicality 0.1.0

data/lib/musicality/notation/parsing/segment_parsing.treetop

@@ -0,0 +1,23 @@
+module Musicality
+module Parsing
+
+grammar Segment
+  include NonnegativeInteger
+  include NonnegativeFloat
+  include NonnegativeRational
+  
+  rule range
+    first:nonnegative_number ([.] 2..3) last:nonnegative_number {
+      def to_range
+        first.to_num...last.to_num
+      end
+    }
+  end
+  
+  rule nonnegative_number
+    nonnegative_float / nonnegative_rational / nonnegative_integer
+  end
+end
+
+end
+end

data/lib/musicality/notation/util/interpolation.rb

@@ -0,0 +1,16 @@
+module Musicality
+
+module Interpolation  
+  # Linear interpolation
+  # Given 2 sample points, interpolates a value anywhere between the two points.
+  #
+  # @param [Numeric] y0 First (left) y-value
+  # @param [Numeric] y1 Second (right) y-value
+  # @param [Numeric] x Percent distance (along the x-axis) between the two y-values
+  def self.linear y0, y1, x
+    raise ArgumentError, "x is not between 0.0 and 1.0" unless x.between?(0.0,1.0)
+    return y0 + x * (y1 - y0)
+  end
+end
+
+end

data/lib/musicality/notation/util/piecewise_function.rb

@@ -0,0 +1,122 @@
+module Musicality
+
+# Combine functions that are each applicable for a non-overlapping domain.
+#
+# @author James Tunnell
+class PiecewiseFunction
+  attr_reader :pieces
+  
+  # Take an array of points (each point is a two-element array pair) and
+  # create a piecewise function to calculate values in-between.
+  def initialize points = []
+    @pieces = { }
+    
+    points = points.sort_by {|p| p[0]}
+    
+    if points.count > 1
+      if points.is_a?(Hash)
+        points = points.to_a
+      end
+      
+      for i in 1...points.count
+        add_points points[i-1], points[i]
+      end
+    end
+  end
+  
+  def add_points prev_point, point
+    domain = prev_point[0]..point[0]
+    func = lambda do |x|
+      perc = (x - domain.min).to_f / (domain.max - domain.min)
+      y = Interpolation.linear prev_point[1], point[1], perc
+      return y
+    end
+    add_piece(domain, func)
+  end
+  
+  # Add a function piece, which covers the given domain (includes domain start 
+  # but not the end).
+  # @param [Range] domain The function domain. If this overlaps an existing domain,
+  #                       the existing domain will be split with the non-
+  #                       overlapping pieces kept and the overlapping old piece
+  #                       discarded.
+  def add_piece domain, func
+    
+    raise ArgumentError, "domain is not a Range" if !domain.is_a? Range
+    raise ArgumentError, "func is not a Proc" if !func.is_a? Proc
+    
+    contains_domain_completely = @pieces.select { |d,f| d.include?(domain.begin) && d.include?(domain.end) }
+    if contains_domain_completely.any?
+      contains_domain_completely.each do |d,f|
+        l = d.begin...domain.begin
+        if d.exclude_end?
+          r = domain.end...d.end
+        else
+          r = domain.end..d.end
+        end
+        
+        @pieces.delete d
+        
+        if domain.begin != d.begin
+          @pieces[l] = f
+        end
+        if domain.end == d.end
+          @pieces[domain.begin..domain.end] = func
+        else
+          @pieces[domain.begin...domain.end] = func
+          @pieces[r] = f
+        end
+      end
+    else
+      delete_completely = @pieces.select { |d,f| domain.include?(d.begin) && domain.include?(d.end) }
+      delete_completely.each do |d,f|
+        @pieces.delete d
+      end
+      
+      # should only be one
+      move_end = @pieces.select { |d,f| domain.include?(d.end) }
+      move_end.each do |d,f|
+        @pieces.delete d
+        @pieces[d.begin...domain.begin] = f
+      end
+      
+      # should only be one
+      move_begin = @pieces.select { |d,f| domain.include?(d.begin) }
+      move_begin.each do |d,f|
+        @pieces.delete d
+        if d.exclude_end?
+          @pieces[domain.end...d.end] = f
+        else
+          @pieces[domain.end..d.end] = f
+        end
+      end
+      
+      if move_begin.any?
+        @pieces[domain.begin...domain.end] = func
+      else
+        @pieces[domain] = func
+      end
+    end
+  end
+  
+  # Evaluate the piecewise function by finding a function piece whose domain 
+  # includes the given independent value.
+  def eval x
+    y = nil
+    
+    @pieces.each do |domain, func|
+      if domain.include? x
+        y = func.call x
+        break
+      end
+    end
+    
+    if y.nil?
+      raise ArgumentError, "The input #{x} is not in the domain."
+    end
+    
+    return y
+  end
+end
+
+end

data/lib/musicality/notation/util/value_computer.rb

@@ -0,0 +1,170 @@
+module Musicality
+
+# Given a start value, and value changes, compute the value at any offset.
+class ValueComputer
+  attr_reader :piecewise_function
+
+  def initialize start_value, value_changes = {}
+    @piecewise_function = PiecewiseFunction.new
+    set_default_value start_value
+    
+    if value_changes.any?
+      value_changes.sort.each do |offset,change|
+        
+        case change
+        when Change::Immediate
+          add_immediate_change change, offset
+        when Change::Gradual
+          add_linear_change change, offset
+        #  add_sigmoid_change change, offset
+        end
+        
+      end
+    end
+  end
+
+  # Compute the value at the given offset.
+  # @param [Numeric] offset The given offset to compute value at.
+  def value_at offset
+    @piecewise_function.eval offset
+  end
+  
+  def sample xmin, xmax, srate
+    sample_period = Rational(1,srate)
+    ((xmin.to_r)..(xmax.to_r)).step(sample_period).map do |x|
+      value_at(x)
+    end
+  end
+  
+  # finds the minimum domain value
+  def domain_min
+    -Float::INFINITY
+  end
+
+  # finds the maximum domain value
+  def domain_max
+    Float::INFINITY
+  end
+
+  # finds the minimum domain value
+  def self.domain_min
+    -Float::INFINITY
+  end
+
+  # finds the maximum domain value
+  def self.domain_max
+    Float::INFINITY
+  end
+
+  private
+
+  def set_default_value value
+    func = lambda {|x| value }
+    @piecewise_function.add_piece( domain_min..domain_max, func )
+  end
+  
+  # Add a function piece to the piecewise function, which will to compute value
+  # for a matching note offset. Transition duration will be ignored since the
+  # change is immediate.
+  #
+  # @param [ValueChange] value_change An event with information about the new value.
+  # @param [Numeric] offset
+  def add_immediate_change value_change, offset
+    func = nil
+    value = value_change.value
+    domain = offset..domain_max
+    func = lambda {|x| value }
+    
+    @piecewise_function.add_piece domain, func
+  end
+    
+  # Add a function piece to the piecewise function, which will to compute value
+  # for a matching note offset. If the dynamic event duration is non-zero, a 
+  # linear transition function is created.
+  #
+  # @param [ValueChange] value_change An event with information about the new value.
+  # @param [Numeric] offset
+  def add_linear_change value_change, offset
+    
+    func = nil
+    value = value_change.value
+    duration = value_change.duration
+    domain = offset..domain_max
+    
+    if duration == 0
+      add_immediate_change(value_change, offset)
+    else
+      b = @piecewise_function.eval domain.first
+      m = (value.to_f - b.to_f) / duration.to_f
+      
+      func = lambda do |x|
+        raise RangeError, "#{x} is not in the domain" if !domain.include?(x)
+        
+        if x < (domain.first + duration)
+          (m * (x - domain.first)) + b
+        else
+          value
+        end
+      end
+      @piecewise_function.add_piece domain, func
+    end
+  end
+
+  # Add a function piece to the piecewise function, which will to compute value
+  # for a matching note offset. If the dynamic event duration is non-zero, a 
+  # linear transition function is created.
+  #
+  # @param [ValueChange] value_change An event with information about the new value.
+  # @param [Numeric] offset
+  def add_sigmoid_change value_change, offset
+    
+    func = nil
+    start_value = @piecewise_function.eval offset
+    end_value = value_change.value
+    value_diff = end_value - start_value
+    duration = value_change.duration
+    domain = offset.to_f..domain_max
+    abruptness = 0.7 # value_change.transition.abruptness.to_f
+
+    if duration == 0
+      add_immediate_change(value_change,offset)
+    else
+      raise ArgumentError, "abruptness is not between 0 and 1" unless abruptness.between?(0,1)
+      
+      min_magn = 2
+      max_magn = 6
+      tanh_domain_magn = abruptness * (max_magn - min_magn) + min_magn
+      tanh_domain = -tanh_domain_magn..tanh_domain_magn
+
+      tanh_range = Math::tanh(tanh_domain.first)..Math::tanh(tanh_domain.last)
+      tanh_span = tanh_range.last - tanh_range.first
+
+      func = lambda do |x|
+        raise RangeError, "#{x} is not in the domain" if !domain.include?(x)
+          if x < (domain.first + duration)
+            start_domain = domain.first...(domain.first + duration)
+            x2 = transform_domains(start_domain, tanh_domain, x)
+            y = Math::tanh x2
+            z = (y / tanh_span) + 0.5 # ranges from 0 to 1
+            start_value + (z * value_diff)
+          else
+            end_value
+          end
+      end
+      @piecewise_function.add_piece domain, func
+    end
+  end
+
+  # x should be in the start domain 
+  def transform_domains start_domain, end_domain, x
+    perc = (x - start_domain.first) / (start_domain.last - start_domain.first).to_f
+    x2 = perc * (end_domain.last - end_domain.first) + end_domain.first
+  end
+
+  # 0 to 1
+  def logistic x
+    1.0 / (1 + Math::exp(-x))
+  end
+end
+
+end

data/lib/musicality/performance/conversion/glissando_converter.rb

@@ -0,0 +1,34 @@
+module Musicality
+
+class GlissandoConverter
+  def self.glissando_pitches(start_pitch, target_pitch)
+    start, finish = start_pitch.total_semitones, target_pitch.total_semitones
+    if finish >= start
+      semitones = start.ceil.upto(finish.floor).to_a
+    else
+      semitones = start.floor.downto(finish.ceil).to_a
+    end
+    
+    if semitones.empty? || semitones[0] != start
+      semitones.unshift(start)
+    end
+    
+    if semitones.size > 1 && semitones[-1] == finish
+      semitones.pop
+    end
+    
+    semitones.map do |semitone|
+      Pitch.from_semitones(semitone)
+    end
+  end
+
+  def self.glissando_elements(start_pitch, target_pitch, duration, accented)
+    pitches = glissando_pitches(start_pitch, target_pitch)
+    subdur = Rational(duration, pitches.size)
+    pitches.map do |pitch|
+      LegatoElement.new(subdur, pitch, accented)
+    end
+  end
+end
+
+end

data/lib/musicality/performance/conversion/note_sequence_extractor.rb

@@ -0,0 +1,98 @@
+module Musicality
+
+class NoteSequenceExtractor
+  # For all link types:
+  #  - Remove link where source pitch is not in current note
+  # For tie:
+  #  - Remove any bad tie (where the tying pitch does not exist in the next note).
+  #  - Replace any good tie with a slur.
+  # For slur/legato:
+  #  - Remove any bad link (where the target pitch does not exist in the next note).
+  # TODO: what to do about multiple links that target the same pitch?
+  def self.fixup_links note, next_note
+    note.links.each do |pitch, link|
+      if !note.pitches.include?(pitch)
+        note.links.delete pitch
+      elsif link.is_a? Link::Tie
+        if next_note.pitches.include? pitch
+          note.links[pitch] = Link::Slur.new(pitch)
+        else
+          note.links.delete pitch
+        end
+      elsif (link.is_a?(Link::Slur) ||
+             link.is_a?(Link::Legato))
+        unless next_note.pitches.include? link.target_pitch
+          note.links.delete pitch
+        end
+      end
+    end
+  end
+
+  def self.replace_articulation note, next_note
+    case note.articulation
+    when Articulations::SLUR
+      NoteLinker.fully_link(note, next_note, Link::Slur)
+      note.articulation = Articulations::NORMAL
+    when Articulations::LEGATO
+      NoteLinker.fully_link(note, next_note, Link::Legato)
+      note.articulation = Articulations::NORMAL
+    end
+  end
+
+  attr_reader :notes
+  def initialize notes, cents_per_step = 10
+    @cents_per_step = cents_per_step
+    @notes = notes.map {|n| n.clone }
+
+    @notes.push Note.quarter
+    (@notes.size-1).times do |i|
+      NoteSequenceExtractor.fixup_links(@notes[i], @notes[i+1])
+      NoteSequenceExtractor.replace_articulation(@notes[i], @notes[i+1])
+    end
+    @notes.pop
+  end
+
+  def extract_sequences
+    sequences = []
+    offset = 0
+
+    @notes.each_index do |i|
+      while @notes[i].pitches.any?
+        elements = []
+
+        j = i
+        loop do
+          note = @notes[j]
+          pitch = note.pitches.pop
+          dur = note.duration
+          accented = note.accented
+          link = note.links[pitch]
+
+          case link
+          when Link::Slur
+            elements.push(SlurredElement.new(dur, pitch, accented))
+          when Link::Legato
+            elements.push(LegatoElement.new(dur, pitch, accented))
+          when Link::Glissando
+            elements += GlissandoConverter.glissando_elements(pitch, link.target_pitch, dur, accented)
+          when Link::Portamento
+            elements += PortamentoConverter.portamento_elements(pitch, link.target_pitch, @cents_per_step, dur, accented)
+          else
+            elements.push(FinalElement.new(dur, pitch, accented, note.articulation))
+            break
+          end
+
+          j += 1
+          break if j >= @notes.size || !@notes[j].pitches.include?(link.target_pitch)
+        end
+
+        sequences.push(NoteSequence.from_elements(offset,elements))
+      end
+      offset += @notes[i].duration
+    end
+
+    return sequences
+  end
+end
+
+end

data/lib/musicality/performance/conversion/portamento_converter.rb

@@ -0,0 +1,24 @@
+module Musicality
+
+class PortamentoConverter
+  def self.portamento_pitches(start_pitch, target_pitch, cents_per_step)
+    start, finish = start_pitch.total_cents, target_pitch.total_cents
+    step_size = finish >= start ? cents_per_step : -cents_per_step
+    nsteps = ((finish - 1 - start) / step_size.to_f).ceil
+    cents = Array.new(nsteps+1){|i| start + i * step_size }
+    
+    cents.map do |cent|
+      Pitch.new(cent: cent)
+    end
+  end
+
+  def self.portamento_elements(start_pitch, target_pitch, cents_per_step, duration, accented)
+    pitches = portamento_pitches(start_pitch, target_pitch, cents_per_step)
+    subdur = Rational(duration, pitches.size)
+    pitches.map do |pitch|
+      SlurredElement.new(subdur, pitch, accented)
+    end
+  end
+end
+
+end

data/lib/musicality/performance/conversion/score_collator.rb

@@ -0,0 +1,126 @@
+module Musicality
+
+class ScoreNotValidError < StandardError; end
+
+# Combine multiple program segments to one, using tempo/note/dynamic
+# replication and truncation where necessary.
+class ScoreCollator
+  def initialize score
+    unless score.valid?
+      raise ScoreNotValidError, "errors found in score: #{score.errors}"
+    end
+    @score = score
+  end
+  
+  def collate_parts
+    segments = @score.program.segments
+    
+    Hash[
+      @score.parts.map do |name, part|
+	new_dcs = collate_changes(part.start_dynamic,
+	  part.dynamic_changes, segments)
+	new_notes = collate_notes(part.notes, segments)
+	new_part = Part.new(part.start_dynamic,
+	  dynamic_changes: new_dcs, notes: new_notes)
+	[ name, new_part ]
+      end
+    ]
+  end
+  
+  def collate_tempo_changes
+    collate_changes(@score.start_tempo,
+      @score.tempo_changes, @score.program.segments)
+  end
+  
+  def collate_meter_changes
+    collate_changes(@score.start_meter,
+      @score.meter_changes, @score.program.segments)
+  end
+  
+  private
+  
+  def collate_changes start_value, changes, program_segments
+    new_changes = {}
+    comp = ValueComputer.new(start_value,changes)
+    segment_start_offset = 0.to_r
+    
+    program_segments.each do |seg|
+      seg = seg.first...seg.last
+      
+      # add segment start value
+      value = comp.value_at seg.first
+      new_changes[segment_start_offset] = Change::Immediate.new(value)
+      
+      # add any immediate changes in segment
+      changes.select {|o,c| c.is_a?(Change::Immediate) && seg.include?(o) }.each do |off,c|
+	new_changes[(off - seg.first) + segment_start_offset] = c.clone
+      end
+      
+      # add gradual changes
+      changes.select {|o,c| c.is_a?(Change::Gradual)}.each do |off, change|
+	adj_start_off = (off - seg.first) + segment_start_offset
+	end_off = off + change.duration
+	if seg.include?(off) # change that are wholly included in segment
+	  if end_off <= seg.last
+	    new_changes[adj_start_off] = change.clone
+	  else # change that overlap segment end
+	    over = end_off - seg.last
+	    new_changes[adj_start_off] = Change::Gradual.new(change.value,
+	      change.duration - over, change.elapsed, change.remaining + over)
+	  end
+	elsif end_off > seg.first && end_off < seg.last # change that overlap segment start
+	  under = seg.first - off
+	  new_changes[segment_start_offset] = Change::Gradual.new(change.value,
+	    change.duration - under, change.elapsed + under, change.remaining)
+	end
+      end
+    end
+    
+    return new_changes
+  end
+  
+  def collate_notes notes, program_segments
+    new_notes = []
+    program_segments.each do |seg|
+      cur_offset = 0
+      cur_notes = []
+      
+      l = 0
+      while cur_offset < seg.first && l < notes.size
+        cur_offset += notes[l].duration
+        l += 1
+      end
+      
+      pre_remainder = cur_offset - seg.first
+      if pre_remainder > 0
+        cur_notes << Note.new(pre_remainder)
+      end
+      
+      # found some notes to add...
+      if l < notes.size
+        r = l
+        while cur_offset < seg.last && r < notes.size
+          cur_offset += notes[r].duration
+          r += 1
+        end
+        
+        cur_notes += Marshal.load(Marshal.dump(notes[l...r]))
+        overshoot = cur_offset - seg.last
+        if overshoot > 0
+          cur_notes[-1].duration -= overshoot
+          cur_offset = seg.last
+        end
+      end
+      
+      post_remainder = seg.last - cur_offset
+      if post_remainder > 0
+        cur_notes << Note.new(post_remainder)
+      end
+        
+      new_notes.concat cur_notes
+    end
+    return new_notes
+  end
+end
+
+end

data/lib/musicality/performance/midi/midi_events.rb

@@ -0,0 +1,34 @@
+module Musicality
+
+class MidiEvent
+  def <=> other
+    ORDERING[self] <=> ORDERING[other]
+  end
+  
+  class NoteOn < MidiEvent
+    attr_reader :notenum, :accented
+    def initialize notenum, accented
+      @notenum, @accented = notenum, accented
+    end
+  end
+  
+  class NoteOff < MidiEvent
+    attr_reader :notenum
+    def initialize notenum
+      @notenum = notenum
+    end
+  end
+  
+  class Expression < MidiEvent
+    attr_reader :volume
+    def initialize volume
+      @volume = volume
+    end
+  end
+  
+  ORDERING = {
+    NoteOff => 0, Expression => 1, NoteOn => 2
+  }
+end
+
+end

data/lib/musicality/performance/midi/midi_util.rb

@@ -0,0 +1,31 @@
+module Musicality
+
+class MidiUtil
+  QUARTER = Rational(1,4)    
+  # Number of pulses equivalent to the given duration
+  def self.delta duration, ppqn
+    pulses = (duration / QUARTER) * ppqn
+    return pulses.round
+  end
+  
+  p0 = Pitch.new(octave:-1,semitone:0)
+  MIDI_NOTENUMS = Hash[
+    (0..127).map do |note_num|
+      [ p0.transpose(note_num), note_num ]
+    end
+  ]
+  
+  def self.pitch_to_notenum pitch
+    MIDI_NOTENUMS.fetch(pitch.round)
+  end
+  
+  def self.dynamic_to_volume dynamic
+    (dynamic * 127).round
+  end
+  
+  def self.note_velocity(accented)
+    accented ? 112 : 70
+  end
+end
+
+end