X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fbeam-concave.cc;h=501b753d2108a1f858f75663865e7f03fcb67ba5;hb=174f5edb85ffdfe5ba808e48131ac03d59f478a7;hp=f0e0cbde50a384afdd67cbfff4f2f01fdc8a2946;hpb=eb72c0f066957c3e71d336db0f72814e34d3964d;p=lilypond.git diff --git a/lily/beam-concave.cc b/lily/beam-concave.cc index f0e0cbde50..501b753d21 100644 --- a/lily/beam-concave.cc +++ b/lily/beam-concave.cc @@ -1,19 +1,49 @@ +/* + This file is part of LilyPond, the GNU music typesetter. + + Copyright (C) 2004 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 . +*/ + /* Determine whether a beam is concave. + + A beam is concave when the middle notes get closer to the + beam than the left and right edge notes. + + This is determined in two ways: by looking at the positions of the + middle notes, or by looking at the deviation of the inside notes + compared to the line connecting first and last. + + The tricky thing is what to do with beams with chords. There are no + real guidelines in this case. */ #include "pointer-group-interface.hh" -#include "array.hh" #include "stem.hh" #include "beam.hh" +#include "grob.hh" #include "staff-symbol-referencer.hh" +#include "directional-element-interface.hh" bool -is_concave_single_notes (Array const &positions, Direction beam_dir) +is_concave_single_notes (vector const &positions, Direction beam_dir) { Interval covering; covering.add_point (positions[0]); - covering.add_point (positions.top ()); + covering.add_point (positions.back ()); bool above = false; bool below = false; @@ -22,7 +52,7 @@ is_concave_single_notes (Array const &positions, Direction beam_dir) /* notes above and below the interval covered by 1st and last note. */ - for (int i = 1; i < positions.size () - 1; i++) + for (vsize i = 1; i + 1 < positions.size (); i++) { above = above || (positions[i] > covering[UP]); below = below || (positions[i] < covering[DOWN]); @@ -33,22 +63,22 @@ is_concave_single_notes (Array const &positions, Direction beam_dir) A note as close or closer to the beam than begin and end, but the note is reached in the opposite direction as the last-first dy */ - int dy = positions.top () - positions[0]; - int closest = max (beam_dir * positions.top (), beam_dir * positions[0]); - for (int i = 2; !concave && i < positions.size () - 1; i++) + int dy = positions.back () - positions[0]; + int closest = max (beam_dir * positions.back (), beam_dir * positions[0]); + for (vsize i = 2; !concave && i + 1 < positions.size (); i++) { int inner_dy = positions[i] - positions[i - 1]; if (sign (inner_dy) != sign (dy) - && (beam_dir * positions[i] >= closest - || beam_dir * positions[i - 1] >= closest)) - concave = true; + && (beam_dir * positions[i] >= closest + || beam_dir * positions[i - 1] >= closest)) + concave = true; } bool all_closer = true; - for (int i = 1; all_closer && i < positions.size () - 1; i++) + for (vsize i = 1; all_closer && i + 1 < positions.size (); i++) { all_closer = all_closer - && (beam_dir * positions[i] > closest); + && (beam_dir * positions[i] > closest); } concave = concave || all_closer; @@ -56,12 +86,12 @@ is_concave_single_notes (Array const &positions, Direction beam_dir) } Real -calc_concaveness (Array const &positions, Direction beam_dir) +calc_positions_concaveness (vector const &positions, Direction beam_dir) { - Real dy = positions.top () - positions[0]; + Real dy = positions.back () - positions[0]; Real slope = dy / Real (positions.size () - 1); Real concaveness = 0.0; - for (int i = 1; i < positions.size () - 1; i++) + for (vsize i = 1; i + 1 < positions.size (); i++) { Real line_y = slope * i + positions[0]; @@ -79,67 +109,62 @@ calc_concaveness (Array const &positions, Direction beam_dir) return concaveness; } -MAKE_SCHEME_CALLBACK (Beam, check_concave, 1); +MAKE_SCHEME_CALLBACK (Beam, calc_concaveness, 1); SCM -Beam::check_concave (SCM smob) +Beam::calc_concaveness (SCM smob) { Grob *me = unsmob_grob (smob); - Link_array stems + vector stems = extract_grob_array (me, "stems"); if (is_knee (me)) - return SCM_UNSPECIFIED; + return scm_from_double (0.0); Direction beam_dir = CENTER; - for (int i = stems.size (); i--;) + for (vsize i = stems.size (); i--;) { - if (Stem::is_invisible (stems[i])) - stems.del (i); + if (Stem::is_normal_stem (stems[i])) + { + if (Direction dir = get_grob_direction (stems[i])) + beam_dir = dir; + } else - { - if (Direction dir = Stem::get_direction (stems[i])) - beam_dir = dir; - } + stems.erase (stems.begin () + i); } if (stems.size () <= 2) - return SCM_UNSPECIFIED; + return scm_from_int (0); - Array close_positions; - Array far_positions; - for (int i = 0; i < stems.size (); i++) + vector close_positions; + vector far_positions; + for (vsize i = 0; i < stems.size (); i++) { /* - For chords, we take the note head that is closest to the beam. - - Hmmm.. wait, for the beams in the last measure of morgenlied, - this doesn't look so good. Let's try the heads farthest from - the beam. + For chords, we take the note head that is closest to the beam. + Hmmm.. wait, for the beams in the last measure of morgenlied, + this doesn't look so good. Let's try the heads farthest from + the beam. */ Interval posns = Stem::head_positions (stems[i]); - close_positions.push ((int) rint (posns[beam_dir])); - far_positions.push ((int) rint (posns[-beam_dir])); + close_positions.push_back ((int) rint (posns[beam_dir])); + far_positions.push_back ((int) rint (posns[-beam_dir])); } - if (is_concave_single_notes (far_positions, beam_dir)) - { - Drul_array pos = ly_scm2interval (me->get_property ("positions")); - Real r = linear_combination (pos, 0.0); + Real concaveness = 0.0; - r /= Staff_symbol_referencer::staff_space (me); - me->set_property ("positions", ly_interval2scm (Drul_array (r, r))); - me->set_property ("least-squares-dy", scm_from_double (0)); + if (is_concave_single_notes (beam_dir == UP ? close_positions : far_positions, beam_dir)) + { + concaveness = 10000; } else { - Real concaveness = (calc_concaveness (far_positions, beam_dir) - + calc_concaveness (close_positions, beam_dir)) / 2; - - me->set_property ("concaveness", scm_from_double (concaveness)); + concaveness = (calc_positions_concaveness (far_positions, beam_dir) + + calc_positions_concaveness (close_positions, beam_dir)) / 2; } - return SCM_UNSPECIFIED; + return scm_from_double (concaveness); } +