Bezier & Hermite (kommentekkel)

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;

namespace grafikaBeadando
{
    public partial class Form1 : Form
    {

        /*
         * BÉZIER:
         * - egy lista, amiben a pontokat tároljuk
         * - 7 elemig megyünk, a 4.-et és a 7.-et külön vizsgáljuk
         * - minden 5. elemet legeneráljuk
         * - 4.-nél görberajzolunk, majd generálunk
         * - pont kirajzolás a két if között
         * - 7.-nél 0-3 törlés, majd rajzolás
         * - 5. pont generálása, pont kirajzolás
         * - újabb 0-3 törlés, hogy ne maradjon csak a csatlakozó elem, meg a generált
         * - kezdődik előről
         *
         * HERMITE:
         * - ugyanaz a lista, 4 pontot várunk
         * - ha megvan a 4 pont, egy hermitpont objektumba vesszük fel őket (első, utolsó, második, harmadik)
         * - hermiterajzol fgv, benne számol fgv (-> polinom)
         * - pontok kirajzoltatása (float x, float y - paraméterezés: kezd, vég, kezdirány-kezd, vég-végirány) (!!!!!!!!!)
         * - egy elemet hagyunk (RemoveRange(0,3), vagy egyesével töröljük, forciklus, vagy bármi
         * - innen kezdődik az egész előről
         *
         */

        Graphics g;
        List<PointF> pontok; // kattintás- és kontrollpontok
        int DB = 200; // Görbe pontjai

        // Tartomány (próbáld ki nem 0-1 határokkal. mókás dolgok születnek belőle:D)
        float A = 0;
        float B = 1;

        List<HermitPontok> hermitPontok; // kattintáspontok hermitgörbéhez

        public Form1()
        {
            InitializeComponent();
            g = CreateGraphics();
            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
            pontok = new List<PointF>();
            hermitPontok = new List<HermitPontok>();
            MouseUp += Form1_MouseUp;
        }

        void Form1_MouseUp(object sender, MouseEventArgs e)
        {
            if (radioBezier.Checked) //  Bézier-görbe!
            {
                if (pontok.Count < 7) // 4 és 7 pontnál rajzolunk!
                {
                    pontok.Add(e.Location); // listához hozzáadjuk a pontot
                    if (pontok.Count == 4)
                    {
                        BezierGörbeRajzol(); // ezt itt már össze is kötjük
                        // A 4. pontot nekünk kell kiszámolni! (Q1)
                        pontok.Add(new PointF(pontok[2].X + 2 * (pontok[3].X - pontok[2].X), pontok[2].Y + 2 * (pontok[3].Y - pontok[2].Y)));
                    }
                    PontokRajzol(); // a pontokat minden esetben kirajzoljuk! (átláthatóság miatt)

                    if (pontok.Count == 7) // megvan a 7 pont
                    {
                        pontok.RemoveRange(0, 3); // meghagyunk 4 pontot
                        BezierGörbeRajzol(); //...és ezeket kirajzoljuk
                        pontok.Add(new PointF(pontok[2].X + 2 * (pontok[3].X - pontok[2].X), pontok[2].Y + 2 * (pontok[3].Y - pontok[2].Y)));
                        PontokRajzol(); // 5. pont generálása!
                        pontok.RemoveRange(0, 3); // meghagyunk 1 (vagyis 2) pontot, amiről fut tovább a görbe (csatlakozik)
                    }
                }
            }

            else // Hermit-görbe!
            {
                pontok.Add(e.Location); // Listához hozzáadjuk
                PontokRajzol();
                if (pontok.Count == 4) // Ha megvan 4, ahogy a feladat kérte, létrehozunk egy hermitgörbe objektumot (lap alja!)
                {
                    hermitPontok.Add(new HermitPontok(pontok[0], pontok[3], pontok[1], pontok[2])); //...hozzáadjuk a 4 pontot..
                    // FONTOS A SORREND. első, utolsó, második, harmadik. !!
                    HermitGörbeRajzol(); //...és kirajzoljuk.
                    pontok.RemoveRange(0, 3); // egy elemet hagyunk, innen fog csatlakozni (nem volt kikötve csatlakozással kapcsolatban semmi, szóval jó így is)
                }
            }
        }

        void HermitGörbeRajzol()
        {
            foreach (var pont in hermitPontok) // Végig a listán...
            {
                for (float u = 0; u <= 1; u += 0.01f) // A megadott határok között (jelen esetben 0 és 1)
                {
                    // Az x,y koordináták kiszámítása polinomiálisan
                    float x = Képlet(pont.kezd.X, pont.vég.X, pont.kezdirány.X - pont.kezd.X, pont.vég.X - pont.végirány.X, u);
                    float y = Képlet(pont.kezd.Y, pont.vég.Y, pont.kezdirány.Y - pont.kezd.Y, pont.vég.Y - pont.végirány.Y, u);
                    g.FillEllipse(Brushes.SeaGreen, x - 2, y - 2, 4, 4);
                }
            }
        }

        float Képlet(float a0, float a1, float a2, float a3, float u) // "Végeredmény" (ilyen képlet lesz megadva a dolgozatban)
        {
            float x = a0 * (2 * u * u * u - 3 * u * u + 1) + a1 * (-2 * u * u * u + 3 * u * u) + a2 * (u * u * u - 2 * u * u + u) + a3 * (u * u * u - u * u);
            return x;
        }

        void BezierGörbeRajzol()
        {
            float h = Math.Abs(B - A) / DB; // lépésköz
            float u = A;
            PointF[] görbepontjai = new PointF[DB + 1];
            for (int i = 0; i < görbepontjai.Length; i++) // Ezek a pontok alkotják a görbét
            {
                görbepontjai[i] = Bezier(u); // Kiszámolunk minden egyes pontot
                u += h; // növeljük az átadott értéket (u) a lépésközzel (h)
            }
            g.DrawLines(Pens.BlueViolet, görbepontjai.ToArray());
        }

        PointF Bezier(float u)
        {
            int n = pontok.Count - 1;
            PointF p = new PointF();
            for (int i = 0; i < pontok.Count; i++)
            {
                float b = Bernstein(i, n, u); // a varázslat itt történik (Bernstein-polinom)
                p.X += pontok[i].X * b; // meg kell szorozni!
                p.Y += pontok[i].Y * b; // ezt is meg kell szorozni!
            }
            return p; //...és elkészült egy újabb pontja a Bézier-görbének!
        }

        float Bernstein(int i, int n, float u)
        {
            float x = (float)(N_K(n, i) * ((i == 0) ? 1 : Math.Pow(u, i)) * ((n - i == 0) ? 1 : Math.Pow(1 - u, n - i)));
            return x;
            // Megj.: Ez csak annyi, hogyha i=0 vagy n-i=0, akkor ne számoljon hatványt, annak az értéke 1. (? : operátor)
        }

        int N_K(int n, int k)
        {
            int x = Fakt(n) / (Fakt(k) * Fakt(n - k));
            return x;
        }

        int Fakt(int n)
        {
            int x = 1;
            for (int i = 1; i <= n; i++)
            {
                x *= i;
            }
            return x;
        }

        void PontokRajzol()
        {
            foreach (var p in pontok)
            {
                g.FillEllipse(Brushes.Red, p.X - 3, p.Y - 3, 6, 6);
            }
        }

        private void radioHermite_CheckedChanged(object sender, EventArgs e)
        {
            // Ürítés! Törlünk mindent!
            Invalidate();
            Update();
            pontok.Clear();
            hermitPontok.Clear();
        }
    }

    public class HermitPontok
    {
        public PointF kezd, vég, kezdirány, végirány;
        public HermitPontok(PointF k, PointF v, PointF ki, PointF vi)
        {
            kezd = k;
            vég = v;
            kezdirány = ki;
            végirány = vi;
        }
    }
}