lily/beaming-pattern.cc

   1 /*
   2   beaming-info.cc -- implement Beam_rhythmic_element, Beaming_pattern
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1999--2006 Han-Wen Nienhuys <hanwen@xs4all.nl>
   7 */
   8
   9 #include "beaming-pattern.hh"
  10 #include "context.hh"
  11
  12 Beam_rhythmic_element::Beam_rhythmic_element ()
  13 {
  14   start_moment_ = 0;
  15   beam_count_drul_[LEFT] = 0;
  16   beam_count_drul_[RIGHT] = 0;
  17
  18 }
  19
  20 Beam_rhythmic_element::Beam_rhythmic_element (Moment m, int i)
  21 {
  22   start_moment_ = m;
  23   beam_count_drul_[LEFT] = i;
  24   beam_count_drul_[RIGHT] = i;
  25 }
  26
  27 int
  28 Beaming_pattern::best_splitpoint_index (bool *at_boundary) const
  29 {
  30   *at_boundary = true;
  31   for (vsize i = 1; i < infos_.size (); i++)
  32     {
  33       if (infos_[i].group_start_  == infos_[i].start_moment_)
  34         return i;
  35     }
  36
  37   for (vsize i = 1; i < infos_.size (); i++)
  38     {
  39       if (infos_[i].beat_start_  == infos_[i].start_moment_)
  40         return i;
  41     }
  42
  43   *at_boundary = false;
  44
  45   int min_denominator = INT_MAX;
  46   int min_index = -1;
  47
  48   Moment beat_pos;
  49   for (vsize i = 1; i < infos_.size (); i++)
  50     {
  51       Moment dt = infos_[i].start_moment_ - infos_[i].beat_start_;
  52       if (dt.den () < min_denominator)
  53         {
  54           min_denominator = dt.den ();
  55           min_index = i;
  56         }
  57     }
  58
  59   return min_index;
  60 }
  61
  62 int
  63 Beaming_pattern::beam_extend_count (Direction d) const
  64 {
  65   if (infos_.size () == 1)
  66     return infos_[0].beam_count_drul_[d];
  67
  68   Beam_rhythmic_element thisbeam = boundary (infos_, d, 0);
  69   Beam_rhythmic_element next = boundary (infos_, d, 1);
  70
  71   return min (thisbeam.beam_count_drul_[-d], next.beam_count_drul_[d]);
  72 }
  73
  74 void
  75 Beaming_pattern::beamify (Context *context)
  76 {
  77   if (infos_.size () <= 1)
  78     return;
  79
  80   bool subdivide_beams = to_boolean (context->get_property ("subdivideBeams"));
  81   Moment beat_length = robust_scm2moment (context->get_property ("beatLength"), Moment (1, 4));
  82   Moment measure_length = robust_scm2moment (context->get_property ("beatLength"), Moment (1, 4));
  83
  84   if (infos_[0].start_moment_ < Moment (0))
  85     for (vsize i = 0; i < infos_.size(); i++)
  86       infos_[i].start_moment_ += measure_length;
  87
  88   SCM grouping = context->get_property ("beatGrouping");
  89   Moment measure_pos (0);
  90
  91   vector<Moment> group_starts;
  92   vector<Moment> beat_starts;
  93
  94   while (measure_pos <= infos_.back().start_moment_)
  95     {
  96       int count = 2;
  97       if (scm_is_pair (grouping))
  98         {
  99           count = scm_to_int (scm_car (grouping));
 100           grouping = scm_cdr (grouping);
 101         }
 102
 103       group_starts.push_back (measure_pos);
 104       for (int i = 0; i < count; i++)
 105         {
 106           beat_starts.push_back (measure_pos + beat_length * i);
 107         }
 108       measure_pos += beat_length * count;
 109     }
 110
 111   vsize j = 0;
 112   vsize k = 0;
 113   for (vsize i = 0; i  < infos_.size(); i++)
 114     {
 115       while (j < group_starts.size()-1
 116              && group_starts[j+1] <= infos_[i].start_moment_)
 117         j++;
 118
 119       infos_[i].group_start_ = group_starts[j];
 120
 121       while (k < beat_starts.size()-1
 122              && beat_starts[k+1] <= infos_[i].start_moment_)
 123         k++;
 124
 125       infos_[i].beat_start_ = beat_starts[k];
 126     }
 127
 128   beamify (subdivide_beams);
 129 }
 130
 131
 132 void
 133 Beaming_pattern::beamify (bool subdivide_beams)
 134 {
 135   if (infos_.size () <= 1)
 136     return;
 137
 138   Drul_array<Beaming_pattern> splits;
 139
 140   bool at_boundary = false;
 141   int m = best_splitpoint_index (&at_boundary);
 142
 143   splits[LEFT].infos_ = vector<Beam_rhythmic_element> (infos_.begin (),
 144                                               infos_.begin () + m);
 145   splits[RIGHT].infos_ = vector<Beam_rhythmic_element> (infos_.begin () + m,
 146                                                infos_.end ());
 147
 148   Direction d = LEFT;
 149
 150   do
 151     {
 152       splits[d].beamify (subdivide_beams);
 153     }
 154   while (flip (&d) != LEFT);
 155
 156   int middle_beams = ((at_boundary && subdivide_beams)
 157                       ? 1
 158                       : min (splits[RIGHT].beam_extend_count (LEFT),
 159                              splits[LEFT].beam_extend_count (RIGHT)));
 160
 161   do
 162     {
 163       if (splits[d].infos_.size () != 1)
 164         boundary (splits[d].infos_, -d, 0).beam_count_drul_[-d] = middle_beams;
 165     }
 166   while (flip (&d) != LEFT);
 167
 168   infos_ = splits[LEFT].infos_;
 169   infos_.insert (infos_.end (),
 170                  splits[RIGHT].infos_.begin (),
 171                  splits[RIGHT].infos_.end ());
 172 }
 173
 174
 175 void
 176 Beaming_pattern::add_stem (Moment m, int b)
 177 {
 178   infos_.push_back (Beam_rhythmic_element (m, b));
 179 }
 180
 181 Beaming_pattern::Beaming_pattern ()
 182 {
 183 }
 184
 185 int
 186 Beaming_pattern::beamlet_count (int i, Direction d) const
 187 {
 188   return infos_.at (i).beam_count_drul_[d];
 189 }