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

#include <vcl.h>
#include <math.h>
#pragma hdrstop

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

TForm1 *Form1;

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

void __fastcall TForm1::Pomoc1Click(TObject *Sender)
{
        ShowMessage("Wybierz algorytm z menu Algorytm.");
}

 int test_fib(int l){
        int a = 1, b = 2, c ;
        do{
                c = a + b ;
                a = b ;
                b = c ;
                if (c==l)
                return 1 ;       //zwraca 1 gdy liczba nalezy do c.Fibonnaciego
        }
        while(c < l);
        return 0;
 }

void swap(int &p1, int &p2){
        int p3;
        p3=p1;
        p1=p2;
        p2=p3;
}

void LiniaPrzyrost(int x0, int y0, int x1, int y1)   {
        int x, b=0;
        float dx, dy,xx, y, m;
        double alfa;
        if(abs(y1-y0)>abs(x1-x0)){
                swap(x0, y0);
                swap(x1, y1);
                b=1;
        }
        if(x0>x1){
                swap(x0, x1);
                swap(y0, y1);
        }
        dx=x1-x0;
        dy=y1-y0;
        if(dx==0) m=1;
        else m=dy/dx;
        y=y0;
        for(x=x0;x<=x1;x++){
                       if(b==1)Form1->Canvas->Pixels[(int)floor(y+0.5)][x]=clRed;
                       else Form1->Canvas->Pixels[x][(int)floor(y+0.5)]=clRed;
                y+=m;
        }
}

// x0 , y0 - wspó&#322;rz&#281;dne pocz&#261;tku odcinka


void Fibbonaci(int w){
   int R=400;     // R - dlugosc boku kwadratu
   int N=10;     // N - ilosc odcinkow na jakie dzielimy bok
   int x=210;      //srodek
   int y=210;
   Form1->Canvas->MoveTo(x+R/2,y+R/2);
   int i,j,tX[80],tY[80];

   tX[0]=x+R/2;      //wprowadzenie do tablicy wpolzendnych prawego gornego rogu
   tY[0]=y+R/2;
//Obliczenie wsp. N punktow dookola krawedzi o boku R
   i=1;
   double p1, p2;
   for(int k=1;k<=4;k++){
        if(k==1){
                p1=-(R/N);
                p2=0;
        }
        else if(k==2){
                p1=0;
                p2=-(R/N);
        }
        else if(k==3){
                p1=(R/N);
                p2=0;
        }
        else if(k==4){
                p1=0;
                p2=(R/N);
        }
        for(;i<=(k*N);i++){
            tX[i]=tX[i-1]+p1;
            tY[i]=tY[i-1]+p2;
        }
   }
// Laczenie punktow linia
  for(i=4*N-1;i>=0;i--){
   for (j=4*N-1;j>=0;j--){
       int z=i-j;                              // obliczanie roznicy (i - j)
       if (z<0)
       z+=4*N;                      // odejmowanie modulo
       if(test_fib(z)){                        //sprawdzanie czy (i - j) jest liczba z cia. Fibonnaciego
        if(w==0){
                Form1->Canvas->MoveTo(tX[i],tY[i]);
                Form1->Canvas->LineTo(tX[j],tY[j]);
        }
        if(w==1){
                LiniaPrzyrost(tX[i], tY[i], tX[j], tY[j]);
        }
        if(w==2){
                //BresenhamLine(tX[i], tY[i], tX[j], tY[j]);
        }
       }
   }
  }
}



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


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


void __fastcall TForm1::Fibprzyrost1Click(TObject *Sender)
{
      Form1->Repaint();
      Form1->Canvas->Pen->Color=clRed;
      Fibbonaci(1);
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Fib1Click(TObject *Sender)
{
      Form1->Repaint();
      Form1->Canvas->Pen->Color=clRed;
      Fibbonaci(0);
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Fibpktsr1Click(TObject *Sender)
{
      Form1->Repaint();
      Form1->Canvas->Pen->Color=clRed;
      Fibbonaci(2);
}
//---------------------------------------------------------------------------

void KoloPrzyrost(int x0=210, int y0=210, int r=100)
{
//                int r=100;      //promien
  //              int x0=210, y0=210;      //srodek okregu
                int lp=1000;     //liczba odcinkow; przyblizen

                double theta=0.0;
                double thinc=2*M_PI/lp;
                int xn,yn;
                for(int i=0;i<lp;i++){
                        theta=theta+thinc;
                        xn=(int) x0+r*cos(theta);
                        yn=(int) y0+r*sin(theta);
                        Form1->Canvas->Pixels[xn][yn]=clGreen;
                }
}

void SetPixel(int x, int y, double tX, double tY){
        Form1->Canvas->Pixels[x+tX][y+tY]=clRed;
        Form1->Canvas->Pixels[y+tX][x+tY]=clRed;
        Form1->Canvas->Pixels[y+tX][-x+tY]=clRed;
        Form1->Canvas->Pixels[x+tX][-y+tY]=clRed;
        Form1->Canvas->Pixels[-x+tX][-y+tY]=clRed;
        Form1->Canvas->Pixels[-y+tX][-x+tY]=clRed;
        Form1->Canvas->Pixels[-y+tX][+x+tY]=clRed;
        Form1->Canvas->Pixels[-x+tX][+y+tY]=clRed;
}

void MidpointCircle(int tX, int tY, int r){
    int x, y;
    float d;
      x=0;
      y=r;
      d=5/4-r;
      SetPixel(x, y, tX, tY);
      while(y>x){
        if (d<0){    //wybiera E
          d+=x*2+3;
          x++;
        }else{              //wybiera NE
          d+=(x-y)*2+5;
          x++;
          y--;
        }
        SetPixel(x, y, tX, tY);
      }
}



void __fastcall TForm1::Styczneokrgi1Click(TObject *Sender)
{
        int r=100;    //promien okregow
        int x0=210, y0=210;      //srodek

        Form1->Repaint();
        Form1->Canvas->Pen->Color=clRed;
        x0-=r;
        y0-=r;
        KoloPrzyrost(x0, y0, r);
        x0+=2*r;
        MidpointCircle(x0,y0,r);
        x0-=r;
        y0+=r*(sqrt(3));
        MidpointCircle(x0,y0,r);
}
//---------------------------------------------------------------------------
void p_kw(int x, int y, int size){   // pedzel kwadratowy
        if(size < 1) size=1;
        for (int i=x; i<=x+size; i++)
        for (int z=y; z<=y+size; z++)
        Form1->Canvas->Pixels[i][z]=clRed;
}
/****************************************************************************/
void p_pr(int x, int y, int size){   // pedzel prostokatny
        if (size < 1) size=1;
        for (int i=x; i<x+size+2; i++)
        for (int z=y; z<y+size; z++)
        Form1->Canvas->Pixels[i][z]=clRed;
}
/****************************************************************************/
void p_ok(int x, int y, int size){   // pedzel okragly
        int x1,y1;
        for (int i=0; i<size; i++)
        for (int z=0; z < 360; z++){
                x1=x+i*cos(z*M_PI/180);
                y1=y+i*sin(z*M_PI/180);
                Form1->Canvas->Pixels[x1][y1]=clRed;
        }
}
/****************************************************************************/
void o_pow(int x, int y, int g){
   if (g >= 0) {  // sprawdzam czy promien jest dodatni
        int x_w=0;
        int y_w=0;
        for (int i=1; i <= 360; i++) {      //przesuwa pozycje "pedzla"
                x_w=x+g*cos(i*M_PI/180);      //co 1 stopien obliczane sa wspolrzedne "x" i "y"
                y_w=y+g*sin(i*M_PI/180);
                Form1->Canvas->Pixels[x_w][y_w]=clRed;
        }
   }
}
/****************************************************************************/
void (*p)( int, int, int );
// x1 , y1 - wspó&#322;rz&#281;dne konca odcinka
void BresenhamLine(int x0 , int y0 , int x1 , int y1 )
{
        int dx, dy, err=0, ystep, x, y, b=0;
        if(abs(y1-y0)>abs(x1-x0)){
                swap(x0, y0);
                swap(x1, y1);
                b=1;
        }
        if(x0>x1){
                swap(x0, x1);
                swap(y0, y1);
        }
        dx=x1-x0;
        dy=abs(y1-y0);
        y=y0;
        if(y0<y1)ystep=1;
        else ystep=-1;
        for(x=x0;x<x1;x++){
                if(b==1)(*p)(y,x,5);
                else (*p)(x,y,5);
                err+=dy;
                if(2*err>=dx){
                        y+=ystep;
                        err-=dx;
                }
        }
}
void punkty_okregu(int cx, int cy, int x, int y){
    if (x == 0){
          (*p)(cx,cy,5);(*p)(cx,cy-y,5);(*p)(cx+y,cy,5);(*p)(cx-y,cy,5);
    }else
    if (x == y){
          (*p)(cx+x,cy+y,5);(*p)(cx-x,cy+y,5);(*p)(cx+x,cy-y,5);(*p)(cx-x,cy-y,5);
    }else
    if (x < y){
          (*p)(cx+x,cy+y,5);(*p)(cx-x,cy+y,5);(*p)(cx+x,cy-y,5);(*p)(cx-x,cy-y,5);
          (*p)(cx+y,cy+x,5);(*p)(cx-y,cy+x,5);(*p)(cx+y,cy-x,5);(*p)(cx-y,cy-x,5);
   }
}
void Algorytm_1(int xCenter, int yCenter, int radius){ //algorytm z punktem srodkowym(Bresenham'a)
    xCenter=StrToInt(Form1->Edit1->Text);
    yCenter=StrToInt(Form1->Edit2->Text);
    radius=StrToInt(Form1->Edit3->Text);

    Form1->Repaint();
    Form1->Canvas->Pen->Color=clRed;

    int x = 0;
    int y = radius;
    float d = 5/4-radius;        //wartosc poczatkowa
    while (x < y) {              //warunek poczatkowy
          if (d < 0)             //wybieram pixel na bazie znaku zmiennej "d"
          {                      //wybram E --> punkt nad
             d += x*2+3;         // uaktualniam zmienna decyzyjna o odpowiedna wartosc delta
             x++;}
                 else{           //wybram SE --> punkt pod
                  d +=(x-y)*2+5; // uaktualniam zmienna decyzyjna o odpowiedna wartosc delta
                  x++;
                  y--;}
                  punkty_okregu(xCenter, yCenter-5, x, y);
                  }
        BresenhamLine(xCenter-2*radius, yCenter+radius, xCenter+2*radius, yCenter+radius);
        BresenhamLine(xCenter, yCenter-2*radius, xCenter+2*radius, yCenter+radius);
        BresenhamLine(xCenter, yCenter-2*radius, xCenter-2*radius, yCenter+radius);
}



void __fastcall TForm1::Algorytm11Click(TObject *Sender)
{
        p=p_ok;
        Algorytm_1(200, 200, 50);
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Algorytm21Click(TObject *Sender)
{
        p=p_kw;
        Algorytm_1(200, 200, 50);

}
//---------------------------------------------------------------------------

void __fastcall TForm1::Algorytm31Click(TObject *Sender)
{
        p=p_pr;
        Algorytm_1(200, 200, 50);

}
//---------------------------------------------------------------------------

void __fastcall TForm1::Algorytm41Click(TObject *Sender)
{
        p=o_pow;
        Algorytm_1(200, 200, 50);

}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{
        Algorytm_1(200, 200, 50);
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate(TObject *Sender)
{
        p=p_ok;
}
//---------------------------------------------------------------------------