X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Faccidental-placement.cc;h=c8c14d4bd980ce54cceba08d4c3f56eee003c937;hb=47db9a3883d726ca53e2133a3b2298f78dd6a32e;hp=0f14cc9a83e94e021e173075c6b1dfa4ddc9b7ff;hpb=10f6972fc8fce3ea99b880955f7a28e6ff5e5475;p=lilypond.git diff --git a/lily/accidental-placement.cc b/lily/accidental-placement.cc index 0f14cc9a83..c8c14d4bd9 100644 --- a/lily/accidental-placement.cc +++ b/lily/accidental-placement.cc @@ -1,47 +1,66 @@ /* - accidental-placement.cc -- implement Accidental_placement + This file is part of LilyPond, the GNU music typesetter. - source file of the GNU LilyPond music typesetter + Copyright (C) 2002--2015 Han-Wen Nienhuys - (c) 2002--2009 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 "accidental-placement.hh" -#include "item.hh" -#include "rhythmic-head.hh" #include "accidental-interface.hh" +#include "item.hh" #include "music.hh" #include "note-collision.hh" #include "note-column.hh" #include "pointer-group-interface.hh" +#include "rhythmic-head.hh" #include "skyline.hh" +#include "skyline-pair.hh" #include "stream-event.hh" #include "warn.hh" - -void -Accidental_placement::add_accidental (Grob *me, Grob *a) +static Pitch * +accidental_pitch (Grob *acc) { - a->set_parent (me, X_AXIS); - a->set_property ("X-offset", Grob::x_parent_positioning_proc); - SCM cause = a->get_parent (Y_AXIS)->get_property ("cause"); + SCM cause = acc->get_parent (Y_AXIS)->get_property ("cause"); - Stream_event *mcause = unsmob_stream_event (cause); + Stream_event *mcause = Stream_event::unsmob (cause); if (!mcause) { programming_error ("note head has no event cause"); - return; + return 0; } - Pitch *p = unsmob_pitch (mcause->get_property ("pitch")); + return Pitch::unsmob (mcause->get_property ("pitch")); +} + +void +Accidental_placement::add_accidental (Grob *me, Grob *a, bool stagger, long context_hash) +{ + Pitch *p = accidental_pitch (a); + if (!p) + return; - int n = p->get_notename (); + a->set_parent (me, X_AXIS); + a->set_property ("X-offset", Grob::x_parent_positioning_proc); + long n = p->get_notename (); SCM accs = me->get_object ("accidental-grobs"); - SCM key = scm_from_int (n); - SCM entry = scm_assq (key, accs); + SCM key = scm_cons (scm_from_int (n), scm_from_long (stagger ? context_hash : 1)); + // assoc because we're dealing with pairs + SCM entry = scm_assoc (key, accs); if (entry == SCM_BOOL_F) entry = SCM_EOL; else @@ -49,7 +68,7 @@ Accidental_placement::add_accidental (Grob *me, Grob *a) entry = scm_cons (a->self_scm (), entry); - accs = scm_assq_set_x (accs, key, entry); + accs = scm_assoc_set_x (accs, key, entry); me->set_object ("accidental-grobs", accs); } @@ -59,121 +78,166 @@ Accidental_placement::add_accidental (Grob *me, Grob *a) */ void Accidental_placement::split_accidentals (Grob *accs, - vector *break_reminder, - vector *real_acc) + vector *break_reminder, + vector *real_acc) { for (SCM acs = accs->get_object ("accidental-grobs"); scm_is_pair (acs); acs = scm_cdr (acs)) for (SCM s = scm_cdar (acs); scm_is_pair (s); s = scm_cdr (s)) { - Grob *a = unsmob_grob (scm_car (s)); + Grob *a = Grob::unsmob (scm_car (s)); - if (unsmob_grob (a->get_object ("tie")) - && !to_boolean (a->get_property ("forced"))) - break_reminder->push_back (a); - else - real_acc->push_back (a); + if (Grob::is_smob (a->get_object ("tie")) + && !to_boolean (a->get_property ("forced"))) + break_reminder->push_back (a); + else + real_acc->push_back (a); } } -vector -Accidental_placement::get_relevant_accidentals (vector const &elts, Grob *left) +vector +Accidental_placement::get_relevant_accidentals (vector const &elts, Grob *left) { - vector br; - vector ra; - vector ret; + vector br; + vector ra; + vector ret; bool right = dynamic_cast (left)->break_status_dir () == RIGHT; for (vsize i = 0; i < elts.size (); i++) { split_accidentals (elts[i], &br, &ra); - + ret.insert (ret.end (), ra.begin (), ra.end ()); if (right) - ret.insert (ret.end (), br.begin (), br.end ()); + ret.insert (ret.end (), br.begin (), br.end ()); } return ret; } struct Accidental_placement_entry { - Skyline left_skyline_; - Skyline right_skyline_; - Interval vertical_extent_; - vector extents_; - vector grobs_; + Skyline_pair horizontal_skylines_; + vector grobs_; }; Real ape_priority (Accidental_placement_entry const *a) { - return a->vertical_extent_[UP]; -} - -int ape_compare (Accidental_placement_entry *const &a, - Accidental_placement_entry *const &b) -{ - return sign (ape_priority (a) - ape_priority (b)); + // right is up because we're horizontal + return a->horizontal_skylines_.right (); } bool ape_less (Accidental_placement_entry *const &a, - Accidental_placement_entry *const &b) + Accidental_placement_entry *const &b) { + vsize size_a = a->grobs_.size (); + vsize size_b = b->grobs_.size (); + if (size_a != size_b) + return size_b < size_a; + return ape_priority (a) < ape_priority (b); } -int ape_rcompare (Accidental_placement_entry *const &a, - Accidental_placement_entry *const &b) +/* + This function provides a method for sorting accidentals that belong to the + same note. The accidentals that this function considers to be "smallest" + will be placed to the left of the "larger" accidentals. + + Naturals are the largest (so that they don't get confused with cancellation + naturals); apart from that, we order according to the alteration (so + double-flats are the smallest). + + Precondition: the accidentals are attached to NoteHeads of the same note + name -- the octaves, however, may be different. +*/ +static bool +acc_less (Grob *const &a, Grob *const &b) { - return -sign (ape_priority (a) - ape_priority (b)); + Pitch *p = accidental_pitch (a); + Pitch *q = accidental_pitch (b); + + if (!p || !q) + { + programming_error ("these accidentals do not have a pitch"); + return false; + } + + if (p->get_octave () != q->get_octave ()) + return p->get_octave () < q->get_octave (); + + if (p->get_alteration () == Rational (0)) + return false; + if (q->get_alteration () == Rational (0)) + return true; + + return p->get_alteration () < q->get_alteration (); } /* TODO: should favor - b - b + * b + * b placement */ void -stagger_apes (vector *apes) +stagger_apes (vector *apes) { - vector asc = *apes; + vector asc = *apes; vector_sort (asc, &ape_less); + // we do the staggering below based on size + // this ensures that if a placement has 4 entries, it will + // always be closer to the NoteColumn than a placement with 1 + // this allows accidentals to be on-average closer to notes + // while still preserving octave alignment + vector > ascs; + + vsize sz = INT_MAX; + for (vsize i = 0; i < asc.size (); i++) + { + vsize my_sz = asc[i]->grobs_.size (); + if (sz != my_sz) + ascs.push_back (vector ()); + ascs.back ().push_back (asc[i]); + sz = my_sz; + } apes->clear (); - int parity = 1; - for (vsize i = 0; i < asc.size ();) + for (vsize i = 0; i < ascs.size (); i++) { - Accidental_placement_entry *a = 0; - if (parity) - { - a = asc.back (); - asc.pop_back (); - } - else - a = asc[i++]; - - apes->push_back (a); - parity = !parity; + int parity = 1; + for (vsize j = 0; j < ascs[i].size ();) + { + Accidental_placement_entry *a = 0; + if (parity) + { + a = ascs[i].back (); + ascs[i].pop_back (); + } + else + a = ascs[i][j++]; + + apes->push_back (a); + parity = !parity; + } } reverse (*apes); } -static vector +static vector build_apes (SCM accs) { - vector apes; + vector apes; for (SCM s = accs; scm_is_pair (s); s = scm_cdr (s)) { Accidental_placement_entry *ape = new Accidental_placement_entry; for (SCM t = scm_cdar (s); scm_is_pair (t); t = scm_cdr (t)) - ape->grobs_.push_back (unsmob_grob (scm_car (t))); + ape->grobs_.push_back (Grob::unsmob (scm_car (t))); apes.push_back (ape); } @@ -183,41 +247,77 @@ build_apes (SCM accs) static void set_ape_skylines (Accidental_placement_entry *ape, - Grob **common) + Grob **common, Real padding) { - for (vsize i = ape->grobs_.size (); i--;) + vector accs (ape->grobs_); + vector_sort (accs, &acc_less); + + /* We know that each accidental has the same note name and we assume that + accidentals in different octaves won't collide. If two or more + accidentals are in the same octave: + 1) if they are the same accidental, print them in overstrike + 2) otherwise, shift one to the left so they don't overlap. */ + int last_octave = 0; + Real offset = 0; + Real last_offset = 0; + Rational last_alteration (0); + for (vsize i = accs.size (); i--;) { - Grob *a = ape->grobs_[i]; - vector boxes = Accidental_interface::accurate_boxes (a, common); - ape->extents_.insert (ape->extents_.end (), boxes.begin (), boxes.end ()); - - for (vsize j = boxes.size (); j--;) - ape->vertical_extent_.unite (boxes[j][Y_AXIS]); + Grob *a = accs[i]; + Pitch *p = accidental_pitch (a); + + if (!p) + continue; + + if (i == accs.size () - 1 || p->get_octave () != last_octave) + { + last_offset = 0; + offset = a->extent (a, X_AXIS)[LEFT] - padding; + } + else if (p->get_alteration () == last_alteration) + a->translate_axis (last_offset, X_AXIS); + else /* Our alteration is different from the last one */ + { + Real this_offset = offset - a->extent (a, X_AXIS)[RIGHT]; + a->translate_axis (this_offset, X_AXIS); + + last_offset = this_offset; + offset -= a->extent (a, X_AXIS).length () + padding; + } + + if (Skyline_pair *sky = Skyline_pair::unsmob (a->get_property ("horizontal-skylines"))) + { + Skyline_pair copy (*sky); + copy.raise (a->relative_coordinate (common[X_AXIS], X_AXIS)); + copy.shift (a->relative_coordinate (common[Y_AXIS], Y_AXIS)); + ape->horizontal_skylines_.merge (copy); + } + + last_octave = p->get_octave (); + last_alteration = p->get_alteration (); } - ape->left_skyline_ = Skyline (ape->extents_, 0, Y_AXIS, LEFT); - ape->right_skyline_ = Skyline (ape->extents_, 0, Y_AXIS, RIGHT); } -static vector -extract_heads_and_stems (vector const &apes) +static vector +extract_heads_and_stems (vector const &apes) { - vector note_cols; - vector ret; + vector note_cols; + vector ret; for (vsize i = apes.size (); i--;) { Accidental_placement_entry *ape = apes[i]; for (vsize j = ape->grobs_.size (); j--;) - { - Grob *acc = ape->grobs_[j]; - Grob *head = acc->get_parent (Y_AXIS); - Grob *col = head->get_parent (X_AXIS); - - if (Note_column::has_interface (col)) - note_cols.push_back (col); - else - ret.push_back (head); - } + { + Grob *acc = ape->grobs_[j]; + Grob *head = acc->get_parent (Y_AXIS); + Grob *col = head->get_parent (X_AXIS); + + if (Note_column::has_interface (col)) + note_cols.push_back (col); + else + ret.push_back (head); + } } /* @@ -228,10 +328,10 @@ extract_heads_and_stems (vector const &apes) { Grob *c = note_cols[i]->get_parent (X_AXIS); if (Note_collision_interface::has_interface (c)) - { - extract_grob_set (c, "elements", columns); - concat (note_cols, columns); - } + { + extract_grob_set (c, "elements", columns); + concat (note_cols, columns); + } } /* Now that we have all of the columns, grab all of the note-heads */ @@ -242,40 +342,38 @@ extract_heads_and_stems (vector const &apes) for (vsize i = ret.size (); i--;) if (Grob *s = Rhythmic_head::get_stem (ret[i])) ret.push_back (s); - - - vector_sort (ret, less ()); - uniq (ret); + + uniquify (ret); return ret; } -static Grob* -common_refpoint_of_accidentals (vector const &apes, Axis a) +static Grob * +common_refpoint_of_accidentals (vector const &apes, Axis a) { Grob *ret = 0; for (vsize i = apes.size (); i--;) for (vsize j = apes[i]->grobs_.size (); j--;) { - if (!ret) - ret = apes[i]->grobs_[j]; - else - ret = ret->common_refpoint (apes[i]->grobs_[j], a); + if (!ret) + ret = apes[i]->grobs_[j]; + else + ret = ret->common_refpoint (apes[i]->grobs_[j], a); } return ret; } static Skyline -build_heads_skyline (vector const &heads_and_stems, - Grob **common) +build_heads_skyline (vector const &heads_and_stems, + Grob **common) { vector head_extents; for (vsize i = heads_and_stems.size (); i--;) head_extents.push_back (Box (heads_and_stems[i]->extent (common[X_AXIS], X_AXIS), - heads_and_stems[i]->pure_height (common[Y_AXIS], 0, INT_MAX))); + heads_and_stems[i]->pure_height (common[Y_AXIS], 0, INT_MAX))); - return Skyline (head_extents, 0, Y_AXIS, LEFT); + return Skyline (head_extents, Y_AXIS, LEFT); } /* @@ -284,13 +382,13 @@ build_heads_skyline (vector const &heads_and_stems, */ static Interval position_apes (Grob *me, - vector const &apes, - Skyline const &heads_skyline) + vector const &apes, + Skyline const &heads_skyline) { Real padding = robust_scm2double (me->get_property ("padding"), 0.2); Skyline left_skyline = heads_skyline; left_skyline.raise (-robust_scm2double (me->get_property ("right-padding"), 0)); - + /* Add accs entries right-to-left. */ @@ -300,23 +398,28 @@ position_apes (Grob *me, { Accidental_placement_entry *ape = apes[i]; - Real offset = -ape->right_skyline_.distance (left_skyline); + Real offset = -ape->horizontal_skylines_[RIGHT] + .distance (left_skyline, 0.1); if (isinf (offset)) - offset = last_offset; + offset = last_offset; else - offset -= padding; + offset -= padding; - Skyline new_left_skyline = ape->left_skyline_; + Skyline new_left_skyline = ape->horizontal_skylines_[LEFT]; new_left_skyline.raise (offset); new_left_skyline.merge (left_skyline); left_skyline = new_left_skyline; /* Shift all of the accidentals in this ape */ for (vsize j = ape->grobs_.size (); j--;) - ape->grobs_[j]->translate_axis (offset, X_AXIS); + ape->grobs_[j]->translate_axis (offset, X_AXIS); - for (vsize j = ape->extents_.size (); j--;) - width.unite (offset + ape->extents_[j][X_AXIS]); + for (LEFT_and_RIGHT (d)) + { + Real mh = ape->horizontal_skylines_[d].max_height (); + if (!isinf (mh)) + width.add_point (mh + offset); + } last_offset = offset; } @@ -324,7 +427,6 @@ position_apes (Grob *me, return width; } - /* This routine computes placements of accidentals. During add_accidental (), accidentals are already grouped by note, so that @@ -337,12 +439,11 @@ position_apes (Grob *me, TODO: more advanced placement. Typically, the accs should be placed to form a C shape, like this - - ## - b b - # # - b - b b + * ## + * b b + * # # + * b + * b b The naturals should be left of the C as well; they should be separate accs. @@ -363,35 +464,35 @@ position_apes (Grob *me, * |_| | * | | * - */ MAKE_SCHEME_CALLBACK (Accidental_placement, calc_positioning_done, 1); SCM Accidental_placement::calc_positioning_done (SCM smob) { - Grob *me = unsmob_grob (smob); + Grob *me = Grob::unsmob (smob); if (!me->is_live ()) return SCM_BOOL_T; me->set_property ("positioning-done", SCM_BOOL_T); - + SCM accs = me->get_object ("accidental-grobs"); if (!scm_is_pair (accs)) return SCM_BOOL_T; - vector apes = build_apes (accs); + vector apes = build_apes (accs); Grob *common[] = {me, 0}; - vector heads_and_stems = extract_heads_and_stems (apes); + vector heads_and_stems = extract_heads_and_stems (apes); common[Y_AXIS] = common_refpoint_of_accidentals (apes, Y_AXIS); common[Y_AXIS] = common_refpoint_of_array (heads_and_stems, common[Y_AXIS], Y_AXIS); common[X_AXIS] = common_refpoint_of_array (heads_and_stems, me, X_AXIS); + Real padding = robust_scm2double (me->get_property ("padding"), 0.2); for (vsize i = apes.size (); i--;) - set_ape_skylines (apes[i], common); + set_ape_skylines (apes[i], common, padding); Skyline heads_skyline = build_heads_skyline (heads_and_stems, common); stagger_apes (&apes); @@ -406,14 +507,13 @@ Accidental_placement::calc_positioning_done (SCM smob) } ADD_INTERFACE (Accidental_placement, - "Resolve accidental collisions.", - - /* properties */ - "accidental-grobs " - "direction " - "left-padding " - "padding " - "positioning-done " - "right-padding " - "script-priority " - ) + "Resolve accidental collisions.", + + /* properties */ + "accidental-grobs " + "direction " + "padding " + "positioning-done " + "right-padding " + "script-priority " + );