musicality 0.8.0 → 0.9.0

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

@@ -6,14 +6,22 @@ grammar Note
   include Articulation
   include Link
   include Duration
+  include Mark
 
   rule note
+    begin_marks:(
+      (first:begin_triplet second:begin_slur?) / 
+      (first:begin_slur second:begin_triplet?)
+    )?
     duration
     more:(
       first_pl:pitch_link
       more_pl:("," pl:pitch_link)*
       art:articulation?
-      acc:accent?
+    )?
+    end_marks:(
+      (first:end_triplet second:end_slur?) / 
+      (first:end_slur second:end_triplet?)
     )?
     <NoteNode>
   end
@@ -21,10 +29,6 @@ grammar Note
   rule pitch_link
     pitch the_link:link?
   end
-  
-  rule accent
-    "!"
-  end
 end
 
 end

data/lib/musicality/notation/parsing/numbers/nonnegative_integer_parsing.rb

@@ -45,8 +45,13 @@ module NonnegativeInteger
         break
       end
     end
-    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-    r0.extend(NonnegativeInteger0)
+    if s0.empty?
+      @index = i0
+      r0 = nil
+    else
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(NonnegativeInteger0)
+    end
 
     node_cache[:nonnegative_integer][start_index] = r0
 

data/lib/musicality/notation/parsing/numbers/nonnegative_integer_parsing.treetop

@@ -3,7 +3,7 @@ module Parsing
 
 grammar NonnegativeInteger
   rule nonnegative_integer
-    [0-9]* {
+    [0-9]+ {
       def to_i
         text_value.to_i
       end

data/lib/musicality/notation/parsing/numbers/positive_integer_parsing.rb

@@ -14,9 +14,6 @@ module PositiveInteger
   include NonnegativeInteger
 
   module PositiveInteger0
-    def nonnegative_integer
-      elements[2]
-    end
   end
 
   module PositiveInteger1
@@ -66,7 +63,12 @@ module PositiveInteger
       end
       s0 << r3
       if r3
-        r4 = _nt_nonnegative_integer
+        r5 = _nt_nonnegative_integer
+        if r5
+          r4 = r5
+        else
+          r4 = instantiate_node(SyntaxNode,input, index...index)
+        end
         s0 << r4
       end
     end

data/lib/musicality/notation/parsing/numbers/positive_integer_parsing.treetop

@@ -5,7 +5,7 @@ grammar PositiveInteger
   include NonnegativeInteger
   
   rule positive_integer
-    [0]* [1-9] nonnegative_integer {
+    [0]* [1-9] nonnegative_integer? {
       def to_i
         text_value.to_i
       end

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

@@ -13,15 +13,41 @@ class Function
     return perc * (end_domain.last - end_domain.first) + end_domain.first
   end
 
+  attr_reader :domain
+  def initialize domain = (DOMAIN_MIN...DOMAIN_MAX), memoize: true, &at_block
+    raise ArgumentError unless domain.last > domain.first
+    @domain = domain
+    raise ArgumentError unless block_given?
+    raise ArgumentError unless at_block.arity == 1
+    @at_block = at_block
+
+    @memoize = memoize
+    @memoized = {}
+  end
+
+  def at(x)
+    raise DomainError unless @domain.include?(x)
+    if @memoize
+      if @memoized.has_key? x
+        @memoized[x]
+      else
+        @memoized[x] = @at_block.call(x)
+      end
+    else
+      @at_block.call(x)
+    end
+  end
+
+  def ==(other)
+    @domain == other.domain
+  end
+
   class Constant < Function
     attr_reader :value
     
     def initialize value
       @value = value
-    end
-    
-    def at(x)
-      @value
+      super() {|x| @value }
     end
     
     def ==(other)
@@ -35,10 +61,8 @@ class Function
     def initialize p1,p2
       @slope = (p2[1] - p1[1])/(p2[0] - p1[0]).to_f
       @intercept = p1[1] - @slope * p1[0]
-    end
-    
-    def at(x)
-      x * @slope + @intercept
+
+      super() {|x| x * @slope + @intercept }
     end
     
     def ==(other)
@@ -59,24 +83,23 @@ class Function
     SIGM_RANGE = Sigmoid.sigm(SIGM_DOMAIN.first)..Sigmoid.sigm(SIGM_DOMAIN.last)
     SIGM_SPAN = SIGM_RANGE.last - SIGM_RANGE.first
     
-    attr_reader :y0, :dy, :domain
+    attr_reader :y0, :dy
     def initialize p0, p1
       @y0, y1 = p0[1], p1[1]
       @dy = y1 - @y0
-      @domain = p0[0]..p1[0]
-    end
-    
-    def at(x)
-      x_ = Function.transform_domains(@domain, SIGM_DOMAIN, x)
-      y_ = (Sigmoid.sigm(x_) - SIGM_RANGE.first) / SIGM_SPAN
-      y = @y0 + y_ * @dy
-      return y
+      @external_domain = p0[0]..p1[0]
+
+      super() do |x|
+        x_ = Function.transform_domains(@external_domain, SIGM_DOMAIN, x)
+        y_ = (Sigmoid.sigm(x_) - SIGM_RANGE.first) / SIGM_SPAN
+        @y0 + y_ * @dy
+      end
     end
     
     #def from(y)
     #  y2 = (y - @y0) / @dy
     #  x2 = Sigmoid.inv_sigm(y2 * SIGM_SPAN + SIGM_RANGE.first)
-    #  x = Function.transform_domains(SIGM_DOMAIN, @domain, x2)
+    #  x = Function.transform_domains(SIGM_DOMAIN, @external_domain, x2)
     #  return x
     #end
     

data/lib/musicality/packable.rb

@@ -0,0 +1,156 @@
+# Requires that an including class can be instantiated entirely by keyword 
+# args that map these symbols to values
+module Packable
+  PACKED_CLASS_KEY = :packed_class
+
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.class_variable_set(:@@special_packing, {})
+    base.class_variable_set(:@@special_unpacking, {})
+  end
+
+  module ClassMethods
+    def unpack packing
+      args = []
+      kwargs = {}
+
+      init_params.each do |name,type|
+        if (type == :req || type == :keyreq) && !packing.has_key?(name)
+          raise ArgumentError, "Packing does not have required key #{name}"
+        end
+
+        val = packing[name]
+        if type == :keyrest
+          raise "Expected this to be a Hash" unless val.is_a? Hash
+        end
+
+        val2 = if unpacks_specially?(name)
+          unpack_specially(name,val)
+        else
+          Packable.unpack_val(val)
+        end
+
+        case type
+        when :req, :opt
+          args.push val2
+        when :key, :keyreq
+          kwargs[name] = val2
+        when :keyrest
+          kwargs.merge!(val2)
+        end
+      end
+      
+      if args.any?
+        if kwargs.any?
+          obj = new(*args,**kwargs)
+        else
+          obj = new(*args)
+        end
+      elsif kwargs.any?
+        obj = new(**kwargs)
+      else
+        obj = new
+      end
+
+      block_given? ? yield(obj) : obj
+    end
+
+    def init_params
+      params = instance_method(:initialize).parameters
+      Hash[ params.map {|pair| pair.reverse } ]
+    end
+    
+    def special_packing sym, &block
+      class_variable_get(:@@special_packing)[sym] = block
+    end
+
+    def special_unpacking sym, &block
+      class_variable_get(:@@special_unpacking)[sym] = block
+    end
+    
+    def packs_specially? sym
+      class_variable_get(:@@special_packing).has_key?(sym)
+    end
+
+    def unpacks_specially? sym
+      class_variable_get(:@@special_unpacking).has_key?(sym)
+    end
+
+    def pack_specially sym, val
+      class_variable_get(:@@special_packing)[sym].call(val)
+    end
+
+    def unpack_specially sym, val
+      class_variable_get(:@@special_unpacking)[sym].call(val)
+    end
+  end
+
+  def init_params
+    self.class.init_params
+  end
+  
+  def class_str
+    self.class.to_s
+  end
+
+  def pack
+    packing = { PACKED_CLASS_KEY => class_str }
+    init_params.keys.each do |name|
+      val = self.send(name)
+      val2 = if self.class.packs_specially?(name)
+        self.class.pack_specially(name,val)
+      else
+        Packable.pack_val(val)
+      end
+      packing[name] = val2
+    end
+    packing
+  end
+
+  def recover_class klass_str
+    Kernel.const_get(klass_str)
+  end
+  module_function :recover_class
+
+  private
+
+  def unpack_val val
+    if val.is_a? Array
+      val.map {|v| Packable.unpack_val v}
+    elsif val.is_a? Hash
+      if val.packed_class?
+        val.unpack
+      else
+        Hash[ val.map {|k,v| [ Packable.unpack_val(k), Packable.unpack_val(v) ]} ]
+      end
+    else
+      val
+    end
+  end
+  module_function :unpack_val
+
+  def pack_val val
+    if val.is_a?(Packable)
+      val.pack
+    elsif val.is_a? Array
+      val.map {|v| pack_val v}
+    elsif val.is_a? Hash
+      Hash[ val.map {|k,v| [ Packable.pack_val(k), Packable.pack_val(v) ]} ]
+    else
+      val
+    end
+  end
+  module_function :pack_val  
+end
+
+class Hash
+  def packed_class?
+    has_key?(Packable::PACKED_CLASS_KEY) && 
+      Packable.recover_class(fetch(Packable::PACKED_CLASS_KEY)).included_modules.include?(Packable)
+  end
+
+  def unpack
+    raise "Not a packed class" unless packed_class?
+    Packable.recover_class(fetch(Packable::PACKED_CLASS_KEY)).unpack self
+  end
+end

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

@@ -22,11 +22,11 @@ class GlissandoConverter
     end
   end
 
-  def self.glissando_elements(start_pitch, target_pitch, duration, accented)
+  def self.glissando_elements(start_pitch, target_pitch, duration, attack)
     pitches = glissando_pitches(start_pitch, target_pitch)
     subdur = Rational(duration, pitches.size)
     pitches.map do |pitch|
-      LegatoElement.new(subdur, pitch, accented)
+      NoteSequence::Element.new(subdur, pitch, attack)
     end
   end
 end

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

@@ -1,97 +1,250 @@
 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)
+  attr_reader :notes
+  def initialize notes
+    prepare_notes(notes)
+    mark_slurring
+    remove_bad_links
+    calculate_offsets
+    establish_maps
+    # now, ready to extract sequences!
+  end
+  
+  def extract_sequences cents_per_step = 10
+    return [] if @notes.empty?
+    
+    next_seqs = seqs_from_note(@notes.size-1, cents_per_step)
+    return next_seqs if @notes.one?
+    
+    complete_seqs = []
+    (@notes.size-2).downto(0) do |i|
+      cur_seqs = seqs_from_note(i, cents_per_step)
+      map = @maps[i]
+      
+      next_seqs.each do |next_seq|
+        p1 = nil
+        p2 = next_seq.elements.first.pitch
+        if p1 = map[:ties].key(p2)
+          cur_seq = cur_seqs.find {|x| x.elements.first.pitch == p1 }
+          NoteSequenceExtractor.tie_seqs(cur_seq, next_seq)
+        elsif p1 = map[:slurs].key(p2)
+          cur_seq = cur_seqs.find {|x| x.elements.first.pitch == p1 }
+          NoteSequenceExtractor.slur_seqs(cur_seq, next_seq)
+        elsif p1 = map[:full_glissandos].key(p2)
+          cur_seq = cur_seqs.find {|x| x.elements.first.pitch == p1 }
+          NoteSequenceExtractor.glissando_seqs(cur_seq, next_seq)
+        elsif p1 = map[:full_portamentos].key(p2)
+          cur_seq = cur_seqs.find {|x| x.elements.first.pitch == p1 }
+          NoteSequenceExtractor.portamento_seqs(cur_seq, next_seq, cents_per_step)
         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
+          complete_seqs.push next_seq
         end
+      end      
+      next_seqs = cur_seqs
+    end
+    complete_seqs += next_seqs
+    return complete_seqs
+  end
+  
+  private
+  
+  def self.tie_seqs(cur_seq, next_seq)
+    cur_seq.elements.last.duration += next_seq.elements.first.duration
+    cur_seq.elements += next_seq.elements[1..-1]
+  end
+  
+  def self.slur_seqs(cur_seq, next_seq)
+    if next_seq.elements.first.attack == Attack::NORMAL
+      next_seq.elements.first.attack = Attack::NONE
+    end
+    cur_seq.separation = next_seq.separation
+    cur_seq.elements += next_seq.elements
+  end
+
+  def self.glissando_seqs(cur_seq, next_seq)
+    cur_seq.elements = GlissandoConverter.glissando_elements(cur_seq.last_pitch,
+      next_seq.first_pitch, cur_seq.full_duration, cur_seq.last_attack)
+    cur_seq.separation = next_seq.separation
+    cur_seq.elements += next_seq.elements
+  end
+
+  def self.portamento_seqs(cur_seq, next_seq, cents_per_step)
+    cur_seq.elements = PortamentoConverter.portamento_elements(cur_seq.last_pitch,
+      next_seq.first_pitch, cents_per_step, cur_seq.full_duration, cur_seq.last_attack)
+    cur_seq.separation = Separation::NONE
+    cur_seq.elements += next_seq.elements    
+  end
+  
+  def seqs_from_note(idx, cents_per_step)
+    map = @maps[idx]
+    note = @notes[idx]
+    attack = NoteSequenceExtractor.note_attack(note.articulation)
+    separation = NoteSequenceExtractor.note_separation(note.articulation, @slurring_flags[idx])
+    offset = @offsets[idx]
+    note.pitches.map do |p|
+      if map[:half_glissandos].has_key?(p)
+        NoteSequence.new(offset, separation, 
+          GlissandoConverter.glissando_elements(
+            p, map[:half_glissandos][p], note.duration, attack))
+      elsif map[:half_portamentos].has_key?(p)
+        NoteSequence.new(offset, Separation::NONE, 
+          PortamentoConverter.portamento_elements(
+            p, map[:half_portamentos][p], cents_per_step, note.duration, attack))
+      else
+        NoteSequence.new(offset, separation,
+          [NoteSequence::Element.new(note.duration, p, attack)])
       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
+  def self.note_attack articulation
+    case articulation
+    when Articulations::NORMAL then Attack::NORMAL
+    when Articulations::TENUTO then Attack::TENUTO
+    when Articulations::ACCENT then Attack::ACCENT
+    when Articulations::MARCATO then Attack::ACCENT
+    when Articulations::PORTATO then Attack::NORMAL
+    when Articulations::STACCATO then Attack::NORMAL
+    when Articulations::STACCATISSIMO then Attack::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 }
+  def self.note_separation articulation, under_slur
+    if under_slur
+      case articulation
+      when Articulations::NORMAL then Separation::NONE
+      when Articulations::TENUTO then Separation::NONE
+      when Articulations::ACCENT then Separation::NONE
+      when Articulations::MARCATO then Separation::PORTATO
+      when Articulations::PORTATO then Separation::NORMAL
+      when Articulations::STACCATO then Separation::PORTATO
+      when Articulations::STACCATISSIMO then Separation::STACCATO
+      end
+    else
+      case articulation
+      when Articulations::NORMAL then Separation::NORMAL
+      when Articulations::TENUTO then Separation::TENUTO
+      when Articulations::ACCENT then Separation::NORMAL
+      when Articulations::MARCATO then Separation::NORMAL
+      when Articulations::PORTATO then Separation::PORTATO
+      when Articulations::STACCATO then Separation::STACCATO
+      when Articulations::STACCATISSIMO then Separation::STACCATISSIMO
+      end
+    end
+  end
+
+  def prepare_notes notes
+    in_triplet = false
+    @notes = Array.new(notes.size) do |i|
+      note = notes[i]
+
+      if note.begins_triplet?
+        in_triplet = true
+      end
+      
+      new_note = in_triplet ? note.resize(note.duration * Rational(2,3)) : note.clone
+
+      if note.ends_triplet?
+        in_triplet = false
+      end
 
-    @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])
+      new_note
     end
-    @notes.pop
   end
 
-  def extract_sequences
-    sequences = []
-    offset = 0
+  def mark_slurring
+    @slurring_flags = []
+    under_slur = false
+    
+    @slurring_flags = Array.new(@notes.size) do |i|
+      note = @notes[i]
 
-    @notes.each_index do |i|
-      while @notes[i].pitches.any?
-        elements = []
+      if note.begins_slur? && !note.ends_slur?
+        under_slur = true
+      end
+      flag = under_slur
 
-        j = i
-        loop do
-          note = @notes[j]
-          pitch = note.pitches.pop
-          dur = note.duration
-          accented = note.accented
-          link = note.links[pitch]
+      if note.ends_slur? && !note.begins_slur?
+        under_slur = false
+      end
+      flag
+    end
+  end
 
-          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)
+  def remove_bad_links
+    @notes.each_with_index do |n,i|
+      # create a dummy note (with no pitches) for checking links from the last note
+      n2 = (i == (@notes.size-1)) ? Note.quarter : @notes[i+1]
+      n.links.delete_if do |p,l|
+        !n.pitches.include?(p) || (l.is_a?(Link::Tie) && !n2.pitches.include?(p))
+      end
+    end
+  end
+    
+  def calculate_offsets
+    offset = 0.to_r
+    @offsets = Array.new(@notes.size) do |i|
+      cur_offset = offset
+      offset += @notes[i].duration
+      cur_offset
+    end
+  end
+  
+  def self.no_separation?(articulation, under_slur)
+    under_slur && (
+      articulation == Articulations::NORMAL ||
+      articulation == Articulations::TENUTO ||
+      articulation == Articulations::ACCENT
+    )
+  end
+  
+  def establish_maps
+    @maps = []
+    
+    @notes.each_index do |i|
+      map = { :ties => {}, :slurs => {}, :full_glissandos => {}, 
+        :full_portamentos => {}, :half_glissandos => {}, 
+        :half_portamentos => {}}
+      note = @notes[i]
+      
+      # Create a dummy note (with no pitches) for the last note to "link" to.
+      # This will allow half glissandos and half portamentos from the last note
+      next_note = (i == (@notes.size-1)) ? Note.quarter : @notes[i+1]
+      
+      no_separation = NoteSequenceExtractor.no_separation?(note.articulation, @slurring_flags[i])
+      
+      linked = note.pitches & note.links.keys
+      linked.each do |p|
+        l = note.links[p]
+        if l.is_a?(Link::Tie)
+          map[:ties][p] = p
+        elsif l.is_a?(Link::Glissando)
+          if next_note.pitches.include?(l.target_pitch)
+            map[:full_glissandos][p] = l.target_pitch
           else
-            elements.push(FinalElement.new(dur, pitch, accented, note.articulation))
-            break
+            map[:half_glissandos][p] = l.target_pitch
+          end
+        elsif l.is_a?(Link::Portamento)
+          if next_note.pitches.include?(l.target_pitch)
+            map[:full_portamentos][p] = l.target_pitch
+          else
+            map[:half_portamentos][p] = l.target_pitch
           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
+      
+      if(no_separation)
+        unlinked = note.pitches - linked
+        target_pitches = note.links.map {|p,l| l.is_a?(Link::Tie) ? p : l.target_pitch }
+        untargeted = next_note.pitches - target_pitches
+        Optimization.linking(unlinked, untargeted).each do |pitch,tgt_pitch|
+          map[:slurs][pitch] = tgt_pitch
+        end
+      end
+      
+      @maps.push map
     end
-
-    return sequences
   end
 end