From 80a4253726ff55f14448d9c614433b7d1779286e Mon Sep 17 00:00:00 2001 From: Joe Neeman Date: Tue, 26 Jun 2007 15:08:43 +0300 Subject: [PATCH] tweaks to spacing and include spring.cc --- .../regression/spacing-accidental-stretch.ly | 2 +- lily/note-spacing.cc | 6 +- lily/rhythmic-column-engraver.cc | 3 + lily/spacing-basic.cc | 2 +- lily/spring.cc | 156 ++++++++++++++++++ 5 files changed, 164 insertions(+), 5 deletions(-) create mode 100644 lily/spring.cc diff --git a/input/regression/spacing-accidental-stretch.ly b/input/regression/spacing-accidental-stretch.ly index f8f6bb41ae..f862dc8a2f 100644 --- a/input/regression/spacing-accidental-stretch.ly +++ b/input/regression/spacing-accidental-stretch.ly @@ -11,7 +11,7 @@ The accidental does add a little non-stretchable space. \layout { line-width = 18.\cm } -\relative c'' \context GrandStaff { +\relative c'' { #(set-accidental-style 'piano-cautionary) \time 2/4 d16 d d d d d cis d dis dis dis dis diff --git a/lily/note-spacing.cc b/lily/note-spacing.cc index 38a87e2d38..6577fa7085 100644 --- a/lily/note-spacing.cc +++ b/lily/note-spacing.cc @@ -66,14 +66,14 @@ Note_spacing::get_spacing (Grob *me, Item *right_col, adjust things so there are no collisions. */ Real min_dist = Spacing_interface::minimum_distance (me, right_col); - Real min_desired_space = max (left_head_end + (min_dist - left_head_end) / 2, - min_dist - (base_space - increment) / 2); + Real min_desired_space = left_head_end + (min_dist - left_head_end) / 2; Real ideal = base_space - increment + min_desired_space; stem_dir_correction (me, right_col, increment, &ideal, &min_desired_space); Spring ret (ideal, min_dist); - ret.set_inverse_compress_strength (ideal - max (min_dist, min_desired_space)); + ret.set_inverse_compress_strength (max (0.0, ideal - max (min_dist, min_desired_space))); + ret.set_inverse_stretch_strength (max (0.1, base_space - increment)); return ret; } diff --git a/lily/rhythmic-column-engraver.cc b/lily/rhythmic-column-engraver.cc index d57c1c49a5..5ebd6d5b76 100644 --- a/lily/rhythmic-column-engraver.cc +++ b/lily/rhythmic-column-engraver.cc @@ -83,6 +83,9 @@ Rhythmic_column_engraver::process_acknowledged () { if (!rheads_[i]->get_parent (X_AXIS)) Note_column::add_head (note_column_, rheads_[i]); + + if (Grob *dot = unsmob_grob (rheads_[i]->get_object ("dot"))) + Pointer_group_interface::add_grob (note_column_, ly_symbol2scm ("elements"), dot); } rheads_.resize (0); } diff --git a/lily/spacing-basic.cc b/lily/spacing-basic.cc index e2f69b0bea..bed086a72c 100644 --- a/lily/spacing-basic.cc +++ b/lily/spacing-basic.cc @@ -29,7 +29,7 @@ Spring Spacing_spanner::standard_breakable_column_spacing (Grob *me, Item *l, Item *r, Spacing_options const *options) { - Real min_dist = Paper_column::minimum_distance (l, r); + Real min_dist = max (0.0, Paper_column::minimum_distance (l, r)); Real ideal; if (Paper_column::is_breakable (l) && Paper_column::is_breakable (r)) diff --git a/lily/spring.cc b/lily/spring.cc new file mode 100644 index 0000000000..679ccfa29d --- /dev/null +++ b/lily/spring.cc @@ -0,0 +1,156 @@ +/* + spring.cc -- declare Spring + + source file of the GNU LilyPond music typesetter + + (c) 2007 Joe Neeman +*/ + +#include "spring.hh" + +Spring::Spring () +{ + 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; + + set_distance (dist); + set_min_distance (min_dist); + set_default_strength (); + update_blocking_force (); +} + +void +Spring::update_blocking_force () +{ + if (distance_ == min_distance_) + blocking_force_ = 0.0; + else + blocking_force_ = (min_distance_ - distance_) / inverse_compress_strength_; +} + +/* 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_ = distance_ - min_distance_; + inverse_stretch_strength_ *= 0.8; +} + +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; + + for (vsize i = 0; i < springs.size (); i++) + { + avg_distance += springs[i].distance (); + avg_stretch += springs[i].inverse_stretch_strength (); + min_distance = max (springs[i].min_distance (), min_distance); + } + + avg_stretch /= springs.size (); + avg_distance /= 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); + + return ret; +} + +void +Spring::set_distance (Real d) +{ + if (d < 0 || isinf (d) || isnan (d)) + programming_error ("insane spring distance requested, ignoring it"); + else + { + min_distance_ = min (min_distance_, d); + distance_ = d; + update_blocking_force (); + } +} + +void +Spring::set_min_distance (Real d) +{ + if (d < 0 || isinf (d) || isnan (d)) + programming_error ("insane spring min_distance requested, ignoring it"); + else + { + min_distance_ = d; + distance_ = max (distance_, min_distance_); + update_blocking_force (); + } +} + +void +Spring::set_inverse_stretch_strength (Real f) +{ + if (isinf (f) || isnan (f) || f < 0) + programming_error ("insane spring constant"); + else + inverse_stretch_strength_ = f; +} + +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 (); +} + +void +Spring::set_blocking_force (Real f) +{ + if (isinf (f) || isnan (f)) + { + programming_error ("insane blocking force"); + return; + } + + 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_; +} + +Real +Spring::length (Real f) const +{ + Real force = max (f, blocking_force_); + Real inv_k = force < 0.0 ? inverse_compress_strength_ : inverse_stretch_strength_; + return distance_ + force * inv_k; +} -- 2.39.2