musa-dsl 0.14.32 → 0.21.0

data/lib/musa-dsl/datasets/score.rb

@@ -0,0 +1,210 @@
+require_relative 'e'
+
+require_relative 'score/queriable'
+require_relative 'score/to-mxml/to-mxml'
+require_relative 'score/render'
+
+require_relative '../core-ext/inspect-nice'
+
+module Musa::Datasets
+  class Score
+    include Enumerable
+
+    include AbsD
+    NaturalKeys = NaturalKeys.freeze
+
+    include ToMXML
+    include Queriable
+    include Render
+
+    using Musa::Extension::InspectNice
+
+    def initialize(hash = nil)
+      raise ArgumentError, "'hash' parameter should be a Hash with time and events information" unless hash.nil? || hash.is_a?(Hash)
+
+      @score = {}
+      @indexer = []
+
+      if hash
+        hash.sort.each do |k, v|
+          raise ArgumentError, "'hash' values for time #{k} should be an Array of events" unless v.is_a?(Array)
+
+          v.each do |vv|
+            at(k, add: vv)
+          end
+        end
+      end
+    end
+
+    def reset
+      @score.clear
+      @indexer.clear
+    end
+
+    def [](key)
+      if NaturalKeys.include?(key) && self.respond_to?(key)
+        self.send(key)
+      end
+    end
+
+    def finish
+      @indexer.collect { |i| i[:finish] }.max
+    end
+
+    def duration
+      (finish || 1r) - 1r
+    end
+
+    def at(time, add: nil)
+      time = time.rationalize
+
+      if add
+        raise ArgumentError, "#{add} is not a Abs dataset" unless add&.is_a?(Musa::Datasets::Abs)
+
+        slot = @score[time] ||= [].extend(QueryableByTimeSlot)
+
+        slot << add
+
+        @indexer << { start: time,
+                      finish: time + add.duration.rationalize,
+                      dataset: add }
+
+        nil
+      else
+        @score[time] ||= [].extend(QueryableByTimeSlot)
+      end
+    end
+
+    def size
+      @score.keys.size
+    end
+
+    def positions
+      @score.keys.sort
+    end
+
+    def each(&block)
+      @score.sort.each(&block)
+    end
+
+    def to_h
+      @score.sort.to_h
+    end
+
+    def between(closed_interval_start, open_interval_finish)
+      @indexer
+        .select { |i| i[:start] < open_interval_finish && i[:finish] > closed_interval_start ||
+                      closed_interval_start == open_interval_finish &&
+                          i[:start] == i[:finish] &&
+                          i[:start] == closed_interval_start }
+        .sort_by { |i| i[:start] }
+        .collect { |i| { start: i[:start],
+                         finish: i[:finish],
+                         start_in_interval: i[:start] > closed_interval_start ? i[:start] : closed_interval_start,
+                         finish_in_interval: i[:finish] < open_interval_finish ? i[:finish] : open_interval_finish,
+                         dataset: i[:dataset] } }.extend(QueryableByDataset)
+    end
+
+    # TODO hay que implementar un effective_start y effective_finish con el inicio/fin dentro del bar, no absoluto
+
+    def changes_between(closed_interval_start, open_interval_finish)
+      (
+        #
+        # we have a start event if the element
+        # begins between queried interval start (included) and interval finish (excluded)
+        #
+        @indexer
+          .select { |i| i[:start] >= closed_interval_start && i[:start] < open_interval_finish }
+          .collect { |i| i.clone.merge({ change: :start, time: i[:start] }) } +
+
+        #
+        # we have a finish event if the element interval finishes
+        # between queried interval start (excluded) and queried interval finish (included) or
+        # element interval finishes exactly on queried interval start
+        # but the element interval started before queried interval start
+        # (the element is not an instant)
+        #
+        @indexer
+          .select { |i| ( i[:finish] > closed_interval_start ||
+                          i[:finish] == closed_interval_start && i[:finish] == i[:start])   &&
+                        ( i[:finish] < open_interval_finish ||
+                          i[:finish] == open_interval_finish && i[:start] < open_interval_finish) }
+          .collect { |i| i.clone.merge({ change: :finish, time: i[:finish] }) } +
+
+        #
+        # when the queried interval has no duration (it's an instant) we have a start and a finish event
+        # if the element also is an instant exactly coincident with the queried interval
+        #
+        @indexer
+          .select { |i| ( closed_interval_start == open_interval_finish &&
+                          i[:start] == closed_interval_start &&
+                          i[:finish] == open_interval_finish) }
+          .collect { |i| [i.clone.merge({ change: :start, time: i[:start] }),
+                          i.clone.merge({ change: :finish, time: i[:finish] })] }
+          .flatten(1)
+      )
+        .sort_by { |i| [ i[:time],
+                         i[:start] < i[:finish] && i[:change] == :finish ? 0 : 1] }
+        .collect { |i| { change: i[:change],
+                         time: i[:time],
+                         start: i[:start],
+                         finish: i[:finish],
+                         start_in_interval: i[:start] > closed_interval_start ? i[:start] : closed_interval_start,
+                         finish_in_interval: i[:finish] < open_interval_finish ? i[:finish] : open_interval_finish,
+                         time_in_interval: if i[:time] < closed_interval_start
+                                             closed_interval_start
+                                           elsif i[:time] > open_interval_finish
+                                             open_interval_finish
+                                           else
+                                             i[:time]
+                                           end,
+                         dataset: i[:dataset] } }.extend(QueryableByDataset)
+    end
+
+    def values_of(attribute)
+      values = Set[]
+      @score.each_value do |slot|
+        slot.each { |dataset| values << dataset[attribute] }
+      end
+      values
+    end
+
+    def subset
+      raise ArgumentError, "subset needs a block with the inclusion condition on the dataset" unless block_given?
+
+      filtered_score = Score.new
+
+      @score.each_pair do |time, datasets|
+        datasets.each do |dataset|
+          filtered_score.at time, add: dataset if yield(dataset)
+        end
+      end
+
+      filtered_score
+    end
+
+    def inspect
+      s = StringIO.new
+
+      first_level1 = true
+
+      s.write "Musa::Datasets::Score.new({\n"
+
+      @score.each do |k, v|
+        s.write "#{ ", \n" unless first_level1 }  #{ k.inspect } => [\n"
+        first_level1 = false
+        first_level2 = true
+
+        v.each do |vv|
+          s.write "#{ ", \n" unless first_level2 }\t#{ vv }"
+          first_level2 = false
+        end
+
+        s.write  " ]"
+      end
+      s.write "\n})"
+
+      s.string
+    end
+  end
+end

data/lib/musa-dsl/datasets/score/queriable.rb

@@ -0,0 +1,48 @@
+module Musa::Datasets; class Score
+  module Queriable
+    module QueryableByTimeSlot
+      def group_by_attribute(attribute)
+        group_by { |e| e[attribute] }.transform_values! { |e| e.extend(QueryableByTimeSlot) }
+      end
+
+      def select_by_attribute(attribute, value = nil)
+        if value.nil?
+          select { |e| !e[attribute].nil? }
+        else
+          select { |e| e[attribute] == value }
+        end.extend(QueryableByTimeSlot)
+      end
+
+      def sort_by_attribute(attribute)
+        select_by_attribute(attribute).sort_by { |e| e[attribute] }.extend(QueryableByTimeSlot)
+      end
+    end
+
+    private_constant :QueryableByTimeSlot
+
+    module QueryableByDataset
+      def group_by_attribute(attribute)
+        group_by { |e| e[:dataset][attribute] }.transform_values! { |e| e.extend(QueryableByDataset) }
+      end
+
+      def select_by_attribute(attribute, value = nil)
+        if value.nil?
+          select { |e| !e[:dataset][attribute].nil? }
+        else
+          select { |e| e[:dataset][attribute] == value }
+        end.extend(QueryableByDataset)
+      end
+
+      def subset
+        raise ArgumentError, "subset needs a block with the inclusion condition on the dataset" unless block_given?
+        select { |e| yield e[:dataset] }.extend(QueryableByDataset)
+      end
+
+      def sort_by_attribute(attribute)
+        select_by_attribute(attribute).sort_by { |e| e[:dataset][attribute] }.extend(QueryableByDataset)
+      end
+    end
+
+    private_constant :QueryableByDataset
+  end
+end; end

data/lib/musa-dsl/datasets/score/render.rb

@@ -0,0 +1,31 @@
+require_relative '../../sequencer'
+require_relative '../../series'
+
+module Musa::Datasets; class Score
+  module Render
+    def render(on:, &block)
+      @score.keys.each do |score_at|
+        effective_wait = score_at - 1r
+
+        @score[score_at].each do |element|
+          case element
+          when Score
+            on.wait effective_wait do
+              element.render(on: on, &block)
+            end
+
+          when Abs
+            on.wait effective_wait do
+              block.call(element)
+            end
+
+          else
+            raise ArgumentError, "Can't sequence #{element} because it's not an Abs dataset"
+          end
+        end
+      end
+
+      nil
+    end
+  end
+end; end

data/lib/musa-dsl/datasets/score/to-mxml/process-pdv.rb

@@ -0,0 +1,160 @@
+require 'prime'
+
+module Musa::Datasets::Score::ToMXML
+  private
+
+  def process_pdv(measure, bar, divisions_per_bar, element, pointer, logger, do_log)
+
+    pitch, octave, sharps = pitch_and_octave_and_sharps(element[:dataset])
+
+    continue_from_previous_bar = element[:start] < bar
+    continue_to_next_bar = element[:finish] > bar + 1r
+
+    effective_start = continue_from_previous_bar ? 0r : element[:start] - bar
+
+    effective_duration = continue_to_next_bar ?
+                             (1r - effective_start) :
+                             (element[:start] + element[:dataset][:duration] - (bar + effective_start))
+
+    effective_duration_decomposition = \
+      integrate_as_dotteable_durations(
+        decompose_as_sum_of_simple_durations(effective_duration))
+
+    if do_log
+      logger.debug "\nprocess_pdv #{element}"
+      logger.debug ""
+      logger.debug "             pointer #{pointer} continue_from_previous #{continue_from_previous_bar} continue_to_next #{continue_to_next_bar}"
+      logger.debug "             effective_start #{effective_start} effective_duration #{effective_duration}"
+      logger.debug "             duration decomposition #{effective_duration_decomposition}"
+    end
+
+    if pointer > effective_start
+      duration_to_go_back = (pointer - effective_start)
+
+      logger.debug "\n         ->  adding backup #{duration_to_go_back * divisions_per_bar}" if do_log
+
+      measure.add_backup(duration_to_go_back * divisions_per_bar)
+      pointer -= duration_to_go_back
+
+
+    elsif pointer < effective_start
+      warn "\n         ->  adding start rest duration #{effective_start - pointer} start #{bar + pointer} finish #{bar + effective_start}" if do_log
+
+      pointer = process_pdv(measure, bar, divisions_per_bar,
+                            { start: bar + pointer,
+                              finish: bar + effective_start,
+                              dataset: { pitch: :silence, duration: effective_start - pointer }.extend(PDV) },
+                            pointer,
+                            logger, do_log)
+    end
+
+    # TODO generalize articulations and other musicxml elements
+
+    staccato = element[:dataset][:st] == 1 || element[:dataset][:st] == true
+    staccatissimo = element[:dataset][:st].is_a?(Numeric) && element[:dataset][:st] > 1
+
+    trill = !element[:dataset][:tr].nil?
+
+    mordent = [:down, :low].include?(element[:dataset][:mor])
+    inverted_mordent = [:up, true].include?(element[:dataset][:mor])
+
+    turn = [:up, true].include?(element[:dataset][:turn])
+    inverted_turn = [:down, :low].include?(element[:dataset][:turn])
+
+    first = true
+
+    until effective_duration_decomposition.empty?
+      duration = effective_duration_decomposition.shift
+
+      type, dots, tuplet_ratio = type_and_dots_and_tuplet_ratio(duration)
+
+      raise NotImplementedError,
+            "Found irregular time (tuplet ratio #{tuplet_ratio}) on element #{element}. " \
+            "Don't know how to handle on this version. " \
+        unless tuplet_ratio == 1
+
+      tied = if continue_from_previous_bar && first && !effective_duration_decomposition.empty?
+               'continue'
+             elsif continue_to_next_bar && effective_duration_decomposition.empty?
+               'continue'
+             elsif !first && !effective_duration_decomposition.empty?
+               'continue'
+             elsif first && !effective_duration_decomposition.empty?
+               'start'
+             elsif !first && effective_duration_decomposition.empty?
+               'stop'
+             else
+               nil
+             end
+
+      slur = if element[:dataset][:grace]
+               { type: 'start', number: 2 }
+             elsif element[:dataset][:graced]
+               { type: 'stop', number: 2 }
+             end
+
+      if pitch == :silence
+        measure.add_rest type: type,
+                         dots: dots,
+                         duration: (duration * divisions_per_bar).to_i,
+                         voice: element[:dataset][:voice]
+      else
+        measure.add_pitch pitch, octave: octave, alter: sharps,
+                          type: type,
+                          dots: dots,
+                          duration: (duration * divisions_per_bar).to_i,
+                          grace: element[:dataset][:grace],
+                          slur: slur,
+                          tied: tied,
+                          tie_stop: tied == 'stop' || tied == 'continue',
+                          tie_start: tied == 'start' || tied == 'continue',
+                          staccato: staccato,
+                          staccatissimo: staccatissimo,
+                          trill_mark: trill,
+                          mordent: mordent,
+                          inverted_mordent: inverted_mordent,
+                          turn: turn,
+                          inverted_turn: inverted_turn,
+                          voice: element[:dataset][:voice]
+      end
+
+      first = false
+      pointer += duration unless element[:dataset][:grace]
+    end
+
+    pointer
+  end
+
+  def pitch_and_octave_and_sharps(pdv)
+    if pdv[:pitch] == :silence
+      [:silence, nil, nil]
+    else
+      p, s = [['C', 0], ['C', 1],
+              ['D', 0], ['D', 1],
+              ['E', 0],
+              ['F', 0], ['F', 1],
+              ['G', 0], ['G', 1],
+              ['A', 0], ['A', 1],
+              ['B', 0]][(pdv[:pitch] - 60) % 12]
+
+      o = 4 + ((pdv[:pitch] - 60).rationalize / 12r).floor
+
+      [p, o, s]
+    end
+  end
+
+  def dynamics_index_of(midi_velocity)
+    return nil unless midi_velocity
+
+    # ppp = midi 16 ... fff = midi 127
+    # mp = dynamics index 6; dynamics = 0..10
+    # TODO create a customizable MIDI velocity to score dynamics bidirectional conversor
+    [0..0, 1..1, 2..8, 9..16, 17..33, 34..49, 49..64, 65..80, 81..96, 97..112, 113..127]
+       .index { |r| r.cover? midi_velocity.round.to_i }
+  end
+
+  def dynamics_to_string(dynamics_index)
+    return nil unless dynamics_index
+    ['pppppp', 'ppppp', 'pppp', 'ppp', 'pp', 'p', 'mp', 'mf', 'f', 'ff', 'fff'][dynamics_index.round.to_i]
+  end
+end