/*
This file is part of LilyPond, the GNU music typesetter.
- Copyright (C) 2004--2011 Han-Wen Nienhuys <hanwen@xs4all.nl>
+ Copyright (C) 2004--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
LilyPond is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "spanner.hh"
#include "staff-symbol-referencer.hh"
#include "stem.hh"
+#include "tie.hh"
#include "warn.hh"
Bezier
Real p = 2 * (y - staff->relative_coordinate (state.common_[Y_AXIS], Y_AXIS))
/ state.staff_space_;
- Real distance = fabs (my_round (p) - p); // in halfspaces
- if (distance < 4 * state.thickness_
- && (int) fabs (my_round (p))
- <= 2 * Staff_symbol_referencer::staff_radius (staff) + 0.1
- && (int (fabs (my_round (p))) % 2
- != Staff_symbol_referencer::line_count (staff) % 2))
+ Real const round = my_round (p);
+ Real const frac = p - round;
+ if (fabs (frac) < 4 * state.thickness_
+ && Staff_symbol_referencer::on_staff_line (staff, int (round)))
{
- Direction resolution_dir
- = (distance ? state.dir_ : Direction (sign (p - my_round (p))));
+ Direction resolution_dir = frac ? state.dir_ : CENTER;
// TODO: parameter
- Real newp = my_round (p) + resolution_dir
- * 5 * state.thickness_;
+ Real newp = round + resolution_dir * 5 * state.thickness_;
Real dy = (newp - p) * state.staff_space_ / 2.0;
}
Real
-fit_factor (Offset dz_unit, Offset dz_perp,
+fit_factor (Offset dz_unit, Offset dz_perp, Real close_to_edge_length,
Bezier curve, Direction d, vector<Offset> const &avoid)
{
Real fit_factor = 0.0;
Offset p (dot_product (z, dz_unit),
d * dot_product (z, dz_perp));
+ bool close_to_edge = false;
+ for (LEFT_and_RIGHT (d))
+ close_to_edge = close_to_edge || -d * (p[X_AXIS] - curve_xext[d]) < close_to_edge_length;
+
+ if (close_to_edge)
+ continue;
+
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;
+ dz_unit * x2;
curve.control_[3] = attachment_[RIGHT];
- Real ff = fit_factor (dz_unit, dz_perp, curve, state.dir_, avoid);
+ Real ff = fit_factor (dz_unit, dz_perp, state.parameters_.close_to_edge_length_,
+ curve, state.dir_, avoid);
height = max (height, min (height * ff, max_h));
{
if (s < 0)
{
- programming_error ("Negative demerits found for slur. Ignoring");
+ programming_error ("Negative demerits found for slur. Ignoring");
s = 0.0;
}
demerit += stem_dem;
}
- else if (!edge)
- {
- Interval ext;
- ext.add_point (state.encompass_infos_[j].stem_);
- ext.add_point (state.encompass_infos_[j].head_);
-
- // ?
- demerit += -state.parameters_.closeness_factor_
- * min (state.dir_
- * (y - (ext[state.dir_] + state.dir_ * state.parameters_.free_head_distance_)), 0.0)
- / state.encompass_infos_.size ();
- }
}
add_score (demerit, "encompass");
- if (convex_head_distances.size ())
+ if (vsize n = convex_head_distances.size ())
{
Real avg_distance = 0.0;
Real min_dist = infinity_f;
- for (vsize j = 0; j < convex_head_distances.size (); j++)
+
+ for (vsize j = 0; j < n; j++)
{
min_dist = min (min_dist, convex_head_distances[j]);
avg_distance += convex_head_distances[j];
For slurs over 3 or 4 heads, the average distance is not a
good normalizer.
*/
- Real n = convex_head_distances.size ();
if (n <= 2)
{
Real fact = 1.0;
avg_distance += height_ * fact;
- n += fact;
+ ++n;
}
/*
void
Slur_configuration::score_extra_encompass (Slur_score_state const &state)
{
+ // we find forbidden attachments
+ vector<Offset> forbidden_attachments;
+ for (vsize i = 0; i < state.extra_encompass_infos_.size (); i++)
+ if (Tie::has_interface (state.extra_encompass_infos_[i].grob_))
+ {
+ Grob *t = state.extra_encompass_infos_[i].grob_;
+ Grob *common_x = Grob::get_vertical_axis_group (t);
+ Real rp = t->relative_coordinate (common_x, X_AXIS);
+ SCM cp = t->get_property ("control-points");
+
+ Bezier b;
+ int j = 0;
+ for (SCM s = cp; scm_is_pair (s); s = scm_cdr (s))
+ {
+ b.control_[j] = ly_scm2offset (scm_car (s));
+ j++;
+ }
+ forbidden_attachments.push_back (Offset (b.control_[0]) + Offset (rp, 0));
+ forbidden_attachments.push_back (Offset (b.control_[3]) + Offset (rp, 0));
+ }
+
+ bool too_close = false;
+ for (vsize k = 0; k < forbidden_attachments.size (); k++)
+ for (LEFT_and_RIGHT (side))
+ if ((forbidden_attachments[k] - attachment_[side]).length () < state.parameters_.slur_tie_extrema_min_distance_)
+ {
+ too_close = true;
+ break;
+ }
+
+ if (too_close)
+ add_score (state.parameters_.slur_tie_extrema_min_distance_penalty_, "extra");
+
for (vsize j = 0; j < state.extra_encompass_infos_.size (); j++)
{
Drul_array<Offset> attachment = attachment_;
to prevent numerical inaccuracies in
Bezier::get_other_coordinate ().
*/
- Direction d = LEFT;
+
bool found = false;
Real y = 0.0;
- do
+ for (LEFT_and_RIGHT (d))
{
/*
We need to check for the bound explicitly, since the
}
}
- while (flip (&d) != LEFT);
if (!found)
{
void
Slur_configuration::score_edges (Slur_score_state const &state)
{
- Direction d = LEFT;
+
Offset dz = attachment_[RIGHT]
- attachment_[LEFT];
Real slope = dz[Y_AXIS] / dz[X_AXIS];
- do
+ for (LEFT_and_RIGHT (d))
{
Real y = attachment_[d][Y_AXIS];
Real dy = fabs (y - state.base_attachments_[d][Y_AXIS]);
string dir_str = d == LEFT ? "L" : "R";
add_score (demerit, dir_str + " edge");
}
- while (flip (&d) != LEFT);
}
void