X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Ftie-formatting-problem.cc;h=f7682c904c56db5af97bcd4c9c3f0c240e6a7b84;hb=f604d2f2f7f03cbbd43182c14ef20647d16f87d8;hp=4dada25d220116b68dfc8f6a70b8a7e962a53a1e;hpb=392960cc1178c8560b54598bc081e54fbd85dcb7;p=lilypond.git

diff --git a/lily/tie-formatting-problem.cc b/lily/tie-formatting-problem.cc
index 4dada25d22..f7682c904c 100644
--- a/lily/tie-formatting-problem.cc
+++ b/lily/tie-formatting-problem.cc
@@ -3,7 +3,7 @@
 
   source file of the GNU LilyPond music typesetter
 
-  (c) 2005--2006 Han-Wen Nienhuys <hanwen@xs4all.nl>
+  (c) 2005--2007 Han-Wen Nienhuys <hanwen@xs4all.nl>
 
 */
 
@@ -12,7 +12,6 @@
 #include "paper-column.hh"
 #include "bezier.hh" 
 #include "directional-element-interface.hh"
-#include "item.hh"
 #include "libc-extension.hh"
 #include "misc.hh"
 #include "note-head.hh"
@@ -23,7 +22,8 @@
 #include "tie-configuration.hh"
 #include "tie.hh"
 #include "warn.hh"
-
+#include "pointer-group-interface.hh"
+#include "output-def.hh"
 
 void
 Tie_formatting_problem::print_ties_configuration (Ties_configuration const *ties)
@@ -49,16 +49,16 @@ Tie_formatting_problem::get_attachment (Real y, Drul_array<int> columns) const
       Tuple2<int> key (columns[d], int (d));
       Chord_outline_map::const_iterator i (chord_outlines_.find (key));
       if (i == chord_outlines_.end ())
-	programming_error ("Can't find chord outline");
+	programming_error ("Cannot find chord outline");
       else
-	attachments[d] = skyline_height ((*i).second, y, -d);
+	attachments[d] = i->second.height (y);
     }
   while (flip (&d) != LEFT);
   
   return attachments;
 }
 
-Tie_formatting_problem::Tie_formatting_problem()
+Tie_formatting_problem::Tie_formatting_problem ()
 {
   x_refpoint_ = 0;
 }
@@ -104,6 +104,9 @@ Tie_formatting_problem::set_column_chord_outline (vector<Item*> bounds,
 	  Interval x = dots->extent (x_refpoint_, X_AXIS);
 	  int p = int (Staff_symbol_referencer::get_position (dots));
 
+	  /*
+	    TODO: shouldn't this use column-rank dependent key?  
+	  */
 	  dot_positions_.insert (p);
 	  dot_x_.unite (x);
 
@@ -115,71 +118,82 @@ Tie_formatting_problem::set_column_chord_outline (vector<Item*> bounds,
     }
 
   Tuple2<int> key (column_rank, int (dir));
-  
-  chord_outlines_[key] = empty_skyline (-dir);
-      
-  if (bounds[0]->break_status_dir ())
-    {
-      Real x = robust_relative_extent (bounds[0],  x_refpoint_, X_AXIS)[-dir];
-      chord_outlines_[key].at (0).height_ = x; 
-    }
-  else
-    {
-      Interval x;
-      for (vsize j = 0; j < head_boxes.size (); j++)
-	{
-	  x.unite (head_boxes[j][X_AXIS]);
-	}
-      
-      chord_outlines_[key].at (0).height_ = x[dir];
-    }
-      
-  for (vsize i = 0; i < boxes.size (); i++)
-    insert_extent_into_skyline (&chord_outlines_[key]  ,
-				boxes[i], Y_AXIS, -dir);
 
-  if (stem
-      && !Stem::is_invisible (stem))
+  if (stem)
     {
-      Interval x;
-      x.add_point (stem->relative_coordinate (x_refpoint_, X_AXIS));
-      x.widen (staff_space / 20); // ugh.
-      Interval y;
-      y.add_point (Stem::stem_end_position (stem) * staff_space * .5);
-
-      Direction stemdir = get_grob_direction (stem);
-      y.add_point (Stem::head_positions (stem)[-stemdir]
-		   * staff_space * .5);
+      if (Stem::is_normal_stem (stem))
+	{
 	  
-      insert_extent_into_skyline (&chord_outlines_[key], Box (x,y), Y_AXIS, -dir);
+	  Interval x;
+	  x.add_point (stem->relative_coordinate (x_refpoint_, X_AXIS));
+	  x.widen (staff_space / 20); // ugh.
+	  Interval y;
+	  Real stem_end_position =
+	    Stem::is_cross_staff (stem)
+	    ? get_grob_direction (stem) * infinity_f
+	    : Stem::stem_end_position (stem) * staff_space * .5;
+
+	  y.add_point (stem_end_position);
+
+	  Direction stemdir = get_grob_direction (stem);
+	  y.add_point (Stem::head_positions (stem)[-stemdir]
+		       * staff_space * .5);
+
+	  /*
+	    add extents of stem.
+	  */
+	  boxes.push_back (Box (x, y));
 
-      stem_extents_[key].unite (Box (x,y));
+	  stem_extents_[key].unite (Box (x, y));
 
-      if (dir == LEFT)
+	  if (dir == LEFT)
+	    {
+	      Box flag_box = Stem::get_translated_flag (stem).extent_box ();
+	      flag_box.translate ( Offset (x[RIGHT], X_AXIS));
+	      boxes.push_back (flag_box);
+	    }
+	}
+      else
 	{
-	  Box flag_box = Stem::get_translated_flag (stem).extent_box ();
-	  flag_box.translate( Offset (x[RIGHT], X_AXIS));
-	  insert_extent_into_skyline (&chord_outlines_[key], flag_box,
-				      Y_AXIS, -dir);
+	  Grob *head = Stem::support_head (stem);
+
+	  /*
+	    In case of invisible stem, don't pass x-center of heads.
+	  */
+	  Real x_center = head->extent (x_refpoint_, X_AXIS).center ();
+	  Interval x_ext;
+	  x_ext[-dir] = x_center;
+	  Interval y_ext;
+	  for (vsize j = 0; j < head_boxes.size (); j++)
+	    y_ext.unite (head_boxes[j][Y_AXIS]);
+
+	  boxes.push_back (Box (x_ext, y_ext));
 	}
-    }
-  else if (stem)
-    {
-      Grob *head = Stem::support_head (stem);
 
-      /*
-	In case of invisible stem, don't pass x-center of heads.
-       */
-      Real x_center = head->extent (x_refpoint_, X_AXIS).center ();
-      Interval x_ext;
-      x_ext[-dir] = x_center;
-      Interval y_ext;
-      for (vsize j = 0; j < head_boxes.size (); j++)
-	y_ext.unite (head_boxes[j][Y_AXIS]);
+      extract_grob_set (stem, "note-heads", heads);
+      for (vsize i = 0; i < heads.size (); i ++)
+	{
+	  if (find (bounds.begin (), bounds.end (), dynamic_cast<Item*> (heads[i])) ==  bounds.end ())
+	    {
+	      /*
+		other untied notes in the same chord.
+	      */
 	  
-      insert_extent_into_skyline (&chord_outlines_[key],
-				  Box (x_ext, y_ext),
-				  Y_AXIS, -dir);
+	      Interval y = Staff_symbol_referencer::extent_in_staff (heads[i]);
+	      Interval x = heads[i]->extent (x_refpoint_, X_AXIS);
+	      boxes.push_back (Box (x, y));
+	    }
+	  
+	  Grob *acc = unsmob_grob (heads[i]->get_object ("accidental-grob"));
+	  if (acc && acc->is_live () && dir == RIGHT)
+	    {
+	      boxes.push_back (Box (acc->extent (x_refpoint_, X_AXIS),
+				    Staff_symbol_referencer::extent_in_staff (acc)));
+	    }
+
+	  head_positions_[column_rank].add_point (int (Staff_symbol_referencer::get_position (heads[i])));
+	}
+      
     }
   
   Direction updowndir = DOWN;
@@ -187,7 +201,7 @@ Tie_formatting_problem::set_column_chord_outline (vector<Item*> bounds,
     {
       Interval x;
       Interval y;
-      if (head_boxes.size())
+      if (head_boxes.size ())
 	{
 	  Box b = boundary (head_boxes, updowndir, 0);
 	  x = b[X_AXIS];
@@ -197,12 +211,29 @@ Tie_formatting_problem::set_column_chord_outline (vector<Item*> bounds,
 	}
 
       if (!x.is_empty ())
-	insert_extent_into_skyline (&chord_outlines_[key],
-				    Box (x,y),
-				    Y_AXIS, -dir);
+	boxes.push_back (Box (x, y));
     }
   while (flip (&updowndir) != DOWN);
-  
+
+  /* todo: the horizon_padding is somewhat arbitrary */
+  chord_outlines_[key] = Skyline (boxes, details_.skyline_padding_, Y_AXIS, -dir);
+  if (bounds[0]->break_status_dir ())
+    {
+      Real x = robust_relative_extent (bounds[0],  x_refpoint_, X_AXIS)[-dir];
+      
+      chord_outlines_[key].set_minimum_height (x);
+    }
+  else
+    {
+      Interval x;
+      for (vsize j = 0; j < head_boxes.size (); j++)
+	{
+	  x.unite (head_boxes[j][X_AXIS]);
+	}
+      
+      chord_outlines_[key].set_minimum_height (x[dir]);
+    }
+
   head_extents_[key].set_empty ();
   for (vsize i = 0; i < head_boxes.size (); i++)
     {
@@ -276,8 +307,19 @@ Tie_formatting_problem::from_ties (vector<Grob*> const &ties)
       for (vsize i = 0; i < ties.size (); i++)
 	{
 	  Item *it = dynamic_cast<Spanner*> (ties[i])->get_bound (d);
-					     
-	  bounds.push_back (it);
+	  if (it->break_status_dir ())
+	    {
+	      Item *sep
+		= dynamic_cast<Item*> (unsmob_grob (ties[i]->get_object ("separation-item")));
+	      if (sep && sep->get_column () == it->get_column ())
+		it = sep;
+
+	      bounds.push_back (it);
+	    }
+	  else 
+	    {
+	      bounds.push_back (it);
+	    }
 	}
       
       set_chord_outline (bounds, d);
@@ -288,16 +330,12 @@ Tie_formatting_problem::from_ties (vector<Grob*> const &ties)
   for (vsize i = 0; i < ties.size (); i++)
     {
       Tie_specification spec;
-
-      spec.get_tie_manual_settings (ties[i]);
-      
-
+      spec.from_grob (ties[i]);
       
       do
 	{
 	  spec.note_head_drul_[d] = Tie::head (ties[i], d);
-	  spec.column_ranks_[d] =
-	    dynamic_cast<Spanner*> (ties[i])->get_bound (d)->get_column ()->get_rank ();
+	  spec.column_ranks_[d] = Tie::get_column_rank (ties[i], d);
 	}
       while (flip (&d) != LEFT);
       specifications_.push_back (spec);
@@ -327,10 +365,10 @@ Tie_formatting_problem::from_semi_ties (vector<Grob*> const &semi_ties, Directio
 	  spec.position_ = int (Staff_symbol_referencer::get_position (head));
 	}
 
-      spec.get_tie_manual_settings (semi_ties[i]);
+      spec.from_grob (semi_ties[i]);
       
       spec.note_head_drul_[head_dir] = head;
-      column_rank = dynamic_cast<Item*> (head)->get_column ()->get_rank ();
+      column_rank = Tie::get_column_rank (semi_ties[i], head_dir);
       spec.column_ranks_ = Drul_array<int> (column_rank, column_rank);
       heads.push_back (head);
       specifications_.push_back (spec);
@@ -344,22 +382,12 @@ Tie_formatting_problem::from_semi_ties (vector<Grob*> const &semi_ties, Directio
 
   set_chord_outline (heads, head_dir);
 
-  Real extremal = head_dir * infinity_f;   
-
   Tuple2<int> head_key (column_rank, head_dir);
   Tuple2<int> open_key (column_rank, -head_dir);
-  
-  for (vsize i = 0; i < chord_outlines_[head_key].size (); i++)
-    {
-      extremal = head_dir * min (head_dir * extremal,
-				 head_dir * chord_outlines_[head_key][i].height_);
-    }
+  Real extremal = chord_outlines_[head_key].max_height ();
 
-  Skyline_entry right_entry;
-  right_entry.width_.set_full ();
-  right_entry.height_ = extremal - head_dir * 1.5;
-  
-  chord_outlines_[open_key].push_back (right_entry);
+  chord_outlines_[open_key] = Skyline (head_dir);
+  chord_outlines_[open_key].set_minimum_height (extremal - head_dir * 1.5);
 }
 
 
@@ -374,7 +402,8 @@ Tie_formatting_problem::get_tie_specification (int i) const
   Return configuration, create it if necessary. 
 */
 Tie_configuration*
-Tie_formatting_problem::get_configuration (int pos, Direction dir, Drul_array<int> columns) const
+Tie_formatting_problem::get_configuration (int pos, Direction dir, Drul_array<int> columns,
+					   bool tune_dy) const
 {
   int key_components[] = {
     pos, dir, columns[LEFT], columns[RIGHT]
@@ -388,14 +417,14 @@ Tie_formatting_problem::get_configuration (int pos, Direction dir, Drul_array<in
     }
 
   
-  Tie_configuration *conf = generate_configuration (pos, dir, columns);
+  Tie_configuration *conf = generate_configuration (pos, dir, columns, tune_dy);
   ((Tie_formatting_problem*) this)->possibilities_[key] = conf;
   return conf;
 }
 
 Tie_configuration*
 Tie_formatting_problem::generate_configuration (int pos, Direction dir,
-						Drul_array<int> columns) const
+						Drul_array<int> columns, bool y_tune) const
 {
   Tie_configuration *conf = new Tie_configuration;
   conf->position_ = pos;
@@ -405,7 +434,6 @@ Tie_formatting_problem::generate_configuration (int pos, Direction dir,
   
   Real y = conf->position_ * 0.5 * details_.staff_space_;
 
-  bool y_tune = true;
   if (dot_positions_.find (pos) != dot_positions_.end ())
     {
       conf->delta_y_ += dir * 0.25 * details_.staff_space_;
@@ -436,37 +464,41 @@ Tie_formatting_problem::generate_configuration (int pos, Direction dir,
 	size.
 	
        */
-      if (h < details_.intra_space_threshold_ * 0.5 * details_.staff_space_)
+      if (head_positions_slice (columns[LEFT]).contains (pos)
+	  || head_positions_slice (columns[RIGHT]).contains (pos)
+	  || abs (pos) < 2 * Staff_symbol_referencer::staff_radius (details_.staff_symbol_referencer_))
 	{
-	  if (!Staff_symbol_referencer::on_line (details_.staff_symbol_referencer_, pos)
-	      && abs (pos) < 2 * Staff_symbol_referencer::staff_radius (details_.staff_symbol_referencer_))
-	    {
-	      conf->center_tie_vertically (details_);
-	    }
-	  else if (Staff_symbol_referencer::on_line (details_.staff_symbol_referencer_, pos))
+	  if (h < details_.intra_space_threshold_ * 0.5 * details_.staff_space_)
 	    {
-	      conf->delta_y_ += dir *
-		details_.tip_staff_line_clearance_ * 0.5 *  details_.staff_space_;
+	      if (!Staff_symbol_referencer::on_line (details_.staff_symbol_referencer_, pos)
+		  && abs (pos) < 2 * Staff_symbol_referencer::staff_radius (details_.staff_symbol_referencer_))
+		{
+		  conf->center_tie_vertically (details_);
+		}
+	      else if (Staff_symbol_referencer::on_line (details_.staff_symbol_referencer_, pos))
+		{
+		  conf->delta_y_ += dir *
+		    details_.tip_staff_line_clearance_ * 0.5 *  details_.staff_space_;
+		}
 	    }
-	}
-      else 
-	{
-	  Real top_y = y + conf->delta_y_ + conf->dir_ * h;
-	  Real top_pos = top_y / (0.5*details_.staff_space_);
-	  int round_pos = int (my_round (top_pos));
-
-	  /* TODO: should use other variable? */
-	  Real clearance = details_.center_staff_line_clearance_;
-	  if (fabs (top_pos - round_pos) < clearance
-	      && Staff_symbol_referencer::on_staff_line (details_.staff_symbol_referencer_,
-							 round_pos))
+	  else 
 	    {
-	      Real new_y = (round_pos + clearance * conf->dir_) * 0.5 * details_.staff_space_;
-	      conf->delta_y_ = (new_y - top_y);
+	      Real top_y = y + conf->delta_y_ + conf->dir_ * h;
+	      Real top_pos = top_y / (0.5*details_.staff_space_);
+	      int round_pos = int (my_round (top_pos));
+
+	      /* TODO: should use other variable? */
+	      Real clearance = details_.center_staff_line_clearance_;
+	      if (fabs (top_pos - round_pos) < clearance
+		  && Staff_symbol_referencer::on_staff_line (details_.staff_symbol_referencer_,
+							     round_pos))
+		{
+		  Real new_y = (round_pos + clearance * conf->dir_) * 0.5 * details_.staff_space_;
+		  conf->delta_y_ = (new_y - top_y);
+		}
 	    }
 	}
-    }
-  
+    }  
   conf->attachment_x_ = get_attachment (y + conf->delta_y_, conf->column_ranks_);
   if (conf->height (details_) < details_.intra_space_threshold_ * 0.5 * details_.staff_space_)
     {
@@ -552,7 +584,8 @@ Tie_formatting_problem::score_aptitude (Tie_configuration *conf,
     }
 
   {
-    Real p = details_.vertical_distance_penalty_factor_ * fabs (curve_y - tie_y);
+    Real relevant_dist = max (fabs (curve_y - tie_y) - 0.5, 0.0);
+    Real p = details_.vertical_distance_penalty_factor_ * convex_amplifier (1.0, 0.9, relevant_dist);
     if (ties_conf)
       ties_conf->add_tie_score (p, tie_idx, "vdist");
     else
@@ -567,22 +600,79 @@ Tie_formatting_problem::score_aptitude (Tie_configuration *conf,
       
       Interval head_x = spec.note_head_drul_[d]->extent (x_refpoint_, X_AXIS);
       Real dist = head_x.distance (conf->attachment_x_[d]);
+      
 
       /*
 	TODO: flatten with log or sqrt.
        */
-      Real p = details_.horizontal_distance_penalty_factor_ * dist;
+      Real p = details_.horizontal_distance_penalty_factor_
+	* convex_amplifier (1.25, 1.0, dist);
       if (ties_conf)
 	ties_conf->add_tie_score (p, tie_idx,
 				  (d == LEFT) ? "lhdist" : "rhdist");
       else
 	penalty += p;
+
+    }
+  while (flip (&d) != LEFT);
+
+  if (ties_conf
+      && ties_conf->size () == 1)
+    {
+      Direction d = LEFT;
+      Drul_array<Grob*> stems (0, 0);
+      do
+	{
+	  if (!spec.note_head_drul_[d])
+	    continue;
+
+	  Grob *stem = unsmob_grob (spec.note_head_drul_[d]->get_object ("stem"));
+	  if (stem
+	      && Stem::is_normal_stem (stem))
+	    stems[d] = stem;
+	}
+      while (flip (&d) != LEFT);
+
+      bool tie_stem_dir_ok = true;
+      bool tie_position_dir_ok = true;
+      if (stems[LEFT] && !stems[RIGHT])
+	tie_stem_dir_ok = conf->dir_ != get_grob_direction (stems[LEFT]);
+      else if (!stems[LEFT] && stems[RIGHT])
+	tie_stem_dir_ok = conf->dir_ != get_grob_direction (stems[RIGHT]);
+      else if (stems[LEFT] && stems[RIGHT]
+	  && get_grob_direction (stems[LEFT]) == get_grob_direction (stems[RIGHT]))
+	tie_stem_dir_ok = conf->dir_ != get_grob_direction (stems[LEFT]);
+      else if (spec.position_)
+	tie_position_dir_ok = conf->dir_ == sign (spec.position_);
+
+      if (!tie_stem_dir_ok)
+	ties_conf->add_score (details_.same_dir_as_stem_penalty_, "tie/stem dir");
+      if (!tie_position_dir_ok)
+	ties_conf->add_score (details_.same_dir_as_stem_penalty_, "tie/pos dir");
     }
   while (flip (&d) != LEFT);
 
+	    
   return penalty;
 }
 
+
+Slice
+Tie_formatting_problem::head_positions_slice (int rank) const
+{
+  Position_extent_map::const_iterator i (head_positions_.find (rank));
+  if (i != head_positions_.end ())
+    {
+      return  (*i).second; 
+    }
+  Slice empty;
+  return empty;
+}
+
+/*
+  Score a configuration, ie. how well these ties looks without regard
+  to the note heads that they should connect to.
+ */
 void
 Tie_formatting_problem::score_configuration (Tie_configuration *conf) const
 {
@@ -611,13 +701,17 @@ Tie_formatting_problem::score_configuration (Tie_configuration *conf) const
       conf->add_score (
 	details_.staff_line_collision_penalty_
 	* peak_around (0.1 * details_.center_staff_line_clearance_,
-		     details_.center_staff_line_clearance_,
+		       details_.center_staff_line_clearance_,
 		       fabs (top_pos - round_top_pos)),
 	"line center");
     }
-  
-  if (Staff_symbol_referencer::on_line (details_.staff_symbol_referencer_,
-					int (rint (tip_pos))))
+
+  int rounded_tip_pos = int (rint (tip_pos));
+  if (Staff_symbol_referencer::on_line (details_.staff_symbol_referencer_, rounded_tip_pos)
+      && (head_positions_slice (conf->column_ranks_[LEFT]).contains (rounded_tip_pos)
+	  || head_positions_slice (conf->column_ranks_[RIGHT]).contains (rounded_tip_pos)
+	  || abs (rounded_tip_pos) < 2 * Staff_symbol_referencer::staff_radius (details_.staff_symbol_referencer_))
+	  )
     {
       conf->add_score (details_.staff_line_collision_penalty_
 		       * peak_around (0.1 * details_.tip_staff_line_clearance_,
@@ -652,96 +746,6 @@ Tie_formatting_problem::score_configuration (Tie_configuration *conf) const
   conf->scored_ = true;
 }
 
-Tie_configuration
-Tie_formatting_problem::find_optimal_tie_configuration (Tie_specification const &spec) const
-{
-  vector<Tie_configuration*> confs;
-
-  int pos = spec.position_;
-  Direction dir = spec.manual_dir_;
-
-  for (int i = 0; i < details_.single_tie_region_size_; i ++)
-    {
-      confs.push_back (generate_configuration (pos + i * dir, dir,
-					       spec.column_ranks_));
-      
-      if (spec.has_manual_position_)
-	{
-	  confs.back ()->delta_y_
-	    = (spec.manual_position_ - spec.position_)
-	    * 0.5 * details_.staff_space_;
-
-	  break;
-	}
-    }
-
-  vector<Real> scores;
-
-  int best_idx = -1;
-  Real best_score = 1e6;
-  for (vsize i = 0; i < confs.size (); i ++)
-    {
-      score_configuration (confs[i]);
-      Real score = score_aptitude (confs[i], spec, 0, 0)
-	+ confs[i]->score ();
-
-      if (score < best_score)
-	{
-	  best_score = score;
-	  best_idx = i;
-	}
-    }
-
-  if (best_idx < 0)
-    programming_error ("No best tie configuration found.");
-
-  Tie_configuration best
-    = (best_idx >= 0) ?  *confs[best_idx] : *confs[0];
-  
-  for (vsize i = 0; i < confs.size (); i++)
-    delete confs[i];
-
-  return best;
-}
-
-Tie_specification::Tie_specification ()
-{
-  has_manual_position_ = false;
-  has_manual_dir_ = false;
-  position_ = 0;
-  manual_position_ = 0;
-  manual_dir_ = CENTER;
-  note_head_drul_[LEFT] =
-    note_head_drul_[RIGHT] = 0;
-  column_ranks_[RIGHT] =
-    column_ranks_[LEFT] = 0;
-}
-
-
-void
-Tie_specification::get_tie_manual_settings (Grob *tie)
-{
-  if (scm_is_number (tie->get_property_data ("direction")))
-    {
-      manual_dir_ = to_dir (tie->get_property ("direction"));
-      has_manual_dir_ = true;
-    }
-  
-  position_ = Tie::get_position (tie);
-  if (scm_is_number (tie->get_property ("staff-position")))
-    {
-      manual_position_ = scm_to_double (tie->get_property ("staff-position"));
-      has_manual_position_ = true;
-      position_ = int (my_round (manual_position_));
-    }
-}
-
-int
-Tie_specification::column_span () const
-{
-  return column_ranks_[RIGHT] - column_ranks_[LEFT];
-}
-
 void
 Tie_formatting_problem::score_ties_aptitude (Ties_configuration *ties) const
 {
@@ -807,21 +811,23 @@ Tie_formatting_problem::score_ties_configuration (Ties_configuration *ties) cons
       last_center = center;
     }
 
-  ties->add_score (details_.outer_tie_length_symmetry_penalty_factor_
-		   * fabs (ties->at (0).attachment_x_.length () - ties->back ().attachment_x_.length ()),
-		   "length symm");
+  if (ties->size () > 1)
+    {
+      ties->add_score (details_.outer_tie_length_symmetry_penalty_factor_
+		       * fabs (ties->at (0).attachment_x_.length () - ties->back ().attachment_x_.length ()),
+		       "length symm");
   
-  ties->add_score (details_.outer_tie_vertical_distance_symmetry_penalty_factor_
-		   * fabs (fabs (specifications_[0].position_ * 0.5 * details_.staff_space_
-				 - (ties->at (0).position_ * 0.5 * details_.staff_space_
-				    + ties->at (0).delta_y_))
-			   -
-			   fabs (specifications_.back ().position_ * 0.5 * details_.staff_space_
-				 - (ties->back ().position_ * 0.5 * details_.staff_space_
-				    + ties->back ().delta_y_))),
-		   "pos symmetry");
+      ties->add_score (details_.outer_tie_vertical_distance_symmetry_penalty_factor_
+		       * fabs (fabs (specifications_[0].position_ * 0.5 * details_.staff_space_
+				     - (ties->at (0).position_ * 0.5 * details_.staff_space_
+					+ ties->at (0).delta_y_))
+			       -
+			       fabs (specifications_.back ().position_ * 0.5 * details_.staff_space_
+				     - (ties->back ().position_ * 0.5 * details_.staff_space_
+					+ ties->back ().delta_y_))),
+		       "pos symmetry");
+    }
 }
-
 /*
   Generate with correct X-attachments and beziers, copying delta_y_
   from TIES_CONFIG if necessary.
@@ -833,8 +839,9 @@ Tie_formatting_problem::generate_ties_configuration (Ties_configuration const &t
   for (vsize i = 0; i < ties_config.size (); i++)
     {
       Tie_configuration * ptr = get_configuration (ties_config[i].position_, ties_config[i].dir_,
-						   ties_config[i].column_ranks_);
-      if (specifications_[i].has_manual_position_)
+						   ties_config[i].column_ranks_,
+						   !specifications_[i].has_manual_delta_y_);
+      if (specifications_[i].has_manual_delta_y_)
 	{
 	  ptr->delta_y_
 	    = (specifications_[i].manual_position_ - ties_config[i].position_)
@@ -858,8 +865,9 @@ Tie_formatting_problem::generate_base_chord_configuration ()
       if (specifications_[i].has_manual_position_)
 	{
 	  conf.position_ = (int) my_round (specifications_[i].manual_position_);
-	  conf.delta_y_ = (specifications_[i].manual_position_ - conf.position_)
-	    * 0.5 * details_.staff_space_;
+	  if (specifications_[i].has_manual_delta_y_)
+	    conf.delta_y_ = (specifications_[i].manual_position_ - conf.position_)
+	      * 0.5 * details_.staff_space_;
 	}
       else
 	{
@@ -882,7 +890,7 @@ Tie_formatting_problem::generate_base_chord_configuration ()
 
 Ties_configuration
 Tie_formatting_problem::find_best_variation (Ties_configuration const &base,
-					     vector<Tie_configuration_variation> vars)
+					     vector<Tie_configuration_variation> const &vars)
 {
   Ties_configuration best = base;
   
@@ -910,16 +918,24 @@ Tie_formatting_problem::find_best_variation (Ties_configuration const &base,
 				       
 
 Ties_configuration
-Tie_formatting_problem::generate_optimal_chord_configuration ()
+Tie_formatting_problem::generate_optimal_configuration ()
 {
   Ties_configuration base = generate_base_chord_configuration ();
-  vector<Tie_configuration_variation> vars = generate_collision_variations (base);
-  
   score_ties (&base);
+
+  vector<Tie_configuration_variation> vars;  
+  if (specifications_.size () > 1)
+    vars = generate_collision_variations (base);
+  else
+    vars = generate_single_tie_variations (base);
+
   Ties_configuration best = find_best_variation (base, vars);
-  vars = generate_extremal_tie_variations (best);
-  best = find_best_variation (best, vars);
 
+  if (specifications_.size () > 1)
+    {
+      vars = generate_extremal_tie_variations (best);
+      best = find_best_variation (best, vars);
+    }
   return best;
 }
 
@@ -967,7 +983,7 @@ Tie_formatting_problem::set_ties_config_standard_directions (Ties_configuration
 	}
     }
 
-  for (vsize i = 1; i < tie_configs->size() - 1; i++)
+  for (vsize i = 1; i + 1 < tie_configs->size (); i++)
     {
       Tie_configuration &conf = tie_configs->at (i);
       if (conf.dir_)
@@ -1003,7 +1019,8 @@ Tie_formatting_problem::generate_extremal_tie_variations (Ties_configuration con
 	    var.index_ = (d == DOWN) ? 0 : ties.size () - 1;
 	    var.suggestion_ = get_configuration (boundary (ties, d, 0).position_
 						 + d * i, d,
-						 boundary (ties, d, 0).column_ranks_);
+						 boundary (ties, d, 0).column_ranks_,
+						 true);
 	    vars.push_back (var);
 	  }
     }
@@ -1012,6 +1029,41 @@ Tie_formatting_problem::generate_extremal_tie_variations (Ties_configuration con
   return vars;
 }
 
+vector<Tie_configuration_variation>
+Tie_formatting_problem::generate_single_tie_variations (Ties_configuration const &ties) const
+{
+  vector<Tie_configuration_variation> vars;
+
+  int sz = details_.single_tie_region_size_;
+  if (specifications_[0].has_manual_position_)
+    sz = 1;
+  for (int i = 0; i < sz; i ++)
+    {
+      Direction d = LEFT;
+      do
+	{
+	  if (i == 0
+	      && ties[0].dir_ == d)
+	    continue;
+	  
+	  int p = ties[0].position_ + i * d;
+	  
+	  if (!specifications_[0].has_manual_dir_
+	      || d == specifications_[0].manual_dir_)
+	    {
+	      Tie_configuration_variation var;
+	      var.index_ = 0;
+	      var.suggestion_ = get_configuration (p,
+						   d, specifications_[0].column_ranks_,
+						   !specifications_[0].has_manual_delta_y_);
+	      vars.push_back (var);
+	    }
+	}
+      while (flip (&d) != LEFT);
+    }
+  return vars;
+}
+
 
 vector<Tie_configuration_variation>
 Tie_formatting_problem::generate_collision_variations (Ties_configuration const &ties) const
@@ -1038,7 +1090,8 @@ Tie_formatting_problem::generate_collision_variations (Ties_configuration const
 						       - ties[i].dir_,
 						       - ties[i].dir_,
 
-						       ties[i].column_ranks_
+						       ties[i].column_ranks_,
+						       !specifications_[i].has_manual_delta_y_
 						       );
 
 		  vars.push_back (var);
@@ -1051,7 +1104,9 @@ Tie_formatting_problem::generate_collision_variations (Ties_configuration const
 		  var.suggestion_ = get_configuration (specifications_[i-1].position_
 						       - ties[i-1].dir_,
 						       - ties[i-1].dir_,
-						       specifications_[i-1].column_ranks_);
+						       specifications_[i-1].column_ranks_,
+						       !specifications_[i-1].has_manual_delta_y_
+						       );
 
 		  vars.push_back (var);
 		}
@@ -1062,17 +1117,22 @@ Tie_formatting_problem::generate_collision_variations (Ties_configuration const
 		  Tie_configuration_variation var;
 		  var.index_ = i-1;
 		  var.suggestion_ = get_configuration (specifications_[i-1].position_ - 1, DOWN,
-						       specifications_[i-1].column_ranks_);
+						       specifications_[i-1].column_ranks_,
+						       !specifications_[i-1].has_manual_delta_y_
+
+						       );
 		  vars.push_back (var);
 		}
-	      if (i == ties.size() && !specifications_[i].has_manual_position_
+	      if (i == ties.size () && !specifications_[i].has_manual_position_
 		  && ties[i].dir_ == UP)
 		{
 		  Tie_configuration_variation var;
 		  var.index_ = i;
 		  var.suggestion_ = get_configuration (specifications_[i].position_
 						       + 1, UP,
-						       specifications_[i].column_ranks_);
+						       specifications_[i].column_ranks_,
+						       !specifications_[i].has_manual_delta_y_
+						       );
 		  vars.push_back (var);
 		}
 	    }
@@ -1083,7 +1143,9 @@ Tie_formatting_problem::generate_collision_variations (Ties_configuration const
 	      var.index_ = i;
 	      var.suggestion_ = get_configuration (ties[i].position_  + ties[i].dir_,
 						   ties[i].dir_,
-						   ties[i].column_ranks_);
+						   ties[i].column_ranks_,
+						   !specifications_[i].has_manual_delta_y_
+						   );
 	      vars.push_back (var);
 	    }
 	  
@@ -1112,7 +1174,9 @@ Tie_formatting_problem::set_manual_tie_configuration (SCM manual_configs)
 	    {
 	      spec.has_manual_position_ = true;
 	      spec.manual_position_ = scm_to_double (scm_car (entry));
+	      spec.has_manual_delta_y_ = (scm_inexact_p (scm_car (entry)) == SCM_BOOL_T);
 	    }
+	  
 	  if (scm_is_number (scm_cdr (entry)))
 	    {
 	      spec.has_manual_dir_ = true;
@@ -1123,3 +1187,20 @@ Tie_formatting_problem::set_manual_tie_configuration (SCM manual_configs)
     }
 }
 
+
+void
+Tie_formatting_problem::set_debug_scoring (Ties_configuration const &base)
+{
+#if DEBUG_TIE_SCORING
+  if (to_boolean (x_refpoint_->layout ()
+		  ->lookup_variable (ly_symbol2scm ("debug-tie-scoring"))))
+    {
+      for (vsize i = 0; i < base.size (); i++)
+	{
+	  string card = base.complete_tie_card (i);
+	  specifications_[i].tie_grob_->set_property ("quant-score",
+						      ly_string2scm (card));
+	}
+    }
+#endif
+}