//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
#include<math.h>
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Load1Click(TObject *Sender)
{


if (OpenDialog->Execute()) {
    Image1->Picture->LoadFromFile(OpenDialog->FileName);
    Form1->Caption = ExtractFileName(OpenDialog->FileName);
      N = Image1->Picture->Width;
      M = Image1->Picture->Height;
       obj=new TList;
Bitmap1 = new Graphics::TBitmap();
Bitmap1->Width=N ;
Bitmap1->Height=M;
 int *tab=new int[N*M];
  Graphics::TBitmap * bitmap;
  for(int i=0;i<N;i++)
  for(int j=0;j<M;j++)
        {
        tab[i+j*N]=1;
        }
  bitmap=slicer(L1distance, OpenDialog->FileName,10,3);
  while(bitmap=slicer(L1distance, "",10,3))
  {
  for(int i=0;i<N;i++)
  for(int j=0;j<M;j++)
        if(bitmap->Canvas->Pixels[i][j]>16000000)
        {
        tab[i+j*N]=0;
        }
        vectorisation(tab);
          for(int i=0;i<N;i++)
  for(int j=0;j<M;j++)

        {
        tab[i+j*N]=1;
        }
   }  

  slicer(NULL, "", 0, 0);

      Image1->Refresh();
  Application->ProcessMessages();
 Image1->Picture->Assign(Bitmap1);
  Image1->Refresh();
  Application->ProcessMessages();

  }

}
//---------------------------------------------------------------------------
void TForm1::small_vectors(int *tab1)
{
int sth;
for(int j=4;j<M-4;j++)
for(int i=4;i<N-4;i++)
        {
        if(tab1[i+j*N]==0)
                {
                //vec=new struct vector;
                 sth=0;
                 for(int k=-1;k<4;k++)
                 for(int l=0;l<4;l++)
                 if(tab1[i+k+(j+l)*N]==0 && (k!=0 || l!=0))
                                {
                                vec=new struct vector;
                                vec[0].i1=i;
                                vec[0].j1=j;
                                //add vector
                                vec[0].i2=i+k;
                                vec[0].j2=j+l;
                                tab1[i+k+(j+l)*N]=1;
                                svector_list->Add(vec);
                                sth++;
                                }

                  tab1[i+j*N]=1;
                }

        }


}


//---------------------------------------------------------------------------
void TForm1::vectorisation(int*tab1)
{
line_list=new TList;
line1_list=new TList;
lvector_list = new TList;
svector_list = new TList;
point_list = new TList;
point1_list = new TList;
rectangle_list = new TList;
triangle_list=new TList;
pie_list = new TList;
circle_list = new TList;
liness(tab1);


small_vectors(tab1);
lvector_list =vectors(svector_list,3,50);
lvector_list =vectors(lvector_list,5,10);
lvector_list=lines(lvector_list,10);
lvector_list=disshort(lvector_list,16);
lvector_list=lines(lvector_list,10);
lvector_list =vectors(lvector_list,7,10);
lvector_list=lines(lvector_list,20);
lvector_list =vectors(lvector_list,7,5);
lvector_list=lines(lvector_list,20);
lvector_list=disshort(lvector_list,49);


//Find_circle(lvector_list,tab1)  ;
sh();


}
//---------------------------------------------------------------------------
void TForm1::sh()
{
Bitmap1->Canvas->Brush->Color=clWhite;
Bitmap1->Canvas->Pen->Color=clBlack;
Bitmap1->Canvas->Pen->Width=1;
for(int i=0;i<lvector_list->Count;i++)
       {
        vec=(struct vector*) lvector_list->Items[i];
        obj->Add(vec);
        Bitmap1->Canvas->MoveTo(vec->i1,vec->j1);
        Bitmap1->Canvas->LineTo(vec->i2,vec->j2);
      }

Bitmap1->Canvas->Pen->Color=clBlue;
for(int i=0;i<line_list->Count;i++)
       {
        lin=(struct line*) line_list->Items[i];
        obj->Add(lin);
        Bitmap1->Canvas->MoveTo(lin->x1,lin->y1);
        Bitmap1->Canvas->LineTo(lin->x2,lin->y2);
        }


Bitmap1->Canvas->Pen->Color=clGreen;
for(int i=0;i<triangle_list->Count;i++)
       {
        tri=(struct triangle*) triangle_list->Items[i];
        obj->Add(tri);
        Bitmap1->Canvas->MoveTo(tri->x1,tri->y1);
        Bitmap1->Canvas->LineTo(tri->x2,tri->y2);
        Bitmap1->Canvas->MoveTo(tri->x1,tri->y1);
        Bitmap1->Canvas->LineTo(tri->x3,tri->y3);
        Bitmap1->Canvas->MoveTo(tri->x2,tri->y2);
        Bitmap1->Canvas->LineTo(tri->x3,tri->y3);
        }
Bitmap1->Canvas->Pen->Color=clRed;
for(int i=0;i<rectangle_list->Count;i++)
       {
        rec=(struct rectangle*) rectangle_list->Items[i];
        obj->Add(rec);
        Bitmap1->Canvas->MoveTo(rec->x1,rec->y1);
        Bitmap1->Canvas->LineTo(rec->x2,rec->y2);
        Bitmap1->Canvas->MoveTo(rec->x2,rec->y2);
        Bitmap1->Canvas->LineTo(rec->x3,rec->y3);
        Bitmap1->Canvas->MoveTo(rec->x3,rec->y3);
        Bitmap1->Canvas->LineTo(rec->x4,rec->y4);
        Bitmap1->Canvas->MoveTo(rec->x4,rec->y4);
        Bitmap1->Canvas->LineTo(rec->x1,rec->y1);

        }

Bitmap1->Canvas->Pen->Color=clYellow;
struct circle *circ;
for(int i=0;i<circle_list->Count;i++)
       {
        circ=(struct circle*) circle_list->Items[i];
        obj->Add(circ);
        Bitmap1->Canvas->Ellipse(circ->x-circ->r,circ->y-circ->r,circ->x+circ->r,circ->y-circ->r);
        }
}
//---------------------------------------------------------------------------
TList* TForm1::vectors(TList *ssvector_list,int dev,double ang)
{
TList *llvector_list=new TList;
int j2,i2,i1,j1;
struct vector* vec1=new struct vector;
double asum,angle;
double ax,ay,bx,by;
double sth1;
for (int i = 0; i < ssvector_list->Count; i++)
        {
        vec=new struct vector;
        vec= (TForm1::vector*) ssvector_list->Items[i];
        j2=vec->j2;
        i2=vec->i2;
        j1=vec->j1;
        i1=vec->i1;
        asum=0;
        ssvector_list->Delete(i);
        int sth=0;

        for(int j=0;j< ssvector_list->Count;j++)
                {
                vec1= (TForm1::vector*) ssvector_list->Items[j];
                if(vec1->i1>=i2-dev && vec1->i1<=i2+dev && vec1->j1<=j2+dev && vec1->j1>=j2)
                        {
                        bx=vec1->i2-vec1->i1;
                        by=vec1->j2-vec1->j1;
                        ax=i2-i1;
                        ay=j2-j1;
                        if(by==0 && ay==0)
                        sth1=0;
                        else
                        sth1=acos((ax*bx+ay*by)/(sqrt(ax*ax+ay*ay)*sqrt(by*by+bx*bx)));
                        if(sth>M_PI_2)
                        sth1=-sth1-M_PI;
                        asum+=sth1;
                        if(abs(asum*180*M_1_PI)<ang)
                               {
                                sth++;
                                j1=j2;
                                i1=i2;
                                j2=vec1->j2;
                                i2=vec1->i2;
                                j1=vec1->j1;
                                i1=vec1->i1;
                                ssvector_list->Delete (j);
                                j--;
                               }
                        }
                }
        vec->i2=i2;
        vec->j2=j2;
        llvector_list->Add(vec);
        i--;
       }

//Application->MessageBox(IntToStr(ssvector_list->Count).c_str(),"svectors",MB_OK) ;
//Application->MessageBox(IntToStr(llvector_list->Count).c_str(),"lvectors",MB_OK) ;
return    llvector_list;
}


//---------------------------------------------------------------------------
TList *TForm1::lines(TList* list,int dis )
{
double a,b;
double x1,x2;
int X1,Y1,X2,Y2;
int j2,i1,j1;
//int sth;
TList * lines=new TList;
struct vector* vec1=new struct vector;
struct vector* vec2=new struct vector;
struct vector* vec3=new struct vector;
for (int i = 0; i < list->Count; i++)
        {
        //sth=0;
        vec1= (TForm1::vector*) list->Items[i];
        list->Delete(i);
        X1=vec1->i1;
        Y1=vec1->j1;
        X2=vec1->i2;
        Y2=vec1->j2;
        for(int j=0;j< list->Count;j++)
                {
                //sth=0;
                vec2= (TForm1::vector*) list->Items[j];
                if(vec2->i1>=vec1->i2+dis && vec2->i1<=vec1->i2-dis && vec2->j1<=vec1->j2+dis && vec2->j1>=vec1->j2-dis)
                   {
                   if(vec1->i1!=vec2->i2)
                        {
                        a=(double)(vec2->j2-vec1->j1)/(double)(vec2->i2-vec1->i1);
                        b=(double)vec1->j1-a*vec1->i1;
                        x1=x2=0;
                        }
                   else
                        {
                        x1=vec1->i1-dis;
                        x2=vec1->i1+dis;
                        }

                   X2=vec2->i2;
                   Y2=j2=vec2->j2;
                   //going up
                        if(x1==0&& x2==0)
                        {//vertical line
                        for (int k = 0; k < list->Count; k++)
                                {
                                vec3= (TForm1::vector*) list->Items[k];
                                if(vec3->i1>=x1 && vec3->i1<=x2 &&vec3->i2>=x1 && vec3->i2<=x2 && vec3->j1<=j2+dis && vec3->j1>=j2-dis)
                                        {

                                        list->Delete(k);
                                        if(vec3->j2>Y2)
                                        {X2=vec3->i2;
                                        Y2=j2=vec3->j2;
                                        }
                                        k--;
                                        }
                                }
                        }
                        else //not vertical line
                        {
                           for (int k = 0; k < list->Count; k++)
                                {
                                vec3= (TForm1::vector*) list->Items[k];
                                if(vec3->j1>=a*vec3->i1+b-dis &&vec3->j1<=a*vec3->i1+b+dis &&
                                vec3->j2>=a*vec3->i2+b-dis &&vec3->j2<=a*vec3->i2+b+dis &&
                                vec3->j1<=j2+dis && vec3->j1>=j2-dis )
                                        {

                                        list->Delete(k);
                                        if(vec3->j2>Y2)
                                        {
                                        X2=vec3->i2;
                                        Y2=j2=vec3->j2;
                                        }
                                        k--;
                                        }
                                }
                        }

                        j2=Y1;
                        //going down
                        if(x1==0&& x2==0)
                        {//vertical line
                        for (int k = 0; k < list->Count; k++)
                                {
                                vec3= (TForm1::vector*) list->Items[k];
                                if(vec3->i1>=x1 && vec3->i1<=x2 &&vec3->i2>=x1 && vec3->i2<=x2 && vec3->j2>=j1-dis && vec3->j2<=j1+dis)
                                        {
                                        list->Delete(k);
                                        if(vec3->j2<Y1)
                                        {
                                        X1=vec3->i2;
                                        Y1=j2=vec3->j2;}
                                        k--;
                                        }
                                }
                        }
                        else //not vertical line
                        {
                           for (int k = 0; k < list->Count; k++)
                                {
                                vec3= (TForm1::vector*) list->Items[k];
                                if(vec3->j1>=a*vec3->i1+b-dis &&vec3->j1<=a*vec3->i1+b+dis &&
                                vec3->j2>=a*vec3->i2+b-dis &&vec3->j2<=a*vec3->i2+b+dis&&
                                vec3->j2<=j1+dis && vec3->j2>=j1-dis )
                                        {
                                        list->Delete(k);
                                        if(vec3->j2<Y1)
                                        {
                                        X1=vec3->i2;
                                        Y1=j2=vec3->j2;}
                                        k--;
                                        }
                                }
                        }

                        list->Delete(j);j--;break;
                  }//end if vec2
                }//j
        vec=new struct vector;
        vec->i1=X1;
        vec->i2=X2;
        vec->j1=Y1;
        vec->j2=Y2;
        i--;
        lines->Add(vec);
        }//i
return   lines;
}
//---------------------------------------------------------------------------
TList* TForm1::disshort(TList* list ,int dis)
{
int x1,x2,y1,y2;
//Application->MessageBox(IntToStr(list->Count).c_str(),"wchodzace",MB_OK) ;
for (int i = 0; i < list->Count; i++)
        {
        vec=new struct vector;
        vec= (TForm1::vector*) list->Items[i];
        x1=vec->i1-vec->i2;
        y1=vec->j1-vec->j2;
        if(x1*x1+y1*y1<dis)
                {
                list->Delete(i);
                i--;
                }
        }
return list;
//Application->MessageBox(IntToStr(list->Count).c_str(),"wychodzace",MB_OK) ;
}



//---------------------------------------------------------------------------
void TForm1::liness(int *tab1)
{

int sth;
for(int j=1;j<M-1;j++)
for(int i=1;i<N-1;i++)
        {

                 sth=0;
                 if(tab1[i+j*N]==0)
                 for(int k=-1;k<2;k++)
                 for(int l=-1;l<2;l++)
                 if(tab1[i+k+(j+l)*N]==0 && (k!=0 || l!=0))
                                {
                                sth++;
                                }

                  if(sth==1)
                     {
                     po=new struct point;
                     po[0].i1=i;
                     po[0].j1=j;
                     point_list->Add(po);
                     }
                  }



struct point* po1=new struct point;
struct point* po2=new struct point;
float a;
float b;
int xmin,xmax;
int ymin,ymax;
float ob1;
float ob2;
for(int i=0;i<point_list->Count;i++)
        {
        po1=(struct point*) point_list->Items[i];
        for(int j=0;j<point_list->Count;j++)
        if(i!=j)
                {
                po2=(struct point*) point_list->Items[j];
                if( po2->i1==po1->i1)
                po2->i1=po1->i1+1;
                a=(float)(po2->j1-po1->j1)/(float)(po2->i1-po1->i1);
                b=(float)po1->j1-(float)a*po1->i1;
                if(po1->i1>po2->i1)
                {xmax=po1->i1;xmin=po2->i1;}
                else
                {xmax=po2->i1;xmin=po1->i1;}

                if(po1->j1>po2->j1)
                {ymax=po1->j1;ymin=po2->j1;}
                else
                {ymax=po2->j1;ymin=po1->j1;}

                ob1=sqrt((xmax-xmin)*(xmax-xmin)+(ymax-ymin)*(ymax-ymin));
                ob2=0;
                for(int k=xmin-1;k<xmax+1;k++)
                for(int l=ymin-1;l<ymax+1;l++)
                        {
                        if( tab1[k+l*N]==0 && a*k+b-5<l && a*k+b+5>l)
                        ob2+=1;
                        }
                ob2*=0.9*sqrt(2);
                if(ob2<=1.5*ob1 && ob2>=0.8*ob1)
                        {
                        for(int k=xmin-1;k<xmax+1;k++)
                        for(int l=ymin-1;l<ymax+1;l++)
                                {
                                if( a*k+b-10<l && a*k+b+10>l)
                                tab1[k+l*N]=1;
                                }

                         lin =new struct line;
                         lin->x1=po1->i1;
                         lin->y1=po1->j1;
                         lin->x2=po2->i1;
                         lin->y2=po2->j1;
                         point_list->Delete(i);
                          i--;j--;
                         point_list->Delete(j);

                         line_list->Add(lin);
                         break;
                         }

                }
        }



//looking for corners of rectangle

for(int j=1;j<M-1;j++)
for(int i=1;i<N-1;i++)
        {

                 sth=0;
                 if(tab1[i+j*N]==0)
                 {
                 if(tab1[i+1+j*N]==0 && tab1[i+(j-1)*N]==0 )
                                {
                                sth++;
                                }
                 if(tab1[i+1+j*N]==0 && tab1[i+(j+1)*N]==0 )
                                {
                                sth++;
                                }
                 if(tab1[i+(j+1)*N]==0 && tab1[i-1+j*N]==0 )
                                {
                                sth++;
                                }
                 if(tab1[i+(j-1)*N]==0 && tab1[i-1+j*N]==0 )
                                {
                                sth++;
                                }
              
                  if(sth==1)
                     {
                     po=new struct point;
                     po[0].i1=i;
                     po[0].j1=j;
                     point1_list->Add(po);
                     }
                  }
                  }



//looking for the edges


int pom;
    for(int i=0;i<point1_list->Count;i++)
        {
        pom=0;
        po1=(struct point*) point1_list->Items[i];

        for(int j=0;j<point1_list->Count;j++)
        if(i!=j)
                {
                po2=(struct point*) point1_list->Items[j];
                if(po2->i1!=po1->i1)
                {
                a=(float)(po2->j1-po1->j1)/(float)(po2->i1-po1->i1);
                b=(float)po1->j1-(float)a*po1->i1;
                }
                else
                {
                a=0;
                b=po1->i1;
                }
                if(po1->i1>po2->i1)
                {xmax=po1->i1;xmin=po2->i1;}
                else
                {xmax=po2->i1;xmin=po1->i1;}

                if(po1->j1>po2->j1)
                {ymax=po1->j1;ymin=po2->j1;}
                else
                {ymax=po2->j1;ymin=po1->j1;}

                ob1=sqrt((xmax-xmin)*(xmax-xmin)+(ymax-ymin)*(ymax-ymin));
                ob2=0;
                for(int k=xmin-3;k<xmax+3;k++)
                for(int l=ymin-2;l<ymax+2;l++)
                        {
                        if(po2->i1!=po1->i1)
                                {
                                if( tab1[k+l*N]==0 && a*k+b-5<l && a*k+b+5>l)
                                ob2+=1;
                                }
                        else
                             {
                             if( tab1[k+l*N]==0 && l<ymax+2 && l>ymin-2)
                             ob2+=1;
                             }
                        }
               if(po2->i1!=po1->i1)
               ob2*=0.9*sqrt(2);
                if(ob2<=1.5*ob1 && ob2>=0.9*ob1)
                        {
                        for(int k=xmin-1;k<xmax+1;k++)
                        for(int l=ymin-1;l<ymax+1;l++)
                                {
                               // if( a*k+b-3<l && a*k+b+3>l)
                                 // ;
                                tab1[k+l*N]=1;
                                }
                         
                         lin =new struct line;
                         lin->x1=po1->i1;
                         lin->y1=po1->j1;
                         lin->x2=po2->i1;
                         lin->y2=po2->j1;
                         pom++;
                         line1_list->Add(lin);
                         }

                }
                if(pom>1)
                {
                point1_list->Delete(i);
                i--;
                }
         }
struct line* line1=new struct line;
struct line* line2=new struct line;
for(int i=0;i<line1_list->Count;i++)
        {
        line1=(struct line*) line1_list->Items[i];
        for(int j=0;j<line1_list->Count;j++)
                if(i!=j)
                {
                 line2=(struct line*) line1_list->Items[j];
                 if(( line1->x1==line2->x1 && line1->y1==line2->y1 && line1->x2==line2->x2 &&line1->y2==line2->y2 )||
                   ( line1->x1==line2->x2 && line1->y1==line2->y2 && line1->x2==line2->x1 &&line1->y2==line2->y1 ))
                   {line1_list->Delete(i);i--;break;}
                 }

        }
//add lines to rectangle


struct line* line3=new struct line;

for(int i=0;i<line1_list->Count;i++)
        {
        pom=0;
        line1=(struct line*) line1_list->Items[i];

        for(int j=0;j<line1_list->Count;j++)
                if(i!=j)
                {
                 line2=(struct line*) line1_list->Items[j];
                 if((line2->x1==line1->x1 && line2->y1==line1->y1)||(line2->x2==line1->x2 && line2->y2==line1->y2))
                        {
                        if(line2->x1==line1->x1 && line2->y1==line1->y1)
                                {
                                sth=0;

                                        //rectangle
                                        rec=new struct rectangle;
                                        rec->x1=line1->x1;
                                        rec->y1=line1->y1;
                                        rec->x2=line1->x2;
                                        rec->y2=line1->y2;
                                        rec->x4=line2->x2;
                                        rec->y4=line2->y2;
                                        line1_list->Delete(j);
                                        line1_list->Delete(i);
                                        i--;
                                        for(int k=0;k<line1_list->Count;k++)
                                                {
                                                line3=(struct line*) line1_list->Items[k];
                                                if((line3->x1==line1->x2 && line3->y1==line1->y2 && line3->x2!=line2->x2 && line3->y2!=line1->y2)||(line3->x2==line1->x2 && line3->y2==line1->y2 && line3->x1!=line1->x2 && line3->y1!=line1->y2))
                                                        {
                                                        if(line3->x1==line1->x2 && line3->y1==line1->y2)
                                                                {
                                                                rec->x3=line3->x2;
                                                                rec->y3=line3->y2;
                                                                line1_list->Delete(k);
                                                                break;
                                                                }
                                                        else
                                                                {
                                                                rec->x3=line3->x1;
                                                                rec->y3=line3->y1;
                                                                line1_list->Delete(k);
                                                                break;
                                                                }
                                                        }
                                                } //k

                                        rectangle_list->Add(rec);
                                        for(int k=0;k<line1_list->Count;k++)
                                                {
                                                line3=(struct line*) line1_list->Items[k];
                                                if((line3->x1==line2->x2 && line3->y1==line2->y2)||(line3->x2==line2->x2 && line3->y2==line2->y2))
                                                        {
                                                        line1_list->Delete(k);
                                                        break;
                                                        }
                                                }
                                                break;
                                        } //x1==x1


                                else
                                        {
                                        rec=new struct rectangle;
                                        rec->x1=line1->x2;
                                        rec->y1=line1->y2;
                                        rec->x2=line1->x2;
                                        rec->y2=line1->y2;
                                        rec->x4=line2->x1;
                                        rec->y4=line2->y1;
                                        line1_list->Delete(j);
                                        line1_list->Delete(i);
                                        i--;
                                         for(int k=0;k<line1_list->Count;k++)
                                                {
                                                line3=(struct line*) line1_list->Items[k];
                                                if((line3->x1==line1->x1 && line3->y1==line1->y1 && line3->x2!=line2->x1 && line3->y2!=line1->y1)||(line3->x2==line1->x1 && line3->y2==line1->y1 && line3->x1!=line1->x1 && line3->y1!=line1->y1))
                                                        {
                                                        if(line3->x1==line1->x1 && line3->y1==line1->y1)
                                                                {
                                                                rec->x3=line3->x2;
                                                                rec->y3=line3->y2;
                                                                line1_list->Delete(k);
                                                                break;
                                                                }

                                                else
                                                        {
                                                        rec->x3=line3->x1;
                                                        rec->y3=line3->y1;
                                                        line1_list->Delete(k);
                                                        break;
                                                        }
                                                        }
                                                } //k

                                        rectangle_list->Add(rec);
                                        for(int k=0;k<line1_list->Count;k++)
                                                {
                                                line3=(struct line*) line1_list->Items[k];
                                                if((line3->x1==line2->x1 && line3->y1==line2->y1)||(line3->x2==line2->x1 && line3->y2==line2->y1))
                                                        {
                                                        line1_list->Delete(k);
                                                        break;
                                                        }
                                                }
                                           break;
                                        }


                        }
                }//j

        }  //i


for(int i=0;i<line1_list->Count;i++)
        {
        line1_list->Delete(i);
        }
for(int i=0;i<point1_list->Count;i++)
        {
        point1_list->Delete(i);
        }
//kopniete
for(int j=1;j<M-1;j++)
for(int i=1;i<N-1;i++)
        {

                 sth=0;
                 if(tab1[i+j*N]==0)
                 {


                  if(tab1[i+1+(j-1)*N]==0 && tab1[i+1+(j+1)*N]==0 )
                                {
                                sth++;
                                }
                   if(tab1[i+1+(j-1)*N]==0 && tab1[i-1+(j-1)*N]==0 )
                                {
                                sth++;
                                }
                    if(tab1[i-1+(j-1)*N]==0 && tab1[i-1+(j+1)*N]==0 )
                                {
                                sth++;
                                }
                     if(tab1[i-1+(j+1)*N]==0 && tab1[i+1+(j+1)*N]==0)
                                {
                                sth++;
                                }

                  if(sth==1)
                     {
                     po=new struct point;
                     po[0].i1=i;
                     po[0].j1=j;
                     point1_list->Add(po);
                     }
                  }
        }



//looking for the edges



    for(int i=0;i<point1_list->Count;i++)
        {
        pom=0;
        po1=(struct point*) point1_list->Items[i];

        for(int j=0;j<point1_list->Count;j++)
        if(i!=j)
                {
                po2=(struct point*) point1_list->Items[j];
                if(po2->i1!=po1->i1)
                {
                a=(float)(po2->j1-po1->j1)/(float)(po2->i1-po1->i1);
                b=(float)po1->j1-(float)a*po1->i1;
                }
                else
                {
                a=0;
                b=po1->i1;
                }
                if(po1->i1>po2->i1)
                {xmax=po1->i1;xmin=po2->i1;}
                else
                {xmax=po2->i1;xmin=po1->i1;}

                if(po1->j1>po2->j1)
                {ymax=po1->j1;ymin=po2->j1;}
                else
                {ymax=po2->j1;ymin=po1->j1;}

                ob1=sqrt((xmax-xmin)*(xmax-xmin)+(ymax-ymin)*(ymax-ymin));
                ob2=0;
                for(int k=xmin-3;k<xmax+3;k++)
                for(int l=ymin-2;l<ymax+2;l++)
                        {
                        if(po2->i1!=po1->i1)
                                {
                                if( tab1[k+l*N]==0 && a*k+b-5<l && a*k+b+5>l)
                                ob2+=1;
                                }
                        else
                             {
                             if( tab1[k+l*N]==0 && l<ymax+2 && l>ymin-2)
                             ob2+=1;
                             }
                        }
               if(po2->i1!=po1->i1)
               ob2*=0.9*sqrt(2);
                if(ob2<=1.5*ob1 && ob2>=0.9*ob1)
                        {
                       for(int k=xmin-1;k<xmax+1;k++)
                        for(int l=ymin-1;l<ymax+1;l++)
                                {
                                //if( a*k+b-3<l && a*k+b+3>l)
                                // ;
                                tab1[k+l*N]=1;
                                }

                         lin =new struct line;
                         lin->x1=po1->i1;
                         lin->y1=po1->j1;
                         lin->x2=po2->i1;
                         lin->y2=po2->j1;
                         pom++;
                         line1_list->Add(lin);
                         }

                }
                if(pom>1)
                {
                point1_list->Delete(i);
                i--;
                }
         }

for(int i=0;i<line1_list->Count;i++)
        {
        line1=(struct line*) line1_list->Items[i];
        for(int j=0;j<line1_list->Count;j++)
                if(i!=j)
                {
                 line2=(struct line*) line1_list->Items[j];
                 if(( line1->x1==line2->x1 && line1->y1==line2->y1 && line1->x2==line2->x2 &&line1->y2==line2->y2 )||
                   ( line1->x1==line2->x2 && line1->y1==line2->y2 && line1->x2==line2->x1 &&line1->y2==line2->y1 ))
                   {line1_list->Delete(i);i--;break;}
                 }

        }
//add lines to rectangle




for(int i=0;i<line1_list->Count;i++)
        {
        pom=0;
        line1=(struct line*) line1_list->Items[i];

        for(int j=0;j<line1_list->Count;j++)
                if(i!=j)
                {
                 line2=(struct line*) line1_list->Items[j];
                 if((line2->x1==line1->x1 && line2->y1==line1->y1)||(line2->x2==line1->x2 && line2->y2==line1->y2))
                        {
                        if(line2->x1==line1->x1 && line2->y1==line1->y1)
                                {
                                sth=0;
                                                                
                                        //rectangle
                                        rec=new struct rectangle;
                                        rec->x1=line1->x1;
                                        rec->y1=line1->y1;
                                        rec->x2=line1->x2;
                                        rec->y2=line1->y2;
                                        rec->x4=line2->x2;
                                        rec->y4=line2->y2;
                                        line1_list->Delete(j);
                                        line1_list->Delete(i);
                                        i--;
                                        for(int k=0;k<line1_list->Count;k++)
                                                {
                                                line3=(struct line*) line1_list->Items[k];
                                                if((line3->x1==line1->x2 && line3->y1==line1->y2 && line3->x2!=line2->x2 && line3->y2!=line1->y2)||(line3->x2==line1->x2 && line3->y2==line1->y2 && line3->x1!=line1->x2 && line3->y1!=line1->y2))
                                                        {
                                                        if(line3->x1==line1->x2 && line3->y1==line1->y2)
                                                                {
                                                                rec->x3=line3->x2;
                                                                rec->y3=line3->y2;
                                                                line1_list->Delete(k);
                                                                break;
                                                                }

                                                else
                                                        {
                                                        rec->x3=line3->x1;
                                                        rec->y3=line3->y1;
                                                        line1_list->Delete(k);
                                                        break;
                                                        }
                                                        }
                                                } //k

                                        rectangle_list->Add(rec);
                                        for(int k=0;k<line1_list->Count;k++)
                                                {
                                                line3=(struct line*) line1_list->Items[k];
                                                if((line3->x1==line2->x2 && line3->y1==line2->y2)||(line3->x2==line2->x2 && line3->y2==line2->y2))
                                                        {
                                                        line1_list->Delete(k);
                                                        break;
                                                        }
                                                }
                                        } //x1==x1


                                else
                                        {
                                        rec=new struct rectangle;
                                        rec->x1=line1->x2;
                                        rec->y1=line1->y2;
                                        rec->x2=line1->x2;
                                        rec->y2=line1->y2;
                                        rec->x4=line2->x1;
                                        rec->y4=line2->y1;
                                        line1_list->Delete(j);
                                        line1_list->Delete(i);
                                        i--;
                                         for(int k=0;k<line1_list->Count;k++)
                                                {
                                                line3=(struct line*) line1_list->Items[k];
                                                if((line3->x1==line1->x1 && line3->y1==line1->y1 && line3->x2!=line2->x1 && line3->y2!=line1->y1)||(line3->x2==line1->x1 && line3->y2==line1->y1 && line3->x1!=line1->x1 && line3->y1!=line1->y1))
                                                        {
                                                        if(line3->x1==line1->x1 && line3->y1==line1->y1)
                                                                {
                                                                rec->x3=line3->x2;
                                                                rec->y3=line3->y2;
                                                                line1_list->Delete(k);
                                                                break;
                                                                }

                                                else
                                                        {
                                                        rec->x3=line3->x1;
                                                        rec->y3=line3->y1;
                                                        line1_list->Delete(k);
                                                        break;
                                                        }
                                                        }
                                                } //k

                                        rectangle_list->Add(rec);
                                        for(int k=0;k<line1_list->Count;k++)
                                                {
                                                line3=(struct line*) line1_list->Items[k];
                                                if((line3->x1==line2->x1 && line3->y1==line2->y1)||(line3->x2==line2->x1 && line3->y2==line2->y1))
                                                        {
                                                        line1_list->Delete(k);
                                                        break;
                                                        }
                                                }
                                        }


                        }
                }//j

        }  //i


//cleaning input

for(int i=0;i<line1_list->Count;i++)
        {
        line1_list->Delete(i);
        }
for(int i=0;i<point1_list->Count;i++)
        {
        point1_list->Delete(i);
        }

}

//---------------------------------------------------------------------------
#include<stdlib.h>
void TForm1::Find_circle(TList* list,int* tab)
{
struct vector *vec1,*vec2;
circ =new struct circle;
TList *list1=new TList;
int j1,j2,i1,i2;
for (int i = 5; i < N-5; i++)
for (int j = 5; j < M-5; j++)
             if(tab[i+j*N]==0)
                 {
                  for (int k = -10; k < 10; k++)
                  for (int l = -10; l < 10; l++)
                             if(tab[i+k+(j+l)*N]==0 && k!=0 && l!=0)
                             { i1=k+i;j1=l+j;break;}
                  for (int k = -10; k < 10; k++)
                  for (int l = -10; l < 10; l++)
                             if(tab[i+k+(j+l)*N]==0 && k!=0 && l!=0 && i+k+(j+l)*N!=i1+j1*N)
                             { i2=k+i;j2=l+j;}
                  ala(i,j,i2,j2,i1,j1,circ);
                  if(isacircle(circ,tab))
                  {i=-1;break;}

                }

}

//---------------------------------------------------------------------------
void TForm1::ala(int x1,int y1,int x2,int y2,int x3,int y3,circle* circ)
{
if((x2-x1)*(y3-y1)-(y2-y1)*(x3-x1)==0)
{
circ->x=0;
circ->y=0;
circ->r=0;
}
else
{
circ->x=((y3-y1)*(x2*x2-x1*x1+y2*y2-y1*y1)-(y2-y1)*(x3*x3-x1*x1+y3*y3-y1*y1))/
((x2-x1)*(y3-y1)-(y2-y1)*(x3-x1))*0.5;
circ->y=((x1-x3)*(x2*x2-x1*x1+y2*y2-y1*y1)-(x1-x2)*(x3*x3-x1*x1+y3*y3-y1*y1))/
((x2-x1)*(y3-y1)-(y2-y1)*(x3-x1))*0.5;
circ->r=sqrt((x1-circ->x)*(x1-circ->x)+(y1-circ->y)*(y1-circ->y));
}
}
//---------------------------------------------------------------------------
TList *TForm1::Find_pie(TList* list)
{
return 0;
}
//---------------------------------------------------------------------------
int TForm1::isacircle(struct circle * circ,int* tab1)
{
if(circ->r<10)
return 0;
struct vector *vec1;
int sum=0;

float sum1=2*M_PI*circ->r;
if(circ->x+circ->r +3>N)
return 0;
if(circ->x-circ->r -3<0)
return 0;
if(circ->y+circ->r +3>M)
return 0;
if(circ->y-circ->r -3<0)
return 0;

for(int i=circ->x-circ->r-3;i<circ->x+circ->r+3;i++)
for(int j=circ->y-circ->r-3;j<circ->y+circ->r+3;j++)
     if( tab1[i+j*N]==0)
     sum++;
if(sum)
{
int aa;
aa=0;
}
sum*=sqrt(2);
double pom1,pom2,pom3;

if(sum>=0.6*sum1 &&sum<=1.4*sum1)
        {
       for(int i=circ->x-circ->r-3;i<circ->x+circ->r+3;i++)
        for(int j=circ->y-circ->r-3;j<circ->y+circ->r+3;j++)
        if( tab1[i+j*N]==0)
        tab1[i+j*N]=1;
        circle_list->Add(circ);
         return 1;
        }
return 0;

}



/*
void TForm1::vectorisation1(int*tab1)
{
t1=new int [N*M];
t1=f(tab1,mask1);
//t1=f2(t1);
t2=new int [N*M];
t2=f(tab1,mask2);
//t2=f2(t2);
t3=new int [N*M];
t3=f(tab1,mask3);
//t3=f2(t3);
t4=new int [N*M];
t4=f(tab1,mask4);
//t4=f2(t4);
ttx=new float [N*M];
tty=new float [N*M];
float s2=1./sqrt(2);
for(int i=1;i<N-1;i++)
    for(int j=1;j<M-1;j++)
    {
    ttx[i+j*N]=(1*t2[i+j*N]+s2*t4[i+j*N]-s2*t3[i+j*N]+6*s2)*10;
    tty[i+j*N]=(-s2*t4[i+j*N]+1*t1[i+j*N]+s2*t3[i+j*N]+6*s2)*10;
    }

Bitmap1 = new Graphics::TBitmap();
Bitmap1->Width=N ;
Bitmap1->Height=M;

Bitmap1->Canvas->Brush->Color=clWhite;
Bitmap1->Canvas->Pen->Color=clBlack;
Bitmap1->Canvas->Pen->Width=1;
tab=new int [N*M];
for(int i=1;i<N-1;i++)
    for(int j=1;j<M-1;j++)
    {
    tab[i+j*N]=(int)ttx[i+j*N]+256*(int)tty[i+j*N];
    }

//tab=f2(tab);
//tab=f2(tab);
/*for(int i=1;i<N-1;i++)
    for(int j=1;j<M-1;j++)
    {
    Bitmap1->Canvas->Pixels[i][j]=tab[i+j*N];
    }
//Image1->Picture->Assign(Bitmap1);
//Image1->Refresh();
V(tab,tab1);
sh();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Image1MouseMove(TObject *Sender, TShiftState Shift,
      int X, int Y)
{
StatusBar1->SimpleText=IntToStr(Image1->Canvas->Pixels[X][Y] &0xFF )+IntToStr((Image1->Canvas->Pixels[X][Y] >>8)&0xFF );
}
//---------------------------------------------------------------------------
int *TForm1::f2(int*t)
 {
int *ttt=new int [N*M];
 float sum;
 int no;
 for(int i=1;i<N-1;i++)
    for(int j=1;j<M-1;j++)
    {
    sum=0.0;

    no=0.0;
    if(t[i+j*N]<0.2)
    {
    int sum1=0;
    int sum2=0;
    for(int k=-1;k<2;k++)
    for(int l=-1;l<2;l++)
        {
        if(t[i+k+(j+l)*N]>0)
        {
        sum1+=(t[i+k+(j+l)*N])&0xFF;
        sum2+=((t[i+k+(j+l)*N])>>8)&0xFF;
        no+=1;}

        }
        if(no)
        sum=(int)(sum1/no)+256*(int)(sum2/no);




                ttt[i+j*N]=sum;

        }
      else
       ttt[i+j*N]=t[i+j*N];
    }

   return ttt;
 }
//---------------------------------------------------------------------------
TList *TForm1::V(int*angle,int*t)
{
lvector_list = new TList;
int x1,y1,x2,y2;
int c1,c2;
float c11,c12,b;
float cmin;
for(int i=1;i<N-1;i++)
    for(int j=1;j<M-1;j++)
    if(cmin>angle[i+j*N])
    cmin=angle[i+j*N];

for(int i=1;i<N-1;i++)
    for(int j=1;j<M-1;j++)
    {
    if( angle[i+j*N]!=0)//t[i+j*N]==0 &&
        {
         c1=(angle[i+j*N])&0xFF;
         c2=((angle[i+j*N])>>8)&0xFF;

         c11=tan(atan2(c2-cmin,c1-cmin)-5/180.*M_PI);
         c12=tan(atan2(c2-cmin,c1-cmin)+5/180.*M_PI);
         if(c11<c12);
         else
         {float c=c12;c12=c11;c11=c;}
         b=j-(c11+c12)/2.*i;
         //c=(float)(c2-42)/(c1-42);
         int xl,yl,xln,yln;
         xl=i;
         yl=j;

                do
                {
                xln=xl;
                yln=yl;
                for(int k=-7;k<7;k++)
                for(int l=-7;l<7;l++)
                        {
                        if(angle[k+xl+(l+yl)*N]!=0 && l*l+k*k>36)
                        if(c11*(k+xl)+b-10<=l+yl && c12*(k+xl)+b+10>=l+yl )
                                {
                                xl+=k;yl+=l;
                                }
                        }
                }
                while(xl!=xln && yl!=yln);

                if(i==xl && j==yl);
                else
                {
                vec=new struct vector;
                vec->i1=i;
                vec->j1=j;
                vec->i2=xl;
                vec->j2=yl;
                lvector_list->Add(vec);
                int pom,pom1;
                if(i>xl)
                        {pom=xl;pom1=i;}
                else
                        {pom=i;pom1=xl;}
                for(int k=1;k<N-1;k++)
                for(int l=1;l<M-1;l++)
                if(k<pom1+6 && k>pom-6 &&l>=j && l<=yl)
                angle[i+j*N]=0;
                }
         }

    }
}
//---------------------------------------------------------------------------
int *TForm1::f(int*t,int**mask)
{
int *ttt=new int [N*M];
float val;
for(int i=1;i<N-1;i++)
    for(int j=1;j<M-1;j++)
    {
    val=0;
    for(int k=-1;k<2;k++)
    for(int l=-1;l<2;l++)
        {
        val+=mask[k+1][l+1]*t[i+k+(j+l)*N];
        }
       if(val<=0)
       val=0;
    ttt[i+j*N] =val;

    }
return ttt;
}
*/

void __fastcall TForm1::FormActivate(TObject *Sender)
{
 /*mask1 = new int*[3];
 mask2 = new int*[3];
  mask3 = new int*[3];
   mask4 = new int*[3];
       for (int j = 0; j < 3; j++)
           {
           mask1[j] = new int[3];
           mask2[j] = new int[3];
           mask3[j] = new int[3];
           mask4[j] = new int[3];
                      }
//pros
mask1[0][0]=-1;
mask1[0][1]=-1;
mask1[0][2]=-1;
mask1[1][0]=2;
mask1[1][1]=2;
mask1[1][2]=2;
mask1[2][0]=-1;
mask1[2][1]=-1;
mask1[2][2]=-1;

//row
mask2[0][0]=-1;
mask2[0][1]=2;
mask2[0][2]=-1;
mask2[1][0]=-1;
mask2[1][1]=2;
mask2[1][2]=-1;
mask2[2][0]=-1;
mask2[2][1]=2;
mask2[2][2]=-1;

// skosne w prawo     /
mask3[0][0]=2;
mask3[0][1]=-1;
mask3[0][2]=-2;
mask3[1][0]=-1;
mask3[1][1]=2;
mask3[1][2]=-1;
mask3[2][0]=-2;
mask3[2][1]=-1;
mask3[2][2]=2;
//     w lewo        \
mask4[0][0]=-2;
mask4[0][1]=-1;
mask4[0][2]=2;
mask4[1][0]=-1;
mask4[1][1]=2;
mask4[1][2]=-1;
mask4[2][0]=2;
mask4[2][1]=-1;
mask4[2][2]=-2;


 */
}








int LIdistance(long a, long b) {
   return MAX3( ABS( TORED(a)-TORED(b) ), ABS( TOGREEN(a)-TOGREEN(b) ), ABS( TOBLUE(a)-TOBLUE(b) ) );
}

int L1distance(long a, long b) {
   return ABS( TORED(a)-TORED(b) ) + ABS( TOGREEN(a)-TOGREEN(b) ) + ABS( TOBLUE(a)-TOBLUE(b) );
}

int Eucldistance(long a, long b) {
   return sqrt( SQR( TORED(a)-TORED(b) ) + SQR( TOGREEN(a)-TOGREEN(b) ) + SQR( TOBLUE(a)-TOBLUE(b) ) );
}


/* THE SLICER FUNCTION */

Graphics::TBitmap *slicer(int (*newDist)(long, long), AnsiString filNam, double TH, double VTH) {
   static Graphics::TBitmap *original;
   static Graphics::TBitmap *processed;
   static Graphics::TBitmap *distance;
   static Graphics::TBitmap *output;
   static int actY, actX;
   static int (*dist)(long, long);
   static int hist[800];
   static int level;
   double THval, VTHval, newTHval;

   /* closing the function usage */
   if (!TH && !VTH) {
      if (original) delete original; if (processed) delete processed;
      if (distance) delete distance; if (output) delete output;
      return NULL;
   }

   /* change distance function used */
   if (newDist) dist = newDist;

   /* initialize if file name is given */
   if (filNam != "") {
      if (original) delete original; if (processed) delete processed;
      if (distance) delete distance; if (output) delete output;
      original = new Graphics::TBitmap();
      original -> LoadFromFile(filNam);
      processed = new Graphics::TBitmap(); distance  = new Graphics::TBitmap();
      output    = new Graphics::TBitmap();
      processed->Height = original->Height; distance->Height = original->Height;
      output->Height = original->Height; processed->Width = original->Width;
      distance->Width = original->Width; output->Width = original->Width;
      actY = actX = 0; level = 0;
      for (int x = 0; x < original->Width; ++x)
         for (int y = 0; y < original->Height; ++y)
            processed->Canvas->Pixels[x][y] = 0;
   }

   /* looking for the seed pixel and returning NULL if no seed is available*/
   while (actY < processed->Height && processed->Canvas->Pixels[actX][actY]) {
     ++actX;
     if (actX == processed->Width) { actX = 0; ++actY; }
   }
   if (actY == processed->Height) return NULL;
   //printf("\nSeed coordinates: %i,%i\n", actX, actY);

   ++level;
   /* calculation THval and VTHval and resetting the histogram */
   THval  = dist(0, 0x00FFFFFF)*TH/100;
   VTHval = original->Height*original->Width*VTH/100;
   for (int i = 0; i < dist(0, 0x00FFFFFF); ++i)
      hist[i] = 0;

   /* creating the distance image and the histogram */
   int actDist; long seedColor = original->Canvas->Pixels[actX][actY];
   for (int x = 0; x < original->Width; ++x)
      for (int y = 0; y < original->Height; ++y) {
         actDist = dist(seedColor, original->Canvas->Pixels[x][y]);
         distance->Canvas->Pixels[x][y] = actDist;
         ++hist[actDist];
      }

   // saving the distance image
   /*{
      Graphics::TBitmap *toSave = new Graphics::TBitmap;
      long c; int maxDist = dist(0, 0x00FFFFFF);
      toSave->Height = distance->Height; toSave->Width = distance->Width;
      for (int x = 0; x < toSave->Width; ++x)
         for (int y = 0; y < toSave->Height; ++y) {
            c = (double) distance->Canvas->Pixels[x][y] / maxDist * 255;
            toSave->Canvas->Pixels[x][y] = TOCOLOR(c, c, c);
         }
      printf("Saving distance image \tno. %i\tby seed at (%i,%i)\n", level-1, actX, actY);
      toSave->SaveToFile((AnsiString) DISTFILENAME + (level-1) + ".BMP");
   }*/

   /* searching for minimal threshold value */
   newTHval = THval;
   {  int numofExtr = 0;
      int extremas[800]; short extrtype[800]; // +1 : max, -1 : min
      // searching for local extremas
      if (hist[0] != hist[1]) {
         ++numofExtr; extremas[0] = 0;
         if (hist[0] > hist[1]) extrtype[0] = 1;
         else extrtype[0] = -1;
      }
      for (int i = 1; i < THval-1; ++i) {
         if (hist[i] > hist[i-1] && hist[i] > hist[i+1]) {
            extremas[numofExtr] = i; extrtype[numofExtr] = 1;
            ++numofExtr;
         } else if (hist[i] < hist[i-1] && hist[i] < hist[i+1]) {
            extremas[numofExtr] = i; extrtype[numofExtr] = -1;
            ++numofExtr;
         }
      }
      // searching for extrema distances larger than Vertical Threshold
      for (int i = 0; i < numofExtr && extremas[i] < newTHval; ++i)
         if (extrtype[i] == 1)
            for (int j = i+1; j < numofExtr && extremas[j] < newTHval; ++j)
               if ((extrtype[j] == -1) && (hist[extremas[i]]-hist[extremas[j]] >= VTHval))
                  newTHval = extremas[j];

   }

   /* thresholding the image */
   for (int y = 0; y < distance->Height; ++y)
      for (int x = 0; x < distance->Width; ++x)
         if (!processed->Canvas->Pixels[x][y] && distance->Canvas->Pixels[x][y] <= newTHval) {
            output->Canvas->Pixels[x][y] = 0x00FFFFFF;
            processed->Canvas->Pixels[x][y] = 1;
         } else output->Canvas->Pixels[x][y] = 0;

   /* saving the histogram
   FILE *fil = fopen(((AnsiString) DISTFILENAME + level + ".TXT").c_str(), "w");
   fprintf(fil, "Seed coordinates: ( %i, %i )\n", actX, actY);
   fprintf(fil, "Seed colour: %x\n\n", original->Canvas->Pixels[actX][actY]);
   fprintf(fil, "Original THval: %i\n", THval);
   fprintf(fil, "New      THval: %i\n", newTHval);
   fprintf(fil, "Vertical TH   : %i\n\n", VTHval);
   for (int i = 0; i < dist(0, 0x00FFFFFF); ++i)
      fprintf(fil, "%i\n", hist[i]);
   fclose(fil);*/

   // marking the seed pixel
   //output->Canvas->Pixels[actX][actY] = 0x00FF0000;
   return output;
}