musicality 0.8.0 → 0.9.0

data/lib/musicality/{composition/model/pitch_class.rb → pitch_class.rb}

@@ -1,7 +1,7 @@
 module Musicality
 
 class PitchClass
-  MOD = Pitch::SEMITONES_PER_OCTAVE
+  MOD = 12 # semitones per octave
   
   def self.from_i i
     i % MOD

data/lib/musicality/{composition/model/pitch_classes.rb → pitch_classes.rb}

@@ -1,18 +1,18 @@
 module Musicality
 
 module PitchClasses  
-  C = 0
-  Db = 1
+  C = Bs = 0
+  Cs = Db = 1
   D = 2
-  Eb = 3
-  E = 4
-  F = 5
-  Gb = 6
+  Ds = Eb = 3
+  E = Fb = 4
+  Es = F = 5
+  Fs = Gb = 6
   G = 7
-  Ab = 8
+  Gs = Ab = 8
   A = 9
-  Bb = 10
-  B = 11
+  As = Bb = 10
+  B = Cb = 11
 end
 
 PITCH_CLASSES = PitchClasses.constants.map do |sym|

data/lib/musicality/printing/lilypond/clef.rb

@@ -0,0 +1,12 @@
+module Musicality
+
+module Clef
+  TREBLE = :treble
+  BASS = :bass
+  TENOR = :tenor
+  ALTO = :alto
+end
+
+CLEFS = [Clef::TREBLE, Clef::ALTO, Clef::BASS, Clef::TENOR]
+
+end

data/lib/musicality/printing/lilypond/key_engraving.rb

@@ -0,0 +1,9 @@
+module Musicality
+
+class Key
+  def to_lilypond
+    "\\key #{PitchClass.to_lilypond(@tonic_pc, sharp?)} \\#{@triad}"
+  end
+end
+
+end

data/lib/musicality/printing/lilypond/lilypond_settings.rb

@@ -0,0 +1,105 @@
+module Musicality
+
+class LilypondSettings
+  include Packable
+
+  attr_reader :instrument_name, :clefs, :transpose_interval
+
+  def initialize instrument_name, clefs: [Clef::TREBLE, Clef::BASS], transpose_interval: 0
+    raise ArgumentError unless (clefs & CLEFS) == clefs
+    @instrument_name = instrument_name
+    @clefs = clefs
+    @transpose_interval = transpose_interval
+  end
+
+  def self.treble_bass(instrument_name, transpose_interval: 0)
+    new(instrument_name, clefs: [Clef::TREBLE, Clef::BASS], transpose_interval: transpose_interval)
+  end
+
+  def self.treble(instrument_name, transpose_interval: 0)
+    new(instrument_name, clefs: [Clef::TREBLE], transpose_interval: transpose_interval)
+  end
+
+  def self.bass(instrument_name, transpose_interval: 0)
+    new(instrument_name, clefs: [Clef::BASS], transpose_interval: transpose_interval)
+  end
+
+  def self.guitar(instrument_name)
+    new(instrument_name, clefs: [Clef::TENOR], transpose_interval: 12)
+  end
+
+  def self.bass_guitar(instrument_name)
+    new(instrument_name, clefs: [Clef::BASS], transpose_interval: 12)
+  end
+
+  ACOUSTIC_GRAND_PIANO = LilypondSettings.treble_bass("Acoustic Grand Piano")
+  BRIGHT_ACOUSTIC_PIANO = LilypondSettings.treble_bass("Bright Acoustic Piano")
+  ELECTRIC_GRAND_PIANO = LilypondSettings.treble_bass("Electric Grand Piano")
+  HONKY_TONK_PIANO = LilypondSettings.treble_bass("Honky Tonk Piano")
+  ELECTRIC_PIANO = LilypondSettings.treble_bass("Electric Piano")
+  HARPSICHORD = LilypondSettings.treble_bass("Harpsichord")
+  CLAVINET = LilypondSettings.treble_bass("Clavinet")
+  CELESTA = LilypondSettings.treble_bass("Celesta", transpose_interval: -12)
+
+  GLOCKENSPIEL = LilypondSettings.treble_bass("Glockenspiel", transpose_interval: -24)
+  MUSIC_BOX = LilypondSettings.treble_bass("Music Box")
+  VIBRAPHONE = LilypondSettings.treble_bass("Virbaphone")
+  MARIMBA = LilypondSettings.treble_bass("Marimba")
+  XYLOPHONE = LilypondSettings.treble_bass("Xylophone", transpose_interval: -12)
+  TUBULAR_BELLS = LilypondSettings.treble_bass("Tubular Bells")
+  DULCIMER = LilypondSettings.treble("Dulcimer")
+
+  DRAWBAR_ORGAN = LilypondSettings.treble_bass("Drawbar Organ")
+  PERCUSSIVE_ORGAN = LilypondSettings.treble_bass("Percussive Organ")
+  ROCK_ORGAN = LilypondSettings.treble_bass("Rock Organ")
+  CHURCH_ORGAN = LilypondSettings.treble_bass("Church Organ")
+  REED_ORGAN = LilypondSettings.treble_bass("Reed Organ")
+  ACCORDIAN = LilypondSettings.treble_bass("Accordion")
+  HARMONICA = LilypondSettings.treble("Harmonica")
+  TANGO_ACCORDIAN = LilypondSettings.treble_bass("Tango Accordion")
+
+  ACOUSTIC_GUITAR = LilypondSettings.guitar('Acoustic Guitar')
+  ELECTRIC_GUITAR = LilypondSettings.guitar('Electric Guitar')
+  OVERDRIVEN_GUITAR = LilypondSettings.guitar('Overdriven Guitar')
+  DISTORTION_GUITAR = LilypondSettings.guitar('Distortion Guitar')
+  GUITAR_HARMONICS = LilypondSettings.guitar('Guitar Harmonics')
+  
+  ACOUSTIC_BASS = LilypondSettings.bass_guitar('Acoustic Bass')
+  ELECTRIC_BASS = LilypondSettings.bass_guitar('Electric Bass')
+  FRETLESS_BASS = LilypondSettings.bass_guitar('Fretless Bass')
+  SLAP_BASS = LilypondSettings.bass_guitar('Slap Bass')
+  SYNTH_BASS = LilypondSettings.bass_guitar('Synth Bass')
+
+  VIOLIN = LilypondSettings.treble('Violin')
+  VIOLA = LilypondSettings.new('Viola', clefs: [Clef::TREBLE, Clef::ALTO])
+  CELLO = LilypondSettings.new('Cello', clefs: [Clef::BASS, Clef::TENOR])
+  CONTRABASS = LilypondSettings.bass('Contrabass', transpose_interval: 12)
+  TREMOLO_STRINGS = LilypondSettings.treble_bass('Tremolo Strings')
+  PIZZICATO_STRINGS = LilypondSettings.treble_bass('Pizzicato Strings')
+  ORCHESTRAL_HARP = LilypondSettings.treble_bass('Orchestral Harp')
+  TIMPANI = LilypondSettings.bass('Timpani')
+  STRING_ENSEMBLE = LilypondSettings.treble_bass('String Ensemble')
+  
+  TRUMPET = LilypondSettings.treble('Trumpet', transpose_interval: 2)
+  TROMBONE = LilypondSettings.new('Trombone', clefs: [Clef::BASS, Clef::TENOR])
+  TUBA = LilypondSettings.bass('Tuba')
+  FRENCH_HORN = LilypondSettings.bass('French Horn')
+  
+  SOPRANO_SAX = LilypondSettings.treble('Soprano Sax', transpose_interval: 2)
+  ALTO_SAX = LilypondSettings.treble('Alto Sax', transpose_interval: 9)
+  TENOR_SAX = LilypondSettings.treble('Tenor Sax', transpose_interval: 14)
+  BARITONE_SAX = LilypondSettings.treble('Baritone Sax', transpose_interval: 21)
+  OBOE = LilypondSettings.treble('Oboe')
+  ENGLISH_HORN = LilypondSettings.treble('English Horn', transpose_interval: 7)
+  BASSOON = LilypondSettings.bass('Bassoon')
+  CLARINET = LilypondSettings.treble('Clarinet', transpose_interval: 2)
+  PICCOLO = LilypondSettings.treble('Piccolo', transpose_interval: -12)
+end
+
+class Part
+  def lilypond_settings
+    find_settings(LilypondSettings)
+  end
+end
+
+end

data/lib/musicality/printing/lilypond/meter_engraving.rb

@@ -4,7 +4,7 @@ class Meter
   def to_lilypond
     num = beats_per_measure * beat_duration.numerator
     den = beat_duration.denominator
-    "#{num}/#{den}"
+    "\\time #{num}/#{den}"
   end
 end
 

data/lib/musicality/printing/lilypond/note_engraving.rb

@@ -1,52 +1,134 @@
 module Musicality
 
 class Note
+  SMALLEST_PIECE = Rational(1,256)
+
   def to_lilypond sharpit = false
-    dur_strs = []
-    d = duration
-    
-    if d > 1
-      dur_strs += ["1"]*d.to_i
-      d -= d.to_i
-    end
+    subdurs = [1]*@duration.to_i + fractional_subdurs(SMALLEST_PIECE)
 
-    if d > 0
-      n = Math.log2(d)
-      if n < -7
-        raise UnsupportedDurationError, "Note duration #{d} is too short for Lilypond"
+    piece_strs = []
+    pitches_to_strs = Hash[ pitches.map {|p| [p,p.to_lilypond(sharpit)] }]
+    while subdurs.any?
+      subdur = subdurs.shift
+      dur_str = subdur.denominator.to_s
+      if subdurs.any? && subdur == subdurs.first*2
+        dur_str += "."
+        subdurs.shift
       end
+      last = subdurs.empty?
 
-      if n.to_i == n # duration is exact power of two
-        dur_strs.push (2**(-n)).to_i.to_s
-      else # duration may be dotted
-        undotted_duration = d/1.5
-        n = Math.log2(undotted_duration)
-
-        if n.to_i == n # duration (undotted) is exact power of two
-          if n < -7
-            raise UnsupportedDurationError, "Undotted note duration #{undotted_duration} is too short for Lilypond"
+      piece_str = if pitches.any?
+        if last
+          # figure if ties are needed on per-pitch basis, based on note links
+          if pitches_to_strs.size == 1
+            p, p_str = pitches_to_strs.first
+            needs_tie = links.include?(p) && links[p].is_a?(Link::Tie)
+            p_str + dur_str + (needs_tie ? "~" : "")
+          else
+            p_strs = pitches_to_strs.map do |p,p_str|
+              if links.include?(p) && links[p].is_a?(Link::Tie)
+                p_str + "~"
+              else
+                p_str
+              end
+            end
+            "<#{p_strs.join(" ")}>" + dur_str
           end
-
-          dur_strs.push (2**(-n)).to_i.to_s + "."
         else
-          raise UnsupportedDurationError, "Leftover note duration #{d}is not power-of-two, and is not dotted power-of-two"
+          str = if pitches.size == 1
+            pitches_to_strs.values.first
+          else
+            "<#{pitches_to_strs.values.join(" ")}>"
+          end
+          str + dur_str + "~"
         end
+      else
+        "r" + dur_str
       end
+
+      piece_strs.push piece_str
     end
-    
+
+    if pitches.any?
+      if articulation != Articulations::NORMAL
+        piece_strs[0] += "-" + ARTICULATION_SYMBOLS[articulation]
+      end
+
+      if begins_slur?
+        piece_strs[-1] += MARK_SYMBOLS[Mark::Slur::Begin]
+      end
+
+      if ends_slur?
+        piece_strs[-1] += MARK_SYMBOLS[Mark::Slur::End]
+      end
+    end
+
+    if begins_triplet?
+      piece_strs[0].prepend("\\tuplet 3/2 {")
+    end
+
+    if ends_triplet?
+      piece_strs[-1].concat("}")
+    end
+
+    return piece_strs.join(" ")
+  end
+
+  def fractional_subdurs smallest_piece
+    remaining = @duration - @duration.to_i    
+    pieces = []
+    i = 0
+    while((current_dur = Rational(1,2<<i)) >= smallest_piece)
+      if remaining >= current_dur
+        pieces.push current_dur
+        remaining -= current_dur
+      end
+      i += 1
+    end
+
+    unless remaining.zero?
+      raise RuntimeError, "Non-zero remainder #{remaining}"
+    end
+
+    return pieces
+  end
+
+  private
+
+
+  def pieces_to_dur_strs pieces
+    dur_strs = []
+    while pieces.any?
+      piece = pieces.shift
+      triplet = piece.denominator % 3 == 0
+      piece_str = (triplet ? (piece * 1.5.to_r) : piece).denominator.to_s
+      if pieces.any? && piece == pieces.first*2
+        piece_str += "."
+        pieces.shift
+      end
+
+      if triplet
+        piece_str = "\\tuplet 3/2 { #{piece_str} }"
+      end
+
+      dur_strs.push piece_str
+    end
+    return dur_strs
+  end
+
+  def figure_pitch_and_joipiece_str sharpit
     if pitches.any?
       if pitches.size == 1
-        p_str = pitches.first.to_lilypond
+        p_str = pitches.first.to_lilypond(sharpit)
       else
-        p_str = "<" + pitches.map {|p| p.to_lilypond}.join(" ") + ">"
+        p_str = "<" + pitches.map {|p| p.to_lilypond(sharpit) }.join(" ") + ">"
       end
-      join_str = "~ "
+      joipiece_str = "~ "
     else
       p_str = "r"
-      join_str = " "
+      joipiece_str = " "
     end
-
-    return dur_strs.map {|dur_str| p_str + dur_str }.join(join_str)
+    return [ p_str, joipiece_str ]
   end
 end
 

data/lib/musicality/printing/lilypond/part_engraver.rb

@@ -1,11 +1,122 @@
 module Musicality
 
 class PartEngraver
-  def initialize part
-    @part = part
+  MAX_LINE_LEN = 76
+  INDENT = "  "
+
+  def initialize part, title
+    if part.invalid?
+      raise ArgumentError, "given part contains errors: #{part.errors}"
+    end
+
+    @transpose_interval = part.lilypond_settings.transpose_interval
+    @clefs = part.lilypond_settings.clefs
+    @part = (@transpose_interval == 0) ? part : part.transpose(@transpose_interval)
+    @title = title
+    @indent = INDENT
+  end
+
+  def increase_indent
+    @indent += INDENT
+  end
+
+  def decrease_indent
+    @indent = @indent[0...-INDENT.size]
+  end
+
+  def make_lilypond start_key, start_meter, key_changes: {}, meter_changes: {}, master: false
+    if @transpose_interval != 0
+      start_key = transpose_start_key(start_key)
+      key_changes = transpose_key_changes(key_changes)      
+    end
+
+    sharpit = start_key.sharp?
+    return make_preliminary(start_meter, start_key, master) + 
+      make_body(sharpit) + make_final()
+  end
+
+  def make_preliminary start_meter, start_key, master
+    clef = self.class.best_clef(@part.notes, @clefs)
+
+    output = @indent + "\\new Staff {\n"
+    increase_indent
+    output += @indent + "\\set Staff.instrumentName = \\markup { \"#{@title}\" }\n"
+    output += @indent + "\\clef #{clef}\n"
+    if master
+      output += @indent + start_meter.to_lilypond + "\n"
+    end
+    output += @indent + start_key.to_lilypond + "\n"
+    return output
+  end
+
+  def make_body sharpit
+    pieces = @part.notes.map {|n| n.to_lilypond(sharpit)}
+
+    output = ""
+    while pieces.any?
+      line = @indent + pieces.shift
+      until pieces.empty? || (line.size + 1 + pieces.first.size) > MAX_LINE_LEN
+        line += " " + pieces.shift
+      end
+      output += line + "\n"
+    end
+    return output
+  end
+
+  def make_final
+    decrease_indent
+    return @indent + "}\n"
+  end 
+
+  CLEF_RANGES = {
+    Clef::TREBLE => Pitches::C4..Pitches::A5,
+    Clef::ALTO => Pitches::D3..Pitches::B4,
+    Clef::TENOR => Pitches::B2..Pitches::G4,
+    Clef::BASS => Pitches::E2..Pitches::C4,
+  }
+
+  def self.best_clef notes, allowed_clefs
+    raise ArgumentError unless notes.any?
+    raise ArgumentError unless allowed_clefs.any?
+
+    ranges = CLEF_RANGES.select {|clef,range| allowed_clefs.include?(clef) }
+    range_scores = Hash.new(0)
+
+    in_triplet = false
+    notes.each do |note|
+      if note.begins_triplet?
+        in_triplet = true
+      end
+
+      dur = note.duration * (in_triplet ? Rational(2,3) : 1)
+      note.pitches.each do |p|
+        ranges.each do |name,range|
+          if p >= range.min && p <= range.max
+            range_scores[name] += dur
+          end
+        end
+      end
+
+      if note.ends_triplet?
+        in_triplet = false
+      end
+    end
+    range_score = range_scores.max_by {|range,score| score}
+    range_score.nil? ? allowed_clefs.first : range_score[0]
+  end
+
+  private
+
+  def transpose_start_key start_key
+    start_key.transpose(@transpose_interval)
   end
 
-  def to_lilypad
+  def transpose_key_changes key_changes
+    Hash[
+      key_changes.map do |off,change|
+        change.clone {|v| v.transpose(@transpose_interval) }
+      end
+    ]
   end
 end