Canvas: new x-fade drawing, two curve widget

1 files changed, 1 insertions, 196 deletions

diff --git a/libs/canvas/curve.cc b/libs/canvas/curve.cc
index e5db740d66..451289e8ea 100644
--- a/libs/canvas/curve.cc
+++ b/libs/canvas/curve.cc
@@ -74,205 +74,10 @@ void
 Curve::interpolate ()
 {
 	samples.clear ();
-	interpolate (_points, points_per_segment, CatmullRomCentripetal, false, samples);
+	InterpolatedCurve::interpolate (_points, points_per_segment, CatmullRomCentripetal, false, samples);
 	n_samples = samples.size();
 }
 
-/* Cartmull-Rom code from http://stackoverflow.com/questions/9489736/catmull-rom-curve-with-no-cusps-and-no-self-intersections/19283471#19283471
- * 
- * Thanks to Ted for his Java version, which I translated into Ardour-idiomatic
- * C++ here.
- */
-
-/**
- * Calculate the same values but introduces the ability to "parameterize" the t
- * values used in the calculation. This is based on Figure 3 from
- * http://www.cemyuksel.com/research/catmullrom_param/catmullrom.pdf
- *
- * @param p An array of double values of length 4, where interpolation
- * occurs from p1 to p2.
- * @param time An array of time measures of length 4, corresponding to each
- * p value.
- * @param t the actual interpolation ratio from 0 to 1 representing the
- * position between p1 and p2 to interpolate the value.
- */
-static double 
-__interpolate (double p[4], double time[4], double t) 
-{
-        const double L01 = p[0] * (time[1] - t) / (time[1] - time[0]) + p[1] * (t - time[0]) / (time[1] - time[0]);
-        const double L12 = p[1] * (time[2] - t) / (time[2] - time[1]) + p[2] * (t - time[1]) / (time[2] - time[1]);
-        const double L23 = p[2] * (time[3] - t) / (time[3] - time[2]) + p[3] * (t - time[2]) / (time[3] - time[2]);
-        const double L012 = L01 * (time[2] - t) / (time[2] - time[0]) + L12 * (t - time[0]) / (time[2] - time[0]);
-        const double L123 = L12 * (time[3] - t) / (time[3] - time[1]) + L23 * (t - time[1]) / (time[3] - time[1]);
-        const double C12 = L012 * (time[2] - t) / (time[2] - time[1]) + L123 * (t - time[1]) / (time[2] - time[1]);
-        return C12;
-}   
-
-/**
- * Given a list of control points, this will create a list of points_per_segment
- * points spaced uniformly along the resulting Catmull-Rom curve.
- *
- * @param points The list of control points, leading and ending with a 
- * coordinate that is only used for controling the spline and is not visualized.
- * @param index The index of control point p0, where p0, p1, p2, and p3 are
- * used in order to create a curve between p1 and p2.
- * @param points_per_segment The total number of uniformly spaced interpolated
- * points to calculate for each segment. The larger this number, the
- * smoother the resulting curve.
- * @param curve_type Clarifies whether the curve should use uniform, chordal
- * or centripetal curve types. Uniform can produce loops, chordal can
- * produce large distortions from the original lines, and centripetal is an
- * optimal balance without spaces.
- * @return the list of coordinates that define the CatmullRom curve
- * between the points defined by index+1 and index+2.
- */
-static void
-_interpolate (const Points& points, Points::size_type index, int points_per_segment, Curve::SplineType curve_type, Points& results) 
-{
-        double x[4];
-        double y[4];
-        double time[4];
-
-        for (int i = 0; i < 4; i++) {
-                x[i] = points[index + i].x;
-                y[i] = points[index + i].y;
-                time[i] = i;
-        }
-        
-        double tstart = 1;
-        double tend = 2;
-
-        if (curve_type != Curve::CatmullRomUniform) {
-                double total = 0;
-                for (int i = 1; i < 4; i++) {
-                        double dx = x[i] - x[i - 1];
-                        double dy = y[i] - y[i - 1];
-                        if (curve_type == Curve::CatmullRomCentripetal) {
-                                total += pow (dx * dx + dy * dy, .25);
-                        } else {
-                                total += pow (dx * dx + dy * dy, .5);
-                        }
-                        time[i] = total;
-                }
-                tstart = time[1];
-                tend = time[2];
-        }
-
-        int segments = points_per_segment - 1;
-        results.push_back (points[index + 1]);
-
-        for (int i = 1; i < segments; i++) {
-                double xi = __interpolate (x, time, tstart + (i * (tend - tstart)) / segments);
-                double yi = __interpolate (y, time, tstart + (i * (tend - tstart)) / segments);
-                results.push_back (Duple (xi, yi));
-        }
-
-        results.push_back (points[index + 2]);
-}
-
-/**
- * This method will calculate the Catmull-Rom interpolation curve, returning
- * it as a list of Coord coordinate objects.  This method in particular
- * adds the first and last control points which are not visible, but required
- * for calculating the spline.
- *
- * @param coordinates The list of original straight line points to calculate
- * an interpolation from.
- * @param points_per_segment The integer number of equally spaced points to
- * return along each curve.  The actual distance between each
- * point will depend on the spacing between the control points.
- * @return The list of interpolated coordinates.
- * @param curve_type Chordal (stiff), Uniform(floppy), or Centripetal(medium)
- * @throws gov.ca.water.shapelite.analysis.CatmullRomException if
- * points_per_segment is less than 2.
- */
-
-void
-Curve::interpolate (const Points& coordinates, uint32_t points_per_segment, SplineType curve_type, bool closed, Points& results)
-{
-        if (points_per_segment < 2) {
-                return;
-        }
-        
-        // Cannot interpolate curves given only two points.  Two points
-        // is best represented as a simple line segment.
-        if (coordinates.size() < 3) {
-                results = coordinates;
-                return;
-        }
-
-        // Copy the incoming coordinates. We need to modify it during interpolation
-        Points vertices = coordinates;
-        
-        // Test whether the shape is open or closed by checking to see if
-        // the first point intersects with the last point.  M and Z are ignored.
-        if (closed) {
-                // Use the second and second from last points as control points.
-                // get the second point.
-                Duple p2 = vertices[1];
-                // get the point before the last point
-                Duple pn1 = vertices[vertices.size() - 2];
-                
-                // insert the second from the last point as the first point in the list
-                // because when the shape is closed it keeps wrapping around to
-                // the second point.
-                vertices.insert(vertices.begin(), pn1);
-                // add the second point to the end.
-                vertices.push_back(p2);
-        } else {
-                // The shape is open, so use control points that simply extend
-                // the first and last segments
-                
-                // Get the change in x and y between the first and second coordinates.
-                double dx = vertices[1].x - vertices[0].x;
-                double dy = vertices[1].y - vertices[0].y;
-                
-                // Then using the change, extrapolate backwards to find a control point.
-                double x1 = vertices[0].x - dx;
-                double y1 = vertices[0].y - dy;
-                
-                // Actaully create the start point from the extrapolated values.
-                Duple start (x1, y1);
-                
-                // Repeat for the end control point.
-                int n = vertices.size() - 1;
-                dx = vertices[n].x - vertices[n - 1].x;
-                dy = vertices[n].y - vertices[n - 1].y;
-                double xn = vertices[n].x + dx;
-                double yn = vertices[n].y + dy;
-                Duple end (xn, yn);
-                
-                // insert the start control point at the start of the vertices list.
-                vertices.insert (vertices.begin(), start);
-                
-                // append the end control ponit to the end of the vertices list.
-                vertices.push_back (end);
-        }
-        
-        // When looping, remember that each cycle requires 4 points, starting
-        // with i and ending with i+3.  So we don't loop through all the points.
-        
-        for (Points::size_type i = 0; i < vertices.size() - 3; i++) {
-
-                // Actually calculate the Catmull-Rom curve for one segment.
-		Points r;
-
-                _interpolate (vertices, i, points_per_segment, curve_type, r);
- 
-                // Since the middle points are added twice, once for each bordering
-                // segment, we only add the 0 index result point for the first
-                // segment.  Otherwise we will have duplicate points.
-
-                if (results.size() > 0) {
-                        r.erase (r.begin());
-                }
-                
-                // Add the coordinates for the segment to the result list.
-
-                results.insert (results.end(), r.begin(), r.end());
-        }
-}
-
 void
 Curve::render (Rect const & area, Cairo::RefPtr<Cairo::Context> context) const
 {