lily/slur-scoring.cc

   1 /*
   2   slur-scoring.cc -- Score based slur formatting
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1996--2006 Han-Wen Nienhuys <hanwen@xs4all.nl>
   7   Jan Nieuwenhuizen <janneke@gnu.org>
   8 */
   9
  10
  11 #include "slur-scoring.hh"
  12 #include "libc-extension.hh"
  13 #include "slur-configuration.hh"
  14 #include "beam.hh"
  15 #include "directional-element-interface.hh"
  16 #include "pointer-group-interface.hh"
  17 #include "slur.hh"
  18 #include "note-column.hh"
  19 #include "output-def.hh"
  20 #include "pitch.hh"
  21 #include "spanner.hh"
  22 #include "staff-symbol-referencer.hh"
  23 #include "staff-symbol.hh"
  24 #include "stem.hh"
  25 #include "warn.hh"
  26 #include "paper-column.hh"
  27 #include "accidental-interface.hh"
  28
  29 /*
  30   TODO:
  31
  32   - curve around flag for y coordinate
  33
  34   - short-cut: try a smaller region first.
  35
  36   - handle non-visible stems better.
  37
  38   - try to prune number of scoring criteria
  39
  40   - take encompass-objects more into account when determining
  41   slur shape
  42
  43   - calculate encompass scoring directly after determining slur shape.
  44
  45   - optimize.
  46 */
  47 struct Slur_score_state;
  48
  49 Slur_score_state::Slur_score_state ()
  50 {
  51   musical_dy_ = 0.0;
  52   valid_ = false;
  53   edge_has_beams_ = false;
  54   has_same_beam_ = false;
  55   is_broken_ = false;
  56   dir_ = CENTER;
  57   slur_ = 0;
  58   common_[X_AXIS] = 0;
  59   common_[Y_AXIS] = 0;
  60 }
  61
  62 Slur_score_state::~Slur_score_state ()
  63 {
  64   junk_pointers (configurations_);
  65 }
  66
  67 Real
  68 get_detail (SCM alist, SCM sym)
  69 {
  70   SCM entry = scm_assq (sym, alist);
  71   return robust_scm2double (scm_is_pair (entry)
  72                             ? scm_cdr (entry)
  73                             : SCM_EOL,
  74                             0.0);
  75 }
  76
  77 void
  78 Slur_score_parameters::fill (Grob *me)
  79 {
  80   SCM details = me->get_property ("details");
  81
  82   region_size_
  83     = (int) get_detail (details, ly_symbol2scm ("region-size"));
  84   head_encompass_penalty_
  85     = get_detail (details, ly_symbol2scm ("head-encompass-penalty"));
  86   stem_encompass_penalty_
  87     = get_detail (details, ly_symbol2scm ("stem-encompass-penalty"));
  88   closeness_factor_
  89     = get_detail (details, ly_symbol2scm ("closeness-factor"));
  90   edge_attraction_factor_
  91     = get_detail (details, ly_symbol2scm ("edge-attraction-factor"));
  92   same_slope_penalty_
  93     = get_detail (details, ly_symbol2scm ("same-slope-penalty"));
  94   steeper_slope_factor_
  95     = get_detail (details, ly_symbol2scm ("steeper-slope-factor"));
  96   non_horizontal_penalty_
  97     = get_detail (details, ly_symbol2scm ("non-horizontal-penalty"));
  98   max_slope_
  99     = get_detail (details, ly_symbol2scm ("max-slope"));
 100   max_slope_factor_
 101     = get_detail (details, ly_symbol2scm ("max-slope-factor"));
 102   free_head_distance_
 103     = get_detail (details, ly_symbol2scm ("free-head-distance"));
 104   absolute_closeness_measure_
 105     = get_detail (details, ly_symbol2scm ("absolute-closeness-measure"));
 106   extra_object_collision_penalty_
 107     = get_detail (details, ly_symbol2scm ("extra-object-collision-penalty"));
 108   accidental_collision_
 109     = get_detail (details, ly_symbol2scm ("accidental-collision"));
 110   extra_encompass_free_distance_
 111     = get_detail (details, ly_symbol2scm ("extra-encompass-free-distance"));
 112   head_slur_distance_factor_
 113     = get_detail (details, ly_symbol2scm ("head-slur-distance-factor"));
 114   head_slur_distance_max_ratio_
 115     = get_detail (details, ly_symbol2scm ("head-slur-distance-max-ratio"));
 116   free_slur_distance_
 117     = get_detail (details, ly_symbol2scm ("free-slur-distance"));
 118   edge_slope_exponent_
 119     = get_detail (details, ly_symbol2scm ("edge-slope-exponent"));
 120 }
 121
 122 Real
 123 broken_trend_y (Slur_score_state const &state, Direction hdir)
 124 {
 125   /* A broken slur should maintain the same vertical trend
 126      the unbroken slur would have had.  */
 127   Real by = 0.0;
 128   if (Spanner *mother = dynamic_cast<Spanner *> (state.slur_->original ()))
 129     {
 130       vsize k = broken_spanner_index (state.slur_);
 131       int j = int (k) + hdir;
 132       if (j < 0 || vsize (j) >= mother->broken_intos_.size ())
 133         return by;
 134
 135       Grob *neighbor = mother->broken_intos_[j];
 136       Spanner *common_mother
 137         = dynamic_cast<Spanner *> (state.common_[Y_AXIS]->original ());
 138       int common_k
 139         = broken_spanner_index (dynamic_cast<Spanner *> (state.common_[Y_AXIS]));
 140       int common_j = common_k + hdir;
 141
 142       if (common_j < 0 || vsize (common_j) >= common_mother->broken_intos_.size ())
 143         return by;
 144
 145       Grob *common_next_system = common_mother->broken_intos_[common_j];
 146
 147       SCM last_point = scm_car (scm_last_pair (neighbor->get_property ("control-points")));
 148
 149       return scm_to_double (scm_cdr (last_point))
 150         + neighbor->relative_coordinate (common_next_system, Y_AXIS);
 151     }
 152   return by;
 153 }
 154
 155 /*
 156   copy slur dir forwards across line break.
 157 */
 158 void
 159 Slur_score_state::set_next_direction ()
 160 {
 161   if (extremes_[RIGHT].note_column_)
 162     return;
 163
 164   if (Spanner *mother = dynamic_cast<Spanner *> (slur_->original ()))
 165     {
 166       vsize j = 1 + broken_spanner_index (slur_);
 167       if (j >= mother->broken_intos_.size ())
 168         return;
 169
 170       Grob *neighbor = mother->broken_intos_[j];
 171       set_grob_direction (neighbor, dir_);
 172     }
 173 }
 174
 175 Encompass_info
 176 Slur_score_state::get_encompass_info (Grob *col) const
 177 {
 178   Grob *stem = unsmob_grob (col->get_object ("stem"));
 179   Encompass_info ei;
 180
 181   if (!stem)
 182     {
 183       programming_error ("no stem for note column");
 184       ei.x_ = col->relative_coordinate (common_[X_AXIS], X_AXIS);
 185       ei.head_ = ei.stem_ = col->extent (common_[Y_AXIS],
 186                                          Y_AXIS)[dir_];
 187       return ei;
 188     }
 189   Direction stem_dir = get_grob_direction (stem);
 190
 191   if (Grob *head = Note_column::first_head (col))
 192     ei.x_ = head->extent (common_[X_AXIS], X_AXIS).center ();
 193   else
 194     ei.x_ = col->extent (common_[X_AXIS], X_AXIS).center ();
 195
 196   Grob *h = Stem::extremal_heads (stem)[Direction (dir_)];
 197   if (!h)
 198     {
 199       ei.head_ = ei.stem_ = col->extent (common_[Y_AXIS], Y_AXIS)[dir_];
 200       return ei;
 201     }
 202
 203   ei.head_ = h->extent (common_[Y_AXIS], Y_AXIS)[dir_];
 204
 205   if ((stem_dir == dir_)
 206       && !stem->extent (stem, Y_AXIS).is_empty ())
 207     {
 208       ei.stem_ = stem->extent (common_[Y_AXIS], Y_AXIS)[dir_];
 209       if (Grob *b = Stem::get_beam (stem))
 210         ei.stem_ += stem_dir * 0.5 * Beam::get_thickness (b);
 211
 212       Interval x = stem->extent (common_[X_AXIS], X_AXIS);
 213       ei.x_ = x.is_empty ()
 214         ? stem->relative_coordinate (common_[X_AXIS], X_AXIS)
 215         : x.center ();
 216     }
 217   else
 218     ei.stem_ = ei.head_;
 219
 220   return ei;
 221 }
 222
 223 Drul_array<Bound_info>
 224 Slur_score_state::get_bound_info () const
 225 {
 226   Drul_array<Bound_info> extremes;
 227
 228   Direction d = LEFT;
 229   Direction dir = dir_;
 230
 231   do
 232     {
 233       extremes[d].bound_ = slur_->get_bound (d);
 234       if (Note_column::has_interface (extremes[d].bound_))
 235         {
 236           extremes[d].note_column_ = extremes[d].bound_;
 237           extremes[d].stem_ = Note_column::get_stem (extremes[d].note_column_);
 238           if (extremes[d].stem_)
 239             {
 240               extremes[d].stem_dir_ = get_grob_direction (extremes[d].stem_);
 241
 242               for (int a = X_AXIS; a < NO_AXES; a++)
 243                 {
 244                   Axis ax = Axis (a);
 245                   Interval s = extremes[d].stem_->extent (common_[ax], ax);
 246                   if (s.is_empty ())
 247                     {
 248                       /*
 249                         do not issue warning. This happens for rests and
 250                         whole notes.
 251                       */
 252                       s = Interval (0, 0)
 253                         + extremes[d].stem_->relative_coordinate (common_[ax], ax);
 254                     }
 255                   extremes[d].stem_extent_[ax] = s;
 256                 }
 257
 258               extremes[d].slur_head_
 259                 = Stem::extremal_heads (extremes[d].stem_)[dir];
 260               if (!extremes[d].slur_head_
 261                   && Note_column::has_rests (extremes[d].bound_))
 262                 extremes[d].slur_head_ = Note_column::get_rest (extremes[d].bound_);
 263               extremes[d].staff_ = Staff_symbol_referencer
 264                 ::get_staff_symbol (extremes[d].stem_);
 265               extremes[d].staff_space_ = Staff_symbol_referencer
 266                 ::staff_space (extremes[d].stem_);
 267             }
 268
 269           if (extremes[d].slur_head_)
 270             extremes[d].slur_head_x_extent_
 271               = extremes[d].slur_head_->extent (common_[X_AXIS], X_AXIS);
 272
 273         }
 274     }
 275   while (flip (&d) != LEFT);
 276
 277   return extremes;
 278 }
 279
 280 void
 281 Slur_score_state::fill (Grob *me)
 282 {
 283   slur_ = dynamic_cast<Spanner *> (me);
 284   columns_
 285     = internal_extract_grob_array (me, ly_symbol2scm ("note-columns"));
 286
 287   if (columns_.empty ())
 288     {
 289       me->suicide ();
 290       return;
 291     }
 292
 293   staff_space_ = Staff_symbol_referencer::staff_space (me);
 294   Real lt = me->layout ()->get_dimension (ly_symbol2scm ("line-thickness"));
 295   thickness_ = robust_scm2double (me->get_property ("thickness"), 1.0) * lt;
 296
 297   dir_ = get_grob_direction (me);
 298   parameters_.fill (me);
 299
 300   extract_grob_set (me, "note-columns", columns);
 301   extract_grob_set (me, "encompass-objects", extra_objects);
 302
 303   Spanner *sp = dynamic_cast<Spanner *> (me);
 304
 305   for (int i = X_AXIS; i < NO_AXES; i++)
 306     {
 307       Axis a = (Axis)i;
 308       common_[a] = common_refpoint_of_array (columns, me, a);
 309       common_[a] = common_refpoint_of_array (extra_objects, common_[a], a);
 310
 311       Direction d = LEFT;
 312       do
 313         {
 314           /*
 315             If bound is not in note-columns, we don't want to know about
 316             its Y-position
 317           */
 318           if (a != Y_AXIS)
 319             common_[a] = common_[a]->common_refpoint (sp->get_bound (d), a);
 320         }
 321       while (flip (&d) != LEFT);
 322     }
 323
 324   extremes_ = get_bound_info ();
 325   is_broken_ = (!extremes_[LEFT].note_column_
 326                 || !extremes_[RIGHT].note_column_);
 327
 328   has_same_beam_
 329     = (extremes_[LEFT].stem_ && extremes_[RIGHT].stem_
 330        && Stem::get_beam (extremes_[LEFT].stem_) == Stem::get_beam (extremes_[RIGHT].stem_));
 331
 332   base_attachments_ = get_base_attachments ();
 333
 334   Drul_array<Real> end_ys
 335     = get_y_attachment_range ();
 336
 337   configurations_ = enumerate_attachments (end_ys);
 338   for (vsize i = 0; i < columns_.size (); i++)
 339     encompass_infos_.push_back (get_encompass_info (columns_[i]));
 340
 341   extra_encompass_infos_ = get_extra_encompass_infos ();
 342   valid_ = true;
 343
 344   musical_dy_ = 0.0;
 345   Direction d = LEFT;
 346   do
 347     {
 348       if (!is_broken_
 349           && extremes_[d].slur_head_)
 350         musical_dy_ += d
 351           * extremes_[d].slur_head_->relative_coordinate (common_[Y_AXIS], Y_AXIS);
 352     }
 353   while (flip (&d) != LEFT);
 354
 355   edge_has_beams_
 356     = (extremes_[LEFT].stem_ && Stem::get_beam (extremes_[LEFT].stem_))
 357     || (extremes_[RIGHT].stem_ && Stem::get_beam (extremes_[RIGHT].stem_));
 358
 359   set_next_direction ();
 360
 361   if (is_broken_)
 362     musical_dy_ = 0.0;
 363 }
 364
 365
 366 MAKE_SCHEME_CALLBACK(Slur, calc_control_points, 1)
 367 SCM
 368 Slur::calc_control_points (SCM smob)
 369 {
 370   Spanner *me = unsmob_spanner (smob);
 371
 372   Slur_score_state state;
 373   state.fill (me);
 374
 375   if (!state.valid_)
 376     return SCM_EOL;
 377
 378   state.generate_curves ();
 379
 380   SCM end_ys = me->get_property ("positions");
 381   Bezier best;
 382
 383   if (is_number_pair (end_ys))
 384     best = state.configurations_[state.get_closest_index (end_ys)]->curve_;
 385   else
 386     best = state.get_best_curve ();
 387
 388   SCM controls = SCM_EOL;
 389   for (int i = 4; i--;)
 390     {
 391       Offset o = best.control_[i]
 392         - Offset (me->relative_coordinate (state.common_[X_AXIS], X_AXIS),
 393                   me->relative_coordinate (state.common_[Y_AXIS], Y_AXIS));
 394       controls = scm_cons (ly_offset2scm (o), controls);
 395     }
 396
 397   return controls;
 398 }
 399
 400 Bezier
 401 Slur_score_state::get_best_curve ()
 402 {
 403   int opt_idx = -1;
 404   Real opt = 1e6;
 405
 406 #if DEBUG_SLUR_SCORING
 407   SCM inspect_quants = slur_->get_property ("inspect-quants");
 408   if (to_boolean (slur_->layout ()
 409                   ->lookup_variable (ly_symbol2scm ("debug-slur-scoring")))
 410       && scm_is_pair (inspect_quants))
 411     {
 412       opt_idx = get_closest_index (inspect_quants);
 413       configurations_[opt_idx]->score (*this);
 414       opt = configurations_[opt_idx]->score_;
 415     }
 416   else
 417 #endif
 418     {
 419       for (vsize i = 0; i < configurations_.size (); i++)
 420         configurations_[i]->score (*this);
 421       for (vsize i = 0; i < configurations_.size (); i++)
 422         {
 423           if (configurations_[i]->score_ < opt)
 424             {
 425               opt = configurations_[i]->score_;
 426               opt_idx = i;
 427             }
 428         }
 429     }
 430
 431 #if DEBUG_SLUR_SCORING
 432   if (opt_idx >= 0)
 433     {
 434       configurations_[opt_idx]->score_card_ += to_string ("=%.2f", opt);
 435       configurations_[opt_idx]->score_card_ += to_string ("i%d", opt_idx);
 436     }
 437   else
 438     {
 439       programming_error ("No optimal slur found. Guessing 0.");
 440       opt_idx = 0;
 441     }
 442
 443   // debug quanting
 444   slur_->set_property ("quant-score",
 445                        scm_makfrom0str (configurations_[opt_idx]->score_card_.c_str ()));
 446
 447 #endif
 448
 449   return configurations_[opt_idx]->curve_;
 450 }
 451
 452 int
 453 Slur_score_state::get_closest_index (SCM inspect_quants) const
 454 {
 455   Drul_array<Real> ins = ly_scm2interval (inspect_quants);
 456
 457   int opt_idx = -1;
 458   Real mindist = 1e6;
 459   for (vsize i = 0; i < configurations_.size (); i++)
 460     {
 461       Real d = fabs (configurations_[i]->attachment_[LEFT][Y_AXIS] - ins[LEFT])
 462         + fabs (configurations_[i]->attachment_[RIGHT][Y_AXIS] - ins[RIGHT]);
 463       if (d < mindist)
 464         {
 465           opt_idx = i;
 466           mindist = d;
 467         }
 468     }
 469   if (mindist > 1e5)
 470     programming_error ("can't not find quant");
 471   return opt_idx;
 472 }
 473
 474 /*
 475   TODO: should analyse encompasses to determine sensible region, and
 476   should limit slopes available.
 477 */
 478
 479 Drul_array<Real>
 480 Slur_score_state::get_y_attachment_range () const
 481 {
 482   Drul_array<Real> end_ys;
 483   Direction d = LEFT;
 484   do
 485     {
 486       if (extremes_[d].note_column_)
 487         {
 488           end_ys[d] = dir_
 489             * max (max (dir_ * (base_attachments_[d][Y_AXIS]
 490                                           + parameters_.region_size_ * dir_),
 491                         dir_ * (dir_ + extremes_[d].note_column_->extent (common_[Y_AXIS], Y_AXIS)[dir_])),
 492                    dir_ * base_attachments_[-d][Y_AXIS]);
 493         }
 494       else
 495         end_ys[d] = base_attachments_[d][Y_AXIS] + parameters_.region_size_ * dir_;
 496     }
 497   while (flip (&d) != LEFT);
 498
 499   return end_ys;
 500 }
 501
 502 bool
 503 spanner_less (Spanner *s1, Spanner *s2)
 504 {
 505   Slice b1, b2;
 506   Direction d = LEFT;
 507   do
 508     {
 509       b1[d] = s1->get_bound (d)->get_column ()->get_rank ();
 510       b2[d] = s2->get_bound (d)->get_column ()->get_rank ();
 511     }
 512   while (flip (&d) != LEFT);
 513
 514   return b2[LEFT] <= b1[LEFT] && b2[RIGHT] >= b1[RIGHT]
 515     && (b2[LEFT] != b1[LEFT] || b2[RIGHT] != b1[RIGHT]);
 516 }
 517
 518 Drul_array<Offset>
 519 Slur_score_state::get_base_attachments () const
 520 {
 521   Drul_array<Offset> base_attachment;
 522   Direction d = LEFT;
 523   do
 524     {
 525       Grob *stem = extremes_[d].stem_;
 526       Grob *head = extremes_[d].slur_head_;
 527
 528       Real x = 0.0;
 529       Real y = 0.0;
 530       if (extremes_[d].note_column_)
 531         {
 532
 533           /*
 534             fixme: X coord should also be set in this case.
 535           */
 536           if (stem
 537               && !Stem::is_invisible (stem)
 538               && extremes_[d].stem_dir_ == dir_
 539               && Stem::get_beaming (stem, -d)
 540               && Stem::get_beam (stem)
 541               && (!spanner_less (slur_, Stem::get_beam (stem))
 542                   || has_same_beam_))
 543             y = extremes_[d].stem_extent_[Y_AXIS][dir_];
 544           else if (head)
 545             y = head->extent (common_[Y_AXIS], Y_AXIS)[dir_];
 546           y += dir_ * 0.5 * staff_space_;
 547
 548           y = move_away_from_staffline (y, head);
 549
 550           Grob *fh = Note_column::first_head (extremes_[d].note_column_);
 551           x
 552             = (fh ? fh->extent (common_[X_AXIS], X_AXIS)
 553                : extremes_[d].bound_->extent (common_[X_AXIS], X_AXIS))
 554             .linear_combination (CENTER);
 555         }
 556       base_attachment[d] = Offset (x, y);
 557     }
 558   while (flip (&d) != LEFT);
 559
 560   do
 561     {
 562       if (!extremes_[d].note_column_)
 563         {
 564           Real x, y;
 565           if (d == RIGHT)
 566             x = robust_relative_extent (extremes_[d].bound_, common_[X_AXIS], X_AXIS)[d];
 567           else
 568             x = slur_->get_broken_left_end_align ();
 569           Grob *col = (d == LEFT) ? columns_[0] : columns_.back ();
 570
 571           if (extremes_[-d].bound_ != col)
 572             {
 573               y = robust_relative_extent (col, common_[Y_AXIS], Y_AXIS)[dir_];
 574               y += dir_ * 0.5 * staff_space_;
 575
 576               if (get_grob_direction (col) == dir_
 577                   && Note_column::get_stem (col)
 578                   && !Stem::is_invisible (Note_column::get_stem (col)))
 579                 y -= dir_ * 1.5 * staff_space_;
 580             }
 581           else
 582             y = base_attachment[-d][Y_AXIS];
 583
 584           y = move_away_from_staffline (y, col);
 585
 586           base_attachment[d] = Offset (x, y);
 587         }
 588     }
 589   while (flip (&d) != LEFT);
 590
 591   do
 592     {
 593       for (int a = X_AXIS; a < NO_AXES; a++)
 594         {
 595           Real &b = base_attachment[d][Axis (a)];
 596
 597           if (isinf (b) || isnan (b))
 598             {
 599               programming_error ("slur attachment is inf/nan");
 600               b = 0.0;
 601             }
 602         }
 603     }
 604   while (flip (&d) != LEFT);
 605
 606   return base_attachment;
 607 }
 608
 609 Real
 610 Slur_score_state::move_away_from_staffline (Real y,
 611                                             Grob *on_staff) const
 612 {
 613   if (!on_staff)
 614     return y;
 615
 616   Grob *staff_symbol = Staff_symbol_referencer::get_staff_symbol (on_staff);
 617   if (!staff_symbol)
 618     return y;
 619
 620   Real pos
 621     = (y - staff_symbol->relative_coordinate (common_[Y_AXIS],
 622                                               Y_AXIS))
 623     * 2.0 / staff_space_;
 624
 625   if (fabs (pos - my_round (pos)) < 0.2
 626       && Staff_symbol_referencer::on_line (on_staff, (int) rint (pos))
 627       && Staff_symbol_referencer::line_count (on_staff) - 1 >= rint (pos))
 628     y += 1.5 * staff_space_ * dir_ / 10;
 629
 630   return y;
 631 }
 632
 633 vector<Offset>
 634 Slur_score_state::generate_avoid_offsets () const
 635 {
 636   vector<Offset> avoid;
 637   vector<Grob*> encompasses = columns_;
 638
 639   for (vsize i = 0; i < encompasses.size (); i++)
 640     {
 641       if (extremes_[LEFT].note_column_ == encompasses[i]
 642           || extremes_[RIGHT].note_column_ == encompasses[i])
 643         continue;
 644
 645       Encompass_info inf (get_encompass_info (encompasses[i]));
 646       Real y = dir_ * (max (dir_ * inf.head_, dir_ * inf.stem_));
 647
 648       avoid.push_back (Offset (inf.x_, y + dir_ * parameters_.free_head_distance_));
 649     }
 650
 651   extract_grob_set (slur_, "encompass-objects", extra_encompasses);
 652   for (vsize i = 0; i < extra_encompasses.size (); i++)
 653     {
 654       if (Slur::has_interface (extra_encompasses[i]))
 655         {
 656           Grob *small_slur = extra_encompasses[i];
 657           Bezier b = Slur::get_curve (small_slur);
 658
 659           Offset z = b.curve_point (0.5);
 660           z += Offset (small_slur->relative_coordinate (common_[X_AXIS], X_AXIS),
 661                        small_slur->relative_coordinate (common_[Y_AXIS], Y_AXIS));
 662
 663           z[Y_AXIS] += dir_ * parameters_.free_slur_distance_;
 664           avoid.push_back (z);
 665         }
 666       else if (extra_encompasses[i]->get_property ("avoid-slur") == ly_symbol2scm ("inside"))
 667         {
 668           Grob *g = extra_encompasses [i];
 669           Interval xe = g->extent (common_[X_AXIS], X_AXIS);
 670           Interval ye = g->extent (common_[Y_AXIS], Y_AXIS);
 671
 672           if (!xe.is_empty ()
 673               && !ye.is_empty ())
 674             avoid.push_back (Offset (xe.center(), ye[dir_]));
 675         }
 676     }
 677   return avoid;
 678 }
 679
 680 void
 681 Slur_score_state::generate_curves () const
 682 {
 683   Real r_0 = robust_scm2double (slur_->get_property ("ratio"), 0.33);
 684   Real h_inf = staff_space_ * scm_to_double (slur_->get_property ("height-limit"));
 685
 686   vector<Offset> avoid = generate_avoid_offsets ();
 687   for (vsize i = 0; i < configurations_.size (); i++)
 688     configurations_[i]->generate_curve (*this, r_0, h_inf, avoid);
 689 }
 690
 691 vector<Slur_configuration*>
 692 Slur_score_state::enumerate_attachments (Drul_array<Real> end_ys) const
 693 {
 694   vector<Slur_configuration*> scores;
 695
 696   Drul_array<Offset> os;
 697   os[LEFT] = base_attachments_[LEFT];
 698   Real minimum_length = staff_space_
 699     * robust_scm2double (slur_->get_property ("minimum-length"), 2.0);
 700
 701   for (int i = 0; dir_ * os[LEFT][Y_AXIS] <= dir_ * end_ys[LEFT]; i++)
 702     {
 703       os[RIGHT] = base_attachments_[RIGHT];
 704       for (int j = 0; dir_ * os[RIGHT][Y_AXIS] <= dir_ * end_ys[RIGHT]; j++)
 705         {
 706           Slur_configuration s;
 707           Direction d = LEFT;
 708           Drul_array<bool> attach_to_stem (false, false);
 709           do
 710             {
 711               os[d][X_AXIS] = base_attachments_[d][X_AXIS];
 712               if (extremes_[d].stem_
 713                   && !Stem::is_invisible (extremes_[d].stem_)
 714                   && extremes_[d].stem_dir_ == dir_)
 715                 {
 716                   Interval stem_y = extremes_[d].stem_extent_[Y_AXIS];
 717                   stem_y.widen (0.25 * staff_space_);
 718                   if (stem_y.contains (os[d][Y_AXIS]))
 719                     {
 720                       os[d][X_AXIS] = extremes_[d].stem_extent_[X_AXIS][-d]
 721                         - d * 0.3;
 722                       attach_to_stem[d] = true;
 723                     }
 724                   else if (dir_ * extremes_[d].stem_extent_[Y_AXIS][dir_]
 725                            < dir_ * os[d][Y_AXIS]
 726                            && !extremes_[d].stem_extent_[X_AXIS].is_empty ())
 727
 728                     os[d][X_AXIS] = extremes_[d].stem_extent_[X_AXIS].center ();
 729                 }
 730             }
 731           while (flip (&d) != LEFT);
 732
 733           Offset dz;
 734           dz = os[RIGHT] - os[LEFT];
 735           if (dz[X_AXIS] < minimum_length
 736               || fabs (dz[Y_AXIS] / dz[X_AXIS]) > parameters_.max_slope_)
 737             {
 738               do
 739                 {
 740                   if (extremes_[d].slur_head_
 741                       && !extremes_[d].slur_head_x_extent_.is_empty ())
 742                     {
 743                       os[d][X_AXIS] = extremes_[d].slur_head_x_extent_.center ();
 744                       attach_to_stem[d] = false;
 745                     }
 746                 }
 747               while (flip (&d) != LEFT);
 748             }
 749
 750           dz = os[RIGHT] - os[LEFT];
 751           do
 752             {
 753               if (extremes_[d].slur_head_
 754                   && !attach_to_stem[d])
 755                 {
 756                   /* Horizontally move tilted slurs a little.  Move
 757                      more for bigger tilts.
 758
 759                      TODO: parameter */
 760                   os[d][X_AXIS]
 761                     -= dir_ * extremes_[d].slur_head_x_extent_.length ()
 762                     * sin (dz.arg ()) / 3;
 763                 }
 764             }
 765           while (flip (&d) != LEFT);
 766
 767           s.attachment_ = os;
 768           s.index_ = scores.size ();
 769
 770           scores.push_back (new Slur_configuration (s));
 771
 772           os[RIGHT][Y_AXIS] += dir_ * staff_space_ / 2;
 773         }
 774
 775       os[LEFT][Y_AXIS] += dir_ * staff_space_ / 2;
 776     }
 777
 778   assert (scores.size () > 0);
 779   return scores;
 780 }
 781
 782 vector<Extra_collision_info>
 783 Slur_score_state::get_extra_encompass_infos () const
 784 {
 785   extract_grob_set (slur_, "encompass-objects", encompasses);
 786   vector<Extra_collision_info> collision_infos;
 787   for (vsize i = encompasses.size (); i--;)
 788     {
 789       if (Slur::has_interface (encompasses[i]))
 790         {
 791           Spanner *small_slur = dynamic_cast<Spanner *> (encompasses[i]);
 792           Bezier b = Slur::get_curve (small_slur);
 793
 794           Offset relative (small_slur->relative_coordinate (common_[X_AXIS], X_AXIS),
 795                            small_slur->relative_coordinate (common_[Y_AXIS], Y_AXIS));
 796
 797           for (int k = 0; k < 3; k++)
 798             {
 799               Direction hdir = Direction (k / 2 - 1);
 800
 801               /*
 802                 Only take bound into account if small slur starts
 803                 together with big slur.
 804               */
 805               if (hdir && small_slur->get_bound (hdir) != slur_->get_bound (hdir))
 806                 continue;
 807
 808               Offset z = b.curve_point (k / 2.0);
 809               z += relative;
 810
 811               Interval yext;
 812               yext.set_full ();
 813               yext[dir_] = z[Y_AXIS] + dir_ * thickness_ * 1.0;
 814
 815               Interval xext (-1, 1);
 816               xext = xext * (thickness_ * 2) + z[X_AXIS];
 817               Extra_collision_info info (small_slur,
 818                                          k - 1.0,
 819                                          xext,
 820                                          yext,
 821                                          parameters_.extra_object_collision_penalty_);
 822               collision_infos.push_back (info);
 823             }
 824         }
 825       else
 826         {
 827           Grob *g = encompasses [i];
 828           Interval xe = g->extent (common_[X_AXIS], X_AXIS);
 829           Interval ye = g->extent (common_[Y_AXIS], Y_AXIS);
 830
 831           Real xp = 0.0;
 832           Real penalty = parameters_.extra_object_collision_penalty_;
 833           if (Accidental_interface::has_interface (g))
 834             {
 835               penalty = parameters_.accidental_collision_;
 836               /* Begin copy accidental.cc */
 837               bool parens = false;
 838               if (to_boolean (g->get_property ("cautionary")))
 839                 {
 840                   SCM cstyle = g->get_property ("cautionary-style");
 841                   parens = ly_is_equal (cstyle, ly_symbol2scm ("parentheses"));
 842                 }
 843
 844               SCM accs = g->get_property ("accidentals");
 845               SCM scm_style = g->get_property ("style");
 846               if (!scm_is_symbol (scm_style)
 847                   && !parens
 848                   && scm_ilength (accs) == 1)
 849                 {
 850                   /* End copy accidental.cc */
 851                   switch (scm_to_int (scm_car (accs)))
 852                     {
 853                     case FLAT:
 854                     case DOUBLE_FLAT:
 855                       xp = LEFT;
 856                       break;
 857                     case SHARP:
 858                       xp = 0.5 * dir_;
 859                       break;
 860                     case NATURAL:
 861                       xp = -dir_;
 862                       break;
 863                     }
 864                 }
 865             }
 866
 867           ye.widen (thickness_ * 0.5);
 868           xe.widen (thickness_ * 1.0);
 869           Extra_collision_info info (g, xp, xe, ye, penalty);
 870           collision_infos.push_back (info);
 871         }
 872     }
 873
 874   return collision_infos;
 875 }
 876
 877 Extra_collision_info::Extra_collision_info (Grob *g, Real idx, Interval x, Interval y, Real p)
 878 {
 879   idx_ = idx;
 880   extents_[X_AXIS] = x;
 881   extents_[Y_AXIS] = y;
 882   penalty_ = p;
 883   grob_ = g;
 884   type_ = g->get_property ("avoid-slur");
 885 }
 886
 887 Extra_collision_info::Extra_collision_info ()
 888 {
 889   idx_ = 0.0;
 890   penalty_ = 0.;
 891   grob_ = 0;
 892   type_ = SCM_EOL;
 893 }