lily/slur-configuration.cc

   1 /*
   2   slur-configuration.cc --  implement Slur_configuration
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 2004--2005 Han-Wen Nienhuys <hanwen@xs4all.nl>
   7
   8 */
   9
  10 #include "slur-configuration.hh"
  11
  12 #include <math.h>
  13
  14 #include "stem.hh"
  15 #include "warn.hh"
  16 #include "misc.hh"
  17 #include "item.hh"
  18 #include "group-interface.hh"
  19 #include "slur.hh"
  20 #include "slur-scoring.hh"
  21 #include "spanner.hh"
  22 #include "staff-symbol-referencer.hh"
  23 #include "libc-extension.hh"
  24
  25 Bezier
  26 avoid_staff_line (Slur_score_state const &state,
  27                   Bezier bez)
  28 {
  29   Offset horiz (1, 0);
  30   Array<Real> ts = bez.solve_derivative (horiz);
  31
  32   /* TODO: handle case of broken slur.  */
  33   if (!ts.is_empty ()
  34       && (state.extremes_[LEFT].staff_ == state.extremes_[RIGHT].staff_)
  35       && state.extremes_[LEFT].staff_ && state.extremes_[RIGHT].staff_)
  36     {
  37       Real y = bez.curve_point (ts[0])[Y_AXIS];
  38
  39       Grob *staff = state.extremes_[LEFT].staff_;
  40
  41       Real p = 2 * (y - staff->relative_coordinate (state.common_[Y_AXIS], Y_AXIS))
  42         / state.staff_space_;
  43
  44       Real distance = fabs (my_round (p) - p);  //  in halfspaces
  45       if (distance < 4 * state.thickness_
  46           && (int) fabs (my_round (p))
  47           <= 2 * Staff_symbol_referencer::staff_radius (staff) + 0.1
  48           && (int (fabs (my_round (p))) % 2
  49               != Staff_symbol_referencer::line_count (staff) % 2))
  50         {
  51           Direction resolution_dir =
  52          (distance ?  state.dir_ : Direction (sign (p - my_round (p))));
  53
  54           // TODO: parameter
  55           Real newp = my_round (p) + resolution_dir
  56             * 5 * state.thickness_;
  57
  58           Real dy = (newp - p) * state.staff_space_ / 2.0;
  59
  60           bez.control_[1][Y_AXIS] += dy;
  61           bez.control_[2][Y_AXIS] += dy;
  62         }
  63     }
  64   return bez;
  65 }
  66
  67 Real
  68 fit_factor (Offset dz_unit, Offset dz_perp,
  69             Bezier curve, Direction d,  Array<Offset> const &avoid)
  70 {
  71   Real fit_factor = 0.0;
  72   Offset x0 = curve.control_[0];
  73   curve.translate (-x0);
  74   curve.rotate (-dz_unit.arg ());
  75   curve.scale (1, d);
  76
  77   Interval curve_xext;
  78   curve_xext.add_point (curve.control_[0][X_AXIS]);
  79   curve_xext.add_point (curve.control_[3][X_AXIS]);
  80
  81   for (int i = 0; i < avoid.size (); i++)
  82     {
  83       Offset z = (avoid[i] - x0) ;
  84       Offset p (dot_product (z, dz_unit),
  85                 d* dot_product (z, dz_perp));
  86       if (!curve_xext.contains (p[X_AXIS]))
  87         continue;
  88
  89       Real y = curve.get_other_coordinate (X_AXIS, p[X_AXIS]);
  90       if (y)
  91         {
  92           fit_factor = fit_factor >? (p[Y_AXIS] / y);
  93         }
  94     }
  95   return fit_factor;
  96 }
  97
  98 void
  99 Slur_configuration::generate_curve (Slur_score_state const &state,
 100                                     Real r_0, Real h_inf )
 101 {
 102   Link_array<Grob> encompasses = state.columns_;
 103
 104   Array<Offset> avoid;
 105   for (int i = 0; i < encompasses.size (); i++)
 106     {
 107       if (state.extremes_[LEFT].note_column_ == encompasses[i]
 108           || state.extremes_[RIGHT].note_column_ == encompasses[i])
 109         continue;
 110
 111       Encompass_info inf (state.get_encompass_info (encompasses[i]));
 112       Real y = state.dir_ * ((state.dir_ * inf.head_) >? (state.dir_ *inf.stem_));
 113
 114       avoid.push (Offset (inf.x_,  y + state.dir_ * state.parameters_.free_head_distance_));
 115     }
 116
 117   Link_array<Grob> extra_encompasses
 118     = Pointer_group_interface__extract_grobs (state.slur_, (Grob *)0, "encompass-objects");
 119   for (int i = 0;  i < extra_encompasses.size (); i++)
 120     if (Slur::has_interface (extra_encompasses[i]))
 121       {
 122         Grob * small_slur = extra_encompasses[i];
 123         Bezier b = Slur::get_curve (small_slur);
 124
 125         Offset z = b.curve_point (0.5);
 126         z += Offset (small_slur->relative_coordinate (state.common_[X_AXIS], X_AXIS),
 127                      small_slur->relative_coordinate (state.common_[Y_AXIS], Y_AXIS));
 128
 129         z[Y_AXIS] += state.dir_ * state.parameters_.free_slur_distance_;
 130         avoid.push (z);
 131       }
 132
 133   Offset dz = attachment_[RIGHT]- attachment_[LEFT];;
 134   Offset dz_unit = dz;
 135   dz_unit *= 1 / dz.length ();
 136   Offset dz_perp = dz_unit * Offset (0, 1);
 137
 138   Real indent, height;
 139   get_slur_indent_height (&indent, &height, dz.length (), h_inf, r_0);
 140
 141
 142   Real len = dz.length ();
 143
 144   /* This condition,
 145
 146      len^2 > 4h^2 +  3 (i + 1/3len)^2  - 1/3 len^2
 147
 148      is equivalent to:
 149
 150      |bez' (0)| < | bez' (.5)|
 151
 152      when (control2 - control1) has the same direction as
 153     (control3 - control0).  */
 154
 155
 156
 157   Real max_indent = len / 3.1;
 158   indent = indent <? max_indent;
 159
 160   Real a1 = sqr (len) / 3.0;
 161   Real a2 = 0.75 * sqr (indent + len / 3.0);
 162   Real max_h = a1 - a2;
 163
 164
 165   if (max_h < 0)
 166     {
 167       programming_error ("Slur indent too small.");
 168       max_h = len / 3.0 ;
 169     }
 170   else
 171     {
 172       max_h = sqrt (max_h);
 173     }
 174
 175   Real excentricity = robust_scm2double (state.slur_->get_property ("excentricity"), 0);
 176
 177   Real x1 = (excentricity + indent);
 178   Real x2 = (excentricity - indent);
 179
 180   Bezier curve;
 181   curve.control_[0] = attachment_[LEFT];
 182   curve.control_[1] = attachment_[LEFT] + dz_perp * height * state.dir_
 183     + dz_unit * x1;
 184   curve.control_[2] = attachment_[RIGHT] + dz_perp * height * state.dir_
 185     + dz_unit * x2;
 186   curve.control_[3] = attachment_[RIGHT];
 187
 188   Real ff = fit_factor (dz_unit, dz_perp, curve, state.dir_, avoid);
 189
 190   height = height >? ((height * ff) <? max_h);
 191
 192   curve.control_[0] = attachment_[LEFT];
 193   curve.control_[1] = attachment_[LEFT] + dz_perp * height * state.dir_
 194     + dz_unit * x1;
 195   curve.control_[2] = attachment_[RIGHT] + dz_perp * height * state.dir_
 196     + dz_unit * x2;
 197   curve.control_[3] = attachment_[RIGHT];
 198
 199   curve_ = avoid_staff_line (state, curve);
 200   height_ = height;
 201 }
 202
 203 Slur_configuration::Slur_configuration()
 204 {
 205   score_ = 0.0;
 206   index_ = -1;
 207 };
 208
 209
 210
 211
 212 void
 213 Slur_configuration::score_encompass (Slur_score_state const &state)
 214 {
 215   Bezier const &bez (curve_);
 216   Real demerit = 0.0;
 217
 218   /*
 219     Distances for heads that are between slur and line between
 220     attachment points.
 221   */
 222   Array<Real> convex_head_distances;
 223   for (int j = 0; j < state.encompass_infos_.size (); j++)
 224     {
 225       Real x = state.encompass_infos_[j].x_;
 226
 227       bool l_edge = j == 0;
 228       bool r_edge = j == state.encompass_infos_.size ()-1;
 229       bool edge =  l_edge || r_edge;
 230
 231       if (! (x < attachment_[RIGHT][X_AXIS]
 232              && x > attachment_[LEFT][X_AXIS]))
 233         continue;
 234
 235       Real y = bez.get_other_coordinate (X_AXIS, x);
 236       if (!edge)
 237         {
 238           Real head_dy = (y - state.encompass_infos_[j].head_);
 239           if (state.dir_ * head_dy < 0)
 240             {
 241               demerit += state.parameters_.head_encompass_penalty_;
 242               convex_head_distances.push (0.0);
 243             }
 244           else
 245             {
 246               Real hd = (head_dy)
 247                 ? (1 / fabs (head_dy) - 1 / state.parameters_.free_head_distance_)
 248                 : state.parameters_.head_encompass_penalty_;
 249               hd = (hd >? 0)<? state.parameters_.head_encompass_penalty_;
 250
 251               demerit += hd;
 252             }
 253
 254           Real line_y = linear_interpolate (x,
 255                                             attachment_[RIGHT][X_AXIS],
 256                                             attachment_[LEFT][X_AXIS],
 257                                             attachment_[RIGHT][Y_AXIS],
 258                                             attachment_[LEFT][Y_AXIS]);
 259
 260           if ( 1 ) // state.dir_ * state.encompass_infos_[j].get_point (state.dir_) > state.dir_ *line_y )
 261             {
 262
 263               Real closest =
 264                 state.dir_ * (state.dir_ * state.encompass_infos_[j].get_point (state.dir_)
 265                               >? state.dir_ *line_y
 266                               );
 267               Real d = fabs (closest - y);
 268
 269               convex_head_distances.push (d);
 270             }
 271         }
 272
 273
 274
 275       if (state.dir_ * (y - state.encompass_infos_[j].stem_) < 0)
 276         {
 277           Real stem_dem = state.parameters_.stem_encompass_penalty_ ;
 278           if ((l_edge && state.dir_ == UP)
 279               || (r_edge && state.dir_ == DOWN))
 280             stem_dem /= 5;
 281
 282           demerit +=  stem_dem;
 283         }
 284       else if (!edge)
 285         {
 286           Interval ext;
 287           ext.add_point (state.encompass_infos_[j].stem_);
 288           ext.add_point (state.encompass_infos_[j].head_);
 289
 290           // ?
 291           demerit += -state.parameters_.closeness_factor_
 292             * (state.dir_
 293                * (y - (ext[state.dir_] + state.dir_ * state.parameters_.free_head_distance_))
 294                <? 0)
 295             / state.encompass_infos_.size ();
 296         }
 297     }
 298
 299   Real variance_penalty = 0.0;
 300
 301   if (convex_head_distances.size ())
 302     {
 303       Real avg_distance = 0.0;
 304       Real min_dist = infinity_f;
 305       for (int j = 0; j < convex_head_distances.size (); j++)
 306         {
 307           min_dist = min_dist <? convex_head_distances[j];
 308           avg_distance += convex_head_distances[j];
 309         }
 310
 311       /*
 312         For slurs over 3 or 4 heads, the average distance is not a
 313         good normalizer.
 314       */
 315       Real n =  convex_head_distances.size ();
 316       if (n <= 2)
 317         {
 318           Real fact = 1.0;
 319           avg_distance += height_ * fact;
 320           n += fact;
 321         }
 322
 323       /*
 324         TODO: maybe it's better to use (avgdist - mindist)*factor
 325         as penalty.
 326       */
 327       avg_distance /= n;
 328       variance_penalty = state.parameters_.head_slur_distance_max_ratio_;
 329       if (min_dist > 0.0)
 330         variance_penalty =
 331           (avg_distance / (min_dist + state.parameters_.absolute_closeness_measure_ ) - 1.0)
 332           <? variance_penalty;
 333
 334       variance_penalty = variance_penalty >? 0.0;
 335       variance_penalty *= state.parameters_.head_slur_distance_factor_;
 336     }
 337
 338 #if DEBUG_SLUR_SCORING
 339   score_card_ += to_string ("C%.2f", demerit);
 340   score_card_ += to_string ("D%.2f", variance_penalty);
 341 #endif
 342
 343   score_ += demerit + variance_penalty;
 344 }
 345
 346 void
 347 Slur_configuration::score_extra_encompass (Slur_score_state const &state)
 348 {
 349   Real demerit = 0.0;
 350   for (int j = 0; j < state.extra_encompass_infos_.size (); j++)
 351     {
 352       Drul_array<Offset> attachment = attachment_;
 353       Interval slur_wid (attachment[LEFT][X_AXIS], attachment[RIGHT][X_AXIS]);
 354
 355       /*
 356         to prevent numerical inaccuracies in
 357         Bezier::get_other_coordinate ().
 358       */
 359       Direction d = LEFT;
 360       bool found = false;
 361       Real y = 0.0;
 362
 363       do
 364         {
 365           /*
 366             We need to check for the bound explicitly, since the
 367             slur-ending can be almost vertical, making the Y
 368             coordinate a bad approximation of the object-slur
 369             distance.
 370           */
 371           Item * as_item =  dynamic_cast<Item*> (state.extra_encompass_infos_[j].grob_);
 372           if ((as_item
 373                && as_item->get_column ()
 374                == state.extremes_[d] .bound_->get_column ())
 375               || state.extra_encompass_infos_[j].extents_[X_AXIS].contains (attachment[d][X_AXIS]))
 376             {
 377               y = attachment[d][Y_AXIS];
 378               found = true;
 379             }
 380         }
 381       while (flip (&d) != LEFT);
 382
 383       if (!found)
 384         {
 385           Real x = state.extra_encompass_infos_[j].extents_[X_AXIS]
 386             .linear_combination (state.extra_encompass_infos_[j].idx_);
 387
 388           if (!slur_wid.contains (x))
 389             continue;
 390
 391           y = curve_.get_other_coordinate (X_AXIS, x);
 392         }
 393
 394       Real dist = state.extra_encompass_infos_[j].extents_[Y_AXIS].distance (y);
 395       demerit +=
 396         fabs (0 >? (state.parameters_.extra_encompass_free_distance_ - dist)) /
 397         state.parameters_.extra_encompass_free_distance_
 398         * state.extra_encompass_infos_[j].penalty_;
 399     }
 400 #if DEBUG_SLUR_SCORING
 401   score_card_ += to_string ("X%.2f", demerit);
 402 #endif
 403   score_ += demerit;
 404 }
 405
 406 void
 407 Slur_configuration::score_edges (Slur_score_state const &state)
 408 {
 409   Direction d = LEFT;
 410   Offset dz = attachment_[RIGHT]
 411     - attachment_[LEFT];
 412   Real slope = dz[Y_AXIS] / dz[X_AXIS];
 413   do
 414     {
 415       Real y = attachment_[d][Y_AXIS];
 416       Real dy = fabs (y - state.base_attachments_[d][Y_AXIS]);
 417
 418       Real factor = state.parameters_.edge_attraction_factor_;
 419       Real demerit = factor * dy;
 420       if (state.extremes_[d].stem_
 421           && state.extremes_[d].stem_dir_ == state.dir_
 422           && !Stem::get_beaming (state.extremes_[d].stem_, -d)
 423           )
 424         demerit /= 5;
 425
 426       demerit *= exp (state.dir_ * d * slope
 427                       * state.parameters_.edge_slope_exponent_ );
 428
 429       score_ += demerit;
 430 #if DEBUG_SLUR_SCORING
 431       score_card_ += to_string ("E%.2f", demerit);
 432 #endif
 433     }
 434   while (flip (&d) != LEFT);
 435 }
 436
 437 void
 438 Slur_configuration ::score_slopes (Slur_score_state const &state)
 439 {
 440   Real dy = state.musical_dy_;
 441   Offset slur_dz = attachment_[RIGHT] - attachment_[LEFT];
 442   Real slur_dy = slur_dz[Y_AXIS];
 443   Real demerit = 0.0;
 444
 445   demerit += ((fabs (slur_dy / slur_dz[X_AXIS])
 446                - state.parameters_.max_slope_) >? 0)
 447     * state.parameters_.max_slope_factor_;
 448
 449   /* 0.2: account for staffline offset. */
 450   Real max_dy = (fabs (dy) + 0.2);
 451   if (state.edge_has_beams_)
 452     max_dy += 1.0;
 453
 454   if (!state.is_broken_)
 455     demerit += state.parameters_.steeper_slope_factor_
 456       * ((fabs (slur_dy) -max_dy) >? 0);
 457
 458   demerit += ((fabs (slur_dy/slur_dz[X_AXIS])
 459                - state.parameters_.max_slope_) >? 0)
 460     * state.parameters_.max_slope_factor_;
 461
 462   if (sign (dy) == 0
 463       && sign (slur_dy) != 0
 464       && !state.is_broken_)
 465     demerit += state.parameters_.non_horizontal_penalty_;
 466
 467   if (sign (dy)
 468       && !state.is_broken_
 469       && sign (slur_dy)
 470       && sign (slur_dy) != sign (dy))
 471     demerit += state.edge_has_beams_
 472       ? state.parameters_.same_slope_penalty_ / 10
 473       : state.parameters_.same_slope_penalty_;
 474
 475 #if DEBUG_SLUR_SCORING
 476   score_card_ += to_string ("S%.2f", demerit);
 477 #endif
 478   score_ += demerit;
 479 }
 480
 481
 482 void
 483 Slur_configuration::score (Slur_score_state const &state)
 484 {
 485   score_extra_encompass (state);
 486   score_slopes  (state);
 487   score_edges (state);
 488   score_encompass (state);
 489 }