X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fspring.cc;h=d1640e72b9790fb2d96991a743cfebef63f62f81;hb=97a0169312a260933246ab224e4f8b0969871dd5;hp=67d41c9c39640e0add681aa50728ec5e5f240861;hpb=0e5d83a9ceb4a143f83d22406d7eb816314ff9f7;p=lilypond.git diff --git a/lily/spring.cc b/lily/spring.cc index 67d41c9c39..d1640e72b9 100644 --- a/lily/spring.cc +++ b/lily/spring.cc @@ -1,9 +1,37 @@ /* - spring.cc -- declare Spring + This file is part of LilyPond, the GNU music typesetter. - source file of the GNU LilyPond music typesetter + Copyright (C) 2007--2015 Joe Neeman - (c) 2007--2009 Joe Neeman + 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 . +*/ + +/* + Springs help chains of objects, such as the notes in a line of music, + distribute themselves evenly. + Each spring decides the length from the reference point of one object + along the line to the reference point of the next, based on a force + applied to the entire chain (see Spring::length() for details): + length = distance_ + flexibility * force + + distance_ is the ideal separation between reference points + inverse_stretch_strength_ is the flexibility when the force is stretching + inverse_compress_strength_ is the flexibility when the force is compressing + min_distance_ sets a lower limit on length + + Typically, the force applied to a list of objects ranges from about + -1 to about 1, though there are no set limits. */ #include "spring.hh" @@ -22,6 +50,8 @@ Spring::Spring (Real dist, Real min_dist) { distance_ = 1.0; min_distance_ = 1.0; + inverse_stretch_strength_ = 1.0; + inverse_compress_strength_ = 1.0; set_distance (dist); set_min_distance (min_dist); @@ -32,23 +62,36 @@ Spring::Spring (Real dist, Real min_dist) void Spring::update_blocking_force () { - if (distance_ == min_distance_) - blocking_force_ = 0.0; - else + // blocking_force_ is the value of force + // below which length(force) is constant, and + // above which length(force) varies according to inverse_*_strength. + // Simple_spacer::compress_line() depends on the condition above. + // We assume inverse_*_strength are non-negative. + if (min_distance_ > distance_) + if (inverse_stretch_strength_ > 0.0) + blocking_force_ = (min_distance_ - distance_) / inverse_stretch_strength_; + else + // Conceptually, this should be +inf, but 0.0 meets the requirements + // of Simple_spacer and creates fewer cases of 0.0*inf to handle. + blocking_force_ = 0.0; + else if (inverse_compress_strength_ > 0.0) blocking_force_ = (min_distance_ - distance_) / inverse_compress_strength_; + else + blocking_force_ = 0.0; } /* scale a spring, but in a way that doesn't violate min_distance */ void -Spring::operator*= (Real r) +Spring::operator *= (Real r) { distance_ = max (min_distance_, distance_ * r); - inverse_compress_strength_ = distance_ - min_distance_; - inverse_stretch_strength_ *= 0.8; + inverse_compress_strength_ = max (0.0, distance_ - min_distance_); + inverse_stretch_strength_ *= r; + update_blocking_force (); } bool -Spring::operator> (Spring const &other) const +Spring::operator > (Spring const &other) const { return blocking_force_ > other.blocking_force_; } @@ -71,9 +114,9 @@ merge_springs (vector const &springs) min_distance = max (springs[i].min_distance (), min_distance); } - avg_stretch /= springs.size (); - avg_compress /= springs.size (); - avg_distance /= springs.size (); + avg_stretch /= Real (springs.size ()); + avg_compress /= Real (springs.size ()); + avg_distance /= Real (springs.size ()); avg_distance = max (min_distance + 0.3, avg_distance); Spring ret = Spring (avg_distance, min_distance); @@ -90,7 +133,6 @@ Spring::set_distance (Real d) programming_error ("insane spring distance requested, ignoring it"); else { - min_distance_ = min (min_distance_, d); distance_ = d; update_blocking_force (); } @@ -104,11 +146,16 @@ Spring::set_min_distance (Real d) else { min_distance_ = d; - distance_ = max (distance_, min_distance_); update_blocking_force (); } } +void +Spring::ensure_min_distance (Real d) +{ + set_min_distance (max (d, min_distance_)); +} + void Spring::set_inverse_stretch_strength (Real f) { @@ -116,6 +163,8 @@ Spring::set_inverse_stretch_strength (Real f) programming_error ("insane spring constant"); else inverse_stretch_strength_ = f; + + update_blocking_force (); } void @@ -140,15 +189,27 @@ Spring::set_blocking_force (Real f) blocking_force_ = -infinity_f; min_distance_ = length (f); - distance_ = max (distance_, min_distance_); update_blocking_force (); } void Spring::set_default_strength () { - inverse_compress_strength_ = distance_ - min_distance_; - inverse_stretch_strength_ = distance_ - min_distance_; + set_default_stretch_strength (); + set_default_compress_strength (); +} + +void +Spring::set_default_compress_strength () +{ + inverse_compress_strength_ = (distance_ >= min_distance_) ? distance_ - min_distance_ : 0; + update_blocking_force (); +} + +void +Spring::set_default_stretch_strength () +{ + inverse_stretch_strength_ = distance_; } Real @@ -163,5 +224,9 @@ Spring::length (Real f) const force = 0.0; } - return distance_ + force * inv_k; + // There is a corner case here: if min_distance_ is larger than + // distance_ but the spring is fixed, then inv_k will be zero + // and we need to make sure that we return min_distance_. + return max (min_distance_, distance_ + force * inv_k); } +