开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 交通/航空行业 > 查看源码
GpsDrawMap.cpp
资源名称：GPRS-GSM040806.rar　[点击查看]
上传用户：yffx2008
上传日期：2014-10-12
资源大小：12414k
文件大小：97k
源码类别：

交通/航空行业

开发平台：

Visual C++

GpsDrawMap.cpp：源码内容
  1. // GpsDrawMap.cpp: implementation of the CGpsDrawMap class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "GpsSC.h"
  7. #include "GpsDrawMap.h"
  8. #include "SearchSignDlg.h"
  9. #include "ShowSignDlg.h"
  10. #include "InputStringDlg.h"
  11. #include "ListSimilarStrDlg.h"
  13. #include "GpsSCDoc.h"
  14. #include "GpsSCView.h"
  16. #include "math.h"
  18. #ifdef _DEBUG
  19. #undef THIS_FILE
  20. static char THIS_FILE[]=__FILE__;
  21. #define new DEBUG_NEW
  22. #endif
  24. #define Square(a) ((a) * (a))
  25. #define Max(a, b) ((a) > (b) ? (a) : (b))
  26. #define Min(a, b) ((a) > (b) ? (b) : (a))
  27. #define PI 3.1415927
  28. #define GPS_INFINITE 0x7fffff
  29. #define GPS_CAR_WIDTH_HEIGH 40
  32. #define CompanyIconName "\GpsIcon\GpsSign\Company.bmp"
  33. #define PlaceNameIconName "\GpsIcon\GpsSign\PlaceName.bmp"
  34. #define BuildingIconName "\GpsIcon\GpsSign\Building.bmp"
  35. #define TrafficIconName "\GpsIcon\GpsSign\Traffic.bmp"
  36. #define OilIconName "\GpsIcon\GpsSign\Oil.bmp"
  37. #define GovernmentIconName "\GpsIcon\GpsSign\Government.bmp"
  38. #define EducationIconName "\GpsIcon\GpsSign\edu.bmp"
  39. #define HotelIconName "\GpsIcon\GpsSign\Hotel.bmp"
  40. #define ShoppingIconName "\GpsIcon\GpsSign\Shopping.bmp"
  41. #define AmusementIconName "\GpsIcon\GpsSign\Amusement.bmp"
  42. #define ProjectIconName "\GpsIcon\GpsSign\finan.bmp"
  43. #define HospitalIconName "\GpsIcon\GpsSign\Hospital.bmp"
  46. //////////////////////////////////////////////////////////////////////
  47. // Construction/Destruction
  48. //////////////////////////////////////////////////////////////////////
  50. CGpsDrawMap::CGpsDrawMap()
  51. {
  52. InitDrawMap();
  53. }
  55. CGpsDrawMap::~CGpsDrawMap()
  56. {
  57. ClearMemberVar();
  58. }
  60. void CGpsDrawMap::ClearMemberVar()
  61. {
  62. if(FileContent != NULL) {
  63. delete [] FileContent;
  64. }
  65. m_cFatStruct.Clear();
  66. m_cCurrMapInfo.Clear();
  67. ClearLinkList(&mLinkList);
  68. ClearPointList(&mSaveRecePointList);
  69. m_cCurrMapInfo.ClearBRoadSaveList(&mSaveBRList);
  70. ClearPointList(&mSaveTempList1);
  71. ClearPointList(&mSaveTempList2);
  72. }
  74. void CGpsDrawMap::InitDrawMap()
  75. {
  76. m_cFatStruct.Clear();
  77. m_cCurrMapInfo.Clear();
  78. ClearLinkList(&mLinkList);
  79. ClearPointList(&mSaveRecePointList);
  81. long Ret;
  82. if(Ret = GetGpsFatBuf()) {
  83. GetGpsFatInfo();
  86. gCurrMapLevel = 6;
  87. m_PointWidth = 5;
  88. m_byZoomCoeffic = 1;
  91. GetLinkList(&mLinkList,gCurrMapLevel);
  93. gBRcross.m_bEnable = false;
  94. gBRcross.m_bHaveSpoint = false;
  95. gBRcross.m_EndCross.Clear();
  96. gBRcross.m_StartCross.Clear();
  98. GetAreaLibList(&m_cCurrMapInfo.lAreaLibList);
  99. }
  100. }
  102. void CGpsDrawMap::ClearStrArr(CString StrArr[],long Count)
  103. {
  104. long i;
  106. for(i = 0; i < Count; i++) {
  107. StrArr[i].Empty();
  108. }
  109. }
  111. long CGpsDrawMap::GetGpsFatBuf()
  112. {
  113. CString sPath;
  114. char CurrPath[500];
  115. CFile f;
  116. long FatLen = 0;
  118. ClearBYTEArr(CurrPath,500);
  119. ::GetCurrentDirectory(500,CurrPath);
  121. sPath = CurrPath;
  122. sPath  += "\Map\fat.fat";
  124. short Course = 0; //将不同角度的Car保存到数组中
  125. CString str;
  126. CString CarPath;
  128. CarPath  = CurrPath;
  129. CarPath += "\GpsIcon\GpsCar\Car";
  130. for(BYTE i = 0; i < 24; i++) {
  131. str.Format("%03d",Course);
  132. SaveGpsCarPath[i] = CarPath + str + ".bmp";
  133. Course    += 15;
  134. }
  136. if(!f.Open(sPath,CFile::modeRead,NULL)) {
  137. AfxMessageBox("打开地图出错，初始化画图系统失败!");
  138. FileContent = NULL;
  139. return FatLen;
  140. }
  141. f.SeekToBegin();
  142. FatLen = f.GetLength();
  143. FileContent = new BYTE[FatLen];
  144. f.Read(FileContent,FatLen);
  145. f.Close();
  147. return FatLen;
  148. }
  151. CString CGpsDrawMap::GetCurrDir()
  152. {
  153. CString sPath;
  154. char CurrPath[500];
  156. ClearBYTEArr(CurrPath,500);
  157. ::GetCurrentDirectory(500,CurrPath);
  159. return sPath = CurrPath;
  160. }
  162. bool CGpsDrawMap::ShowSignLib()
  163. {
  164. CShowSignDlg dlg;
  165. if(dlg.DoModal() == IDCANCEL) return false;
  167. m_ShowSign.bShowBuilding = dlg.m_byBuilding;
  168. m_ShowSign.bShowHotel = dlg.m_byHotel;
  169. m_ShowSign.bShowCompany = dlg.m_byCompany;
  170. m_ShowSign.bShowAmuse = dlg.m_byAmuse;
  171. m_ShowSign.bShowPlaceName = dlg.m_byPlaceName;
  172. m_ShowSign.bShowGovern = dlg.m_byGovern;
  173. m_ShowSign.bShowTraffic = dlg.m_byTraffic;
  174. m_ShowSign.bShowShopping = dlg.m_byShopping;
  175. m_ShowSign.bShowEducation = dlg.m_byEducation;
  176. m_ShowSign.bShowHospital = dlg.m_byHospital;
  177. m_ShowSign.bShowBureau = dlg.m_byBureau;
  178. m_ShowSign.bShowOil = dlg.m_byOil;
  180. return true;
  181. }
  183. void CGpsDrawMap::GetGpsFatInfo()
  184. {
  185. long BufPos = 0;
  187. m_cFatStruct.m_lLinkLibTotal = GetFourBNum(FileContent,BufPos); //链接库
  188. BufPos += LibTotalBytes;
  189. m_cFatStruct.m_lDataLibTotal = GetFourBNum(FileContent,BufPos); //数据库
  190. BufPos += LibTotalBytes;
  191. m_cFatStruct.m_lSignLibTotal = GetFourBNum(FileContent,BufPos); //标志库
  192. BufPos += LibTotalBytes;
  193. m_cFatStruct.m_lRegionLibTotal = GetFourBNum(FileContent,BufPos); //地区库
  194. BufPos += LibTotalBytes;
  195. m_cFatStruct.m_lRecordLibTotal = GetFourBNum(FileContent,BufPos); //记录库
  196. BufPos += LibTotalBytes;
  198. m_cFatStruct.m_lLinkLibAddr = BufPos;
  199. m_cFatStruct.m_lDataLibAddr = m_cFatStruct.m_lLinkLibAddr  + 
  200.   m_cFatStruct.m_lLinkLibTotal  * LibInfoBytes;
  202. m_cFatStruct.m_lSignLibAddr = m_cFatStruct.m_lDataLibAddr  + 
  203.   m_cFatStruct.m_lDataLibTotal  * LibInfoBytes;
  205. m_cFatStruct.m_lRegionLibAddr = m_cFatStruct.m_lSignLibAddr  + 
  206.   m_cFatStruct.m_lSignLibTotal  * LibInfoBytes;
  208. m_cFatStruct.m_lRecordLibAddr = m_cFatStruct.m_lRegionLibAddr  +
  209.   m_cFatStruct.m_lRegionLibTotal * LibInfoBytes;
  210. }
  212. /*************Get one NE of Point*************/
  213. void CGpsDrawMap::GetPointNE(BYTE *BUF,long *BufPos,double *gx,double *gy)
  214. {
  215. long tmp1;
  217. tmp1 = GetFourBNum(BUF,*BufPos);
  218. *gy = CovertNE(tmp1);
  220. *BufPos += GpsPointNEBytes;
  221. tmp1 = GetFourBNum(BUF,*BufPos);
  222. *gx = CovertNE(tmp1);
  224. *BufPos += GpsPointNEBytes;
  225. }
  227. /*************Get a long number of four bytes*************/
  228. long CGpsDrawMap::GetFourBNum(BYTE *BUF,long BufPos)
  229. {
  230. long RetLong;
  231. RetLong = BUF[BufPos + 0]  + (BUF[BufPos + 1]  + BUF[BufPos + 2]  * 256 + BUF[BufPos + 3]  * 65536) * 256;
  233. return RetLong;
  234. }
  236. short CGpsDrawMap::GetTwoBNum(BYTE *BUF,long BufPos)
  237. {
  238. short RetShort;
  240. RetShort = BUF[BufPos + 0]  + BUF[BufPos + 1] * 256;
  242. return RetShort;
  243. }
  245. BYTE CGpsDrawMap::GetOneBNum(BYTE *BUF,long BufPos)
  246. {
  247. BYTE RetByte;
  249. RetByte = BUF[BufPos];
  251. return RetByte;
  252. }
  254. void CGpsDrawMap::GetLenArray(BYTE *pTarget,BYTE Len,BYTE *Buf,long BufPos)
  255. {
  256. BYTE i;
  258. for(i = 0; i < Len; i++) {
  259. pTarget[i] = Buf[BufPos++];
  260. }
  261. }
  263. void CGpsDrawMap::ClearBYTEArr(char Array[],long ArrLen)
  264. {
  265. long i;
  267. for(i = 0; i < ArrLen; i++) {
  268. Array[i] = 0;
  269. }
  270. }
  272. void CGpsDrawMap::CopyStr2Arr(CString Str,char *Arr,BYTE ArrLen)
  273. {
  274. BYTE i;
  275. for(i = 0;i < Str.GetLength(); i++) {
  276. Arr[i] = Str.GetAt(i);
  277. if(i == ArrLen) break;
  278. }
  279. }
  281. void CGpsDrawMap::CopyEquaLenArr(char *SrcArr,char *DstArr,BYTE CpyLen)
  282. {
  283. BYTE i;
  284. for(i = 0; i < CpyLen; i++) {
  285. DstArr[i] = SrcArr[i];
  286. }
  287. }
  289. BYTE CGpsDrawMap::CompareTwoArr(char *pArr1,char *pArr2)
  290. {
  291. CString Str1(pArr1),Str2(pArr2);
  292. BYTE Ret = 3;
  294. Str1.MakeUpper();
  295. Str2.MakeUpper();
  296. if((Str1 == Str2) && (!Str1.IsEmpty()) && (!Str2.IsEmpty())) return Ret = 1;
  297. if(Str1  > Str2) return Ret = 2;
  298. if(Str1  < Str2) return Ret = 0;
  300. return Ret;
  301. }
  303. /*************From XY to NE or From NE to XY*************/
  304. void CGpsDrawMap::CovertNEXY(CGpsPoint * cmpoint, ChangeNormal change, bool NE2XY)
  305. {
  306. #if 0
  307. if (NE2XY) {
  308. cmpoint->m_lx = (long)(change.a11 * cmpoint->m_dgx +
  309.  change.a12 * cmpoint->m_dgy + change.dx);
  311. cmpoint->m_ly = (long)(change.a21 * cmpoint->m_dgx +
  312.  change.a22 * cmpoint->m_dgy + change.dy);
  313.     }
  314.     else {
  315. cmpoint->m_dgx = change.a11 * cmpoint->m_lx +
  316.   change.a12 * cmpoint->m_ly + change.dx;
  318. cmpoint->m_dgy = change.a21 * cmpoint->m_lx +
  319.   change.a22 * cmpoint->m_ly + change.dy;
  320.     }
  321. #else
  322. long lTemp;
  323. double x,y,dTemp;
  325.     if (NE2XY) {
  326. lTemp = (long)cmpoint->m_dgx   / 100;
  327. dTemp = cmpoint->m_dgx - lTemp * 40;
  328. x = dTemp;
  329. lTemp = (long)cmpoint->m_dgy   / 100;
  330. dTemp = cmpoint->m_dgy - lTemp * 40;
  331. y = dTemp;
  332. cmpoint->m_lx = (long)(change.a11 * x + change.a12 * y + change.dx);
  333. cmpoint->m_ly = (long)(change.a21 * x + change.a22 * y + change.dy);
  334.     }
  335.     else {
  336. x = cmpoint->m_lx;
  337. y = cmpoint->m_ly;
  339. dTemp = change.a11 * x + change.a12 * y + change.dx;
  340. lTemp = (long)dTemp   / 60;
  341. cmpoint->m_dgx = dTemp + lTemp * 40;
  342. dTemp = change.a21 * x + change.a22 * y + change.dy;
  343. lTemp = (long)dTemp   / 60;
  344. cmpoint->m_dgy = dTemp + lTemp * 40;
  345.     }
  346. #endif
  347. }
  349. void CGpsDrawMap::CalculateCoeffNEXY(ChangeTriangle Triangle1,ChangeTriangle Triangle2,ChangeNormal *Change)
  350. {
  351. #if 0
  352. double tmp1,tmp2;
  353. tmp1 = (Triangle2.x2 - Triangle2.x1) * (Triangle2.y3 - Triangle2.y1) - 
  354.    (Triangle2.x3 - Triangle2.x1) * (Triangle2.y2 - Triangle2.y1);
  355.      
  356. tmp2 = (Triangle1.x2 - Triangle1.x1) * (Triangle2.y3 - Triangle2.y1) - 
  357.    (Triangle1.x3 - Triangle1.x1) * (Triangle2.y2 - Triangle2.y1);
  358. Change->a11 = tmp2 / tmp1;
  360. tmp2 = (Triangle2.x2 - Triangle2.x1) * (Triangle1.x3 - Triangle1.x1) - 
  361.    (Triangle2.x3 - Triangle2.x1) * (Triangle1.x2 - Triangle1.x1);
  362. Change->a12 = tmp2 / tmp1;
  364. tmp2 = (Triangle1.y2 - Triangle1.y1) * (Triangle2.y3 - Triangle2.y1) - 
  365.    (Triangle1.y3 - Triangle1.y1) * (Triangle2.y2 - Triangle2.y1);
  366. Change->a21 = tmp2 / tmp1;
  368. tmp2 = (Triangle2.x2 - Triangle2.x1) * (Triangle1.y3 - Triangle1.y1) - 
  369.    (Triangle2.x3 - Triangle2.x1) * (Triangle1.y2 - Triangle1.y1);
  370. Change->a22 = tmp2 / tmp1;
  372. Change->dx = Triangle1.x1 - Change->a11 * Triangle2.x1 - 
  373. Change->a12 * Triangle2.y1;
  374. Change->dy = Triangle1.y1 - Change->a21 * Triangle2.x1 - 
  375. Change->a22 * Triangle2.y1;
  376. #else
  377. double tmp1,tmp2;
  378. tmp1 = (Triangle2.x2 - Triangle2.x1) * (Triangle2.y3 - Triangle2.y1) - 
  379.    (Triangle2.x3 - Triangle2.x1) * (Triangle2.y2 - Triangle2.y1);
  380.      
  381. tmp2 = (Triangle1.x2 - Triangle1.x1) * (Triangle2.y3 - Triangle2.y1) - 
  382.    (Triangle1.x3 - Triangle1.x1) * (Triangle2.y2 - Triangle2.y1);
  383. Change->a11 = tmp2 / tmp1;
  385. tmp2 = (Triangle2.x2 - Triangle2.x1) * (Triangle1.x3 - Triangle1.x1) - 
  386.    (Triangle2.x3 - Triangle2.x1) * (Triangle1.x2 - Triangle1.x1);
  387. Change->a12 = tmp2 / tmp1;
  389. tmp2 = (Triangle1.y2 - Triangle1.y1) * (Triangle2.y3 - Triangle2.y1) - 
  390.    (Triangle1.y3 - Triangle1.y1) * (Triangle2.y2 - Triangle2.y1);
  391. Change->a21 = tmp2 / tmp1;
  393. tmp2 = (Triangle2.x2 - Triangle2.x1) * (Triangle1.y3 - Triangle1.y1) - 
  394.    (Triangle2.x3 - Triangle2.x1) * (Triangle1.y2 - Triangle1.y1);
  395. Change->a22 = tmp2 / tmp1;
  397. Change->dx = Triangle1.x1 - Change->a11 * Triangle2.x1 - 
  398. Change->a12 * Triangle2.y1;
  399. Change->dy = Triangle1.y1 - Change->a21 * Triangle2.x1 - 
  400. Change->a22 * Triangle2.y1;
  401. #endif
  402. }
  404. void CGpsDrawMap::RefreshMapWnd()
  405. {
  406. ChangeTriangle triangle;
  407. ChangeNormal TmpTri;
  408. CRect lpRect;
  410. ((CGpsSCView*)m_pCurrView)->GetClientRect(lpRect);
  412. if((m_cCurrMapInfo.m_lWnd_Max_X == 0) || (m_cCurrMapInfo.m_lWnd_Max_Y == 0)) {
  413. lpRect.right *= m_byZoomCoeffic;
  414. lpRect.bottom *= m_byZoomCoeffic;
  415. m_cCurrMapInfo.m_lWnd_Max_X = lpRect.right;
  416. m_cCurrMapInfo.m_lWnd_Max_Y = lpRect.bottom;
  417. ((CGpsSCView*)m_pCurrView)->SetScrollSizes(MM_TEXT, CSize(m_cCurrMapInfo.m_lWnd_Max_X, m_cCurrMapInfo.m_lWnd_Max_Y));
  418. }
  419. else {
  420. lpRect.right = m_cCurrMapInfo.m_lWnd_Max_X;
  421. lpRect.bottom = m_cCurrMapInfo.m_lWnd_Max_Y;
  422. }
  424. m_cCurrMapInfo.m_WndTriangle.x1 = lpRect.left;
  425. m_cCurrMapInfo.m_WndTriangle.y1 = lpRect.top;
  426. m_cCurrMapInfo.m_WndTriangle.x2 = lpRect.left;
  427. m_cCurrMapInfo.m_WndTriangle.y2 = lpRect.bottom;
  428. m_cCurrMapInfo.m_WndTriangle.x3 = lpRect.right;
  429. m_cCurrMapInfo.m_WndTriangle.y3 = lpRect.bottom;
  431. #if 1
  432. triangle =  m_cCurrMapInfo.m_MapTriangle;
  433. long iTemp;
  434. iTemp = (long)(m_cCurrMapInfo.m_MapTriangle.x1 / 100);
  435. m_cCurrMapInfo.m_MapTriangle.x1 = m_cCurrMapInfo.m_MapTriangle.x1 - iTemp * 40;
  436. iTemp = (long)(m_cCurrMapInfo.m_MapTriangle.x2 / 100);
  437. m_cCurrMapInfo.m_MapTriangle.x2 = m_cCurrMapInfo.m_MapTriangle.x2 - iTemp * 40;
  438. iTemp = (long)(m_cCurrMapInfo.m_MapTriangle.x3 / 100);
  439. m_cCurrMapInfo.m_MapTriangle.x3 = m_cCurrMapInfo.m_MapTriangle.x3 - iTemp * 40;
  440. iTemp = (long)(m_cCurrMapInfo.m_MapTriangle.y1 / 100);
  441. m_cCurrMapInfo.m_MapTriangle.y1 = m_cCurrMapInfo.m_MapTriangle.y1 - iTemp * 40;
  442. iTemp = (long)(m_cCurrMapInfo.m_MapTriangle.y2 / 100);
  443. m_cCurrMapInfo.m_MapTriangle.y2 = m_cCurrMapInfo.m_MapTriangle.y2 - iTemp * 40;
  444. iTemp = (long)(m_cCurrMapInfo.m_MapTriangle.y3 / 100);
  445. m_cCurrMapInfo.m_MapTriangle.y3 = m_cCurrMapInfo.m_MapTriangle.y3 - iTemp * 40;
  446. #endif
  448. CalculateCoeffNEXY(m_cCurrMapInfo.m_WndTriangle,m_cCurrMapInfo.m_MapTriangle,&TmpTri);
  449. m_cCurrMapInfo.CoeffNE_XY = TmpTri;
  451. CalculateCoeffNEXY(m_cCurrMapInfo.m_MapTriangle,m_cCurrMapInfo.m_WndTriangle,&TmpTri);
  452. m_cCurrMapInfo.CoeffXY_NE = TmpTri;
  454. m_cCurrMapInfo.m_MapTriangle = triangle;
  455. }
  457. void CGpsDrawMap::GetCurrMapInfo(CGpsLinkStruct *pLinkStruct,CCurrMapInfo *MapInfo)
  458. {
  459. CopyEquaLenArr(pLinkStruct->m_LinkLibName,MapInfo->m_LinkFileName,pLinkStruct->m_LinkLibName_Bytes);
  460. CopyEquaLenArr(pLinkStruct->m_RelatedSignLibName,MapInfo->m_SignFileName,pLinkStruct->m_SignLibName_Bytes);
  461. MapInfo->LinkName2DataLib(MapInfo->m_LinkFileName,MapInfo->m_DataFileName);
  462. MapInfo->m_MapTriangle = pLinkStruct->m_MapTri;
  463. }
  465. long CGpsDrawMap::GetDataLibAddr(char *DataLibName)
  466. {
  467. long InfoAddr,DataStartAddr,DataEndAddr,i,RetAddr = -1;
  468. char DataFileName[GpsLibFileLen + 1];
  470. InfoAddr = m_cFatStruct.m_lDataLibAddr;
  471. for(i = 0; i < m_cFatStruct.m_lDataLibTotal; i++) {
  472. ClearBYTEArr(DataFileName,GpsLibFileLen + 1);
  473. GetLibInfo(FileContent,InfoAddr,DataFileName,&DataStartAddr,&DataEndAddr);
  474. InfoAddr += LibInfoBytes; //链接库在FAT表中占用的字节数
  475. if(CompareTwoArr(DataFileName,DataLibName) == 1) {
  476. RetAddr = DataStartAddr;
  477. break;
  478. }
  479. }
  481. return RetAddr;
  482. }
  484. bool CGpsDrawMap::GetDataLib(char *DataLibName)
  485. {
  486. long DataLibStart;
  488. DataLibStart = GetDataLibAddr(DataLibName);
  489. if(DataLibStart == -1) return false;
  491. m_cCurrMapInfo.ClearColorBList();
  492. DataLibStart = GetColorBList(&m_cCurrMapInfo.lCurrColorBList,DataLibStart);
  494. m_cCurrMapInfo.ClearRoadList(m_cCurrMapInfo.lCurrRoadList);
  495. DataLibStart = GetRoadPlainPoint(&m_cCurrMapInfo.lCurrRoadList,DataLibStart);
  497. m_cCurrMapInfo.ClearCrossList();
  498. GetRoadCrossPoint(&m_cCurrMapInfo.lCurrCrossList,DataLibStart);
  500. return true;
  501. }
  503. long CGpsDrawMap::GetColorBList(CObList *ColorBList,long StartAddr)
  504. {
  505. CGpsColorBlock *pBlock;
  506. CGpsColorBlock cBlock;
  507. CGpsPoint *pPoint;
  508. short i,j;
  510. StartAddr += ColorBTotalBytes;
  511. cBlock.m_ColorBlockTotal = GetTwoBNum(FileContent,StartAddr);
  513. StartAddr += cBlock.m_ColorBlock_Bytes;
  514. for(i = 0; i < cBlock.m_ColorBlockTotal; i++) {
  515. pBlock = new CGpsColorBlock;
  516. ColorBList->AddHead(pBlock);
  517. pBlock->m_ColorBlockTotal = cBlock.m_ColorBlockTotal;
  519. pBlock->m_ColorValue = GetTwoBNum(FileContent,StartAddr);
  520. StartAddr += cBlock.m_ColorValue_Bytes;
  522. pBlock->m_ColorBlock_PointTotal = GetTwoBNum(FileContent,StartAddr);
  523. StartAddr += cBlock.m_ColorBlock_PointTotal_Bytes;
  525. for(j = 0; j < pBlock->m_ColorBlock_PointTotal; j++) {
  526. pPoint = new CGpsPoint;
  527. pBlock->ColorBlockPointList.AddHead(pPoint);
  528. GetPointNE(FileContent,&StartAddr,&pPoint->m_dgx,&pPoint->m_dgy);
  529. CovertNEXY(pPoint, m_cCurrMapInfo.CoeffNE_XY, true);
  530. }
  531. }
  533. return StartAddr;
  534. }
  536. long CGpsDrawMap::GetRoadPlainPoint(CObList *RoadList,long BufPos)
  537. {
  538. CSmallRoadStruct *pSmallRoad;
  539. CGpsRoadStruct *pRoad;
  540. CRoadPoint *pRoadPoint;
  541. long RoadTotal,i,j,k;
  542. BYTE DispLevel;
  544. RoadTotal = GetFourBNum(FileContent,BufPos);
  545. BufPos += LibTotalBytes;
  547. for(i = 0; i < RoadTotal; i++) {
  548. pRoad = new CGpsRoadStruct;
  549. RoadList->AddHead(pRoad);
  551. pRoad->BigRoad_Serial = GetOneBNum(FileContent,BufPos);
  552. BufPos += pRoad->BigRoad_SN_Bytes;
  553. pRoad->m_BigRoad_Number = GetTwoBNum(FileContent,BufPos);
  554. BufPos += pRoad->m_byBigRoad_Number_Bytes;
  556. pRoad->SmallRoadTotal = GetOneBNum(FileContent,BufPos);
  557. BufPos += pRoad->SmallRoadTotal_Bytes;
  558. pRoad->m_byIsHelpRoad = GetOneBNum(FileContent,BufPos);
  559. BufPos += pRoad->m_byHelpRoad_Bytes;
  561. for(j = 0; j < pRoad->SmallRoadTotal; j++) {
  562. pSmallRoad = new CSmallRoadStruct;
  563. pRoad->SmallRoadList.AddHead(pSmallRoad);
  565. GetLenArray(pSmallRoad->SmallRoad_SerialNumber,pSmallRoad->SmallRoad_SN_Bytes,FileContent,BufPos);
  566. BufPos += pSmallRoad->SmallRoad_SN_Bytes;
  567. GetLenArray((BYTE*)pSmallRoad->RoadName,pSmallRoad->RoadName_Bytes,FileContent,BufPos);
  568. BufPos += pSmallRoad->RoadName_Bytes;
  569. pSmallRoad->Road_SD = GetOneBNum(FileContent,BufPos);
  570. BufPos += pSmallRoad->Road_SD_Bytes;
  571. DispLevel = GetOneBNum(FileContent,BufPos);
  572. pSmallRoad->RoadorName_DispLevel = GetOneBNum(FileContent,BufPos);
  573. BufPos += pSmallRoad->DispLevel_Bytes;
  574. pSmallRoad->SmallRoad_PointTotal = GetTwoBNum(FileContent,BufPos);
  575. BufPos += pSmallRoad->PointTotal_Bytes;
  577. for(k = 0; k < pSmallRoad->SmallRoad_PointTotal; k++) {
  578. pRoadPoint = new CRoadPoint;
  579. pSmallRoad->RoadPointList.AddHead(pRoadPoint);
  581. GetLenArray(pRoadPoint->BigRoad_SerialNumber,pRoadPoint->BigRoad_SN_Bytes,FileContent,BufPos);
  582. BufPos += pRoadPoint->BigRoad_SN_Bytes;
  583. GetPointNE(FileContent,&BufPos,&pRoadPoint->m_dgx,&pRoadPoint->m_dgy);
  584. pRoadPoint->OutOfMap = GetOneBNum(FileContent,BufPos);
  585. BufPos += pRoadPoint->OutOfMap_Bytes;
  586. BufPos += pRoadPoint->OutOfMap_Bytes;
  588. CovertNEXY(pRoadPoint, m_cCurrMapInfo.CoeffNE_XY, true);
  589. }
  590. }
  591. }
  593. return BufPos;
  594. }
  596. long CGpsDrawMap::GetRoadCrossPoint(CObList *CrossList,long BufPos)
  597. {
  598. CGpsRoadCrossPoint *pCross;
  599. long CrossTotal,i;
  601. CrossTotal = GetFourBNum(FileContent,BufPos);
  602. BufPos += LibTotalBytes;
  604. for(i = 0; i < CrossTotal; i++) {
  605. pCross = new CGpsRoadCrossPoint;
  606. CrossList->AddHead(pCross);
  608. GetPointNE(FileContent,&BufPos,&pCross->m_dgx,&pCross->m_dgy);
  610. pCross->m_CrossRoad1_Serial = GetOneBNum(FileContent,BufPos);
  611. BufPos += pCross->m_CrossRoad1_Serial_Bytes;
  612. pCross->m_CrossRoad1_Number = GetTwoBNum(FileContent,BufPos);
  613. BufPos += pCross->m_CrossRoad1_Number_Bytes;
  614. pCross->m_CrossRoad1_Level  = GetOneBNum(FileContent,BufPos);
  615. BufPos += pCross->m_CrossRoad1_Level_Bytes;
  617. pCross->m_CrossRoad2_Serial = GetOneBNum(FileContent,BufPos);
  618. BufPos += pCross->m_CrossRoad2_Serial_Bytes;
  619. pCross->m_CrossRoad2_Number = GetTwoBNum(FileContent,BufPos);
  620. BufPos += pCross->m_CrossRoad2_Number_Bytes;
  621. pCross->m_CrossRoad2_Level  = GetOneBNum(FileContent,BufPos);
  622. BufPos += pCross->m_CrossRoad2_Level_Bytes;
  624. pCross->m_CrossRoad3_Serial = GetOneBNum(FileContent,BufPos);
  625. BufPos += pCross->m_CrossRoad3_Serial_Bytes;
  626. pCross->m_CrossRoad3_Number = GetTwoBNum(FileContent,BufPos);
  627. BufPos += pCross->m_CrossRoad3_Number_Bytes;
  628. pCross->m_CrossRoad3_Level  = GetOneBNum(FileContent,BufPos);
  629. BufPos += pCross->m_CrossRoad3_Level_Bytes;
  631. pCross->m_CrossRoad4_Serial = GetOneBNum(FileContent,BufPos);
  632. BufPos += pCross->m_CrossRoad4_Serial_Bytes;
  633. pCross->m_CrossRoad4_Number = GetTwoBNum(FileContent,BufPos);
  634. BufPos += pCross->m_CrossRoad4_Number_Bytes;
  635. pCross->m_CrossRoad4_Level  = GetOneBNum(FileContent,BufPos);
  636. BufPos += pCross->m_CrossRoad4_Level_Bytes;
  638. CovertNEXY(pCross, m_cCurrMapInfo.CoeffNE_XY, true);
  639. }
  641. return BufPos;
  642. }
  644. //Get Sign Lib...
  645. long CGpsDrawMap::GetSignLibAddr(char *SignLibName)
  646. {
  647. long InfoAddr,SignStartAddr,SignEndAddr,i,RetAddr = -1;
  648. char SignFileName[GpsLibFileLen + 1];
  650. InfoAddr = m_cFatStruct.m_lSignLibAddr;
  651. for(i = 0; i < m_cFatStruct.m_lSignLibTotal; i++) {
  652. ClearBYTEArr(SignFileName,GpsLibFileLen + 1);
  653. GetLibInfo(FileContent,InfoAddr,SignFileName,&SignStartAddr,&SignEndAddr);
  654. InfoAddr += LibInfoBytes; //链接库在FAT表中占用的字节数
  655. if(CompareTwoArr(SignFileName,SignLibName) == 1) {
  656. RetAddr = SignStartAddr;
  657. break;
  658. }
  659. }
  661. return RetAddr;
  662. }
  664. bool CGpsDrawMap::GetSignLib(char *SignLibName,CObList *SignList,bool Del)
  665. {
  666. long SignLibStart;
  668. SignLibStart = GetSignLibAddr(SignLibName);
  669. if(SignLibStart == -1) return false;
  671. if(!GetSignList(SignList,SignLibStart,Del)) return false;
  673. return true;
  674. }
  676. BYTE CGpsDrawMap::GetSignList(CObList *SignList,long StartAddr,bool Del)
  677. {
  678. BYTE Ret = 0;
  679. long Total;
  680. char CurrPath[500];
  681. CString Path;
  683. ClearBYTEArr(CurrPath,500);
  684. ::GetCurrentDirectory(500,CurrPath);
  685. Path = CurrPath;
  687. //Get Building
  688. if(GetSignObjectList(SignList,StartAddr,SignObjectOfOthers_Bytes,1,false,Del,Path + BuildingIconName)) Ret++;
  690. //Get Hotel
  691. if(GetSignObjectList(SignList,StartAddr,SignObjectOfOthers_Bytes,2,false,Del,Path + HotelIconName)) Ret++;
  693. //Get Company
  694. if(GetSignObjectList(SignList,StartAddr,SignObjectOfCompany_Bytes,3,true,Del,Path + CompanyIconName)) Ret++;
  696. //Get Amusement
  697. if(GetSignObjectList(SignList,StartAddr,SignObjectOfOthers_Bytes,4,false,Del,Path + AmusementIconName)) Ret++;
  699. //Get PlaceName
  700. if(GetSignObjectList(SignList,StartAddr,SignObjectOfOthers_Bytes,5,false,Del,Path + PlaceNameIconName)) Ret++;
  702. //跳过道路名层
  703. Total = GetFourBNum(FileContent,StartAddr);
  704. StartAddr += (LibTotalBytes + Total * SignRoadNameObjectBytes);
  706. //Get Government
  707. if(GetSignObjectList(SignList,StartAddr,SignObjectOfOthers_Bytes,7,false,Del,Path + GovernmentIconName)) Ret++;
  709. //Get Traffic
  710. if(GetSignObjectList(SignList,StartAddr,SignObjectOfOthers_Bytes,8,false,Del,Path + TrafficIconName)) Ret++;
  712. //Get Shopping
  713. if(GetSignObjectList(SignList,StartAddr,SignObjectOfOthers_Bytes,9,false,Del,Path + ShoppingIconName)) Ret++;
  715. //Get Education
  716. if(GetSignObjectList(SignList,StartAddr,SignObjectOfOthers_Bytes,10,false,Del,Path + EducationIconName)) Ret++;
  718. //Get AfterService
  719. if(GetSignObjectList(SignList,StartAddr,SignObjectOfAfterService_Bytes,11,false,Del)) Ret++;
  721. //Get Hospital
  722. if(GetSignObjectList(SignList,StartAddr,SignObjectOfOthers_Bytes,12,false,Del,Path + HospitalIconName)) Ret++;
  724. //Get Project
  725. if(GetSignObjectList(SignList,StartAddr,SignObjectOfProject_Bytes,13,false,Del,Path + ProjectIconName)) Ret++;
  727. //Get Oil
  728. if(GetSignObjectList(SignList,StartAddr,SignObjectOfOil_Bytes,14,false,Del,Path + OilIconName)) Ret++;
  730. return Ret;
  731. }
  733. bool CGpsDrawMap::GetSignObjectList(CObList *SignList,long &StartAddr,BYTE SignObject_Bytes,
  734. BYTE SignType,bool IsCompany,bool Del,CString IconName)
  735. {
  736. CGpsSignObject *pSign;
  737. long SignTotal,i;
  738. bool Flag = false;
  740. SignTotal = GetFourBNum(FileContent,StartAddr);
  741. StartAddr += LibTotalBytes;
  742. for(i = 0; i < SignTotal; i++) {
  743. pSign = new CGpsSignObject(SignObject_Bytes);
  744. if(SignObject_Bytes > SignObjectOfOil_Bytes) {
  745. GetLenArray((BYTE*)pSign->m_pSignObjectName,SignObject_Bytes,FileContent,StartAddr);
  746. StartAddr += SignObject_Bytes;
  748. GetPointNE(FileContent,&StartAddr,&pSign->m_dgx,&pSign->m_dgy);
  750. pSign->m_arrSignObject_Serial1 = GetOneBNum(FileContent,StartAddr);
  751. StartAddr += pSign->m_bySignObject_Serial1_Bytes;
  752. pSign->m_arrSignObject_Number1 = GetTwoBNum(FileContent,StartAddr);
  753. StartAddr += pSign->m_bySignObject_Number1_Bytes;
  754. pSign->m_arrSignObject_Serial2 = GetOneBNum(FileContent,StartAddr);
  755. StartAddr += pSign->m_bySignObject_Serial2_Bytes;
  756. pSign->m_arrSignObject_Number2 = GetTwoBNum(FileContent,StartAddr);
  757. StartAddr += pSign->m_bySignObject_Number2_Bytes;
  759. GetLenArray((BYTE*)pSign->m_arrSignObjectDispLevel,pSign->m_bySignDispLevel_Bytes,FileContent,StartAddr);
  760. StartAddr += pSign->m_bySignDispLevel_Bytes;
  762. if(IsCompany) {
  763. GetLenArray((BYTE*)pSign->m_arrSignAdvertise,pSign->m_bySignAdvertise_Bytes,FileContent,StartAddr);
  764. StartAddr += pSign->m_bySignAdvertise_Bytes;
  765. }
  766. }
  767. else {
  768. pSign->m_dgy = GetFourBNum(FileContent,StartAddr);
  769. StartAddr += pSign->m_gyBytes;
  771. pSign->m_dgx = GetFourBNum(FileContent,StartAddr);
  772. StartAddr += pSign->m_gxBytes;
  774. pSign->m_arrSignObject_Serial1 = GetOneBNum(FileContent,StartAddr);
  775. StartAddr += pSign->m_bySignObject_Serial1_Bytes;
  776. pSign->m_arrSignObject_Number1 = GetTwoBNum(FileContent,StartAddr);
  777. StartAddr += pSign->m_bySignObject_Number1_Bytes;
  778. pSign->m_arrSignObject_Serial2 = GetOneBNum(FileContent,StartAddr);
  779. StartAddr += pSign->m_bySignObject_Serial2_Bytes;
  780. pSign->m_arrSignObject_Number2 = GetTwoBNum(FileContent,StartAddr);
  781. StartAddr += pSign->m_bySignObject_Number2_Bytes;
  782. }
  783. pSign->m_sIconName = IconName;
  784. pSign->m_bySignType = SignType;
  786. CovertNEXY(pSign, m_cCurrMapInfo.CoeffNE_XY, true);
  788. if(Del) {
  789. //只显示当前图标志物
  790. if((pSign->m_lx > m_cCurrMapInfo.m_lWnd_Max_X) || (pSign->m_lx < 0) ||
  791.    (pSign->m_ly > m_cCurrMapInfo.m_lWnd_Max_Y) || (pSign->m_ly < 0)) {
  792. delete pSign;
  793. continue;
  794. }
  795. }
  797. SignList->AddHead(pSign);
  798. }
  799. if(SignList->GetCount()) Flag = true;
  801. return Flag;
  802. }
  804. bool CGpsDrawMap::CalcNE2XY(double gx,double gy,long &x,long &y)
  805. {
  806. if(!IsValidNE(gx,gy)) return false;
  808. CGpsPoint cPoint;
  810. cPoint.m_dgx = gx;
  811. cPoint.m_dgy = gy;
  813. CovertNEXY(&cPoint, m_cCurrMapInfo.CoeffNE_XY, true);
  815. x = cPoint.m_lx;
  816. y = cPoint.m_ly;
  818. return true;
  819. }
  821. /*************Get Library Infomation*************/
  822. void CGpsDrawMap::GetLibInfo(BYTE *Buf,long InfoAddr,char *FileName,long *StartAddr,long *EndAddr)
  823. {
  824. for(long i = 0; i < GpsLibFileLen; i++){
  825. FileName[i] = Buf[InfoAddr + i];
  826. }
  828. InfoAddr  += GpsLibFileLen;
  829. *StartAddr = GetFourBNum(Buf,InfoAddr);
  830. InfoAddr  += LibAddrBytes;
  831. *EndAddr   = GetFourBNum(Buf,InfoAddr);
  832. }
  834. /*************Calculate NE*************/
  835. double CGpsDrawMap::CovertNE(long lTemp)
  836. {
  837. double Ret,dTemp;
  838. dTemp = lTemp % 360000;
  839. Ret  = (lTemp / 360000) * 100 + dTemp / 6000;
  841. return Ret;
  842. }
  844. long CGpsDrawMap::CovertToLongNE(double dTemp)
  845. {
  846. long lTmp;
  847. lTmp = (long)( dTemp / 100);
  848. lTmp = (long)((lTmp  * 3600 + (dTemp - lTmp * 100) * 60) * 100);
  850. return lTmp;
  851. }
  853. void CGpsDrawMap::GetLinkLibThreePoint(BYTE * BUF,long StartAddr,ChangeTriangle * ThreePoint)
  854. {
  855. long BufPos;
  856. long ltmp;
  858. BufPos = StartAddr;
  859. ltmp = GetFourBNum(BUF,BufPos);
  860. ThreePoint->y1 = CovertNE(ltmp);
  862. BufPos += LibAddrBytes;
  863. ltmp = GetFourBNum(BUF,BufPos);
  864. ThreePoint->x1 = CovertNE(ltmp);
  866. BufPos += LibAddrBytes;
  867. ltmp = GetFourBNum(BUF,BufPos);
  868. ThreePoint->y2 = CovertNE(ltmp);
  870. BufPos += LibAddrBytes;
  871. ltmp = GetFourBNum(BUF,BufPos);
  872. ThreePoint->x2 = CovertNE(ltmp);
  874. BufPos += LibAddrBytes;
  875. ltmp = GetFourBNum(BUF,BufPos);
  876. ThreePoint->y3 = CovertNE(ltmp);
  878. BufPos += LibAddrBytes;
  879. ltmp = GetFourBNum(BUF,BufPos);
  880. ThreePoint->x3 = CovertNE(ltmp);
  882. #if 0
  883. long iTemp;
  884. iTemp = (long)(ThreePoint->x1 / 100);
  885. ThreePoint->x1 = ThreePoint->x1 - iTemp * 40;
  886. iTemp = (long)(ThreePoint->x2 / 100);
  887. ThreePoint->x2 = ThreePoint->x2 - iTemp * 40;
  888. iTemp = (long)(ThreePoint->x3 / 100);
  889. ThreePoint->x3 = ThreePoint->x3 - iTemp * 40;
  890. iTemp = (long)(ThreePoint->y1 / 100);
  891. ThreePoint->y1 = ThreePoint->y1 - iTemp * 40;
  892. iTemp = (long)(ThreePoint->y2 / 100);
  893. ThreePoint->y2 = ThreePoint->y2 - iTemp * 40;
  894. iTemp = (long)(ThreePoint->y3 / 100);
  895. ThreePoint->y3 = ThreePoint->y3 - iTemp * 40;
  896. #endif
  897. }
  899. long CGpsDrawMap::GetLinkList(CObList *pLinkList,BYTE MapLevel)
  900. {
  901. long InfoAddr,LinkStartAddr,LinkEndAddr,i,Count = 0;
  902. char FirstChar;
  903. CGpsLinkStruct cGpsLink,*pLink;
  904. ChangeTriangle TmpTri;
  906. FirstChar = MapLevel + ('A' - 1);
  908. InfoAddr = m_cFatStruct.m_lLinkLibAddr;
  909. for(i = 0; i < m_cFatStruct.m_lLinkLibTotal; i++) {
  910. ClearBYTEArr(cGpsLink.m_LinkLibName,9);
  911. GetLibInfo(FileContent,InfoAddr,cGpsLink.m_LinkLibName,&LinkStartAddr,&LinkEndAddr);
  913. InfoAddr += LibInfoBytes; //链接库在FAT表中占用的字节数
  914. if(FirstChar != cGpsLink.m_LinkLibName[0]) {
  915. continue;
  916. }
  917. LinkStartAddr += 68; //将链接库指针移动到三个经纬度坐标
  918. GetLinkLibThreePoint(FileContent,LinkStartAddr,&TmpTri);
  920. LinkStartAddr += 24;
  921. ClearBYTEArr(cGpsLink.m_RelatedSignLibName,9);
  922. GetLenArray((BYTE*)cGpsLink.m_RelatedSignLibName,GpsLibFileLen,FileContent,LinkStartAddr); //获得综合标志库名称
  924. pLink  = new CGpsLinkStruct;
  925. *pLink = cGpsLink;
  926. pLink->m_MapTri = TmpTri;
  928. pLinkList->AddHead(pLink);
  929. Count++;
  930. }
  932. return Count;
  933. }
  935. void CGpsDrawMap::GetAreaLibList(CObList *AreaList)
  936. {
  937. CGpsAreaLibStruct *pArea = NULL;
  938. long j,Total,StartAddr,EndAddr;
  939. char FileName[8],i;
  941. if(!m_cFatStruct.m_lRegionLibTotal) return ;
  942. GetLibInfo(FileContent,m_cFatStruct.m_lRegionLibAddr,FileName,&StartAddr,&EndAddr);
  944. for(i = 1; i <= AreaLibLevelTotal; i++) {
  945. Total = GetFourBNum(FileContent,StartAddr);
  946. StartAddr += LibTotalBytes;
  947. for(j = 0; j < Total; j++) {
  948. pArea = new CGpsAreaLibStruct;
  949. AreaList->AddHead(pArea);
  950. pArea->m_byAreaLevel = i;
  951. GetLenArray((BYTE*)pArea->m_arrAreaABCD,pArea->m_byAreaABCD_Bytes,FileContent,StartAddr);
  952. StartAddr += pArea->m_byAreaABCD_Bytes;
  953. GetLenArray((BYTE*)pArea->m_arrAreaName,pArea->m_byAreaName_Bytes,FileContent,StartAddr);
  954. StartAddr += pArea->m_byAreaName_Bytes;
  956. if(i == AreaLibLevelTotal) {
  957. GetLenArray((BYTE*)pArea->m_arrRelateSignLibName,pArea->m_byRelateSignLibName_Bytes,FileContent,StartAddr);
  958. StartAddr += pArea->m_byRelateSignLibName_Bytes;
  959. }
  960. }
  961. }
  962. }
  964. bool CGpsDrawMap::CompareTri(ChangeTriangle TmpTri1,ChangeTriangle TmpTri2)
  965. {
  966. double dx1,dy1,dx2,dy2,Bevel1,Bevel2;
  967. bool Result = false;
  969. dx1 = TmpTri1.x3 - TmpTri1.x1; dy1 = TmpTri1.y1 - TmpTri1.y3;
  970. Bevel1 = sqrt(dx1 * dx1 + dy1 * dy1);
  971. dx2 = TmpTri2.x3 - TmpTri2.x1; dy2 = TmpTri2.y1 - TmpTri2.y3;
  972. Bevel2 = sqrt(dx2 * dx2 + dy2 * dy2);
  974. if((Bevel1 - Bevel2) > 0) {
  975. Result = true;
  976. }
  978. return Result;
  979. }
  981. /*************Find CurrPoint in whitch map*************/
  982. bool CGpsDrawMap::CheckPointInMap(double gx,double gy,ChangeTriangle *TmpTri)
  983. {
  984. bool InMap = false;
  986. if(((gx >= TmpTri->x1) && (gx <= TmpTri->x3)) &&
  987.    ((gy <= TmpTri->y1) && (gy >= TmpTri->y3))) {
  988. InMap = true;
  989. }
  991. return InMap;
  992. }
  994. bool CGpsDrawMap::GetCurrLinkLib(CObList *LinkList,CGpsLinkStruct *pLink,double gx,double gy)
  995. {
  996. CGpsLinkStruct *pTemp;
  997. POSITION pos;
  998. bool Result = false,Flag = false;
  1000. if(LinkList->GetCount() == 0) return false;
  1002. pos = LinkList->GetTailPosition();
  1003. while(pos != NULL) {
  1004. pTemp  = (CGpsLinkStruct*)LinkList->GetPrev(pos);
  1005. if(CheckPointInMap(gx,gy,&pTemp->m_MapTri)) {
  1006. if(!Flag) {
  1007. Flag = true;
  1008. Result = true;
  1009. *pLink = *pTemp;
  1010. pLink->m_MapTri = pTemp->m_MapTri;
  1011. }
  1012. else {
  1013. if(CompareTri(pLink->m_MapTri,pTemp->m_MapTri)) {
  1014. *pLink = *pTemp;
  1015. pLink->m_MapTri = pTemp->m_MapTri;
  1016. }
  1017. }
  1018. }
  1019. }
  1021. return Result;
  1022. }
  1024. long CGpsDrawMap::GetLinkLibAddr(char *pLinkName)
  1025. {
  1026. long Result = -1;
  1027. char LinkName[GpsLibFileLen + 1];
  1028. long InfoAddr,LinkStartAddr,LinkEndAddr,i;
  1030. InfoAddr = m_cFatStruct.m_lLinkLibAddr;
  1031. for(i  = 0; i < m_cFatStruct.m_lLinkLibTotal; i++) {
  1032. ClearBYTEArr(LinkName,GpsLibFileLen + 1);
  1033. GetLibInfo(FileContent,InfoAddr,LinkName,&LinkStartAddr,&LinkEndAddr);
  1034. InfoAddr += LibInfoBytes; //链接库在FAT表中占用的字节数
  1035. if(CompareTwoArr(pLinkName,LinkName) == 1) {
  1036. Result = InfoAddr;
  1037. break;
  1038. }
  1039. }
  1041. return Result;
  1042. }
  1044. /*************Draw ColorBlock*************/
  1045. void CGpsDrawMap::DrawColorBlock(CObList *ColorBList,CDC * MemDC)
  1046. {
  1047. CGpsColorBlock *pBlock;
  1048. POSITION pos;
  1049. CPen *DrawPen;
  1051. pos = ColorBList->GetTailPosition();
  1052. while(pos != NULL) {
  1053. pBlock = (CGpsColorBlock*)ColorBList->GetPrev(pos);
  1054. pBlock->m_ColorValue == 8 ? DrawPen = m_cColor.MapColor[6]:
  1055. DrawPen = m_cColor.MapColor[pBlock->m_ColorValue - 1];
  1056. DrawOneBlock(&pBlock->ColorBlockPointList,DrawPen,MemDC);
  1057. }
  1058. }
  1060. void CGpsDrawMap::DrawOneBlock(CObList * PointList,CPen * CurrPen,CDC * MemDC)
  1061. {
  1062. long PointXY[3000][2];
  1063. long MapBrim[500][4];
  1064. long minX1 = -3000,minX2,PointCount;
  1065. int i,j;
  1066. BYTE b_draw;
  1067. CGpsPoint *tmpPoint;
  1068. POSITION pos;
  1070. PointCount = PointList->GetCount();
  1071. pos = PointList->GetHeadPosition();
  1072. i = 0;
  1073. while(pos != NULL){
  1074. tmpPoint = (CGpsPoint*)PointList->GetNext(pos);
  1075. PointXY[i][0] = tmpPoint->m_lx;
  1076. PointXY[i][1] = tmpPoint->m_ly;
  1077. i++;
  1078. if(i == 3000) {
  1079. AfxMessageBox("系统内部出错!");
  1080. return;
  1081. }
  1082. }
  1083. minX1 = GetMinX(&PointXY[0][0],PointCount,minX1);
  1084. minX2 = GetMinX(&PointXY[0][0],PointCount,minX1);
  1086. CString str;
  1088. while(true){
  1089. if(minX1 > m_cCurrMapInfo.m_lWnd_Max_X) {
  1090.         break;
  1091. }
  1093.     minX2 = GetMinX(&PointXY[0][0],PointCount,minX1);
  1095. if(minX2 == 10000){
  1096.         break;
  1097. }
  1098.     if(minX2 < 0) {
  1099.         minX1 = minX2;
  1100. continue;
  1101. }
  1103.     b_draw = 0;
  1104.     for(i = 0; i < (PointCount - 1);i++){
  1105.         if((( PointXY[i][0] <= minX1) &&
  1106. ( PointXY[i + 1][0] >= minX2) &&
  1107. ( PointXY[i][0] <  PointXY[i + 1][0])) ||
  1108. ((PointXY[i][0] >= minX2) &&
  1109. ( PointXY[i + 1][0] <= minX1) &&
  1110. ( PointXY[i][0] >  PointXY[i + 1][0]))){
  1111.         GetDrawPoint(&PointXY[i][0],minX1,minX2,&MapBrim[b_draw][0]);
  1112. b_draw++;
  1113. if(b_draw == 500){
  1114. AfxMessageBox("系统内部出错!");
  1115. return;
  1116. }
  1117. }
  1118.     }
  1120. long tmp;
  1121. for(i = 0; i < b_draw; i++){
  1122. for(j = i + 1; j < b_draw; j++){
  1123. if(MapBrim[i][1] > MapBrim[j][1]){
  1124. tmp = MapBrim[i][1];
  1125. MapBrim[i][1] = MapBrim[j][1]; 
  1126. MapBrim[j][1] = tmp;
  1128. tmp = MapBrim[i][3];
  1129. MapBrim[i][3] = MapBrim[j][3]; 
  1130. MapBrim[j][3] = tmp;
  1131. }
  1132. }
  1133. }
  1135. b_draw = b_draw / 2;
  1136. for(i = 0; i < b_draw; i++){
  1137. DrawTriangle(&MapBrim[2 * i][0],&MapBrim[2 * i + 1][0],CurrPen,MemDC);
  1138.     }
  1140.     minX1 = minX2;
  1141. }
  1142. }
  1144. void CGpsDrawMap::DrawTriangle(long *bian1, long *bian2,CPen * CurrPen,CDC * MemDC)
  1145. {
  1146. long y1,y2,tmp;
  1148.     if((bian1[3] > bian2[3]) || (bian1[1] > bian2[1])){
  1149. tmp = bian1[3];
  1150. bian1[3] = bian2[3];
  1151. bian2[3] = tmp;
  1153. tmp = bian1[1];
  1154. bian1[1] = bian2[1];
  1155. bian2[1] = tmp;
  1156.     }
  1158.     for(int i = bian1[0]; i < bian2[2]; i++){
  1159.         y1 = bian1[1] + (i - bian1[0]) * (bian1[3] - bian1[1]) / (bian1[2] - bian1[0]);
  1161. if(y1 > m_cCurrMapInfo.m_lWnd_Max_Y) {
  1162. y1 = (long)m_cCurrMapInfo.m_lWnd_Max_Y;
  1163. }
  1164. else if(y1 < 0) {
  1165.         y1 = 0;
  1166. }
  1168.         y2 = bian2[1] + (i - bian2[0]) * (bian2[3] - bian2[1]) / (bian2[2] - bian2[0]);
  1170. if(y2 > m_cCurrMapInfo.m_lWnd_Max_X) {
  1171.     y2 = (long)m_cCurrMapInfo.m_lWnd_Max_X;
  1172. }
  1173. else{
  1174. if(y2 < 0){
  1175. y2 = 0;
  1176. }
  1177. }
  1179. DrawLine(i,y1,i,y2,1,CurrPen,MemDC);
  1180.     }
  1181. }
  1183. /*************Draw Line*************/
  1184. void CGpsDrawMap::DrawLine(long SX, long SY, long EX, long EY, int LineCount,CPen * CurrPen,CDC * MemDC)
  1185. {
  1186. CPen * OldPen;
  1187. OldPen = MemDC->SelectObject(CurrPen);
  1189. int bian  = 1;
  1190. int LineWide = LineCount;
  1192. MemDC->MoveTo(SX,SY);
  1193. MemDC->LineTo(EX,EY);
  1195.     while((LineCount--) > 0){
  1196. if(SX == EX){
  1197. bool flag = true;
  1198. BYTE tmp  = 1;
  1199. for(int i = 0; i < LineWide; i++){
  1200. if(flag){
  1201. MemDC->MoveTo(SX + tmp,SY);
  1202. MemDC->LineTo(EX + tmp,EY);
  1203. flag = false;
  1204. }
  1205. else{
  1206. MemDC->MoveTo(SX - tmp,SY);
  1207. MemDC->LineTo(EX - tmp,EY);
  1208. flag = true;
  1209. }
  1210. if (flag) tmp++;
  1211. }
  1212. }
  1213. else if( ((EY - SY) / ( EX - SX)) != 0){
  1214. MemDC->MoveTo(SX - bian,SY);
  1215. MemDC->LineTo(EX - bian,EY);
  1216. }
  1217. else{
  1218. MemDC->MoveTo(SX,SY - bian);
  1219. MemDC->LineTo(EX,EY - bian);
  1220. }
  1222. if(bian > 0){
  1223. bian = 0 - bian;
  1224. }
  1225. else{
  1226. bian = 0 - bian;
  1227. bian++;
  1228. }
  1229. }
  1230. MemDC->SelectObject(OldPen);
  1231. }
  1233. long CGpsDrawMap::GetMinX(long *pDataXY,long PointCount,long MinX)
  1234. {
  1235.     long ret = 10000;
  1236.     bool flag = false;
  1237.     for(int i = 0; i < PointCount; i++){
  1238.         if(pDataXY[i * 2] > MinX){
  1239.     if(pDataXY[i * 2] < ret){
  1240.         ret = pDataXY[i * 2];
  1241. flag = true;
  1242.     }
  1243. }
  1244. }
  1246. return ret;
  1247. }
  1249. void CGpsDrawMap::GetDrawPoint(long line_p[], int minX1, int minX2, long *Result)
  1250. {
  1251.     int x1,y1,x2,y2;
  1252. bool flag = true;
  1254.     if(line_p[1] == line_p[3]){
  1255.         flag = false;
  1256. }
  1258.     if(line_p[0] > line_p[2]){
  1259.         x1 = line_p[2];
  1260.         y1 = line_p[3];
  1261.         x2 = line_p[0];
  1262.         y2 = line_p[1];
  1263.     }
  1264.     else{
  1265.         x1 = line_p[0];
  1266.         y1 = line_p[1];
  1267.         x2 = line_p[2];
  1268.         y2 = line_p[3];
  1269.     }
  1271.     if(minX1 < 0){
  1272.         Result[0] = 0;
  1273.     }
  1274.     else{
  1275.         Result[0] = minX1;
  1276.     }
  1277.     if(minX2 > m_cCurrMapInfo.m_lWnd_Max_X) {
  1278.         Result[2] = (long)m_cCurrMapInfo.m_lWnd_Max_X;
  1279.     }
  1280.     else{
  1281.         Result[2] = minX2;
  1282.     }
  1285.     if(flag){
  1286. Result[1] = y1 + (Result[0] - x1) * (y2 - y1) / (x2 - x1);
  1287. }
  1288.     else{
  1289. Result[1] = line_p[1];
  1290. }
  1292.     if(flag){
  1293.         Result[3] = y1 + (Result[2] - x1) * (y2 - y1) / (x2 - x1);
  1294. }
  1295.     else{
  1296.         Result[3] = line_p[1];
  1297. }
  1298. }
  1300. /*************Draw Road*************/
  1301. void CGpsDrawMap::DrawRoad(CObList *RoadList,CDC *pDC)
  1302. {
  1303. CGpsRoadStruct *pRoad;
  1304. CSmallRoadStruct *pSmall;
  1305. CRoadPoint *pRoadPoint;
  1306. POSITION pos,pos1,pos2;
  1307. CPoint PrevPoint,CurrPoint;
  1308. CPen *CurrPen;
  1309. BYTE RoadLevel,RoadWidth;
  1310. bool Flag;
  1312. pos = RoadList->GetTailPosition();
  1313. while(pos != NULL) {
  1314. pRoad  = (CGpsRoadStruct*)RoadList->GetPrev(pos);
  1315. pos1   = pRoad->SmallRoadList.GetTailPosition();
  1316. Flag   = false;
  1317. while(pos1 != NULL) {
  1318. pSmall  = (CSmallRoadStruct*)pRoad->SmallRoadList.GetPrev(pos1);
  1320. RoadLevel = pSmall->RoadorName_DispLevel & 0x0f;
  1321. switch (RoadLevel) {
  1322. case 0:
  1323. CurrPen   = m_cColor.RoadColor[5];
  1324. RoadWidth = 1;
  1325. break;
  1326. case 1:
  1327. RoadWidth = 3;
  1328. CurrPen   = m_cColor.RoadColor[0];
  1329. break;
  1330. case 2:
  1331. RoadWidth = 3;
  1332. CurrPen   = m_cColor.RoadColor[1];
  1333. break;
  1334. case 3:
  1335. RoadWidth = 3;
  1336. CurrPen   = m_cColor.RoadColor[2];
  1337. break;
  1338. case 4:
  1339. RoadWidth = 2;
  1340. CurrPen   = m_cColor.RoadColor[3];
  1341. break;
  1342. case 5:
  1343. RoadWidth = 1;
  1344. CurrPen   = m_cColor.RoadColor[4];
  1345. break;
  1346. default:
  1347. RoadWidth = 3;
  1348. CurrPen   = m_cColor.RoadColor[2];
  1349. break;
  1350. }
  1351. switch(m_byZoomCoeffic) {
  1352. case 1:
  1353. RoadWidth += 2;
  1354. break;
  1355. case 2:
  1356. RoadWidth += 3;
  1357. break;
  1358. case 4:
  1359. RoadWidth += 4;
  1360. break;
  1361. }
  1362. if(pRoad->m_byIsHelpRoad) {
  1363. RoadWidth = 2;
  1364. }
  1366. pos2 = pSmall->RoadPointList.GetTailPosition();
  1367. while(pos2 != NULL) {
  1368. pRoadPoint = (CRoadPoint*)pSmall->RoadPointList.GetPrev(pos2);
  1369. if(pRoadPoint->BigRoad_SerialNumber[1] == 100) continue;
  1370. CurrPoint.x = pRoadPoint->m_lx; CurrPoint.y = pRoadPoint->m_ly;
  1371. if(!Flag) {
  1372. Flag = true;
  1373. }
  1374. else {
  1375. // DrawLine(PrevPoint.x, PrevPoint.y, 
  1376. //  CurrPoint.x, CurrPoint.y, 
  1377. //  RoadWidth,CurrPen,pDC);
  1378. MapDrawRoad(pDC,PrevPoint.x,PrevPoint.y,CurrPoint.x,CurrPoint.y,RoadWidth,CurrPen);
  1379. }
  1380. PrevPoint = CurrPoint;
  1381. }
  1382. }
  1383. }
  1384. }
  1386. void CGpsDrawMap::MapDrawRoad(CDC *pDC, long SX, long SY, long EX, long EY, BYTE RoadWide,CPen *CurrPen)
  1387. {
  1388. CPen BorderPen(PS_SOLID,1,RGB(115,115,115));
  1389. long W;
  1391. MapDrawLineWidth(pDC,SX,SY,EX,EY,RoadWide,CurrPen);
  1393. /*
  1394.  ** always draws from small X to large X
  1395. */
  1396. if (SX > EX) {
  1397. W = EX, EX = SX, SX = W;
  1398. W = EY, EY = SY, SY = W;
  1399. }
  1401. if (SX == EX) {
  1402. DrawLine(SX - (RoadWide >> 1), SY, EX - (RoadWide >> 1), EY,0,&BorderPen,pDC);
  1403. DrawLine(SX + (RoadWide >> 1), SY, EX + (RoadWide >> 1), EY,0,&BorderPen,pDC);
  1404. return;
  1405. }
  1407. if (SY == EY) {
  1408. DrawLine(SX, SY - (RoadWide >> 1), EX, EY - (RoadWide >> 1),0,&BorderPen,pDC);
  1409. DrawLine(SX, SY + (RoadWide >> 1), EX, EY + (RoadWide >> 1),0,&BorderPen,pDC);
  1410. return;
  1411. }
  1413. if (SY < EY) {
  1414. DrawLine(SX + (RoadWide >> 1), SY - (RoadWide >> 1), EX + (RoadWide >> 1), EY - (RoadWide >> 1),0,&BorderPen,pDC);
  1415. DrawLine(SX - (RoadWide >> 1), SY + (RoadWide >> 1), EX - (RoadWide >> 1), EY + (RoadWide >> 1),0,&BorderPen,pDC);
  1416. return;
  1417. }
  1419. if (SY > EY) {
  1420. DrawLine(SX - (RoadWide >> 1), SY - (RoadWide >> 1), EX - (RoadWide >> 1), EY - (RoadWide >> 1),0,&BorderPen,pDC);
  1421. DrawLine(SX + (RoadWide >> 1), SY + (RoadWide >> 1), EX + (RoadWide >> 1), EY + (RoadWide >> 1),0,&BorderPen,pDC);
  1422. return;
  1423. }
  1424. }
  1426. void CGpsDrawMap::MapDrawLineWidth(CDC *pDC, long SX, long SY, long EX, long EY, BYTE MapLineWidth,CPen *Pen)
  1427. {
  1428. long W, H, Ha, dY, f;
  1429. BYTE HalfWidth = MapLineWidth / 2;
  1430. CPoint sp,ep;
  1431. CPen *OldPen;
  1433. OldPen = pDC->SelectObject(Pen);
  1434. /*
  1435. for (i = 0; i < MapLineWidth; i++) {
  1436. sp.x = SX - HalfWidth + i;
  1437. sp.y = SX - HalfWidth;
  1438. ep.x = SX - HalfWidth + i;
  1439. ep.y = SX - HalfWidth - MapLineWidth;
  1440. pDC->MoveTo(sp);
  1441. pDC->LineTo(ep);
  1443. sp.x = EX - HalfWidth + i;
  1444. sp.y = EX - HalfWidth;
  1445. ep.x = EX - HalfWidth + i;
  1446. ep.y = EX - HalfWidth - MapLineWidth;
  1447. pDC->MoveTo(sp);
  1448. pDC->LineTo(ep);
  1449. }
  1450. */
  1451. /*
  1452.  ** always draws from small X to large X
  1453.  */
  1454. if (SX > EX) {
  1455. W = EX, EX = SX, SX = W;
  1456. W = EY, EY = SY, SY = W;
  1457. }
  1459. /*
  1460.  ** we might want to clip the line here
  1461.  */
  1462. W = (EX - SX);
  1463. H = (EY - SY);
  1464. Ha = (H < 0) ? -H : H;
  1465. dY = (H < 0) ? -1 : 1;
  1467. if (Ha > W) {
  1468. /* Y-majored */
  1469. f = 0;
  1470. while (1) {
  1471. sp.x = SX - HalfWidth;
  1472. sp.y = SY - HalfWidth;
  1473. ep.x = SX - HalfWidth + MapLineWidth;
  1474. ep.y = SY - HalfWidth;
  1475. pDC->MoveTo(sp);
  1476. pDC->LineTo(ep);
  1478. sp.x = SX - HalfWidth;
  1479. sp.y = SY - HalfWidth;
  1480. ep.x = SX - HalfWidth;
  1481. ep.y = SY - HalfWidth + MapLineWidth;
  1482. pDC->MoveTo(sp);
  1483. pDC->LineTo(ep);
  1487. sp.x = SX + HalfWidth;
  1488. sp.y = SY + HalfWidth;
  1489. ep.x = SX + HalfWidth - MapLineWidth;
  1490. ep.y = SY + HalfWidth;
  1491. pDC->MoveTo(sp);
  1492. pDC->LineTo(ep);
  1494. sp.x = SX + HalfWidth;
  1495. sp.y = SY + HalfWidth;
  1496. ep.x = SX + HalfWidth;
  1497. ep.y = SY + HalfWidth - MapLineWidth;
  1498. pDC->MoveTo(sp);
  1499. pDC->LineTo(ep);
  1502. if (SY == EY) break;
  1503. if ((f += W) >= Ha) {
  1504. f -= Ha;
  1505. SX++;
  1506. }
  1507. SY += dY;
  1508. }
  1509. }
  1510. else {
  1511. /* X-majored */
  1512. f = 0;
  1513. while (1) {
  1514. sp.x = SX - HalfWidth;
  1515. sp.y = SY - HalfWidth;
  1516. ep.x = SX - HalfWidth + MapLineWidth;
  1517. ep.y = SY - HalfWidth;
  1518. pDC->MoveTo(sp);
  1519. pDC->LineTo(ep);
  1521. sp.x = SX - HalfWidth;
  1522. sp.y = SY - HalfWidth;
  1523. ep.x = SX - HalfWidth;
  1524. ep.y = SY - HalfWidth + MapLineWidth;
  1525. pDC->MoveTo(sp);
  1526. pDC->LineTo(ep);
  1528. sp.x = SX + HalfWidth;
  1529. sp.y = SY + HalfWidth;
  1530. ep.x = SX + HalfWidth - MapLineWidth;
  1531. ep.y = SY + HalfWidth;
  1532. pDC->MoveTo(sp);
  1533. pDC->LineTo(ep);
  1535. sp.x = SX + HalfWidth;
  1536. sp.y = SY + HalfWidth;
  1537. ep.x = SX + HalfWidth;
  1538. ep.y = SY + HalfWidth - MapLineWidth;
  1539. pDC->MoveTo(sp);
  1540. pDC->LineTo(ep);
  1542. if (SX == EX) break;
  1543. if ((f += Ha) >= W) {
  1544. f -= W;
  1545. SY += dY;
  1546. }
  1547. SX++;
  1548. }
  1549. }
  1551. pDC->SelectObject(OldPen);
  1552. }
  1554. /*************Draw Road Name*************/
  1555. void CGpsDrawMap::DrawRoadName(CObList *RoadList,CDC *pDC)
  1556. {
  1557. CGpsRoadStruct *pRoad;
  1558. CSmallRoadStruct *pSmall;
  1559. POSITION pos,pos1;
  1560. CString RoadName;
  1562. pos = RoadList->GetTailPosition();
  1563. while(pos != NULL) {
  1564. pRoad  = (CGpsRoadStruct*)RoadList->GetPrev(pos);
  1565. if(isupper(pRoad->BigRoad_Serial)) continue;
  1566. pos1   = pRoad->SmallRoadList.GetTailPosition();
  1567. while(pos1  != NULL) {
  1568. pSmall   = (CSmallRoadStruct*)pRoad->SmallRoadList.GetPrev(pos1);
  1569. RoadName.Empty();
  1570. RoadName = pSmall->RoadName;
  1571. if(RoadName.IsEmpty()) continue;
  1572. if(pSmall->RoadPointList.GetCount() < 2) continue;
  1573. DrawOneRoadName(&pSmall->RoadPointList,RoadName,pDC);
  1574. }
  1575. }
  1576. }
  1578. BYTE CGpsDrawMap::GetChrCount(CString RoadName)
  1579. {
  1580. BYTE chr,pos,Length = 0;
  1582. pos = 0;
  1583. while(pos < RoadName.GetLength()) {
  1584. chr = RoadName.GetAt(pos);
  1585. if(chr < 0x80) pos++;
  1586. else pos += 2;
  1587. Length++;
  1588. }
  1590. return Length;
  1591. }
  1593. CPoint CGpsDrawMap::GetRoadMidPoint(CObList *RoadList)
  1594. {
  1595. CGpsPoint *pPoint;
  1596. POSITION pos;
  1597. CPoint point;
  1598. short Mid,Count = 0;
  1600. Mid = RoadList->GetCount() / 2;
  1601. pos = RoadList->GetTailPosition();
  1602. while(pos != NULL) {
  1603. pPoint = (CGpsPoint*)RoadList->GetPrev(pos);
  1604. if(Count == Mid) {
  1605. point.x = pPoint->m_lx;
  1606. point.y = pPoint->m_ly;
  1607. return point;
  1608. }
  1609. Count++;
  1610. }
  1612. return NULL;
  1613. }
  1615. void CGpsDrawMap::DrawStr(CDC *pDC,CPoint point,CString Name)
  1616. {
  1617. CPoint TempPoint,cPoint(6,6),SavePoint;
  1618. CBrush cBrush(RGB(0,255,255));
  1619. CPen CurrPen(PS_SOLID,1,RGB(0,0,255)),*pSavePen = NULL;
  1620. CRect cRect;
  1621. bool Flag1 = false,Flag2 = false;
  1623. pSavePen = pDC->SelectObject(&CurrPen);
  1625. TempPoint.x = (long)(point.x + 30 / sqrt(2));
  1626. TempPoint.y = (long)(point.y - 30 / sqrt(2));
  1628. cRect = CRect(TempPoint.x - 3,TempPoint.y - 2,TempPoint.x + 3 + Name.GetLength() * 8,TempPoint.y + 18);
  1630. if(cRect.top < 0) Flag1 = true;
  1631. if(cRect.right > m_cCurrMapInfo.m_lWnd_Max_X) Flag2 = true;
  1633. if(Flag1) {
  1634. TempPoint.y = (long)(point.y + 30 / sqrt(2));
  1635. }
  1636. if(Flag2) {
  1637. TempPoint.x = (long)(point.x - 30 / sqrt(2));
  1638. }
  1640. pDC->MoveTo(point);
  1641. pDC->LineTo(TempPoint);
  1642. SavePoint = TempPoint;
  1644. if(Flag2) TempPoint.x = TempPoint.x - (3 + Name.GetLength() * 8);
  1646. cRect = CRect(TempPoint.x - 3,TempPoint.y - 2,TempPoint.x + 3 + Name.GetLength() * 8,TempPoint.y + 18);
  1648. pDC->SetBkMode(TRANSPARENT);
  1649. pDC->RoundRect(cRect,cPoint);
  1650. // pDC->FillRect(cRect,&cBrush);
  1651. pDC->TextOut(TempPoint.x,TempPoint.y,Name);
  1653. TempPoint = SavePoint;
  1654. TempPoint.y += 8;
  1656. pDC->MoveTo(point);
  1657. pDC->LineTo(TempPoint);
  1659. pDC->SelectObject(pSavePen);
  1660. }
  1662. long CGpsDrawMap::CalcTwoPointDist(CPoint sp,CPoint ep)
  1663. {
  1664. long dx,dy,Distance;
  1666. dx = abs(sp.x - ep.x);
  1667. dy = abs(sp.y - ep.y);
  1669. Distance = (long)sqrt(Square(dx) + Square(dy));
  1671. return Distance;
  1672. }
  1674. void CGpsDrawMap::SearchSign()
  1675. {
  1676. CSearchSignDlg dlg(&m_cCurrMapInfo.lCurrSignList,&m_cCurrMapInfo.lAreaLibList);
  1678. dlg.GetParent(this);
  1679. dlg.DoModal();
  1680. }
  1682. long CGpsDrawMap::CalcPointsDist(CObList *TempList,bool ByNE)
  1683. {
  1684. CGpsPoint *pPoint;
  1685. POSITION pos = TempList->GetTailPosition();
  1686. CPoint sp,ep;
  1687. long Dist = 0;
  1688. BYTE Flag = 0;
  1690. while(pos != NULL) {
  1691. pPoint = (CGpsPoint*)TempList->GetPrev(pos);
  1692. if(!ByNE) {
  1693. ep.x = pPoint->m_lx;
  1694. ep.y = pPoint->m_ly;
  1695. }
  1696. else {
  1697. ep.x = CovertToLongNE(pPoint->m_dgx);
  1698. ep.y = CovertToLongNE(pPoint->m_dgy);
  1699. }
  1701. if(!Flag) {
  1702. Flag = 1;
  1703. sp = ep;
  1704. continue;
  1705. }
  1706. Dist +=CalcTwoPointDist(sp,ep);
  1707. sp = ep;
  1708. }
  1710. return Dist;
  1711. }
  1713. CPoint CGpsDrawMap::CalcOneLinePoint(CPoint sp,CPoint ep,long WordPos,long Bevel)
  1714. {
  1715. CPoint point;
  1716. long dx,dy;
  1718. dx = ep.x - sp.x; dy = ep.y - sp.y;
  1720. if(dx == 0) {
  1721. point.x = sp.x;
  1722. point.y = sp.y + dy - WordPos;
  1723. }
  1724. else if(dy == 0) {
  1725. point.x = sp.x + dx - WordPos;
  1726. point.y = sp.y;
  1727. }
  1728. else {
  1729. point.x = sp.x + (WordPos * dx) / Bevel;
  1730. point.y = sp.y + (WordPos * dy) / Bevel;
  1731. }
  1733. return point;
  1734. }
  1736. void CGpsDrawMap::DrawOneRoadName(CObList * TempList,CString RoadName,CDC * MemDC)
  1737. {
  1738. CGpsPoint *pPoint = NULL;
  1739. POSITION pos;
  1740. CString Word;
  1741. CPoint point,sp,ep;
  1742. BYTE FirstChr,DrawMode,Flag = 0;
  1743. BYTE NamePos = 1,Len = GetChrCount(RoadName);
  1744. short PointTotal = TempList->GetCount();
  1745. long WordPos,Dist,CurrDist,d = 0,dx,dy;
  1747. FirstChr = RoadName.GetAt(0);
  1748. if(isalpha(FirstChr)) DrawMode = true;
  1749. else if(Len > PointTotal) DrawMode = true;
  1750. else DrawMode = false;
  1752. if(DrawMode) {
  1753. // point = GetRoadMidPoint(TempList);
  1754. // DrawStr(MemDC,point,RoadName);
  1755. return;
  1756. }
  1757. else {
  1758. Dist = CalcPointsDist(TempList);
  1759. WordPos = Dist / (Len + 1) + 1;
  1760. pos = TempList->GetTailPosition();
  1761. while(pos  != NULL) {
  1762. pPoint  = (CGpsPoint*)TempList->GetPrev(pos);
  1763. ep.x = pPoint->m_lx;
  1764. ep.y = pPoint->m_ly;
  1765. if(!Flag) {
  1766. sp = ep;
  1767. Flag = 1;
  1768. continue;
  1769. }
  1770. CurrDist = CalcTwoPointDist(sp,ep);
  1771. d  += CurrDist;
  1772. if(NamePos / 2 >= Len) return;
  1773. dx = abs(sp.x - ep.x); dy = abs(sp.y - ep.y);
  1774. if(d == WordPos) {
  1775. Word.Empty();
  1776. Word += RoadName.GetAt(NamePos - 1);
  1777. Word += RoadName.GetAt(NamePos - 0);
  1778. // AfxMessageBox(Word);
  1779. MemDC->SetBkMode (TRANSPARENT);
  1780. if(dx > dy) {
  1781. MemDC->TextOut(ep.x +  0,ep.y - 15,Word);
  1782. }
  1783. else {
  1784. MemDC->TextOut(ep.x - 15,ep.y +  0,Word);
  1785. }
  1786. d = 0;
  1787. NamePos += 2;
  1788. }
  1789. else if(d > WordPos) {
  1790. point = CalcOneLinePoint(sp,ep,CurrDist - (d - WordPos),CurrDist);
  1791. Word.Empty();
  1792. Word += RoadName.GetAt(NamePos - 1);
  1793. Word += RoadName.GetAt(NamePos - 0);
  1794. // AfxMessageBox(Word);
  1795. MemDC->SetBkMode (TRANSPARENT);
  1796. if(dx > dy) {
  1797. MemDC->TextOut(point.x +  0,point.y - 15,Word);
  1798. }
  1799. else {
  1800. MemDC->TextOut(point.x - 15,point.y +  0,Word);
  1801. }
  1802. d = d - WordPos;
  1803. NamePos += 2;
  1804. }
  1805. sp = ep;
  1806. }
  1807. }
  1808. }
  1810. void CGpsDrawMap::ClearLinkList(CObList *pLinkList)
  1811. {
  1812. CGpsLinkStruct *pLink;
  1813. POSITION pos;
  1815. pos = pLinkList->GetHeadPosition();
  1816. while(pos != NULL) {
  1817. pLink  = (CGpsLinkStruct*)pLinkList->GetNext(pos);
  1818. delete pLink;
  1819. }
  1820. pLinkList->RemoveAll();
  1821. }
  1823. void CGpsDrawMap::ClearPointList(CObList *PointList)
  1824. {
  1825. CGpsPoint *pPoint;
  1826. POSITION pos;
  1828. pos = PointList->GetHeadPosition();
  1829. while(pos != NULL) {
  1830. pPoint = (CGpsPoint*)PointList->GetNext(pos);
  1831. delete pPoint;
  1832. }
  1833. PointList->RemoveAll();
  1834. }
  1836. bool CGpsDrawMap::SaveRecePoint(double gx,double gy,CDC *pDC,CString strVehicleNO)
  1837. {
  1838. if(!IsValidNE(gx,gy)) return false;
  1840. CGpsPoint *pPoint,*pTempPoint = NULL;
  1841. POSITION pos;
  1842. bool Flag = false;
  1844. pPoint = new CGpsPoint;
  1845. pPoint->m_dgx = gx; pPoint->m_dgy = gy;
  1846. pPoint->m_sVehicleNO = strVehicleNO;
  1847. CovertNEXY(pPoint, m_cCurrMapInfo.CoeffNE_XY, true);
  1849. pos = mSaveRecePointList.GetTailPosition();
  1850. while(pos != NULL) {
  1851. pTempPoint = (CGpsPoint*)mSaveRecePointList.GetPrev(pos);
  1852. if(pTempPoint->m_sVehicleNO.Compare(strVehicleNO) == 0) {
  1853. // ErasePrevPoint(pDC,pTempPoint->m_lx,pTempPoint->m_ly);
  1854. pTempPoint->m_dgx = pPoint->m_dgx;
  1855. pTempPoint->m_dgy = pPoint->m_dgy;
  1856. pTempPoint->m_lx = pPoint->m_lx;
  1857. pTempPoint->m_ly = pPoint->m_ly;
  1859. delete pPoint;
  1860. Flag = true;
  1862. break;
  1863. }
  1864. }
  1865. if(!Flag) {
  1866. mSaveRecePointList.AddHead(pPoint);
  1867. }
  1869. return true;
  1870. }
  1872. void CGpsDrawMap::ErasePrevPoint(CDC *pDC,long x,long y)
  1873. {
  1874. CRect cRect;
  1876. cRect.left  = x - GPS_CAR_WIDTH_HEIGH / 2;
  1877. cRect.right  = x + GPS_CAR_WIDTH_HEIGH / 2;
  1878. cRect.top  = y - GPS_CAR_WIDTH_HEIGH / 2;
  1879. cRect.bottom = y + GPS_CAR_WIDTH_HEIGH / 2;
  1881. RedrawInvalidRect(cRect,pDC,false);
  1882. }
  1884. void CGpsDrawMap::DrawEllipse(CDC *pDC)
  1885. {
  1886. CGpsPoint *pPoint = NULL;
  1887. CBrush cBrush(RGB(255,8,0));
  1888. CBrush *SaveBrush = pDC->SelectObject(&cBrush);
  1889. CRect cRect;
  1890. BYTE Width = m_PointWidth + 2;
  1892. if(mSaveRecePointList.GetCount() == 0) return;
  1895. #if 1
  1896. pPoint = (CGpsPoint*)mSaveRecePointList.GetHead();
  1897. if(pPoint != NULL) {
  1898. cRect.left  = pPoint->m_lx - Width;
  1899. cRect.right  = pPoint->m_lx + Width;
  1900. cRect.top  = pPoint->m_ly - Width;
  1901. cRect.bottom = pPoint->m_ly + Width;
  1902. pDC->Ellipse(&cRect);
  1903. }
  1904. #else
  1905. pos = mSaveRecePointList.GetTailPosition();
  1906. while(pos != NULL) {
  1907. pPoint = (CGpsPoint*)mSaveRecePointList.GetPrev(pos);
  1908. cRect.left  = pPoint->m_lx - Width;
  1909. cRect.right  = pPoint->m_lx + Width;
  1910. cRect.top  = pPoint->m_ly - Width;
  1911. cRect.bottom = pPoint->m_ly  + Width;
  1912. pDC->Ellipse(&cRect);
  1913. }
  1914. #endif
  1915. pDC->SelectObject(SaveBrush);
  1916. SaveBrush->DeleteObject();
  1917. }
  1919. //Get Course of the car ...
  1920. CString CGpsDrawMap::GetCarByDirection(double Course)
  1921. {
  1922. CString ret;
  1923. double TmpCourse = 0;
  1925. ret = SaveGpsCarPath[0];
  1927. for(BYTE i = 0; i < 24; i++) {
  1928. if((Course >= TmpCourse) && (Course < TmpCourse + 15)) {
  1929. ret = SaveGpsCarPath[i];
  1930. }
  1931. TmpCourse += 15;
  1932. }
  1934. return ret;
  1935. }
  1937. //Redraw invalid rectangle...
  1938. void CGpsDrawMap::RedrawInvalidRect(CRect cRect,CDC * pDC,bool Flag)
  1939. {
  1940. int i,j;
  1941. int x,y;
  1943. for(x = 0,i = cRect.left; i < cRect.right; i++,x++) {
  1944. for(y = 0,j = cRect.top; j < cRect.bottom; j++,y++) {
  1945. if((x == 40) || (y == 40)) break;
  1946. if(Flag) {
  1947. SaveInvalidRectColor[x][y]= GetPixel(*pDC,i,j);
  1948. }
  1949. else {
  1950. SetPixel(*pDC,i,j,SaveInvalidRectColor[x][y]);
  1951. }
  1952. }
  1953. }
  1954. }
  1956. //Draw Gps Car ...
  1957. void CGpsDrawMap::DrawGpsCar(CDC *pDC,double Course)
  1958. {
  1959. #if 0
  1960. CString CarName,CarPath;
  1961. CBmpProc CarMap;
  1962. CGpsPoint *pPoint = NULL;
  1963. CRect cRect;
  1964. HWND hWnd = ::GetActiveWindow();
  1965. POSITION pos;
  1967. CarPath += GetCarByDirection(Course);
  1968. CarMap.LoadFromFile(CarPath);
  1970. //refresh Prev Car...
  1971. pos = mSaveRecePointList.GetHeadPosition();
  1972. if(pos != NULL) {
  1973. mSaveRecePointList.GetNext(pos);
  1974. if(pos != NULL) {
  1975. pPoint = (CGpsPoint*)mSaveRecePointList.GetNext(pos);
  1976. if(pPoint != NULL) {
  1977. cRect.left  = pPoint->m_lx - CarMap.Width () / 2;
  1978. cRect.right  = pPoint->m_lx + CarMap.Width () / 2;
  1979. cRect.top  = pPoint->m_ly - CarMap.Height() / 2;
  1980. cRect.bottom = pPoint->m_ly + CarMap.Height() / 2;
  1981. RedrawInvalidRect(cRect,pDC,false);
  1982. }
  1983. }
  1984. }
  1986. //Draw Car...
  1987. pPoint = (CGpsPoint*)mSaveRecePointList.GetHead();
  1988. if(pPoint != NULL) {
  1989. cRect.left  = pPoint->m_lx - CarMap.Width () / 2;
  1990. cRect.right  = pPoint->m_lx + CarMap.Width () / 2;
  1991. cRect.top  = pPoint->m_ly - CarMap.Height() / 2;
  1992. cRect.bottom = pPoint->m_ly + CarMap.Height() / 2;
  1994. RedrawInvalidRect(cRect,pDC,true);
  1996. CarMap.DrawTransparentInRect(*pDC,0,&cRect,NULL,0); //装入汽车位图
  1997. CPoint point;
  1998. point.x = pPoint->m_lx;
  1999. point.y = pPoint->m_ly;
  2000. DrawStr(pDC,point,strVehicleNO);
  2001. }
  2002. CarMap.Clear();
  2003. #else
  2004. CString CarName,CarPath;
  2005. CBmpProc CarMap;
  2006. CGpsPoint *pPoint = NULL;
  2007. CRect cRect;
  2008. POSITION pos;
  2010. CarPath += GetCarByDirection(Course);
  2011. CarMap.LoadFromFile(CarPath);
  2013. //refresh Prev Car...
  2014. /* pos = mSaveRecePointList.GetHeadPosition();
  2015. if(pos != NULL) {
  2016. mSaveRecePointList.GetNext(pos);
  2017. if(pos != NULL) {
  2018. pPoint = (CGpsPoint*)mSaveRecePointList.GetNext(pos);
  2019. if(pPoint != NULL) {
  2020. ErasePrevPoint(pDC,pPoint->m_lx,pPoint->m_ly);
  2021. }
  2022. }
  2023. }
  2024. */
  2025. //Draw Car...
  2026. pos  = mSaveRecePointList.GetTailPosition();
  2027. while(pos != NULL) {
  2028. pPoint = (CGpsPoint*)mSaveRecePointList.GetPrev(pos);
  2029. if(pPoint != NULL) {
  2030. cRect.left  = pPoint->m_lx - CarMap.Width () / 2;
  2031. cRect.right  = pPoint->m_lx + CarMap.Width () / 2;
  2032. cRect.top  = pPoint->m_ly - CarMap.Height() / 2;
  2033. cRect.bottom = pPoint->m_ly + CarMap.Height() / 2;
  2035. RedrawInvalidRect(cRect,pDC,true);
  2037. CarMap.DrawTransparentInRect(*pDC,0,&cRect,NULL,0); //装入汽车位图
  2038. CPoint point;
  2039. point.x = pPoint->m_lx;
  2040. point.y = pPoint->m_ly;
  2041. if(!pPoint->m_sVehicleNO.IsEmpty()) {
  2042. DrawStr(pDC,point,pPoint->m_sVehicleNO);
  2043. }
  2044. }
  2045. }
  2046. CarMap.Clear();
  2047. #endif
  2048. }
  2050. void CGpsDrawMap::MoveScrollBar(long x,long y)
  2051. {
  2052. CGpsSCView *pView = ((CGpsSCView*)m_pCurrView);
  2053. CSize scrollsize = pView->GetTotalSize();
  2054. int hscrollpos[5],vscrollpos[4];
  2056. for(int i=0;i<5;i++)
  2057. hscrollpos[i] = scrollsize.cx/5*(i+1);// - scrollsize.cx/15;
  2058. for(i=0;i<4;i++)
  2059. vscrollpos[i]= scrollsize.cy/4*(i+1);// - scrollsize.cy/15 ;
  2061. if(x>=hscrollpos[0]&& x<=hscrollpos[1])
  2062. pView->SetScrollPos(SB_HORZ,hscrollpos[0],TRUE);
  2063. else if(x>hscrollpos[1]&& x<=hscrollpos[2])
  2064. pView->SetScrollPos(SB_HORZ,hscrollpos[1],TRUE);
  2065. else if(x>hscrollpos[2]&& x<=hscrollpos[3])
  2066. pView->SetScrollPos(SB_HORZ,hscrollpos[2],TRUE);
  2067. else if(x>hscrollpos[3]&& x<=hscrollpos[4])
  2068. pView->SetScrollPos(SB_HORZ,hscrollpos[3],TRUE);
  2069. else if(x>hscrollpos[4]&& x<=hscrollpos[5])
  2070. pView->SetScrollPos(SB_HORZ,hscrollpos[4],TRUE);
  2071. else
  2072. pView->SetScrollPos(SB_HORZ,0,TRUE);
  2074. if(y>=vscrollpos[0] && y<=vscrollpos[1])
  2075. pView->SetScrollPos(SB_VERT,vscrollpos[0]);
  2076. else if(y>vscrollpos[1] && y<=vscrollpos[2])
  2077. pView->SetScrollPos(SB_VERT,vscrollpos[1]);
  2078. else if(y>vscrollpos[2] && y<=vscrollpos[3])
  2079. pView->SetScrollPos(SB_VERT,vscrollpos[2]);
  2080. else if(y>vscrollpos[3] && y<=vscrollpos[4])
  2081. pView->SetScrollPos(SB_VERT,vscrollpos[3]);
  2082. else
  2083. pView->SetScrollPos(SB_VERT,0,TRUE);
  2084. }
  2086. /***********Draw icon***********/
  2087. void CGpsDrawMap::DrawIcon(CDC *pDC,CPoint point,CString IconName)
  2088. {
  2089. CRect cRect;
  2090. CString IconPath;
  2091. CBmpProc IconMap;
  2093. IconMap.LoadFromFile(IconName);
  2095. cRect.top  = point.y - IconMap.Height() / 2;
  2096. cRect.bottom = point.y + IconMap.Height() / 2;
  2097. cRect.left  = point.x - IconMap.Width () / 2;
  2098. cRect.right  = point.x + IconMap.Width () / 2;
  2100. IconMap.DrawTransparentInRect(*pDC,0,&cRect,NULL,0); //装入标志物图标
  2101. }
  2103. //在NE中国范围内即为有效
  2104. BYTE CGpsDrawMap::IsValidNE(double gx,double gy)
  2105. {
  2106. double MinN,MinE,MaxN,MaxE;
  2107. BYTE Invalid = 0;
  2109. MinN = 7310.0000; MinE = 6060.0080;
  2110. MaxN = 13530.0000; MaxE = 1810.0000;
  2111. if(((gx - MinN >= 0.0) && (gx - MaxN <= 0.0)) &&
  2112.    ((gy - MinE <= 0.0) && (gy - MaxE >= 0.0))) {
  2113. Invalid = 1;
  2114. }
  2116. return Invalid;
  2117. }
  2119. void CGpsDrawMap::GetView(CView *pView)
  2120. {
  2121. m_pCurrView = pView;
  2122. }
  2124. void CGpsDrawMap::FreshWnd()
  2125. {
  2126. ((CGpsSCView*)m_pCurrView)->Invalidate();
  2127. }
  2129. BYTE CGpsDrawMap::CheckMapIsChange(double gx,double gy)
  2130. {
  2131. CGpsLinkStruct cLink;
  2132. BYTE IsChange;
  2134. if(!IsValidNE(gx,gy)) return 0;
  2135. if(!GetCurrLinkLib(&mLinkList,&cLink,gx,gy)) return 0;
  2137. if(CompareTwoArr(cLink.m_LinkLibName,m_cCurrMapInfo.m_LinkFileName) != 1) {
  2138. IsChange = 1;
  2139. GetCurrMapInfo(&cLink,&m_cCurrMapInfo);
  2141. ((CGpsSCView*)m_pCurrView)->m_bMapIsDrawed = false;
  2142. ((CGpsSCView*)m_pCurrView)->Invalidate();
  2143. }
  2144. else {
  2145. IsChange = 0;
  2146. ((CGpsSCView*)m_pCurrView)->Invalidate();
  2147. }
  2149. return IsChange;
  2150. }
  2152. void CGpsDrawMap::ClearSaveInvalidRectColor()
  2153. {
  2154. BYTE i,j;
  2156. for(i = 0; i < 40; i++) {
  2157. for(j = 0; j < 40; j++) {
  2158. SaveInvalidRectColor[i][j] = 0;
  2159. }
  2160. }
  2161. }
  2163. void CGpsDrawMap::ReCalcPointXY(CObList *PointList)
  2164. {
  2165. CGpsPoint *pPoint = NULL;
  2166. POSITION pos;
  2168. pos = PointList->GetTailPosition();
  2169. while(pos != NULL) {
  2170. pPoint = (CGpsPoint*)PointList->GetPrev(pos);
  2171. CovertNEXY(pPoint, m_cCurrMapInfo.CoeffNE_XY, true);
  2172. }
  2173. }
  2175. //Draw Fat Map ...
  2176. void CGpsDrawMap::DrawFatMap(CDC *pDC)
  2177. {
  2178. CGpsLinkStruct cLink;
  2180. RefreshMapWnd();
  2182. if(!GetDataLib(m_cCurrMapInfo.m_DataFileName)) return ;
  2183. m_cCurrMapInfo.ClearSignList();
  2184. GetSignLib(m_cCurrMapInfo.m_SignFileName,&m_cCurrMapInfo.lCurrSignList);
  2186. ReDraw(pDC);
  2188. // ClearPointList(&mSaveRecePointList);
  2189. ReCalcPointXY(&mSaveRecePointList);
  2190. ClearSaveInvalidRectColor();
  2191. }
  2193. void CGpsDrawMap::DrawSignLib(CDC *pDC)
  2194. {
  2195. CGpsSignObject *pSign;
  2196. POSITION pos;
  2197. CString SignName;
  2198. CPoint point;
  2200. pos  = m_cCurrMapInfo.lCurrSignList.GetTailPosition();
  2201. while(pos != NULL) {
  2202. pSign  = (CGpsSignObject*)m_cCurrMapInfo.lCurrSignList.GetPrev(pos);
  2203. if((pSign->m_bySignType == m_ShowSign.bShowBuilding) ||
  2204.    (pSign->m_bySignType == m_ShowSign.bShowHotel)    ||
  2205.        (pSign->m_bySignType == m_ShowSign.bShowCompany)  ||
  2206.    (pSign->m_bySignType == m_ShowSign.bShowAmuse)    ||
  2207.    (pSign->m_bySignType == m_ShowSign.bShowPlaceName)||
  2208.    (pSign->m_bySignType == m_ShowSign.bShowGovern)   ||
  2209.    (pSign->m_bySignType == m_ShowSign.bShowTraffic)  ||
  2210.    (pSign->m_bySignType == m_ShowSign.bShowShopping) ||
  2211.    (pSign->m_bySignType == m_ShowSign.bShowEducation)||
  2212.    (pSign->m_bySignType == m_ShowSign.bShowHospital) ||
  2213.    (pSign->m_bySignType == m_ShowSign.bShowBureau)   ||
  2214.    (pSign->m_bySignType == m_ShowSign.bShowOil)) {
  2215. // if(!pSign->m_bDraw) continue;
  2216. SignName = pSign->m_pSignObjectName;
  2217. point.x = pSign->m_lx; point.y = pSign->m_ly;
  2218. DrawIcon(pDC,point,pSign->m_sIconName);
  2219. DrawStr(pDC,point,SignName);
  2220. }
  2221. }
  2222. }
  2225. void CGpsDrawMap::DrawOneSignPoint(CDC *pDC)
  2226. {
  2227. // if(pDispOneSign == NULL) return;
  2229. CString SignName;
  2230. CPoint point;
  2232. SignName = pDispOneSign.m_pSignObjectName;
  2233. point.x = pDispOneSign.m_lx; point.y = pDispOneSign.m_ly;
  2235. DrawIcon(pDC,point,pDispOneSign.m_sIconName);
  2236. DrawStr(pDC,point,SignName);
  2237. }
  2239. void CGpsDrawMap::ReDraw(CDC *pDC)
  2240. {
  2241. DrawColorBlock(&m_cCurrMapInfo.lCurrColorBList,pDC);
  2243. DrawRoad(&m_cCurrMapInfo.lCurrRoadList,pDC);
  2245. DrawRoadName(&m_cCurrMapInfo.lCurrRoadList,pDC);
  2246. }
  2249. void CGpsDrawMap::SwapTwoVar(long &a, long &b)
  2250. {
  2251. long SwapVar;
  2253. SwapVar = a;
  2254. a = b;
  2255. b = SwapVar;
  2256. }
  2258. BYTE CGpsDrawMap::PointOnLineNE(long SY, long SX, long EY, long EX, long NY, long NX, long K)
  2259. {
  2260.     long W, H;
  2261.     long MaxN, MaxE, MinN, MinE;
  2263.     W = abs(SX - EX);
  2264.     H = abs(SY - EY);
  2266.     if (H > W) {
  2267. /* Y-majored */
  2268. MaxN = Max(SY, EY);
  2269. MinN = Min(SY, EY);
  2270. MaxE = Max(SX, EX) + K;
  2271. MinE = Min(SX, EX) - K;
  2272.     }
  2273.     else {
  2274. /* X-majored */
  2275. MaxN = Max(SY, EY) + K;
  2276. MinN = Min(SY, EY) - K;
  2277. MaxE = Max(SX, EX);
  2278. MinE = Min(SX, EX);
  2279.     }
  2281.     return (NX > MinE && NX < MaxE && NY > MinN && NY < MaxN);
  2282. }
  2284. long CGpsDrawMap::DistanceToLine(long SY, long SX, long EY, long EX, long NY, long NX)
  2285. {
  2286.     long W, H, Ha, dY, f;
  2288.     /*
  2289.      ** always draws from small X to large X
  2290.      */
  2293.     if (SX > EX) {
  2294. SwapTwoVar(SX, EX);
  2295. SwapTwoVar(SY, EY);
  2296.     }
  2298.     /*
  2299.      ** we might want to clip the line here
  2300.      */
  2301.     W = (EX - SX);
  2302.     H = (EY - SY);
  2303.     Ha = (H < 0) ? -H : H;
  2304.     dY = (H < 0) ? -1 : 1;
  2306.     if (Ha > W) {
  2307. if (NY > Max(SY, EY) || NY < Min(SY, EY)) return GPS_INFINITE;
  2308.     }
  2309.     else {
  2310. if (NX > Max(SX, EX) || NX < Min(SX, EX)) return GPS_INFINITE;
  2311.     }
  2313.     if (Ha > W) {
  2314. /* Y-majored */
  2315. f = 0;
  2316. while (1) {
  2317. if (SY == NY) {
  2318. return ((long)abs(SX - NX));
  2319. }
  2320. if (SY == EY)
  2321. break;
  2322. if ((f += W) >= Ha) {
  2323. f -= Ha;
  2324. SX++;
  2325. }
  2326. SY += dY;
  2327. }
  2328.     }
  2329. else {
  2330. /* X-majored */
  2331. f = 0;
  2332. while (1) {
  2333. if (SX == NX) {
  2334. return ((long)abs(SY - NY));
  2335. }
  2336. if (SX == EX)
  2337. break;
  2338. if ((f += Ha) >= W) {
  2339. f -= W;
  2340. SY += dY;
  2341. }
  2342. SX++;
  2343. }
  2344.     }
  2346.     return GPS_INFINITE;
  2347. }
  2349. long CGpsDrawMap::CalcPointToOneRoadDist(CPoint point,CSmallRoadStruct *pSmall)
  2350. {
  2351. CRoadPoint *pRoadPoint;
  2352. CPoint sp,ep;
  2353. POSITION pos;
  2354. long d,Dist = GPS_INFINITE;
  2355. bool Flag = false;
  2357. pos = pSmall->RoadPointList.GetTailPosition();
  2358. while(pos != NULL) {
  2359. pRoadPoint = (CRoadPoint*)pSmall->RoadPointList.GetPrev(pos);
  2360. ep.x = pRoadPoint->m_lx; ep.y = pRoadPoint->m_ly;
  2361. if(!Flag) {
  2362. Flag = true;
  2363. sp = ep;
  2364. continue;
  2365. }
  2366. if(!PointOnLineNE(sp.y,sp.x,ep.y,ep.x,point.y,point.x,100)) continue;
  2367. d = DistanceToLine(sp.y,sp.x,ep.y,ep.x,point.y,point.x);
  2368. if(d < Dist) {
  2369. Dist = d;
  2370. }
  2371. sp = ep;
  2372. }
  2374. return Dist;
  2375. }
  2377. CString CGpsDrawMap::SearchRoad(const CPoint point,CString &RoadSn)
  2378. {
  2379. CSmallRoadStruct *pSmall;
  2380. CGpsRoadStruct *pRoad;
  2381. POSITION pos,pos1;
  2382. CString RoadName(""),Name;
  2383. long d,Dist = GPS_INFINITE;
  2385. pos = m_cCurrMapInfo.lCurrRoadList.GetTailPosition();
  2386. while(pos != NULL) {
  2387. pRoad  = (CGpsRoadStruct*)m_cCurrMapInfo.lCurrRoadList.GetPrev(pos);
  2388. pos1   = pRoad->SmallRoadList.GetTailPosition();
  2389. while(pos1 != NULL) {
  2390. pSmall = (CSmallRoadStruct*)pRoad->SmallRoadList.GetPrev(pos1);
  2391. Name = pSmall->RoadName;
  2392. if(Name.IsEmpty()) continue;
  2393. d = CalcPointToOneRoadDist(point,pSmall);
  2394. if(d < Dist) {
  2395. Dist = d;
  2396. RoadName = Name;
  2397. }
  2398. }
  2399. }
  2401. return RoadName;
  2402. }
  2404. CString CGpsDrawMap::GetMapInfoByNE(double gx,double gy,BYTE SignType,BYTE InfoType)
  2405. {
  2406. CString RelatedInfo("没有找到相关信息!");
  2408. if(InfoType == 2) {
  2409. return RelatedInfo;
  2410. }
  2412. if(!IsValidNE(gx,gy)) return RelatedInfo;
  2414. CGpsSignObject *pSign = NULL,*pMin = NULL;
  2415. POSITION pos;
  2416. CGpsPoint cPoint;
  2417. CPoint p1,p2;
  2418. CString SignName,RoadName,RoadSn;
  2419. long Dist = GPS_INFINITE,d;
  2420. bool Flag;
  2422. cPoint.m_dgx = gx;
  2423. cPoint.m_dgy = gy;
  2424. CovertNEXY(&cPoint, m_cCurrMapInfo.CoeffNE_XY, true);
  2425. p1.x = cPoint.m_lx; p1.y = cPoint.m_ly;
  2427. Flag = false;
  2428. pos  = m_cCurrMapInfo.lCurrSignList.GetTailPosition();
  2429. while(pos != NULL) {
  2430. pSign  = (CGpsSignObject*)m_cCurrMapInfo.lCurrSignList.GetPrev(pos);
  2431. if((pSign->m_bySignType != SignType) && (SignType != 0)) continue;
  2432. if((abs(pSign->m_lx - cPoint.m_lx) < 100) && 
  2433.    (abs(pSign->m_ly - cPoint.m_ly) < 100)) {
  2434. p2.x = pSign->m_lx; p2.y = pSign->m_ly;
  2435. d = CalcTwoPointDist(p1,p2);
  2436. if(d < Dist) {
  2437. Dist = d;
  2438. SignName = pSign->m_pSignObjectName;
  2439. Flag = true;
  2440. pMin = pSign;
  2441. }
  2442. }
  2443. }
  2444. if(Flag) pMin->m_bDraw = true;
  2446. RoadName = SearchRoad(p1,RoadSn);
  2448. if(Flag && (!RoadName.IsEmpty())) {
  2449. RelatedInfo.Format("您现在在%s,%s附近!",RoadName,SignName);
  2450. }
  2451. else if(Flag) {
  2452. RelatedInfo.Format("您现在在%s附近!",SignName);
  2453. }
  2454. else if(!RoadName.IsEmpty()) {
  2455. RelatedInfo.Format("您现在在%s!",RoadName);
  2456. }
  2458. return RelatedInfo;
  2459. }
  2461. #if 0
  2462. //void zoom in
  2463. void CGpsDrawMap::ZoomDown()
  2464. {
  2465. if(m_byZoomCoeffic == 1) return;
  2467. m_cCurrMapInfo.m_lWnd_Max_X = m_cCurrMapInfo.m_lWnd_Max_X / m_byZoomCoeffic;
  2468. m_cCurrMapInfo.m_lWnd_Max_Y = m_cCurrMapInfo.m_lWnd_Max_Y / m_byZoomCoeffic;
  2470. m_byZoomCoeffic = m_byZoomCoeffic / 2;
  2471. if(m_byZoomCoeffic < 1) m_byZoomCoeffic = 1;
  2473. m_cCurrMapInfo.m_lWnd_Max_X = m_cCurrMapInfo.m_lWnd_Max_X * m_byZoomCoeffic;
  2474. m_cCurrMapInfo.m_lWnd_Max_Y = m_cCurrMapInfo.m_lWnd_Max_Y * m_byZoomCoeffic;
  2476. ((CGpsSCView*)m_pCurrView)->SetScrollSizes(MM_TEXT, CSize(m_cCurrMapInfo.m_lWnd_Max_X, m_cCurrMapInfo.m_lWnd_Max_Y));
  2478. RefreshMapWnd();
  2480. CalcAllPointXY();
  2482. ((CGpsSCView*)m_pCurrView)->m_bMapIsDrawed = false;
  2483. ((CGpsSCView*)m_pCurrView)->Invalidate();
  2484. }
  2486. //zoon out
  2487. void CGpsDrawMap::ZoomUp()
  2488. {
  2489. if(m_byZoomCoeffic == 8) return;
  2491. m_cCurrMapInfo.m_lWnd_Max_X = m_cCurrMapInfo.m_lWnd_Max_X / m_byZoomCoeffic;
  2492. m_cCurrMapInfo.m_lWnd_Max_Y = m_cCurrMapInfo.m_lWnd_Max_Y / m_byZoomCoeffic;
  2494. m_byZoomCoeffic *= 2;
  2495. if(m_byZoomCoeffic > 8) m_byZoomCoeffic = 8;
  2497. m_cCurrMapInfo.m_lWnd_Max_X = m_cCurrMapInfo.m_lWnd_Max_X * m_byZoomCoeffic;
  2498. m_cCurrMapInfo.m_lWnd_Max_Y = m_cCurrMapInfo.m_lWnd_Max_Y * m_byZoomCoeffic;
  2500. ((CGpsSCView*)m_pCurrView)->SetScrollSizes(MM_TEXT, CSize(m_cCurrMapInfo.m_lWnd_Max_X, m_cCurrMapInfo.m_lWnd_Max_Y));
  2502. RefreshMapWnd();
  2504. CalcAllPointXY();
  2506. ((CGpsSCView*)m_pCurrView)->m_bMapIsDrawed = false;
  2507. ((CGpsSCView*)m_pCurrView)->Invalidate();
  2508. }
  2509. #else
  2510. void CGpsDrawMap::DispOtherLevelMap()
  2511. {
  2512. if(mSaveRecePointList.GetCount() == 0) return;
  2515. ClearLinkList(&mLinkList);
  2516. GetLinkList(&mLinkList,gCurrMapLevel);
  2517. CGpsPoint *pPoint = NULL;
  2520. pPoint = (CGpsPoint*)mSaveRecePointList.GetHead();
  2521. CheckMapIsChange(pPoint->m_dgx,pPoint->m_dgy);
  2523. CGpsLinkStruct cLink;
  2525. RefreshMapWnd();
  2527. if(!GetDataLib(m_cCurrMapInfo.m_DataFileName)) return ;
  2528. }
  2530. //void zoom in
  2531. void CGpsDrawMap::ZoomDown()
  2532. {
  2533. BYTE SaveCoeff = m_byZoomCoeffic;
  2535. if(m_byZoomCoeffic == 1) {
  2536. if(gCurrMapLevel > 1) {
  2537. gCurrMapLevel--;
  2538. m_byZoomCoeffic = 2;
  2540. DispOtherLevelMap();
  2541. }
  2542. }
  2543. else {
  2544. // m_cCurrMapInfo.m_lWnd_Max_X = m_cCurrMapInfo.m_lWnd_Max_X / m_byZoomCoeffic;
  2545. // m_cCurrMapInfo.m_lWnd_Max_Y = m_cCurrMapInfo.m_lWnd_Max_Y / m_byZoomCoeffic;
  2547. m_byZoomCoeffic = m_byZoomCoeffic / 2;
  2548. if(m_byZoomCoeffic < 1) m_byZoomCoeffic = 1;
  2549. }
  2551. m_cCurrMapInfo.m_lWnd_Max_X = m_cCurrMapInfo.m_lWnd_Max_X / SaveCoeff;
  2552. m_cCurrMapInfo.m_lWnd_Max_Y = m_cCurrMapInfo.m_lWnd_Max_Y / SaveCoeff;
  2554. m_cCurrMapInfo.m_lWnd_Max_X = m_cCurrMapInfo.m_lWnd_Max_X * m_byZoomCoeffic;
  2555. m_cCurrMapInfo.m_lWnd_Max_Y = m_cCurrMapInfo.m_lWnd_Max_Y * m_byZoomCoeffic;
  2557. ((CGpsSCView*)m_pCurrView)->SetScrollSizes(MM_TEXT, CSize(m_cCurrMapInfo.m_lWnd_Max_X, m_cCurrMapInfo.m_lWnd_Max_Y));
  2559. RefreshMapWnd();
  2561. CalcAllPointXY();
  2563. ((CGpsSCView*)m_pCurrView)->m_bMapIsDrawed = false;
  2564. ((CGpsSCView*)m_pCurrView)->Invalidate();
  2565. }
  2567. //zoon out
  2568. void CGpsDrawMap::ZoomUp()
  2569. {
  2570. BYTE SaveCoeff = m_byZoomCoeffic;
  2572. if((m_byZoomCoeffic == 2) && (gCurrMapLevel < 6)) {
  2573. if(gCurrMapLevel < 6) {
  2574. gCurrMapLevel++;
  2576. m_byZoomCoeffic = 1;
  2578. DispOtherLevelMap();
  2579. }
  2580. }
  2581. else {
  2582. // m_cCurrMapInfo.m_lWnd_Max_X = m_cCurrMapInfo.m_lWnd_Max_X / m_byZoomCoeffic;
  2583. // m_cCurrMapInfo.m_lWnd_Max_Y = m_cCurrMapInfo.m_lWnd_Max_Y / m_byZoomCoeffic;
  2585. m_byZoomCoeffic *= 2;
  2586. if(m_byZoomCoeffic > 2) m_byZoomCoeffic = 2;
  2587. }
  2589. m_cCurrMapInfo.m_lWnd_Max_X = m_cCurrMapInfo.m_lWnd_Max_X / SaveCoeff;
  2590. m_cCurrMapInfo.m_lWnd_Max_Y = m_cCurrMapInfo.m_lWnd_Max_Y / SaveCoeff;
  2592. m_cCurrMapInfo.m_lWnd_Max_X = m_cCurrMapInfo.m_lWnd_Max_X * m_byZoomCoeffic;
  2593. m_cCurrMapInfo.m_lWnd_Max_Y = m_cCurrMapInfo.m_lWnd_Max_Y * m_byZoomCoeffic;
  2595. ((CGpsSCView*)m_pCurrView)->SetScrollSizes(MM_TEXT, CSize(m_cCurrMapInfo.m_lWnd_Max_X, m_cCurrMapInfo.m_lWnd_Max_Y));
  2597. RefreshMapWnd();
  2599. CalcAllPointXY();
  2601. ((CGpsSCView*)m_pCurrView)->m_bMapIsDrawed = false;
  2602. ((CGpsSCView*)m_pCurrView)->Invalidate();
  2603. }
  2604. #endif
  2606. void CGpsDrawMap::ReCalcRoadXY(CObList *RoadList)
  2607. {
  2608. CGpsRoadStruct *pRoad;
  2609. CSmallRoadStruct *pSmall;
  2610. POSITION pos,pos1;
  2612. pos = RoadList->GetTailPosition();
  2613. while(pos != NULL) {
  2614. pRoad = (CGpsRoadStruct*)RoadList->GetPrev(pos);
  2615. pos1 = pRoad->SmallRoadList.GetTailPosition();
  2616. while(pos1 != NULL) {
  2617. pSmall = (CSmallRoadStruct*)pRoad->SmallRoadList.GetPrev(pos1);
  2618. ReCalcPointXY(&pSmall->RoadPointList);
  2619. }
  2620. }
  2621. }
  2623. void CGpsDrawMap::ReCalcColorBXY(CObList *ColorBList)
  2624. {
  2625. CGpsColorBlock *pBlock;
  2626. POSITION pos;
  2628. pos = ColorBList->GetTailPosition();
  2629. while(pos != NULL) {
  2630. pBlock = (CGpsColorBlock*)ColorBList->GetPrev(pos);
  2631. ReCalcPointXY(&pBlock->ColorBlockPointList);
  2632. }
  2633. }
  2635. void CGpsDrawMap::CalcAllPointXY()
  2636. {
  2637. ReCalcRoadXY(&m_cCurrMapInfo.lCurrRoadList);
  2638. ReCalcColorBXY(&m_cCurrMapInfo.lCurrColorBList);
  2639. ReCalcPointXY(&m_cCurrMapInfo.lCurrSignList);
  2640. ReCalcPointXY(&m_cCurrMapInfo.lCurrCrossList);
  2641. ReCalcPointXY(&mSaveRecePointList);
  2643. CovertNEXY(&pDispOneSign, m_cCurrMapInfo.CoeffNE_XY, true);
  2644. }
  2646. bool CGpsDrawMap::GetOneRoadPlain(CGpsRoadCrossPoint *pCross1,
  2647.  CGpsRoadCrossPoint *pCross2,
  2648.  CObList *RoadList,CString RoadSn,CObList *DstList)
  2649. {
  2650. CSmallRoadStruct *pSmall;
  2651. CGpsRoadStruct *pRoad;
  2652. CRoadPoint *pRoadPoint,*pPoint;
  2653. POSITION pos,pos1,pos2;
  2654. CString TempSn;
  2655. char Flag_SD;
  2656. short C1Pos = -1,C2Pos = -1,Pos;
  2657. bool Flag = false;
  2658. // AfxMessageBox(RoadSn);
  2659. pos = RoadList->GetTailPosition();
  2660. while(pos != NULL) {
  2661. pRoad  = (CGpsRoadStruct*)RoadList->GetPrev(pos);
  2662. TempSn.Format("%c%d",pRoad->BigRoad_Serial,pRoad->m_BigRoad_Number);
  2663. if(TempSn != RoadSn) continue;
  2664. // AfxMessageBox(RoadSn);
  2665. // if(RoadSn != "S87") continue;
  2666. Flag = true;
  2667. Pos  = 1;
  2668. pos1 = pRoad->SmallRoadList.GetTailPosition();
  2669. while(pos1 != NULL) {
  2670. pSmall  = (CSmallRoadStruct*)pRoad->SmallRoadList.GetPrev(pos1);
  2671. Flag_SD = (char)pSmall->Road_SD;
  2672. pos2 = pSmall->RoadPointList.GetTailPosition();
  2673. while(pos2 != NULL) {
  2674. pRoadPoint = (CRoadPoint*)pSmall->RoadPointList.GetPrev(pos2);
  2675. CString str;
  2676. str.Format("%d,%d;%d,%d",pRoadPoint->m_lx,pRoadPoint->m_ly,pCross1->m_lx,pCross1->m_ly);
  2677. // AfxMessageBox(str);
  2678. if((pRoadPoint->m_lx == pCross1->m_lx) && 
  2679.    (pRoadPoint->m_ly == pCross1->m_ly)) {
  2680. C1Pos = Pos;
  2681. // AfxMessageBox("a");
  2682. }
  2683. if((pRoadPoint->m_lx == pCross2->m_lx) &&
  2684.    (pRoadPoint->m_ly == pCross2->m_ly)) {
  2685. C2Pos = Pos;
  2686. // AfxMessageBox("b");
  2687. }
  2688. Pos++;
  2689. }
  2690. }
  2691. if(Flag) break;
  2692. }
  2693. if(!Flag) return false;
  2694. // AfxMessageBox("1");
  2695. if((C1Pos == -1) || (C2Pos == -1)) return false;
  2696. // AfxMessageBox("2");
  2697. bool IsSingle = false;
  2698. if(Flag_SD == 'S') {
  2699. if(C1Pos > C2Pos) return false;
  2700. // if(C1Pos > C2Pos) IsSingle = true;
  2701. }
  2702. // AfxMessageBox("3");
  2703. if(C1Pos > C2Pos) {
  2704. short Temp;
  2705. Temp  = C1Pos;
  2706. C1Pos = C2Pos;
  2707. C2Pos = Temp;
  2708. }
  2710. Pos  = 1;
  2711. pos1 = pRoad->SmallRoadList.GetTailPosition();
  2712. while(pos1 != NULL) {
  2713. pSmall  = (CSmallRoadStruct*)pRoad->SmallRoadList.GetPrev(pos1);
  2714. pos2 = pSmall->RoadPointList.GetTailPosition();
  2715. while(pos2 != NULL) {
  2716. pRoadPoint = (CRoadPoint*)pSmall->RoadPointList.GetPrev(pos2);
  2717. if((Pos >= C1Pos) && (Pos <= C2Pos)) {
  2718. pPoint  = new CRoadPoint;
  2719. *pPoint = *pRoadPoint;
  2720. DstList->AddHead(pPoint);
  2721. }
  2722. Pos++;
  2723. }
  2724. }
  2725. CString str;
  2726. str.Format("Count = %d",DstList->GetCount());
  2727. // AfxMessageBox(str);
  2729. return true;
  2730. }
  2732. bool CGpsDrawMap::IsInvalidSn(CString RoadSn)
  2733. {
  2734. if(RoadSn == "x255") return true;
  2736. return false;
  2737. }
  2739. bool CGpsDrawMap::SimilarCross(CGpsRoadCrossPoint *C1,CGpsRoadCrossPoint *C2)
  2740. {
  2741. CString arrRoadSn[4];
  2742. BYTE i;
  2744. if((C1->m_lx != C2->m_lx) || (C1->m_ly != C2->m_ly)) return false;
  2746. arrRoadSn[0].Format("%c%d",C1->m_CrossRoad1_Serial,C1->m_CrossRoad1_Number);
  2747. arrRoadSn[1].Format("%c%d",C1->m_CrossRoad2_Serial,C1->m_CrossRoad2_Number);
  2748. arrRoadSn[2].Format("%c%d",C1->m_CrossRoad3_Serial,C1->m_CrossRoad3_Number);
  2749. arrRoadSn[3].Format("%c%d",C1->m_CrossRoad4_Serial,C1->m_CrossRoad4_Number);
  2751. for(i = 0; i < 4; i++) {
  2752. if(IsInvalidSn(arrRoadSn[i])) continue;
  2753. if(!RoadSnInCross(arrRoadSn[i],C2)) return false;
  2754. }
  2755. arrRoadSn[0].Format("%c%d",C2->m_CrossRoad1_Serial,C2->m_CrossRoad1_Number);
  2756. arrRoadSn[1].Format("%c%d",C2->m_CrossRoad2_Serial,C2->m_CrossRoad2_Number);
  2757. arrRoadSn[2].Format("%c%d",C2->m_CrossRoad3_Serial,C2->m_CrossRoad3_Number);
  2758. arrRoadSn[3].Format("%c%d",C2->m_CrossRoad4_Serial,C2->m_CrossRoad4_Number);
  2760. for(i = 0; i < 4; i++) {
  2761. if(IsInvalidSn(arrRoadSn[i])) continue;
  2762. if(!RoadSnInCross(arrRoadSn[i],C1)) return false;
  2763. }
  2765. return true;
  2766. }
  2768. bool CGpsDrawMap::GetOneRoadPoint(CObList *RoadList,CString RoadSn,CGpsRoadStruct *DstRoad)
  2769. {
  2770. CGpsRoadStruct *pRoad;
  2771. POSITION pos;
  2772. CString TempSn;
  2774. pos = RoadList->GetTailPosition();
  2775. while(pos != NULL) {
  2776. pRoad  = (CGpsRoadStruct*)RoadList->GetPrev(pos);
  2777. TempSn.Format("%c%d",pRoad->BigRoad_Serial,pRoad->m_BigRoad_Number);
  2778. if(TempSn != RoadSn) continue;
  2779. *DstRoad   = *pRoad;
  2780. return true;
  2781. }
  2783. return false;
  2784. }
  2786. bool CGpsDrawMap::RoadSnInCross(CString RoadSn,CGpsRoadCrossPoint *pCross)
  2787. {
  2788. CString TempSn;
  2790. TempSn.Format("%c%d",pCross->m_CrossRoad1_Serial,pCross->m_CrossRoad1_Number);
  2791. if(TempSn == RoadSn) return true;
  2793. TempSn.Format("%c%d",pCross->m_CrossRoad2_Serial,pCross->m_CrossRoad2_Number);
  2794. if(TempSn == RoadSn) return true;
  2796. TempSn.Format("%c%d",pCross->m_CrossRoad3_Serial,pCross->m_CrossRoad3_Number);
  2797. if(TempSn == RoadSn) return true;
  2799. TempSn.Format("%c%d",pCross->m_CrossRoad4_Serial,pCross->m_CrossRoad4_Number);
  2800. if(TempSn == RoadSn) return true;
  2802. return false;
  2803. }
  2805. bool CGpsDrawMap::GetPointInListEx(CPoint point,CString RoadSn,CObList *CrossList,CGpsRoadCrossPoint *pPoint,BYTE Bound)
  2806. {
  2807. CGpsRoadCrossPoint *pGpsPoint;
  2808. bool ret = false;
  2809. POSITION pos;
  2810. CString TempSn;
  2812. pos = CrossList->GetHeadPosition();
  2814. while(pos != NULL)
  2815. {
  2816. pGpsPoint = (CGpsRoadCrossPoint*)CrossList->GetNext(pos);
  2817. TempSn.Format("%c%d",pGpsPoint->m_CrossRoad1_Serial,pGpsPoint->m_CrossRoad1_Number);
  2818. if(TempSn != RoadSn) continue;
  2819. if((abs(point.x - pGpsPoint->m_lx) < Bound) && 
  2820.    (abs(point.y - pGpsPoint->m_ly) < Bound)) { //捕获范围
  2821. *pPoint = *pGpsPoint; 
  2822. ret = true;
  2823. break;
  2824. }
  2825. }
  2827. return ret;
  2828. }
  2830. bool CGpsDrawMap::GetOneBRCrossPoint(CPoint point,CObList *RoadList,CObList *CrossList,
  2831.  CString Sn,CBRCrossStruct *pDstCross,CObList *SavePoint)
  2832. {
  2833. CGpsRoadStruct *pRoad;
  2834. CSmallRoadStruct *pSmall;
  2835. CRoadPoint *pRoadPoint;
  2836. CRoadPoint *pTempPoint;
  2837. POSITION pos,pos1,pos2;
  2838. CString RoadSn;
  2839. CPoint Epoint;
  2840. bool Result = false,Flag = false;
  2842. pos = RoadList->GetTailPosition();
  2843. while(pos != NULL) {
  2844. pRoad  = (CGpsRoadStruct*)RoadList->GetPrev(pos);
  2845. RoadSn.Format("%c%d",pRoad->BigRoad_Serial,pRoad->m_BigRoad_Number);
  2846. // if(RoadSn != Sn) continue;
  2847. pos1   = pRoad->SmallRoadList.GetTailPosition();
  2848. while(pos1 != NULL) {
  2849. pSmall = (CSmallRoadStruct*)pRoad->SmallRoadList.GetPrev(pos1);
  2850. pos2 = pSmall->RoadPointList.GetTailPosition();
  2851. while(pos2 != NULL) {
  2852. pRoadPoint = (CRoadPoint*)pSmall->RoadPointList.GetPrev(pos2);
  2853. if((abs(pRoadPoint->m_lx - point.x) < m_PointWidth * 10) && 
  2854.    (abs(pRoadPoint->m_ly - point.y) < m_PointWidth * 10)) {
  2855. Flag = true;
  2856. }
  2857. if(!Flag) continue;
  2858. pTempPoint = new CRoadPoint;
  2859. pTempPoint->m_lx = pRoadPoint->m_lx;
  2860. pTempPoint->m_ly = pRoadPoint->m_ly;
  2861. SavePoint->AddHead(pTempPoint);
  2863. if((pRoadPoint->OutOfMap == 3) || 
  2864.    (pRoadPoint->OutOfMap == 6) ||
  2865.    (pRoadPoint->OutOfMap == 8)) {
  2866. Epoint.x = pRoadPoint->m_lx; Epoint.y = pRoadPoint->m_ly;
  2868. Result = GetPointInListEx(Epoint,RoadSn,CrossList,&pDstCross->m_cCross,1);
  2869. if(Result) return true;
  2870. }
  2871. }
  2872. }
  2873. if(Flag) break;
  2874. }
  2876. return Result;
  2877. }
  2879. long CGpsDrawMap::CalcCrossVectorDist(CGpsRoadCrossPoint *StartPoint,CGpsRoadCrossPoint *EndPoint,
  2880.  CObList *RoadList)
  2881. {
  2882. CString arrRoadSn[4];
  2883. long Dist;
  2884. BYTE i;
  2886. arrRoadSn[0].Format("%c%d",StartPoint->m_CrossRoad1_Serial,StartPoint->m_CrossRoad1_Number);
  2887. arrRoadSn[1].Format("%c%d",StartPoint->m_CrossRoad2_Serial,StartPoint->m_CrossRoad2_Number);
  2888. arrRoadSn[2].Format("%c%d",StartPoint->m_CrossRoad3_Serial,StartPoint->m_CrossRoad3_Number);
  2889. arrRoadSn[3].Format("%c%d",StartPoint->m_CrossRoad4_Serial,StartPoint->m_CrossRoad4_Number);
  2890. for(i = 0; i < 4; i++) {
  2891. if(IsInvalidSn(arrRoadSn[i])) continue;
  2892. Dist = CalcCrossDistInRoadSn(StartPoint,EndPoint,RoadList,arrRoadSn[i]);
  2893. if(Dist != GPS_INFINITE) return Dist;
  2894. }
  2896. return GPS_INFINITE;
  2897. }
  2899. long CGpsDrawMap::CalcCrossDistInRoadSn(CGpsRoadCrossPoint *StartPoint,CGpsRoadCrossPoint *EndPoint,
  2900.    CObList *RoadList,CString RoadSn)
  2901. {
  2902. BYTE RoadDir,i;
  2903. long Dist;
  2905. if(!RoadSnInCross(RoadSn,StartPoint) || !RoadSnInCross(RoadSn,EndPoint)) return GPS_INFINITE;
  2907. if(SimilarCross(StartPoint,EndPoint)) return GPS_INFINITE;
  2909. if((StartPoint->m_lx == EndPoint->m_lx) && 
  2910.    (StartPoint->m_ly == EndPoint->m_ly)) {
  2911. return 0;
  2912. }
  2914. CGpsRoadStruct DstRoad;
  2915. CSmallRoadStruct *pSmall;
  2916. CRoadPoint *pRoadPoint,*pPoint;
  2917. CObList TempPointList;
  2918. POSITION pos1,pos2;
  2919. short StartPos = -1,EndPos = -1,Pos = 1;
  2921. if(!GetOneRoadPoint(RoadList,RoadSn,&DstRoad)) return GPS_INFINITE;
  2923. i  = 0;
  2924. pos1 = DstRoad.SmallRoadList.GetTailPosition();
  2925. while(pos1 != NULL) {
  2926. pSmall  = (CSmallRoadStruct*)DstRoad.SmallRoadList.GetPrev(pos1);
  2927. pos2 = pSmall->RoadPointList.GetTailPosition();
  2928. RoadDir = pSmall->Road_SD;
  2929. while(pos2 != NULL) {
  2930. pRoadPoint = (CRoadPoint*)DstRoad.SmallRoadList.GetPrev(pos2);
  2931. if((pRoadPoint->OutOfMap != 3) && 
  2932.    (pRoadPoint->OutOfMap != 6) &&
  2933.    (pRoadPoint->OutOfMap != 8)) continue;
  2935. if((pRoadPoint->m_lx == StartPoint->m_lx) && (pRoadPoint->m_ly == StartPoint->m_ly)) {
  2936. if(StartPos == -1) {
  2937. pRoadPoint->m_bIsModify = true;
  2938. StartPos = Pos;
  2939. }
  2940. }
  2941. if((pRoadPoint->m_lx == EndPoint->m_lx) && (pRoadPoint->m_ly == EndPoint->m_ly)) {
  2942. if(EndPos == -1) {
  2943. pRoadPoint->m_bIsModify = true;
  2944. EndPos = Pos;
  2945. }
  2946. }
  2947. Pos++;
  2948. }
  2949. }
  2950. if((StartPos == -1) || (EndPos == -1)) return GPS_INFINITE;
  2952. if(RoadDir == 'S') {
  2953. if(StartPos > EndPos) return GPS_INFINITE;
  2954. }
  2956. i  = 0;
  2957. pos1 = DstRoad.SmallRoadList.GetTailPosition();
  2958. while(pos1 != NULL) {
  2959. pSmall  = (CSmallRoadStruct*)DstRoad.SmallRoadList.GetPrev(pos1);
  2960. pos2 = pSmall->RoadPointList.GetTailPosition();
  2961. while(pos2 != NULL) {
  2962. pRoadPoint = (CRoadPoint*)DstRoad.SmallRoadList.GetPrev(pos2);
  2963. if(pRoadPoint->m_bIsModify) i++;
  2964. if(i == 1) {
  2965. pPoint  = new CRoadPoint;
  2966. *pPoint = *pRoadPoint;
  2967. TempPointList.AddHead(pPoint);
  2968. }
  2969. if(i >= 2) break;
  2970. }
  2971. if(i >= 2) break;
  2972. }
  2973. Dist = CalculateOneRoadVD(&TempPointList);
  2974. m_cCurrMapInfo.ClearPointList(&TempPointList);
  2976. return Dist;
  2977. }
  2979. long CGpsDrawMap::CalculateTwoPointDistance(CPoint PrevP,CPoint CurrP)
  2980. {
  2981. long dx,dy,Distance;
  2983. dx = abs(PrevP.x - CurrP.x);
  2984. dy = abs(PrevP.y - CurrP.y);
  2986. Distance = (long)sqrt(Square(dx) + Square(dy));
  2988. return Distance;
  2989. }
  2991. long CGpsDrawMap::CalculateOneRoadVD(CObList *PlainList)
  2992. {
  2993. CRoadPoint *pRoadPoint;
  2994. POSITION pos;
  2995. CPoint PrevP,CurrP;
  2996. long Distance = 0;
  2997. bool Flag = false;
  2999. pos = PlainList->GetTailPosition();
  3000. while(pos != NULL) {
  3001. pRoadPoint = (CRoadPoint*)PlainList->GetPrev(pos);
  3002. CurrP.x = pRoadPoint->m_lx; CurrP.y = pRoadPoint->m_ly;
  3003. if(Flag) {
  3004. Distance += CalculateTwoPointDistance(PrevP,CurrP);
  3005. // Distance += CalculateDist(PrevP,CurrP);
  3006. }
  3007. else {
  3008. Flag = true;
  3009. }
  3010. PrevP = CurrP;
  3011. }
  3012. if(!Flag) Distance = GPS_INFINITE;
  3013. if(PlainList->GetCount() == 1) Distance = GPS_INFINITE;
  3015. return Distance;
  3016. }
  3018. bool CGpsDrawMap::SaveInitBRCross(CObList *CrossList,CObList *DstList)
  3019. {
  3020. CGpsRoadCrossPoint *pCross;
  3021. CBRCrossStruct *pBRCross,*pSave;
  3022. POSITION pos,pos1;
  3023. bool Flag;
  3025. pos = CrossList->GetTailPosition();
  3026. while(pos != NULL) {
  3027. pCross = (CGpsRoadCrossPoint*)CrossList->GetPrev(pos);
  3028. pos1   = DstList->GetTailPosition();
  3029. if(pos1  == NULL) {
  3030. pSave = new CBRCrossStruct;
  3031. pSave->m_cCross = *pCross;
  3032. // pSave->m_Adjust = 2;
  3033. // pSave->m_Distance = GPS_INFINITE;
  3034. // pSave->m_Double = 0;
  3035. DstList->AddHead(pSave);
  3036. continue;
  3037. }
  3038. Flag = false;
  3039. while(pos1  != NULL) {
  3040. pBRCross = (CBRCrossStruct*)DstList->GetPrev(pos1);
  3041. if(SimilarCross(&pBRCross->m_cCross,pCross)) {
  3042. pBRCross->m_Double = 1;
  3043. break;
  3044. Flag = true;
  3045. }
  3046. }
  3047. if(!Flag) {
  3048. pSave = new CBRCrossStruct;
  3049. pSave->m_cCross = *pCross;
  3050. // pSave->m_Adjust = 2;
  3051. // pSave->m_Distance = GPS_INFINITE;
  3052. // pSave->m_Double = 0;
  3053. DstList->AddHead(pSave);
  3054. }
  3055. }
  3056. if(DstList->GetCount() != 0) return true;
  3058. return false;
  3059. }
  3061. bool CGpsDrawMap::GetMinDistPoint(CObList *CrossList,CBRCrossStruct *MinCross)
  3062. {
  3063. CBRCrossStruct *pBRCross,*pMin;
  3064. POSITION pos;
  3065. long Distance = GPS_INFINITE;
  3067. pos = CrossList->GetTailPosition();
  3068. while(pos != NULL) {
  3069. pBRCross = (CBRCrossStruct*)CrossList->GetPrev(pos);
  3070. if(pBRCross->m_Adjust != 1) continue;
  3071. if(Distance > pBRCross->m_Distance) {
  3072. *MinCross = *pBRCross;
  3073. pMin = pBRCross;
  3074. Distance = pBRCross->m_Distance;
  3075. }
  3076. }
  3077. if(Distance == GPS_INFINITE) return false;
  3078. pMin->m_Adjust = 0;
  3080. return true;
  3081. }
  3083. bool CGpsDrawMap::CheckCrossSame(CGpsRoadCrossPoint *pC1,CGpsRoadCrossPoint *pC2)
  3084. {
  3085. bool Flag = false;
  3086. if( (pC1->m_CrossRoad1_Serial == pC2->m_CrossRoad1_Serial) &&
  3087. (pC1->m_CrossRoad1_Number == pC2->m_CrossRoad1_Number) &&
  3088. // (pC1->CrossRoad1_Level  == pC2->CrossRoad2_Level)  &&
  3089. (pC1->m_CrossRoad2_Serial == pC2->m_CrossRoad2_Serial) &&
  3090. (pC1->m_CrossRoad2_Number == pC2->m_CrossRoad2_Number) &&
  3091. // (pC1->CrossRoad2_Level  == pC2->CrossRoad2_Level)  &&
  3092. (pC1->m_CrossRoad3_Serial == pC2->m_CrossRoad3_Serial) &&
  3093. (pC1->m_CrossRoad3_Number == pC2->m_CrossRoad3_Number) &&
  3094. // (pC1->CrossRoad3_Level  == pC2->CrossRoad3_Level)  &&
  3095. (pC1->m_CrossRoad4_Serial == pC2->m_CrossRoad4_Serial) &&
  3096. (pC1->m_CrossRoad4_Number == pC2->m_CrossRoad4_Number) &&
  3097. // (pC1->CrossRoad4_Level  == pC2->CrossRoad4_Level)  &&
  3098. (pC1->m_lx == pC2->m_lx) && (pC1->m_ly == pC2->m_ly)) {
  3099. Flag = true;
  3100. }
  3102. return Flag;
  3103. }
  3105. bool CGpsDrawMap::HaveSaveOneRoadSn(CGpsRoadCrossPoint *pCross1,CGpsRoadCrossPoint *pCross2)
  3106. {
  3107. CString arrRoadSn[4];
  3108. BYTE i;
  3110. arrRoadSn[0].Format("%c%d",pCross1->m_CrossRoad1_Serial,pCross1->m_CrossRoad1_Number);
  3111. arrRoadSn[1].Format("%c%d",pCross1->m_CrossRoad2_Serial,pCross1->m_CrossRoad2_Number);
  3112. arrRoadSn[2].Format("%c%d",pCross1->m_CrossRoad3_Serial,pCross1->m_CrossRoad3_Number);
  3113. arrRoadSn[3].Format("%c%d",pCross1->m_CrossRoad4_Serial,pCross1->m_CrossRoad4_Number);
  3115. for(i = 0; i < 4; i++) {
  3116. if(IsInvalidSn(arrRoadSn[i])) continue;
  3117. if(RoadSnInCross(arrRoadSn[i],pCross2)) return true;
  3118. }
  3120. return false;
  3121. }
  3123. bool CGpsDrawMap::BRCrossInList(CBRCrossStruct *pBRCross,CObList *CrossList)
  3124. {
  3125. CBRCrossStruct *pCross;
  3126. POSITION pos;
  3128. pos = CrossList->GetTailPosition();
  3129. while(pos != NULL) {
  3130. pCross = (CBRCrossStruct*)CrossList->GetPrev(pos);
  3131. if(SimilarCross(&pBRCross->m_cCross,&pCross->m_cCross)) {
  3132. return true;
  3133. }
  3134. }
  3135. return false;
  3136. }
  3138. short CGpsDrawMap::BR_SaveOnePath(CGpsRoadCrossPoint *StartPoint,
  3139.  CGpsRoadCrossPoint *EndPoint,
  3140.  CObList *RoadList,CObList *CrossList,CObList *SavePathList)
  3141. {
  3142. CBRCrossStruct cMinCross,*pBRCross,*pSave,SimilarEnd;
  3143. CBRCrossStruct *pTempCross;
  3144. POSITION pos;
  3145. long Distance,RecordTimes = 0;
  3146. CObList TempCrossList;
  3147. short PathLen = 0;
  3148. bool Flag = false,Flag1 = false;
  3150. if(CheckCrossSame(StartPoint,EndPoint)) return 0;
  3151. if(!SaveInitBRCross(CrossList,&TempCrossList)) return 0;
  3153. pos = TempCrossList.GetTailPosition();
  3154. while(pos != NULL) {
  3155. pBRCross = (CBRCrossStruct*)TempCrossList.GetPrev(pos);
  3156. if(SimilarCross(&pBRCross->m_cCross,StartPoint)) {
  3157. pBRCross->m_Adjust = 1;
  3158. pBRCross->m_Distance = 0;
  3159. Flag = true;
  3160. }
  3161. if(!Flag1) {
  3162. if(SimilarCross(&pBRCross->m_cCross,EndPoint)) {
  3163. SimilarEnd = *pBRCross;
  3164. Flag1 = true;
  3165. }
  3166. }
  3167. if(Flag && Flag1) break;
  3168. }
  3169. if((!Flag) || (!Flag1)) {
  3170. m_cCurrMapInfo.ClearBRoadSaveList(&TempCrossList);
  3171. return 0;
  3172. }
  3174. while(true) {
  3175. cMinCross.Clear();
  3176. if(!GetMinDistPoint(&TempCrossList,&cMinCross)) {
  3177. m_cCurrMapInfo.ClearBRoadSaveList(&TempCrossList);
  3178. return 0;
  3179. }
  3181. if(SimilarCross(&cMinCross.m_cCross,&SimilarEnd.m_cCross)) {
  3182. // if(CheckCrossSame(&cMinCross.m_cCross,&SimilarEnd.m_cCross)) {
  3183. break;
  3184. }
  3185. Distance = GPS_INFINITE;
  3186. pos = TempCrossList.GetTailPosition();
  3187. while(pos != NULL) {
  3188. pBRCross = (CBRCrossStruct*)TempCrossList.GetPrev(pos);
  3189. if(pBRCross->m_Adjust == 0) {
  3190. continue;
  3191. }
  3192. Distance = CalcCrossVectorDist(&cMinCross.m_cCross,
  3193.    &pBRCross->m_cCross,RoadList);
  3194. if(Distance == GPS_INFINITE) continue;
  3195. if(cMinCross.m_Distance  + Distance < pBRCross->m_Distance) {
  3196. pBRCross->m_Distance = cMinCross.m_Distance + Distance;
  3197. pBRCross->m_Adjust  = 1;
  3198. }
  3199. }
  3201. RecordTimes++;
  3202. if(RecordTimes > TempCrossList.GetCount() * 2) {
  3203. break;
  3204. }
  3205. }
  3207. PathLen = 0;
  3208. pos = TempCrossList.GetTailPosition();
  3209. while(pos != NULL) {
  3210. pBRCross = (CBRCrossStruct*)TempCrossList.GetPrev(pos);
  3211. // if(CheckCrossSame(&pBRCross->m_cCross,&SimilarEnd.m_cCross) && 
  3212. if(SimilarCross(&pBRCross->m_cCross,&SimilarEnd.m_cCross) && 
  3213.   (pBRCross->m_Distance != GPS_INFINITE)) {
  3214. pSave  = new CBRCrossStruct;
  3215. *pSave = *pBRCross;
  3216. SavePathList->AddHead(pSave);
  3217. PathLen++;
  3218. break;
  3219. }
  3220. }
  3221. if(PathLen == 0) {
  3222. m_cCurrMapInfo.ClearBRoadSaveList(&TempCrossList);
  3223. return 0;
  3224. }
  3226. Distance = GPS_INFINITE;
  3227. RecordTimes = 0;
  3228. while(true) {
  3229. // Distance = GPS_INFINITE;
  3230. pSave  = new CBRCrossStruct;
  3231. pTempCross  = (CBRCrossStruct*)SavePathList->GetHead();
  3232. pos = TempCrossList.GetTailPosition();
  3233. while(pos != NULL) {
  3234. pBRCross = (CBRCrossStruct*)TempCrossList.GetPrev(pos);
  3235. // if(BRCrossInList(pBRCross,SavePathList)) continue;
  3236. if(pBRCross->m_Distance == GPS_INFINITE) continue;
  3237. if(pBRCross->m_Adjust != 0) continue;
  3238. if(HaveSaveOneRoadSn(&pBRCross->m_cCross,&pTempCross->m_cCross)) {
  3239. if(pBRCross->m_Distance < Distance) {
  3240. *pSave = *pBRCross;
  3241. Distance = pBRCross->m_Distance;
  3242. }
  3243. }
  3244. }
  3245. if(Distance != GPS_INFINITE) {
  3246. SavePathList->AddHead(pSave);
  3247. PathLen++;
  3248. if((pSave->m_cCross.m_lx == StartPoint->m_lx) &&
  3249.    (pSave->m_cCross.m_ly == StartPoint->m_ly)) {
  3250. // if(SimilarCross(&pSave->m_cCross,StartPoint)) {
  3251. break;
  3252. }
  3253. }
  3254. else {
  3255. delete pSave;
  3256. }
  3258. if(RecordTimes > TempCrossList.GetCount()) break;
  3259. RecordTimes++;
  3260. }
  3261. if(RecordTimes > TempCrossList.GetCount()) {
  3262. m_cCurrMapInfo.ClearBRoadSaveList(SavePathList);
  3263. PathLen = 0;
  3264. }
  3265. m_cCurrMapInfo.ClearBRoadSaveList(&TempCrossList);
  3267. return PathLen;
  3268. }
  3270. long CGpsDrawMap::alculateDist(CPoint SP,CPoint EP)
  3271. {
  3272. long dx,dy,min;
  3273. dx = abs(SP.x - EP.x); dy = abs(SP.y - EP.y);
  3274. min = Min(dx,dy);
  3275. return (dx + dy - min / 2 - min / 4 + min / 8);
  3277. }
  3279. void CGpsDrawMap::WritePathToTxt(CObList *PathList)
  3280. {
  3281. CFile f;
  3282. if(!f.Open("Path.txt",CFile::modeCreate | CFile::modeReadWrite,NULL)) return;
  3283. CBRCrossStruct *pCross;
  3284. POSITION pos;
  3285. CString Str;
  3286. short PointTotal;
  3288. PointTotal = PathList->GetCount();
  3289. Str.Format("共经过 %d 个交叉点: %c%c",PointTotal,'r','n');
  3290. f.Write(Str,Str.GetLength());
  3292. pos = PathList->GetHeadPosition();
  3293. while(pos != NULL) {
  3294. pCross = (CBRCrossStruct*)PathList->GetNext(pos);
  3295. Str.Format("(%c%d,%c%d,%c%d,%c%d);(%d,%d);%d;%c%c",
  3296. pCross->m_cCross.m_CrossRoad1_Serial,
  3297. pCross->m_cCross.m_CrossRoad1_Number,
  3298. pCross->m_cCross.m_CrossRoad2_Serial,
  3299. pCross->m_cCross.m_CrossRoad2_Number,
  3300. pCross->m_cCross.m_CrossRoad3_Serial,
  3301. pCross->m_cCross.m_CrossRoad3_Number,
  3302. pCross->m_cCross.m_CrossRoad4_Serial,
  3303. pCross->m_cCross.m_CrossRoad4_Number,
  3304. pCross->m_cCross.m_lx,pCross->m_cCross.m_ly,pCross->m_Distance,
  3305. 'r','n');
  3306. f.Write(Str,Str.GetLength());
  3307. }
  3308. f.Close();
  3309. }
  3312. void CGpsDrawMap::WriteBRcross(CBRCrossStruct *pBRCross,CString FileName)
  3313. {
  3314. CFile f;
  3315. if(!f.Open(FileName,CFile::modeReadWrite,NULL)) {
  3316. if(!f.Open(FileName,CFile::modeCreate | CFile::modeReadWrite,NULL)) {
  3317. return;
  3318. }
  3319. }
  3320. f.SeekToEnd();
  3321. CString str;
  3322. str.Format("(x=%d;y=%d:Dist=%d:Adjust=%d);(%c%d,%c%d,%c%d,%c%d)%c%c",
  3323. pBRCross->m_cCross.m_lx,pBRCross->m_cCross.m_ly,
  3324. pBRCross->m_Distance,pBRCross->m_Adjust,
  3325. pBRCross->m_cCross.m_CrossRoad1_Serial,
  3326. pBRCross->m_cCross.m_CrossRoad1_Number,
  3327. pBRCross->m_cCross.m_CrossRoad2_Serial,
  3328. pBRCross->m_cCross.m_CrossRoad2_Number,
  3329. pBRCross->m_cCross.m_CrossRoad3_Serial,
  3330. pBRCross->m_cCross.m_CrossRoad3_Number,
  3331. pBRCross->m_cCross.m_CrossRoad4_Serial,
  3332. pBRCross->m_cCross.m_CrossRoad4_Number,
  3333. 'r','n');
  3334. // AfxMessageBox(str);
  3336. f.Write(str,str.GetLength());
  3337. f.Close();
  3338. }
  3340. void CGpsDrawMap::WriteCross(CGpsRoadCrossPoint *pCross,CString FileName)
  3341. {
  3342. CFile f;
  3343. if(!f.Open(FileName,CFile::modeReadWrite,NULL)) {
  3344. if(!f.Open(FileName,CFile::modeCreate | CFile::modeReadWrite,NULL)) {
  3345. return;
  3346. }
  3347. }
  3348. f.SeekToEnd();
  3349. CString str;
  3350. str.Format("(x=%d;y=%d);(%c%d,%c%d,%c%d,%c%d)%c%c",
  3351. pCross->m_lx,pCross->m_ly,
  3352. pCross->m_CrossRoad1_Serial,
  3353. pCross->m_CrossRoad1_Number,
  3354. pCross->m_CrossRoad2_Serial,
  3355. pCross->m_CrossRoad2_Number,
  3356. pCross->m_CrossRoad3_Serial,
  3357. pCross->m_CrossRoad3_Number,
  3358. pCross->m_CrossRoad4_Serial,
  3359. pCross->m_CrossRoad4_Number,
  3360. 'r','n');
  3361. // AfxMessageBox(str);
  3363. f.Write(str,str.GetLength());
  3364. f.Close();
  3365. }
  3367. void CGpsDrawMap::DrawBetweenBRCrossLine(CDC *pDC,CObList *SaveBRCrossList)
  3368. {
  3369. CBRCrossStruct *pCross,pPrevCross;
  3370. CObList TempList;
  3371. POSITION pos;
  3372. CString RoadSn("");
  3373. bool Flag = false;
  3375. DrawLineEx(pDC,&mSaveTempList1);
  3376. DrawLineEx(pDC,&mSaveTempList2);
  3378. pos = SaveBRCrossList->GetHeadPosition();
  3379. while(pos != NULL) {
  3380. pCross = (CBRCrossStruct*)SaveBRCrossList->GetNext(pos);
  3381. if(Flag) {
  3382. DrawBetweenCross(&pPrevCross.m_cCross,&pCross->m_cCross,&m_cCurrMapInfo.lCurrRoadList,pDC);
  3383. // if(!DrawBetweenCross(&pPrevCross.m_cCross,&pCross->m_cCross,&DispRoadList,pDC)) {
  3384. // ClearBRoadSaveList(SaveBRCrossList);
  3385. // return;
  3386. // }
  3387. }
  3388. else {
  3389. Flag = true;
  3390. }
  3391. pPrevCross = *pCross;
  3392. }
  3393. }
  3395. bool CGpsDrawMap::DrawBetweenCross(CGpsRoadCrossPoint *pPrevCross,CGpsRoadCrossPoint *pCross,CObList *RoadList,CDC *pDC)
  3396. {
  3397. CObList DstList;
  3398. CString RoadSn;
  3400. RoadSn.Format("%c%d",pPrevCross->m_CrossRoad1_Serial,pPrevCross->m_CrossRoad1_Number);
  3401. if(RoadSnInCross(RoadSn,pCross)) {
  3402. if(GetOneRoadPlain(pPrevCross,pCross,RoadList,RoadSn,&DstList)) {
  3403. DrawLineEx(pDC,&DstList);
  3404. m_cCurrMapInfo.ClearPointList(&DstList);
  3405. return true;
  3406. }
  3407. }
  3409. RoadSn.Format("%c%d",pPrevCross->m_CrossRoad2_Serial,pPrevCross->m_CrossRoad2_Number);
  3410. if(RoadSnInCross(RoadSn,pCross)) {
  3411. if(GetOneRoadPlain(pPrevCross,pCross,RoadList,RoadSn,&DstList)) {
  3412. DrawLineEx(pDC,&DstList);
  3413. m_cCurrMapInfo.ClearPointList(&DstList);
  3414. return true;
  3415. }
  3416. }
  3418. RoadSn.Format("%c%d",pPrevCross->m_CrossRoad3_Serial,pPrevCross->m_CrossRoad3_Number);
  3419. if(RoadSnInCross(RoadSn,pCross)) {
  3420. if(GetOneRoadPlain(pPrevCross,pCross,RoadList,RoadSn,&DstList)) {
  3421. DrawLineEx(pDC,&DstList);
  3422. m_cCurrMapInfo.ClearPointList(&DstList);
  3423. return true;
  3424. }
  3425. }
  3427. RoadSn.Format("%c%d",pPrevCross->m_CrossRoad4_Serial,pPrevCross->m_CrossRoad4_Number);
  3428. if(RoadSnInCross(RoadSn,pCross)) {
  3429. if(GetOneRoadPlain(pPrevCross,pCross,RoadList,RoadSn,&DstList)) {
  3430. DrawLineEx(pDC,&DstList);
  3431. m_cCurrMapInfo.ClearPointList(&DstList);
  3432. return true;
  3433. }
  3434. }
  3436. return false;
  3437. }
  3439. void CGpsDrawMap::DrawLineEx(CDC *pDC,CObList *TempList)
  3440. {
  3441. CRoadPoint *pPoint;
  3442. POSITION pos;
  3443. CPoint point,point1;
  3444. bool Flag = false;
  3446. pos = TempList->GetHeadPosition();
  3447. while(pos  != NULL) {
  3448. pPoint  = (CRoadPoint*)TempList->GetNext(pos);
  3449. point.x = pPoint->m_lx; point.y = pPoint->m_ly;
  3450. if(Flag) {
  3451. DrawLine(point1.x,point1.y,point.x,point.y,3,m_cColor.RoadColor[6],pDC);
  3452. }
  3453. else {
  3454. Flag = true;
  3455. }
  3456. point1 = point;
  3457. }
  3458. }
  3460. void CGpsDrawMap::CalculateBRroadPath(CPoint point)
  3461. {
  3462. CPoint cPoint;
  3463. CString RoadSn;
  3464. if(!gBRcross.m_bHaveSpoint) {
  3465. if(!SearchSignByPoint(point,cPoint)) return;
  3466. if(SearchRoad(point,RoadSn) == "") return;
  3467. ClearPointList(&mSaveTempList1);
  3468. if(GetOneBRCrossPoint(point,&m_cCurrMapInfo.lCurrRoadList,
  3469. &m_cCurrMapInfo.lCurrCrossList,
  3470. RoadSn,&gBRcross.m_StartCross,&mSaveTempList1)) {
  3471. gBRcross.m_bHaveSpoint = true;
  3472. AfxMessageBox("请选择目标点!");
  3473. }
  3474. }
  3475. else {
  3476. if(!SearchSignByPoint(point,cPoint)) return;
  3477. if(SearchRoad(point,RoadSn) == "") return;
  3478. ClearPointList(&mSaveTempList2);
  3479. if(GetOneBRCrossPoint(point,&m_cCurrMapInfo.lCurrRoadList,
  3480. &m_cCurrMapInfo.lCurrCrossList,
  3481. RoadSn,&gBRcross.m_EndCross,&mSaveTempList2)) {
  3482. m_cCurrMapInfo.ClearBRoadSaveList(&mSaveBRList);
  3483. gBRcross.m_bEnable = true;
  3484. ((CGpsSCView*)m_pCurrView)->StatusPrompt("正在计算路径，请稍等...",0);
  3485. AfxGetApp()->BeginWaitCursor();
  3486. short Len = BR_SaveOnePath(&gBRcross.m_StartCross.m_cCross,
  3487.    &gBRcross.m_EndCross.m_cCross,
  3488.    &m_cCurrMapInfo.lCurrRoadList,
  3489.    &m_cCurrMapInfo.lCurrCrossList,
  3490.    &mSaveBRList);
  3491. if(Len <= 1) {
  3492. AfxMessageBox("没有找到路径!");
  3493. }
  3494. else {
  3495. // m_cDrawMap.WritePathToTxt(&mSaveBRList);
  3496. CString Prompt;
  3497. Prompt.Format("查找到路径!",Len);
  3498. AfxMessageBox(Prompt);
  3499. }
  3501. AfxGetApp()->EndWaitCursor();
  3503. ((CGpsSCView*)m_pCurrView)->Invalidate();
  3504. }
  3505. }
  3506. }
  3508. void CGpsDrawMap::DispShootPic(CDC *pDC,CPoint point,CString PicPath)
  3509. {
  3510. /*
  3511. CPicture mPic;
  3512. CRect cRect;
  3513. CSize Size;
  3515. if(mPic.Load(PicPath)) {
  3516. Size  = mPic.GetImageSize();
  3518. cRect.top  = point.y - Size.cy / 2;
  3519. cRect.bottom = point.y + Size.cy / 2;
  3520. cRect.left  = point.x - Size.cx / 2;
  3521. cRect.right  = point.x + Size.cx / 2;
  3523. mPic.Render(pDC,cRect);
  3524. }
  3525. */
  3526. }
  3528. bool CGpsDrawMap::SearchSignByPoint(CPoint point,CPoint &Ret)
  3529. {
  3530. CGpsSignObject *pSign = NULL;
  3531. POSITION pos;
  3533. pos = m_cCurrMapInfo.lCurrSignList.GetTailPosition();
  3534. while(pos != NULL) {
  3535. pSign  = (CGpsSignObject*)m_cCurrMapInfo.lCurrSignList.GetPrev(pos);
  3536. if((abs(pSign->m_lx - point.x) < m_PointWidth) &&
  3537.    (abs(pSign->m_ly - point.y) < m_PointWidth)) {
  3538. Ret.x = pSign->m_lx;
  3539. Ret.y = pSign->m_ly;
  3540. return true;
  3541. }
  3542. }
  3544. return false;
  3545. }
  3547. void CGpsDrawMap::GetCarXY(int &nx,int &ny)
  3548. {
  3549. CGpsPoint *pPoint = NULL;
  3550. POSITION pos;
  3551. pos  = mSaveRecePointList.GetTailPosition();
  3552. while(pos != NULL) {
  3553. pPoint = (CGpsPoint*)mSaveRecePointList.GetPrev(pos);
  3554. if(pPoint != NULL) {
  3555. nx = pPoint->m_lx;
  3556. ny = pPoint->m_ly;
  3557. }
  3558. }
  3559. }
  3561. bool CGpsDrawMap::CompanySimilarStr(CString Str1,CString Str2)
  3562. {
  3563. CString Temp;
  3564. BYTE pos = 0;
  3566. while(pos <= Str1.GetLength() - 4) {
  3567. Temp = Str1.Mid(pos,4);
  3568. if(Str2.Find(Temp,0) != -1) return true;
  3569. pos += 2;
  3570. }
  3572. while(pos <= Str2.GetLength() - 4) {
  3573. Temp = Str2.Mid(pos,4);
  3574. if(Str1.Find(Temp,0) != -1) return true;
  3575. pos += 2;
  3576. }
  3578. return false;
  3579. }
  3581. void CGpsDrawMap::SearchSignByInput()
  3582. {
  3583. CInputStringDlg input;
  3585. input.m_sCaption = "请输入标志名称:";
  3586. if(input.DoModal() == IDCANCEL) return;
  3587. if(input.m_sString.IsEmpty()) return;
  3589. CString arrSignName[100];
  3590. int Count = 0;
  3592. CGpsSignObject *pSign = NULL;
  3593. POSITION pos;
  3594. CString Name;
  3596. pos  = m_cCurrMapInfo.lCurrSignList.GetTailPosition();
  3597. while(pos != NULL) {
  3598. pSign = (CGpsSignObject*)m_cCurrMapInfo.lCurrSignList.GetPrev(pos);
  3599. Name = pSign->m_pSignObjectName;
  3600. if(CompanySimilarStr(Name, input.m_sString)) {
  3601. arrSignName[Count++] = Name;
  3602. }
  3603. }
  3604. if(Count == 0) return;
  3606. CListSimilarStrDlg dlg(arrSignName,Count);
  3607. dlg.m_sCaption = "相似标志物:";
  3608. dlg.GetParent(this);
  3610. dlg.DoModal();
  3611. }
  3613. void CGpsDrawMap::DrawSignByName(CString SignName)
  3614. {
  3615. CGpsSignObject *pSign = NULL;
  3616. POSITION pos;
  3617. CString Name;
  3618. bool Flag = false;
  3620. pos  = m_cCurrMapInfo.lCurrSignList.GetTailPosition();
  3621. while(pos != NULL) {
  3622. pSign = (CGpsSignObject*)m_cCurrMapInfo.lCurrSignList.GetPrev(pos);
  3623. Name = pSign->m_pSignObjectName;
  3624. if(Name == SignName) {
  3625. Flag = true;
  3626. break;
  3627. }
  3628. }
  3629. if(!Flag) return;
  3631. CheckMapIsChange(pSign->m_dgx,pSign->m_dgy);
  3633. RefreshMapWnd();
  3635. CovertNEXY(pSign, m_cCurrMapInfo.CoeffNE_XY, true);
  3637. pDispOneSign.m_lx = pSign->m_lx;
  3638. pDispOneSign.m_ly = pSign->m_ly;
  3640. pDispOneSign.m_dgx = pSign->m_dgx;
  3641. pDispOneSign.m_dgy = pSign->m_dgy;
  3643. pDispOneSign.m_sIconName = pSign->m_sIconName;
  3644. CopyEquaLenArr(pSign->m_pSignObjectName,pDispOneSign.m_pSignObjectName,pSign->m_bySignName_Bytes);
  3646. FreshWnd();
  3647. }