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