musicality 0.8.0 → 0.9.0

data/bin/midify

@@ -3,25 +3,29 @@
 exe_name = File.basename(__FILE__)
 
 doc = <<DOCOPT
-Loads a musicality score from YAML file, and converts it to a MIDI file.
+Loads a musicality score from YAML file, and converts it to one or more MIDI 
+files. If no part names are given, all score parts are selected for MIDI 
+sequencing. Otherwise, only the given parts names will be selected. By default,
+a single engraving file will be produced. If the --split flag is used, a file 
+will be produced for each part. If --outdir is not given, files will be put in
+the same directory as the score file.
 
 Usage:
-  #{exe_name} <input> [PART PROGRAM] ... [options]
+  #{exe_name} SCORE [PART]... [options]
   #{exe_name} -h | --help
   #{exe_name} --version
 
 Arguments:
-  input A musicality score file (may be packed as a hash) in YAML format
-  PART name of a part in the score
-  PROGRAM MIDI program (instrument) number for the given part
-  
+  SCORE A musicality score file (may be packed as a hash) in a YAML file
+  PART name of a part in the score (e.g. "lhand")
+
 Options:
+  --split        Make separate files for each part
+  --outdir=OUTD  Dir where files will be put (defaults to same dir as score file)
   --srate=SRATE sampling rate for converting tempo-based score to time-based
                 score, and for sampling dynamic change values [default: 200]
   -h --help     Show this screen.
   --version     Show version.
-  --outfile=OUTF Name of output MIDI file
-
 DOCOPT
 
 require 'docopt'
@@ -40,16 +44,34 @@ if args["--version"]
   exit
 end
 
+SCORE_FILE = args["SCORE"]
+unless File.exists? SCORE_FILE
+  puts "Score file #{SCORE_FILE} does not exist. Aborting."
+  exit
+end
+
+if args["--outdir"]
+  OUTDIR = args["--outdir"]
+  unless Dir.exists? OUTDIR
+    puts "Output directory #{OUTDIR} does not exist. Aborting."
+    exit
+  end
+else
+  OUTDIR = File.dirname(SCORE_FILE)
+end
+
+PARTS = args["PART"]
+SPLIT = args["--split"]
+
 require 'yaml'
 include Musicality
 
-fin_name = args["<input>"]
-File.open(fin_name) do |fin|
-  print "Reading file '#{fin_name}'..."
+File.open(SCORE_FILE) do |fin|
+  print "Reading file '#{SCORE_FILE}'..."
   score = YAML.load(fin.read)
   
   if score.is_a? Hash
-    score = Score.unpack(score)
+    score = score.unpack
   end
   puts "done"
   
@@ -60,22 +82,40 @@ File.open(fin_name) do |fin|
   end
   
   if score.valid?
-    part_names = args["PART"]
-    program_nums = args["PROGRAM"].map {|str| str.to_i }
-    instr_map = Hash[[part_names,program_nums].transpose]
-    
+    if PARTS.any?
+      selected_parts = PARTS
+    else
+      selected_parts = score.parts.keys
+    end
+
     print "Making MIDI sequence..."
     sequencer = ScoreSequencer.new(score)
-    seq = sequencer.make_midi_seq(instr_map)
+    outfiles = {}
+
+    if SPLIT
+      selected_parts.each do |selected_part|
+        outfiles[selected_part] = sequencer.make_midi_seq([selected_part])
+      end
+    else
+      outfiles[""] = sequencer.make_midi_seq(selected_parts)
+    end
     puts "done"  
-  
-    fout_name = args["--outfile"]
-    if fout_name.nil?
-      fout_name = "#{File.dirname(fin_name)}/#{File.basename(fin_name,File.extname(fin_name))}.mid"
+
+    # part_names = args["PART"]
+    # program_nums = args["PROGRAM"].map {|str| str.to_i }
+    # instr_map = Hash[[part_names,program_nums].transpose]    
+
+    base_fout_name = "#{OUTDIR}/#{File.basename(SCORE_FILE,File.extname(SCORE_FILE))}"  
+    outfiles.each do |outfile, seq|
+      if outfile.empty?
+        fout_name = "#{base_fout_name}.mid"
+      else
+        fout_name = "#{base_fout_name}_#{outfile}.mid"
+      end
+      print "Writing MIDI file '#{fout_name}'..."
+      File.open(fout_name, 'wb'){ |fout| seq.write(fout) }
+      puts "done"
     end
-    print "Writing MIDI file '#{fout_name}'..."
-    File.open(fout_name, 'wb'){ |fout| seq.write(fout) }
-    puts "done"    
   else
     puts "Score is not valid. See errors:"
     puts score.errors.join("\n")

data/bin/musicality

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+exe_name = File.basename(__FILE__)
+
+doc = <<DOCOPT
+The 'new' subcommand wll create a new musicality project.
+
+Usage:
+  #{exe_name} new PROJECT_DIR [options]
+  #{exe_name} -h | --help
+  #{exe_name} --version
+
+Arguments:
+  PROJECT_DIR Path of an empty directory or directory to be created
+
+Options:
+  -h --help     Show this screen.
+  --version     Show version.
+DOCOPT
+
+require 'docopt'
+begin
+  args = Docopt::docopt(doc)
+  puts args
+rescue Docopt::Exit => e
+  puts e.message
+  exit
+end
+
+require 'musicality'
+
+if args["--version"]
+  puts "#{exe_name} in musicality v#{Musicality::VERSION}"
+  exit
+end
+
+if args["new"]
+  Musicality::Project.new(args["PROJECT_DIR"])
+end

data/examples/composition/auto_counterpoint.rb

@@ -5,8 +5,8 @@ include Pitches
 bass_pitch_palette = [ C2, D2, E2, F2, G2, A2, B2, C3 ]
 guitar_pitch_palette = [ C3, D3, E3, F3, G3, A3, B3, C4 ]
 
-bass = Part.new(Dynamics::MF)
-guitar = Part.new(Dynamics::MF)
+bass = Part.new(Dynamics::MF, settings: [MidiSettings::ELECTRIC_BASS_FINGER])
+guitar = Part.new(Dynamics::MF, settings: [MidiSettings::ELECTRIC_GUITAR_JAZZ])
 
 def random_melody rhythm, pitch_palette
   pitches = pitch_palette.sample(rand(2..pitch_palette.size))
@@ -43,11 +43,10 @@ end
   end
 end
 
-score = Score::Unmeasured.new(120,
+score = Score::Tempo.new(Meters::FOUR_FOUR, 120,
   parts: { "bass" => bass, "guitar" => guitar },
   program: [ 0...([bass.duration,guitar.duration].min) ]
 )
 
-instr_map = { "bass" => 32, "guitar" => 25 }
-seq = ScoreSequencer.new(score.to_timed(200)).make_midi_seq(instr_map)
+seq = ScoreSequencer.new(score.to_timed(200)).make_midi_seq
 File.open("./auto_counterpoint.mid", 'wb'){ |fout| seq.write(fout) }

data/examples/composition/part_generator.rb

@@ -16,8 +16,10 @@ end
 
 rhythm_seq2 = RepeatingSequence.new([3/8.to_r]*4)
 
-score = Score::Measured.new(SIX_EIGHT,90) do |s|
+score = Score::Tempo.new(SIX_EIGHT,90) do |s|
   s.parts["main"] = Part.new(Dynamics::MF) do |p|
+    p.settings.push MidiSettings::LEAD_SAWTOOTH
+
     rhythm_seq = RepeatingSequence.new(([1/8.to_r]*3)*3 + [1/4.to_r,1/8.to_r])
     selector = RepeatingSequence.new([4,2,0])
     rhythm = rhythm_seq.take(pitch_seqs.size * rhythm_seq.pattern_size).to_a
@@ -27,6 +29,8 @@ score = Score::Measured.new(SIX_EIGHT,90) do |s|
   end
   
   s.parts["bass"] = Part.new(Dynamics::MP) do |p|
+    p.settings.push MidiSettings::LEAD_SQUARE
+
     rhythm_seq = RepeatingSequence.new([3/8.to_r]*4)
     selector = RepeatingSequence.new([-7])
     rhythm = rhythm_seq.take(pitch_seqs.size * rhythm_seq.pattern_size).to_a
@@ -36,6 +40,8 @@ score = Score::Measured.new(SIX_EIGHT,90) do |s|
   end
   
   s.parts["pluck"] = Part.new(Dynamics::MP) do |p|
+    p.settings.push MidiSettings::ORCHESTRAL_HARP
+
     rhythm_seq = RepeatingSequence.new(([1/8.to_r]*3)*4)
     selector = RepeatingSequence.new([0,2,4])
     rhythm = rhythm_seq.take(pitch_seqs.size * rhythm_seq.pattern_size).to_a
@@ -47,5 +53,5 @@ score = Score::Measured.new(SIX_EIGHT,90) do |s|
   s.program = [0...s.measures_long]*2
 end
 
-seq = ScoreSequencer.new(score.to_timed(200)).make_midi_seq("main" => 81, "bass" => 80, "pluck" => 46)
+seq = ScoreSequencer.new(score.to_timed(200)).make_midi_seq
 File.open("./part_generator.mid", 'wb'){ |fout| seq.write(fout) }

data/examples/composition/scale_exercise.rb

@@ -26,7 +26,7 @@ def scale_exercise scale_class, base_pitch, rhythm
   return notes
 end
 
-score = Score::Measured.new(FOUR_FOUR,120) do |s|
+score = Score::Tempo.new(FOUR_FOUR,120) do |s|
   s.parts["scale"] = Part.new(Dynamics::MP) do |p|
     Heptatonic::Prima::MODES.each do |mode_n,scale_class|
       [[1/4.to_r,1/4.to_r,1/2.to_r]].each  do |rhythm|

data/examples/notation/notes.rb

@@ -0,0 +1,27 @@
+require 'musicality'
+include Musicality
+include Pitches
+
+#
+# convenience methods for common durations
+#
+single = Note.quarter(Ab4)
+rest = Note.quarter
+chord = Note.whole([C3,E3,G3])
+
+#
+# specific duration + articulation
+#
+note = Note.new(Rational(7,8), Bb3, articulation: Articulations::STACCATO)
+puts note.to_s  # => "7/8Bb3."
+
+#
+# magic!
+#
+puts note.transpose(2).to_s  # => "7/8C4."
+
+#
+# create notes from a compact syntax
+#
+notes = "/4C3 /4D3 /2E3,G3,B3".to_notes
+puts notes.join(" ") # => "/4C3 /4D3 /2E3,G3,B3"

data/examples/notation/parts.rb

@@ -0,0 +1,51 @@
+require 'musicality'
+include Musicality
+include Pitches
+include Dynamics
+
+
+#
+# Building up a part piece-by-piece
+#
+
+# an empty part with no notes and default dynamic (loudness)
+p = Part.new(MP)
+
+# add some notes
+p.notes += "/4C3 /4D3 /2E3,G3,B3".to_notes * 2
+
+# add dynamic changes
+p.dynamic_changes[0.5] = Change::Gradual.linear(FF, 0.5)
+p.dynamic_changes[1] = Change::Immediate.new(MP)
+
+# Add custom settings for LilyPond engraving
+p.settings.push LilypondSettings::CLARINET
+
+# Add custom settings for MIDI conversion
+p.settings.push MidiSettings::CLARINET
+
+
+#
+# Using block initialization to do the same
+#
+
+p = Part.new(MP) do |p|
+  p.notes += "/4C3 /4D3 /2E3,G3,B3".to_notes * 2
+  p.dynamic_changes[0.5] = Change::Gradual.linear(FF, 0.5)
+  p.dynamic_changes[1] = Change::Immediate.new(MP)
+  p.settings.push LilypondSettings::CLARINET
+  p.settings.push MidiSettings::CLARINET
+end
+
+
+#
+# Passing all the pieces as keyword parameters
+#
+p = Part.new(MP,
+  notes: "/4C3 /4D3 /2E3,G3,B3".to_notes * 2,
+  dynamic_changes: {
+    0.5 => Change::Gradual.linear(FF, 0.5),
+    1.0 => Change::Immediate.new(MP)
+  },
+  settings: [ LilypondSettings::CLARINET, MidiSettings::CLARINET ]
+)

data/examples/notation/scores.rb

@@ -0,0 +1,38 @@
+require 'musicality'
+include Musicality
+include Pitches
+include Dynamics
+include Keys
+include Meters
+
+#
+# Basics of creating a score from scratch
+#
+
+# minimum score, with no parts
+s = Score::Tempo.new(FOUR_FOUR, 120)
+
+# add a part
+s.parts["piano"] = Part.new(MP) do |p|
+  p.notes = q(C4,C4,G4,G4,A4,A4) + h(G4) + 
+            q(F4,F4,E4,E4,D4,D4) + h(C4)
+end
+
+# add a key and tempo change
+s.key_changes[s.measures_long] = Change::Immediate.new(D_MAJOR)
+s.tempo_changes[s.measures_long] = Change::Immediate.new(140)
+s.parts["piano"].notes += transpose(s.parts["piano"].notes, 2)
+
+
+#
+# Score conversion
+#
+
+# Convert tempo-based score to time-based
+s.to_timed(200) # requires tempo sampling rate
+
+# Engrave the score using LilyPond
+puts s.to_lilypond
+
+# Convert the score to a MIDI file
+s.to_midi_seq(200)

data/examples/notation/twinkle.rb

@@ -0,0 +1,34 @@
+require 'musicality'
+include Musicality
+include Meters
+include Dynamics
+include Pitches
+
+score = Score::Tempo.new(FOUR_FOUR, 120, title: "Twinkle, Twinkle, Little Star") do |s|
+  s.parts["rhand"] = Part.new(MF) do |p|
+    a_notes = q(C4,C4,G4,G4,A4,A4) + h(G4) +
+              q(F4,F4,E4,E4,D4,D4) + h(C4)
+    b_notes = q(G4,G4,F4,F4,E4,E4) + h(D4)
+    p.notes += a_notes + b_notes
+  end
+  
+  s.parts["lhand"] = Part.new(MF) do |p|
+    Cmaj = [C3,E3,G3]
+    Fmaj = [F2,A2,C3]
+    Gmaj = [G2,B2,D3]
+    
+    a_chords = h(Cmaj,Cmaj,Fmaj,Cmaj) + 
+               h(Fmaj,Cmaj,Gmaj,Cmaj)
+    b_chords = h(Cmaj,Fmaj,Cmaj,Gmaj)
+    p.notes += a_chords + b_chords
+  end
+  
+  s.program.push 0...4
+  s.program.push 4...6
+  s.program.push 4...6
+  s.program.push 0...4
+end
+
+File.open('twinkle.ly','w'){|f| f.write(score.to_lilypond) }
+File.open('twinkle.mid','wb'){|f| score.to_midi_seq(200).write(f) }
+score.to_osc(200,'twinkle')

data/examples/notation/twinkle.score

@@ -0,0 +1,33 @@
+# run me with the following ruby code:
+#   require 'musicality'
+#   include Musicality
+#   include Pitches
+#   ScoreDSL.load('twinkle.score')
+
+tempo_score Meters::FOUR_FOUR, 120 do
+  title "Twinkle, Twinkle, Little Star"
+
+  Cmaj = [C3,E3,G3]
+  Fmaj = [F2,A2,C3]
+  Gmaj = [G2,B2,D3]
+  section "A" do
+    notes(
+      "rhand" => q(C4,C4,G4,G4,A4,A4) + h(G4) +
+                 q(F4,F4,E4,E4,D4,D4) + h(C4),
+      "lhand" => h(Cmaj,Cmaj,Fmaj,Cmaj) + 
+                 h(Fmaj,Cmaj,Gmaj,Cmaj)
+    )
+  end
+
+  section "B" do
+    notes(
+      "rhand" => q(G4,G4,F4,F4,E4,E4) + h(D4),
+      "lhand" => h(Cmaj,Fmaj,Cmaj,Gmaj)
+    )
+  end
+  repeat "B"
+  repeat "A"
+end
+
+File.open('twinkle.ly','w'){|f| f.write(score.to_lilypond) }
+File.open('twinkle.mid','wb'){|f| score.to_midi_seq(200).write(f) }

data/lib/musicality.rb

@@ -1,24 +1,31 @@
 # basic core classes
 require 'musicality/version'
+require 'musicality/packable'
 require 'musicality/validatable'
 require 'musicality/errors'
 
+require 'musicality/pitch_class'
+require 'musicality/pitch_classes'
+
 #
 # Notation
 #
 
 require 'musicality/notation/model/pitch'
 require 'musicality/notation/model/pitches'
-require 'musicality/notation/model/links'
 require 'musicality/notation/model/articulations'
-require 'musicality/notation/model/symbols'
 require 'musicality/notation/model/link'
+require 'musicality/notation/model/mark'
+require 'musicality/notation/model/marks'
+require 'musicality/notation/model/symbols'
 require 'musicality/notation/model/note'
 require 'musicality/notation/model/dynamics'
 require 'musicality/notation/model/change'
 require 'musicality/notation/model/part'
 require 'musicality/notation/model/meter'
 require 'musicality/notation/model/meters'
+require 'musicality/notation/model/key'
+require 'musicality/notation/model/keys'
 require 'musicality/notation/model/score'
 
 require 'treetop'
@@ -35,6 +42,7 @@ require 'musicality/notation/parsing/duration_nodes'
 require 'musicality/notation/parsing/articulation_parsing'
 require 'musicality/notation/parsing/link_parsing'
 require 'musicality/notation/parsing/link_nodes'
+require 'musicality/notation/parsing/mark_parsing'
 require 'musicality/notation/parsing/note_parsing'
 require 'musicality/notation/parsing/note_node'
 require 'musicality/notation/parsing/meter_parsing'
@@ -42,10 +50,6 @@ require 'musicality/notation/parsing/segment_parsing'
 require 'musicality/notation/parsing/parseable'
 require 'musicality/notation/parsing/convenience_methods'
 
-require 'musicality/notation/packing/change_packing'
-require 'musicality/notation/packing/part_packing'
-require 'musicality/notation/packing/score_packing'
-
 require 'musicality/notation/util/interpolation'
 require 'musicality/notation/util/function'
 require 'musicality/notation/util/piecewise_function'
@@ -71,8 +75,6 @@ require 'musicality/composition/util/random_sampler'
 require 'musicality/composition/util/probabilities'
 require 'musicality/composition/util/note_generation'
 
-require 'musicality/composition/model/pitch_class'
-require 'musicality/composition/model/pitch_classes'
 require 'musicality/composition/model/scale'
 require 'musicality/composition/model/scale_class'
 require 'musicality/composition/model/scale_classes'
@@ -89,11 +91,12 @@ require 'musicality/composition/convenience_methods'
 # Performance
 #
 
-require 'musicality/performance/model/note_attacks'
+require 'musicality/performance/model/attack'
+require 'musicality/performance/model/separation'
+require 'musicality/performance/model/duration_functions'
 require 'musicality/performance/model/note_sequence'
 
 require 'musicality/performance/util/optimization'
-require 'musicality/performance/util/note_linker'
 
 require 'musicality/performance/conversion/glissando_converter'
 require 'musicality/performance/conversion/portamento_converter'
@@ -103,17 +106,49 @@ require 'musicality/performance/conversion/score_collator'
 require 'midilib'
 require 'musicality/performance/midi/midi_util'
 require 'musicality/performance/midi/midi_events'
+require 'musicality/performance/midi/midi_settings'
 require 'musicality/performance/midi/part_sequencer'
 require 'musicality/performance/midi/score_sequencer'
 require 'musicality/performance/midi/score_sequencing'
 
+require 'musicality/performance/supercollider/message'
+require 'musicality/performance/supercollider/bundle'
+require 'musicality/performance/supercollider/server'
+require 'musicality/performance/supercollider/add_actions'
+require 'musicality/performance/supercollider/node'
+require 'musicality/performance/supercollider/synth'
+require 'musicality/performance/supercollider/group'
+require 'musicality/performance/supercollider/synthdef'
+require 'musicality/performance/supercollider/synthdefs'
+require 'musicality/performance/supercollider/performer'
+require 'musicality/performance/supercollider/conductor'
+require 'musicality/performance/supercollider/score_conducting'
+
 #
 # Printing
 #
 
 require 'musicality/printing/lilypond/errors'
+require 'musicality/printing/lilypond/pitch_class_engraving'
 require 'musicality/printing/lilypond/pitch_engraving'
 require 'musicality/printing/lilypond/note_engraving'
 require 'musicality/printing/lilypond/meter_engraving'
+require 'musicality/printing/lilypond/key_engraving'
+require 'musicality/printing/lilypond/clef'
+require 'musicality/printing/lilypond/lilypond_settings'
+require 'musicality/printing/lilypond/part_engraver'
 require 'musicality/printing/lilypond/score_engraver'
-require 'musicality/printing/lilypond/score_engraving'
+require 'musicality/printing/lilypond/score_engraving'
+
+# 
+# Project
+#
+
+require 'rake'
+require 'yaml'
+require 'rake/tasklib'
+require 'musicality/project/file_raker'
+require 'musicality/project/file_cleaner'
+require 'musicality/project/project'
+require 'musicality/project/load_config'
+require 'musicality/project/create_tasks'