X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fslur-configuration.cc;h=1285a3bb5d2357f66f3ef61918c036c455439b1c;hb=03f79cd4492c3ef03d4a79d16eb898aaee32cd1c;hp=0cc546582bb8e7a0fdee92637d13e89bd5449d6a;hpb=e6caaa132f59006e5c47d0007b24bfedd07ad145;p=lilypond.git diff --git a/lily/slur-configuration.cc b/lily/slur-configuration.cc index 0cc546582b..1285a3bb5d 100644 --- a/lily/slur-configuration.cc +++ b/lily/slur-configuration.cc @@ -1,35 +1,45 @@ /* - slur-configuration.cc -- implement Slur_configuration + This file is part of LilyPond, the GNU music typesetter. - source file of the GNU LilyPond music typesetter + Copyright (C) 2004--2011 Han-Wen Nienhuys - (c) 2004--2005 Han-Wen Nienhuys + LilyPond is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + LilyPond is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with LilyPond. If not, see . */ #include "slur-configuration.hh" -#include -#include "stem.hh" -#include "warn.hh" -#include "misc.hh" #include "item.hh" +#include "libc-extension.hh" +#include "misc.hh" #include "pointer-group-interface.hh" -#include "slur.hh" #include "slur-scoring.hh" +#include "slur.hh" #include "spanner.hh" #include "staff-symbol-referencer.hh" -#include "libc-extension.hh" +#include "stem.hh" +#include "warn.hh" Bezier avoid_staff_line (Slur_score_state const &state, Bezier bez) { Offset horiz (1, 0); - Array ts = bez.solve_derivative (horiz); + vector ts = bez.solve_derivative (horiz); /* TODO: handle case of broken slur. */ - if (!ts.is_empty () + if (!ts.empty () && (state.extremes_[LEFT].staff_ == state.extremes_[RIGHT].staff_) && state.extremes_[LEFT].staff_ && state.extremes_[RIGHT].staff_) { @@ -65,7 +75,7 @@ avoid_staff_line (Slur_score_state const &state, Real fit_factor (Offset dz_unit, Offset dz_perp, - Bezier curve, Direction d, Array const &avoid) + Bezier curve, Direction d, vector const &avoid) { Real fit_factor = 0.0; Offset x0 = curve.control_[0]; @@ -77,19 +87,21 @@ fit_factor (Offset dz_unit, Offset dz_perp, curve_xext.add_point (curve.control_[0][X_AXIS]); curve_xext.add_point (curve.control_[3][X_AXIS]); - for (int i = 0; i < avoid.size (); i++) + for (vsize i = 0; i < avoid.size (); i++) { Offset z = (avoid[i] - x0); Offset p (dot_product (z, dz_unit), d * dot_product (z, dz_perp)); - if (!curve_xext.contains (p[X_AXIS])) + + Real eps = 0.01; + Interval pext = eps * Interval (-1,1) + p[X_AXIS]; + pext.intersect (curve_xext); + if (pext.is_empty () || pext.length () <= 1.999 * eps) continue; Real y = curve.get_other_coordinate (X_AXIS, p[X_AXIS]); if (y) - { - fit_factor = max (fit_factor, (p[Y_AXIS] / y)); - } + fit_factor = max (fit_factor, (p[Y_AXIS] / y)); } return fit_factor; } @@ -97,8 +109,7 @@ fit_factor (Offset dz_unit, Offset dz_perp, void Slur_configuration::generate_curve (Slur_score_state const &state, Real r_0, Real h_inf, - Array const &avoid - ) + vector const &avoid) { Offset dz = attachment_[RIGHT]- attachment_[LEFT];; Offset dz_unit = dz; @@ -134,9 +145,7 @@ Slur_configuration::generate_curve (Slur_score_state const &state, max_h = len / 3.0; } else - { - max_h = sqrt (max_h); - } + max_h = sqrt (max_h); Real eccentricity = robust_scm2double (state.slur_->get_property ("eccentricity"), 0); @@ -172,6 +181,24 @@ Slur_configuration::Slur_configuration () index_ = -1; }; +void +Slur_configuration::add_score (Real s, string desc) +{ + if (s < 0) + { + programming_error ("Negative demerits found for slur. Ignoring"); + s = 0.0; + } + + if (s) + { + if (score_card_.length () > 0) + score_card_ += ", "; + score_card_ += to_string ("%s=%.2f", desc.c_str (), s); + score_ += s; + } +} + void Slur_configuration::score_encompass (Slur_score_state const &state) { @@ -182,8 +209,8 @@ Slur_configuration::score_encompass (Slur_score_state const &state) Distances for heads that are between slur and line between attachment points. */ - Array convex_head_distances; - for (int j = 0; j < state.encompass_infos_.size (); j++) + vector convex_head_distances; + for (vsize j = 0; j < state.encompass_infos_.size (); j++) { Real x = state.encompass_infos_[j].x_; @@ -202,7 +229,7 @@ Slur_configuration::score_encompass (Slur_score_state const &state) if (state.dir_ * head_dy < 0) { demerit += state.parameters_.head_encompass_penalty_; - convex_head_distances.push (0.0); + convex_head_distances.push_back (0.0); } else { @@ -227,7 +254,7 @@ Slur_configuration::score_encompass (Slur_score_state const &state) = state.dir_ * max (state.dir_ * state.encompass_infos_[j].get_point (state.dir_), state.dir_ * line_y); Real d = fabs (closest - y); - convex_head_distances.push (d); + convex_head_distances.push_back (d); } } @@ -253,14 +280,13 @@ Slur_configuration::score_encompass (Slur_score_state const &state) / state.encompass_infos_.size (); } } - - Real variance_penalty = 0.0; - + add_score (demerit, "encompass"); + if (convex_head_distances.size ()) { Real avg_distance = 0.0; Real min_dist = infinity_f; - for (int j = 0; j < convex_head_distances.size (); j++) + for (vsize j = 0; j < convex_head_distances.size (); j++) { min_dist = min (min_dist, convex_head_distances[j]); avg_distance += convex_head_distances[j]; @@ -283,30 +309,26 @@ Slur_configuration::score_encompass (Slur_score_state const &state) as penalty. */ avg_distance /= n; - variance_penalty = state.parameters_.head_slur_distance_max_ratio_; + Real variance_penalty = state.parameters_.head_slur_distance_max_ratio_; if (min_dist > 0.0) variance_penalty - = min ((avg_distance / (min_dist + state.parameters_.absolute_closeness_measure_) - 1.0), variance_penalty); + = min ((avg_distance / (min_dist + state.parameters_.absolute_closeness_measure_) - 1.0), variance_penalty); variance_penalty = max (variance_penalty, 0.0); variance_penalty *= state.parameters_.head_slur_distance_factor_; - } -#if DEBUG_SLUR_SCORING - score_card_ += to_string ("C%.2f", demerit); - score_card_ += to_string ("D%.2f", variance_penalty); -#endif - - score_ += demerit + variance_penalty; + add_score (variance_penalty, "variance"); + } } void Slur_configuration::score_extra_encompass (Slur_score_state const &state) { - Real demerit = 0.0; - for (int j = 0; j < state.extra_encompass_infos_.size (); j++) + for (vsize j = 0; j < state.extra_encompass_infos_.size (); j++) { Drul_array attachment = attachment_; + Extra_collision_info const &info (state.extra_encompass_infos_[j]); + Interval slur_wid (attachment[LEFT][X_AXIS], attachment[RIGHT][X_AXIS]); /* @@ -326,21 +348,23 @@ Slur_configuration::score_extra_encompass (Slur_score_state const &state) distance. */ Item *as_item = dynamic_cast (state.extra_encompass_infos_[j].grob_); - if ((as_item - && as_item->get_column () - == state.extremes_[d].bound_->get_column ()) - || state.extra_encompass_infos_[j].extents_[X_AXIS].contains (attachment[d][X_AXIS])) + if (!as_item) + continue; + + Interval item_x = as_item->extent (state.common_[X_AXIS], X_AXIS); + item_x.intersect (state.extremes_[d].slur_head_x_extent_); + if (!item_x.is_empty ()) { y = attachment[d][Y_AXIS]; found = true; } + } while (flip (&d) != LEFT); if (!found) { - Real x = state.extra_encompass_infos_[j].extents_[X_AXIS] - .linear_combination (state.extra_encompass_infos_[j].idx_); + Real x = info.extents_[X_AXIS].linear_combination (info.idx_); if (!slur_wid.contains (x)) continue; @@ -348,16 +372,27 @@ Slur_configuration::score_extra_encompass (Slur_score_state const &state) y = curve_.get_other_coordinate (X_AXIS, x); } - Real dist = state.extra_encompass_infos_[j].extents_[Y_AXIS].distance (y); - demerit - += fabs (max (0.0, (state.parameters_.extra_encompass_free_distance_ - dist))) - / state.parameters_.extra_encompass_free_distance_ - * state.extra_encompass_infos_[j].penalty_; + Real dist = 0.0; + if (info.type_ == ly_symbol2scm ("around")) + dist = info.extents_[Y_AXIS].distance (y); + + /* + Have to score too: the curve enumeration is limited in its + shape, and may produce curves which collide anyway. + */ + else if (info.type_ == ly_symbol2scm ("inside")) + dist = state.dir_ * (y - info.extents_[Y_AXIS][state.dir_]); + else + programming_error ("unknown avoidance type"); + + dist = max (dist, 0.0); + + Real penalty = info.penalty_ * peak_around (0.1 * state.parameters_.extra_encompass_free_distance_, + state.parameters_.extra_encompass_free_distance_, + dist); + + add_score (penalty, "extra"); } -#if DEBUG_SLUR_SCORING - score_card_ += to_string ("X%.2f", demerit); -#endif - score_ += demerit; } void @@ -376,16 +411,16 @@ Slur_configuration::score_edges (Slur_score_state const &state) Real demerit = factor * dy; if (state.extremes_[d].stem_ && state.extremes_[d].stem_dir_ == state.dir_ + // TODO - Stem::get_beaming() should be precomputed. && !Stem::get_beaming (state.extremes_[d].stem_, -d)) demerit /= 5; demerit *= exp (state.dir_ * d * slope * state.parameters_.edge_slope_exponent_); - score_ += demerit; -#if DEBUG_SLUR_SCORING - score_card_ += to_string ("E%.2f", demerit); -#endif + + string dir_str = d == LEFT ? "L" : "R"; + add_score (demerit, dir_str + " edge"); } while (flip (&d) != LEFT); } @@ -428,17 +463,54 @@ Slur_configuration ::score_slopes (Slur_score_state const &state) ? state.parameters_.same_slope_penalty_ / 10 : state.parameters_.same_slope_penalty_; -#if DEBUG_SLUR_SCORING - score_card_ += to_string ("S%.2f", demerit); -#endif - score_ += demerit; + add_score (demerit, "slope"); +} + + +// This is a temporary hack to see how much we can gain by using a +// priority queue on the beams to score. +static int score_count = 0; +LY_DEFINE (ly_slur_score_count, "ly:slur-score-count", 0, 0, 0, + (), + "count number of slur scores.") { + return scm_from_int (score_count); } void -Slur_configuration::score (Slur_score_state const &state) +Slur_configuration::run_next_scorer (Slur_score_state const &state) +{ + switch (next_scorer_todo) { + case EXTRA_ENCOMPASS: + score_extra_encompass (state); + break; + case SLOPE: + score_slopes (state); + break; + case EDGES: + score_edges (state); + break; + case ENCOMPASS: + score_encompass (state); + break; + default: + assert (false); + } + next_scorer_todo++; + score_count++; +} + +bool +Slur_configuration::done () const +{ + return next_scorer_todo >= NUM_SCORERS; +} + +Slur_configuration * +Slur_configuration::new_config (Drul_array const &offs, int idx) { - score_extra_encompass (state); - score_slopes (state); - score_edges (state); - score_encompass (state); + Slur_configuration *conf = new Slur_configuration; + conf->attachment_ = offs; + conf->index_ = idx; + conf->next_scorer_todo = INITIAL_SCORE + 1; + return conf; }