}
Interval
-Tie_formatting_problem::get_attachment (Real y) const
+Tie_formatting_problem::get_attachment (Real y, Drul_array<int> columns) const
{
- Interval attachments;
+ Interval attachments (0,0);
Direction d = LEFT;
do
{
- attachments[d] = skyline_height (chord_outlines_[d], y, -d);
+ 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");
+ else
+ attachments[d] = skyline_height ((*i).second, y, -d);
}
while (flip (&d) != LEFT);
}
void
-Tie_formatting_problem::set_chord_outline (vector<Item*> bounds,
- Direction dir)
+Tie_formatting_problem::set_column_chord_outline (vector<Item*> bounds,
+ Direction dir,
+ int column_rank)
{
Real staff_space = Staff_symbol_referencer::staff_space (bounds[0]);
Grob *head = bounds[i];
if (!Note_head::has_interface (head))
continue;
-
+
if (!stem)
stem = unsmob_grob (head->get_object ("stem"));
}
}
- chord_outlines_[dir] = empty_skyline (-dir);
+ 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_[dir].at (0).height_ = x;
+ chord_outlines_[key].at (0).height_ = x;
}
else
{
- Interval x;
- for (vsize i = 0; i < head_boxes.size (); i++)
+ Interval x;
+ for (vsize j = 0; j < head_boxes.size (); j++)
{
- x.unite (head_boxes[i][X_AXIS]);
+ x.unite (head_boxes[j][X_AXIS]);
}
-
- chord_outlines_[dir].at (0).height_ = x[dir];
+
+ chord_outlines_[key].at (0).height_ = x[dir];
}
-
+
for (vsize i = 0; i < boxes.size (); i++)
- insert_extent_into_skyline (&chord_outlines_[dir] ,
+ insert_extent_into_skyline (&chord_outlines_[key] ,
boxes[i], Y_AXIS, -dir);
if (stem
y.add_point (Stem::head_positions (stem)[-stemdir]
* staff_space * .5);
- insert_extent_into_skyline (&chord_outlines_[dir], Box (x,y), Y_AXIS, -dir);
+ insert_extent_into_skyline (&chord_outlines_[key], Box (x,y), Y_AXIS, -dir);
- stem_extents_[dir].unite (Box (x,y));
+ stem_extents_[key].unite (Box (x,y));
if (dir == LEFT)
{
Box flag_box = Stem::get_translated_flag (stem).extent_box ();
flag_box.translate( Offset (x[RIGHT], X_AXIS));
- insert_extent_into_skyline (&chord_outlines_[dir], flag_box,
+ insert_extent_into_skyline (&chord_outlines_[key], flag_box,
Y_AXIS, -dir);
}
}
}
if (!x.is_empty ())
- insert_extent_into_skyline (&chord_outlines_[dir],
+ insert_extent_into_skyline (&chord_outlines_[key],
Box (x,y),
Y_AXIS, -dir);
}
while (flip (&updowndir) != DOWN);
- head_extents_[dir].set_empty ();
+ head_extents_[key].set_empty ();
for (vsize i = 0; i < head_boxes.size (); i++)
{
- head_extents_[dir].unite (head_boxes[i]);
+ head_extents_[key].unite (head_boxes[i]);
+ }
+}
+
+void
+Tie_formatting_problem::set_chord_outline (vector<Item*> bounds,
+ Direction dir)
+
+{
+ vector<int> ranks;
+ for (vsize i = 0; i < bounds.size (); i++)
+ ranks.push_back (bounds[i]->get_column ()->get_rank ());
+
+ vector_sort (ranks, default_compare);
+ uniq (ranks);
+
+ for (vsize i = 0; i < ranks.size (); i++)
+ {
+ vector<Item*> col_items;
+ for (vsize j = 0; j < bounds.size (); j ++)
+ {
+ if (bounds[j]->get_column ()->get_rank () == ranks[i])
+ col_items.push_back (bounds[j]);
+ }
+
+ set_column_chord_outline (col_items, dir, ranks[i]);
}
}
+
void
details_.from_grob (lv_ties[0]);
vector<Item*> heads;
-
+
+ int column_rank = -1;
for (vsize i = 0; i < lv_ties.size (); i++)
{
Tie_specification spec;
{
spec.position_ = int (Staff_symbol_referencer::get_position (head));
}
+
spec.note_head_drul_[head_dir] = head;
+ column_rank = dynamic_cast<Item*> (head)->get_column ()->get_rank ();
+ spec.column_ranks_ = Drul_array<int> (column_rank, column_rank);
heads.push_back (head);
specifications_.push_back (spec);
}
Real extremal = head_dir * infinity_f;
- for (vsize i = 0; i < chord_outlines_[head_dir].size (); i++)
+ 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_dir][i].height_);
+ head_dir * chord_outlines_[head_key][i].height_);
}
Skyline_entry right_entry;
right_entry.width_.set_full ();
right_entry.height_ = extremal - head_dir * 1.5;
- chord_outlines_[-head_dir].push_back (right_entry);
+ chord_outlines_[open_key].push_back (right_entry);
}
conf->delta_y_ += dir * 0.25 * details_.staff_space_;
y_tune = false;
}
-
-
if (y_tune
- && max (fabs (head_extents_[LEFT][Y_AXIS][dir] - y),
- fabs (head_extents_[RIGHT][Y_AXIS][dir] - y)) < 0.25
+ && max (fabs (get_head_extent (columns[LEFT], LEFT, Y_AXIS)[dir] - y),
+ fabs (get_head_extent (columns[RIGHT], RIGHT, Y_AXIS)[dir] - y)) < 0.25
&& !Staff_symbol_referencer::on_line (details_.staff_symbol_referencer_, pos))
{
conf->delta_y_ =
- (head_extents_[LEFT][Y_AXIS][dir] - y)
+ (get_head_extent (columns[LEFT], LEFT, Y_AXIS)[dir] - y)
+ dir * details_.outer_tie_vertical_gap_;
}
if (y_tune)
{
- conf->attachment_x_ = get_attachment (y + conf->delta_y_);
+ conf->attachment_x_ = get_attachment (y + conf->delta_y_, conf->column_ranks_);
Real h = conf->height (details_);
/*
}
}
- conf->attachment_x_ = get_attachment (y + conf->delta_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_)
{
/*
Interval close_by = get_attachment (y
+ conf->delta_y_
+ (dir * details_.intra_space_threshold_ * 0.25
- * details_.staff_space_));
+ * details_.staff_space_),
+ conf->column_ranks_);
conf->attachment_x_.intersect (close_by);
}
do
{
Real y = conf->position_ * details_.staff_space_ * 0.5 + conf->delta_y_;
- if (stem_extents_[d][X_AXIS].is_empty ()
- || !stem_extents_[d][Y_AXIS].contains (y))
+ if (get_stem_extent (conf->column_ranks_[d], d, X_AXIS).is_empty ()
+ || !get_stem_extent (conf->column_ranks_[d], d, Y_AXIS).contains (y))
continue;
conf->attachment_x_[d] =
- d* min (d * conf->attachment_x_[d],
- d * (stem_extents_[d][X_AXIS][-d] - d * details_.stem_gap_));
+ d * min (d * conf->attachment_x_[d],
+ d * (get_stem_extent (conf->column_ranks_[d], d, X_AXIS)[-d] - d * details_.stem_gap_));
}
while (flip (&d) != LEFT);
+
return conf;
}
+Interval
+Tie_formatting_problem::get_head_extent (int col, Direction d, Axis a) const
+{
+ return (*head_extents_.find (Tuple2<int> (col, int (d)))).second[a];
+}
+
+Interval
+Tie_formatting_problem::get_stem_extent (int col, Direction d, Axis a) const
+{
+ return (*stem_extents_.find (Tuple2<int> (col, int (d)))).second[a];
+}
+
/**
TIE_IDX and TIES_CONF are optional.
*/
}
}
- Tie_configuration best = *confs[best_idx];
+ 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];
{
conf.position_ = specifications_[i].position_;
}
+
+ conf.column_ranks_ = specifications_[i].column_ranks_;
ties_config.push_back (conf);
}