mtk 0.0.2 → 0.0.3

data/lib/mtk/helpers/collection.rb

@@ -0,0 +1,164 @@
+module MTK
+  module Helpers
+
+     # Given a method #elements, which returns an Array of elements in the collection,
+     # including this module will make the class Enumerable and provide various methods you'd expect from an Array.
+     module Collection
+       include Enumerable
+
+       # A mutable array of elements in this collection
+       def to_a
+         Array.new(elements) # we construct a new array since some including classes make elements be immutable
+       end
+
+       # The number of elements in this collection
+       def size
+         elements.size
+       end
+       alias length size
+
+       def empty?
+         elements.nil? or elements.size == 0
+       end
+
+       # The each iterator for providing Enumerable functionality
+       def each &block
+         elements.each(&block)
+       end
+
+       # the original Enumerable#map implementation, which returns an Array
+       alias enumerable_map map
+
+       # the overriden #map implementation, which returns an object of the same type
+       def map &block
+         clone_with enumerable_map(&block)
+       end
+
+       # The first element
+       def first(n=nil)
+         n ? elements.first(n) : elements.first
+       end
+
+       # The last element
+       def last(n=nil)
+         n ? elements.last(n) : elements.last
+       end
+
+       # The element with the given index
+       def [](index)
+         elements[index]
+       end
+
+       def repeat(times=2)
+         full_repetitions, fractional_repetitions = times.floor, times%1  # split into int and fractional part
+         repeated = elements * full_repetitions
+         repeated += elements[0...elements.size*fractional_repetitions]
+         clone_with repeated
+       end
+
+       def permute
+         clone_with elements.shuffle
+       end
+       alias shuffle permute
+
+       def rotate(offset=1)
+         clone_with elements.rotate(offset)
+       end
+
+       def concat(other)
+         other_elements = (other.respond_to? :elements) ? other.elements : other
+         clone_with(elements + other_elements)
+       end
+
+       def reverse
+         clone_with elements.reverse
+       end
+       alias retrograde reverse
+
+
+       # Partition the collection into an Array of sub-collections.
+       #
+       # With a Numeric argument: partition the elements into collections of the given size (plus whatever's left over).
+       #
+       # With an Array argument: partition the elements into collections of the given sizes.
+       #
+       # Otherwise if a block is given: partition the elements into collections with the same block return value.
+       #
+       def partition(arg=nil, &block)
+         partitions = nil
+         case arg
+           when Numeric
+             partitions = self.each_slice(arg)
+
+           when Enumerable
+             partitions = []
+             items, sizes = self.to_enum, arg.to_enum
+             group = []
+             size = sizes.next
+             loop do
+               item = items.next
+               if group.size < size
+                 group << item
+               else
+                 partitions << group
+                 group = []
+                 size = sizes.next
+                 group << item
+               end
+             end
+             partitions << group unless group.empty?
+
+           else
+             if block
+               group = Hash.new{|h,k| h[k] = [] }
+               if block.arity == 2
+                 self.each_with_index{|item,index| group[block[item,index]] << item }
+               else
+                 self.each{|item| group[block[item]] << item }
+               end
+               partitions = group.values
+             end
+         end
+
+         if partitions
+           partitions.map{|p| self.class.from_a(p) }
+         else
+           self
+         end
+       end
+
+       def ==(other)
+         if other.respond_to? :elements
+           if other.respond_to? :options
+             elements == other.elements and @options == other.options
+           else
+             elements == other.elements
+           end
+         else
+           elements == other
+         end
+       end
+
+       # Create a copy of the collection.
+       # In order to use this method, the including class must implement .from_a()
+       def clone
+         clone_with to_a
+       end
+
+       #################################
+       private
+
+       # "clones" the object with the given elements, attempting to maintain any @options
+       # This is designed to work with 2 argument constructors: def initialize(elements, options=default)
+       def clone_with elements
+         from_a = self.class.method(:from_a)
+         if @options and from_a.arity == -2
+           from_a[elements, @options]
+         else
+           from_a[elements]
+         end
+       end
+
+     end
+  end
+end

data/lib/mtk/helpers/convert.rb

@@ -0,0 +1,36 @@
+module MTK
+  module Helpers
+
+    module Convert
+
+      def to_pitch_classes(*anything)
+        anything = anything.first if anything.length == 1
+        if anything.respond_to? :to_pitch_classes
+          anything.to_pitch_classes
+        else
+          case anything
+            when Enumerable then anything.map{|item| PitchClass(item) }
+            else [PitchClass(anything)]
+          end
+        end
+      end
+      module_function :to_pitch_classes
+
+
+      def to_pitches(*anything)
+        anything = anything.first if anything.length == 1
+        if anything.respond_to? :to_pitches
+          anything.to_pitches
+        else
+          case anything
+            when Enumerable then anything.map{|item| Pitch(item) }
+            else [Pitch(anything)]
+          end
+        end
+      end
+      module_function :to_pitches
+
+    end
+
+  end
+end

data/lib/mtk/helpers/lilypond.rb

@@ -0,0 +1,162 @@
+require 'tempfile'
+require 'tmpdir'
+require 'fileutils'
+
+module MTK
+  module Helpers
+
+    # Uses {Timeline}s to generates music notation graphics with {http://lilypond.org/ Lilypond}.
+    # @note This class is optional and only available if you require 'mtk/helpers/lilypond'.
+    # @note To make notation graphics, {http://lilypond.org/download.html Lilypond} must be installed
+    #       and you must follow the "Running on the command-line" instructions (found on the download page for
+    #       your operating system). If the lilypond command is not on your PATH, set the environment variable LILYPOND_PATH
+    class Lilypond
+
+      LILYPOND_PATH = ENV['LILYPOND_PATH'] || 'lilypond'
+
+      VALID_FORMATS = %w( png pdf ps )
+
+
+      def initialize(file, options={})
+        @file = file
+        @options = options
+
+        @format = File.extname(file)[1..-1].downcase
+        raise ArgumentError.new("Invalid file format '#{@format}'") unless VALID_FORMATS.include? @format
+
+        @dpi = options[:dpi]
+      end
+
+      def self.open(file, options={})
+        new(file,options)
+      end
+
+
+      def write(timeline)
+        lilypond_syntax = syntax_for_timeline(timeline)
+        puts lilypond_syntax
+        puts "_____________________________"
+        Tempfile.open('mtk_lilypond') do |lilypond_file|
+          Dir.mktmpdir do |tmpdir|
+            # use the directory...
+            #open("#{dir}/foo", "w") { ... }
+
+            lilypond_file.write(lilypond_syntax)
+            lilypond_file.flush
+
+            cmd = ['lilypond', '-dbackend=eps', "-f#{@format}", "--output=\"#{tmpdir}\""]
+            cmd << "-dresolution=#{@dpi}" if @dpi
+            cmd << lilypond_file.path
+            cmd = cmd.join(' ')
+
+            puts cmd if $DEBUG
+            lilypond_command_output = `#{cmd}`
+            puts lilypond_command_output if $DEBUG
+
+            output_file = Dir["#{tmpdir}/*.#{@format}"].first
+
+            FileUtils.cp output_file, @file
+
+            puts "Wrote #{@file}"
+          end
+        end
+      end
+
+
+      ########################
+      private
+
+      QUANTIZATION_INTERVAL = 0.0625 # 64th note granularity
+
+      SYNTAX_PREFIX = '
+      \language "english"
+      \paper{
+        oddFooterMarkup=##f
+        oddHeaderMarkup=##f
+      }
+      \new PianoStaff {
+        \autochange {
+      '
+
+      SYNTAX_SUFFIX = '
+        }
+      }
+      '
+
+      def syntax_for_timeline(timeline)
+        quantized_timeline = timeline.flatten.quantize(QUANTIZATION_INTERVAL)
+        last_time = 0
+        last_duration = 0
+
+        s = ''
+        s << SYNTAX_PREFIX
+
+        for time,events in quantized_timeline
+
+          # handle rests between notes
+          delta = time - last_time
+          if delta > last_duration
+            s << 'r'+syntax_for_duration(delta - last_duration)
+            s << ' '
+          end
+
+          notes = events.find_all{|event| event.type == :note }
+
+          if notes.length > 1
+            # a chord
+            s << '<'
+            total_duration = 0
+            for note in notes
+              total_duration += note.duration
+              s << syntax_for_pitch(note.pitch)
+              s << ' '
+            end
+            s << '>'
+            duration = total_duration.to_f/notes.length
+            s << syntax_for_duration(duration)
+
+          else # a single note
+            note = notes.first
+            s << syntax_for_pitch(note.pitch)
+            duration = note.duration
+            s << syntax_for_duration(duration)
+          end
+
+          last_time = time
+          last_duration = duration
+          s << ' '
+        end
+
+        s << SYNTAX_SUFFIX
+        s
+      end
+
+      def syntax_for_pitch(pitch)
+        syntax = pitch.pitch_class.name.downcase
+        if syntax.length > 0
+          syntax = syntax[0] + syntax[1..-1].gsub('b','f') # .gsub('#','s') pitch class names never have '#'
+        end
+        oct = pitch.octave
+        while oct > 3
+          syntax << "'"
+          oct -= 1
+        end
+        while oct < 3
+          syntax << ","
+          oct += 1
+        end
+        syntax
+      end
+
+      def syntax_for_duration(duration)
+        # TODO: handle dots, triplets, and ties of arbitrary durations
+        duration = MTK::Timeline.quantize_time(duration.to_f.abs, QUANTIZATION_INTERVAL)
+        syntax = (4.0/duration).round
+        syntax = 1 if syntax < 1
+        syntax.to_s
+      end
+
+    end
+
+  end
+end

data/lib/mtk/helpers/output_selector.rb

@@ -0,0 +1,67 @@
+require 'mtk/midi/output'
+
+module MTK
+  module Helpers
+
+    # Optional class for loading the preferred platform-specific implementation of an output,
+    # and methods to assist with selecting an output.
+    class OutputSelector
+
+      class << self
+
+        def output
+          MTK::MIDI::Output
+        end
+
+        # Look for an output by name using case insensitive matching,
+        # treating underscore like either an underscore or whitespace
+        def search output_name_pattern
+          output.find_by_name(/#{output_name_pattern.to_s.sub '_','(_|\\s+)'}/i)
+        end
+
+        # Command line interface to list output choices and select an output.
+        def prompt_for_output
+          devices_by_name = output.devices_by_name
+          names_by_number = {}
+
+          puts "Available MIDI outputs:"
+          devices_by_name.keys.each_with_index do |name,index|
+            number = index+1
+            names_by_number[number] = name
+            puts " #{number} => #{name}"
+          end
+
+          print "Enter the number of the output to test: "
+          device = nil
+          loop do
+            begin
+              number = STDIN.gets.to_i
+              name = names_by_number[number]
+              device = devices_by_name[name]
+              return output.open(device) if device
+            rescue
+              if $DEBUG
+                puts $!
+                puts $!.backtrace
+              end
+              # keep looping
+            end
+            print "Invalid input. Enter a number listed above: "
+          end
+        end
+
+
+        def ensure_output name=nil
+          output = nil
+          if name
+            output = search name
+            puts "Output '#{name}' not found." unless output
+          end
+          output || prompt_for_output
+        end
+
+      end
+
+    end
+  end
+end

data/lib/mtk/helpers/pitch_collection.rb

@@ -0,0 +1,23 @@
+module MTK
+  module Helpers
+
+    # An extension to {Collection}, which provides additional transformations for pitch-like collections.
+    #
+    module PitchCollection
+      include Collection
+
+      # Transpose all elements upward by the given interval
+      # @param interval_in_semitones [Numeric] an interval in semitones
+      def transpose interval_in_semitones
+        map{|elem| elem + interval_in_semitones }
+      end
+
+      # Invert all elements around the given inversion point
+      # @param inversion_point [Numeric] the value around which all elements will be inverted (defaults to the first element in the collection)
+      def invert(inversion_point=first)
+        map{|elem| elem.invert(inversion_point) }
+      end
+
+    end
+  end
+end