X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Faccidental-placement.cc;h=a96f0e2542afdde9c4ad0cb894e99fb12d35675a;hb=94345c6367d9e6a7dac6711cbb81845e8e889db5;hp=9a0ab1fec317539dbc79556be67644ce3f892c02;hpb=9f651eaf19ec2ae978ddebae88736e4b3d54c459;p=lilypond.git diff --git a/lily/accidental-placement.cc b/lily/accidental-placement.cc index 9a0ab1fec3..b7a41c0266 100644 --- a/lily/accidental-placement.cc +++ b/lily/accidental-placement.cc @@ -1,359 +1,518 @@ -/* -accidental-placement.cc -- implement Accidental_placement +/* + This file is part of LilyPond, the GNU music typesetter. + + Copyright (C) 2002--2012 Han-Wen Nienhuys -source file of the GNU LilyPond music typesetter + 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. -(c) 2002 Han-Wen Nienhuys + 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 -#include +#include "accidental-interface.hh" #include "item.hh" -#include "skyline.hh" #include "music.hh" -#include "pitch.hh" -#include "warn.hh" -#include "accidental-placement.hh" -#include "note-column.hh" -#include "group-interface.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" -MAKE_SCHEME_CALLBACK(Accidental_placement,extent_callback, 2); -SCM -Accidental_placement::extent_callback(SCM s, SCM axis) +static Pitch * +accidental_pitch (Grob *acc) { - Grob * me =unsmob_grob (s); - Axis a = Axis (gh_scm2int (axis)); + SCM cause = acc->get_parent (Y_AXIS)->get_property ("cause"); - assert (a == X_AXIS); + Stream_event *mcause = unsmob_stream_event (cause); + if (!mcause) + { + programming_error ("note head has no event cause"); + return 0; + } - SCM w = position_accidentals (me); - return w; + return unsmob_pitch (mcause->get_property ("pitch")); } -MAKE_SCHEME_CALLBACK(Accidental_placement,alignment_callback, 2); -SCM -Accidental_placement::alignment_callback(SCM s, SCM ) +void +Accidental_placement::add_accidental (Grob *me, Grob *a, bool stagger, long context_hash) { - Grob * me =unsmob_grob (s); + Pitch *p = accidental_pitch (a); + if (!p) + return; - Grob * par = me->get_parent (X_AXIS); - if (!to_boolean (par->get_grob_property ("alignment-done"))) - { - par->set_grob_property ("alignment-done", SCM_BOOL_T); - position_accidentals (par); - } + a->set_parent (me, X_AXIS); + a->set_property ("X-offset", Grob::x_parent_positioning_proc); + long n = p->get_notename (); - return gh_int2scm (0); -} + SCM accs = me->get_object ("accidental-grobs"); + 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 + entry = scm_cdr (entry); + entry = scm_cons (a->self_scm (), entry); + accs = scm_assoc_set_x (accs, key, entry); + me->set_object ("accidental-grobs", accs); +} + +/* + Split into break reminders. +*/ void -Accidental_placement::add_accidental (Grob* me, Grob* a) +Accidental_placement::split_accidentals (Grob *accs, + vector *break_reminder, + vector *real_acc) { - a->set_parent (me, X_AXIS); - a->add_offset_callback (alignment_callback_proc, X_AXIS); - SCM cause = a->get_parent (Y_AXIS)->get_grob_property("cause"); - - Music *mcause =unsmob_music (cause); - if (!mcause) - { - programming_error ("Note head has no music cause!"); - return; - } - - Pitch *p= unsmob_pitch (mcause->get_mus_property ("pitch")); + 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)); + + if (unsmob_grob (a->get_object ("tie")) + && !to_boolean (a->get_property ("forced"))) + break_reminder->push_back (a); + else + real_acc->push_back (a); + } +} - int n = p->notename_i_; +vector +Accidental_placement::get_relevant_accidentals (vector const &elts, Grob *left) +{ + vector br; + vector ra; + vector ret; + bool right = dynamic_cast (left)->break_status_dir () == RIGHT; - SCM accs = me->get_grob_property ("accidentals"); - SCM key = gh_int2scm (n); - SCM entry = scm_assq (key, accs); - if (entry == SCM_BOOL_F) + for (vsize i = 0; i < elts.size (); i++) { - entry = SCM_EOL; - } - else - entry = gh_cdr (entry); - - entry = gh_cons (a->self_scm (), entry); + split_accidentals (elts[i], &br, &ra); - accs = scm_assq_set_x (accs, key, entry); + ret.insert (ret.end (), ra.begin (), ra.end ()); - me->set_grob_property ("accidentals", accs); + if (right) + ret.insert (ret.end (), br.begin (), br.end ()); + } + return ret; } struct Accidental_placement_entry { - Array left_skyline_; - Array right_skyline_; - Interval vertical_extent_; - Array extents_; - Link_array grobs_; - Real offset_; - int notename_; - Accidental_placement_entry() - { - offset_ =0.0; - notename_ = -1; - } + Skyline_pair horizontal_skylines_; + vector grobs_; }; -static Interval all_accidental_vertical_extent; -Real ape_priority (Accidental_placement_entry const * a) +Real ape_priority (Accidental_placement_entry const *a) { - Real c = a->vertical_extent_.center(); - - /* - far from center means we can fold more. Hopefully. - */ - Real center_distance = - fabs(c - all_accidental_vertical_extent[LEFT]) >? - fabs(c - all_accidental_vertical_extent[RIGHT]); - - return 20 * a->vertical_extent_.length () + center_distance; + // right is up because we're horizontal + return a->horizontal_skylines_.right (); } - - -int ape_compare (Accidental_placement_entry *const &a, - Accidental_placement_entry *const &b) +bool ape_less (Accidental_placement_entry *const &a, + Accidental_placement_entry *const &b) { - return sign (ape_priority (a) - ape_priority(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); } /* - Return: width as SCM interval. + 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). - This routine computes placements of accidentals. During - add_accidental(), accidentals are already grouped by note, so that - octaves are placed above each other; they form columns. Then the - columns are sorted: the biggest columns go closest to the note. - Then the columns are spaced as closely as possible (using skyline - spacing). - - - TODO: more advanced placement. Typically, the accs should be placed - to form a C shape, like this + 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) +{ + Pitch *p = accidental_pitch (a); + Pitch *q = accidental_pitch (b); - - ## - b b - # # - b - b b + if (!p || !q) + { + programming_error ("these accidentals do not have a pitch"); + return false; + } - The naturals should be left of the C as well; they should - be separate accs. + if (p->get_octave () != q->get_octave ()) + return p->get_octave () < q->get_octave (); - TODO: Try to combine Apes before sorting them: this will allow a - better placement. + if (p->get_alteration () == Rational (0)) + return false; + if (q->get_alteration () == Rational (0)) + return true; - Note that this placement problem is almost certainly NP hard, so we - just use a simple strategy, not an optimal choice. -*/ + return p->get_alteration () < q->get_alteration (); +} -SCM -Accidental_placement::position_accidentals (Grob * me) +/* + TODO: should favor + + * b + * b + + placement +*/ +void +stagger_apes (vector *apes) { - SCM accs = me->get_grob_property ("accidentals"); + 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 (); + + for (vsize i = 0; i < ascs.size (); i++) + { + 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; + } + } - Link_array apes; - for (SCM s = accs; gh_pair_p (s); s =gh_cdr (s)) + reverse (*apes); +} + +static vector +build_apes (SCM accs) +{ + vector apes; + for (SCM s = accs; scm_is_pair (s); s = scm_cdr (s)) { Accidental_placement_entry *ape = new Accidental_placement_entry; - ape->notename_ = gh_scm2int (gh_caar (s)); - - for (SCM t = gh_cdar (s); gh_pair_p (t); t =gh_cdr (t)) - ape->grobs_.push (unsmob_grob (gh_car (t))); - apes.push (ape); + for (SCM t = scm_cdar (s); scm_is_pair (t); t = scm_cdr (t)) + ape->grobs_.push_back (unsmob_grob (scm_car (t))); + + apes.push_back (ape); } + return apes; +} - Grob *commony =0 ; +static void +set_ape_skylines (Accidental_placement_entry *ape, + Grob **common, Real padding) +{ + 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 = 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 (); + } +} - /* - First we must extract *all* pointers. We can only determine - extents if we're sure that we've found the right common refpoint - */ - Link_array note_cols, heads; - for (int i= apes.size (); i--;) - { - Accidental_placement_entry * ape = apes[i]; - for (int j = ape->grobs_.size(); j--;) - { - Grob * a = ape->grobs_[j]; - - commony = commony->common_refpoint (a, Y_AXIS); - Grob *head = a->get_parent (Y_AXIS); - - Grob * col = head->get_parent (X_AXIS); - if (Note_column::has_interface (col)) - note_cols.push (col); - else - heads.push (head); - } +static vector +extract_heads_and_stems (vector const &apes) +{ + 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); + } } /* - This is a little kludgy: to get all notes, we look if there are - collisions as well. - */ - for (int i = note_cols.size() ; i--;) + This is a little kludgy: in case there are note columns without + accidentals, we get them from the Note_collision objects. + */ + for (vsize i = note_cols.size (); i--;) { Grob *c = note_cols[i]->get_parent (X_AXIS); if (Note_collision_interface::has_interface (c)) - { - Link_array gs = - Pointer_group_interface__extract_grobs (c, (Grob*)0, "elements"); - - note_cols.concat (gs); - } - } - - for (int i = note_cols.size() ; i--;) - { - heads.concat (Pointer_group_interface__extract_grobs (note_cols[i], - (Grob*)0, - "note-heads")); - + { + extract_grob_set (c, "elements", columns); + concat (note_cols, columns); + } } - heads.default_sort(); - heads.uniq(); - commony = common_refpoint_of_array (heads, commony, Y_AXIS); - - for (int i= apes.size (); i--;) - { - Accidental_placement_entry * ape = apes[i]; - ape->left_skyline_ = empty_skyline (LEFT); - ape->right_skyline_ = empty_skyline (RIGHT); - - for (int j = apes[i]->grobs_.size(); j--;) - { - Grob * a = apes[i]->grobs_[j]; - Box b; - b[X_AXIS] = a->extent (me, X_AXIS); - b[Y_AXIS] = a->extent (commony, Y_AXIS); - - ape->extents_.push (b); - - /* - TODO: replace the extents of a flat by combination of two - bboxes, so that we use the shape of the flat better. - */ - insert_extent_into_skyline (&ape->left_skyline_, b, Y_AXIS, LEFT); - insert_extent_into_skyline (&ape->right_skyline_ , b,Y_AXIS, RIGHT); - } - } + /* Now that we have all of the columns, grab all of the note-heads */ + for (vsize i = note_cols.size (); i--;) + concat (ret, extract_grob_array (note_cols[i], "note-heads")); + /* Now that we have all of the heads, grab all of the stems */ + for (vsize i = ret.size (); i--;) + if (Grob *s = Rhythmic_head::get_stem (ret[i])) + ret.push_back (s); + + uniquify (ret); + return ret; +} - Interval total; - for (int i = apes.size(); i--;) - { - Interval y ; - - for (int j = apes[i]->extents_.size(); j--;) - { - y.unite (apes[i]->extents_[j][Y_AXIS]); - } - apes[i]->vertical_extent_ = y; - total.unite (y); - } - all_accidental_vertical_extent = total; - apes.sort (&ape_compare); - - Accidental_placement_entry * head_ape = new Accidental_placement_entry; - Grob *commonx = common_refpoint_of_array (heads, me, X_AXIS); - Array head_skyline (empty_skyline (LEFT)); - Array head_extents; - for (int i = heads.size(); i--;) - { - Box b(heads[i]->extent (commonx, X_AXIS), - heads[i]->extent (commony, Y_AXIS)); +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); + } + + return ret; +} - insert_extent_into_skyline (&head_skyline, b , Y_AXIS, LEFT); - } +static Skyline +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))); - head_ape-> left_skyline_ = head_skyline; - head_ape->offset_ = 0.0; + return Skyline (head_extents, Y_AXIS, LEFT); +} - SCM rs = me->get_grob_property ("right-padding"); - if (gh_number_p (rs)) - head_ape->offset_ -= gh_scm2double (rs); +/* + Position the apes, starting from the right, so that they don't collide. + Return the total width. +*/ +static Interval +position_apes (Grob *me, + 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)); - - Real padding = 0.2; - SCM spad = me->get_grob_property ("padding"); - if (gh_number_p (spad)) - padding = gh_scm2double (spad); - - apes.push (head_ape); - for (int i= apes.size () -1 ; i-- > 0;) + /* + Add accs entries right-to-left. + */ + Interval width; + Real last_offset = 0.0; + for (vsize i = apes.size (); i-- > 0;) { Accidental_placement_entry *ape = apes[i]; - Real d = 0.0; - int j = i+1; - do { - d = - skyline_meshing_distance (ape->right_skyline_, - apes[j]->left_skyline_); - - if (!isinf(d) - || j + 1 == apes.size()) - break; - - j = j+ 1; - } while (1); - - if (isinf(d)) - d = 0.0; - - d -= padding; - ape->offset_ += apes[j]->offset_ + d; - } - apes.pop(); - for (int i = apes.size(); i--;) - { - Accidental_placement_entry* ape = apes[i]; - for (int j = ape->grobs_.size(); j--;) - { - ape->grobs_[j]->translate_axis (ape->offset_, X_AXIS); - } + Real offset = -ape->horizontal_skylines_[RIGHT].distance (left_skyline); + if (isinf (offset)) + offset = last_offset; + else + offset -= padding; + + 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); + + for (LEFT_and_RIGHT (d)) + { + Real mh = ape->horizontal_skylines_[d].max_height (); + if (!isinf (mh)) + width.add_point (mh); + } + + last_offset = offset; } - - Interval left_extent, right_extent; - Accidental_placement_entry *ape = apes[0]; + return width; +} + +/* + This routine computes placements of accidentals. During + add_accidental (), accidentals are already grouped by note, so that + octaves are placed above each other; they form columns. Then the + columns are sorted: the biggest columns go closest to the note. + Then the columns are spaced as closely as possible (using skyline + spacing). - for (int i = ape->extents_.size(); i--;) - left_extent.unite (ape->offset_ + ape->extents_[i][X_AXIS]); - ape = apes.top(); - for (int i = ape->extents_.size(); i--;) - right_extent.unite (ape->offset_ + ape->extents_[i][X_AXIS]); + TODO: more advanced placement. Typically, the accs should be placed + to form a C shape, like this - SCM ls = me->get_grob_property ("left-padding"); - if (gh_number_p (rs)) - left_extent[LEFT] -= gh_scm2double (ls); + * ## + * b b + * # # + * b + * b b - - Interval width(left_extent[LEFT], right_extent[RIGHT]); + The naturals should be left of the C as well; they should + be separate accs. - SCM scm_width = ly_interval2scm (width); - me->set_extent (scm_width, X_AXIS); - - for (int i = apes.size(); i--;) - delete apes[i]; + Note that this placement problem looks NP hard, so we just use a + simple strategy, not an optimal choice. +*/ + +/* + TODO: there should be more space in the following situation + + + Natural + downstem + + * + * |_ + * | | X + * |_| | + * | | + * +*/ + +MAKE_SCHEME_CALLBACK (Accidental_placement, calc_positioning_done, 1); +SCM +Accidental_placement::calc_positioning_done (SCM smob) +{ + Grob *me = unsmob_grob (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); + + Grob *common[] = {me, 0}; + + 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, padding); + Skyline heads_skyline = build_heads_skyline (heads_and_stems, common); + + stagger_apes (&apes); + Interval width = position_apes (me, apes, heads_skyline); + + me->flush_extent_cache (X_AXIS); + me->set_property ("X-extent", ly_interval2scm (width)); + + junk_pointers (apes); - return scm_width; + return SCM_BOOL_T; } -ADD_INTERFACE(Accidental_placement, - "accidental-placement-interface", - "Take care of complex accidental collisions.", - "left-padding padding right-padding accidentals alignment-done") +ADD_INTERFACE (Accidental_placement, + "Resolve accidental collisions.", + + /* properties */ + "accidental-grobs " + "direction " + "padding " + "positioning-done " + "right-padding " + "script-priority " + );