lily/beam.cc

   1 /*
   2   beam.cc -- implement Beam
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
   7
   8   TODO
   9
  10   Less hairy code.  knee: ([\stem 1; c8 \stem -1; c8]
  11
  12 */
  13
  14 #include <math.h>
  15
  16 #include "p-col.hh"
  17 #include "varray.hh"
  18 #include "proto.hh"
  19 #include "dimen.hh"
  20 #include "beam.hh"
  21 #include "abbreviation-beam.hh"
  22 #include "misc.hh"
  23 #include "debug.hh"
  24 #include "atom.hh"
  25 #include "molecule.hh"
  26 #include "leastsquares.hh"
  27 #include "stem.hh"
  28 #include "paper-def.hh"
  29 #include "lookup.hh"
  30 #include "grouping.hh"
  31 #include "stem-info.hh"
  32 #include "main.hh"  // experimental features
  33
  34
  35 IMPLEMENT_IS_TYPE_B1 (Beam, Spanner);
  36
  37 const int MINIMUM_STEMLEN[6] = {
  38   0, // just in case
  39   5,
  40   4,
  41   3,
  42   2,
  43   2,
  44 };
  45
  46 Beam::Beam ()
  47 {
  48   slope_f = 0;
  49   left_y = 0.0;
  50 }
  51
  52 void
  53 Beam::add (Stem*s)
  54 {
  55   stems.push (s);
  56   s->add_dependency (this);
  57   s->beam_l_ = this;
  58
  59   if (!spanned_drul_[LEFT])
  60     set_bounds (LEFT,s);
  61   else
  62     set_bounds (RIGHT,s);
  63 }
  64
  65 Molecule*
  66 Beam::brew_molecule_p () const
  67 {
  68   Molecule *mol_p = new Molecule;
  69   Real inter_f = paper ()->internote_f ();
  70   Real x0 = stems[0]->hpos_f ();
  71   for (int j=0; j <stems.size (); j++)
  72     {
  73       Stem *i = stems[j];
  74       Stem * prev = (j > 0)? stems[j-1] : 0;
  75       Stem * next = (j < stems.size ()-1) ? stems[j+1] :0;
  76
  77       Molecule sb = stem_beams (i, next, prev);
  78       Real  x = i->hpos_f ()-x0;
  79       sb.translate (Offset (x, (x * slope_f  + left_y)* inter_f));
  80       mol_p->add (sb);
  81     }
  82   mol_p->translate_axis (x0 - spanned_drul_[LEFT]->absolute_coordinate (X_AXIS), X_AXIS);
  83   return mol_p;
  84 }
  85
  86 Offset
  87 Beam::center () const
  88 {
  89   Real w= (paper ()->note_width () + width ().length ())/2.0;
  90   return Offset (w, (left_y + w* slope_f)*paper ()->internote_f ());
  91 }
  92
  93 void
  94 Beam::do_pre_processing ()
  95 {
  96   if (!dir_)
  97     set_default_dir ();
  98 }
  99
 100 void
 101 Beam::do_print () const
 102 {
 103 #ifndef NPRINT
 104   DOUT << "slope_f " <<slope_f << "left ypos " << left_y;
 105   Spanner::do_print ();
 106 #endif
 107 }
 108
 109 void
 110 Beam::do_post_processing ()
 111 {
 112   if (stems.size () < 2)
 113     {
 114       warning (_ ("Beam with less than 2 stems"));
 115       transparent_b_ = true;
 116       return ;
 117     }
 118   solve_slope ();
 119   set_stemlens ();
 120 }
 121
 122 void
 123 Beam::do_substitute_dependent (Score_elem*o,Score_elem*n)
 124 {
 125   if (o->is_type_b (Stem::static_name ()))
 126       stems.substitute ((Stem*)o->item (),  n? (Stem*) n->item ():0);
 127 }
 128
 129 Interval
 130 Beam::do_width () const
 131 {
 132   return Interval (stems[0]->hpos_f (),
 133                    stems.top ()->hpos_f ());
 134 }
 135
 136 void
 137 Beam::set_default_dir ()
 138 {
 139   Drul_array<int> total;
 140   total[UP]  = total[DOWN] = 0;
 141   Drul_array<int> count;
 142   count[UP]  = count[DOWN] = 0;
 143   Direction d = DOWN;
 144
 145   for (int i=0; i <stems.size (); i++)
 146     do {
 147       Stem *s = stems[i];
 148       int current = s->dir_
 149         ? (1 + d * s->dir_)/2
 150         : s->get_center_distance (Direction (-d));
 151
 152       if (current)
 153         {
 154           total[d] += current;
 155           count[d] ++;
 156         }
 157
 158     } while ((d *= -1) != DOWN);
 159
 160    do {
 161     if (!total[d])
 162       count[d] = 1;
 163   } while ((d *= -1) != DOWN);
 164
 165   /* the following relation is equal to
 166           up / up_count > down / down_count
 167           */
 168   dir_ = (total[UP] * count[DOWN] > total[DOWN] * count[UP]) ? UP : DOWN;
 169
 170   for (int i=0; i <stems.size (); i++)
 171     {
 172       Stem *sl = stems[i];
 173       sl->dir_ = dir_;
 174     }
 175 }
 176
 177 /*
 178   should use minimum energy formulation (cf linespacing)
 179
 180 */
 181 void
 182 Beam::solve_slope ()
 183 {
 184   Array<Stem_info> sinfo;
 185   for (int j=0; j <stems.size (); j++)
 186     {
 187       Stem *i = stems[j];
 188
 189       i->set_default_extents ();
 190       if (i->invisible_b ())
 191         continue;
 192
 193       Stem_info info (i);
 194       sinfo.push (info);
 195     }
 196   if (! sinfo.size ())
 197     slope_f = left_y = 0;
 198   else if (sinfo.size () == 1)
 199     {
 200       slope_f = 0;
 201       left_y = sinfo[0].idealy_f_;
 202     }
 203   else
 204     {
 205
 206       Real leftx = sinfo[0].x;
 207       Least_squares l;
 208       for (int i=0; i < sinfo.size (); i++)
 209         {
 210           sinfo[i].x -= leftx;
 211           l.input.push (Offset (sinfo[i].x, sinfo[i].idealy_f_));
 212         }
 213
 214       l.minimise (slope_f, left_y);
 215     }
 216
 217   Real dy = 0.0;
 218   for (int i=0; i < sinfo.size (); i++)
 219     {
 220       Real y = sinfo[i].x * slope_f + left_y;
 221       Real my = sinfo[i].miny_f_;
 222
 223       if (my - y > dy)
 224         dy = my -y;
 225     }
 226   left_y += dy;
 227   left_y *= dir_;
 228
 229   slope_f *= dir_;
 230
 231   /*
 232     This neat trick is by Werner Lemberg, damped = tanh (slope_f) corresponds
 233     with some tables in [Wanske]
 234     */
 235   slope_f = 0.6 * tanh (slope_f);
 236
 237   quantise_yspan ();
 238
 239   // y-values traditionally use internote dimension: therefore slope = (y/in)/x
 240   // but mf and beam-lookup use PT dimension for y (as used for x-values)
 241   // ugh --- there goes our simplified but careful quantisation
 242   Real sl = slope_f * paper ()->internote_f ();
 243   paper ()->lookup_l ()->beam (sl, 20 PT);
 244   slope_f = sl / paper ()->internote_f ();
 245 }
 246
 247 void
 248 Beam::quantise_yspan ()
 249 {
 250   /*
 251     [Ross] (simplification of)
 252     Try to set slope_f complying with y-span of:
 253       - zero
 254       - beam_thickness / 2 + staffline_thickness / 2
 255       - beam_thickness + staffline_thickness
 256     + n * interline
 257     */
 258   Real interline_f = paper ()->interline_f ();
 259   Real internote_f = interline_f / 2;
 260   Real staffline_thickness = paper ()->rule_thickness ();
 261   Real beam_thickness = 0.48 * (interline_f - staffline_thickness);
 262
 263   const int QUANTS = 3;
 264   Real qdy[QUANTS] = {
 265     0,
 266     beam_thickness / 2 + staffline_thickness / 2,
 267     beam_thickness + staffline_thickness
 268   };
 269
 270   Real xspan_f = stems.top ()->hpos_f () - stems[0]->hpos_f ();
 271   // y-values traditionally use internote dimension: therefore slope = (y/in)/x
 272   Real yspan_f = xspan_f * abs (slope_f * internote_f);
 273   int yspan_i = (int)(yspan_f / interline_f);
 274   Real q = (yspan_f / interline_f - yspan_i) * interline_f;
 275   int i = 0;
 276   for (; i < QUANTS - 1; i++)
 277     if ((q >= qdy[i]) && (q <= qdy[i + 1]))
 278       {
 279         if (q - qdy[i] < qdy[i + 1] - q)
 280           break;
 281         else
 282         {
 283           i++;
 284           break;
 285         }
 286       }
 287   q = qdy[i];
 288
 289   yspan_f = (Real)yspan_i * interline_f + q;
 290   // y-values traditionally use internote dimension: therefore slope = (y/in)/x
 291   slope_f = yspan_f / xspan_f / internote_f * sign (slope_f);
 292 }
 293
 294 void
 295 Beam::quantise_left_y (Beam::Pos pos, bool extend_b)
 296 {
 297   /*
 298    quantising left y should suffice, as slope is quantised too
 299    if extend then stems must not get shorter
 300    */
 301
 302   Real interline_f = paper ()->interline_f ();
 303   Real internote_f = interline_f / 2;
 304   Real staffline_thickness = paper ()->rule_thickness ();
 305   Real beam_thickness = 0.48 * (interline_f - staffline_thickness);
 306
 307   const int QUANTS = 6;
 308   Real qy[QUANTS] = {
 309     -staffline_thickness,
 310     beam_thickness / 2,
 311     beam_thickness + staffline_thickness / 2,
 312     interline_f / 2 + beam_thickness / 2 + staffline_thickness / 2,
 313     interline_f - staffline_thickness,
 314     interline_f + beam_thickness / 2,
 315   };
 316   /*
 317    ugh, using i triggers gcc 2.7.2.1 internal compiler error (far down):
 318    for (int i = 0; i < QUANTS; i++)
 319    */
 320   for (int ii = 0; ii < QUANTS; ii++)
 321     qy[ii] -= beam_thickness / 2;
 322   Pos qpos[QUANTS] = {
 323     HANG,
 324     STRADDLE,
 325     SIT,
 326     INTER,
 327     HANG,
 328     STRADDLE
 329   };
 330
 331   // y-values traditionally use internote dimension
 332   Real y = left_y * internote_f;
 333   int y_i = (int)floor(y / interline_f);
 334   y = (y / interline_f - y_i) * interline_f;
 335
 336   if (y < 0)
 337     for (int ii = 0; ii < QUANTS; ii++)
 338       qy[ii] -= interline_f;
 339
 340   int lower_i = 0;
 341   int i = 0;
 342   for (; i < QUANTS; i++)
 343     {
 344       if (qy[i] > y)
 345         break;
 346       // found if lower_i is allowed, and nearer (from below) y than new pos
 347       if ((pos & qpos[lower_i]) && (y - qy[lower_i] < y - qy[i]))
 348         break;
 349       // if new pos is allowed or old pos isn't: assign new pos
 350       if ((pos & qpos[i]) || !(pos & qpos[lower_i]))
 351         lower_i = i;
 352     }
 353
 354   int upper_i = QUANTS - 1;
 355   for (i = QUANTS - 1; i >= 0; i--)
 356     {
 357       if (qy[i] < y)
 358         break;
 359       // found if upper_i is allowed, and nearer (from above) y than new pos
 360       if ((pos & qpos[upper_i]) && (qy[upper_i] - y < qy[i] - y))
 361         break;
 362       // if new pos is allowed or old pos isn't: assign new pos
 363       if ((pos & qpos[i]) || !(pos & qpos[upper_i]))
 364         upper_i = i;
 365     }
 366
 367   // y-values traditionally use internote dimension
 368   Real upper_y = (qy[upper_i] + interline_f * y_i) / internote_f;
 369   Real lower_y = (qy[lower_i] + interline_f * y_i) / internote_f;
 370
 371   if (extend_b)
 372     left_y = (dir_ > 0 ? upper_y : lower_y);
 373   else
 374     left_y = (upper_y - left_y < y - lower_y ? upper_y : lower_y);
 375 }
 376
 377 void
 378 Beam::set_stemlens ()
 379 {
 380   Real x0 = stems[0]->hpos_f ();
 381   Real dy = 0;
 382
 383   Real interline_f = paper ()->interline_f ();
 384   Real internote_f = interline_f / 2;
 385   Real staffline_thickness = paper ()->rule_thickness ();
 386   Real beam_thickness = 0.48 * (interline_f - staffline_thickness);
 387   Real interbeam_f = paper ()->interbeam_f ();
 388   Real xspan_f = stems.top ()->hpos_f () - stems[0]->hpos_f ();
 389   /*
 390    ugh, y values are in "internote" dimension
 391    */
 392   Real yspan_f = xspan_f * abs (slope_f * internote_f);
 393   int yspan_i = (int)(yspan_f / interline_f);
 394
 395   Pos left_pos = NONE;
 396
 397   if (yspan_f < staffline_thickness / 2)
 398     left_pos = (Pos)(STRADDLE | SIT | HANG);
 399   else
 400     left_pos = (Pos) (sign (slope_f) > 0 ? STRADDLE | HANG
 401       : SIT | STRADDLE);
 402
 403   /*
 404    ugh, slope currently mangled by availability mf chars...
 405    be more generous regarding beam position between stafflines
 406    */
 407   Real q = (yspan_f / interline_f - yspan_i) * interline_f;
 408   if (q < interline_f / 3 - beam_thickness / 2)
 409     left_pos = (Pos) (left_pos | INTER);
 410
 411   if (stems[0]->beams_right_i_ > 1)
 412     left_pos = (Pos) (dir_ > 0 ? HANG : SIT);
 413
 414   // ugh, rounding problems!
 415   const Real EPSILON = interline_f / 10;
 416   do
 417     {
 418       left_y += dy * dir_;
 419       quantise_left_y (left_pos, dy);
 420       dy = 0;
 421       for (int j=0; j < stems.size (); j++)
 422         {
 423           Stem *s = stems[j];
 424
 425           Real x = s->hpos_f () - x0;
 426           s->set_stemend (left_y + slope_f * x);
 427           Real y = s->stem_length_f ();
 428           int mult = max (stems[j]->beams_left_i_, stems[j]->beams_right_i_);
 429           if (mult > 1)
 430               // dim(y) = internote
 431               y -= (mult - 1) * interbeam_f / internote_f;
 432           if (y < MINIMUM_STEMLEN[mult])
 433             dy = dy >? (MINIMUM_STEMLEN[mult] - y);
 434         }
 435     } while (abs (dy) > EPSILON);
 436 }
 437
 438 void
 439 Beam::set_grouping (Rhythmic_grouping def, Rhythmic_grouping cur)
 440 {
 441   def.OK ();
 442   cur.OK ();
 443   assert (cur.children.size () == stems.size ());
 444
 445   cur.split (def);
 446
 447   Array<int> b;
 448   {
 449     Array<int> flags;
 450     for (int j=0; j <stems.size (); j++)
 451       {
 452         Stem *s = stems[j];
 453
 454         int f = s->flag_i_ - 2;
 455         assert (f>0);
 456         flags.push (f);
 457       }
 458     int fi =0;
 459     b= cur.generate_beams (flags, fi);
 460     b.insert (0,0);
 461     b.push (0);
 462     assert (stems.size () == b.size ()/2);
 463   }
 464
 465   for (int j=0, i=0; i < b.size () && j <stems.size (); i+= 2, j++)
 466     {
 467       Stem *s = stems[j];
 468       s->beams_left_i_ = b[i];
 469       s->beams_right_i_ = b[i+1];
 470     }
 471 }
 472
 473 /*
 474   beams to go with one stem.
 475   */
 476 Molecule
 477 Beam::stem_beams (Stem *here, Stem *next, Stem *prev) const
 478 {
 479   assert (!next || next->hpos_f () > here->hpos_f ());
 480   assert (!prev || prev->hpos_f () < here->hpos_f ());
 481   //    Real dy=paper ()->internote_f ()*2;
 482   Real dy = paper ()->interbeam_f ();
 483   Real stemdx = paper ()->rule_thickness ();
 484   Real sl = slope_f*paper ()->internote_f ();
 485   paper ()->lookup_l ()->beam (sl, 20 PT);
 486
 487   Molecule leftbeams;
 488   Molecule rightbeams;
 489
 490   /* half beams extending to the left. */
 491   if (prev)
 492     {
 493       int lhalfs= lhalfs = here->beams_left_i_ - prev->beams_right_i_ ;
 494       int lwholebeams= here->beams_left_i_ <? prev->beams_right_i_ ;
 495       Real w = (here->hpos_f () - prev->hpos_f ())/4;
 496       Atom a;
 497       if (lhalfs)               // generates warnings if not
 498         a =  paper ()->lookup_l ()->beam (sl, w);
 499       a.translate (Offset (-w, -w * sl));
 500       for (int j = 0; j  < lhalfs; j++)
 501         {
 502           Atom b (a);
 503           b.translate_axis (-dir_ * dy * (lwholebeams+j), Y_AXIS);
 504           leftbeams.add (b);
 505         }
 506     }
 507
 508   if (next)
 509     {
 510       int rhalfs = here->beams_right_i_ - next->beams_left_i_;
 511       int rwholebeams = here->beams_right_i_ <? next->beams_left_i_;
 512
 513       Real w = next->hpos_f () - here->hpos_f ();
 514       Atom a = paper ()->lookup_l ()->beam (sl, w + stemdx);
 515
 516       int j = 0;
 517       Real gap_f = 0;
 518       if (here->beam_gap_i_)
 519         {
 520           int nogap = rwholebeams - here->beam_gap_i_;
 521           for (; j  < nogap; j++)
 522             {
 523               Atom b (a);
 524               b.translate_axis (-dir_ * dy * j, Y_AXIS);
 525               rightbeams.add (b);
 526             }
 527           // TODO: notehead widths differ for different types
 528           gap_f = paper ()->note_width () / 2;
 529           w -= 2 * gap_f;
 530           a = paper ()->lookup_l ()->beam (sl, w + stemdx);
 531         }
 532
 533       for (; j  < rwholebeams; j++)
 534         {
 535           Atom b (a);
 536           b.translate (Offset (gap_f, -dir_ * dy * j));
 537           rightbeams.add (b);
 538         }
 539
 540       w /= 4;
 541       if (rhalfs)
 542         a = paper ()->lookup_l ()->beam (sl, w);
 543
 544       for (; j  < rwholebeams + rhalfs; j++)
 545         {
 546           Atom b (a);
 547           b.translate_axis (-dir_ * dy * j, Y_AXIS);
 548           rightbeams.add (b);
 549         }
 550
 551     }
 552   leftbeams.add (rightbeams);
 553   return leftbeams;
 554 }