//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop
#include <math.h>
#include <math.hpp>
#include <iostream.h>
#include <vector>

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;

int Nk=3;

class Punkt2D{

public:
        double x,y;
        Punkt2D();
        Punkt2D(double x, double y);
};

class Punkt3D{

public:
        double x, y, z;

        Punkt3D();
        Punkt3D(double x, double y, double z);

};
double toRad(int kat) {return (M_PI*kat/360);}
double silnia(double x);
double newton(double n, double k);
double breinstain(double n, double k, double u);
double trojkat(double r, double s, double t);       \
double bernstein3(int n, int i, int j, int k, double r, double s, double t);
/* funkcje do okienkowania*/
double transformX1(double x, double width, double minX, double maxX);
double transformY1(double y, double width, double height, double minX, double maxX, double minY, double maxY);
double transformX2 (double x, double width, double height, double minX, double maxX, double minY, double maxY);
double transformY2 (double y, double height, double minY, double maxY);
double transformX(double x, double width, double minX, double maxX);
double transformY(double y, double height, double minY, double maxY);

Punkt2D::Punkt2D(){
        x=0;
        y=0;
}

Punkt2D::Punkt2D(double x, double y){
        this->x=x;
        this->y=y;
}

Punkt3D::Punkt3D(){
        x=0;
        y=0;
        z=0;
}

Punkt3D::Punkt3D(double x, double y, double z){
        this->x=x;
        this->y=y;
        this->z=z;
}

double silnia(double x){
        double wynik=1;
        for(int i=1; i<=x; i++)
                wynik*=i;
        return wynik;
}

double newton(double n, double k) {
        return (silnia(n)/(silnia(k)*silnia(n-k)));
}

Punkt2D rzutPerspektywiczny(Punkt3D p, double d)
{
        Punkt2D punkt;
        punkt.x = d*p.z/(p.z+d);
        punkt.y = d*p.y/(p.z+d);
        return punkt;
}
//---------------------------------------------------------------------------

Punkt2D rzutOrtogonalny(Punkt3D p, double alfa, double fi)
{
        Punkt2D punkt;
      //  punkt.x = p.x;
       // punkt.y = p.y;
       // return punkt;
        double alfaa=toRad(alfa);
        double fia=toRad(fi);
        double r=p.z*1/tan(alfaa);
        punkt.x=p.x+r*cos(fia);
        punkt.y=p.y+r+sin(alfaa);
        return punkt;
}

// wielomian breinstaina u E [0,1]
double breinstain(double n, double k, double u){
        if(u==0)
                return 0;
        return newton(n, k)*pow(u, k)*pow((1-u), (n-k));
}

double transformX1(double x, double width, double minX, double maxX)
{
        double xs = (width/(maxX - minX))*(x - minX);
        return xs;
}

double transformY1(double y, double width, double height, double minX, double maxX, double minY, double maxY)
{
        double ys = height/2 + (width/(maxX - minX))*(y - (minY + maxY)/2);
        return ys;
}

double transformX2 (double x, double width, double height, double minX, double maxX, double minY, double maxY)
{
        double xs =  width/2 + (height/(maxY - minY))*(x - (minX + maxX)/2);
        return xs;
}

double transformY2 (double y, double height, double minY, double maxY)
{
        double ys = (height/(maxY - minY))*(y - minY);
        return ys;
}

double transformX(double x, double width, double minX, double maxX)
{
        double xs = width*((x-minX)/(maxX - minX));
        return xs;
}

double transformY(double y, double height, double minY, double maxY)
{
        double ys = height*((y-minY)/(maxY - minY));
        return ys;
}

double trojkat(int n, int i, int j, int k, double r, double s, double t){
        //współrzędne barycentryczne r s t
        double wynik=0;

        double jeden, dwa, trzy;
                if(r==0)
                        jeden=0;
                else
                        jeden=pow(r,i);

                if(s==0)
                        dwa=0;
                else
                        dwa=pow(s,j);

                if(t==0)
                        trzy=0;
                else
                        trzy=pow(t,k);

                wynik=((silnia(n))/(silnia(i)*silnia(j)*silnia(k)))*jeden*dwa*trzy;
        return wynik;
}

//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------



void __fastcall TForm1::Button1Click(TObject *Sender)
{
        Punkt3D *tab = new Punkt3D[Nk];

        Punkt3D tablica[3][3][3];
        tablica[2][0][0].x=0;
        tablica[2][0][0].y=0;
        tablica[2][0][0].z=0;
        tablica[1][1][0].x=2;
        tablica[1][1][0].y=2;
        tablica[1][1][0].z=0;
        tablica[0][2][0].x=4;
        tablica[0][2][0].y=0;
        tablica[0][2][0].z=0;
        tablica[1][0][1].x=1;
        tablica[1][0][1].y=4;
        tablica[1][0][1].z=2;
        tablica[0][1][1].x=3;
        tablica[0][1][1].y=2;
        tablica[0][1][1].z=2;
        tablica[0][0][2].x=2;
        tablica[0][0][2].y=0;
        tablica[0][0][2].z=4;

        double width = Form1->Image1->Width-150;
        double height = Form1->Image1->Height-150;

        double minX = tablica[2][0][0].x, maxX = tablica[2][0][0].x;
        double minY = tablica[2][0][0].y, maxY = tablica[2][0][0].y;

                for (int i =0; i<Nk; i++){
                        for(int j=0; j<Nk;j++){
                                for(int k=0;k<Nk;k++){
                                        minX = min(minX, tablica[i][j][k].x);
                                        maxX = max(maxX, tablica[i][j][k].x);
                                        minY = min(minY, tablica[i][j][k].y);
                                        maxY = max(maxY, tablica[i][j][k].y);
                                }
                        }
                }

                double propX = width/(maxX - minX);
                double propY = height/(maxY - minY);

                /*if (propX == propY)
                {
                        for (int i=0; i<Nk; i++)
                        {
                                for(int j=0;j<Nk;j++){
                                        for(int k=0;k<Nk;k++){
                                                tablica[i][j][k].x = transformX(tablica[i][j][k].x, width, minX, maxX);
                                                tablica[i][j][k].y = transformY(tablica[i][j][k].y, height, minY, maxY);
                                        }
                                }
                        }
                }
                if (propX < propY)
                {
                        for (int i=0; i<Nk; i++)
                        {
                                for(int j=0;j<Nk;j++){
                                        for(int k=0;k<Nk;k++){
                                                tablica[i][j][k].x = transformX1(tablica[i][j][k].x, width, minX, maxX);
                                                tablica[i][j][k].y = transformY1(tablica[i][j][k].y, width, height, minX, maxX, minY, maxY);
                                        }
                                }
                        }
                }
                if (propX > propY)
                {
                        for (int i=0; i<Nk; i++)
                        {
                                for(int j=0;j<Nk;j++){
                                        for(int k=0;k<Nk;k++){
                                              tablica[i][j][k].x = transformX2(tablica[i][j][k].x, width, height, minX, maxX, minY, maxY);
                                              tablica[i][j][k].y = transformY2(tablica[i][j][k].y, height, minY, maxY);
                                        }
                                }
                        }
                } */

        Punkt2D dwaD;
        std::vector<Punkt2D> vektor;
        int temp=0;
        for(double r=0.00;r<1;r+=0.01){
                for(double s=r;s<1;s+=0.01){
                        Punkt3D test;
                        test.x=0;
                        test.y=0;
                        test.z=0;
                        for(int i=0;i<=Nk;i++){
                                for(int j=0;j<=Nk;j++){
                                        int k=Nk-(i+j);
                                        if(i+j+k == Nk){
                                          double t=1-(r+s);
                                          test.x+=tablica[i][j][k].x*trojkat(Nk,i,j,k,r,s,t);
                                          test.y+=tablica[i][j][k].y*trojkat(Nk,i,j,k,r,s,t);
                                          test.z+=tablica[i][j][k].z*trojkat(Nk,i,j,k,r,s,t);
                                        }
                                }
                        }
                        //dwaD=rzutOrtogonalny(test,30,45);
                        dwaD=Punkt2D(test.x, test.y);
                        //dwaD=rzutPerspektywiczny(test,40);
                        //Image1->Canvas->Pixels[test.x][test.y]=clRed;
                        //Label1->Caption=Label1->Caption+FloatToStr(test.x)+" "+FloatToStr(test.y)+"\n";
                        vektor.push_back(dwaD);
                        //Image1->Canvas->Pixels[dwaD.x][dwaD.y]=clRed;
                }
        }
        Punkt2D *arr=new Punkt2D[vektor.size()];
        for(int i=0; i<vektor.size(); i++) arr[i]=vektor.at(i);

        minX = arr[0].x;
        maxX = arr[0].x;
        minY = arr[0].y;
        maxY = arr[0].y;

                for (int i =0; i<vektor.size(); i++){
                                        minX = min(minX, arr[i].x);
                                        maxX = max(maxX, arr[i].x);
                                        minY = min(minY, arr[i].y);
                                        maxY = max(maxY, arr[i].y);
                }

                propX = width/(maxX - minX);
                propY = height/(maxY - minY);

                if (propX == propY)
                {
                        for (int i=0; i<vektor.size(); i++)
                        {
                                                arr[i].x = transformX(arr[i].x, width, minX, maxX);
                                                arr[i].y = transformY(arr[i].y, height, minY, maxY);
                        }
                }
                if (propX < propY)
                {
                        for (int i=0; i<vektor.size(); i++)
                        {
                                                arr[i].x = transformX1(arr[i].x, width, minX, maxX);
                                                arr[i].y = transformY1(arr[i].y, width, height, minX, maxX, minY, maxY);
                        }
                }
                if (propX > propY)
                {
                        for (int i=0; i<vektor.size(); i++)
                        {
                                              arr[i].x = transformX2(arr[i].x, width, height, minX, maxX, minY, maxY);
                                              arr[i].y = transformY2(arr[i].y, height, minY, maxY);
                        }
                }

                for(int i=0; i<vektor.size(); i++) {
                  Image1->Canvas->Pixels[arr[i].x][arr[i].y]=clRed;
                }
        delete [] arr;
        delete [] tab;
}
//---------------------------------------------------------------------------