X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fspacing-spanner.cc;h=c5b306092a74d5b26ded8c9fc9b02238cbb73ea6;hb=3f2900f0ea52866d3edaa83cee2b16b8be5e4ec9;hp=9c77ccea57ae7905b9486842676974d9e5233064;hpb=a1d72ee4c631e40978415d31666337beaebceabc;p=lilypond.git diff --git a/lily/spacing-spanner.cc b/lily/spacing-spanner.cc index 9c77ccea57..c5b306092a 100644 --- a/lily/spacing-spanner.cc +++ b/lily/spacing-spanner.cc @@ -3,83 +3,94 @@ source file of the GNU LilyPond music typesetter - (c) 1999 Han-Wen Nienhuys + (c) 1999--2000 Han-Wen Nienhuys */ #include "spacing-spanner.hh" -#include "score-column.hh" +#include "paper-column.hh" #include "dimensions.hh" #include "paper-def.hh" #include "warn.hh" -#include "p-score.hh" +#include "paper-score.hh" #include "line-of-score.hh" +#include "misc.hh" -Spacing_spanner::Spacing_spanner () +void +Spacing_spanner::set_interface (Score_element*me) { - set_elt_property (break_helper_only_scm_sym, SCM_BOOL_T); - set_elt_property (transparent_scm_sym, SCM_BOOL_T); -} - -int -Spacing_spanner::col_count () const -{ - return pscore_l_->line_l_->cols_.size (); -} - -Score_column * -Spacing_spanner::scol (int i)const -{ - return dynamic_cast (pscore_l_->line_l_->cols_[i]); + me->set_extent_callback (SCM_EOL, X_AXIS); + me->set_extent_callback (SCM_EOL, Y_AXIS) ; } /* - cut 'n paste from spring-spacer.cc - - generate springs between columns. - The algorithm is partly taken from : John S. Gourlay. ``Spacing a Line of Music,'' Technical Report OSU-CISRC-10/87-TR35, Department of Computer and Information Science, The Ohio State University, 1987. + + TOO HAIRY. + + TODO: write comments */ -Array -Spacing_spanner::do_measure (int col1, int col2) const +void +Spacing_spanner::do_measure (Score_element*me, Link_array cols) { - for (int i =col1; i < col2; i++) - { - scol (i)->preprocess (); - scol (i)->print (); - } - Moment shortest; + Moment mean_shortest; + + /* + space as if this duration is present. + */ + Moment base_shortest_duration = *unsmob_moment (me->get_elt_property ("maximum-duration-for-spacing")); shortest.set_infinite (1); - for (int i =col1; i < col2; i++) + + int n = 0; + for (int i =0 ; i < cols.size (); i++) { - if (scol(i)->musical_b ()) + if (dynamic_cast (cols[i])->musical_b ()) { - shortest = shortest shortest_starter_mom_; + SCM st = cols[i]->get_elt_property ("shortest-starter-duration"); + Moment this_shortest = *unsmob_moment(st); + shortest = shortest meas_springs; - - for (int i= col1; i < col2; i++) + Real non_musical_space_strength = me->paper_l ()->get_var ("breakable_column_space_strength"); + for (int i= 0; i < cols.size () - 1; i++) { - Item * l = scol(i); - Item * r = scol(i+1); - Item * lb = l->find_prebroken_piece (RIGHT); - Item * rb = r->find_prebroken_piece (LEFT); + Item * l = dynamic_cast (cols[i]); + Item * r = dynamic_cast (cols[i+1]); + Item * lb = dynamic_cast ( l->find_prebroken_piece (RIGHT)); + Item * rb = dynamic_cast ( r->find_prebroken_piece (LEFT)); Item* combinations[4][2]={{l,r}, {lb,r}, {l,rb},{lb,rb}}; - for (int i=0; i < 4; i++) + + /* + left refers to the space that is associated with items of the left column, so you have + + LC <- left_space -><- right_space -> RC + <- total space -> + + + typically, right_space is non-zero when there are + accidentals in RC + + */ + for (int j=0; j < 4; j++) { - Score_column * lc = dynamic_cast (combinations[i][0]); - Score_column *rc = dynamic_cast (combinations[i][1]); + Paper_column * lc = dynamic_cast (combinations[j][0]); + Paper_column *rc = dynamic_cast (combinations[j][1]); if (!lc || !rc) continue; @@ -87,99 +98,174 @@ Spacing_spanner::do_measure (int col1, int col2) const s.item_l_drul_[LEFT] = lc; s.item_l_drul_[RIGHT] = rc; - SCM hint = lc->get_elt_property (extra_space_scm_sym); - SCM next_hint = rc->get_elt_property (extra_space_scm_sym); - - if (hint != SCM_BOOL_F) + SCM hint = lc->get_elt_property ("extra-space"); + SCM next_hint = rc->get_elt_property ("extra-space"); + SCM stretch_hint = lc->get_elt_property ("stretch-distance"); + SCM next_stretch_hint = rc->get_elt_property ("stretch-distance"); + + Real left_distance; + if (gh_pair_p (hint)) { - hint = SCM_CDDR (hint); - - s.distance_f_ = gh_scm2double (hint); - if (!lc->musical_b ()) - s.strength_f_ = 2.0; + left_distance = gh_scm2double (gh_cdr (hint)); } - else if (!lc->musical_b() && i+1 < col_count()) + // 2nd condition should be (i+1 < col_count()), ie. not the last column in score. FIXME + else if (!lc->musical_b() && i+1 < cols.size ()) { - s.distance_f_ = default_bar_spacing (lc,rc,shortest); - s.strength_f_ = 2.0; + left_distance= default_bar_spacing (me,lc,rc,shortest musical_b()) { - s.distance_f_ = note_spacing (lc, rc, shortest); - + left_distance = note_spacing (me,lc, rc, shortest get_elt_property ("space-factor"); + if (Item::breakable_b (lc) || lc->original_l_) + s.strength_f_ = non_musical_space_strength; + else if (gh_number_p (sfac)) + left_distance *= gh_scm2double (sfac); + - if (next_hint != SCM_BOOL_F) + Real right_dist = 0.0; + if (gh_pair_p (next_hint)) { - next_hint = SCM_CADR(next_hint); - s.distance_f_ += gh_scm2double (next_hint); + right_dist += - gh_scm2double (gh_car (next_hint)); } else { - Interval ext (rc->extent (X_AXIS)); - Real correction = ext.empty_b() ? 0.0 : - ext [LEFT]; + Interval ext (rc->extent (rc, X_AXIS)); + right_dist = ext.empty_b() ? 0.0 : - ext [LEFT]; + } + /* + don't want to create too much extra space for accidentals + */ + if (rc->musical_b ()) + { + if (to_boolean (rc->get_elt_property ("contains-grace"))) + right_dist *= me->paper_l ()->get_var ("before_grace_spacing_factor"); // fixme. + else + right_dist *= gh_scm2double (lc->get_elt_property ("before-musical-spacing-factor")); + } + + s.distance_f_ = left_distance + right_dist; + + Real stretch_dist = 0.; + if (gh_number_p (stretch_hint)) + stretch_dist += gh_scm2double (stretch_hint); + else + stretch_dist += left_distance; + + if (gh_pair_p (next_stretch_hint)) + // see regtest spacing-tight + stretch_dist += - gh_scm2double (gh_car (next_stretch_hint)); + else + stretch_dist += right_dist; + + if (s.distance_f_ <0) + { + programming_error("Negative dist, setting to 1.0 PT"); + s.distance_f_ = 1.0; + } + if (stretch_dist == 0.0) + { /* - don't want to create too much extra space for accidentals + \bar "". We give it 0 space, with high strength. */ - if (lc->musical_b () && rc->musical_b ()) - correction /= 2.0; - - s.distance_f_ += correction; + s.strength_f_ = 20.0; } + else + s.strength_f_ /= stretch_dist; - meas_springs.push (s); + s.add_to_cols (); } } - - return meas_springs; + } /** Do something if breakable column has no spacing hints set. */ Real -Spacing_spanner::default_bar_spacing (Score_column *lc, Score_column *rc, Moment shortest) const +Spacing_spanner::default_bar_spacing (Score_element*me, Score_element *lc, Score_element *rc, + Moment shortest) { - Real symbol_distance = lc->extent (X_AXIS)[RIGHT] ; + Real symbol_distance = lc->extent (lc,X_AXIS)[RIGHT] ; Real durational_distance = 0; - Moment delta_t = rc->when_mom () - lc->when_mom () ; + Moment delta_t = Paper_column::when_mom (rc) - Paper_column::when_mom (lc); - /* + /* ugh should use shortest_playing distance - */ + */ if (delta_t) { - Real k= paper_l()->arithmetic_constant (shortest); - durational_distance = paper_l()->length_mom_to_dist (delta_t,k); + durational_distance = get_duration_space (me, delta_t, shortest); } return symbol_distance >? durational_distance; } +/** + Get the measure wide ant for arithmetic spacing. + + @see + John S. Gourlay. ``Spacing a Line of Music,'' Technical Report + OSU-CISRC-10/87-TR35, Department of Computer and Information Science, + The Ohio State University, 1987. + + */ +Real +Spacing_spanner::get_duration_space (Score_element*me, Moment d, Moment shortest) +{ + Real log = log_2 (shortest); + Real k= me->paper_l ()->get_var ("arithmetic_basicspace") + - log; + + return (log_2 (d) + k) * me->paper_l ()->get_var ("arithmetic_multiplier"); +} + + Real -Spacing_spanner::note_spacing (Score_column *lc, Score_column *rc, Moment shortest) const +Spacing_spanner::note_spacing (Score_element*me, Score_element *lc, Score_element *rc, + Moment shortest) { - Moment shortest_playing_len = lc->shortest_playing_mom_; + Moment shortest_playing_len = 0; + SCM s = lc->get_elt_property ("shortest-playing-duration"); + + // SCM s = lc->get_elt_property ("mean-playing-duration"); + if (unsmob_moment (s)) + shortest_playing_len = *unsmob_moment(s); + if (! shortest_playing_len) { - warning (_f ("can't find a ruling note at %s", - lc->when_mom ().str ())); + programming_error ("can't find a ruling note at " + Paper_column::when_mom (lc).str ()); shortest_playing_len = 1; } + if (! shortest) { - warning (_f ("no minimum in measure at %s", - lc->when_mom ().str ())); + programming_error ("no minimum in measure at " + Paper_column::when_mom (lc).str ()); shortest = 1; } - Moment delta_t = rc->when_mom () - lc->when_mom (); - Real k= paper_l()->arithmetic_constant(shortest); - Real dist = paper_l()->length_mom_to_dist (shortest_playing_len, k); + Moment delta_t = Paper_column::when_mom (rc) - Paper_column::when_mom (lc); + Real dist = get_duration_space (me, shortest_playing_len, shortest); dist *= (double)(delta_t / shortest_playing_len); - dist += stem_dir_correction (lc,rc); + /* + UGH: KLUDGE! + */ + + if (delta_t > Moment (1,32)) + dist += stem_dir_correction (me, lc,rc); return dist; } @@ -192,29 +278,26 @@ Spacing_spanner::note_spacing (Score_column *lc, Score_column *rc, Moment shorte This should be more advanced, since relative heights of the note heads also influence required correction. - Also might not work correctly ico. multi voices or staff changing voices + Also might not work correctly in case of multi voices or staff + changing voices TODO: lookup correction distances? More advanced correction? Possibly turn this off? - This routine reads the DIR_LIST property of both its L and R arguments. -*/ + TODO: have to check wether the stems are in the same staff. + + This routine reads the DIR-LIST property of both its L and R arguments. */ Real -Spacing_spanner::stem_dir_correction (Score_column*l, Score_column*r) const +Spacing_spanner::stem_dir_correction (Score_element*me, Score_element*l, Score_element*r) { - SCM dl = l->get_elt_property (dir_list_scm_sym); - SCM dr = r->get_elt_property (dir_list_scm_sym); - if (dl == SCM_BOOL_F || dr == SCM_BOOL_F) - return 0.0; - - dl = SCM_CDR (dl); - dr = SCM_CDR (dr); - - if (scm_ilength (dl) != 1 && scm_ilength (dr) != 1) + SCM dl = l->get_elt_property ("dir-list"); + SCM dr = r->get_elt_property ("dir-list"); + + if (scm_ilength (dl) != 1 || scm_ilength (dr) != 1) return 0.; - dl = SCM_CAR(dl); - dr = SCM_CAR(dr); + dl = gh_car (dl); + dr = gh_car (dr); assert (gh_number_p (dl) && gh_number_p(dr)); int d1 = gh_scm2int (dl); @@ -223,46 +306,87 @@ Spacing_spanner::stem_dir_correction (Score_column*l, Score_column*r) const if (d1 == d2) return 0.0; - bool err = false; + Real correction = 0.0; - Real ssc = paper_l ()->get_realvar(ly_symbol ("stemSpacingCorrection")); + Real ssc = me->paper_l ()->get_var("stemSpacingCorrection"); - if (d1 && d2) + if (d1 && d2 && d1 * d2 == -1) { - if (d1 == 1 && d2 == -1) - correction = ssc; - else if (d1 == -1 && d2 == 1) - correction = -ssc; - else - err = true; + correction = d1 * ssc; } - else - err = true; - - if (err) programming_error ("Stem directions not set correctly for optical correction"); return correction; } -Array -Spacing_spanner::get_springs () const +MAKE_SCHEME_CALLBACK(Spacing_spanner, set_springs,1); +SCM +Spacing_spanner::set_springs (SCM smob) { - Array springs; - int last_break =0; - for (int i=1; i < col_count (); i++) + Score_element *me = unsmob_element (smob); + Link_array all (me->pscore_l_->line_l_->column_l_arr ()) ; + + int j = 0; + + for (int i = 1; i < all.size (); i++) { - if (scol (i)->breakable_b ()) + Score_element *sc = all[i]; + if (Item::breakable_b (sc)) { - springs.concat (do_measure (last_break, i)); - last_break = i; + Link_array measure (all.slice (j, i+1)); + do_measure (me, measure); + j = i; } } - return springs; + + /* + farewell, cruel world + */ + me->suicide (); + return SCM_UNSPECIFIED; } + +/* + maximum-duration-for-spacing +From: bf250@freenet.carleton.ca (John Sankey) +To: gnu-music-discuss@gnu.org +Subject: note spacing suggestion +Date: Mon, 10 Jul 2000 11:28:03 -0400 (EDT) + +Currently, Lily spaces notes by starting with a basic distance, +arithmetic_multiplier, which it applies to the minimum duration note +of the bar. Then she adds a logarithmic increment, scaled from +arithmetic_basicspace, for longer notes. (Then, columns are aligned +and justified.) Fundamentally, this matches visual spacing to musical +weight and works well. + +A lot of the time in music, I see a section basically in melodic +notes that occasionally has a rapid ornamental run (scale). So, there +will be a section in 1/4 notes, then a brief passage in 1/32nds, then +a return to long notes. Currently, Lily gives the same horizontal +space to the 1/32nd notes in their bar (even if set in small size as +is commonly done for cadenzii) as she gives to 1/4 notes in bars +where 1/4 note is the minimum duration. The resulting visual weight +does not match the musical weight over the page. + +Looking at the music I am typesetting, I feel that Lily's spacing +could be significantly improved if, with no change in the basic +method used, arithmetic_multiplier could be applied referred to the +same duration throughout a piece. Of course, the current method +should be retained for those who have already set music in it, so I +suggest a property called something like arithmetic_base=16 to fix +1/16 duration as the reference for arithmetic_multiplier; the default +would be a dynamic base is it is now. + +Does anyone else feel that this would be a useful improvement for +their music? (Of course, if arithmetic_multiplier became a regular +property, this could be used to achieve a similar result by +tweaking.) + + */