X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fpage-breaking.cc;h=3bc8597c2abb4cc5df89d0c3a9c6a0849c1f49ad;hb=626609cc7a4ae66412702d2c22eef2eb3088917e;hp=0d88338935d56e0269d133d30704f82790f6a553;hpb=87354fef0dcfb6014270d0311abfb45cc57d2726;p=lilypond.git diff --git a/lily/page-breaking.cc b/lily/page-breaking.cc index 0d88338935..3bc8597c2a 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" @@ -37,11 +37,11 @@ compress_lines (const vector &orig) compressed.space_ += old.space_; compressed.inverse_hooke_ += old.inverse_hooke_; - /* 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 @@ -53,6 +53,28 @@ compress_lines (const vector &orig) return ret; } +/* translate the number of systems-per-page into something meaningful for + the uncompressed lines. +*/ +static vector +uncompress_solution (vector const &systems_per_page, + vector const &compressed) +{ + vector ret; + vsize start_sys = 0; + + for (vsize i = 0; i < systems_per_page.size (); i++) + { + int compressed_count = 0; + for (vsize j = start_sys; j < start_sys + systems_per_page[i]; j++) + compressed_count += compressed[j].compressed_lines_count_ - 1; + + ret.push_back (systems_per_page[i] + compressed_count); + start_sys += systems_per_page[i]; + } + return ret; +} + /* for Page_breaking, the start index (when we are dealing with the stuff between a pair of breakpoints) refers to the break_ index of the end of the previous page. So the system index of the start of the current page @@ -75,8 +97,14 @@ Page_breaking::next_system (Break_position const &break_pos) const Page_breaking::Page_breaking (Paper_book *pb, Break_predicate is_break) { book_ = pb; + system_count_ = 0; 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); } @@ -97,6 +125,59 @@ Page_breaking::ragged_last () const 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 page_top_space_; +} + +vsize +Page_breaking::system_count () 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, @@ -175,6 +256,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"); @@ -185,10 +267,11 @@ 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) - scm_to_double (book_->paper_->c_variable ("page-top-space")); + return scm_to_double (height) - page_top_space_; } SCM @@ -217,24 +300,46 @@ 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 = 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)) + { + SCM labels = SCM_EOL; + if (Grob * line = unsmob_grob (scm_car (l))) + { + System *system = dynamic_cast (line); + labels = system->get_property ("labels"); + } + else if (Prob *prob = unsmob_prob (scm_car (l))) + labels = prob->get_property ("labels"); + + for (SCM lbls = labels ; scm_is_pair (lbls) ; lbls = scm_cdr (lbls)) + label_page_table = scm_cons (scm_cons (scm_car (lbls), page_num), + label_page_table); + } scm_apply_1 (page_stencil, page, SCM_EOL); ret = scm_cons (page, ret); systems = scm_list_tail (systems, line_count); } + book_->top_paper ()->set_variable (ly_symbol2scm ("label-page-table"), label_page_table); ret = scm_reverse (ret); return ret; } @@ -402,6 +507,7 @@ Page_breaking::set_current_breakpoints (vsize start, Line_division lower_bound, Line_division upper_bound) { + system_count_ = system_count; current_chunks_ = chunk_list (start, end); current_start_breakpoint_ = start; current_end_breakpoint_ = end; @@ -457,6 +563,7 @@ Page_breaking::set_to_ideal_line_configuration (vsize start, vsize end) current_start_breakpoint_ = start; current_end_breakpoint_ = end; clear_line_details_cache (); + system_count_ = 0; Line_division div; for (vsize i = 0; i+1 < current_chunks_.size (); i++) @@ -469,6 +576,8 @@ Page_breaking::set_to_ideal_line_configuration (vsize start, vsize end) } else div.push_back (1); + + system_count_ += div.back (); } current_configurations_.clear (); current_configurations_.push_back (div); @@ -485,6 +594,7 @@ Page_breaking::cache_line_details (vsize configuration_index) { if (cached_configuration_index_ != configuration_index) { + cached_configuration_index_ = configuration_index; SCM padding_scm = book_->paper_->c_variable ("page-breaking-between-system-padding"); if (!scm_is_number (padding_scm)) padding_scm = book_->paper_->c_variable ("between-system-padding"); @@ -497,8 +607,8 @@ Page_breaking::cache_line_details (vsize configuration_index) vsize sys = next_system (current_chunks_[i]); if (system_specs_[sys].pscore_) { - vsize start = 0; - vsize end = 0; + vsize start; + vsize end; line_breaker_args (sys, current_chunks_[i], current_chunks_[i+1], &start, &end); vector details = line_breaking_[sys].line_details (start, end, div[i]); @@ -508,7 +618,9 @@ Page_breaking::cache_line_details (vsize configuration_index) { assert (div[i] == 1); uncompressed_line_details_.push_back (Line_details (system_specs_[sys].prob_)); - uncompressed_line_details_.back ().padding_ = padding; + uncompressed_line_details_.back ().padding_ = + robust_scm2double (system_specs_[sys].prob_->get_property ("next-padding"), + padding); } } cached_line_details_ = compress_lines (uncompressed_line_details_); @@ -569,6 +681,7 @@ Page_breaking::min_page_count (vsize configuration, vsize first_page_num) 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++) @@ -576,16 +689,19 @@ Page_breaking::min_page_count (vsize configuration, vsize first_page_num) Real ext_len = cached_line_details_[i].extent_.length (); Real next_rod_height = cur_rod_height + ext_len + ((cur_rod_height > 0) ? cached_line_details_[i].padding_: 0); - Real next_spring_height = cur_spring_height + line_space (cached_line_details_[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 = line_space (cached_line_details_[i]); + cur_spring_height = cached_line_details_[i].space_; cur_page_height = page_height (first_page_num + ret, false); ret++; } @@ -620,28 +736,34 @@ Page_breaking::min_page_count (vsize configuration, vsize first_page_num) 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; - assert (n >= min_page_count (configuration, first_page_num)); - cache_line_details (configuration); - if (n > cached_line_details_.size ()) - return Page_spacing_result (); - if (n == 1) + if (systems_per_page_ > 0) { - ret = space_systems_on_1_page (cached_line_details_, - page_height (first_page_num, is_last ()), - ragged () || (is_last () && ragged_last ())); - - uncompress_page_spacing_results (&ret); - } - else if (n == 2) - { - ret = space_systems_on_2_pages (configuration, first_page_num); - uncompress_page_spacing_results (&ret); + 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 ()); + + if (!valid_n) + programming_error ("number of pages is out of bounds"); + + if (n == 1 && valid_n) + ret = space_systems_on_1_page (cached_line_details_, + page_height (first_page_num, is_last ()), + ragged () || (is_last () && ragged_last ())); + else if (n == 2 && valid_n) + ret = space_systems_on_2_pages (configuration, first_page_num); else { Page_spacer ps (cached_line_details_, first_page_num, this); @@ -654,47 +776,74 @@ Page_breaking::space_systems_on_n_pages (vsize configuration, vsize n, vsize fir Real Page_breaking::blank_page_penalty () const { - SCM penalty_sym = is_last () ? ly_symbol2scm ("blank-last-page-force") : ly_symbol2scm ("blank-page-force"); + SCM penalty_sym; + + if (is_last ()) + penalty_sym = ly_symbol2scm ("blank-last-page-force"); + else if (ends_score ()) + penalty_sym = ly_symbol2scm ("blank-after-score-page-force"); + else + penalty_sym = ly_symbol2scm ("blank-page-force"); + + Break_position const &pos = breaks_[current_end_breakpoint_]; + if (Paper_score *ps = system_specs_[pos.system_spec_index_].pscore_) + return robust_scm2double (ps->layout ()->lookup_variable (penalty_sym), 0.0); + 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 (n <= 2) + if (systems_per_page_ > 0) { - n_res = space_systems_on_n_pages (configuration, n, first_page_num); - m_res = space_systems_on_n_pages (configuration, n+1, first_page_num); + 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; } - else + + 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 (); + + if (!valid_n) + programming_error ("both page counts are out of bounds"); + + if (n == 1 && valid_n) { - cache_line_details (configuration); + bool rag = ragged () || (is_last () && ragged_last ()); + Real height = page_height (first_page_num, is_last ()); - vsize min_p_count = min_page_count (configuration, first_page_num); + if (1 >= min_p_count) + n_res = space_systems_on_1_page (cached_line_details_, height, rag); + if (1 < cached_line_details_.size ()) + m_res = space_systems_on_2_pages (configuration, first_page_num); + } + else + { Page_spacer ps (cached_line_details_, first_page_num, this); - if (n >= min_p_count) - { - n_res = ps.solve (n); - uncompress_page_spacing_results (&n_res); - } - if (n < cached_line_details_.size ()) - { - m_res = ps.solve (n+1); - uncompress_page_spacing_results (&m_res); - } - + + if (n >= min_p_count || !valid_n) + n_res = ps.solve (n); + if (n < cached_line_details_.size () || !valid_n) + m_res = ps.solve (n+1); } + m_res = finalize_spacing_result (configuration, m_res); + n_res = finalize_spacing_result (configuration, n_res); + Real penalty = blank_page_penalty (); n_res.demerits_ += penalty; - n_res.force_.back () += penalty; - if (m_res.demerits_ < n_res.demerits_) - return m_res; - return n_res; + if (n_res.force_.size ()) + n_res.force_.back () += penalty; + + return (m_res.demerits_ < n_res.demerits_) ? m_res : n_res; } Page_spacing_result @@ -720,44 +869,122 @@ Page_breaking::space_systems_on_best_pages (vsize configuration, vsize first_pag return finalize_spacing_result (configuration, best); } - - -/* translate the number of systems-per-page into something meaningful for - the uncompressed lines. -*/ -static vector -uncompress_solution (vector const &systems_per_page, - vector const &compressed) +Page_spacing_result +Page_breaking::space_systems_with_fixed_number_per_page (vsize configuration, + vsize first_page_num) { - vector ret; - vsize start_sys = 0; + 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; - for (vsize i = 0; i < systems_per_page.size (); i++) + cache_line_details (configuration); + while (line < cached_line_details_.size ()) { - int compressed_count = 0; - for (vsize j = start_sys; j < start_sys + systems_per_page[i]; j++) - compressed_count += (int)compressed[j].force_; + page++; + space.clear (); + space.resize (page_height (first_page_num + page, false)); - ret.push_back (systems_per_page[i] + compressed_count); - start_sys += systems_per_page[i]; + 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; } - return ret; + + /* 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); } -void -Page_breaking::uncompress_page_spacing_results (Page_spacing_result *res) +Page_spacing_result +Page_breaking::pack_systems_on_least_pages (vsize configuration, vsize first_page_num) { - res->systems_per_page_ = uncompress_solution (res->systems_per_page_, cached_line_details_); + Page_spacing_result res; + vsize page = 0; + vsize page_first_line = 0; + Page_spacing space (page_height (first_page_num, false), page_top_space_); + + cache_line_details (configuration); + for (vsize line = 0; line < cached_line_details_.size (); line++) + { + Real prev_force = space.force_; + space.append_system (cached_line_details_[line]); + if ((line > page_first_line) + && (isinf (space.force_) + || ((line > 0) + && (cached_line_details_[line-1].page_permission_ == ly_symbol2scm ("force"))))) + { + res.systems_per_page_.push_back (line - page_first_line); + res.force_.push_back (prev_force); + res.penalty_ += cached_line_details_[line-1].page_penalty_; + page++; + space.resize (page_height (first_page_num + page, false)); + space.clear (); + space.append_system (cached_line_details_[line]); + page_first_line = line; + } + + if (line == cached_line_details_.size () - 1) + { + /* This is the last line */ + /* When the last page height was computed, we did not know yet that it + * was the last one. If the systems put on it don't fit anymore, the last + * system is moved to a new page */ + space.resize (page_height (first_page_num + page, true)); + if ((line > page_first_line) && (isinf (space.force_))) + { + res.systems_per_page_.push_back (line - page_first_line); + res.force_.push_back (prev_force); + /* the last page containing the last line */ + space.resize (page_height (first_page_num + page + 1, true)); + space.clear (); + space.append_system (cached_line_details_[line]); + res.systems_per_page_.push_back (1); + res.force_.push_back (space.force_); + res.penalty_ += cached_line_details_[line-1].page_penalty_; + res.penalty_ += cached_line_details_[line].page_penalty_; + } + else + { + res.systems_per_page_.push_back (line + 1 - page_first_line); + res.force_.push_back (space.force_); + res.penalty_ += cached_line_details_[line].page_penalty_; + } + } + } + return finalize_spacing_result (configuration, res); } - + /* Calculate demerits and fix res.systems_per_page_ so that it refers to the original line numbers, not the ones given by compress_lines (). */ Page_spacing_result Page_breaking::finalize_spacing_result (vsize configuration, Page_spacing_result res) { + if (res.force_.empty ()) + return res; + cache_line_details (configuration); - uncompress_page_spacing_results (&res); - + res.systems_per_page_ = uncompress_solution (res.systems_per_page_, cached_line_details_); + Real line_force = 0; Real line_penalty = 0; Real page_force = 0; @@ -773,9 +1000,9 @@ Page_breaking::finalize_spacing_result (vsize configuration, Page_spacing_result { 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 @@ -785,6 +1012,7 @@ Page_breaking::finalize_spacing_result (vsize configuration, Page_spacing_result becomes averaged out over many pages. */ res.demerits_ = line_force + line_penalty + (page_force + res.penalty_) * page_weighting; return res; + } /* the cases for page_count = 1 or 2 can be done in O (n) time. Since they @@ -797,15 +1025,19 @@ Page_breaking::finalize_spacing_result (vsize configuration, Page_spacing_result Page_spacing_result Page_breaking::space_systems_on_1_page (vector const &lines, Real page_height, bool ragged) { - Page_spacing space (page_height); + 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; @@ -837,24 +1069,38 @@ Page_breaking::space_systems_on_2_pages (vsize configuration, vsize first_page_n vector page1_force; vector page2_force; - Page_spacing page1 (page1_height); - Page_spacing page2 (page2_height); + + // 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; + 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 */ @@ -863,8 +1109,15 @@ 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]; + // 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) @@ -881,7 +1134,8 @@ Page_breaking::space_systems_on_2_pages (vsize configuration, vsize first_page_n 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; @@ -910,6 +1164,12 @@ Page_breaking::is_last () const return current_end_breakpoint_ == last_break_position (); } +bool +Page_breaking::ends_score () const +{ + return breaks_[current_end_breakpoint_].score_ender_; +} + vsize Page_breaking::last_break_position () const {