X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fspring.cc;h=d1640e72b9790fb2d96991a743cfebef63f62f81;hb=97a0169312a260933246ab224e4f8b0969871dd5;hp=c52b464bc36f2294ca7e9b95a861915c59c010b7;hpb=1a71119277d04b287b3a976c526adba6500239c6;p=lilypond.git diff --git a/lily/spring.cc b/lily/spring.cc index c52b464bc3..d1640e72b9 100644 --- a/lily/spring.cc +++ b/lily/spring.cc @@ -1,58 +1,232 @@ -/* - spring.cc -- implement Spring - - source file of the GNU LilyPond music typesetter - - (c) 1999 Han-Wen Nienhuys - - */ +/* + This file is part of LilyPond, the GNU music typesetter. + + Copyright (C) 2007--2015 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" -#include "debug.hh" -#include "item.hh" -#include "paper-column.hh" Spring::Spring () { - item_l_drul_[LEFT] =item_l_drul_[RIGHT] =0; - distance_f_ =0.; - strength_f_ =1.0; + distance_ = 1.0; + min_distance_ = 1.0; + inverse_stretch_strength_ = 1.0; + inverse_compress_strength_ = 1.0; + + update_blocking_force (); +} + +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); + set_default_strength (); + update_blocking_force (); +} + +void +Spring::update_blocking_force () +{ + // 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) +{ + distance_ = max (min_distance_, distance_ * r); + inverse_compress_strength_ = max (0.0, distance_ - min_distance_); + inverse_stretch_strength_ *= r; + update_blocking_force (); +} + +bool +Spring::operator > (Spring const &other) const +{ + return blocking_force_ > other.blocking_force_; +} + +/* merge springs, basically by averaging them, but leave a little headroom + above the largest minimum distance so that things don't get too cramped */ +Spring +merge_springs (vector const &springs) +{ + Real avg_distance = 0; + Real min_distance = 0; + Real avg_stretch = 0; + Real avg_compress = 0; + + for (vsize i = 0; i < springs.size (); i++) + { + avg_distance += springs[i].distance (); + avg_stretch += springs[i].inverse_stretch_strength (); + avg_compress += 1 / springs[i].inverse_compress_strength (); + min_distance = max (springs[i].min_distance (), min_distance); + } + + 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); + ret.set_inverse_stretch_strength (avg_stretch); + ret.set_inverse_compress_strength (1 / avg_compress); + + return ret; +} + +void +Spring::set_distance (Real d) +{ + if (d < 0 || isinf (d) || isnan (d)) + programming_error ("insane spring distance requested, ignoring it"); + else + { + distance_ = d; + update_blocking_force (); + } } void -Spring::add_to_cols () +Spring::set_min_distance (Real d) { - Direction d = LEFT; - do + if (d < 0 || isinf (d) || isnan (d)) + programming_error ("insane spring min_distance requested, ignoring it"); + else { - item_l_drul_[-d]->column_l ()->add_spring - (item_l_drul_[d]->column_l (), - distance_f_, strength_f_); + min_distance_ = d; + update_blocking_force (); } - while ((flip (&d))!=LEFT); } +void +Spring::ensure_min_distance (Real d) +{ + set_min_distance (max (d, min_distance_)); +} -Column_spring::Column_spring () +void +Spring::set_inverse_stretch_strength (Real f) { - other_l_ = 0; - distance_f_ =0; - strength_f_ =1.0; + if (isinf (f) || isnan (f) || f < 0) + programming_error ("insane spring constant"); + else + inverse_stretch_strength_ = f; + + update_blocking_force (); } +void +Spring::set_inverse_compress_strength (Real f) +{ + if (isinf (f) || isnan (f) || f < 0) + programming_error ("insane spring constant"); + else + inverse_compress_strength_ = f; + + update_blocking_force (); +} -int -Column_spring::compare (Column_spring const & r1, Column_spring const &r2) +void +Spring::set_blocking_force (Real f) { - return r1.other_l_->rank_i() - r2.other_l_->rank_i(); + if (isinf (f) || isnan (f)) + { + programming_error ("insane blocking force"); + return; + } + + blocking_force_ = -infinity_f; + min_distance_ = length (f); + update_blocking_force (); +} + +void +Spring::set_default_strength () +{ + 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 -Column_spring::print () const +Spring::set_default_stretch_strength () +{ + inverse_stretch_strength_ = distance_; +} + +Real +Spring::length (Real f) const { -#ifndef NPRINT - DEBUG_OUT << "Column_spring { rank = " - << other_l_->rank_i () << ", dist = " << distance_f_ << "}\n"; + Real force = max (f, blocking_force_); + Real inv_k = force < 0.0 ? inverse_compress_strength_ : inverse_stretch_strength_; -#endif + if (isinf (force)) + { + programming_error ("cruelty to springs"); + force = 0.0; + } + + // 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); } +