X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fpage-breaking.cc;h=f19079ce35fa049de26470daf4f4d3c5fac79c6b;hb=38d7d319eabc906e82fb42002678c6d42a23b6f7;hp=12372c1e49874cd66990e98d0d467be5f6dbbab7;hpb=9ae52034113dcfbbc98fd7a0f8075ca3ea2cf3c9;p=lilypond.git diff --git a/lily/page-breaking.cc b/lily/page-breaking.cc index 12372c1e49..f19079ce35 100644 --- a/lily/page-breaking.cc +++ b/lily/page-breaking.cc @@ -4,7 +4,7 @@ source file of the GNU LilyPond music typesetter - (c) 2006--2007 Joe Neeman + (c) 2006--2009 Joe Neeman */ #include "page-breaking.hh" @@ -101,9 +101,20 @@ Page_breaking::Page_breaking (Paper_book *pb, Break_predicate is_break) 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); + systems_per_page_ = max (0, robust_scm2int (pb->paper_->c_variable ("systems-per-page"), 0)); + max_systems_per_page_ = max (0, robust_scm2int (pb->paper_->c_variable ("max-systems-per-page"), 0)); + min_systems_per_page_ = max (0, robust_scm2int (pb->paper_->c_variable ("min-systems-per-page"), 0)); + + if (systems_per_page_ && (max_systems_per_page_ || min_systems_per_page_)) + { + warning (_f ("ignoring min-systems-per-page and max-systems-per-page because systems-per-page was set")); + min_systems_per_page_ = max_systems_per_page_ = 0; + } + if (max_systems_per_page_ && min_systems_per_page_ > max_systems_per_page_) + { + warning (_f ("min-systems-per-page is larger than max-systems-per-page, ignoring both values")); + min_systems_per_page_ = max_systems_per_page_ = 0; + } create_system_list (); find_chunks_and_breaks (is_break); @@ -170,8 +181,23 @@ Page_breaking::too_few_lines (int line_count) const Real Page_breaking::line_count_penalty (int line_count) const { - // TODO: also check min_systems_per_page (once we support it in Page_spacer) - return too_many_lines (line_count) ? BAD_SPACING_PENALTY : 0; + 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; +} + +int +Page_breaking::line_count_status (int line_count) const +{ + if (too_many_lines (line_count)) + return SYSTEM_COUNT_TOO_MANY; + if (too_few_lines (line_count)) + return SYSTEM_COUNT_TOO_FEW; + + return SYSTEM_COUNT_OK; } /* translate indices into breaks_ into start-end parameters for the line breaker */ @@ -252,6 +278,7 @@ Page_breaking::systems () 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"); @@ -262,7 +289,8 @@ Page_breaking::page_height (int page_num, bool last) const 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_; @@ -294,21 +322,24 @@ Page_breaking::make_pages (vector lines_per_page, SCM systems) SCM book = book_->self_scm (); int first_page_number = robust_scm2int (book_->paper_->c_variable ("first-page-number"), 1); + bool last_bookpart = ly_scm2bool (book_->paper_->c_variable ("is-last-bookpart")); SCM ret = SCM_EOL; - SCM label_page_table = SCM_EOL; + SCM label_page_table = book_->top_paper ()->c_variable ("label-page-table"); + if (label_page_table == SCM_UNDEFINED) + label_page_table = SCM_EOL; for (vsize i = 0; i < lines_per_page.size (); i++) { SCM page_num = scm_from_int (i + first_page_number); - SCM last = scm_from_bool (i == lines_per_page.size () - 1); - SCM rag = scm_from_bool (ragged () || (to_boolean (last) - && 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, 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)) { @@ -330,7 +361,7 @@ Page_breaking::make_pages (vector lines_per_page, SCM systems) ret = scm_cons (page, ret); systems = scm_list_tail (systems, line_count); } - book_->paper_->set_variable (ly_symbol2scm ("label-page-table"), label_page_table); + book_->top_paper ()->set_variable (ly_symbol2scm ("label-page-table"), label_page_table); ret = scm_reverse (ret); return ret; } @@ -682,11 +713,10 @@ Page_breaking::min_page_count (vsize configuration, vsize first_page_num) + ((cur_rod_height > 0) ? cached_line_details_[i].padding_: 0); Real next_spring_height = cur_spring_height + cached_line_details_[i].space_; Real next_height = next_rod_height + (ragged () ? next_spring_height : 0); + int next_line_count = line_count + cached_line_details_[i].compressed_nontitle_lines_count_; - 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) + if ((!too_few_lines (line_count) && (next_height > cur_page_height && cur_rod_height > 0)) + || too_many_lines (next_line_count) || (i > 0 && cached_line_details_[i-1].page_permission_ == ly_symbol2scm ("force"))) { @@ -700,6 +730,7 @@ Page_breaking::min_page_count (vsize configuration, vsize first_page_num) { cur_rod_height = next_rod_height; cur_spring_height = next_spring_height; + line_count = next_line_count; } } @@ -718,7 +749,8 @@ Page_breaking::min_page_count (vsize configuration, vsize first_page_num) cur_page_height = page_height (first_page_num + ret - 1, true); Real cur_height = cur_rod_height + ((ragged_last () || ragged ()) ? cur_spring_height : 0); - if (cur_height > cur_page_height + if (!too_few_lines (line_count - cached_line_details_.back ().compressed_nontitle_lines_count_) + && cur_height > cur_page_height /* don't increase the page count if the last page had only one system */ && cur_rod_height > cached_line_details_.back ().extent_.length ()) ret++; @@ -892,23 +924,29 @@ Page_breaking::space_systems_with_fixed_number_per_page (vsize configuration, 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.force_.push_back (space.force_); res.penalty_ += cached_line_details_[line-1].page_penalty_; + if (system_count_on_this_page != systems_per_page_) + { + res.penalty_ += TERRIBLE_SPACING_PENALTY; + res.system_count_status_ |= ((system_count_on_this_page < systems_per_page_)) + ? SYSTEM_COUNT_TOO_FEW : SYSTEM_COUNT_TOO_MANY; + } + 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); + res.force_.back () = space.force_; return finalize_spacing_result (configuration, res); } Page_spacing_result Page_breaking::pack_systems_on_least_pages (vsize configuration, vsize first_page_num) { + // TODO: add support for min/max-systems-per-page. Page_spacing_result res; vsize page = 0; vsize page_first_line = 0; @@ -978,7 +1016,7 @@ Page_breaking::finalize_spacing_result (vsize configuration, Page_spacing_result Real line_force = 0; Real line_penalty = 0; - Real page_force = 0; + Real page_demerits = res.penalty_; Real page_weighting = robust_scm2double (book_->paper_->c_variable ("page-spacing-weight"), 10); for (vsize i = 0; i < uncompressed_line_details_.size (); i++) @@ -990,10 +1028,8 @@ Page_breaking::finalize_spacing_result (vsize configuration, Page_spacing_result for (vsize i = 0; i < res.force_.size (); i++) { Real f = res.force_[i]; - if (isinf (f) && res.systems_per_page_[i] == 1) - f = BAD_SPACING_PENALTY; - page_force += f * f; + page_demerits += min(f*f, BAD_SPACING_PENALTY); } /* for a while we tried averaging page and line forces across pages instead @@ -1001,7 +1037,7 @@ Page_breaking::finalize_spacing_result (vsize configuration, Page_spacing_result with a very bad page force (for example because of a forced page break), the page breaker will put in a _lot_ of pages so that the bad force becomes averaged out over many pages. */ - res.demerits_ = line_force + line_penalty + (page_force + res.penalty_) * page_weighting; + res.demerits_ = line_force + line_penalty + page_demerits * page_weighting; return res; } @@ -1018,13 +1054,18 @@ Page_breaking::space_systems_on_1_page (vector const &lines, Real { 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_; + ret.system_count_status_ |= line_count_status (line_count); /* don't do finalize_spacing_result () because we are only an internal function */ return ret; @@ -1056,6 +1097,17 @@ Page_breaking::space_systems_on_2_pages (vsize configuration, vsize first_page_n vector page1_force; vector page2_force; + + // page1_penalty and page2_penalty store the penalties based + // on min-systems-per-page and max-systems-per-page. + vector page1_penalty; + vector page2_penalty; + + // page1_status and page2_status keep track of whether the min-systems-per-page + // and max-systems-per-page constraints are satisfied. + vector page1_status; + vector page2_status; + Page_spacing page1 (page1_height, page_top_space_); Page_spacing page2 (page2_height, page_top_space_); int page1_line_count = 0; @@ -1063,6 +1115,10 @@ Page_breaking::space_systems_on_2_pages (vsize configuration, vsize first_page_n 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); + page1_status.resize (cached_line_details_.size () - 1, 0); + page2_status.resize (cached_line_details_.size () - 1, 0); /* find the page 1 and page 2 forces for each page-breaking position */ for (vsize i = 0; i < page1_force.size (); i++) @@ -1072,19 +1128,17 @@ Page_breaking::space_systems_on_2_pages (vsize configuration, vsize first_page_n 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_; - // 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. - page1_force[i] = line_count_penalty (page1_line_count) - + (ragged1 && page1.force_ < 0 && i > 0) ? infinity_f : page1.force_; + page1_force[i] = (ragged1 && page1.force_ < 0 && i > 0) ? infinity_f : page1.force_; + page1_penalty[i] = line_count_penalty (page1_line_count); + page1_status[i] = line_count_status (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_force[page2_force.size () - 1 - i] += line_count_penalty (page2_line_count); + page2_penalty[page2_penalty.size () - 1 - i] = line_count_penalty (page2_line_count); + page2_status[page2_penalty.size () - 1 - i] = line_count_status (page2_line_count); } /* find the position that minimises the sum of the page forces */ @@ -1093,8 +1147,12 @@ Page_breaking::space_systems_on_2_pages (vsize configuration, vsize first_page_n for (vsize i = 0; i < page1_force.size (); i++) { Real f = page1_force[i] * page1_force[i] + page2_force[i] * page2_force[i]; - Real uneven = 2 * (page1_force[i] - page2_force[i]); - Real dem = uneven * uneven + f + + // 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 = 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) @@ -1109,9 +1167,11 @@ Page_breaking::space_systems_on_2_pages (vsize configuration, vsize first_page_n ret.systems_per_page_.push_back (cached_line_details_.size () - best_sys_count); ret.force_.push_back (page1_force[best_sys_count-1]); ret.force_.push_back (page2_force[best_sys_count-1]); + ret.system_count_status_ = page1_status[best_sys_count-1] | page2_status[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;