Uses horizontal skylines in accidental placement

lily/accidental-placement.cc

 /*
   This file is part of LilyPond, the GNU music typesetter.
 
   Copyright (C) 2002--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
 
   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 <http://www.gnu.org/licenses/>.
 */
 
 #include "accidental-placement.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"
 
 static Pitch *
 accidental_pitch (Grob *acc)
 {
   SCM cause = acc->get_parent (Y_AXIS)->get_property ("cause");
 
   Stream_event *mcause = unsmob_stream_event (cause);
   if (!mcause)
@@ skipping 68 matching lines @@
       ret.insert (ret.end (), ra.begin (), ra.end ());
 
       if (right)
         ret.insert (ret.end (), br.begin (), br.end ());
     }
   return ret;
 }
 
 struct Accidental_placement_entry
 {
-  Skyline left_skyline_;
-  Skyline right_skyline_;
-  Interval vertical_extent_;
-  vector<Box> extents_;
+  Skyline_pair horizontal_skylines_;
   vector<Grob *> grobs_;
 };
 
 Real ape_priority (Accidental_placement_entry const *a)
 {
-  return a->vertical_extent_[UP];
+  // 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)
 {
   return ape_priority (a) < ape_priority (b);
 }
 
 /*
   This function provides a method for sorting accidentals that belong to the
@@ skipping 116 matching lines @@
         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;
         }
 
-      vector<Box> 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]);
+      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_, Y_AXIS, LEFT);
-  ape->right_skyline_ = Skyline (ape->extents_, Y_AXIS, RIGHT);
 }
 
 static vector<Grob *>
 extract_heads_and_stems (vector<Accidental_placement_entry *> const &apes)
 {
   vector<Grob *> note_cols;
   vector<Grob *> ret;
 
   for (vsize i = apes.size (); i--;)
     {
@@ skipping 83 matching lines @@
 
   /*
     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 offset = -ape->right_skyline_.distance (left_skyline);
+      Real offset = -ape->horizontal_skylines_[RIGHT].distance (left_skyline);

[Keith, 2012/09/28 06:56:36]

Both Mike and Janek thought the accidentals needed a bit more padding for close
intervals, so I think Janek should try horizon_padding here with 
distance(left_skyline, 0.1)

If you think it worth making a tunable property of AccidentalPlacement, fine. 
But the old parameters were not tunable, and better to have a non-tunable
correct spacing than non-tunable incorrect spacing.

       if (isinf (offset))
         offset = last_offset;
       else
         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);
 
-      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);
+        }
 
       last_offset = offset;
     }
 
   return width;
 }
 
 /*
   This routine computes placements of accidentals. During
   add_accidental (), accidentals are already grouped by note, so that
@@ skipping 77 matching lines @@
                "Resolve accidental collisions.",
 
                /* properties */
                "accidental-grobs "
                "direction "
                "padding "
                "positioning-done "
                "right-padding "
                "script-priority "
               );