Подставить в программу фрактал Мандельброта

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Threading;
using System.Diagnostics;
 
namespace PikouveraBiomorphs
{
    /// <summary>
    /// Основная форма приложения
    /// </summary>
    public partial class MainForm : Form
    {
 
        /// <summary>
        /// Коэффициенты для выхода из основного цикла
        /// </summary>
        public const int MAX = 200;
 
        /// <summary>
        /// Будем хранить время
        /// </summary>
        private Point TimeOut = new Point();
 
        /// <summary>
        /// Элементы
        /// </summary>
        private List<Rectangle> Items = new List<Rectangle>();
 
        /// <summary>
        /// Координаты центра
        /// </summary>
        private PointF Center;
 
        /// <summary>
        /// Используем как комплексное число
        /// </summary>
        private PointF Z;
 
        /// <summary>
        /// Используем как комплексное число
        /// </summary>
        private PointF T;
 
        /// <summary>
        /// Используем как комплексное число
        /// </summary>
        private PointF C = new PointF(0.5f, 0f);
 
        /// <summary>
        /// Масщтаб
        /// </summary>
        private float Zoom = 1f;
 
        /// <summary>
        /// Кнопка мыши вниз координаты
        /// </summary>
        private Point MdTmp = new Point();
 
        // Сдвиги
        private int OffSetX = 0;
        private int OffSetY = 0;
 
        /// <summary>
        /// Флаг - идет расчет
        /// </summary>
        private bool DoCalc = true;
 
        /// <summary>
        /// Обьект блокировки
        /// </summary>
        private object ObjLock = new object();
 
 
        /// <summary>
        /// Окончание расчета
        /// </summary>
        private event EventHandler Invldok = (s, o) => { };
 
 
        /// <summary>
        /// Основная форма приложения
        /// </summary>
        public MainForm()
        {
            InitializeComponent();
 
            // Настройка стиля (ускоряет отрисовку)
            SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint | ControlStyles.OptimizedDoubleBuffer, true);
 
            Invldok += (s, o) => { Invalidate(); };
            MouseWheel += MainForm_MouseWheel;
     CalcTh();
        }
 
        /// <summary>
        /// Расчет
        /// </summary>
        private void CalcNo()
        {
            //lock (ObjLock)
            //{
            if (!DoCalc) { return; }
 
            DoCalc = false;
 
            // Очистим элементы
            Items.Clear();
 
            // Засекаем время
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            // DateTime dtn = DateTime.Now;
 
            // Координаты центра
            var xc = ClientSize.Width / 2f;
            var yc = ClientSize.Height / 2f;
 
            var cof = (float)ClientSize.Width / (float)ClientSize.Height;
 
            Center = new PointF(xc, yc);
 
            var osX = ((float)OffSetX / (float)ClientSize.Width);
            var osY = ((float)OffSetY / (float)ClientSize.Height);
 
            // Основной цикл по всем точкам комплексной плоскости
            for (float x = -cof; x <= cof; x += 0.003f)
            {
                for (float y = -1f; y <= 1f; y += 0.003f)
                {
                    Z.X = x * Zoom + osX * Zoom;
                    Z.Y = y * Zoom - osY * Zoom;
 
                    // Итерируем функцию f(z) = z^3 + c
                    while (Math.Abs(Z.X) < MAX && Math.Abs(Z.Y) < MAX)
                    {
                        T.X = Z.X;
                        T.Y = Z.Y;
 
                        Z.X = (float)Math.Pow(T.X, 3f) - (3f * T.X * (float)Math.Pow(T.Y, 2f)) + C.X;
                        Z.Y = (3f * (float)Math.Pow(T.X, 2f) * T.Y) - (float)Math.Pow(T.Y, 3f) + C.Y;
                    }
 
                    // Вычисление элементов фрактала
                    if ((Math.Abs(Z.X) < 400) || (Math.Abs(Z.Y) < 10000))
                    {
                        int xt = ChangeCoordinates(x, 0);
                        int yt = ChangeCoordinates(y, 1);
 
                        // Исключаем повторы (оптимизация)
                        if (xt > 0 && xt < ClientSize.Width && yt > 0 && yt < ClientSize.Height)
                        {
                            // BitmapTmp.SetPixel(xt, yt, Color.Red);
                            Items.Add(new Rectangle(xt, yt, 2, 2));
                        }
                    }
                }
            }
 
            // Время расчета (конечное)
            //var tstRes = DateTime.Now - dtn;
            var tstRes = stopWatch.Elapsed;
 
            TimeOut = new Point(tstRes.Seconds, tstRes.Milliseconds);
 
            DoCalc = true;
 
            Invldok(this, EventArgs.Empty);
            //}
        }
 
        /// <summary>
        /// Расчет
        /// </summary>
        private void Calc()
        {
            if (!DoCalc) { return; }
 
            DoCalc = false;
 
            // Очистим элементы
            Items.Clear();
// ЗАСЕКАЕМ ВРЕМЯ
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
 
            // Координаты центра
            var xc = ClientSize.Width / 2f;
            var yc = ClientSize.Height / 2f;
 
            var cof = (float)ClientSize.Width / (float)ClientSize.Height;
 
            Center = new PointF(xc, yc);
 
            var osX = ((float)OffSetX / (float)ClientSize.Width);
            var osY = ((float)OffSetY / (float)ClientSize.Height);
 
            // Основной цикл по всем точкам комплексной плоскости
            float x = -cof;
 
            var CW = ClientSize.Width;
            var CH = ClientSize.Height;
 
            var zoom = Zoom;
 
            // РАССПАРАЛЛЕЛИВАНИЕ ЦИКЛА ДЛЯ ВЫЧИСЛЕНИЯ ЭЛЕМЕНТОВ ФРАКТАЛА
            Parallel.For(0, 2800, f0 =>
            {
                var tT = T;
                var tZ = Z;
                var tC = C;
 
                x += 0.0009f;
 
                for (float y = -1f; y <= 1f; y += 0.0031f)
                {
                    tZ.X = x * zoom + osX * zoom;
                    tZ.Y = y * zoom - osY * zoom;
 
                    // Итерируем функцию f(z) = z^3 + c
                    while (Math.Abs(tZ.X) < MAX && Math.Abs(tZ.Y) < MAX)
                    {
                        tT.X = tZ.X;
                        tT.Y = tZ.Y;
 
                        tZ.X = (float)Math.Pow(tT.X, 3f) - (3f * tT.X * (float)Math.Pow(tT.Y, 2f)) + tC.X;
                        tZ.Y = (3f * (float)Math.Pow(tT.X, 2f) * tT.Y) - (float)Math.Pow(tT.Y, 3f) + tC.Y;
                    }
 
                    // Вычисление элементов фрактала
                    if ((Math.Abs(tZ.X) < 400) || (Math.Abs(tZ.Y) < 10000))
                    {
                        int xt = ChangeCoordinates(x, 0);
                        int yt = ChangeCoordinates(y, 1);
 
                        // Исключаем повторы (оптимизация)
                        if (xt > 0 && xt < CW && yt > 0 && yt < CH)
                        {
                            lock (ObjLock) { Items.Add(new Rectangle(xt, yt, 2, 2)); }
                        }
                    }
                }
            }
                        );
 
            // Время расчета (конечное)
            var tstRes = stopWatch.Elapsed;
            TimeOut = new Point(tstRes.Seconds, tstRes.Milliseconds);
 
            DoCalc = true;
 
            Invldok(this, EventArgs.Empty);
        }
 
        /// <summary>
        /// Расчет
        /// </summary>
        private void Calc2()
        {
            lock (ObjLock)
            {
                if (!DoCalc) { return; }
 
                DoCalc = false;
 
                // Очистим элементы
                Items.Clear();
 
                // Засекаем время
                Stopwatch stopWatch = new Stopwatch();
                stopWatch.Start();
 
                // Координаты центра
                var xc = ClientSize.Width / 2f;
                var yc = ClientSize.Height / 2f;
 
                var cof = (float)ClientSize.Width / (float)ClientSize.Height;
 
                Center = new PointF(xc, yc);
 
                var osX = ((float)OffSetX / (float)ClientSize.Width);
                var osY = ((float)OffSetY / (float)ClientSize.Height);
// Основной цикл по всем точкам комплексной плоскости
                for (float x = -cof; x <= cof; x += 0.007f)
                {
                    for (float y = -1f; y <= 1f; y += 0.007f)
                    {
                        Z.X = x * Zoom + osX * Zoom;
                        Z.Y = y * Zoom - osY * Zoom;
 
                        // Итерируем функцию f(z) = z^3 + c
                        while (Math.Abs(Z.X) < MAX && Math.Abs(Z.Y) < MAX)
                        {
                            T.X = Z.X;
                            T.Y = Z.Y;
 
                            Z.X = (float)Math.Pow(T.X, 3f) - (3f * T.X * (float)Math.Pow(T.Y, 2f)) + C.X;
                            Z.Y = (3f * (float)Math.Pow(T.X, 2f) * T.Y) - (float)Math.Pow(T.Y, 3f) + C.Y;
                        }
 
                        // Вычисление элементов фрактала
                        if ((Math.Abs(Z.X) < 400) || (Math.Abs(Z.Y) < 10000))
                        {
                            int xt = ChangeCoordinates(x, 0);
                            int yt = ChangeCoordinates(y, 1);
 
                            // Исключаем повторы (оптимизация)
                            if (xt > 0 && xt < ClientSize.Width && yt > 0 && yt < ClientSize.Height)
                            {
                                // BitmapTmp.SetPixel(xt, yt, Color.Red);
                                Items.Add(new Rectangle(xt, yt, 1, 1));
                            }
                        }
                    }
                }
 
                // Время расчета (конечное)
                var tstRes = stopWatch.Elapsed;
                TimeOut = new Point(tstRes.Seconds, tstRes.Milliseconds);
 
                DoCalc = true;
 
                Invldok(this, EventArgs.Empty);
            }
        }
 
        /// <summary>
        /// Асинхронны - расчет вот здесь считаем, используя пул потоков
        /// </summary>
        private void CalcTh()
        {
            if (radioButton1.Checked)
            {
                Calc();
            }
            else if (radioButton2.Checked)
            {
                CalcNo();
            }
            else if (radioButton3.Checked)
            {
                ThreadPool.QueueUserWorkItem(f => { Calc2(); });
            }
        }
 
        /// <summary>
        /// Перевод координат
        /// </summary>
        /// <param name="a"></param>
        /// <param name="isY"></param>
        /// <returns></returns>
        public int ChangeCoordinates(float a, int isY)
        {
            var tr = (ClientSize.Height > ClientSize.Width ? ClientSize.Height : ClientSize.Width) / 2;
 
            return (int)(isY == 1 ? (Center.Y - a * tr) : (Center.X + a * tr));
        }
 
        /// <summary>
        /// Скролл
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MainForm_MouseWheel(object sender, MouseEventArgs e)
        {
            if (!DoCalc) { return; }
 
            var tz = Zoom / 10f;
 
            if (e.Delta > 0) { Zoom += tz; CalcTh(); }
            else if (e.Delta < 0) { Zoom -= tz; CalcTh(); }
        }
 
        /// <summary>
        /// Двойной клик по форме
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MainForm_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            var str = "Не пересчитывалось!";
 
            if (e.Button == MouseButtons.Left) { CalcTh(); str = "Использование Task."; }
            else if (e.Button == MouseButtons.Right) { Calc(); str = "В UI потоке."; }
 
            MessageBox.Show(str);
        }
 
        /// <summary>
        /// Игнорим отрисовку фона для ускорения (оптимизация)
        /// </summary>
        /// <param name="e"></param>
        protected override void OnPaintBackground(PaintEventArgs e)
        {
 
        }
 
        /// <summary>
        /// Кнопка мыши вниз
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MainForm_MouseDown(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                MdTmp = new Point(e.X + ClientSize.Width / 2, e.Y + ClientSize.Height / 2);
            }
        }
 
        /// <summary>
        /// Кнопка мыши вверх
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MainForm_MouseUp(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                OffSetX += MdTmp.X - (e.X + ClientSize.Width / 2);
                OffSetY += MdTmp.Y - (e.Y + ClientSize.Height / 2);
 
                CalcTh();
            }
        }
 
        /// <summary>
        /// Отрисовка
        /// </summary>
        /// <param name="e"></param>
        protected override void OnPaint(PaintEventArgs e)
        {
            var g = e.Graphics;
 
            // Ускорит отрисовку (оптимизация)
            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighSpeed;
            g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.Low;
 
            // Использование FillRectangles работает быстрее чем цикл
            lock (ObjLock)
            {
                if (Items.Count > 0)
                {
                    using (var br = new SolidBrush(Color.FromArgb(200, 255, 0, 0)))
                    {
                        foreach (var it in Items)
                        {
                            g.FillRectangle(br, it);
                        }
 
                    }
                }
            }
 
            using (var fnt = new Font("", 16))
            {
                g.DrawString($"{TimeOut.X} : {TimeOut.Y}", fnt, Brushes.White, new Point(5, 5));
            }
 
        }
 
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void buttonDo_Click(object sender, EventArgs e)
        {
            CalcTh();
        }
    }
}