music-performance 0.2.1

data/lib/music-performance/model/note_sequence.rb

@@ -0,0 +1,113 @@
+module Music
+module Performance
+
+SlurredElement = Struct.new(:duration, :pitch, :accented) do
+  def slurred?; true; end
+  def articulation; Music::Transcription::Articulations::NORMAL; end
+  def accented?; accented; end
+end
+
+LegatoElement = Struct.new(:duration, :pitch, :accented) do
+  def slurred?; false; end
+  def articulation; Music::Transcription::Articulations::NORMAL; end
+  def accented?; accented; end
+end
+
+FinalElement = Struct.new(:duration, :pitch, :accented, :articulation) do
+  def slurred?; false; end
+  def accented?; accented; end
+end
+
+class NoteSequence
+  def self.adjust_duration duration, articulation
+    x = duration
+    y = Math.log2(x)
+
+    case articulation
+    when Music::Transcription::Articulations::TENUTO
+      x
+    when Music::Transcription::Articulations::PORTATO
+      x / (1 + 2**(y-1))
+    when Music::Transcription::Articulations::STACCATO
+      x / (1 + 2**(y))
+    when Music::Transcription::Articulations::STACCATISSIMO
+      x / (1 + 2**(y+1))
+    else
+      x - (1/16.0)*(1/(1+2**(-y)))
+    end
+  end
+
+  attr_reader :start, :stop, :pitches, :attacks
+  def initialize start, stop, pitches, attacks
+    if start >= stop
+      raise ArgumentError, "start #{start} is not less than stop #{stop}"
+    end
+    
+    if pitches.empty?
+      raise ArgumentError, "no pitches given (at least one pitch is required at start offset)"
+    end
+    
+    unless pitches.has_key?(start)
+      raise ArgumentError, "no start pitch given"
+    end
+    
+    pitches.keys.each do |offset|
+      unless offset.between?(start,stop)
+        raise ArgumentError, "pitch offset #{offset} is not between start #{start} and stop #{stop}"
+      end
+    end
+    
+    if attacks.empty?
+      raise ArgumentError, "no attacks given (at least one is required at start offset)"
+    end
+    
+    unless attacks.has_key?(start)
+      raise ArgumentError, "no start attack given"
+    end
+    
+    attacks.keys.each do |offset|
+      unless offset.between?(start,stop)
+        raise ArgumentError, "attack offset #{offset} is not between start #{start} and stop #{stop}"
+      end
+    end
+    
+    @start, @stop = start, stop
+    @pitches, @attacks = pitches, attacks
+  end
+    
+  def self.from_elements offset, elements
+    pitches = {}
+    attacks = {}
+    start = offset
+    
+    if elements.empty?
+      raise ArgumentError, "no elements given"
+    end
+      
+    last = elements.last
+    skip_attack = false
+    elements.each do |el|
+      if skip_attack
+        unless pitches.max[1] == el.pitch
+          pitches[offset] = el.pitch
+        end
+      else
+        pitches[offset] = el.pitch
+        attacks[offset] = el.accented ? ACCENTED : UNACCENTED        
+      end      
+      skip_attack = el.slurred?
+      
+      unless el.equal?(last)
+        offset += el.duration
+      end
+    end
+    stop = offset + NoteSequence.adjust_duration(last.duration, last.articulation)
+    
+    new(start, stop, pitches, attacks)
+  end
+
+  def duration; @stop - @start; end
+end
+
+end
+end

data/lib/music-performance/util/interpolation.rb

@@ -0,0 +1,18 @@
+module Music
+module Performance
+
+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
+end

data/lib/music-performance/util/note_linker.rb

@@ -0,0 +1,30 @@
+module Music
+module Performance
+
+class NoteLinker
+  def self.find_unlinked_pitches note
+    linked = Set.new(note.pitches) & note.links.keys
+    (Set.new(note.pitches) - linked).to_a
+  end
+  
+  def self.find_untargeted_pitches note, next_note
+    linked = Set.new(note.pitches) & note.links.keys
+    targeted = Set.new(linked.map {|p| note.links[p].target_pitch })
+    (Set.new(next_note.pitches) - targeted).to_a
+  end
+  
+  def self.figure_links note, next_note
+    unlinked = find_unlinked_pitches(note)
+    untargeted = find_untargeted_pitches(note, next_note)
+    Optimization.linking(unlinked, untargeted)
+  end
+  
+  def self.fully_link note, next_note, link_class
+    figure_links(note,next_note).each do |pitch,tgt_pitch|
+      note.links[pitch] = link_class.new(tgt_pitch)
+    end
+  end  
+end
+
+end
+end

data/lib/music-performance/util/optimization.rb

@@ -0,0 +1,33 @@
+module Music
+module Performance
+
+module Optimization
+  def self.linking unlinked, untargeted
+    n = [unlinked.size, untargeted.size].min
+    
+    bestsol = nil
+    bestscore = Float::INFINITY
+    unlinked.combination(n).each do |comb|
+      untargeted.permutation(n).each do |perm|
+        score = 0
+        n.times do |i|
+          score += perm[i].diff(comb[i]).abs
+        end
+        
+        if score < bestscore
+          bestsol = [ comb, perm ]
+          bestscore = score
+        end
+      end
+    end
+    
+    solution = {}
+    n.times do |i|
+      solution[ bestsol[0][i] ] = bestsol[1][i]
+    end
+    return solution
+  end
+end
+
+end
+end

data/lib/music-performance/util/piecewise_function.rb

@@ -0,0 +1,124 @@
+module Music
+module Performance
+
+# 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
+end

data/lib/music-performance/util/value_computer.rb

@@ -0,0 +1,172 @@
+module Music
+module Performance
+
+# 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 Music::Transcription::Change::Immediate
+          add_immediate_change change, offset
+        when Music::Transcription::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
+end