tool.h

基于EasyArm2200和ucOS2的SD卡文件系统的实现

#ifndef _TOOL_H_
#define _TOOL_H_

#include "cfg.h"
#include "global.h"
#include <math.h>
#include <stdlib.h>

/************************************* FUNCTION ***********************************/
/*Convert GPS point to Plannar point*/
Point ConvertPoint(GPoint pt);
/*The angle from vect1 to vect2*/
INT GetAngle(Vect v1,Vect v2);

INT InitRoad(Road *pRd,INT PtCount);
INT GetPointNum(Road* pRd);
/*Index:based zero*/
INT GetPoint(Road* pRd,UINT nIndex,Point* pRcv);/*pRcv recive a copy of point*/
INT SetPoint(Road* pRd,UINT nIndex,Point pt);
void FreeRoad(Road* pRd);

/*Get vect of road,current point point to pre point*/
Vect GetPreDirection(Road* pRd,UINT nIndex);
/*Get vect of road,current point point to next point*/
Vect GetNextDirection(Road* pRd,UINT nIndex);


void Move(Point *pPt,INT dx,INT dy);
void Zoom(Point *pPt,INT scale);
void Rota(Point *pPt,Point cn,INT theta);
void Map(Point *pPt);

Point ConvertPoint(GPoint pt)
{
	Point p;
	p.x=ER*(pt.Lng-OX);
	p.y=ER*(pt.Lat-OY);
	return p;
}

INT GetAngle(Vect v1,Vect v2)
{
	INT d=(v1.x-v2.x)*(v1.x-v2.x)+(v1.y-v2.y)*(v1.y-v2.y);
	d=v1.x*v2.x+v1.y*v2.y/sqrt((float)d);
	d=acos((float)d)*180/PI;
	if(d<0) d=90+d;
	if(v1.y/v1.x - v2.y/v2.x > 0) d=-d;
	return d;
}

INT InitRoad(Road *pRd,INT PtCount)
{
	pRd->PtCount=PtCount;
	pRd->pt=(Point*)calloc(PtCount,sizeof(Point));
	return pRd==NULL;
}

INT GetPointNum(Road* pRd)
{
	return pRd->PtCount;
}

INT GetPoint(Road* pRd,UINT nIndex,Point* pRcv)
{
	if(pRcv==NULL) pRcv=(Point*)malloc(sizeof(Point));
	if(nIndex<pRd->PtCount)
	{
		(*pRcv)=pRd->pt[nIndex];
		return 1;
	}
	else return 0;
}

INT SetPoint(Road* pRd,UINT nIndex,Point pt)
{
	if(nIndex<pRd->PtCount)
	{
		pRd->pt[nIndex]=pt;
		return 1;
	}
	else return 0;
}

void FreeRoad(Road* pRd)
{
	pRd->PtCount=0;
	free(pRd->pt);
	pRd->pt=NULL;
}

Vect GetPreDirection(Road* pRd,UINT nIndex)
{
	Vect v;
	Point p1,p2;
	INT i=nIndex>0? nIndex-1:nIndex+1;
	GetPoint(pRd,i,&p1);
	GetPoint(pRd,nIndex,&p2);
	v.x=i<nIndex? p1.x-p2.x : p2.x-p1.x;
	v.y=i<nIndex? p1.y-p2.y : p2.y-p1.y;
	return v;
}

Vect GetNextDirection(Road* pRd,UINT nIndex)
{
	Vect v;
	Point p1,p2;
	INT i=nIndex<GetPointNum(pRd)? nIndex+1:nIndex-1;
	GetPoint(pRd,i,&p1);
	GetPoint(pRd,nIndex,&p2);
	v.x=i>nIndex? p1.x-p2.x : p2.x-p1.x;
	v.y=i>nIndex? p1.y-p2.y : p2.y-p1.y;
	return v;
}


void Move(Point *pPt,INT dx,INT dy)
{
	if(pPt==NULL) return;
	pPt->x+=dx;
	pPt->y+=dy;
}

void Zoom(Point *pPt,INT scale)
{
	if(pPt==NULL) return;
	pPt->x= (scale>0 && scale!=0)? pPt->x*scale : pPt->x/(-scale);
	pPt->y= (scale>0 && scale!=0)? pPt->y*scale : pPt->y/(-scale);
}

void Rota(Point *pPt,Point pt,INT theta)
{
	INT x,y;
	if(pPt==NULL) return;
	Move(pPt,-pt.x,-pt.y);
	x=(pPt->x)*cos(theta*PI/180)-(pPt->y)*sin(theta*PI/180);
	y=-((pPt->x)*sin(theta*PI/180)+(pPt->y)*cos(theta*PI/180));
	pPt->x=x;
	pPt->y=y;
	Move(pPt,pt.x,pt.y);
}

void Map(Point *pPt)
{
	pPt->x=pPt->x * g_scale100/100 + g_off.x;
	pPt->y=pPt->y * g_scale100/100 + g_off.y;
}
#endif/*_TOOL_H_*/