Написать свой алгоритм рисования кривых Безье

namespace WindowsFormsApplication5
{
    public partial class Form1 : Form
    {
        private Pen pen = new Pen(Color.Black);
        private Graphics g;
 
        public Form1()
        {
            InitializeComponent();
            Image im = new Bitmap(pictureBox1.Width, pictureBox1.Height);
            g = Graphics.FromImage(im);
            g.Clear(Color.White);
            DrawBeze(new Point(320, 250), new Point(100, 200), new Point(300, 120), new Point(85, 63), g, pen);
            g.Dispose();
        }
        *******public static void DrawBeze(Point A,Point B,Point C, Point D,Graphics g,Pen p)
 *******{
            float Q1, Q2, Q3, Q4, T, T1, Step;
            int M, QX, QY;
 **************if (Math.Abs(D.X - A.X) > Math.Abs(D.Y - A.Y))
 **************{
 ******************M = D.X - A.X;
 **************}
 **************else
 ******************M = D.Y - A.Y;
 **************Step = 1 / M;
 **************T = 0;
 ***********while (T < 1)
 ***************{
                    T = T + Step;
                if (T > 1){
 *******************T = 1;
 *******************T1 = 0;}
                else 
 *******************T1 = 1 - T;
 ***************Q1 = T1 * T1 * T1;
 ***************Q2 = 3 * T1 * T1 * T;
 ***************Q3 = 3 * T1 * T ** T;
 ***************Q4 = ****T ** T ** T;
 ***************QX = (int)(Q1 * A.X + Q2 * B.X + Q3 * C.X + Q4 * D.X);
                QY = (int)(Q1 * A.Y + Q2 * B.Y + Q3 * C.Y + Q4 * D.Y);
                g.DrawRectangle(p,10,10,2,2);
 ***********}
 **************
 
 *******}
    }
}

g.DrawRectangle(p,QX,QY,1,1);

using System;
using System.Drawing;
 
namespace WindowsFormsApplicationTest2
{
    /// <summary>
    /// Кривоая безье
    /// </summary>
    public class BezierCurve
    {
        /// <summary>
        /// Количество точек для отрисовки.
        /// </summary>
        private const int N = 40;
 
        /// <summary>
        /// Опорные точки.
        /// </summary>
        private PointF[] dataPoints;
 
        /// <summary>
        /// Создание кривой безье
        /// </summary>
        /// <param name="points">Опроные точки</param>
        public BezierCurve(PointF[] points)
        {
            if (points.Length != 4)
            {
                throw new ArgumentOutOfRangeException();
            }
            dataPoints = points;
            Invalidate();
        }
 
        /// <summary>
        /// Точки для отрисовки
        /// </summary>
        public PointF[] DrawingPoints { get; private set; }
 
        /// <summary>
        /// Опорные точки
        /// </summary>
        public PointF[] DataPoints
        {
            get { return dataPoints; }
            set
            {
                if (value.Length != 4)
                {
                    throw new ArgumentOutOfRangeException();
                }
                dataPoints = value;
                Invalidate();
            }
        }
 
        /// <summary>
        /// Опорная точка
        /// </summary>
        /// <param name="i">Индекс опорной точки</param>
        public PointF this[int i]
        {
            get { return dataPoints[i]; }
            set
            {
                dataPoints[i] = value;
                Invalidate();
            }
        }
 
        /// <summary>
        /// Обновить точки для отрисовки.
        /// </summary>
        public void Invalidate()
        {
            DrawingPoints = new PointF[N + 1];
            float dt = 1f / N;
            float t = 0f;
            for (int i = 0; i <= N; i++)
            {
                DrawingPoints[i] = B(t);
                t += dt;
            }
        }
 
        /// <summary>
        /// Функция кривой
        /// </summary>
        /// <param name="t">Параметр. Может изменяться от 0 до 1</param>
        /// <returns>Точка кирвой</returns>
        private PointF B(float t)
        {
            float c0 = (1 - t) * (1 - t) * (1 - t);
            float c1 = (1 - t) * (1 - t) * 3 * t;
            float c2 = (1 - t) * t * 3 * t;
            float c3 = t * t * t;
            float x = c0 * dataPoints[0].X + c1 * dataPoints[1].X + c2 * dataPoints[2].X + c3 * dataPoints[3].X;
            float y = c0 * dataPoints[0].Y + c1 * dataPoints[1].Y + c2 * dataPoints[2].Y + c3 * dataPoints[3].Y;
            return new PointF(x, y);
        }
 
        /// <summary>
        /// Отрисовка кривой.
        /// </summary>
        /// <param name="g">График для отрисовки</param>
        public void Draw(Graphics g)
        {
            Pen pen = new Pen(Color.Black, 2f);
            g.DrawLines(pen, DrawingPoints);
        }
    }
}

using System;
using System.Drawing;
using System.Windows.Forms;
 
namespace WindowsFormsApplicationTest2
{
    /// <summary>
    /// Управляющий маркер
    /// </summary>
    public class Marker
    {
        /// <summary>
        /// Радиус маркера
        /// </summary>
        private const int Radius = 10;
 
        /// <summary>
        /// Флаг, определяющий начало перетаскивания
        /// </summary>
        private bool drag;
 
        /// <summary>
        /// Ограничивающий прямоугольник
        /// </summary>
        private RectangleF rectangle;
 
        /// <summary>
        /// Создание нового маркера
        /// </summary>
        /// <param name="x">Координата X</param>
        /// <param name="y">Координата Y</param>
        public Marker(int x, int y)
        {
            rectangle = new RectangleF(x - Radius / 2f, y - Radius / 2f, Radius, Radius);
        }
 
        /// <summary>
        /// Событие, возникающее при перетаскивании
        /// </summary>
        public Action<PointF> OnDrag { get; set; }
 
        /// <summary>
        /// Собитие, возникающее при нажании на маркер
        /// </summary>
        public Action<PointF> OnMouseDown { get; set; }
 
        /// <summary>
        /// Положение маркера
        /// </summary>
        public PointF Location
        {
            get { return new PointF(rectangle.X + Radius / 2f, rectangle.Y + Radius / 2f); }
        }
 
        /// <summary>
        /// Отрисовка маркера
        /// </summary>
        /// <param name="g">График для отрисовки</param>
        public void Draw(Graphics g)
        {
            g.FillEllipse(Brushes.Black, rectangle);
        }
 
        /// <summary>
        /// Необходимо вызывать при нажатии мыши
        /// </summary>
        public void MouseDown(MouseEventArgs e)
        {
            if (rectangle.Contains(e.Location))
            {
                drag = true;
                if (OnMouseDown != null)
                {
                    OnMouseDown(e.Location);
                }
            }
        }
 
        /// <summary>
        /// Необходмио вызывать при отпускании мыши
        /// </summary>
        public void MouseUp()
        {
            drag = false;
        }
 
        /// <summary>
        /// Необходмо вызывать при передвижении мыши
        /// </summary>
        public void MouseMove(MouseEventArgs e)
        {
            if (drag)
            {
                rectangle.X = e.X - Radius / 2f;
                rectangle.Y = e.Y - Radius / 2f;
                if (OnDrag != null)
                {
                    OnDrag(e.Location);
                }
            }
        }
    }
}

using System.Drawing;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Threading;
using System.Windows.Forms;
 
namespace WindowsFormsApplicationTest2
{
    public partial class Form1 : Form
    {
        readonly BezierCurve bezier;
        readonly Marker[] markers = new Marker[4];
 
        public Form1()
        {
            InitializeComponent();
            markers[0] = new Marker(100, 200);
            markers[1] = new Marker(150, 250);
            markers[2] = new Marker(200, 150);
            markers[3] = new Marker(250, 200);
            for (int index = 0; index < markers.Length; index++)
            {
                Marker marker = markers[index];
                int i = index;
                marker.OnDrag += f =>
                {
                    bezier[i] = f;
                    pictureBox.Invalidate();
                };
                marker.OnMouseDown += f => { Cursor = Cursors.Hand; };
            }
 
            bezier = new BezierCurve(markers.Select(m => m.Location).ToArray());
        }
 
        private void pictureBox_Paint(object sender, PaintEventArgs e)
        {
            e.Graphics.SmoothingMode = SmoothingMode.HighQuality;
            Pen pen = new Pen(Color.Gray, 1f);
            e.Graphics.DrawLines(pen, markers.Select(m=>m.Location).ToArray());
            foreach (Marker marker in markers)
            {
               marker.Draw(e.Graphics);
            }
            bezier.Draw(e.Graphics);
        }
 
        private void pictureBox_MouseMove(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                foreach (Marker marker in markers)
                {
                    marker.MouseMove(e);
                    Thread.Sleep(0);
                }
            }
        }
 
        private void pictureBox_MouseDown(object sender, MouseEventArgs e)
        {
            foreach (Marker marker in markers)
            {
                marker.MouseDown(e);
            }
        }
 
        private void pictureBox_MouseUp(object sender, MouseEventArgs e)
        {
            foreach (Marker marker in markers)
            {
                marker.MouseUp();
            }
            Cursor = Cursors.Arrow;
        }
    }
}