+ 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<Spring> 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 ();
+ }