source file of the GNU LilyPond music typesetter
- (c) 2006--2007 Joe Neeman <joeneeman@gmail.com>
+ (c) 2006--2009 Joe Neeman <joeneeman@gmail.com>
*/
#include "page-breaking.hh"
compressed.extent_[UP] = old.extent_[UP] + orig[i].extent_.length () + old.padding_;
compressed.space_ += old.space_;
compressed.inverse_hooke_ += old.inverse_hooke_;
- compressed.title_ = old.title_;
- /* we don't need the force_ field for the vertical spacing,
- so we use force_ = n to signal that the line was compressed,
- reducing the number of lines by n (and force_ = 0 otherwise).
- This makes uncompression much easier. */
- compressed.force_ = old.force_ + 1;
+ compressed.compressed_lines_count_ = old.compressed_lines_count_ + 1;
+ compressed.compressed_nontitle_lines_count_ =
+ old.compressed_nontitle_lines_count_ + (compressed.title_ ? 0 : 1);
+
+ compressed.title_ = compressed.title_ && old.title_;
ret.back () = compressed;
}
else
{
int compressed_count = 0;
for (vsize j = start_sys; j < start_sys + systems_per_page[i]; j++)
- compressed_count += (int)compressed[j].force_;
+ compressed_count += compressed[j].compressed_lines_count_ - 1;
ret.push_back (systems_per_page[i] + compressed_count);
start_sys += systems_per_page[i];
ragged_ = to_boolean (pb->paper_->c_variable ("ragged-bottom"));
ragged_last_ = to_boolean (pb->paper_->c_variable ("ragged-last-bottom"));
page_top_space_ = robust_scm2double (pb->paper_->c_variable ("page-top-space"), 0);
+ systems_per_page_ = robust_scm2int (pb->paper_->c_variable ("systems-per-page"), 0);
+ max_systems_per_page_ = robust_scm2int (pb->paper_->c_variable ("max-systems-per-page"), 0);
+ min_systems_per_page_ = robust_scm2int (pb->paper_->c_variable ("min-systems-per-page"), 0);
+
create_system_list ();
find_chunks_and_breaks (is_break);
}
return ragged_last_;
}
+int
+Page_breaking::systems_per_page () const
+{
+ return systems_per_page_;
+}
+
+int
+Page_breaking::max_systems_per_page () const
+{
+ return max_systems_per_page_;
+}
+
+int
+Page_breaking::min_systems_per_page () const
+{
+ return min_systems_per_page_;
+}
+
Real
Page_breaking::page_top_space () const
{
return system_count_;
}
+bool
+Page_breaking::too_many_lines (int line_count) const
+{
+ return max_systems_per_page () > 0 && line_count > max_systems_per_page ();
+}
+
+bool
+Page_breaking::too_few_lines (int line_count) const
+{
+ return line_count < min_systems_per_page ();
+}
+
+Real
+Page_breaking::line_count_penalty (int line_count) const
+{
+ if (too_many_lines (line_count))
+ return (line_count - max_systems_per_page ()) * TERRIBLE_SPACING_PENALTY;
+ if (too_few_lines (line_count))
+ return (min_systems_per_page () - line_count) * TERRIBLE_SPACING_PENALTY;
+
+ return 0;
+}
+
/* translate indices into breaks_ into start-end parameters for the line breaker */
void
Page_breaking::line_breaker_args (vsize sys,
Real
Page_breaking::page_height (int page_num, bool last) const
{
+ bool last_part = ly_scm2bool (book_->paper_->c_variable ("is-last-bookpart"));
SCM mod = scm_c_resolve_module ("scm page");
SCM calc_height = scm_c_module_lookup (mod, "calc-printable-height");
SCM make_page = scm_c_module_lookup (mod, "make-page");
SCM page = scm_apply_0 (make_page, scm_list_n (
book_->self_scm (),
ly_symbol2scm ("page-number"), scm_from_int (page_num),
- ly_symbol2scm ("is-last"), scm_from_bool (last),
+ ly_symbol2scm ("is-last-bookpart"), scm_from_bool (last_part),
+ ly_symbol2scm ("is-bookpart-last-page"), scm_from_bool (last),
SCM_UNDEFINED));
SCM height = scm_apply_1 (calc_height, page, SCM_EOL);
return scm_to_double (height) - page_top_space_;
SCM book = book_->self_scm ();
int first_page_number
= robust_scm2int (book_->paper_->c_variable ("first-page-number"), 1);
- bool last_part = ly_scm2bool (book_->paper_->c_variable ("part-is-last"));
+ bool last_bookpart = ly_scm2bool (book_->paper_->c_variable ("is-last-bookpart"));
SCM ret = SCM_EOL;
SCM label_page_table = book_->top_paper ()->c_variable ("label-page-table");
if (label_page_table == SCM_UNDEFINED)
for (vsize i = 0; i < lines_per_page.size (); i++)
{
SCM page_num = scm_from_int (i + first_page_number);
- bool last_from_part = (i == lines_per_page.size () - 1);
- SCM last_from_book = scm_from_bool (last_part && last_from_part);
- SCM rag = scm_from_bool (ragged () || (last_from_part && ragged_last ()));
+ bool partbook_last_page = (i == lines_per_page.size () - 1);
+ SCM rag = scm_from_bool (ragged () || ( partbook_last_page && ragged_last ()));
SCM line_count = scm_from_int (lines_per_page[i]);
SCM lines = scm_list_head (systems, line_count);
SCM page = scm_apply_0 (make_page,
- scm_list_n (book, lines, page_num,
- rag, last_from_book, SCM_UNDEFINED));
-
+ scm_list_n (book, lines, page_num, rag,
+ scm_from_bool (last_bookpart),
+ scm_from_bool (partbook_last_page),
+ SCM_UNDEFINED));
/* collect labels */
for (SCM l = lines ; scm_is_pair (l) ; l = scm_cdr (l))
{
Real cur_rod_height = 0;
Real cur_spring_height = 0;
Real cur_page_height = page_height (first_page_num, false);
+ int line_count = 0;
cache_line_details (configuration);
for (vsize i = 0; i < cached_line_details_.size (); i++)
Real next_spring_height = cur_spring_height + cached_line_details_[i].space_;
Real next_height = next_rod_height + (ragged () ? next_spring_height : 0);
+ line_count += cached_line_details_[i].compressed_nontitle_lines_count_;
if ((next_height > cur_page_height && cur_rod_height > 0)
+ || too_many_lines (line_count)
|| (i > 0
&& cached_line_details_[i-1].page_permission_ == ly_symbol2scm ("force")))
{
+ line_count = cached_line_details_[i].compressed_nontitle_lines_count_;
cur_rod_height = ext_len;
cur_spring_height = cached_line_details_[i].space_;
cur_page_height = page_height (first_page_num + ret, false);
return ret;
}
+// If systems_per_page_ is positive, we don't really try to space on N pages;
+// we just put the requested number of systems on each page and penalize
+// if the result doesn't have N pages.
Page_spacing_result
Page_breaking::space_systems_on_n_pages (vsize configuration, vsize n, vsize first_page_num)
{
Page_spacing_result ret;
+ if (systems_per_page_ > 0)
+ {
+ Page_spacing_result ret = space_systems_with_fixed_number_per_page (configuration, first_page_num);
+ ret.demerits_ += (ret.force_.size () == n) ? 0 : BAD_SPACING_PENALTY;
+ return ret;
+ }
+
cache_line_details (configuration);
bool valid_n = (n >= min_page_count (configuration, first_page_num)
&& n <= cached_line_details_.size ());
return robust_scm2double (book_->paper_->lookup_variable (penalty_sym), 0.0);
}
+// If systems_per_page_ is positive, we don't really try to space on N
+// or N+1 pages; see the comment to space_systems_on_n_pages.
Page_spacing_result
Page_breaking::space_systems_on_n_or_one_more_pages (vsize configuration, vsize n, vsize first_page_num)
{
Page_spacing_result n_res;
Page_spacing_result m_res;
+ if (systems_per_page_ > 0)
+ {
+ Page_spacing_result ret = space_systems_with_fixed_number_per_page (configuration, first_page_num);
+ ret.demerits_ += (ret.force_.size () == n || ret.force_.size () == (n-1)) ? 0 : BAD_SPACING_PENALTY;
+ return ret;
+ }
+
cache_line_details (configuration);
vsize min_p_count = min_page_count (configuration, first_page_num);
bool valid_n = n >= min_p_count || n <= cached_line_details_.size ();
return finalize_spacing_result (configuration, best);
}
+Page_spacing_result
+Page_breaking::space_systems_with_fixed_number_per_page (vsize configuration,
+ vsize first_page_num)
+{
+ Page_spacing_result res;
+ Page_spacing space (page_height (first_page_num, false), page_top_space_);
+ vsize line = 0;
+ vsize page = 0;
+ vsize page_first_line = 0;
+
+ cache_line_details (configuration);
+ while (line < cached_line_details_.size ())
+ {
+ page++;
+ space.clear ();
+ space.resize (page_height (first_page_num + page, false));
+
+ int system_count_on_this_page = 0;
+ while (system_count_on_this_page < systems_per_page_
+ && line < cached_line_details_.size ())
+ {
+ Line_details const &cur_line = cached_line_details_[line];
+ space.append_system (cur_line);
+ system_count_on_this_page += cur_line.compressed_nontitle_lines_count_;
+ line++;
+
+ if (cur_line.page_permission_ == ly_symbol2scm ("force"))
+ break;
+ }
+
+ res.systems_per_page_.push_back (line - page_first_line);
+
+ // Don't say that the force is infinite even if it is: if we were told to
+ // put a certain number of systems on a page then we will, even if it's bad.
+ res.force_.push_back (min (space.force_, BAD_SPACING_PENALTY));
+ res.penalty_ += cached_line_details_[line-1].page_penalty_;
+ page_first_line = line;
+ }
+
+ /* Recalculate forces for the last page because we know now that is
+ really the last page. */
+ space.resize (page_height (first_page_num + page, true));
+ res.force_.back () = min(space.force_, BAD_SPACING_PENALTY);
+ return finalize_spacing_result (configuration, res);
+}
+
Page_spacing_result
Page_breaking::pack_systems_on_least_pages (vsize configuration, vsize first_page_num)
{
{
Real f = res.force_[i];
if (isinf (f) && res.systems_per_page_[i] == 1)
- f = 20000;
-
- page_force += f * f;
+ page_force += BAD_SPACING_PENALTY;
+ else
+ page_force += f * f;
}
/* for a while we tried averaging page and line forces across pages instead
{
Page_spacing space (page_height, page_top_space_);
Page_spacing_result ret;
+ int line_count = 0;
for (vsize i = 0; i < lines.size (); i++)
- space.append_system (lines[i]);
+ {
+ space.append_system (lines[i]);
+ line_count += lines[i].compressed_nontitle_lines_count_;
+ }
ret.systems_per_page_.push_back (lines.size ());
ret.force_.push_back (ragged ? min (space.force_, 0.0) : space.force_);
- ret.penalty_ = lines.back ().page_penalty_ + lines.back ().turn_penalty_;
+ ret.penalty_ = line_count_penalty (line_count) + lines.back ().page_penalty_ + lines.back ().turn_penalty_;
/* don't do finalize_spacing_result () because we are only an internal function */
return ret;
vector<Real> page1_force;
vector<Real> page2_force;
+
+ // page1_penalty and page2_penalty store the penalties based
+ // on min-systems-per-page and max-systems-per-page.
+ vector<Real> page1_penalty;
+ vector<Real> page2_penalty;
Page_spacing page1 (page1_height, page_top_space_);
Page_spacing page2 (page2_height, page_top_space_);
+ int page1_line_count = 0;
+ int page2_line_count = 0;
page1_force.resize (cached_line_details_.size () - 1, infinity_f);
page2_force.resize (cached_line_details_.size () - 1, infinity_f);
+ page1_penalty.resize (cached_line_details_.size () - 1, infinity_f);
+ page2_penalty.resize (cached_line_details_.size () - 1, infinity_f);
/* find the page 1 and page 2 forces for each page-breaking position */
for (vsize i = 0; i < page1_force.size (); i++)
{
page1.append_system (cached_line_details_[i]);
page2.prepend_system (cached_line_details_[cached_line_details_.size () - 1 - i]);
+ page1_line_count += cached_line_details_[i].compressed_nontitle_lines_count_;
+ page2_line_count += cached_line_details_[cached_line_details_.size () - 1 - i].compressed_nontitle_lines_count_;
+
page1_force[i] = (ragged1 && page1.force_ < 0 && i > 0) ? infinity_f : page1.force_;
+ page1_penalty[i] = line_count_penalty (page1_line_count);
if (ragged2)
page2_force[page2_force.size () - 1 - i] =
(page2.force_ < 0 && i + 1 < page1_force.size ()) ? infinity_f : 0;
else
page2_force[page2_force.size () - 1 - i] = page2.force_;
+ page2_penalty[page2_penalty.size () - 1 - i] = line_count_penalty (page2_line_count);
}
/* find the position that minimises the sum of the page forces */
for (vsize i = 0; i < page1_force.size (); i++)
{
Real f = page1_force[i] * page1_force[i] + page2_force[i] * page2_force[i];
+ // FIXME: Why do we look at unevenness here? We don't use it in
+ // finalize_spacing_result, so this gives us a different measure of demerits.
Real uneven = 2 * (page1_force[i] - page2_force[i]);
+
+ // NOTE: we treat max-systems-per-page and min-systems-per-page as soft
+ // constraints. That is, we penalize harshly when they don't happen
+ // but we don't completely reject.
Real dem = uneven * uneven + f
+ + page1_penalty[i] + page2_penalty[i]
+ cached_line_details_[i+1].page_penalty_
+ cached_line_details_.back ().page_penalty_ + cached_line_details_.back ().turn_penalty_;
if (dem < best_demerits)
ret.force_.push_back (page2_force[best_sys_count-1]);
ret.penalty_ = cached_line_details_[best_sys_count-1].page_penalty_
+ cached_line_details_.back ().page_penalty_
- + cached_line_details_.back ().turn_penalty_;
+ + cached_line_details_.back ().turn_penalty_
+ + page1_penalty[best_sys_count-1] + page2_penalty[best_sys_count-1];
/* don't do finalize_spacing_result () because we are only an internal function */
return ret;