X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fsimple-spacer.cc;h=cf4fd5849e35601ad8cf839394d7f6d6ba407c8e;hb=b872748c6aa8bb721ced458691b38ac2fac5dfc8;hp=f16e6070610152750213562cca1cbbd4bd15b9f3;hpb=2b695bcbe3d6a5fddd58eb03189d3272112421d9;p=lilypond.git diff --git a/lily/simple-spacer.cc b/lily/simple-spacer.cc index f16e607061..cf4fd5849e 100644 --- a/lily/simple-spacer.cc +++ b/lily/simple-spacer.cc @@ -1,12 +1,23 @@ /* - simple-spacer.cc -- implement Simple_spacer + This file is part of LilyPond, the GNU music typesetter. - source file of the GNU LilyPond music typesetter - - (c) 1999--2007 Han-Wen Nienhuys + Copyright (C) 1999--2015 Han-Wen Nienhuys TODO: - add support for different stretch/shrink constants? + + LilyPond is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + LilyPond is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with LilyPond. If not, see . */ #include @@ -14,7 +25,7 @@ #include "column-x-positions.hh" #include "dimensions.hh" #include "international.hh" -#include "libc-extension.hh" // isinf +#include "libc-extension.hh" // isinf #include "paper-column.hh" #include "simple-spacer.hh" #include "spaceable-grob.hh" @@ -84,7 +95,7 @@ Simple_spacer::rod_force (int l, int r, Real dist) Real c = range_stiffness (l, r, dist > d); Real block_stretch = dist - d; - if (isinf (c)) /* take care of the 0*infinity_f case */ + if (isinf (c) && block_stretch == 0) /* take care of the 0*infinity_f case */ return 0; return c * block_stretch; } @@ -104,8 +115,13 @@ Simple_spacer::add_rod (int l, int r, Real dist) { Real spring_dist = range_ideal_len (l, r); if (spring_dist < dist) - for (int i = l; i < r; i++) - springs_[i].set_distance (springs_[i].distance () * dist / spring_dist); + for (int i = l; i < r; i++) + { + if (spring_dist) + springs_[i].set_distance (springs_[i].distance () * dist / spring_dist); + else + springs_[i].set_distance (dist / (r - l)); + } return; } @@ -129,7 +145,7 @@ Simple_spacer::range_stiffness (int l, int r, bool stretch) const Real den = 0.0; for (int i = l; i < r; i++) den += stretch ? springs_[i].inverse_stretch_strength () - : springs_[i].inverse_compress_strength (); + : springs_[i].inverse_compress_strength (); return 1 / den; } @@ -144,6 +160,12 @@ Simple_spacer::configuration_length (Real force) const return l; } +void +Simple_spacer::set_force (Real force) +{ + force_ = force; +} + void Simple_spacer::solve (Real line_len, bool ragged) { @@ -167,20 +189,20 @@ Simple_spacer::expand_line () double cur_len = configuration_length (force_); fits_ = true; - for (vsize i=0; i < springs_.size (); i++) + for (vsize i = 0; i < springs_.size (); i++) inv_hooke += springs_[i].inverse_stretch_strength (); if (inv_hooke == 0.0) /* avoid division by zero. If springs are infinitely stiff */ - return 0.0; /* anyway, then it makes no difference what the force is */ + inv_hooke = 1e-6; /* then report a very large stretching force */ - assert (cur_len <= line_len_); + if (cur_len > (1 + 1e-6) * line_len_) + programming_error ("misuse of expand_line"); return (line_len_ - cur_len) / inv_hooke + force_; } Real Simple_spacer::compress_line () { - double inv_hooke = 0; double cur_len = configuration_length (force_); double cur_force = force_; bool compressed = false; @@ -197,39 +219,44 @@ Simple_spacer::compress_line () } fits_ = true; - for (vsize i=0; i < springs_.size (); i++) - inv_hooke += compressed - ? springs_[i].inverse_compress_strength () - : springs_[i].inverse_stretch_strength (); - - assert (line_len_ <= cur_len); + if (line_len_ > (1 + 1e-6) * cur_len) + programming_error ("misuse of compress_line"); vector sorted_springs = springs_; sort (sorted_springs.begin (), sorted_springs.end (), greater ()); - for (vsize i = 0; i < sorted_springs.size (); i++) + /* inv_hooke is the total flexibility of currently-active springs */ + double inv_hooke = 0; + vsize i = sorted_springs.size (); + for (; i && sorted_springs[i - 1].blocking_force () < cur_force; i--) + inv_hooke += compressed + ? sorted_springs[i - 1].inverse_compress_strength () + : sorted_springs[i - 1].inverse_stretch_strength (); + /* i now indexes the first active spring, so */ + for (; i < sorted_springs.size (); i++) { Spring sp = sorted_springs[i]; - assert (sp.blocking_force () <= cur_force); if (isinf (sp.blocking_force ())) - break; + break; double block_dist = (cur_force - sp.blocking_force ()) * inv_hooke; if (cur_len - block_dist < line_len_) - { - cur_force += (line_len_ - cur_len) / inv_hooke; - cur_len = line_len_; - - /* - Paranoia check. - */ - assert (fabs (configuration_length (cur_force) - cur_len) < 1e-6); - return cur_force; - } - + { + cur_force += (line_len_ - cur_len) / inv_hooke; + cur_len = line_len_; + + /* + Paranoia check. + */ + if (fabs (configuration_length (cur_force) - cur_len) > 1e-6 * cur_len) + programming_error (to_string ("mis-predicted force, %.6f ~= %.6f", + cur_len, configuration_length(cur_force))); + return cur_force; + } + cur_len -= block_dist; - inv_hooke -= sp.inverse_compress_strength (); + inv_hooke -= compressed ? sp.inverse_compress_strength () : sp.inverse_stretch_strength (); cur_force = sp.blocking_force (); } @@ -266,7 +293,7 @@ Simple_spacer::force_penalty (bool ragged) const /* Use a convex compression penalty. */ Real f = force_; - return f - (f < 0 ? f*f*f*f*2 : 0); + return f - (f < 0 ? f * f * f * f * 2 : 0); } /****************************************************************/ @@ -276,7 +303,7 @@ struct Rod_description vsize r_; Real dist_; - bool operator< (const Rod_description r) + bool operator < (const Rod_description r) { return r_ < r.r_; } @@ -316,26 +343,26 @@ is_loose (Grob *g) return (scm_is_pair (g->get_object ("between-cols"))); } -static Grob* +static Grob * maybe_find_prebroken_piece (Grob *g, Direction d) { - Grob *ret = dynamic_cast (g)->find_prebroken_piece (d); + Grob *ret = dynamic_cast (g)->find_prebroken_piece (d); if (ret) return ret; return g; } -static Grob* -next_spaceable_column (vector const &list, vsize starting) +static Grob * +next_spaceable_column (vector const &list, vsize starting) { - for (vsize i = starting+1; i < list.size (); i++) + for (vsize i = starting + 1; i < list.size (); i++) if (!is_loose (list[i])) return list[i]; return 0; } static Column_description -get_column_description (vector const &cols, vsize col_index, bool line_starter) +get_column_description (vector const &cols, vsize col_index, bool line_starter) { Grob *col = cols[col_index]; if (line_starter) @@ -346,24 +373,30 @@ get_column_description (vector const &cols, vsize col_index, bool line_st if (next_col) description.spring_ = Spaceable_grob::get_spring (col, next_col); - Grob *end_col = dynamic_cast (cols[col_index+1])->find_prebroken_piece (LEFT); - if (end_col) - description.end_spring_ = Spaceable_grob::get_spring (col, end_col); + if (col_index + 1 < cols.size ()) + { + Grob *end_col = dynamic_cast (cols[col_index + 1])->find_prebroken_piece (LEFT); + if (end_col) + description.end_spring_ = Spaceable_grob::get_spring (col, end_col); + } for (SCM s = Spaceable_grob::get_minimum_distances (col); scm_is_pair (s); s = scm_cdr (s)) { - Grob *other = unsmob_grob (scm_caar (s)); + Grob *other = unsmob (scm_caar (s)); vsize j = binary_search (cols, other, Paper_column::less_than, col_index); if (j != VPOS) - { - if (cols[j] == other) - description.rods_.push_back (Rod_description (j, scm_to_double (scm_cdar (s)))); - else /* it must end at the LEFT prebroken_piece */ - description.end_rods_.push_back (Rod_description (j, scm_to_double (scm_cdar (s)))); - } + { + if (cols[j] == other) + description.rods_.push_back (Rod_description (j, scm_to_double (scm_cdar (s)))); + else /* it must end at the LEFT prebroken_piece */ + /* see Spanner::set_spacing_rods for more comments on how + to deal with situations where we don't know if we're + ending yet on the left prebroken piece */ + description.end_rods_.push_back (Rod_description (j, scm_to_double (scm_cdar (s)))); + } } - + if (!line_starter && to_boolean (col->get_property ("keep-inside-line"))) description.keep_inside_line_ = col->extent (col, X_AXIS); @@ -372,12 +405,12 @@ get_column_description (vector const &cols, vsize col_index, bool line_st } vector -get_line_forces (vector const &columns, - Real line_len, Real indent, bool ragged) +get_line_forces (vector const &columns, + Real line_len, Real indent, bool ragged) { vector breaks; vector force; - vector non_loose; + vector non_loose; vector cols; SCM force_break = ly_symbol2scm ("force"); @@ -391,7 +424,7 @@ get_line_forces (vector const &columns, for (vsize i = 1; i + 1 < non_loose.size (); i++) { if (Paper_column::is_breakable (non_loose[i])) - breaks.push_back (cols.size ()); + breaks.push_back (cols.size ()); cols.push_back (get_column_description (non_loose, i, false)); } @@ -403,67 +436,66 @@ get_line_forces (vector const &columns, cols[breaks[b]] = get_column_description (non_loose, breaks[b], true); vsize st = breaks[b]; - for (vsize c = b+1; c < breaks.size (); c++) - { - vsize end = breaks[c]; - Simple_spacer spacer; - - for (vsize i = breaks[b]; i < end - 1; i++) - spacer.add_spring (cols[i].spring_); - spacer.add_spring (cols[end-1].end_spring_); - - - for (vsize i = breaks[b]; i < end; i++) - { - for (vsize r = 0; r < cols[i].rods_.size (); r++) - if (cols[i].rods_[r].r_ < end) - spacer.add_rod (i - st, cols[i].rods_[r].r_ - st, cols[i].rods_[r].dist_); - for (vsize r = 0; r < cols[i].end_rods_.size (); r++) - if (cols[i].end_rods_[r].r_ == end) - spacer.add_rod (i - st, end - st, cols[i].end_rods_[r].dist_); - if (!cols[i].keep_inside_line_.is_empty ()) - { - spacer.add_rod (i - st, end - st, cols[i].keep_inside_line_[RIGHT]); - spacer.add_rod (0, i - st, -cols[i].keep_inside_line_[LEFT]); - } - } - spacer.solve ((b == 0) ? line_len - indent : line_len, ragged); - force[b * breaks.size () + c] = spacer.force_penalty (ragged); - - if (!spacer.fits ()) - { - if (c == b + 1) - force[b * breaks.size () + c] = -200000; - else - force[b * breaks.size () + c] = infinity_f; - break; - } - if (end < cols.size () && cols[end].break_permission_ == force_break) - break; - } + for (vsize c = b + 1; c < breaks.size (); c++) + { + vsize end = breaks[c]; + Simple_spacer spacer; + + for (vsize i = breaks[b]; i < end - 1; i++) + spacer.add_spring (cols[i].spring_); + spacer.add_spring (cols[end - 1].end_spring_); + + for (vsize i = breaks[b]; i < end; i++) + { + for (vsize r = 0; r < cols[i].rods_.size (); r++) + if (cols[i].rods_[r].r_ < end) + spacer.add_rod (i - st, cols[i].rods_[r].r_ - st, cols[i].rods_[r].dist_); + for (vsize r = 0; r < cols[i].end_rods_.size (); r++) + if (cols[i].end_rods_[r].r_ == end) + spacer.add_rod (i - st, end - st, cols[i].end_rods_[r].dist_); + if (!cols[i].keep_inside_line_.is_empty ()) + { + spacer.add_rod (i - st, end - st, cols[i].keep_inside_line_[RIGHT]); + spacer.add_rod (0, i - st, -cols[i].keep_inside_line_[LEFT]); + } + } + spacer.solve ((b == 0) ? line_len - indent : line_len, ragged); + force[b * breaks.size () + c] = spacer.force_penalty (ragged); + + if (!spacer.fits ()) + { + if (c == b + 1) + force[b * breaks.size () + c] = -200000; + else + force[b * breaks.size () + c] = infinity_f; + break; + } + if (end < cols.size () && scm_is_eq (cols[end].break_permission_, force_break)) + break; + } } return force; } Column_x_positions -get_line_configuration (vector const &columns, - Real line_len, - Real indent, - bool ragged) +get_line_configuration (vector const &columns, + Real line_len, + Real indent, + bool ragged) { vector cols; Simple_spacer spacer; Column_x_positions ret; - ret.cols_.push_back (dynamic_cast (columns[0])->find_prebroken_piece (RIGHT)); + ret.cols_.push_back (dynamic_cast (columns[0])->find_prebroken_piece (RIGHT)); for (vsize i = 1; i + 1 < columns.size (); i++) { if (is_loose (columns[i])) - ret.loose_cols_.push_back (columns[i]); + ret.loose_cols_.push_back (columns[i]); else - ret.cols_.push_back (columns[i]); + ret.cols_.push_back (columns[i]); } - ret.cols_.push_back (dynamic_cast (columns.back ())->find_prebroken_piece (LEFT)); + ret.cols_.push_back (dynamic_cast (columns.back ())->find_prebroken_piece (LEFT)); /* since we've already put our line-ending column in the column list, we can ignore the end_XXX_ fields of our column_description */ @@ -475,13 +507,13 @@ get_line_configuration (vector const &columns, for (vsize i = 0; i < cols.size (); i++) { for (vsize r = 0; r < cols[i].rods_.size (); r++) - spacer.add_rod (i, cols[i].rods_[r].r_, cols[i].rods_[r].dist_); + spacer.add_rod (i, cols[i].rods_[r].r_, cols[i].rods_[r].dist_); if (!cols[i].keep_inside_line_.is_empty ()) - { - spacer.add_rod (i, cols.size (), cols[i].keep_inside_line_[RIGHT]); - spacer.add_rod (0, i, -cols[i].keep_inside_line_[LEFT]); - } + { + spacer.add_rod (i, cols.size (), cols[i].keep_inside_line_[RIGHT]); + spacer.add_rod (0, i, -cols[i].keep_inside_line_[LEFT]); + } } spacer.solve (line_len, ragged); @@ -499,10 +531,9 @@ get_line_configuration (vector const &columns, for (vsize i = 1; i + 1 < ret.cols_.size (); i++) { SCM p = ret.cols_[i]->get_property ("line-break-permission"); - if (p == ly_symbol2scm ("force")) - ret.satisfies_constraints_ = false; + if (scm_is_eq (p, ly_symbol2scm ("force"))) + ret.satisfies_constraints_ = false; } return ret; } -