X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fsimple-spacer.cc;h=4376b0133c2d47942884acb8cce9686311ff8db3;hb=54b02666750062788185bd3f99e644d621e348c2;hp=9200554822b87030d8e0b6c452fd7b3fe5ba859a;hpb=91f01637f31c7d904fd8016b49184e935bf1c8ab;p=lilypond.git diff --git a/lily/simple-spacer.cc b/lily/simple-spacer.cc index 9200554822..4376b0133c 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--2011 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 @@ -80,9 +91,12 @@ Simple_spacer::fits () const Real Simple_spacer::rod_force (int l, int r, Real dist) { - Real c = range_stiffness (l, r); Real d = range_ideal_len (l, r); + Real c = range_stiffness (l, r, dist > d); Real block_stretch = dist - d; + + if (isinf (c) && block_stretch == 0) /* take care of the 0*infinity_f case */ + return 0; return c * block_stretch; } @@ -102,13 +116,18 @@ 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].ideal_ *= dist / spring_dist; + { + if (spring_dist) + springs_[i].set_distance (springs_[i].distance () * dist / spring_dist); + else + springs_[i].set_distance (dist / (r - l)); + } return; } force_ = max (force_, block_force); for (int i = l; i < r; i++) - springs_[i].block_force_ = max (block_force, springs_[i].block_force_); + springs_[i].set_blocking_force (max (block_force, springs_[i].blocking_force ())); } Real @@ -116,16 +135,17 @@ Simple_spacer::range_ideal_len (int l, int r) const { Real d = 0.; for (int i = l; i < r; i++) - d += springs_[i].ideal_; + d += springs_[i].distance (); return d; } Real -Simple_spacer::range_stiffness (int l, int r) const +Simple_spacer::range_stiffness (int l, int r, bool stretch) const { Real den = 0.0; for (int i = l; i < r; i++) - den += springs_[i].inverse_hooke_; + den += stretch ? springs_[i].inverse_stretch_strength () + : springs_[i].inverse_compress_strength (); return 1 / den; } @@ -164,7 +184,10 @@ Simple_spacer::expand_line () fits_ = true; for (vsize i=0; i < springs_.size (); i++) - inv_hooke += springs_[i].inverse_hooke_; + 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 */ assert (cur_len <= line_len_); return (line_len_ - cur_len) / inv_hooke + force_; @@ -173,42 +196,59 @@ Simple_spacer::expand_line () Real Simple_spacer::compress_line () { - double inv_hooke = 0; double cur_len = configuration_length (force_); double cur_force = force_; + bool compressed = false; + + /* just because we are in compress_line () doesn't mean that the line + will actually be compressed (as in, a negative force) because + we start out with a stretched line. Here, we check whether we + will be compressed or stretched (so we know which spring constant to use) */ + if (configuration_length (0.0) > line_len_) + { + cur_force = 0.0; + cur_len = configuration_length (0.0); + compressed = true; + } fits_ = true; - for (vsize i=0; i < springs_.size (); i++) - inv_hooke += springs_[i].inverse_hooke_; assert (line_len_ <= cur_len); - vector sorted_springs = springs_; - sort (sorted_springs.begin (), sorted_springs.end (), greater ()); - for (vsize i = 0; i < sorted_springs.size (); i++) + vector sorted_springs = springs_; + sort (sorted_springs.begin (), sorted_springs.end (), greater ()); + + /* 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_description sp = sorted_springs[i]; + Spring sp = sorted_springs[i]; - assert (sp.block_force_ <= cur_force); - if (isinf (sp.block_force_)) + if (isinf (sp.blocking_force ())) break; - double block_dist = (cur_force - sp.block_force_) * inv_hooke; + 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_; + cur_force += (line_len_ - cur_len) / inv_hooke; + cur_len = line_len_; - /* - Paranoia check. + /* + Paranoia check. */ - assert (fabs (configuration_length (cur_force) - cur_len) < 1e-6); - return cur_force; + assert (fabs (configuration_length (cur_force) - cur_len) < 1e-6); + return cur_force; } cur_len -= block_dist; - inv_hooke -= sp.inverse_hooke_; - cur_force = sp.block_force_; + inv_hooke -= compressed ? sp.inverse_compress_strength () : sp.inverse_stretch_strength (); + cur_force = sp.blocking_force (); } fits_ = false; @@ -216,24 +256,10 @@ Simple_spacer::compress_line () } void -Simple_spacer::add_spring (Real ideal, Real inverse_hooke) +Simple_spacer::add_spring (Spring const &sp) { - Spring_description description; - - description.ideal_ = ideal; - description.inverse_hooke_ = inverse_hooke; - if (!description.is_sane ()) - { - programming_error ("insane spring found, setting to unit"); - - description.inverse_hooke_ = 1.0; - description.ideal_ = 1.0; - } - - description.block_force_ = -description.ideal_ / description.inverse_hooke_; - // block at distance 0 - - springs_.push_back (description); + force_ = max (force_, sp.blocking_force ()); + springs_.push_back (sp); } vector @@ -258,50 +284,11 @@ Simple_spacer::force_penalty (bool ragged) const /* Use a convex compression penalty. */ Real f = force_; - return f - (f < 0 ? f*f*f*f*4 : 0); -} - -/****************************************************************/ - -Spring_description::Spring_description () -{ - ideal_ = 0.0; - inverse_hooke_ = 0.0; - block_force_ = 0.0; -} - -bool -Spring_description::is_sane () const -{ - return (inverse_hooke_ >= 0) - && ideal_ > 0 - && !isinf (ideal_) && !isnan (ideal_) - && (inverse_hooke_ == 0.0 || fabs (inverse_hooke_) > 1e-8) - ; -} - -Real -Spring_description::length (Real f) const -{ - return ideal_ + max (f, block_force_) * inverse_hooke_; + return f - (f < 0 ? f*f*f*f*2 : 0); } /****************************************************************/ -/* - TODO: should a add penalty for widely varying spring forces (caused - by constraints, eg. - - - . ===== - . | | - .o|o|x ##x - . - - The ## forces the notes apart; we shouldn't allow the O's to touch - this closely. -*/ - struct Rod_description { vsize r_; @@ -329,19 +316,14 @@ struct Column_description { vector rods_; vector end_rods_; /* use these if they end at the last column of the line */ - Real ideal_; - Real inverse_hooke_; - Real end_ideal_; - Real end_inverse_hooke_; + Spring spring_; + Spring end_spring_; + SCM break_permission_; Interval keep_inside_line_; Column_description () { - ideal_ = 0; - inverse_hooke_ = 0; - end_ideal_ = 0; - end_inverse_hooke_ = 0; break_permission_ = SCM_EOL; } }; @@ -380,10 +362,11 @@ get_column_description (vector const &cols, vsize col_index, bool line_st Column_description description; Grob *next_col = next_spaceable_column (cols, col_index); if (next_col) - Spaceable_grob::get_spring (col, next_col, &description.ideal_, &description.inverse_hooke_); + 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) - Spaceable_grob::get_spring (col, end_col, &description.end_ideal_, &description.end_inverse_hooke_); + 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)) @@ -444,8 +427,8 @@ get_line_forces (vector const &columns, Simple_spacer spacer; for (vsize i = breaks[b]; i < end - 1; i++) - spacer.add_spring (cols[i].ideal_, cols[i].inverse_hooke_); - spacer.add_spring (cols[end-1].end_ideal_, cols[end-1].end_inverse_hooke_); + spacer.add_spring (cols[i].spring_); + spacer.add_spring (cols[end-1].end_spring_); for (vsize i = breaks[b]; i < end; i++) @@ -505,7 +488,7 @@ get_line_configuration (vector const &columns, for (vsize i = 0; i + 1 < ret.cols_.size (); i++) { cols.push_back (get_column_description (ret.cols_, i, i == 0)); - spacer.add_spring (cols[i].ideal_, cols[i].inverse_hooke_); + spacer.add_spring (cols[i].spring_); } for (vsize i = 0; i < cols.size (); i++) {