X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fbeaming-pattern.cc;h=7567caa700744a3b72dd23b479d230ecd7ca57ac;hb=d7c0f4263534307616c82d9b2ce6fdef9472456f;hp=b87b863656047ae56358cb5b56901599e9344b35;hpb=2a5bf602e34fadfeb14b0d7be3b83fa587be3fbb;p=lilypond.git diff --git a/lily/beaming-pattern.cc b/lily/beaming-pattern.cc index b87b863656..7567caa700 100644 --- a/lily/beaming-pattern.cc +++ b/lily/beaming-pattern.cc @@ -1,24 +1,41 @@ /* - beaming-info.cc -- implement Beam_rhythmic_element, Beaming_pattern + This file is part of LilyPond, the GNU music typesetter. - A Beaming_pattern object takes a set of stems at given moments and calculates - the pattern of their beam. That is, it works out, for each stem, how many - beams should be connected to the right and left sides of that stem. In - calculating this, Beaming_pattern takes into account - - the rhythmic position of the stems - - the options that are defined in Beaming_options + Copyright (C) 1999--2010 Han-Wen Nienhuys - source file of the GNU LilyPond music typesetter + LilyPond is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. - (c) 1999--2007 Han-Wen Nienhuys + LilyPond is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with LilyPond. If not, see . */ -#include "beaming-pattern.hh" #include "context.hh" +#include "beaming-pattern.hh" +/* + Represents a stem belonging to a beam. Sometimes (for example, if the stem + belongs to a rest and stemlets aren't used) the stem will be invisible. + + The rhythmic_importance_ of an element tells us the significance of the + moment at which this element occurs. For example, an element that occurs at + a beat is more significant than one that doesn't. Smaller number are + more important. The rhythmic_importance_ is decided and filled in by + Beaming_pattern. A rhythmic_importance_ smaller than zero has extra + significance: it represents the start of a beat and therefore beams may + need to be subdivided. +*/ Beam_rhythmic_element::Beam_rhythmic_element () { start_moment_ = 0; + rhythmic_importance_ = 0; beam_count_drul_[LEFT] = 0; beam_count_drul_[RIGHT] = 0; invisible_ = false; @@ -28,121 +45,68 @@ Beam_rhythmic_element::Beam_rhythmic_element () Beam_rhythmic_element::Beam_rhythmic_element (Moment m, int i, bool inv) { start_moment_ = m; + rhythmic_importance_ = 0; beam_count_drul_[LEFT] = i; beam_count_drul_[RIGHT] = i; invisible_ = inv; } - void Beam_rhythmic_element::de_grace () { if (start_moment_.grace_part_) { - start_moment_.main_part_ = start_moment_.grace_part_; + start_moment_.main_part_ = start_moment_.grace_part_; start_moment_.grace_part_ = 0; } } int -count_factor_twos (int x) -{ - int c = 0; - while (x && x % 2 == 0) - { - x /= 2; - c ++; - } - - return c; -} - -bool -Beaming_pattern::is_next_to_invisible_stem (vsize i) const +Beam_rhythmic_element::count (Direction d) const { - return infos_[i].invisible_ - || (i > 0 && infos_[i-1].invisible_); + return beam_count_drul_[d]; } /* - Finds the best point at which to subdivide a beam. In order of priority - (highest to lowest) this is - - before or after an invisible beam - - at the start of a beat group - - at the start of a beat - - whose position in its beat has the smallest denominator (that is, - a stem that starts halfway through a beat will be preferred over stems - that start 1/3 or 2/3s of the way through the beat). - - any other beam - - at the start of a beat group - - at the start of a beat - - whose position in its beat has the smallest denominator - - If the split point occurs at the start of a beat group or at the start of a - beat, at_boundary will be set to true. Otherwise, it will be set to false. + Finds the appropriate direction for the flags at the given index that + hang below the neighbouring flags. If + the stem has no more flags than either of its neighbours, this returns + CENTER. */ -int -Beaming_pattern::best_splitpoint_index (bool *at_boundary) const +Direction +Beaming_pattern::flag_direction (Beaming_options const &options, vsize i) const { - bool require_invisible = false; - for (vsize i = 0; i < infos_.size (); i++) - require_invisible |= infos_[i].invisible_; - - *at_boundary = true; - for (vsize i = 1; i < infos_.size (); i++) - { - if (infos_[i].group_start_ == infos_[i].start_moment_ - && (!require_invisible || is_next_to_invisible_stem (i))) - return i; - } - - for (vsize i = 1; i < infos_.size (); i++) - { - if (infos_[i].beat_start_ == infos_[i].start_moment_ - && (!require_invisible || is_next_to_invisible_stem (i))) - return i; - } - - *at_boundary = false; - - int min_den = INT_MAX; - int min_index = -1; - - for (vsize i = 1; i < infos_.size (); i++) + // The extremal stems shouldn't be messed with, so it's appropriate to + // return CENTER here also. + if (i == 0 || i == infos_.size () - 1) + return CENTER; + + int count = infos_[i].count (LEFT); // Both directions should still be the same + int left_count = infos_[i-1].count (RIGHT); + int right_count = infos_[i+1].count (LEFT); + + // If we are told to subdivide beams and we are next to a beat, point the + // beamlet away from the beat. + if (options.subdivide_beams_) { - Moment dt = infos_[i].start_moment_ - infos_[i].beat_start_; - - /* - This is a kludge, for the most common case of 16th, 32nds - etc. What should really happen is that \times x/y should - locally introduce a voice-specific beat duration. (or - perhaps: a list of beat durations for nested tuplets.) - - */ - - dt /= infos_[i].beat_length_; - - if (dt.den () < min_den - && (!require_invisible || is_next_to_invisible_stem (i))) - { - min_den = dt.den (); - min_index = i; - } + if (infos_[i].rhythmic_importance_ < 0) + return RIGHT; + else if (infos_[i+1].rhythmic_importance_ < 0) + return LEFT; } - return min_index; -} - -int -Beaming_pattern::beam_extend_count (Direction d) const -{ - if (infos_.size () == 1) - return infos_[0].beam_count_drul_[d]; + if (count <= left_count && count <= right_count) + return CENTER; - Beam_rhythmic_element thisbeam = boundary (infos_, d, 0); - Beam_rhythmic_element next = boundary (infos_, d, 1); + // Try to avoid sticking-out flags as much as possible by pointing my flags + // at the neighbour with the most flags. + else if (right_count > left_count) + return RIGHT; + else if (left_count > right_count) + return LEFT; - return min (thisbeam.beam_count_drul_[-d], next.beam_count_drul_[d]); + // If all else fails, point the beamlet away from the important moment. + return (infos_[i].rhythmic_importance_ <= infos_[i+1].rhythmic_importance_) ? RIGHT : LEFT; } void @@ -168,108 +132,73 @@ Beaming_pattern::beamify (Beaming_options const &options) if (infos_[0].start_moment_ < Moment (0)) for (vsize i = 0; i < infos_.size (); i++) infos_[i].start_moment_ += options.measure_length_; - - Moment measure_pos (0); - - vector group_starts; - vector beat_starts; - // Find the starting moments of the beats and the groups. - SCM grouping = options.grouping_; - while (measure_pos <= infos_.back ().start_moment_) + find_rhythmic_importance (options); + + for (vsize i = 1; i < infos_.size () - 1; i++) { - int count = 2; - if (scm_is_pair (grouping)) + Direction non_flag_dir = other_dir (flag_direction (options, i)); + if (non_flag_dir) { - count = scm_to_int (scm_car (grouping)); - grouping = scm_cdr (grouping); - } + int importance = (non_flag_dir == LEFT) + ? infos_[i].rhythmic_importance_ : infos_[i+1].rhythmic_importance_; + int count = (importance < 0 && options.subdivide_beams_) + ? 1 : min (infos_[i].count (non_flag_dir), + infos_[i+non_flag_dir].count (-non_flag_dir)); - group_starts.push_back (measure_pos); - for (int i = 0; i < count; i++) - { - beat_starts.push_back (measure_pos + options.beat_length_ * i); + infos_[i].beam_count_drul_[non_flag_dir] = count; } - measure_pos += options.beat_length_ * count; } - - // Set the group_start_ and beam_start_ properties of each stem. - vsize j = 0; - vsize k = 0; - for (vsize i = 0; i < infos_.size (); i++) - { - while (j + 1 < group_starts.size () - && group_starts[j+1] <= infos_[i].start_moment_) - j++; - - if (j < group_starts.size ()) - infos_[i].group_start_ = group_starts[j]; - - infos_[i].beat_length_ = options.beat_length_; - while (k + 1 < beat_starts.size () - && beat_starts[k+1] <= infos_[i].start_moment_) - k++; - - if (k < beat_starts.size ()) - infos_[i].beat_start_ = beat_starts[k]; - } - - beamify (options.subdivide_beams_); } - -/* - Determines beaming patterns by splitting the list of stems recursively. - - Given a list of stems, we split it at the most 'natural' place (eg. at - the beginning of a beat) as determined by best_splitpoint_index. We - then beamify both subsets of beams. Finally, we determine the number of - beams between the subsets. - - Note: if one of the subsets has only one element, we will not modify its - beams. This ensure that, for every stem, we will modify its beam count on at - most one side. -*/ void -Beaming_pattern::beamify (bool subdivide_beams) +Beaming_pattern::find_rhythmic_importance (Beaming_options const &options) { - if (infos_.size () <= 1) - return; - - Drul_array splits; - - bool at_boundary = false; - int m = best_splitpoint_index (&at_boundary); - - splits[LEFT].infos_ = vector (infos_.begin (), - infos_.begin () + m); - splits[RIGHT].infos_ = vector (infos_.begin () + m, - infos_.end ()); - - Direction d = LEFT; + Moment measure_pos (0); + SCM grouping = options.grouping_; + vsize i = 0; - do + // Mark the importance of stems that start at a beat or a beat group. + while (i < infos_.size ()) { - splits[d].beamify (subdivide_beams); - } - while (flip (&d) != LEFT); + // If a beat grouping is not specified, default to 2 beats per group. + int count = 2; + if (scm_is_pair (grouping)) + { + count = scm_to_int (scm_car (grouping)); + grouping = scm_cdr (grouping); + } - int middle_beams = (at_boundary && subdivide_beams) - ? 1 - : min (splits[RIGHT].beam_extend_count (LEFT), - splits[LEFT].beam_extend_count (RIGHT)); + // Mark the start of this beat group + if (infos_[i].start_moment_ == measure_pos) + infos_[i].rhythmic_importance_ = -2; - do - { - if (splits[d].infos_.size () != 1) - boundary (splits[d].infos_, -d, 0).beam_count_drul_[-d] = middle_beams; + // Mark the start of each unit up to the end of this beat group. + for (int unit = 1; unit <= count; unit++) + { + Moment next_measure_pos = measure_pos + options.base_moment_; + + while (i < infos_.size () && infos_[i].start_moment_ < next_measure_pos) + { + Moment dt = infos_[i].start_moment_ - measure_pos; + + // The rhythmic importance of a stem between beats depends on its fraction + // of a beat: those stems with a lower denominator are deemed more + // important. + // FIXME: This is not the right way to do things for tuplets. For example, + // in an 8th-note triplet with a quarter-note beat, 1/3 of a beat should be + // more important than 1/2. + if (infos_[i].rhythmic_importance_ >= 0) + infos_[i].rhythmic_importance_ = (dt / options.base_moment_).den (); + + i++; + } + + measure_pos = next_measure_pos; + if (i < infos_.size () && infos_[i].start_moment_ == measure_pos) + infos_[i].rhythmic_importance_ = -1; + } } - while (flip (&d) != LEFT); - - infos_ = splits[LEFT].infos_; - infos_.insert (infos_.end (), - splits[RIGHT].infos_.begin (), - splits[RIGHT].infos_.end ()); } @@ -284,7 +213,7 @@ Beaming_pattern::unbeam_invisible_stems () for (vsize i = 1; i < infos_.size (); i++) if (infos_[i].invisible_) { - int b = infos_[i-1].beam_count_drul_[LEFT]; + int b = min (infos_[i].count (LEFT), infos_[i-1].count (LEFT)); infos_[i].beam_count_drul_[LEFT] = b; infos_[i].beam_count_drul_[RIGHT] = b; } @@ -292,7 +221,7 @@ Beaming_pattern::unbeam_invisible_stems () for (vsize i = infos_.size (); i--;) if (infos_[i].invisible_) { - int b = min (infos_[i].beam_count_drul_[LEFT], infos_[i+1].beam_count_drul_[LEFT]); + int b = min (infos_[i].count (LEFT), infos_[i+1].count (LEFT)); infos_[i].beam_count_drul_[LEFT] = b; infos_[i].beam_count_drul_[RIGHT] = b; } @@ -315,13 +244,60 @@ Beaming_pattern::beamlet_count (int i, Direction d) const return infos_.at (i).beam_count_drul_[d]; } +Moment +Beaming_pattern::start_moment (int i) const +{ + return infos_.at (i).start_moment_; +} + +Moment +Beaming_pattern::end_moment (int i) const +{ + Duration *dur = new Duration (2 + max (beamlet_count (i, LEFT), + beamlet_count (i, RIGHT)), + 0); + + return infos_.at (i).start_moment_ + dur->get_length(); +} + +bool +Beaming_pattern::invisibility (int i) const +{ + return infos_.at (i).invisible_; +} + +/* + Split a beamin pattern at index i and return a new + Beaming_pattern containing the removed elements +*/ +Beaming_pattern * +Beaming_pattern::split_pattern (int i) +{ + Beaming_pattern* new_pattern=0; + int count; + + new_pattern = new Beaming_pattern (); + for (vsize j=i+1; jadd_stem (start_moment (j), + count, + invisibility (j)); + } + for (vsize j=i+1; jget_property ("beatGrouping"); + grouping_ = context->get_property ("beatStructure"); subdivide_beams_ = to_boolean (context->get_property ("subdivideBeams")); - beat_length_ = robust_scm2moment (context->get_property ("beatLength"), Moment (1, 4)); - measure_length_ = robust_scm2moment (context->get_property ("measureLength"), Moment (1, 4)); + base_moment_ = robust_scm2moment (context->get_property ("baseMoment"), + Moment (1, 4)); + measure_length_ = robust_scm2moment (context->get_property ("measureLength"), + Moment (4, 4)); } Beaming_options::Beaming_options ()