Точка должна двигаться по окружности, координаты центра и радиус задаются

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
 
namespace СтрогальныйСтанок
{
    public partial class Form1 : Form
    {
        Panel panel;
        Button startButton;
        Button stopButton;
 
        TextBox[] inputTextBox;
        Label[] inputLabel;
        int countInputControls = 8;
 
        Button updateButton;
 
        Label workPointDOut;        
 
        Pen pen;
 
        Timer timer;
 
        Graphics graphics;
        BufferedGraphics bufferedGraphics;
        BufferedGraphicsContext bufferedGraphicsContext;
 
        float ABLenght, MDLenght, height;
 
        _PointMov pointMov;
        _Point
            pointA,
            pointE,
            pointC,
            pointB,
            pointM,
            pointD;
 
        _Line 
            lineEA,
            lineAB,
            lineBC,
            lineBM,
            lineMD;
 
        _Stand standE;
        _Stand standD;
 
        List<string> inputLabelText = new List<string>() { "Ex", "Ey", "Cx", "Cy", "AE", "AB=BC=BM", "MD", "H" };
        List<float> inputTextBoxText = new List<float>() { 110, 60, 85, 80, 12, 25, 50, 45 };
        bool formShow;
 
        List<_Point> workPointDCalkList;
        List<float> tempCalc;
        _Point pointDMinX, pointDMaxX;
        bool calcDWork;
 
        _Point counterPoint;
 
        public Form1()
        {
            InitializeComponent();
            
            ClientSize = new Size(800, 500);
            MinimumSize = new System.Drawing.Size(640, 480);
 
            StartPosition = FormStartPosition.CenterScreen;
 
            #region создаем контролы формы
 
            panel = new Panel();
            panel.Location = new Point(2, 2);
            panel.Height = Height - 2;
            panel.Width = Width - 200;
            panel.BackColor = Color.White;
            Controls.Add(panel);
 
            startButton = new Button();
            startButton.Size = new Size(100, 25);
            startButton.Location = new Point(panel.Width + 2 + (Width - panel.Width) / 2 - startButton.Width / 2, 10);
            startButton.Text = "старт";
            startButton.Click += new EventHandler(start_Click);
            Controls.Add(startButton);
 
            stopButton = new Button();
            stopButton.Size = new Size(100, 25);
            stopButton.Location = new Point(panel.Width + 2 + (Width - panel.Width) / 2 - startButton.Width / 2, 45);
            stopButton.Text = "стоп";
            stopButton.Click += new EventHandler(stop_Click);
            Controls.Add(stopButton);
 
            inputTextBox = new TextBox[countInputControls];
            inputLabel = new Label[countInputControls];
 
            int xTextBox = startButton.Location.X + startButton.Width / 2,
                xLabel = startButton.Location.X-10,
                y = stopButton.Bottom + 10;
 
            for (int i = 0; i < countInputControls; i++)
            {
                TextBox tb = new TextBox();
                tb.Size = new Size(50, 25);
                tb.Location = new Point(xTextBox, y);
                tb.Text = inputTextBoxText[i].ToString();
                
                Label lbl = new Label();
                lbl.AutoSize = true;
                lbl.Text = inputLabelText[i];
                lbl.Location = new Point(xLabel, y);
                
                inputTextBox[i] = tb;
                inputLabel[i] = lbl;
 
                y += 35;
            }
            for (int i = 0; i < countInputControls; i++)
            {
                Controls.Add(inputTextBox[i]);
                Controls.Add(inputLabel[i]);
            }
 
            updateButton = new Button();
            updateButton.Size = new Size(100, 25);
            updateButton.Location = new Point(panel.Width + 2 + (Width - panel.Width) / 2 - updateButton.Width / 2, y);
            updateButton.Text = "обновить";
            updateButton.Click += new EventHandler(update_Click);
            Controls.Add(updateButton);
 
            y += 35;
 
            workPointDOut = new Label();
            workPointDOut.AutoSize = true;
            workPointDOut.TextAlign = ContentAlignment.MiddleCenter;
            workPointDOut.Text = "идет расчет хода \n выходного звена...";
            workPointDOut.Location = new Point(panel.Width + 2 + (Width - panel.Width) / 2 - workPointDOut.Width / 2, y);
            Controls.Add(workPointDOut);
 
            #endregion
 
            pen = new Pen(Color.Red);
 
            timer = new Timer();
            timer.Interval = 1;
            timer.Tick += new EventHandler(timer_Tick);
 
            InitializeGraphics();
 
            pointMov = new _PointMov(0,0, 50, 2, 0.01f, new SolidBrush(Color.Red));
            pointA = new _Point(pointMov.X, pointMov.Y, 0, new SolidBrush(Color.White));
 
            pointE = new _Point(0, 0, 2, new SolidBrush(Color.Red));
            pointC = new _Point(0, 0, 2, new SolidBrush(Color.Red));
            pointB = new _Point(0, 0, 2, new SolidBrush(Color.Green));
            pointM = new _Point(0, 0, 2, new SolidBrush(Color.Green));
            pointD = new _Point(0, 0, 2, new SolidBrush(Color.Green));
 
            lineEA = new _Line(new Pen(Color.Red, 0.5f));
            lineAB = new _Line(new Pen(Color.Green, 0.5f));
            lineBC = new _Line(new Pen(Color.Green, 0.5f));
            lineBM = new _Line(new Pen(Color.Green, 0.5f));
            lineMD = new _Line(new Pen(Color.Green, 0.5f));
 
            //standE = new _Stand(new Point((int)pointE.X, (int)pointE.Y), new Pen(Color.Black, 1));
            workPointDCalkList = new List<_Point>();
            tempCalc = new List<float>();
 
            pointDMinX = new _Point(0, 0, 2, new SolidBrush(Color.Red));
            pointDMaxX = new _Point(0, 0, 2, new SolidBrush(Color.Red));
 
            formShow = true;
        }
 
        private void timer_Tick(object sender,EventArgs e)
        {
            pointMov.CenterX = pointE.X;
            pointMov.CenterY = pointE.Y;
 
            pointMov.Mov();
            pointA.X = pointMov.X;
            pointA.Y = pointMov.Y;
 
            LocationB();
            LocationM();
            LocationD();
 
            lineEA.NewPoints(pointE, pointA);
            lineAB.NewPoints(pointA, pointB);
            lineBC.NewPoints(pointB, pointC);
            lineBM.NewPoints(pointB, pointM);
            lineMD.NewPoints(pointM, pointD);
 
            //*************************************************************************************
            //вот рассчеты
 
            if (calcDWork)
            {
                workPointDOut.Text = "идет расчет хода \n выходного звена...";
                
 
                if (!pointMov.circ)
                {
                    workPointDCalkList.Add(pointD);
 
                    for (int i = 0; i < workPointDCalkList.Count; i++)
                    {
                        tempCalc.Add(workPointDCalkList[i].X);
                    }
 
                    tempCalc.Sort();
 
                    pointDMinX.X = tempCalc[0]; pointDMinX.Y = pointD.Y;
                    pointDMaxX.X = tempCalc[tempCalc.Count - 1]; pointDMaxX.Y = pointD.Y;
 
                    standD.UpdatePoints(new PointF(pointDMinX.X, pointDMinX.Y), new PointF(pointD.X, pointDMaxX.Y));
                }
                else
                {
                    calcDWork = false;
                    workPointDCalkList.Clear();
                }
            }
 
            //**************************************************************************************************
 
            DrawToBuffer();
        }
 
        private void InitializeGraphics()
        {
            graphics = panel.CreateGraphics();
            bufferedGraphicsContext = new BufferedGraphicsContext();
            bufferedGraphics = bufferedGraphicsContext.Allocate(graphics, new Rectangle(0, 0, panel.Width, panel.Height));
            bufferedGraphics.Graphics.PageUnit = GraphicsUnit.Millimeter;
        }
 
        private void DrawToBuffer()
        {
            graphics.PageUnit = GraphicsUnit.Millimeter;
            bufferedGraphics.Graphics.Clear(Color.White);
 
            pointMov.Draw(bufferedGraphics.Graphics);
            pointE.Draw(bufferedGraphics.Graphics);
            pointC.Draw(bufferedGraphics.Graphics);
            pointB.Draw(bufferedGraphics.Graphics);
            pointM.Draw(bufferedGraphics.Graphics);
            pointD.Draw(bufferedGraphics.Graphics);
 
            lineEA.Draw(bufferedGraphics.Graphics);
            lineAB.Draw(bufferedGraphics.Graphics);
            lineBC.Draw(bufferedGraphics.Graphics);
            lineBM.Draw(bufferedGraphics.Graphics);
            lineMD.Draw(bufferedGraphics.Graphics);
 
            standE.Draw(bufferedGraphics.Graphics);
            standD.Draw(bufferedGraphics.Graphics);
 
            bufferedGraphics.Render();
        }
 
        public void start_Click(object sender,EventArgs e)
        {
            updateButton.PerformClick();
            timer.Start();
        }
 
        public void stop_Click(object sender, EventArgs e) 
        {
            timer.Stop();
        }
 
        private void Form1_SizeChanged(object sender, EventArgs e)
        {
            if (FormWindowState.Minimized == WindowState)
            {
                timer.Stop();
            }
 
            if (formShow && timer.Enabled)
            {
                panel.Height = Height - 2;
                panel.Width = Width - 200;
 
                bufferedGraphics = bufferedGraphicsContext.Allocate(graphics, new Rectangle(0, 0, panel.Width, panel.Height));
                bufferedGraphics.Graphics.PageUnit = GraphicsUnit.Millimeter;
 
                startButton.Location = new Point(panel.Width + 2 + (Width - panel.Width) / 2 - startButton.Width / 2, 50);
                stopButton.Location = new Point(panel.Width + 2 + (Width - panel.Width) / 2 - startButton.Width / 2, 75);
 
                int xTextBox = startButton.Location.X + startButton.Width / 2,
                    xLabel = startButton.Location.X - 10,
                    y = stopButton.Bottom + 10;
 
                for (int i = 0; i < countInputControls; i++)
                {
                    inputTextBox[i].Location = new Point(xTextBox, y);
                    inputLabel[i].Location = new Point(xLabel, y);
 
                    y += 35;
                }
 
                updateButton.Location = new Point(panel.Width + 2 + (Width - panel.Width) / 2 - updateButton.Width / 2, y);
            }
        }
 
        public void update_Click(object sender,EventArgs e)
        {
            float Ex, Ey, Cx, Cy, movRadius;
            if (float.TryParse(inputTextBox[0].Text, out Ex)
                && float.TryParse(inputTextBox[1].Text, out Ey)
                && float.TryParse(inputTextBox[2].Text, out Cx)
                && float.TryParse(inputTextBox[3].Text, out Cy)
                && float.TryParse(inputTextBox[4].Text, out movRadius)
                && float.TryParse(inputTextBox[5].Text, out ABLenght)
                && float.TryParse(inputTextBox[6].Text, out MDLenght)
                && float.TryParse(inputTextBox[7].Text, out height))
            {
                pointE.X = Ex;
                pointE.Y = Ey;
                pointC.X = Cx;
                pointC.Y = Cy;
                pointMov.Radius = movRadius;
 
                standE = new _Stand(pointE, new Pen(Color.Black, 0.5f));
                standD = new _Stand(pointDMinX, pointDMaxX, true, new Pen(Color.Black, 0.5f));
 
                calcDWork = true;
                pointMov.ResetCirc();
            }
            else
            {
                timer.Stop();
                MessageBox.Show("ошибка ввода", "ошибка");
            }
        }
 
        #region расчет координат движущихся точек
 
        /// <summary>
        /// расчет координат точки B
        /// </summary>
        void LocationB() 
        {
            float sumFloat = (pointA.X - pointC.X) * (pointA.X - pointC.X) + (pointA.Y - pointC.Y) * (pointA.Y - pointC.Y);
            double sumDouble = (double)sumFloat;
            double SqrtSumDouble = Math.Sqrt(sumDouble);
            float SqrtSumFloat = (float)SqrtSumDouble;
 
            if (SqrtSumFloat > Math.Abs(2 * ABLenght) || SqrtSumFloat < 0)
            {
                timer.Stop();
                MessageBox.Show("Разрыв в точке В");
            }
            else
            {
                float b = (SqrtSumFloat * SqrtSumFloat) / (2 * SqrtSumFloat);
                float a = SqrtSumFloat - b;
                double h_ = ABLenght * ABLenght - b * b;
                double SqrtH_ = Math.Sqrt(h_);
                float Height = (float)SqrtH_;
                float x = pointA.X + (pointC.X - pointA.X) / (SqrtSumFloat / a);
                float y = pointA.Y + (pointC.Y - pointA.Y) / (SqrtSumFloat / a);
                pointB.X = x + (y - pointC.Y) * Height / b;
                pointB.Y = y - (x - pointC.X) * Height / b;
            }
        }
 
        /// <summary>
        /// расчет координат точки M
        /// </summary>
        void LocationM()
        {
            //нахождение длины отрезка AM(будущий радиус окружности с центром в точке А)
            float AMLenght;
            double SqrAMDouble = 2.10467f * ABLenght * ABLenght;
            double AM = Math.Sqrt(SqrAMDouble);
            AMLenght = (float)AM;
 
            float sumFloat = (pointA.X - pointB.X) * (pointA.X - pointB.X) + (pointA.Y - pointB.Y) * (pointA.Y - pointB.Y);
            double sumDouble = (double)sumFloat;
            double SqrtSumDouble = Math.Sqrt(sumDouble);
            float SqrtSumFloat = (float)SqrtSumDouble;
            float b = (ABLenght * ABLenght - AMLenght * AMLenght + SqrtSumFloat * SqrtSumFloat) / (2 * SqrtSumFloat);
            float a = SqrtSumFloat - b;
            double h_ = ABLenght * ABLenght - b * b;
            double SqrtH_ = Math.Sqrt(h_);
            float Height = (float)SqrtH_;
            float x = pointA.X + (pointB.X - pointA.X) / (SqrtSumFloat / a);
            float y = pointA.Y + (pointB.Y - pointA.Y) / (SqrtSumFloat / a);
            pointM.X = x + (y - pointB.Y) * Height / b;
            pointM.Y = y - (x - pointB.X) * Height / b;
        }
 
        /// <summary>
        /// расчет координат точки D
        /// </summary>
        void LocationD()
        {
            pointD.Y = pointC.Y - height;
            float b = pointD.Y;
            if (b < pointM.Y - MDLenght && b > pointM.Y + MDLenght)
            {
                timer.Stop();
                MessageBox.Show("разрыв в точке D");
            }
            else
            {
                float c = -MDLenght * MDLenght;
                double Discrim = -4 * c;
                double SqrtDiscrimDouble = Math.Sqrt(Discrim);
                float SqrtDiscrimFloat = (float)SqrtDiscrimDouble;
                if (Discrim <= 0)
                {
                    timer.Stop();
                    MessageBox.Show("разрыв в точке D");
                }
                else
                {
                    float k = 0;
                    float a = 1 + k * k;
                    float bb = -2 * pointM.X + 2 * k * b - 2 * k * pointM.Y;
                    float cc = pointM.X * pointM.X + b * b - 2 * b * pointM.Y + pointM.Y * pointM.Y - MDLenght * MDLenght;
                    double Discr = bb * bb - 4 * a * cc;
                    double SqrtDiscrDouble = Math.Sqrt(Discr);
                    float SqrtDiscrFloat = (float)SqrtDiscrDouble;
                    pointD.X = (-bb - SqrtDiscrFloat) / (2 * a);
                    pointD.Y = k * pointD.X + b;
                }
            }
        }
 
        #endregion
    }
 
    #region классы
 
    public class _PointMov 
    {
        float x, y;
        float centerX, centerY, radius;
 
        Brush brush;
 
        float angle;
 
        float velocity;
 
        int size;
 
        public bool circ;
 
        /// <summary>
        /// контруктор
        /// </summary>
        /// <param name="centerX"> координата X центра окружности, по которой движется точка </param>
        /// <param name="centerY"> координата Y центра окружности, по которой движется точка </param>
        /// <param name="radius"> радиус окружности, по которой движется точка </param>
        /// <param name="size"> высота точки = ширина точки = size </param>
        /// <param name="velocity"> скорость точки </param>
        /// <param name="brush"> кисть, которой рисуется точка </param>
        public _PointMov(int centerX, int centerY, int radius, int size,float velocity, Brush brush)
        {
            this.centerX = centerX;
            this.centerY = centerY;
            this.radius = radius;
            this.velocity = velocity;
            this.brush = brush;
 
            this.size = size;
        }
 
        /// <summary>
        /// координата X центра окружности, по которой движется точка
        /// </summary>
        public float CenterX
        {
            get { return centerX; }
            set
            {
                centerX = value;
                x = (float)Math.Cos(angle) * radius + centerY;
            }
        }
 
        /// <summary>
        /// координата Y центра окружности, по которой движется точка
        /// </summary>
        public float CenterY
        {
            get { return centerY; }
            set
            {
                centerY = value;
                y = (float)Math.Sin(angle) * radius + centerY;
            }
        }
 
        /// <summary>
        /// радиус окружности, по которой движется точка
        /// </summary>
        public float Radius
        {
            get { return radius; }
            set { radius = value; }
        }
 
        /// <summary>
        /// кисть, которой рисуется точка
        /// </summary>
        public Brush Brush
        {
            get { return brush; }
            set { brush = value; }
        }
 
        /// <summary>
        /// текущий угол точки
        /// </summary>
        public float Angle
        {
            get { return angle; }
            set { angle = value; }
        }
 
        /// <summary>
        /// координата X точки
        /// </summary>
        public float X
        {
            get { return x; }
        }
 
        /// <summary>
        /// координата Y точки
        /// </summary>
        public float Y
        {
            get { return y; }
        }
 
        /// <summary>
        /// угловая скорость точки
        /// </summary>
        public float Velocity
        {
            get { return velocity; }
            set { velocity = value; }
        }
 
        /// <summary>
        /// шаг точки
        /// </summary>
        public void Mov()
        {
            angle += velocity;
 
            if (angle > 2f * Math.PI)
            {
                angle -= 2f * (float)Math.PI;
                circ = true;
                
            }
            x = (float)Math.Cos(angle) * radius + centerX;
            y = (float)Math.Sin(angle) * radius + centerY;
        }
 
        /// <summary>
        /// сбрасываем флаг оборота точки
        /// </summary>
        public void ResetCirc()
        {
            circ = false;
        }
 
        /// <summary>
        /// рисование точки
        /// </summary>
        /// <param name="graphics"> графический объект </param>
        public void Draw(Graphics graphics)
        {
            graphics.FillEllipse(brush, x - size / 2, y - size / 2, size, size);
        }
    }
 
    public class _Point
    {
        float x, y;
        int size;
 
        Brush brush;
 
        /// <summary>
        /// конструктор
        /// </summary>
        /// <param name="x"> координата X точки </param>
        /// <param name="y"> координата Y точки </param>
        /// <param name="size"> ширина точки = высота точки = size </param>
        /// <param name="brush"> кисть, которой рисуется точка </param>
        public _Point(float x, float y,int size, Brush brush)
        {
            this.x = x;
            this.y = y;
            this.size = size;
            this.brush = brush;
        }
 
        /// <summary>
        /// координата X точки
        /// </summary>
        public float X
        {
            get { return x; }
            set { x = value; }
        }
 
        /// <summary>
        /// координата Y точки
        /// </summary>
        public float Y
        {
            get { return y; }
            set { y = value; }
        }
 
        /// <summary>
        /// рисуем точку
        /// </summary>
        /// <param name="graphics"> графический объект </param>
        public void Draw(Graphics graphics)
        {
            graphics.FillEllipse(brush, x - size / 2, y - size / 2, size, size);
        }
    }
 
    public class _Line
    {
        Pen pen;
 
        float x1, y1, x2, y2;
 
        _Point point1, point2;
 
        /// <summary>
        /// конструктор
        /// </summary>
        /// <param name="pen"> перо, которым рисуется точка </param>
        public _Line(Pen pen)
        {
            this.pen = pen;
        }
 
        /// <summary>
        /// перо, которым рисуется линия
        /// </summary>
        public Pen MyPen
        {
            get { return pen; }
            set { pen = value; }
        }
 
        /// <summary>
        /// обновление точек???
        /// </summary>
        /// <param name="point1"> точка 1 </param>
        /// <param name="point2"> точка 2 </param>
        public void NewPoints(_Point point1,_Point point2)
        {
            this.point1 = point1;
            this.point2 = point2;
        }
 
        /// <summary>
        /// рисуем линию
        /// </summary>
        /// <param name="graphics"> графический объект </param>
        public void Draw(Graphics graphics)
        {
            graphics.DrawLine(pen, point1.X, point1.Y, point2.X, point2.Y);
        }
    }
 
    public class _Stand
    {
        Pen pen;
 
        PointF point1, point2;
 
        bool twoPoints;
 
        bool goriz;
 
        PointF[] triangle;
 
        /// <summary>
        /// конструктор
        /// </summary>
        /// <param name="point"> точка опоры </param>
        /// <param name="pen"> перо, которым рисуется опора </param>
        public _Stand(_Point point,Pen pen)
        {
            this.point1 = new PointF(point.X, point.Y);
            this.pen = pen;
 
            triangle = new PointF[4] { new PointF(point.X, point.Y), new PointF(point.X + 2.5f, point.Y + 2.5f), new PointF(point.X - 2.5f, point.Y + 2.5f), new PointF(point.X, point.Y) };
        }
 
        /// <summary>
        /// конструктор
        /// </summary>
        /// <param name="point1"> точка опоры 1 </param>
        /// <param name="point2"> точка опоры 2 </param>
        /// <param name="pen"> перо, которым рисуется опора </param>
        public _Stand(_Point point1, _Point point2,bool goriz, Pen pen)
        {
            this.point1 = new PointF(point1.X, point1.Y);
            this.point2 = new PointF(point2.X, point2.Y);
            this.pen = pen;
 
            this.goriz = goriz;
 
            twoPoints = true;
        }
 
        /// <summary>
        /// обновление параметров для опоры из 2х точек
        /// </summary>
        /// <param name="point1"> точка 1 </param>
        /// <param name="point2"> точка 2 </param>
        public void UpdatePoints(PointF point1,PointF point2)
        {
            this.point1 = point1;
            this.point2 = point2;
        }
 
        /// <summary>
        /// рисует опору
        /// </summary>
        /// <param name="graphics"> графический объект </param>
        public void Draw(Graphics graphics)
        {
            if (twoPoints)
            {
                if (goriz)
                {
                    graphics.DrawLine(pen, point1.X, point1.Y - 4f, point2.X, point2.Y - 4f);
                    graphics.DrawLine(pen, point1.X, point1.Y + 4f, point2.X, point2.Y + 4f);
                }
                else
                {
                    graphics.DrawLine(pen, point1.X - 4f, point1.Y, point2.X - 4f, point2.Y);
                    graphics.DrawLine(pen, point1.X + 4f, point1.Y, point2.X + 4f, point2.Y);
                }
            }
            else
            {
                graphics.DrawLines(pen, triangle);
                graphics.DrawLine(pen, point1.X - 3.5f, point1.Y + 2.5f, point1.X + 3.5f, point1.Y + 2.5f);
                int countLines = 7;
 
                float x = point1.X - 3.5f, y1 = point1.Y + 4.5f, y2 = point1.Y + 2.5f;
 
                for (int i = 0; i < countLines; i++)
                {
                    graphics.DrawLine(pen, x, y1, x + 0.5f, y2);
                    x += 1f;
                }
            }
        }
    }
 
    #endregion
}