//C++ Program for Map Building

/* 
The map building program has been developed in the C++ environment. 
The program builds the map of the obstacles and the room boundary by  
depth-first traversal following an order priority-based directed search.
Author: Srikanta Patnaik and Team 
Machine Intelligence Laboratory, University College of Engineering, Burla, India
Date of Writing: April, 2003; Version: 1.0
Book: Robot Cognition and Navigation: An Experiment with Mobile Robots
Publisher: Springer
ISBN: 978-3-540-23446-3
URL: http://www.springer.com/3-540-23446-2
 
*/

/* Program for Map Building */
#include<iostream.h>
#include<graphics.h>
#include<conio.h>
#include<math.h>
#include<process.h>
#include<stdio.h>
#include<dos.h>

/*This is the structure of each position around the obstacle containing the (x,y) coordinate, sensing the (x,y) coordinate in 8 direction and the pointer to the next position*/

struct gnode
 {
 int x;
 int y;
 int array[16];
 gnode* next;
};
 /* Structure of linked list maintained for all
the obstacles in the work space */
 struct list
{ int number;
int connect_x; /* x coordinate of the previous obstacle*/
int connect_y; /* y coordinate of the previous obstacle */
int to_x;      /* x coordinate of the next  obstacle */
int to_y;      /*y coordinate of the next obstacle */
int isboundary; /* this is a flag indicating whether this is a room boundary or an obstacle*/
gnode* pointer; //pointer to the obstacle linked list
list* link;
};

int setbit=0;  int setx=5;int sety=5;
int somemore=1;
int nonewset=1;
char obstacles;
 char b_ary[]={48};

/* This is the pointer to the file to which we are storing the world map information*/
 FILE* fileptr;
 list* bigstart;
 list* start; //pointer to a link list of one obstacle
 gnode* dup_list; //temp global variable
 gnode* boundary_list;/*point to the linklist of room boundary */
 gnode* obstucle_list;  /*point to the linked list of obstacle */
 int count=1;
 int i=0;
 int ax,bx,cx,dx;
 int l1,l2;
 int step=4; 
 int  array[2000];
int k,l,m,n;
 int boundary_x;
int boundary_y;
 int boundary[2000];
 int dary[2000];
 gnode* traverse(int,int);/*this function will travrse around one obstacle */
void function(gnode*); /*use the travrse funct. for subsequent movement before backtracking */
 list* reverse_list(list*); /*reversal of linked list for display purpose */
 void show1(void);   //display fuction

/* find distance between two coordinates*/
 double distance( int x1,int y1,int x2,int y2)
{
double dist= sqrt((double)(x2-x1)*(double)(x2-x1)+ (double)(y2-y1)*(double)(y2-y1));
return dist;
}

/*it will draw the boundary of the room*/
void draw_boundary(void)
{
int arr2[20]={80,80,400,80,400,400,80,400};
int arr1[20]={50,50,430,50,430,430,50,430};
setcolor(LIGHTRED);
setfillstyle(SOLID_FILL,LIGHTRED);
setlinestyle(SOLID_LINE,0,THICK_WIDTH);
fillpoly(4,arr1);
setcolor(WHITE);
setfillstyle(SOLID_FILL,WHITE);
setlinestyle(SOLID_LINE,0,THICK_WIDTH);
fillpoly(4,arr2);

}
///////////////////////////////////////////////////////
/*check into north direction and  will
return the obstacle free  coordinates */

gnode* north_check(int x,int y)
{
int k=x;int l=y;
while(getpixel(x,y)!=GREEN)
{
 if(getpixel(x,y)==LIGHTRED)
 {
 gnode* ptr= new gnode;
 ptr->x=x;
 ptr->y=y;
 ptr->next=NULL;
 return ptr;
}
 y++;
}
gnode* ptr=new gnode;
ptr->x=k;
ptr->y=l;
ptr->next=NULL;
return ptr;
}
//////////////////////////////////////////////////

gnode* north_east_check(int x,int y)
{
int k=x;int l=y;
while(getpixel(x,y)!=GREEN)
{
if (getpixel(x,y)==LIGHTRED)
{   gnode* ptr= new gnode;
ptr->x=x;
ptr->y=y;
ptr->next=NULL;
return ptr;
}
x--; y++;

}
gnode* ptr=new gnode;
ptr->x=k;
ptr->y=l;
ptr->next=NULL;
return ptr;
}
/////////////////////////////////////////////////////
gnode* east_check(int x,int y)
{
int k=x;int l=y;
while(getpixel(x,y)!=GREEN)
{
if (getpixel(x,y)==LIGHTRED)
{   gnode* ptr= new gnode;
ptr->x=x;
ptr->y=y;
ptr->next=NULL;
return ptr;
}
x--;
}
gnode* ptr=new gnode;
ptr->x=k;
ptr->y=l;
ptr->next=NULL;
return ptr;
}
////////////////////////////////////////////
gnode* east_south_check(int x,int y)
{
int k=x;int l=y;

while(getpixel(x,y)!=GREEN)
{
if (getpixel(x,y)==LIGHTRED)
{
gnode* ptr= new gnode;
ptr->x=x;
ptr->y=y;
ptr->next=NULL;
return ptr;
}
x--; y--;

}
gnode* ptr=new gnode;
ptr->x=k;
ptr->y=l;
ptr->next=NULL;
return ptr;
}
  ////////////////////////////////////////
gnode* south_check(int x,int y)
{
int k=x;int l=y;
while(getpixel(x,y)!=GREEN)
{
if (getpixel(x,y)==LIGHTRED)
{
gnode* ptr= new gnode;
ptr->x=x;
ptr->y=y;
ptr->next=NULL;
return ptr;
}
y--;

}
gnode* ptr=new gnode;
ptr->x=k;
ptr->y=l;
ptr->next=NULL;
return ptr;
}
 /////////////////////////////////////////
gnode* south_west_check(int x,int y)
{
int k=x;int l=y;
while(getpixel(x,y)!=GREEN)
{
if (getpixel(x,y)==LIGHTRED)
{
gnode* ptr= new gnode;
ptr->x=x;
ptr->y=y;
ptr->next=NULL;
return ptr;
}
x++; y--;
}
gnode* ptr=new gnode;
ptr->x=k;
ptr->y=l;
ptr->next=NULL;
return ptr;
}
/////////////////////////////////////////

gnode* west_check(int x,int y)
{
int k=x;int l=y;
while(getpixel(x,y)!=GREEN)
{
if (getpixel(x,y)==LIGHTRED)
{
gnode* ptr= new gnode;
ptr->x=x;
ptr->y=y;
ptr->next=NULL;
return ptr;
}
x++;
}
gnode* ptr=new gnode;
ptr->x=k;
ptr->y=l;
ptr->next=NULL;
return ptr;
}
///////////////////////////////////////////
gnode* west_north_check(int x,int y)
{
int k=x;int l=y;
while(getpixel(x,y)!=GREEN)
{
if (getpixel(x,y)==LIGHTRED)
{
gnode* ptr= new gnode;
ptr->x=x;
ptr->y=y;
ptr->next=NULL;
return ptr;
}
x++; y++;
}
gnode* ptr=new gnode;
ptr->x=k;
ptr->y=l;
ptr->next=NULL;
return ptr;
	}
//////////////////////////////////////////
/* created obstacle*/
int elements=4;
int arr[10]={140,120,170,100,185,120,175,140};
int brr[10]={240,120,270,140,225,164,210,135};
int crr[10]={178,160,200,180,185,200,170,180};
int drr[10]={245,175,285,200,258,204,230,190};
int err[10]={310,215,360,240,330,270,298,250};
int frr[10]={110,245,130,225,180,240,130,280};
int grr[10]={230,258,270,250,250,280,220,280};
int hrr[10]={220,320,230,300,250,330,230,340};
int krr[10]={190,330,210,350,180,370,170,350};

//////////////make function/////////////
/*traverse function will traverse around the obstacle*/
gnode* traverse(int xco,int yco)
{
int it;
 gnode* ptr1=new gnode;
 ptr1->x=xco;
 ptr1->y=yco;
ptr1->next=NULL;
 gnode* start=ptr1;
 int t1,t2;
do
 {
 //north
t1=ptr1->x;
t2=(ptr1->y)+step;
it=getpixel(t1,t2);
if(it==LIGHTRED)
 {
ptr1->array[0]=0;
ptr1->array[1]=0;
 }
  else
 { ptr1->array[0]=t1;
ptr1->array[1]=t2;
}
//ne
 t1=(ptr1->x)-step;
  t2=(ptr1->y)+step;
it=getpixel(t1,t2);
if(it==LIGHTRED)
{
ptr1->array[2]=0;
ptr1->array[3]=0;
}
else
{ ptr1->array[2]=t1;
ptr1->array[3]=t2;
}
//east
t1=(ptr1->x)-step;
t2=ptr1->y;
it=getpixel(t1,t2);
if(it==LIGHTRED)
{
 ptr1->array[4]=0;
 ptr1->array[5]=0;
}
 else
 { ptr1->array[4]=t1;
ptr1->array[5]=t2;
}
 //se
t1=(ptr1->x)-step;
t2=(ptr1->y)-step;
it=getpixel(t1,t2);
if(it==LIGHTRED)
  {
 ptr1->array[6]=0;
 ptr1->array[7]=0;
 }
  else
 { ptr1->array[6]=t1;
ptr1->array[7]=t2;
}
  //south
t1=ptr1->x;
t2=(ptr1->y)-step;
it=getpixel(t1,t2);
if(it==LIGHTRED)
  {
 ptr1->array[8]=0;
 ptr1->array[9]=0;
 }
  else
 { ptr1->array[8]=t1;
ptr1->array[9]=t2;
}
 //sw
 t1=(ptr1->x)+step;
 t2=(ptr1->y)-step;
it=getpixel(t1,t2);
if(it==LIGHTRED)
  {
 ptr1->array[10]=0;
 ptr1->array[11]=0;
 }
 else
 { ptr1->array[10]=t1;
ptr1->array[11]=t2;
}
//west
 t1=(ptr1->x)+step;
 t2=ptr1->y;
it=getpixel(t1,t2);
if(it==LIGHTRED)
  {
 ptr1->array[12]=0;
 ptr1->array[13]=0;
 }
  else
  { ptr1->array[12]=t1;
ptr1->array[13]=t2;
}
 //wn
  t1=(ptr1->x)+step;
  t2=(ptr1->y)+step;
it=getpixel(t1,t2);
if(it==LIGHTRED)
{
 ptr1->array[14]=0;
 ptr1->array[15]=0;
 }
 else
 { ptr1->array[14]=t1;
ptr1->array[15] =t2;
}
///////////////////////////////////////////////////////////////////////
 /*condition for checking the neighborhood pixel for the next movement*/
 if((ptr1->array[i]==0))
{
 while(ptr1->array[i]==0) i++;
 }
 else
 {
while(ptr1->array[i]!=0) i++;

while(ptr1->array[i]==0) i++;
}
 if((ptr1->array[14]==0)&&(ptr1->array[15]==0))
 { i=0;
  if((ptr1->array[i]==0))
 {
 while(ptr1->array[i]==0) i++;
  }
 }
 /* inserting into linkedlist*/
gnode* ptr2= new gnode;
ptr2->x=ptr1->array[i]; i++;
ptr2->y=ptr1->array[i];
ptr2->next=ptr1;
ptr1=ptr2;
count++;
i=0;
}while(!(((ptr1->x)>=(xco-3))&&((ptr1->x)<=(xco+3))&&((ptr1->y)<=(yco+3))&&((ptr1->y)>=(yco-3))));    //loop upto the same starting point reaches
 start=ptr1;
 return start;
}
/*show function to show the traversal path*/
void show1()
{
int k=0;  list* ptr=bigstart;
ptr=ptr->link;
gnode* tem=ptr->pointer;
while(ptr)
{
while(tem)
{
boundary[k++]=tem->x;
boundary[k++]=tem->y;
tem=tem->next;
}               k--;k/=2;
setcolor(GREEN);
setfillstyle(SOLID_FILL,LIGHTRED);
setlinestyle(SOLID_LINE,0,THICK_WIDTH);
drawpoly(k,boundary);
 ptr=ptr->link;
}
getch();
}
 /*display used in the no of obstacle visited  */
void erase(int x1,int y1,int x2,int y2,int color)
{     int j;
  for(int i=x1;i<x2;i++)
  	for(j=y1;j<y2;j++)
putpixel(i,j,color);
}

//////////////////////////////////////////////
void main()
{
 int stx;
 int sty;

 cout<<"robot starts at x(85-395)="; cin>>stx;
 cout<<"robot starts at y(85-395)=";cin>>sty;

/*initialise the graphics mode*/
int driver,mode;
driver=DETECT;
initgraph(&driver,&mode,"e:\\tcc\\bgi");
  /* drawing room boundary*/
draw_boundary();
setcolor(LIGHTRED);
setfillstyle(SOLID_FILL,LIGHTRED);
setlinestyle(SOLID_LINE,0,THICK_WIDTH);
   /*drawing various obstacle*/
 fillpoly(4,arr);
 fillpoly(4,brr);
 fillpoly(4,crr);
 fillpoly(4,drr);
 fillpoly(4,err);
 fillpoly(4,frr);
 fillpoly(4,grr);
 fillpoly(4,hrr);
 fillpoly(4,krr);
 /*checking the starting position is on the obstacle or not*/
int jet=getpixel(stx,sty);
if(jet==LIGHTRED)
{
   cout<<"you are on the obstucle"<<endl;
   cout<<"press any key to terminate"<<endl;
   getch();
   exit(0);
}
 setcolor(BLUE);
 circle(stx,sty,5);
 setcolor(LIGHTRED);
 ////////////////////////////////////////////////////////
getch();
 /*checking into 8 directions */
double d[9];
int xc=stx;
int yc=sty;
int x[9];
int y[9];

while(getpixel(xc,yc)!=LIGHTRED) yc++;
x[1]=xc; y[1]=--yc; xc=stx; yc=sty;

 while(getpixel(xc,yc)!=LIGHTRED){ yc++; xc--;}
x[2]=++xc; y[2]=--yc; xc=stx; yc=sty;

 while(getpixel(xc,yc)!=LIGHTRED) xc--;
x[3]=++xc; y[3]=yc; xc=stx; yc=sty;

while(getpixel(xc,yc)!=LIGHTRED) {yc--;xc--;}
x[4]=++xc; y[4]=++yc; xc=stx; yc=sty;
		
 while(getpixel(xc,yc)!=LIGHTRED) yc--;
x[5]=xc; y[5]=++yc; xc=stx; yc=sty;

  while(getpixel(xc,yc)!=LIGHTRED) {yc--;xc++;}
x[6]=--xc; y[6]=++yc; xc=stx; yc=sty;

 while(getpixel(xc,yc)!=LIGHTRED) xc++;
x[7]=--xc; y[7]=yc; xc=stx; yc=sty;

 while(getpixel(xc,yc)!=LIGHTRED) {yc++;xc++;}
x[8]=--xc; y[8]=--yc; xc=stx; yc=sty;
 /*finding the distances in 8 directions*/
d[1]=distance(xc,yc,x[1],y[1]);
d[2]=distance(xc,yc,x[2],y[2]);
d[3]=distance(xc,yc,x[3],y[3]);
d[4]=distance(xc,yc,x[4],y[4]);
d[5]=distance(xc,yc,x[5],y[5]);
d[6]=distance(xc,yc,x[6],y[6]);
d[7]=distance(xc,yc,x[7],y[7]);
d[8]=distance(xc,yc,x[8],y[8]);

double mind=d[1];
int minx=x[1]; int miny=y[1];
for(int i=2;i<9; i++)
		{
  if(mind>d[i]){  mind=d[i];minx=x[i]; miny=y[i];}
  }
 /*finding the shortest distance of obstacle*/
  if(minx>400)minx=398;
  if(miny>400)miny=398;
  if(minx<80) minx=82;
  if(miny<80) miny=82;
 /*generates an initial node and go into the loop */


  start=new list;
 start->link=NULL;     k=0;   gnode* one;
 start->pointer=traverse(minx,miny);
 one=start->pointer;
 while(one->next)
 { dary[k++]=one->x;
  dary[k++]=one->y;
   one=one->next;
   }
   k--; l=k/2;
setcolor(GREEN); /*not to traverse the same obstacle twice */
drawpoly(l,dary);
line(dary[0],dary[1],dary[k-5],dary[k-4]);
setcolor(LIGHTRED);
bigstart=start;
dup_list=start->pointer;
dup_list=dup_list->next;
while(somemore==1)
{
function(dup_list);   }
//      modifying
list* alpha;
alpha=bigstart;
alpha=alpha->link;    somemore=1;
//
while(alpha)
{
dup_list=alpha->pointer;
//	   dup_list=dup_list->next;
//	   int nonewset;
//	   while(alpha)
//		   while(somemore==1)
{
function(dup_list);
}
}
getch();
closegraph();   //generation of linkedlist is over
initgraph(&driver,&mode,"e:\\tcc\\bgi");
getch();
setcolor(GREEN); int z1,z2,z3,z4;
circle(stx,sty,5);
alpha=bigstart;
bigstart=reverse_list(bigstart);
alpha=bigstart;
// line(stx,sty,alpha->pointer->x,alpha->pointer->y);
gnode* qqq;
while(alpha)
{
qqq=alpha->pointer;
while(qqq->next)
{  z1=qqq->x;
z2=qqq->y;
z3=qqq->next->x;
z4=qqq->next->y;
line(z1,z2,z3,z4);
//	 sound(1000);
//	   delay(50);
//	   nosound();
qqq=qqq->next;
}
alpha=alpha->link;
//	  line(alpha->connect_x,alpha->connect_y,alpha->to_x,alpha->to_y);
 }
getch();
closegraph();
/*showing the robot simulation of movement*/
initgraph(&driver,&mode,"e:\\tcc\\bgi");
draw_boundary();
setcolor(LIGHTRED);
setfillstyle(SOLID_FILL,LIGHTRED);
setlinestyle(SOLID_LINE,0,THICK_WIDTH);
fillpoly(4,arr);
fillpoly(4,arr);
fillpoly(4,brr);
fillpoly(4,crr);
fillpoly(4,drr);
fillpoly(4,err);
fillpoly(4,frr);
fillpoly(4,grr);
fillpoly(4,hrr);
fillpoly(4,krr);

char a1[]="After visiting ";
char b1[]="obstacle";
char d1[]="   ";
char e1[10][10]={ {"1st"},{"2nd"},{" 3rd"},{"4th"}, {"5th"},
{"6th"},{" 7th"},{"8th"}, {" 9th"},{"10th"}};
int pp=0;
int zz=450;
circle(stx,sty,5);
settextstyle(1,0,2);
alpha=bigstart;
setcolor(GREEN);

line(stx,sty,alpha->pointer->x,alpha->pointer->y);
k=0;l=0;  int mm=0;
while(alpha)
{  qqq=alpha->pointer; k=0;l=0;
while(qqq)
{
dary[k++]=qqq->x;
dary[k++]=qqq->y;
qqq=qqq->next;
}
k--; l=k/2;
setcolor(GREEN);
for(mm=0;mm<k-4;mm+=2)
{ line(dary[mm],dary[mm+1],dary[mm+2],dary[mm+3]);
//	   	sound(1000);
		delay(50);
		nosound();
	   }
//	 drawpoly(l,dary);
/////////////////////////////////////
//text inclusion

obstacles=b_ary[0];
obstacles++;
b_ary[0]=obstacles;
//   b_ary[0]=obstacles++;
//	setusercharsize(2,1,2,1);
settextstyle(1,0,2);
setcolor(WHITE);
moveto(450,150);
outtext(a1);
settextstyle(1,0,2);
zz+=8;
erase(450,175,540,195,BLACK);//moveto(zz,175);
//	outtext("   ");
moveto(zz,175);
outtext(e1[pp]);//b_ary);
settextstyle(1,0,2);
moveto(450,200);
outtext(b1);
pp++;
setcolor(GREEN);
line(dary[0],dary[1],dary[k-5],dary[k-4]);
alpha=alpha->link;
getch();
line(alpha->connect_x,alpha->connect_y,alpha->to_x,alpha->to_y);
   /*connecting line between two obstacle*/
}

getch();
closegraph();
////////////////////
initgraph(&driver,&mode,"e:\\tcc\\bgi");
alpha=bigstart;
k=0;l=0;
while(alpha)
{  qqq=alpha->pointer; k=0;l=0;
while(qqq)
{
 dary[k++]=qqq->x;
 dary[k++]=qqq->y;
 qqq=qqq->next;
 }
 k--; l=k/2;
 setcolor(GREEN);
 fillpoly(l,dary);
//  line(dary[0],dary[1],dary[k-5],dary[k-4]);
 // setcolor(LIGHTRED);
 if(getpixel(stx,sty)==WHITE)
 {
 alpha->isboundary=1;
 }
 closegraph();
initgraph(&driver,&mode,"e:\\tcc\\bgi");
alpha=alpha->link;
}

closegraph();

fileptr=fopen("c:\\coord.dat","w");
/*the room and the obstacle boundaries and stored in the file
coord.dat*/
alpha=bigstart;
while( alpha)
{
qqq=alpha->pointer;
if(alpha->isboundary==1)
//	{ cout<<"boundary"<<endl; getch();  }
fprintf(fileptr,"boundary\n");
else
//	{ cout<<"obstacle"<<endl;  getch();}
{ fprintf(fileptr,"obstucle\n");}
while(qqq)
{
//	cout<<qqq->x<<"  "<<qqq->y;
 fprintf(fileptr,"(%d,%d)", qqq->x,qqq->y);
qqq=qqq->next;
  }
// cout<<endl; getch();
fprintf(fileptr,"\n");
alpha=alpha->link;
 }
fclose(fileptr);
getch();
clrscr();
cout<<" coordinates are stored in c:\\coord.dat file.";
getch();
  }
  /*this function will traverse all the obstacle and
  stops before back tracking */
 void function(gnode* ptr)
{   gnode* ptr2;       double dist;  int a,b,c,d;
gnode* ptr1=ptr; gnode* qqq;
int mintx=1000;
 int minty=1000;
int nextx=1000;
int nexty=1000;
 double mind=1000.0;        int ss;
//checking north of all points
ptr1=ptr1->next;
while(ptr1->next->next)
{   ss=getpixel(ptr1->x,(ptr1->y)+5);
if(ss!=GREEN)

{if(getpixel(ptr1->x,(ptr1->y)+5)!=LIGHTRED)
{
ptr2=north_check(ptr1->x,(ptr1->y)+5);
a=ptr1->x;
b=(ptr1->y)+5;
c=ptr2->x;
d=ptr2->y;
 if((a!=c)||(b!=d))
{
dist= distance(ptr1->x,(ptr1->y)+5,ptr2->x,ptr2->y);
if(dist<mind)
{mind=dist;mintx=a;minty=b;nextx=c;nexty=d;}
}
}
}
ptr1=ptr1->next;
}
ax=mintx;
bx=minty;
cx=nextx;
dx=nexty;
 if((ax!=1000)&&(bx!=1000)&&(cx!=1000)&&(dx!=1000))
{
if(nextx>400)nextx=398;
if(nexty>400)nexty=398;
if(nextx<80)nextx=82;
if(nexty<80)nexty=82;
start=new list;
start->connect_x=ax;
start->connect_y=bx;
start->to_x=cx;
start->to_y=dx;
if(nexty==398)
{start->pointer=traverse(nextx,nexty);}
else
{ start->pointer=traverse(nextx,nexty-1);}
  /////////////////////////////////////

qqq=start->pointer; k=0;l=0;
while(qqq)
{
 dary[k++]=qqq->x;
dary[k++]=qqq->y;
qqq=qqq->next;
}
k--; l=k/2;
setcolor(GREEN);
drawpoly(l,dary);
line(dary[0],dary[1],dary[k-5],dary[k-4]);
setcolor(LIGHTRED);
 /////////////////////////////////////
dup_list=start->pointer;
somemore=1;
start->link=bigstart;
bigstart=start;
return;
 }
//checking into north-east direction
ptr=dup_list->next;
ptr1=ptr;
mintx=1000;
minty=1000;
nextx=1000;
nexty=1000;
mind=1000.0;
ptr1=ptr1->next;
while(ptr1->next->next)
{   ss=getpixel((ptr1->x)-5,(ptr1->y)+5);
if(ss!=GREEN)
{
if(getpixel((ptr1->x)-5,(ptr1->y)+5)!=LIGHTRED)
{
ptr2=north_east_check((ptr1->x)-5,(ptr1->y)+5);
a=(ptr1->x)-5;
b=(ptr1->y)+5;
c=ptr2->x;
d=ptr2->y;
if((a!=c)||(b!=d))
{
dist= distance((ptr1->x)-5,(ptr1->y)+5,ptr2->x,ptr2->y);
 if(dist<mind)
{mind=dist;mintx=a;minty=b;nextx=c;nexty=d;}
}

}
}
ptr1=ptr1->next;
}
ax=mintx;
bx=minty;
cx=nextx;
dx=nexty;
	if((ax!=1000)&&(bx!=1000)&&(cx!=1000)&&(dx!=1000))
{
if(nextx>400)nextx=398;
if(nexty>400)nexty=398;
if(nextx<80)nextx=82;
if(nexty<80)nexty=82;
start=new list;
start->connect_x=ax;
start->connect_y=bx;
start->to_x=cx;
start->to_y=dx;
if((nexty==398)||(nextx==82))
{start->pointer=traverse(nextx,nexty);}
 else
{start->pointer=traverse(nextx+1,nexty-1);}
 /////////////////////////////////////

qqq=start->pointer; k=0;l=0;
while(qqq)
{
dary[k++]=qqq->x;
dary[k++]=qqq->y;
qqq=qqq->next;
}
k--; l=k/2;
setcolor(GREEN);
drawpoly(l,dary);
line(dary[0],dary[1],dary[k-5],dary[k-4]);
setcolor(LIGHTRED);
/////////////////////////////////////
dup_list=start->pointer;
somemore=1;
start->link=bigstart;
bigstart=start;
return;
}

//	checking into east direction
ptr=dup_list->next;
ptr1=ptr;
mintx=1000;
minty=1000;
nextx=1000;
nexty=1000;
mind=1000.0;
ptr1=ptr1->next;
while(ptr1->next->next)
{   ss=getpixel((ptr1->x)-5,ptr1->y);
 if(ss!=GREEN)
{
 if(getpixel((ptr1->x)-5,ptr1->y)!=LIGHTRED)
{
ptr2=east_check((ptr1->x)-5,ptr1->y);
a=(ptr1->x)-5;
b=(ptr1->y);
c=ptr2->x;
d=ptr2->y;
 if((a!=c)||(b!=d))
{
dist= distance((ptr1->x)-5,ptr1->y,ptr2->x,ptr2->y);
if(dist<mind)
{mind=dist;mintx=a;minty=b;nextx=c;nexty=d;}
}
}
}
ptr1=ptr1->next;
}
ax=mintx;
bx=minty;
cx=nextx;
dx=nexty;
if((ax!=1000)&&(bx!=1000)&&(cx!=1000)&&(dx!=1000))
{
if(nextx>400)nextx=398;
if(nexty>400)nexty=398;
if(nextx<80)nextx=82;
if(nexty<80)nexty=82;
start=new list;
start->connect_x=ax;
start->connect_y=bx;
start->to_x=cx;
start->to_y=dx;
if((nexty==398)||(nextx==82))
{start->pointer=traverse(nextx,nexty);}
	else
{ start->pointer=traverse(nextx+1,nexty);}
 /////////////////////////////////////
qqq=start->pointer; k=0;l=0;
while(qqq)
{
dary[k++]=qqq->x;
dary[k++]=qqq->y;
qqq=qqq->next;
}
k--; l=k/2;
setcolor(GREEN);
drawpoly(l,dary);
line(dary[0],dary[1],dary[k-5],dary[k-4]);
setcolor(LIGHTRED);

/////////////////////////////////////
dup_list=start->pointer;
somemore=1;
start->link=bigstart;
bigstart=start;
return;
}
//checking into east-south direction
ptr=dup_list->next;
ptr1=ptr;
mintx=1000;
minty=1000;
nextx=1000;
nexty=1000;
mind=1000.0;
ptr1=ptr1->next;
while(ptr1->next->next)
{   ss=getpixel((ptr1->x)-5,(ptr1->y)-5);
if(ss!=GREEN)
  {
if(getpixel((ptr1->x)-5,(ptr1->y)-5)!=LIGHTRED)
{
ptr2=east_south_check((ptr1->x)-5,(ptr1->y)-5);
a=(ptr1->x)-5;
b=(ptr1->y)-5;
c=ptr2->x;
d=ptr2->y;
if((a!=c)||(b!=d))
{
dist= distance((ptr1->x)-5,(ptr1->y)-5,ptr2->x,ptr2->y);
if(dist<mind)
{mind=dist;mintx=a;minty=b;nextx=c;nexty=d;}
}
}
}
ptr1=ptr1->next;
}
ax=mintx;
bx=minty;
cx=nextx;
dx=nexty;

if((ax!=1000)&&(bx!=1000)&&(cx!=1000)&&(dx!=1000))
{
if(nextx>400)nextx=398;
if(nexty>400)nexty=398;
if(nextx<80)nextx=82;
if(nexty<80)nexty=82;
start=new list;
start->connect_x=ax;
start->connect_y=bx;
start->to_x=cx;
start->to_y=dx;
if((nexty==398)||(nextx==82))
{start->pointer=traverse(nextx,nexty);}
else
{ start->pointer=traverse(nextx+1,nexty+1);}
/////////////////////////////////////
qqq=start->pointer; k=0;l=0;
while(qqq)
{
dary[k++]=qqq->x;
dary[k++]=qqq->y;
qqq=qqq->next;
}
k--; l=k/2;
setcolor(GREEN);
drawpoly(l,dary);
line(dary[0],dary[1],dary[k-5],dary[k-4]);
setcolor(LIGHTRED);
  /////////////////////////////////////
dup_list=start->pointer;
somemore=1;
start->link=bigstart;
bigstart=start;
return;
}
//checking into south direction
ptr=dup_list->next;
ptr1=ptr;
mintx=1000;
minty=1000;
nextx=1000;
nexty=1000;
mind=1000.0;
ptr1=ptr1->next;
while(ptr1->next->next)
{   ss=getpixel(ptr1->x,(ptr1->y)-5);
if(ss!=GREEN)
{
if(getpixel(ptr1->x,(ptr1->y)-5)!=LIGHTRED)
{
ptr2=south_check(ptr1->x,(ptr1->y)-5);
a=ptr1->x;
b=(ptr1->y)-5;
c=ptr2->x;
d=ptr2->y;
if((a!=c)||(b!=d))
{
dist= distance(ptr1->x,(ptr1->y)-5,ptr2->x,ptr2->y);
if(dist<mind)
  {mind=dist;mintx=a;minty=b;nextx=c;nexty=d;}
}
}
}
ptr1=ptr1->next;
		}
ax=mintx;
bx=minty;
cx=nextx;
dx=nexty;
if((ax!=1000)&&(bx!=1000)&&(cx!=1000)&&(dx!=1000))
{
if(nextx>400)nextx=398;
if(nexty>400)nexty=398;
if(nextx<80)nextx=82;
if(nexty<80)nexty=82;
start=new list;
start->connect_x=ax;
start->connect_y=bx;
start->to_x=cx;
start->to_y=dx;
if((nexty==398)||(nextx==82))
{start->pointer=traverse(nextx,nexty);}
else
{ start->pointer=traverse(nextx,nexty+1);}
/////////////////////////////////////
qqq=start->pointer; k=0;l=0;
while(qqq)
{
dary[k++]=qqq->x;
dary[k++]=qqq->y;
qqq=qqq->next;
}
k--; l=k/2;
setcolor(GREEN);
drawpoly(l,dary);
line(dary[0],dary[1],dary[k-5],dary[k-4]);
setcolor(LIGHTRED);

/////////////////////////////////////

dup_list=start->pointer;
somemore=1;
start->link=bigstart;
bigstart=start;
return;
}
//checking into south-west direction

ptr=dup_list->next;
ptr1=ptr;
mintx=1000;
minty=1000;
nextx=1000;
nexty=1000;
mind=1000.0;
ptr1=ptr1->next;
while(ptr1->next->next)
{   ss=getpixel((ptr1->x)+5,(ptr1->y)-5);
if(ss!=GREEN)
{
if(getpixel((ptr1->x)+5,(ptr1->y)-5)!=LIGHTRED)
{
ptr2=south_west_check((ptr1->x)+5,(ptr1->y)-5);
a=(ptr1->x)+5;
b=(ptr1->y)-5;
c=ptr2->x;
d=ptr2->y;
if((a!=c)||(b!=d))
{
dist= distance((ptr1->x)+5,(ptr1->y)-5,ptr2->x,ptr2->y);
i(dist<mind)
{mind=dist;mintx=a;minty=b;nextx=c;nexty=d;}
}
}
}
ptr1=ptr1->next;
}
ax=mintx;
bx=minty;
cx=nextx;
dx=nexty;
if((ax!=1000)&&(bx!=1000)&&(cx!=1000)&&(dx!=1000))
  {
if(nextx>400)nextx=398;
if(nexty>400)nexty=398;
if(nextx<80)nextx=82;
if(nexty<80)nexty=82;
start=new list;
start->connect_x=ax;
start->connect_y=bx;
start->to_x=cx;
start->to_y=dx;
if((nexty==398)||(nextx==82))
{start->pointer=traverse(nextx,nexty);}
	else
 {start->pointer=traverse(nextx-1,nexty+1);}
/////////////////////////////////////

qqq=start->pointer; k=0;l=0;
while(qqq)
{
 dary[k++]=qqq->x;
 dary[k++]=qqq->y;
 qqq=qqq->next;
  }
k--; l=k/2;
setcolor(GREEN);
drawpoly(l,dary);
line(dary[0],dary[1],dary[k-5],dary[k-4]);
setcolor(LIGHTRED);

 /////////////////////////////////////
dup_list=start->pointer;
somemore=1;
start->link=bigstart;
bigstart=start;
return;
}

//checking into west direction
ptr=dup_list->next;
ptr1=ptr;
mintx=1000;
minty=1000;
nextx=1000;
nexty=1000;
mind=1000.0;
ptr1=ptr1->next;
 while(ptr1->next->next)
{ ss=getpixel((ptr1->x)+5,ptr1->y);
   if(ss!=GREEN)
  {
if(getpixel((ptr1->x)+5,ptr1->y)!=LIGHTRED)
 {
ptr2=west_check((ptr1->x)+5,ptr1->y);
a=(ptr1->x)+5;
b=(ptr1->y);
c=ptr2->x;    setx=c;

d=ptr2->y;    sety=d;

if((a!=c)||(b!=d))
{
dist= distance((ptr1->x)+5,ptr1->y,ptr2->x,ptr2->y);
if(dist<mind)
{mind=dist;mintx=a;minty=b;nextx=c;nexty=d;}
}
}
}
ptr1=ptr1->next;
}
ax=mintx;
bx=minty;
cx=nextx;
dx=nexty;
if((ax!=1000)&&(bx!=1000)&&(cx!=1000)&&(dx!=1000))
{
if(nextx>400)nextx=398;
if(nexty>400)nexty=398;
if(nextx<80)nextx=82;
if(nexty<80)nexty=82;
start=new list;
start->connect_x=ax;
start->connect_y=bx;
start->to_x=cx;
start->to_y=dx;
if(nexty==398)
{start->pointer=traverse(nextx,nexty);}
	else
 start->pointer=traverse(nextx-1,nexty);}
  /////////////////////////////////////

qqq=start->pointer; k=0;l=0;
while(qqq)
{
dary[k++]=qqq->x;
dary[k++]=qqq->y;
qqq=qqq->next;
}
k--; l=k/2;
setcolor(GREEN);
drawpoly(l,dary);
line(dary[0],dary[1],dary[k-5],dary[k-4]);
setcolor(LIGHTRED);

/////////////////////////////////////
dup_list=start->pointer;
somemore=1;
start->link=bigstart;
bigstart=start;
return;
}
	
//checking into west-north direction
ptr=dup_list->next;
ptr1=ptr;
mintx=1000;
minty=1000;
nextx=1000;
nexty=1000;
mind=1000.0;
ptr1=ptr1->next;
while(ptr1->next->next)
{ss=getpixel((ptr1->x)+5,(ptr1->y)+5);
if(ss!=GREEN)
  {
if(getpixel((ptr1->x)+5,(ptr1->y)+5)!=LIGHTRED)
{
ptr2=west_north_check((ptr1->x)+5,(ptr1->y)+5);
a=(ptr1->x)+5;
b=(ptr1->y)+5;
c=ptr2->x;
d=ptr2->y;
if((a!=c)||(b!=d))
{
dist= distance((ptr1->x)+5,(ptr1->y)+5,ptr2->x,ptr2->y);
if(dist<mind)
{mind=dist;mintx=a;minty=b;nextx=c;nexty=d;}

}
}
}
ptr1=ptr1->next;
}
ax=mintx;
bx=minty;
cx=nextx;
dx=nexty;
if((ax!=1000)&&(bx!=1000)&&(cx!=1000)&&(dx!=1000))
{
if(nextx>400)nextx=398;
if(nexty>400)nexty=398;
if(nextx<80)nextx=82;
if(nexty<80)nexty=82;
start=new list;
start->connect_x=ax;
start->connect_y=bx;
start->to_x=cx;
start->to_y=dx;
if((nexty==398)||(nextx==82))
{start->pointer=traverse(nextx,nexty);}
else
{ start->pointer=traverse(nextx-1,nexty-1);}

/////////////////////////////////////
qqq=start->pointer; k=0;l=0;
while(qqq)
{
dary[k++]=qqq->x;
dary[k++]=qqq->y;
qqq=qqq->next;
}
k--; l=k/2;
setcolor(GREEN);
drawpoly(l,dary);
line(dary[0],dary[1],dary[k-5],dary[k-4]);
setcolor(LIGHTRED);

 /////////////////////////////////////
dup_list=start->pointer;
somemore=1;
start->link=bigstart;
bigstart=start;
return;
}
somemore=0;
nonewset=1;
}

list* reverse_list(list* ptr)
{
list* ptr1= ptr->link;
ptr->link=NULL;
list* ptr2=ptr;
ptr=ptr1;
while(ptr)
{
ptr1=ptr->link;
ptr->link=ptr2;
ptr2=ptr;
ptr=ptr1;
}
return ptr2;
}

