Source/OpenTK/Math/BezierCurve.cs

#region --- License ---
/* Licensed under the MIT/X11 license.
 * Copyright (c) 2006-2008 the OpenTK Team.
 * This notice may not be removed from any source distribution.
 * See license.txt for licensing detailed licensing details.
 * 
 * Contributions by Georg W�chter.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Text;

namespace OpenTK
{
    [Serializable]
    public struct BezierCurve
    {
        #region Fields

        private List<Vector2> points;

        public float Parallel;

        #endregion

        #region Properties

        public IList<Vector2> Points
        {
            get
            {
                return points;
            }
        }

        #endregion

        #region Constructors

        public BezierCurve(IEnumerable<Vector2> points)
        {
            if (points == null)
                throw new ArgumentNullException("points", "Must point to a valid list of Vector2 structures.");

            this.points = new List<Vector2>(points);
            this.Parallel = 0.0f;
        }

        public BezierCurve(params Vector2[] points)
        {
            if (points == null)
                throw new ArgumentNullException("points", "Must point to a valid list of Vector2 structures.");

            this.points = new List<Vector2>(points);
            this.Parallel = 0.0f;
        }

        public BezierCurve(float parallel, params Vector2[] points)
        {
            if (points == null)
                throw new ArgumentNullException("points", "Must point to a valid list of Vector2 structures.");

            this.Parallel = parallel;
            this.points = new List<Vector2>(points);
        }

        public BezierCurve(float parallel, IEnumerable<Vector2> points)
        {
            if (points == null)
                throw new ArgumentNullException("points", "Must point to a valid list of Vector2 structures.");

            this.Parallel = parallel;
            this.points = new List<Vector2>(points);
        }

        #endregion

        #region Functions


        public Vector2 CalculatePoint(float t)
        {
            return BezierCurve.CalculatePoint(points, t, Parallel);
        }

        public float CalculateLength(float precision)
        {
            return BezierCurve.CalculateLength(points, precision, Parallel);
        }

        #region Static methods

        public static float CalculateLength(IList<Vector2> points, float precision)
        {
            return BezierCurve.CalculateLength(points, precision, 0.0f);
        }

        public static float CalculateLength(IList<Vector2> points, float precision, float parallel)
        {
            float length = 0.0f;
            Vector2 old = BezierCurve.CalculatePoint(points, 0.0f, parallel);

            for (float i = precision; i < (1.0f + precision); i += precision)
            {
                Vector2 n = CalculatePoint(points, i, parallel);
                length += (n - old).Length;
                old = n;
            }

            return length;
        }

        public static Vector2 CalculatePoint(IList<Vector2> points, float t)
        {
            return BezierCurve.CalculatePoint(points, t, 0.0f);
        }

        public static Vector2 CalculatePoint(IList<Vector2> points, float t, float parallel)
        {
            Vector2 r = new Vector2();
            double c = 1.0d - (double)t;
            float temp;
            int i = 0;

            foreach (Vector2 pt in points)
            {
                temp = (float)MathHelper.BinomialCoefficient(points.Count - 1, i) * (float)(System.Math.Pow(t, i) *
                        System.Math.Pow(c, (points.Count - 1) - i));

                r.X += temp * pt.X;
                r.Y += temp * pt.Y;
                i++;
            }

            if (parallel == 0.0f)
                return r;

            Vector2 perpendicular = new Vector2();

            if (t != 0.0f)
                perpendicular = r - BezierCurve.CalculatePointOfDerivative(points, t);
            else
                perpendicular = points[1] - points[0];

            return r + Vector2.Normalize(perpendicular).PerpendicularRight * parallel;
        }

        private static Vector2 CalculatePointOfDerivative(IList<Vector2> points, float t)
        {
            Vector2 r = new Vector2();
            double c = 1.0d - (double)t;
            float temp;
            int i = 0;

            foreach (Vector2 pt in points)
            {
                temp = (float)MathHelper.BinomialCoefficient(points.Count - 2, i) * (float)(System.Math.Pow(t, i) *
                        System.Math.Pow(c, (points.Count - 2) - i));

                r.X += temp * pt.X;
                r.Y += temp * pt.Y;
                i++;
            }

            return r;
        }

        #endregion

        #endregion
    }
}

---