Объясните принцип работы программы

#include <vcl.h>
#pragma hdrstop
 
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
#include <math.h>
#include <stdlib.h>
#define PI 3.14159
 
bool pa = false, li = false, mi = false;
 
TForm1 *Form1;
 
int getmaxx()
{
        return Form1->Image1->Width;
}
int getmaxy()
{
        return Form1->Image1->Height;
}
 
struct Pnt                  // класс точки
{
  double x, y;          // координаты точки
  int code(Pnt q);      // код четверти, в которой лежит точка q
  double operator*(Pnt q);      // векторное произведение
  Pnt operator-(Pnt q);     // разность векторов
  int operator!=(Pnt q);
};
 
int Pnt::code(Pnt q)    // код четверти, в которой лежит точка q
{
// начало координат находится в точке (x, y)
  if(q.x - x >= 0 && q.y - y >= 0) return 0;
  if(q.x - x < 0 && q.y - y >= 0) return 1;
  if(q.x - x >= 0 && q.y - y < 0) return 3;
  if(q.x - x < 0 && q.y - y < 0) return 2;
}
 
double Pnt::operator*(Pnt q)
{
  return x * q.y - y * q.x;     // векторное произведение
}
Pnt Pnt::operator-(Pnt q)       // разность векторов
{
  Pnt t; t.x = x - q.x; t.y = y - q.y; return t;
}
double fabs(Pnt p)
{
        return sqrt(p.x*p.x+p.y*p.y);
}
 
int operator<(Pnt p, Pnt q)
{
  Pnt t;                // сравнение углов радиус-векторов p и q
  t.x = 0; t.y = 0;     // коды четвертей вычисляются
// относительно (0,0)
  if(t.code(p) < t.code(q)) return 1;
  if(t.code(p) > t.code(q)) return 0;
  return (p * q > 0);   // вращение от p к q направлено
// против часовой стрелки
}
int Pnt::operator!=(Pnt q)
{
        return x!=q.x || y!=q.y;
}
 
int intersect(Pnt p, Pnt p1, Pnt p2)
{
// тест на пересечение луча и отрезка
  if(p1.y == p2.y) return 0;
  if((p1.y < p2.y ? p2.y : p1.y) <= p.y) return 0;
  if((p1.y < p2.y ? p1.y : p2.y) > p.y) return 0;
  if(p2.y - p1.y > 0) return
        ((p.x - p1.x)*(p2.y - p1.y)-(p2.x - p1.x)*(p.y - p1.y) > 0);
        else return
        ((p.x - p1.x)*(p2.y - p1.y)-(p2.x - p1.x)*(p.y - p1.y) < 0);
}
 
class CPolygon
{
        int color, n;
        Pnt *p, pC;
  public:
        CPolygon(double *x, double *y, int m, TColor cl);
        CPolygon(const CPolygon &ob);    // конструктор копирования
        int isin(Pnt t);
        void show(double xmin, double ymin,
                double xmax, double ymax);
        void showenter(double xmin, double ymin,
                double xmax, double ymax);
 
};
// Конструктор копирования
CPolygon::CPolygon(const CPolygon &ob)  // необходим для передачи объекта
{                                       // в качестве параметра
  int i;
  n = ob.n; color = ob.color;
  p = new Pnt[n];               // выделим память
  for(i=0; i < ob.n; i++) p[i]=ob.p[i]; // производим копирование
}
void CPolygon::show(double xmin, double ymin,
        double xmax, double ymax)
{
int i;
TPoint *parray = new TPoint [n];
  Form1->Image1->Canvas->Brush->Color=color;
  for(i = 0; i < n; i++)
  {
        parray[i] = Point(
        (p[i].x - xmin) * getmaxx() / (xmax - xmin),
        (ymax - p[i].y) * getmaxy() / (ymax - ymin));
    }
  Form1->Image1->Canvas->Polygon(parray,n-1);
}
 
void CPolygon::showenter(double xmin, double ymin,
        double xmax, double ymax)
{
int i;
TPoint *parray = new TPoint [n];
  Form1->Image1->Canvas->Brush->Color=color;
  for(i = 0; i < n; i++)
  {
        parray[i] = Point(
        p[i].x ,
         p[i].y);
    }
  Form1->Image1->Canvas->Polygon(parray,n-1);
}
 
CPolygon::CPolygon(double *x, double *y, int m, TColor cl):color(cl)
{
int i, j; int i0 = 0, v, w, f = 0;
Pnt t;
  p = new Pnt [m]; n = m;
  pC.x = 0; pC.y = 0;
  for(i = 0; i < m; i++)
  {
    pC.x += x[i]; pC.y += y[i];
  }
  pC.x = pC.x / m; pC.y = pC.y / m;
  for(i = 0; i < m; i++)
  {
    p[i].x = x[i]; p[i].y = y[i];
  }
 
  for(i = 1; i < m; i++)                // сортируем точки по возрастанию угла
                                        // вокруг центра тяжести методом вставок
  {
    t = p[i];
    for(j = i - 1; (j >= 0) && ((t - pC) < (p[j] - pC)); j--)
    p[j + 1] = p[j];
    p[j + 1] = t;
  }
}
 
//
int CPolygon::isin(Pnt t)
{
int i, ind = 0;
// вначале индекс = 0
Pnt q = p[n - 1];
// начальная сторона p(n-1)p(0)
for(i = 0; i < n; i++)
{
if(t.code(q) == t.code(p[i]));  // приращение индекса = 0
else if((t.code(p[i]) - t.code(q) + 3)%4 == 0)
ind++;              // приращение индекса = 1
else if((t.code(p[i]) - t.code(q) + 1)%4 == 0)
ind--;          // приращение индекса = -1
else if((p[i] - q) * (t - q) > 0) ind += 2;
// приращение индекса = 2
else ind -= 2;      // приращение индекса = -2
q = p[i];
}
ind = ind / 4;
if(ind == 0) return 0;
else return 1;
}
 
double *x1, *y1, *x, *y;        // радиус окружности и
// вершины 2mm-угольника
int count=0;
bool fl=false;
bool ok=false;
bool sim=false;
int lx[2],ly[2],p=0;
 
void initpoints(double *x, double *y)
{
 int i,count=0;
  int mm = 10;
   x1 = new double[2 * mm]; y1 = new double [2 * mm];
  for(i = 0; i < mm; i++)
  {
    x1[i] = x[i] ;                 // вершины большого 2mm-угольника
    y1[i] = y[i] ;                 // вершины большого 2mm-угольника
 
    x1[i + mm] = x[i+mm];              // вершины маленького 2mm-угольника
    y1[i + mm] = y[i+mm];
  }
Form1->Image1->Canvas->Pen->Width=1;
Form1->Image1->Canvas->Pen->Color=clBlack;
 
CPolygon cpoly(x1, y1, 10, clRed);  // построение выпуклой оболочки
cpoly.showenter(-300, -300, 300,300);// вывод выпуклой оболочки
 
  delete []x1; delete []y1;
 
}
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
        x = new double[2 * 10]; y = new double [2 * 10];
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::Image1MouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
   if((fl==true)&&(count<20)&&(sim==false))
   {
   x[count]=X;y[count]=Y;
   count++;
   Form1->Image1->Canvas->Pen->Width=3;
   Form1->Image1->Canvas->Pen->Color=clRed;
   Form1->Image1->Canvas->MoveTo(X,Y);
   Form1->Image1->Canvas->LineTo(X,Y);
   Form1->Image1->Canvas->TextOutA(20,20,"Точка"+IntToStr(count));
   if(count==20) ok=true;
   }
 
   if((sim==true)&&(p<=1)&&(fl==false))
   {
        if(p<1)
        {
                 lx[0]=X;ly[0]=Y;
                 Form1->Image1->Canvas->Pen->Width=3;
                 Form1->Image1->Canvas->Pen->Color=clRed;
                 Form1->Image1->Canvas->MoveTo(X,Y);
                 Form1->Image1->Canvas->LineTo(X,Y);
                 p++;
         }
         else
         {
                lx[1]=X;ly[1]=Y;
                Form1->Image1->Canvas->Pen->Width=3;
                Form1->Image1->Canvas->Pen->Color=clRed;
                Form1->Image1->Canvas->MoveTo(lx[0],ly[0]);
                Form1->Image1->Canvas->LineTo(lx[1],ly[1]);
                p++;
         }
   }
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::N5Click(TObject *Sender)
{
exit(1);
}
//---------------------------------------------------------------------------
float k1,k2;
void __fastcall TForm1::N8Click(TObject *Sender)
{
if(sim==false)sim=true;
else sim=false;
 
  Form1->N8->Enabled = False;
  Form1->N9->Enabled = True;
}
//---------------------------------------------------------------------------
float k(float x1, float y1, float x2, float y2)
{
return (float)(y2-y1)/(x2-x1);
}
 
float func(float x1, float y1, float k, float x2)
   {
   return (float)(y1+k*(x2-x1));
   }
 
float per(float x1, float y1, float x2, float y2,float x3, float y3 )
{
k1=k(x1,y1,x2,y2);
k2=-1/k1;
float r[2];
r[0]=k1-k2;
r[1]=k1*(-x1)+y1-(k2*(-x3)+y3);
return (float)((-1)*r[1]/r[0]);
}
 
void __fastcall TForm1::N9Click(TObject *Sender)
{
if(sim==true&&p==2)
{
double tmpx,tmpy,xx,yy;
bool fx=false;
bool fy=false;
ok = true;
if(lx[0]==lx[1])fx=true;
if(ly[0]==ly[1])fy=true;
   if(ok==true)
   {
   for(int i=0;i<10;i++){
     if(fx==true)
     {
     tmpx=x[i];
     x[i]=tmpx+2*(lx[0]-tmpx);
     }
     else if(fy==true)
     {
     tmpy=y[i];
     y[i]=tmpy+2*(ly[0]-tmpy);
     }
     else
     {
    xx=per(lx[0],ly[0],lx[1],ly[1],x[i],y[i] ) ;
    yy=func(x[i], y[i], k2,xx) ;
    tmpx=x[i];tmpy=y[i];
    x[i]=(xx-tmpx)+xx;
    y[i]=(yy-tmpy)+yy;
    }
    }
   initpoints(x,y);
   }
 }
  Form1->N9->Enabled = False;
}
//---------------------------------------------------------------------------
 
void small()
{
  int i;
  int rad = 30;
  int mm = 5;
  x1 = new double[2*mm]; y1 = new double[2*mm];
  for(i = 0; i < mm; i++)
  {
          x1[i] = rad * cos(2 * PI * i / mm);    // берутся точки на
          y1[i] = rad * sin(2 * PI * i / mm);    // окружности радиуса rad
          x1[i + mm] = rad * cos(2 * PI * i / mm + PI / mm) / 2;// и на окружности
          y1[i + mm] = rad * sin(2 * PI * i / mm + PI / mm) / 2;// радиуса rad/2
  }
  CPolygon cpoly(x1,y1,10,clRed);   // объект - многоугольник
  cpoly.show(-300, -300, 300, 300);
  Pnt f = {0., 0.};
  for(i = 0; i < 2 * mm; i++)
  {
    f.x = x1[i]; f.y = y1[i];
    x[i] = (x1[i] + 300.) * getmaxx() / 600 - 1;
    y[i] = ((300. - y1[i]) * getmaxy() / 600 - 1);
  }
  delete []x1; delete []y1;
  Form1->N10->Enabled = False;
  Form1->N8->Enabled = True;
}
 
void medium()
{
  int i;
  int rad = 60;
  int mm = 5;
  x1 = new double[2*mm]; y1 = new double[2*mm];
  for(i = 0; i < mm; i++)
  {
          x1[i] = rad * cos(2 * PI * i / mm);    // берутся точки на
          y1[i] = rad * sin(2 * PI * i / mm);    // окружности радиуса rad
          x1[i + mm] = rad * cos(2 * PI * i / mm + PI / mm) / 2;// и на окружности
          y1[i + mm] = rad * sin(2 * PI * i / mm + PI / mm) / 2;// радиуса rad/2
  }
  CPolygon cpoly(x1,y1,10,clRed);   // объект - многоугольник
  cpoly.show(-300, -300, 300, 300);
  Pnt f = {0., 0.};
  for(i = 0; i < 2 * mm; i++)
  {
    f.x = x1[i]; f.y = y1[i];
    x[i] = (x1[i] + 300.) * getmaxx() / 600 - 1;
    y[i] = ((300. - y1[i]) * getmaxy() / 600 - 1);
  }
  delete []x1; delete []y1;
  Form1->N10->Enabled = False;
  Form1->N8->Enabled = True;
}
 
void big()
{
  int i;
  int rad = 100;
  int mm = 5;
  x1 = new double[2*mm]; y1 = new double[2*mm];
  for(i = 0; i < mm; i++)
  {
          x1[i] = rad * cos(2 * PI * i / mm);    // берутся точки на
          y1[i] = rad * sin(2 * PI * i / mm);    // окружности радиуса rad
          x1[i + mm] = rad * cos(2 * PI * i / mm + PI / mm) / 2;// и на окружности
          y1[i + mm] = rad * sin(2 * PI * i / mm + PI / mm) / 2;// радиуса rad/2
  }
  CPolygon cpoly(x1,y1,10,clRed);   // объект - многоугольник
  cpoly.show(-300, -300, 300, 300);
  Pnt f = {0., 0.};
  for(i = 0; i < 2 * mm; i++)
  {
    f.x = x1[i]; f.y = y1[i];
    x[i] = (x1[i] + 300.) * getmaxx() / 600 - 1;
    y[i] = ((300. - y1[i]) * getmaxy() / 600 - 1);
  }
  delete []x1; delete []y1;
  Form1->N10->Enabled = False;
  Form1->N8->Enabled = True;
}
 
void __fastcall TForm1::N11Click(TObject *Sender)
{
        if((fl==false)&&(sim==false)) {
        Form1->Image1->Canvas->Rectangle(-10,-10,1000,1000);
        small();}
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::N12Click(TObject *Sender)
{
        if((fl==false)&&(sim==false)) {
        Form1->Image1->Canvas->Rectangle(-10,-10,1000,1000);
        medium();}
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::N13Click(TObject *Sender)
{
        if((fl==false)&&(sim==false)) {
        Form1->Image1->Canvas->Rectangle(-10,-10,1000,1000);
        big();}