map.h

These mobility generator tools are used to generate a rich set of mobility scenarios used to evalua

//Date: June 22
//Name: map.h in "manhattan" project
//Desc: State the Map class and define all the function

#ifndef MAP_H_
#define MAP_H_

#include "manhattan.h"

/*=* For manhattan map *=*/

struct cross_point{
	int crosspoint_id;
	int street_id;
	int lane_id;
	int direction;
	float x,y;
};

struct lane_structure{
	int street_id;
	int lane_id;
	int type; // horizontal 0; vertical 1; 
	int direction;	//direction vs. inverse direction
					//+1: left-->right, top-->bottom
					//-1: right--->left, bottom--->top
	int crosspoint_num;

	float x0,y0;
	float x1,y1;
	float vmin,vmax;

	float length;
	float angle; 

	struct cross_point *crosspoint;
};

class Map{

	friend class Node;

	private:
		int map_status; //=0,no obstacle; =1,obstacle; =2,freeway; =3,manhattan
		
	public:
		int num_of_hor_street;
		int num_of_ver_street;
		int num_of_lane;	//total num of lanes in the map
		struct lane_structure *lane_array; //lane[lane_num]
		
		void map_read(char* filename);
		void map_show();
		
		void map_gene(char* filename);

		int find_crspnt(int overall_lane_id, float x, float y);	
};


// generate the map file //
void Map::map_gene(char* filename)
{
	FILE *fp;

	int i,j;
	int lane_num;

	printf("Input: \n");
	printf("ver_num:"); scanf("%d",&num_of_ver_street);
	printf("hor_num:"); scanf("%d",&num_of_hor_street);
	printf("lane_num:"); scanf("%d",&lane_num);
	num_of_lane = lane_num * (num_of_ver_street + num_of_hor_street);

	lane_array = new struct lane_structure[num_of_lane];

	float hor_space = (float)HEIGHT / (num_of_hor_street+1);
	float ver_space = (float)WIDTH / (num_of_ver_street+1); 

	for(i = 0; i < num_of_hor_street; i++)
		for(j = 0; j < lane_num; j++)
		{
			lane_array[i*lane_num+j].type = HORIZONTAL;
			lane_array[i*lane_num+j].street_id = i;
			lane_array[i*lane_num+j].lane_id = j;
			
			if(j==0 || j==2 || j==4)
				lane_array[i*lane_num+j].direction = 1;
			else if (j==1 || j==3 || j==5)
				lane_array[i*lane_num+j].direction = -1;
			
			lane_array[i*lane_num+j].crosspoint_num = lane_num * num_of_ver_street;
			lane_array[i*lane_num+j].crosspoint = new struct cross_point[lane_num * num_of_ver_street];
		

			if(lane_array[i*lane_num+j].direction == 1)
			{		lane_array[i*lane_num+j].x0 = 0 + 0.100000;	
					lane_array[i*lane_num+j].x1 = WIDTH - 0.100000;	}
			else
			{		lane_array[i*lane_num+j].x0 = WIDTH - 0.100000;	 
					lane_array[i*lane_num+j].x1 = 0 + 0.100000;	}

			lane_array[i*lane_num+j].y0 = ver_space * (i+1) - int(lane_num/2) + j;
			lane_array[i*lane_num+j].y1 = ver_space * (i+1) - int(lane_num/2) + j;

			lane_array[i*lane_num+j].vmin=VMIN;	
			lane_array[i*lane_num+j].vmax=VMAX;
		}


	for(i = 0; i < num_of_ver_street; i++)
		for(j = 0; j < lane_num; j++)
		{
			lane_array[(num_of_hor_street+i)*lane_num+j].type = VERTICAL;
			lane_array[(num_of_hor_street+i)*lane_num+j].street_id = i+num_of_hor_street;
			lane_array[(num_of_hor_street+i)*lane_num+j].lane_id = j;
			
			if(j==0 || j==2 || j==4)
				lane_array[(num_of_hor_street+i)*lane_num+j].direction = 1;
			else if (j==1 || j==3 || j==5)
				lane_array[(num_of_hor_street+i)*lane_num+j].direction = -1;
			
			lane_array[(num_of_hor_street+i)*lane_num+j].crosspoint_num = lane_num * num_of_hor_street;
			lane_array[(num_of_hor_street+i)*lane_num+j].crosspoint = new struct cross_point[lane_num * num_of_ver_street];


			if(lane_array[i*lane_num+j].direction == 1)
			{		lane_array[(num_of_hor_street+i)*lane_num+j].y1 = 0 + 0.100000;	
					lane_array[(num_of_hor_street+i)*lane_num+j].y0 = WIDTH - 0.100000;	}
			else
			{		lane_array[(num_of_hor_street+i)*lane_num+j].y1 = WIDTH - 0.100000;	 
					lane_array[(num_of_hor_street+i)*lane_num+j].y0 = 0 + 0.100000;	}

			lane_array[(num_of_hor_street+i)*lane_num+j].x0 = hor_space * (i+1) - int(lane_num/2) + j;
			lane_array[(num_of_hor_street+i)*lane_num+j].x1 = hor_space * (i+1) - int(lane_num/2) + j;

			lane_array[(num_of_hor_street+i)*lane_num+j].vmin=VMIN;	
			lane_array[(num_of_hor_street+i)*lane_num+j].vmax=VMAX;
		}

	//calculate the crosspoint for horizontal lanes
	for(i = 0; i < num_of_hor_street * lane_num; i++)
		for(j = 0; j < lane_array[i].crosspoint_num; j++)
		{
			if(lane_array[i].direction == 1){
				lane_array[i].crosspoint[j].crosspoint_id = j;
				lane_array[i].crosspoint[j].street_id 
					= lane_array[num_of_hor_street*lane_num+j].street_id ;
				lane_array[i].crosspoint[j].lane_id 
					= lane_array[num_of_hor_street*lane_num+j].lane_id ;
				lane_array[i].crosspoint[j].direction 
					= lane_array[num_of_hor_street*lane_num+j].direction ;
				lane_array[i].crosspoint[j].x =
					lane_array[num_of_hor_street*lane_num+j].x0;
				lane_array[i].crosspoint[j].y =
					lane_array[i].y0;
			}
			else if(lane_array[i].direction == -1){
				lane_array[i].crosspoint[lane_array[i].crosspoint_num-1-j].crosspoint_id = lane_array[i].crosspoint_num-1-j;
				lane_array[i].crosspoint[lane_array[i].crosspoint_num-1-j].street_id 
					= lane_array[num_of_hor_street*lane_num+j].street_id ;
				lane_array[i].crosspoint[lane_array[i].crosspoint_num-1-j].lane_id 
					= lane_array[num_of_hor_street*lane_num+j].lane_id ;
				lane_array[i].crosspoint[lane_array[i].crosspoint_num-1-j].direction 
					= lane_array[num_of_hor_street*lane_num+j].direction ;
				lane_array[i].crosspoint[lane_array[i].crosspoint_num-1-j].x =
					lane_array[num_of_hor_street*lane_num+j].x0;
				lane_array[i].crosspoint[lane_array[i].crosspoint_num-1-j].y =
					lane_array[i].y0;
			}
		}
	
	//calculate the crosspoint for vertical lanes
	for(i = num_of_hor_street * lane_num; i < (num_of_ver_street+num_of_hor_street) * lane_num; i++)
		for(j = 0; j < lane_array[i].crosspoint_num; j++)
		{	
			if(lane_array[i].direction == 1){
				lane_array[i].crosspoint[lane_array[i].crosspoint_num-1-j].crosspoint_id = lane_array[i].crosspoint_num-1-j;
				lane_array[i].crosspoint[lane_array[i].crosspoint_num-1-j].street_id 
					= lane_array[j].street_id ;
				lane_array[i].crosspoint[lane_array[i].crosspoint_num-1-j].lane_id 
					= lane_array[j].lane_id ;
				lane_array[i].crosspoint[lane_array[i].crosspoint_num-1-j].direction 
					= lane_array[j].direction ;
				lane_array[i].crosspoint[lane_array[i].crosspoint_num-1-j].x =
					lane_array[i].x0;
				lane_array[i].crosspoint[lane_array[i].crosspoint_num-1-j].y =
					lane_array[j].y0;
			}
			else if(lane_array[i].direction == -1){
				lane_array[i].crosspoint[j].crosspoint_id = j;
				lane_array[i].crosspoint[j].street_id 
					= lane_array[j].street_id ;
				lane_array[i].crosspoint[j].lane_id 
					= lane_array[j].lane_id ;
				lane_array[i].crosspoint[j].direction 
					= lane_array[j].direction ;
				lane_array[i].crosspoint[j].x =
					lane_array[i].x0;
				lane_array[i].crosspoint[j].y =
					lane_array[j].y0;
			}
		}


	fp = fopen(filename,"w");
	if(fp == NULL){
		printf("can not creat the file, exiting...\n");
		exit(-1);
	}

	fprintf(fp,"MANHATTAN\n");
	fprintf(fp,"HOR_STREET_NUM %d\n",num_of_hor_street);
	fprintf(fp,"VER_STREET_NUM %d\n",num_of_ver_street);
	fprintf(fp,"LANE_NUM %d\n",num_of_lane);

	for(i = 0; i < num_of_lane; i++)
	{
		fprintf(fp,"LANE %d %d %d %.2f %.2f %.2f %.2f %d %.2f %.2f\n",
			lane_array[i].street_id, lane_array[i].lane_id,
			lane_array[i].direction,
			lane_array[i].x0, lane_array[i].y0,
			lane_array[i].x1, lane_array[i].y1,
			lane_array[i].crosspoint_num,
			lane_array[i].vmin, lane_array[i].vmax);

		for(j = 0; j < lane_array[i].crosspoint_num; j++){
			fprintf(fp,"CROSSPOINT %d %d %d %d %.2f %.2f\n",
			lane_array[i].crosspoint[j].crosspoint_id,
			lane_array[i].crosspoint[j].street_id,
			lane_array[i].crosspoint[j].lane_id,
			lane_array[i].crosspoint[j].direction,
			lane_array[i].crosspoint[j].x,
			lane_array[i].crosspoint[j].y);
		}
	}
}




// read the map file //
void Map::map_read(char* filename)
{
	FILE *map_fp;
	
	char map_style[20];
	char openfield_sign[20]="OPENFIELD";
	char obstacle_sign[20]="OBSTACLE";
	char freeway_sign[20]="FREEWAY";
	char manhattan_sign[20]="MANHATTAN";
	
	char headword[20];
	char hor_str_num_sign[20]="HOR_STREET_NUM";
	char ver_str_num_sign[20]="VER_STREET_NUM";
	char lane_num_sign[20]="LANE_NUM";
	char lane_sign[20]="LANE";
	char crosspoint_sign[20]="CROSSPOINT";
	
	int temp1;
	float temp2;
	int i,j;

	map_fp = fopen(filename,"r");
	if(map_fp == NULL)
	{	printf("CANNOT find map file!\n");
		exit(0);
	}

	fscanf(map_fp,"%s",map_style);

	if(strcmp(map_style,openfield_sign)==0)
		map_status = OPENFIELD_MAP;
	else if(strcmp(map_style,obstacle_sign)==0)
		map_status = OBSTACLE_MAP;
	else if(strcmp(map_style,freeway_sign)==0)
		map_status=FREEWAY_MAP;
	else if(strcmp(map_style,manhattan_sign)==0)
		map_status=MANHATTAN_MAP;

	if(map_status==MANHATTAN_MAP)
	{
		fscanf(map_fp,"%s",headword);
		if(strcmp(headword,hor_str_num_sign)==0)
				fscanf(map_fp,"%d",&num_of_hor_street);
	
		fscanf(map_fp,"%s",headword);
		if(strcmp(headword,ver_str_num_sign)==0)
				fscanf(map_fp,"%d",&num_of_ver_street);

		fscanf(map_fp,"%s",headword);
		if(strcmp(headword,lane_num_sign)==0)
				fscanf(map_fp,"%d",&num_of_lane);

		lane_array = new struct lane_structure[num_of_lane];

		for(i=0;i<num_of_lane;i++)
		{
			fscanf(map_fp,"%s",headword);
			if(strcmp(headword,lane_sign)==0){
				
				fscanf(map_fp,"%d",&temp1);
				lane_array[i].street_id = temp1;

				fscanf(map_fp,"%d",&temp1);
				lane_array[i].lane_id = temp1;

				fscanf(map_fp,"%d",&temp1);
				lane_array[i].direction = temp1;
		
				fscanf(map_fp,"%f",&temp2);
				lane_array[i].x0 = temp2;

				fscanf(map_fp,"%f",&temp2);
				lane_array[i].y0 = temp2;

				fscanf(map_fp,"%f",&temp2);
				lane_array[i].x1 = temp2;

				fscanf(map_fp,"%f",&temp2);
				lane_array[i].y1 = temp2;

				fscanf(map_fp,"%d",&temp1);
				lane_array[i].crosspoint_num = temp1;

				fscanf(map_fp,"%f",&temp2);
				lane_array[i].vmin = temp2;

				fscanf(map_fp,"%f",&temp2);
				lane_array[i].vmax = temp2;

				lane_array[i].length = getmy_distance(lane_array[i].x0, lane_array[i].y0,
					lane_array[i].x1, lane_array[i].y1);
				//printf("length=%f\n",lane_array[i].length);
										
				lane_array[i].angle = getmy_angle(lane_array[i].x0, lane_array[i].y0,
					lane_array[i].x1, lane_array[i].y1);
				//printf("angle=%f\n",lane_array[i].angle);

				if(lane_array[i].x0 == lane_array[i].x1)
					lane_array[i].type = VERTICAL;
				else if(lane_array[i].y0 == lane_array[i].y1)
					lane_array[i].type = HORIZONTAL;

			}
			lane_array[i].crosspoint = new struct cross_point[lane_array[i].crosspoint_num];
			
			for(j = 0; j < lane_array[i].crosspoint_num; j++)
			{
				fscanf(map_fp,"%s",headword);
				if(strcmp(headword,crosspoint_sign)==0){
					
					fscanf(map_fp,"%d",&temp1);
					lane_array[i].crosspoint[j].crosspoint_id = temp1;

					fscanf(map_fp,"%d",&temp1);
					lane_array[i].crosspoint[j].street_id = temp1;

					fscanf(map_fp,"%d",&temp1);
					lane_array[i].crosspoint[j].lane_id = temp1;

					fscanf(map_fp,"%d",&temp1);
					lane_array[i].crosspoint[j].direction = temp1;

					fscanf(map_fp,"%f",&temp2);
					lane_array[i].crosspoint[j].x = temp2;
					fscanf(map_fp,"%f",&temp2);
					lane_array[i].crosspoint[j].y = temp2;
				}// if
			}// for j
		}// for i
	}// if map_status ==  manhattan

	fclose(map_fp);
}



void Map::map_show()
{
	int i,j;

	printf("hor_street_num = %d, ", num_of_hor_street);
	printf("ver_street_num = %d\n", num_of_ver_street);
	printf("lane_num = %d\n", num_of_lane);

	for(i = 0; i < num_of_lane; i++)
	{
		printf("lane[%d][%d] <%d,%d> (%f,%f)->(%f,%f) <%f,%f> %d [%f,%f]\n",
			lane_array[i].street_id, lane_array[i].lane_id,
			lane_array[i].type,
			lane_array[i].direction,
			lane_array[i].x0, lane_array[i].y0,
			lane_array[i].x1, lane_array[i].y1,
			lane_array[i].vmin, lane_array[i].vmax,
			lane_array[i].crosspoint_num,
			lane_array[i].angle,
			lane_array[i].length);

		for(j = 0; j < lane_array[i].crosspoint_num; j++)
			printf("-- crosspoint%d: [%d][%d] %d, (%f,%f)\n",
			lane_array[i].crosspoint[j].crosspoint_id,
			lane_array[i].crosspoint[j].street_id,
			lane_array[i].crosspoint[j].lane_id,
			lane_array[i].crosspoint[j].direction,
			lane_array[i].crosspoint[j].x,
			lane_array[i].crosspoint[j].y);
	}
}



int	Map::find_crspnt(int overall_lane_id, float x, float y)
{
	int return_value = -1;
	int i;

	if( lane_array[overall_lane_id].type == HORIZONTAL && lane_array[overall_lane_id].direction == 1)
	{
		for(i = 0; i < lane_array[overall_lane_id].crosspoint_num ; i++)
			if(x >= lane_array[overall_lane_id].crosspoint[i].x )
				return_value = i;	}
	else if( lane_array[overall_lane_id].type == HORIZONTAL && lane_array[overall_lane_id].direction == -1)
	{
		for(i = 0; i < lane_array[overall_lane_id].crosspoint_num ; i++)
			if(x <= lane_array[overall_lane_id].crosspoint[i].x )
				return_value = i;	}
	else if( lane_array[overall_lane_id].type == VERTICAL && lane_array[overall_lane_id].direction == -1)
	{
		for(i = 0; i < lane_array[overall_lane_id].crosspoint_num ; i++)
			if(y >= lane_array[overall_lane_id].crosspoint[i].y )
				return_value = i;	}
	else if( lane_array[overall_lane_id].type == VERTICAL && lane_array[overall_lane_id].direction == 1)
	{
		for(i = 0; i < lane_array[overall_lane_id].crosspoint_num ; i++)
			if(y < lane_array[overall_lane_id].crosspoint[i].y )
				return_value = i;	}

	return return_value;	
}

#endif