CardinalSpline.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Shapes;
using System.Windows.Media;
using System.Windows.Media.Imaging;

namespace EdgeClustering
{
    /// \author Manuel Keglevic
    /// \author Thomas Schulz
    /// <summary>
    /// This class provides static functions to generate Cardinal Splines by using Bezier Splines.
    /// </summary>
    static class CardinalSpline
    {
        /// <summary>
        /// This functions uses given points to create a Cardinal Spline Curve passing through that points.
        /// </summary>
        /// <param name="points">control points used to calculate the Cardinal Spline Curve</param>
        /// <param name="tension">tension of the resulting curve</param>
        /// <returns></returns>
        public static StreamGeometry CalculateCardinalSplinePath(Point[] points, double tension)
        {
            Point[] p = CalculateControlPoints(points, tension);
            
            StreamGeometry geometry = new StreamGeometry();
            
            using (StreamGeometryContext sgc = geometry.Open())
            {
                sgc.BeginFigure(p[0], true, false);
                for (int i = 1; i < p.Length; i +=3)
                {
                    sgc.BezierTo(p[i], p[i + 1], p[i + 2], true, false);
                }
            }

            return geometry;
        }

        /// <summary>
        /// This function calculates the Bezier Control points representing a Cardinal Spline
        /// Curve with the given points and tension.
        /// </summary>
        /// <param name="points">control points used to calculate the Cardinal Spline Curve</param>
        /// <param name="tension">tension of the resulting curve</param>
        /// <returns></returns>
        private static Point[] CalculateControlPoints(Point[] points, double tension)
        {
            Point[] p;
            int num = points.Length * 3 - 2;
            Point[] ctrlPoints = new Point[num];
            double t = tension * 1.0 / 3.0;

            //Anfang Berechnen
            ctrlPoints[0] = points[0];
            ctrlPoints[1] = CalculateEnd(points[0], points[1], t);

            for (int i = 0; i < points.Length - 2; i++)
            {
                p = CaclculateCurve(new Point[]{points[i], points[i + 1], points[i + 2]}, t);
                ctrlPoints[3 * i + 2] = p[0];
                ctrlPoints[3 * i + 3] = points[i+1];
                ctrlPoints[3 * i + 4] = p[1];
            }


            ctrlPoints[num - 2] = CalculateEnd(points[points.Length - 1], points[points.Length - 2], t);
            ctrlPoints[num - 1] = points[points.Length - 1];
            return ctrlPoints;
        }

        /// <summary>
        /// Calculates the Bezier Control points for the endpoints of the Cardinal Spline Curve
        /// </summary>
        /// <param name="end">endpoint</param>
        /// <param name="other">point next to the end</param>
        /// <param name="tension">tension of the resulting curve</param>
        /// <returns></returns>
        private static Point CalculateEnd(Point end, Point other, double tension)
        {
            return new Point(tension * (other.X - end.X) + end.X, tension * (other.Y - end.Y) + end.Y);
        }

        /// <summary>
        /// Calculates the Bezier Control points for a given set of 3 points.
        /// </summary>
        /// <param name="p">points on the Cardinal Spline</param>
        /// <param name="tension">tension of the Cardinal Spline</param>
        /// <returns></returns>
        private static Point[] CaclculateCurve(Point[] p, double tension)
        {
            double dx = p[2].X - p[0].X;
            double dy = p[2].Y - p[0].Y;

            Point[] erg = new Point[2];

            erg[0] = new Point(p[1].X - dx * tension, p[1].Y - dy * tension);
            erg[1] = new Point(p[1].X + dx * tension, p[1].Y + dy * tension);

            return erg;
        }
    }
}

---