#include "tie-formatting-problem.hh"
+#include "paper-column.hh"
#include "bezier.hh"
#include "directional-element-interface.hh"
#include "item.hh"
}
Interval
-Tie_formatting_problem::get_attachment (Real y) const
+Tie_formatting_problem::get_attachment (Real y, Drul_array<int> columns) const
{
Interval attachments;
Direction d = LEFT;
do
{
- attachments[d] = skyline_height (chord_outlines_[d], y, -d);
+ Chord_outline_map::const_iterator i (chord_outlines_.find (columns[d]));
+ 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"));
boxes.push_back (Box (x, y));
}
}
-
- chord_outlines_[dir] = empty_skyline (-dir);
+
+ chord_outlines_[column_rank] = 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_[column_rank].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_[column_rank].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_[column_rank] ,
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_[column_rank], Box (x,y), Y_AXIS, -dir);
stem_extents_[dir].unite (Box (x,y));
{
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_[column_rank], flag_box,
Y_AXIS, -dir);
}
}
}
if (!x.is_empty ())
- insert_extent_into_skyline (&chord_outlines_[dir],
+ insert_extent_into_skyline (&chord_outlines_[column_rank],
Box (x,y),
Y_AXIS, -dir);
}
}
}
+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
Tie_formatting_problem::from_tie (Grob *tie)
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 ();
}
while (flip (&d) != LEFT);
-
specifications_.push_back (spec);
}
}
}
+/*
+ Return configuration, create it if necessary.
+*/
Tie_configuration*
-Tie_formatting_problem::get_configuration (int pos, Direction dir) const
+Tie_formatting_problem::get_configuration (int pos, Direction dir, Drul_array<int> columns) const
{
- pair<int,int> key (pos, dir);
+ int key_components[] = {
+ pos, dir, columns[LEFT], columns[RIGHT]
+ };
+ Tuple<int,4> key (key_components);
+
Tie_configuration_map::const_iterator f = possibilities_.find (key);
-
if (f != possibilities_.end ())
{
return (*f).second;
}
- Tie_configuration *conf = generate_configuration (pos, dir);
+ Tie_configuration *conf = generate_configuration (pos, dir, columns);
((Tie_formatting_problem*) this)->possibilities_[key] = conf;
return conf;
}
Tie_configuration*
-Tie_formatting_problem::generate_configuration (int pos, Direction dir) const
+Tie_formatting_problem::generate_configuration (int pos, Direction dir,
+ Drul_array<int> columns) const
{
Tie_configuration *conf = new Tie_configuration;
conf->position_ = pos;
conf->dir_ = dir;
+
+ conf->column_ranks_ = columns;
+
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_;
y_tune = false;
}
-
-
if (y_tune
&& max (fabs (head_extents_[LEFT][Y_AXIS][dir] - y),
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);
}
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 * (stem_extents_[d][X_AXIS][-d] - d * details_.stem_gap_));
}
while (flip (&d) != LEFT);
+
return conf;
}
for (int i = 0; i < details_.single_tie_region_size_; i ++)
{
- confs.push_back (generate_configuration (pos + i * dir, dir));
+ confs.push_back (generate_configuration (pos + i * dir, dir,
+ spec.column_ranks_));
if (spec.has_manual_position_)
{
}
}
- 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];
manual_dir_ = CENTER;
note_head_drul_[LEFT] =
note_head_drul_[RIGHT] = 0;
+ column_ranks_[RIGHT] =
+ column_ranks_[LEFT] = 0;
}
+int
+Tie_specification::column_span () const
+{
+ return column_ranks_[RIGHT] - column_ranks_[LEFT];
+}
void
Tie_formatting_problem::score_ties_aptitude (Ties_configuration *ties) const
Ties_configuration copy;
for (vsize i = 0; i < ties_config.size (); i++)
{
- Tie_configuration * ptr = get_configuration (ties_config[i].position_, ties_config[i].dir_);
+ Tie_configuration * ptr = get_configuration (ties_config[i].position_, ties_config[i].dir_,
+ ties_config[i].column_ranks_);
if (specifications_[i].has_manual_position_)
{
ptr->delta_y_
{
conf.position_ = specifications_[i].position_;
}
+
+ conf.column_ranks_ = specifications_[i].column_ranks_;
ties_config.push_back (conf);
}
*/
for (vsize i = 1; i < tie_configs->size (); i++)
{
- Real diff = (tie_configs->at (i-1).position_
- - tie_configs->at (i).position_);
-
- if (fabs (diff) <= 1)
+ Real diff = (tie_configs->at (i).position_
+ -tie_configs->at (i-1).position_);
+
+ Real span_diff
+ = specifications_[i].column_span () - specifications_[i-1].column_span ();
+ if (span_diff && fabs (diff) <= 2)
+ {
+ if (span_diff > 0)
+ tie_configs->at (i).dir_ = UP;
+ else if (span_diff < 0)
+ tie_configs->at (i-1).dir_ = DOWN;
+ }
+ else if (fabs (diff) <= 1)
{
if (!tie_configs->at (i-1).dir_)
tie_configs->at (i-1).dir_ = DOWN;
Tie_configuration_variation var;
var.index_ = (d == DOWN) ? 0 : ties.size () - 1;
var.suggestion_ = get_configuration (boundary (ties, d, 0).position_
- + d * i, d);
+ + d * i, d,
+ boundary (ties, d, 0).column_ranks_);
vars.push_back (var);
}
}
var.index_ = i;
var.suggestion_ = get_configuration (specifications_[i].position_
- ties[i].dir_,
- -ties[i].dir_);
+ - ties[i].dir_,
+
+ ties[i].column_ranks_
+ );
vars.push_back (var);
}
var.index_ = i-1;
var.suggestion_ = get_configuration (specifications_[i-1].position_
- ties[i-1].dir_,
- - ties[i-1].dir_);
+ - ties[i-1].dir_,
+ specifications_[i-1].column_ranks_);
vars.push_back (var);
}
{
Tie_configuration_variation var;
var.index_ = i-1;
- var.suggestion_ = get_configuration (specifications_[i-1].position_
- - 1, DOWN);
+ var.suggestion_ = get_configuration (specifications_[i-1].position_ - 1, DOWN,
+ specifications_[i-1].column_ranks_);
vars.push_back (var);
}
if (i == ties.size() && !specifications_[i].has_manual_position_
Tie_configuration_variation var;
var.index_ = i;
var.suggestion_ = get_configuration (specifications_[i].position_
- + 1, UP);
+ + 1, UP,
+ specifications_[i].column_ranks_);
vars.push_back (var);
}
}
Tie_configuration_variation var;
var.index_ = i;
var.suggestion_ = get_configuration (ties[i].position_ + ties[i].dir_,
- ties[i].dir_);
+ ties[i].dir_,
+ ties[i].column_ranks_);
vars.push_back (var);
}
projects / lilypond.git / blobdiff