source file of the GNU LilyPond music typesetter
- (c) 1997--2003 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+ (c) 1997--2004 Han-Wen Nienhuys <hanwen@cs.uu.nl>
Jan Nieuwenhuizen <janneke@gnu.org>
+
+
*/
#include <math.h>
+#include "warn.hh"
#include "grob.hh"
#include "staff-symbol-referencer.hh"
#include "beam.hh"
#include "group-interface.hh"
#include "align-interface.hh"
-const int INTER_QUANT_PENALTY = 1000;
-const int SECONDARY_BEAM_DEMERIT = 15;
+const int INTER_QUANT_PENALTY = 1000;
+const Real SECONDARY_BEAM_DEMERIT = 10.0;
const int STEM_LENGTH_DEMERIT_FACTOR = 5;
// possibly ridiculous, but too short stems just won't do
const int STEM_LENGTH_LIMIT_PENALTY = 5000;
-const int DAMPING_DIRECTIION_PENALTY = 800;
+const int DAMPING_DIRECTION_PENALTY = 800;
const int MUSICAL_DIRECTION_FACTOR = 400;
const int IDEAL_SLOPE_FACTOR = 10;
+const Real ROUND_TO_ZERO_SLOPE = 0.05;
+const int ROUND_TO_ZERO_POINTS = 4;
+
+extern bool debug_beam_quanting_flag;
static Real
shrink_extra_weight (Real x, Real fac)
Real yl;
Real yr;
Real demerits;
+
+#if DEBUG_QUANTING
+ String score_card_;
+#endif
};
Real yl = gh_scm2double (gh_car (s));
Real yr = gh_scm2double (gh_cdr (s));
- Real ss = Staff_symbol_referencer::staff_space (me);
- Real thickness = gh_scm2double (me->get_grob_property ("thickness")) / ss;
- Real slt = me->get_paper ()->get_var ("linethickness") / ss;
+ /*
+ Calculations are relative to a unit-scaled staff, i.e. the quants are
+ divided by the current staff_space.
+
+ */
+ Real ss = Staff_symbol_referencer::staff_space (me);
+ Real thickness = Beam::get_thickness (me) / ss ;
+ Real slt = Staff_symbol_referencer::line_thickness (me) / ss;
SCM sdy = me->get_grob_property ("least-squares-dy");
Real dy_mus = gh_number_p (sdy) ? gh_scm2double (sdy) : 0.0;
stem_y != 0.0, when we're cross staff.
*/
- bool french = to_boolean (me->get_grob_property ("french-beaming"));
for (int i= 0; i < stems.size(); i++)
{
Grob*s = stems[i];
- stem_infos.push (Stem::get_stem_info (s));
+
+ Stem_info si (Stem::get_stem_info (s));
+ si.scale (1 / ss);
+ stem_infos.push (si);
dirs_found[stem_infos.top ().dir_] = true;
- bool f = french && i > 0&& (i < stems.size () -1);
+ bool f = to_boolean (s->get_grob_property ("french-beaming"))
+ && s != lvs && s != fvs;
+
base_lengths.push (calc_stem_y (me, s, common, xl, xr,
- Interval (0,0), f));
+ Interval (0,0), f) / ss);
stem_xposns.push (s->relative_coordinate (common[X_AXIS], X_AXIS));
}
parameters outside of the loop, we can save a lot of time. */
for (int i = qscores.size (); i--;)
{
- qscores[i].demerits
- += score_slopes_dy (qscores[i].yl, qscores[i].yr,
- dy_mus, yr- yl, xstaff);
+ Real d = score_slopes_dy (qscores[i].yl, qscores[i].yr,
+ dy_mus, yr- yl,
+ xr - xl,
+ xstaff);
+ qscores[i].demerits += d;
+
+#if DEBUG_QUANTING
+ qscores[i].score_card_ += to_string ("S%.2f",d);
+#endif
}
Real rad = Staff_symbol_referencer::staff_radius (me);
int beam_count = get_beam_count (me);
- Real beam_translation = get_beam_translation (me);
+ Real beam_translation = get_beam_translation (me) / ss;
Real reasonable_score = (knee_b) ? 200000 : 100;
for (int i = qscores.size (); i--;)
if (qscores[i].demerits < reasonable_score)
{
- qscores[i].demerits
- += score_forbidden_quants (qscores[i].yl, qscores[i].yr,
+ Real d = score_forbidden_quants (qscores[i].yl, qscores[i].yr,
rad, slt, thickness, beam_translation,
beam_count, ldir, rdir);
+ qscores[i].demerits += d;
+
+#if DEBUG_QUANTING
+ qscores[i].score_card_ += to_string (" F %.2f", d);
+#endif
}
- // ; /* silly gdb thinks best_idx is inside for loop. */
for (int i = qscores.size (); i--;)
if (qscores[i].demerits < reasonable_score)
{
- qscores[i].demerits
- += score_stem_lengths (stems, stem_infos,
+ Real d=score_stem_lengths (stems, stem_infos,
base_lengths, stem_xposns,
xl, xr,
knee_b,
qscores[i].yl, qscores[i].yr);
+ qscores[i].demerits += d;
+
+#if DEBUG_QUANTING
+ qscores[i].score_card_ += to_string (" L %.2f", d);
+#endif
}
- // ; /* silly gdb thinks best_idx is inside for loop. */
int best_idx = best_quant_score_idx (qscores);
- me->set_grob_property ("positions",
- gh_cons (gh_double2scm (qscores[best_idx].yl),
- gh_double2scm (qscores[best_idx].yr))
- );
+
#if DEBUG_QUANTING
+ SCM inspect_quants = me->get_grob_property ("inspect-quants");
+ if (debug_beam_quanting_flag
+ && gh_pair_p (inspect_quants))
+ {
+ Drul_array<Real> ins = ly_scm2interval (inspect_quants);
+
+ int i = 0;
- // debug quanting
- me->set_grob_property ("quant-score",
- gh_double2scm (qscores[best_idx].demerits));
- me->set_grob_property ("best-idx", scm_int2num (best_idx));
+ Real mindist = 1e6;
+ for (; i < qscores.size(); i ++)
+ {
+ Real d =fabs (qscores[i].yl- ins[LEFT]) + fabs (qscores[i].yr - ins[RIGHT]);
+ if (d < mindist)
+ {
+ best_idx = i;
+ mindist= d;
+ }
+ }
+ if (mindist > 1e5)
+ programming_error ("Could not find quant.");
+ }
+#endif
+
+ me->set_grob_property ("positions",
+ ly_interval2scm (Drul_array<Real> (qscores[best_idx].yl,
+ qscores[best_idx].yr)));
+#if DEBUG_QUANTING
+ if (debug_beam_quanting_flag)
+ {
+ qscores[best_idx].score_card_ += to_string ("i%d", best_idx);
+
+ // debug quanting
+ me->set_grob_property ("quant-score",
+ scm_makfrom0str (qscores[best_idx].score_card_.to_str0 ()));
+ }
#endif
return SCM_UNSPECIFIED;
Real x = stem_xs[i];
Real dx = xr-xl;
- Real beam_y = yr *(x - xl)/dx + yl * ( xr - x)/dx;
+ Real beam_y = dx ? yr *(x - xl)/dx + yl * ( xr - x)/dx : (yr + yl)/2;
Real current_y = beam_y + base_stem_ys[i];
Real length_pen = STEM_LENGTH_DEMERIT_FACTOR;
Direction d = DOWN;
do
{
- if(count[d])
- score[d] /= count[d];
+ score[d] /= (count[d] >? 1);
}
while (flip (&d) != DOWN);
Real
Beam::score_slopes_dy (Real yl, Real yr,
Real dy_mus, Real dy_damp,
+ Real dx,
bool xstaff)
{
Real dy = yr - yl;
-
Real dem = 0.0;
- if (sign (dy_damp) != sign (dy))
+
+ /*
+ DAMPING_DIRECTION_PENALTY is a very harsh measure, while for
+ complex beaming patterns, horizontal is often a good choice.
+
+ TODO: find a way to incorporate the complexity of the beam in this
+ penalty.
+ */
+ if (fabs (dy/dx) > ROUND_TO_ZERO_SLOPE
+ && sign (dy_damp) != sign (dy))
{
- dem += DAMPING_DIRECTIION_PENALTY;
+ dem += DAMPING_DIRECTION_PENALTY;
}
dem += MUSICAL_DIRECTION_FACTOR * (0 >? (fabs (dy) - fabs (dy_mus)));
/* Huh, why would a too steep beam be better than a too flat one ? */
dem += shrink_extra_weight (fabs (dy_damp) - fabs (dy), 1.5)
* slope_penalty;
+
+ /*
+ almost zero slopes look like errors in horizontal beams.
+ */
+ if (fabs (dy) > 1e-3
+ && fabs (dy / dx) < ROUND_TO_ZERO_SLOPE)
+ dem += ROUND_TO_ZERO_POINTS;
+
return dem;
}
return x - floor (x);
}
+
+/*
+ TODO: The fixed value SECONDARY_BEAM_DEMERIT is probably flawed:
+ because for 32nd and 64th beams the forbidden quants are relatively
+ more important than stem lengths.
+*/
Real
Beam::score_forbidden_quants (Real yl, Real yr,
- Real rad,
+ Real radius,
Real slt,
Real thickness, Real beam_translation,
int beam_count,
Direction ldir, Direction rdir)
{
Real dy = yr - yl;
+ Drul_array<Real> y(yl,yr);
+ Drul_array<Direction> dirs(ldir,rdir);
+
+ Real extra_demerit = SECONDARY_BEAM_DEMERIT / beam_count;
+ /*
+ Inside the staff, inter quants are forbidden.
+ */
Real dem = 0.0;
- for (int i = 0; i < 2; i++)
+ Direction d = LEFT;
+ do
{
- Real y = i? yl : yr;
- if (fabs (y) <= (rad + 0.5) && fabs ( my_modf (y) - 0.5) < 1e-3)
+ if (fabs (y[d]) <= (radius + 0.5) && fabs (my_modf (y[d]) - 0.5) < 1e-3)
dem += INTER_QUANT_PENALTY;
}
+ while ((flip (&d))!= LEFT);
+
+
+ for (int j = 1; j <= beam_count; j++)
+ {
+ do
+ {
+ /*
+ see if the outer staffline falls in a beam-gap
+
+ This test is too weak; we should really check all lines.
+ */
+ Direction stem_dir = dirs[d];
+ Real gap1 = y[d] - stem_dir * ((j-1) * beam_translation + thickness / 2 - slt/2 );
+ Real gap2 = y[d] - stem_dir * (j * beam_translation - thickness / 2 + slt/2);
+
+ Interval gap;
+ gap.add_point (gap1);
+ gap.add_point (gap2);
+
+ if (gap.contains (radius))
+ dem += extra_demerit;
+ }
+ while ((flip (&d))!= LEFT);
+ }
+
+
// todo: use beam_count of outer stems.
if (beam_count >= 2)
{
Real sit = (thickness - slt) / 2;
Real inter = 0.5;
Real hang = 1.0 - (thickness - slt) / 2;
-
-
- if (fabs (yl - ldir * beam_translation) < rad
- && fabs (my_modf (yl) - inter) < 1e-3)
- dem += SECONDARY_BEAM_DEMERIT;
- if (fabs (yr - rdir * beam_translation) < rad
- && fabs (my_modf (yr) - inter) < 1e-3)
- dem += SECONDARY_BEAM_DEMERIT;
Real eps = 1e-3;
- /*
- Can't we simply compute the distance between the nearest
- staffline and the secondary beam? That would get rid of the
- silly case analysis here (which is probably not valid when we
- have different beam-thicknesses.)
-
- --hwn
- */
-
-
// hmm, without Interval/Drul_array, you get ~ 4x same code...
- if (fabs (yl - ldir * beam_translation) < rad + inter)
+ if (fabs (y[LEFT] - dirs[LEFT] * beam_translation) < radius + inter)
{
- if (ldir == UP && dy <= eps
- && fabs (my_modf (yl) - sit) < eps)
- dem += SECONDARY_BEAM_DEMERIT;
+ if (dirs[LEFT] == UP && dy <= eps
+ && fabs (my_modf (y[LEFT]) - sit) < eps)
+ dem += extra_demerit;
- if (ldir == DOWN && dy >= eps
- && fabs (my_modf (yl) - hang) < eps)
- dem += SECONDARY_BEAM_DEMERIT;
+ if (dirs[LEFT] == DOWN && dy >= eps
+ && fabs (my_modf (y[LEFT]) - hang) < eps)
+ dem += extra_demerit;
}
- if (fabs (yr - rdir * beam_translation) < rad + inter)
+ if (fabs (y[RIGHT] - dirs[RIGHT] * beam_translation) < radius + inter)
{
- if (rdir == UP && dy >= eps
- && fabs (my_modf (yr) - sit) < eps)
- dem += SECONDARY_BEAM_DEMERIT;
+ if (dirs[RIGHT] == UP && dy >= eps
+ && fabs (my_modf (y[RIGHT]) - sit) < eps)
+ dem += extra_demerit;
- if (rdir == DOWN && dy <= eps
- && fabs (my_modf (yr) - hang) < eps)
- dem += SECONDARY_BEAM_DEMERIT;
+ if (dirs[RIGHT] == DOWN && dy <= eps
+ && fabs (my_modf (y[RIGHT]) - hang) < eps)
+ dem += extra_demerit;
}
if (beam_count >= 3)
{
- if (fabs (yl - 2 * ldir * beam_translation) < rad + inter)
+ if (fabs (y[LEFT] - 2 * dirs[LEFT] * beam_translation) < radius + inter)
{
- if (ldir == UP && dy <= eps
- && fabs (my_modf (yl) - straddle) < eps)
- dem += SECONDARY_BEAM_DEMERIT;
+ if (dirs[LEFT] == UP && dy <= eps
+ && fabs (my_modf (y[LEFT]) - straddle) < eps)
+ dem += extra_demerit;
- if (ldir == DOWN && dy >= eps
- && fabs (my_modf (yl) - straddle) < eps)
- dem += SECONDARY_BEAM_DEMERIT;
+ if (dirs[LEFT] == DOWN && dy >= eps
+ && fabs (my_modf (y[LEFT]) - straddle) < eps)
+ dem += extra_demerit;
}
- if (fabs (yr - 2 * rdir * beam_translation) < rad + inter)
+ if (fabs (y[RIGHT] - 2 * dirs[RIGHT] * beam_translation) < radius + inter)
{
- if (rdir == UP && dy >= eps
- && fabs (my_modf (yr) - straddle) < eps)
- dem += SECONDARY_BEAM_DEMERIT;
+ if (dirs[RIGHT] == UP && dy >= eps
+ && fabs (my_modf (y[RIGHT]) - straddle) < eps)
+ dem += extra_demerit;
- if (rdir == DOWN && dy <= eps
- && fabs (my_modf (yr) - straddle) < eps)
- dem += SECONDARY_BEAM_DEMERIT;
+ if (dirs[RIGHT] == DOWN && dy <= eps
+ && fabs (my_modf (y[RIGHT]) - straddle) < eps)
+ dem += extra_demerit;
}
}
}
projects / lilypond.git / blobdiff