gpsdrawmap.cpp

用VC写的监控中心后台程序。 代码全

{
	bool	InMap = false;

	if(((gx >= TmpTri->x1) && (gx <= TmpTri->x3)) &&
	   ((gy <= TmpTri->y1) && (gy >= TmpTri->y3))) {
		InMap = true;
	}

	return InMap;
}

bool CGpsDrawMap::GetCurrLinkLib(CObList *LinkList,CGpsLinkStruct *pLink,double gx,double gy)
{
	CGpsLinkStruct	*pTemp;
	POSITION		pos;
	bool			Result = false,Flag = false;

	if(LinkList->GetCount() == 0)	return false;

	pos = LinkList->GetTailPosition();
	while(pos != NULL) {
		pTemp  = (CGpsLinkStruct*)LinkList->GetPrev(pos);
		if(CheckPointInMap(gx,gy,&pTemp->m_MapTri)) {
			if(!Flag) {
				Flag	= true;
				Result	= true;
				*pLink	= *pTemp;
				pLink->m_MapTri = pTemp->m_MapTri;
			}
			else {
				if(CompareTri(pLink->m_MapTri,pTemp->m_MapTri)) {
					*pLink	= *pTemp;
					pLink->m_MapTri = pTemp->m_MapTri;
				}
			}
		}
	}

	return Result;
}

long CGpsDrawMap::GetLinkLibAddr(char *pLinkName)
{
	long		Result = -1;
	char		LinkName[GpsLibFileLen + 1];
	long		InfoAddr,LinkStartAddr,LinkEndAddr,i;

	InfoAddr = m_cFatStruct.m_lLinkLibAddr;
	for(i	 = 0; i < m_cFatStruct.m_lLinkLibTotal; i++) {
		ClearBYTEArr(LinkName,GpsLibFileLen + 1);
		GetLibInfo(FileContent,InfoAddr,LinkName,&LinkStartAddr,&LinkEndAddr);
		InfoAddr += LibInfoBytes;						//链接库在FAT表中占用的字节数
		if(CompareTwoArr(pLinkName,LinkName) == 1) {
			Result = InfoAddr;
			break;
		}
	}

	return	Result;
}

/*************Draw ColorBlock*************/
void CGpsDrawMap::DrawColorBlock(CObList *ColorBList,CDC * MemDC)
{
	CGpsColorBlock	*pBlock;
	POSITION		pos;
	CPen		*DrawPen;

	pos = ColorBList->GetTailPosition();
	while(pos != NULL) {
		pBlock = (CGpsColorBlock*)ColorBList->GetPrev(pos);
		pBlock->m_ColorValue == 8 ? DrawPen = m_cColor.MapColor[6]:
									DrawPen = m_cColor.MapColor[pBlock->m_ColorValue - 1];
		DrawOneBlock(&pBlock->ColorBlockPointList,DrawPen,MemDC);
	}
}

void CGpsDrawMap::DrawOneBlock(CObList * PointList,CPen * CurrPen,CDC * MemDC)
{
	long		PointXY[3000][2];
	long		MapBrim[500][4];
	long		minX1 = -3000,minX2,PointCount;
	int			i,j;
	BYTE		b_draw;
	CGpsPoint	*tmpPoint;
	POSITION	pos;

	PointCount	= PointList->GetCount();
	pos			= PointList->GetHeadPosition();
	i			= 0;
	while(pos != NULL){
		tmpPoint = (CGpsPoint*)PointList->GetNext(pos);
		PointXY[i][0] = tmpPoint->m_lx;
		PointXY[i][1] = tmpPoint->m_ly;
		i++;
		if(i == 3000) {
			AfxMessageBox("系统内部出错!");
			return;
		}
	}
	minX1 = GetMinX(&PointXY[0][0],PointCount,minX1);
	minX2 = GetMinX(&PointXY[0][0],PointCount,minX1);

	CString str;

	while(true){
		if(minX1 > m_cCurrMapInfo.m_lWnd_Max_X) {
	        break;
		}

	    minX2 = GetMinX(&PointXY[0][0],PointCount,minX1);

		if(minX2 == 10000){
	        break;
		}
	    if(minX2 < 0) {
	        minX1 = minX2;
			continue;
		}

	    b_draw = 0;
	    for(i = 0; i < (PointCount - 1);i++){
	        if((( PointXY[i][0]		<= minX1) &&
				( PointXY[i + 1][0] >= minX2) &&
				( PointXY[i][0]		<  PointXY[i + 1][0])) ||
				((PointXY[i][0]		>= minX2) &&
				( PointXY[i + 1][0] <= minX1) &&
				( PointXY[i][0]		>  PointXY[i + 1][0]))){
		        GetDrawPoint(&PointXY[i][0],minX1,minX2,&MapBrim[b_draw][0]);
				b_draw++;
				if(b_draw == 500){
					AfxMessageBox("系统内部出错!");
					return;
				}
			}
	    }

		long tmp;
		for(i = 0; i < b_draw; i++){
			for(j = i + 1; j < b_draw; j++){
				if(MapBrim[i][1] > MapBrim[j][1]){
					tmp = MapBrim[i][1];	
					MapBrim[i][1] = MapBrim[j][1]; 
					MapBrim[j][1] = tmp;

					tmp = MapBrim[i][3];
					MapBrim[i][3] = MapBrim[j][3]; 
					MapBrim[j][3] = tmp;
				}
			}
		}

		b_draw = b_draw / 2;
		for(i = 0; i < b_draw; i++){
			DrawTriangle(&MapBrim[2 * i][0],&MapBrim[2 * i + 1][0],CurrPen,MemDC);
	    }

	    minX1 = minX2;
	}
}

void CGpsDrawMap::DrawTriangle(long *bian1, long *bian2,CPen * CurrPen,CDC * MemDC)
{
	long y1,y2,tmp;

    if((bian1[3] > bian2[3]) || (bian1[1] > bian2[1])){
		tmp = bian1[3];
		bian1[3] = bian2[3];
		bian2[3] = tmp;

		tmp = bian1[1];
		bian1[1] = bian2[1];
		bian2[1] = tmp;
    }

    for(int i = bian1[0]; i < bian2[2]; i++){
        y1 = bian1[1] + (i - bian1[0]) * (bian1[3] - bian1[1]) / (bian1[2] - bian1[0]);

	if(y1 > m_cCurrMapInfo.m_lWnd_Max_Y) {
			y1 = (long)m_cCurrMapInfo.m_lWnd_Max_Y;
		}
		else if(y1 < 0) {
	        y1 = 0;
		}

        y2 = bian2[1] + (i - bian2[0]) * (bian2[3] - bian2[1]) / (bian2[2] - bian2[0]);

		if(y2 > m_cCurrMapInfo.m_lWnd_Max_X) {
		    y2 = (long)m_cCurrMapInfo.m_lWnd_Max_X;
		}
		else{
			if(y2 < 0){
				y2 = 0;
			}
		}

		DrawLine(i,y1,i,y2,1,CurrPen,MemDC);
    }
}

/*************Draw Line*************/
void CGpsDrawMap::DrawLine(long SX, long SY, long EX, long EY, int LineCount,CPen * CurrPen,CDC * MemDC)
{
	CPen * OldPen;
	OldPen = MemDC->SelectObject(CurrPen);

	int bian	 = 1;
	int LineWide = LineCount;
	
	MemDC->MoveTo(SX,SY);
	MemDC->LineTo(EX,EY);

    while((LineCount--) > 0){
		if(SX == EX){
			bool flag = true;
			BYTE tmp  = 1;
			for(int i = 0; i < LineWide; i++){
				if(flag){
					MemDC->MoveTo(SX + tmp,SY);
					MemDC->LineTo(EX + tmp,EY);
					flag = false;
				}
				else{
					MemDC->MoveTo(SX - tmp,SY);
					MemDC->LineTo(EX - tmp,EY);
					flag = true;
				}
				if (flag) tmp++;
			}
		}
		else if( ((EY - SY) / ( EX - SX)) != 0){
			MemDC->MoveTo(SX - bian,SY);
			MemDC->LineTo(EX - bian,EY);
		}
		else{
			MemDC->MoveTo(SX,SY - bian);
			MemDC->LineTo(EX,EY - bian);
		}

		if(bian > 0){
			bian = 0 - bian;
		}
		else{
			bian = 0 - bian;
			bian++;
		}
	}
	MemDC->SelectObject(OldPen);	
}

long CGpsDrawMap::GetMinX(long *pDataXY,long PointCount,long MinX)
{
    long ret = 10000;
    bool flag = false;
    for(int i = 0; i < PointCount; i++){
        if(pDataXY[i * 2] > MinX){
		    if(pDataXY[i * 2] < ret){
		        ret = pDataXY[i * 2];
				flag = true;
		    }
		}
	}

	return ret;
}

void CGpsDrawMap::GetDrawPoint(long line_p[], int minX1, int minX2, long *Result)
{
    int x1,y1,x2,y2;
	bool flag = true;

    if(line_p[1] == line_p[3]){
        flag = false;
	}

    if(line_p[0] > line_p[2]){
        x1 = line_p[2];
        y1 = line_p[3];
        x2 = line_p[0];
        y2 = line_p[1];
    }
    else{
        x1 = line_p[0];
        y1 = line_p[1];
        x2 = line_p[2];
        y2 = line_p[3];
    }

    if(minX1 < 0){
        Result[0] = 0;
    }
    else{
        Result[0] = minX1;
    }
    if(minX2 > m_cCurrMapInfo.m_lWnd_Max_X) {
        Result[2] = (long)m_cCurrMapInfo.m_lWnd_Max_X;
    }
    else{
        Result[2] = minX2;
    }


    if(flag){
		Result[1] = y1 + (Result[0] - x1) * (y2 - y1) / (x2 - x1);
	}
    else{
		Result[1] = line_p[1];
	}

    if(flag){
        Result[3] = y1 + (Result[2] - x1) * (y2 - y1) / (x2 - x1);
	}
    else{
        Result[3] = line_p[1];
	}
}

/*************Draw Road*************/
void CGpsDrawMap::DrawRoad(CObList *RoadList,CDC *pDC)
{
	CGpsRoadStruct		*pRoad;
	CSmallRoadStruct	*pSmall;
	CRoadPoint			*pRoadPoint;
	POSITION			pos,pos1,pos2;
	CPoint				PrevPoint,CurrPoint;
	CPen				*CurrPen;
	BYTE				RoadLevel,RoadWidth;
	bool				Flag;

	pos = RoadList->GetTailPosition();
	while(pos != NULL) {
		pRoad  = (CGpsRoadStruct*)RoadList->GetPrev(pos);
		pos1   = pRoad->SmallRoadList.GetTailPosition();
		Flag   = false;
		while(pos1 != NULL) {
			pSmall  = (CSmallRoadStruct*)pRoad->SmallRoadList.GetPrev(pos1);

			RoadLevel = pSmall->RoadorName_DispLevel & 0x0f;
			switch (RoadLevel) {
			case 0:
				CurrPen	  = m_cColor.RoadColor[5];
				RoadWidth = 1;
				break;
			case 1:
				RoadWidth = 3;
				CurrPen   = m_cColor.RoadColor[0];
				break;
			case 2:
				RoadWidth = 3;
				CurrPen   = m_cColor.RoadColor[1];
				break;
			case 3:
				RoadWidth = 3;
				CurrPen   = m_cColor.RoadColor[2];
				break;
			case 4:
				RoadWidth = 2;
				CurrPen   = m_cColor.RoadColor[3];
				break;
			case 5:
				RoadWidth = 1;
				CurrPen   = m_cColor.RoadColor[4];
				break;
			default:
				RoadWidth = 3;
				CurrPen   = m_cColor.RoadColor[2];
				break;
			}
			switch(m_byZoomCoeffic) {
			case 1:
				RoadWidth += 2;
				break;
			case 2:
				RoadWidth += 3;
				break;
			case 4:
				RoadWidth += 4;
				break;
			}
			if(pRoad->m_byIsHelpRoad) {
				RoadWidth = 2;
			}

			pos2	= pSmall->RoadPointList.GetTailPosition();
			while(pos2 != NULL) {
				pRoadPoint = (CRoadPoint*)pSmall->RoadPointList.GetPrev(pos2);
				if(pRoadPoint->BigRoad_SerialNumber[1] == 100)	continue;
				CurrPoint.x = pRoadPoint->m_lx; CurrPoint.y = pRoadPoint->m_ly;
				if(!Flag) {
					Flag = true;
				}
				else {
			//		DrawLine(PrevPoint.x, PrevPoint.y, 
			//				 CurrPoint.x, CurrPoint.y, 
			//				 RoadWidth,CurrPen,pDC);
					MapDrawRoad(pDC,PrevPoint.x,PrevPoint.y,CurrPoint.x,CurrPoint.y,RoadWidth,CurrPen);
				}
				PrevPoint = CurrPoint;
			}
		}
	}
}

void CGpsDrawMap::MapDrawRoad(CDC *pDC, long SX, long SY, long EX, long EY, BYTE RoadWide,CPen *CurrPen)
{
	CPen		BorderPen(PS_SOLID,1,RGB(115,115,115));
	long		W;

	MapDrawLineWidth(pDC,SX,SY,EX,EY,RoadWide,CurrPen);

	/*
	 ** always draws from small X to large X
	*/
	if (SX > EX) {
		W = EX, EX = SX, SX = W;
		W = EY, EY = SY, SY = W;
	}

	if (SX == EX) {
		DrawLine(SX - (RoadWide >> 1), SY, EX - (RoadWide >> 1), EY,0,&BorderPen,pDC);
		DrawLine(SX + (RoadWide >> 1), SY, EX + (RoadWide >> 1), EY,0,&BorderPen,pDC);
		return;
	}

	if (SY == EY) {
		DrawLine(SX, SY - (RoadWide >> 1), EX, EY - (RoadWide >> 1),0,&BorderPen,pDC);
		DrawLine(SX, SY + (RoadWide >> 1), EX, EY + (RoadWide >> 1),0,&BorderPen,pDC);
		return;
	}

	if (SY < EY) {
		DrawLine(SX + (RoadWide >> 1), SY - (RoadWide >> 1), EX + (RoadWide >> 1), EY - (RoadWide >> 1),0,&BorderPen,pDC);
		DrawLine(SX - (RoadWide >> 1), SY + (RoadWide >> 1), EX - (RoadWide >> 1), EY + (RoadWide >> 1),0,&BorderPen,pDC);
		return;
	}

	if (SY > EY) {
		DrawLine(SX - (RoadWide >> 1), SY - (RoadWide >> 1), EX - (RoadWide >> 1), EY - (RoadWide >> 1),0,&BorderPen,pDC);
		DrawLine(SX + (RoadWide >> 1), SY + (RoadWide >> 1), EX + (RoadWide >> 1), EY + (RoadWide >> 1),0,&BorderPen,pDC);
		return;
	}
}

void CGpsDrawMap::MapDrawLineWidth(CDC *pDC, long SX, long SY, long EX, long EY, BYTE MapLineWidth,CPen *Pen)
{
	long		W, H, Ha, dY, f;
	BYTE		HalfWidth = MapLineWidth / 2;
	CPoint		sp,ep;
	CPen		*OldPen;

	OldPen = pDC->SelectObject(Pen);
/*
	for (i = 0; i < MapLineWidth; i++) {
		sp.x	= SX - HalfWidth + i;
		sp.y	= SX - HalfWidth;
		ep.x	= SX - HalfWidth + i;
		ep.y	= SX - HalfWidth - MapLineWidth;
		pDC->MoveTo(sp);
		pDC->LineTo(ep);

		sp.x	= EX - HalfWidth + i;
		sp.y	= EX - HalfWidth;
		ep.x	= EX - HalfWidth + i;
		ep.y	= EX - HalfWidth - MapLineWidth;
		pDC->MoveTo(sp);
		pDC->LineTo(ep);
	}
*/
	/*
	 ** always draws from small X to large X
	 */
	if (SX > EX) {
		W = EX, EX = SX, SX = W;
		W = EY, EY = SY, SY = W;
	}

	/*
	 ** we might want to clip the line here
	 */
	W = (EX - SX);
	H = (EY - SY);
	Ha = (H < 0) ? -H : H;
	dY = (H < 0) ? -1 : 1;

	if (Ha > W)	{
		/* Y-majored */
		f = 0;
		while (1) {
			sp.x	= SX - HalfWidth;
			sp.y	= SY - HalfWidth;
			ep.x	= SX - HalfWidth + MapLineWidth;