MapX 기반 미사일 공격 샌 드 디스크 데모 시스템 코드

하나  데이터 구조

  
  
  
  
  1. ///////////////////////////////////////////////////// ////////////////////////////////  
  2. //  
  3. typedef struct _Position  
  4. {  
  5.     double       m_longtidude;        //  
  6.     double       m_latitude;          //  
  7.     bool         flag;                //  
  8.       
  9. } Position;  
  10.  
  11. typedef  std::vector<Position> _planePositionVector;    //  
  12. typedef  std::vector<Position> _missilePositionVector;  //  
  13.  
  14. /////////////////////////////////////////////////////////////////////////////////////////// 

 
둘.  인터페이스

  
  
  
  
  1.     ////////////////////////////////// ///////////////////  
  2.       
  3. public:  
  4.     int   LoadGeoData(CString file);         //    
  5.     void  CreateLayer(CMapXLayer* layer, CString str, int id );  //  
  6.     void  DrawPoint(CMapXLayer* layer,Position position, CString bitName);          //  
  7.     void  DrawLine(CMapXLayer* layer, Position startPoint, Position endPoint, int lineColor, int lineStyle);//  
  8.  
  9.  
  10.     void  ShowPlaneTrace(_planePositionVector &planeVector);        //  
  11.     void  ShowMissileTrace(_missilePositionVector &missileVector);  //  
  12.  
  13.     void  RecordPlaneTrace(_planePositionVector &planeVector, Position &positionStart, int count);     //  
  14.     void  RecordMissileTrace(_missilePositionVector &missileVector, Position &positionStart, int count); //  
  15.  
  16.     void  PlaneNextPosition(Position &startPosition, Position &endPosition);      //  
  17.     void  MissileNextPosition(Position &startPosition, Position &endPosition);    //  
  18.       
  19. public:  
  20.      
  21.     CMapXLayer m_planeLayer;   //  
  22.     CMapXLayer m_missileLayer; //  
  23.     CMapXLayer m_trackLayer;   //  
  24.     CMapX      m_map;          //  

인터페이스 구현

  
  
  
  
  1.  
  2. //  
  3. int  CLmtestView::LoadGeoData(CString file)  
  4. {  
  5.     if (!m_map.Create(NULL,WS_VISIBLE,CRect(50,50,400,400),this, IDC_MAP))  
  6.     {  
  7.         //  
  8.         return -1;  
  9.     }  
  10.     m_map.SetGeoSet(file);  
  11.     m_map.SetTitleText(" V1.0");  
  12.     //CreateDefenseLayer();   //  
  13.     CreateLayer(&m_planeLayer,"PLANE_LAYER",2);       //  
  14.     CreateLayer(&m_missileLayer,"MISSILE_LAYER",3);   //  
  15.     CreateLayer(&m_trackLayer,"TRACK_LAYER",4);       //  
  16.     m_map.SetCurrentTool(miPanTool);  
  17.     return 0;  
  18. }  
  19.       
  20.  //  
  21.  void   CLmtestView::CreateLayer(CMapXLayer* layer, CString str, int id )  
  22.  {  
  23.      CString geo=m_map.GetGeoSet();  
  24.      if(geo.IsEmpty())  
  25.      {  
  26.          AfxMessageBox(_T(" , "));  
  27.          return;  
  28.      }  
  29.      try 
  30.      {  
  31.          m_map.GetLayers().CreateLayer(_T(str), NULL, id);  
  32.          *layer = m_map.GetLayers().Item(_T(str));  
  33.      }  
  34.      catch(COleDispatchException *e)  
  35.      {  
  36.          e->ReportError();  
  37.          e->Delete();  
  38.      }  
  39.      catch(COleException *e)  
  40.      {  
  41.          e->ReportError();  
  42.          e->Delete();  
  43.      }  
  44.  
  45.  }  
  46.  
  47.  
  48.  //  
  49.  
  50. void CLmtestView::OnPlane()   
  51. {  
  52.     // TODO: Add your command handler code here  
  53.  
  54.     //  
  55.     SetTimer(ID_TIMER_PLANE,1000,NULL);   
  56. }  
  57.  
  58. void CLmtestView::OnMissile()   
  59. {  
  60.     // TODO: Add your command handler code here  
  61.     SetTimer(ID_TIMER_MISSILE,1000,NULL);     
  62. }  
  63.  
  64. void CLmtestView::OnTimer(UINT nIDEvent)   
  65. {  
  66.     // TODO: Add your message handler code here and/or call default  
  67.     //  
  68.  
  69.     if (ID_TIMER_PLANE == nIDEvent)  
  70.     {  
  71.         static bool binit = false;  
  72.         if (!binit)     //  
  73.         {  
  74.             //  
  75.             Position planePositionStart ={87.1875,43.961191,FALSE};  
  76.               
  77.             //  
  78.             RecordPlaneTrace(planePositionVector,planePositionStart,10);  
  79.  
  80.             binit = true;  
  81.  
  82.         }     
  83.         //  
  84.         ShowPlaneTrace(planePositionVector);  
  85.     }   
  86.  
  87.     else if(ID_TIMER_MISSILE == nIDEvent)  
  88.     {  
  89.         static bool binit = false;  
  90.         if (!binit)     //  
  91.         {  
  92.             //  
  93.             Position missilePositionStart ={128.71582,46.498392,FALSE};  
  94.               
  95.             //  
  96.             RecordMissileTrace(missilePositionVector,missilePositionStart,10);  
  97.               
  98.             binit = true;  
  99.               
  100.         }     
  101.         //  
  102.         ShowMissileTrace(missilePositionVector);  
  103.     }  
  104.  
  105.     CView::OnTimer(nIDEvent);  
  106. }  
  107.  
  108.  
  109. //  
  110. void  CLmtestView::DrawLine(CMapXLayer* layer, Position startPoint, Position endPoint, int lineColor, int lineStyle)  
  111. {  
  112.     CMapXStyle lineSty;   //  
  113.       
  114.     COleVariant vt;  
  115.     vt.vt=VT_DISPATCH;  
  116.       
  117.     CMapXFeature newFeature;    //  
  118.       
  119.     CMapXPoint pt;               //  
  120.     CMapXPoints pts;             //  
  121.     pt.CreateDispatch(pt.GetClsid());  
  122.     pts.CreateDispatch(pts.GetClsid());  
  123.           
  124.     pts.RemoveAll();  
  125.     pt.Set(startPoint.m_longtidude, startPoint.m_latitude);   //  
  126.     pts.Add(pt);  
  127.     pt.Set(endPoint.m_longtidude,endPoint.m_latitude);        //  
  128.     pts.Add(pt);  
  129.       
  130.     vt.pdispVal=pts.m_lpDispatch;  
  131.     vt.pdispVal->AddRef();//  
  132.       
  133.     CMapXFeature sidefeature=m_map.GetFeatureFactory().CreateLine(vt);  //  
  134.       
  135.     lineSty=sidefeature.GetStyle();  //  
  136.     lineSty.SetLineColor(lineColor);  
  137.     lineSty.SetLineStyle(lineStyle);  
  138.     sidefeature.SetStyle(lineSty.m_lpDispatch);  
  139.     sidefeature=(*layer).AddFeature(sidefeature);  //  
  140.     sidefeature.Update();  
  141.     //  long sid=sidefeature.GetFeatureID();// ID , ID ,  
  142.     //  m_sidearray.Add(sid);  
  143.       
  144.     m_map.Refresh();          
  145.  
  146. }  
  147.  
  148. void  CLmtestView::DrawPoint(CMapXLayer* layer,Position position, CString bitName)         //  
  149. {  
  150.     //  
  151.               
  152.     CMapXFeature ftr;  
  153.     if(!ftr.CreateDispatch (ftr.GetClsid ()))  
  154.     {  
  155.           
  156.         TRACE(_T("SetMissilePositon FAILED
    "
    ));  
  157.           
  158.     }  
  159.     try 
  160.     {  
  161.         ftr.Attach (m_map.GetDispatch ());        
  162.         //  
  163.         CMapXStyle style=ftr.GetStyle ();  
  164.         style.SetSymbolType(miSymbolTypeBitmap);  
  165.         style.SetSymbolBitmapSize (24);  
  166.         style.SetSymbolBitmapTransparent (TRUE);  
  167.         style.SetSymbolBitmapName(_T(bitName));  
  168.         ftr.GetPoint ().Set(position.m_longtidude, position.m_latitude); //  
  169.         ftr=(*layer).AddFeature(ftr);//      
  170.         m_map.Refresh ();  
  171.     }  
  172.     catch(COleDispatchException *e)  
  173.     {  
  174.         e->ReportError();  
  175.         e->Delete();  
  176.           
  177.     }  
  178.     catch(COleException *e)  
  179.     {  
  180.         e->ReportError();  
  181.         e->Delete();  
  182.           
  183.     }  
  184.  
  185. }  
  186.  
  187.  
  188. //  
  189. void  CLmtestView::PlaneNextPosition(Position &startPosition, Position &endPosition)  
  190. {  
  191.     static int flag = 1; //  
  192.     if (flag<3)  
  193.     {  
  194.         static double longtidudeStep = 2.03;  
  195.         static double latitudeStep = 2.26;  
  196.           
  197.         endPosition.flag = false;  
  198.         endPosition.m_longtidude = startPosition.m_longtidude + longtidudeStep; // +5  
  199.         endPosition.m_latitude = startPosition.m_latitude - latitudeStep;     // -6  
  200.           
  201.         longtidudeStep += 0.89;  
  202.         latitudeStep += 0.35;  
  203.         flag++;  
  204.     }   
  205.     else if(flag <4)  
  206.     {  
  207.         static double longtidudeStep = 2.03;  
  208.         static double latitudeStep = 4.26;  
  209.           
  210.         endPosition.flag = false;  
  211.         endPosition.m_longtidude = startPosition.m_longtidude + longtidudeStep; // +5  
  212.         endPosition.m_latitude = startPosition.m_latitude + latitudeStep;     // -6  
  213.           
  214.         longtidudeStep += 0.89;  
  215.         latitudeStep += 0.35;  
  216.         flag++;  
  217.     }  
  218.     else 
  219.     {  
  220.         static double longtidudeStep = 2.03;  
  221.         static double latitudeStep = 2.26;  
  222.           
  223.         endPosition.flag = false;  
  224.         endPosition.m_longtidude = startPosition.m_longtidude + longtidudeStep; // +5  
  225.         endPosition.m_latitude = startPosition.m_latitude - latitudeStep;     // -6  
  226.           
  227.         longtidudeStep += 0.89;  
  228.         latitudeStep += 0.35;  
  229.         flag = 1;  
  230.  
  231.     }  
  232.  
  233. //      endPosition.flag = false;  
  234. //      endPosition.m_longtidude = startPosition.m_longtidude + 1.35;  
  235. //      endPosition.m_latitude = 7.347826*(endPosition.m_longtidude)*(endPosition.m_longtidude)-1563.31770723*(endPosition.m_longtidude)+82873.51;  
  236. //    
  237.  
  238. }  
  239.  
  240. //  
  241. void  CLmtestView::MissileNextPosition(Position &startPosition, Position &endPosition)  
  242. {  
  243.     static int flag = 1; //  
  244.     if (flag<3)  
  245.     {  
  246.         static double longtidudeStep = 2.03;  
  247.         static double latitudeStep = 2.26;  
  248.           
  249.         endPosition.flag = false;  
  250.         endPosition.m_longtidude = startPosition.m_longtidude - longtidudeStep; // +5  
  251.         endPosition.m_latitude = startPosition.m_latitude - latitudeStep;     // -6  
  252.           
  253.         longtidudeStep += 0.89;  
  254.         latitudeStep += 0.35;  
  255.         flag++;  
  256.     }   
  257.     else if(flag <4)  
  258.     {  
  259.         static double longtidudeStep = 2.03;  
  260.         static double latitudeStep = 4.26;  
  261.           
  262.         endPosition.flag = false;  
  263.         endPosition.m_longtidude = startPosition.m_longtidude- longtidudeStep; // +5  
  264.         endPosition.m_latitude = startPosition.m_latitude + latitudeStep;     // -6  
  265.           
  266.         longtidudeStep += 0.89;  
  267.         latitudeStep += 0.35;  
  268.         flag++;  
  269.     }  
  270.     else 
  271.     {  
  272.         static double longtidudeStep = 2.03;  
  273.         static double latitudeStep = 2.26;  
  274.           
  275.         endPosition.flag = false;  
  276.         endPosition.m_longtidude = startPosition.m_longtidude - longtidudeStep; // +5  
  277.         endPosition.m_latitude = startPosition.m_latitude - latitudeStep;     // -6  
  278.           
  279.         longtidudeStep += 0.89;  
  280.         latitudeStep += 0.35;  
  281.         flag = 1;  
  282.           
  283.     }  
  284.  
  285.  
  286.  
  287. }  
  288.  
  289. //  
  290. void  CLmtestView::ShowPlaneTrace(_planePositionVector &planeVector)         
  291. {  
  292.     static int i = 0;  
  293.     planeVector[0].flag =TRUE;  
  294.  
  295.     for (i; i<planeVector.size(); i++)   
  296.     {  
  297.         if (TRUE == planeVector[i].flag)  
  298.         {  
  299.             //  
  300.             DrawPoint(&m_planeLayer,planeVector[i],"FIRE1-32.BMP");  
  301.               
  302.             //  
  303.             m_map.GetLayers().Item(2).GetSelection().ClearSelection();  
  304.             CMapXFeatures fts = m_map.GetLayers().Item(2).AllFeatures();          
  305.             m_map.GetLayers().Item(2).GetSelection().Add(fts.Item(i+1));  
  306.         }  
  307.         else 
  308.         {  
  309.             break;  
  310.         }         
  311.     }  
  312.     if (i<planeVector.size())  
  313.     {  
  314.         planeVector[i].flag = true//  
  315.     }  
  316.  
  317.     //  
  318.     if (i>1)  
  319.     {  
  320.         DrawLine(&m_trackLayer, planeVector[i-2], planeVector[i-1],miColorBlue,99);  
  321.     }  
  322.  
  323. }   
  324.  
  325. //  
  326. void  CLmtestView::ShowMissileTrace(_missilePositionVector &missileVector)   
  327. {  
  328.     static int i = 0;  
  329.     missileVector[0].flag =TRUE;  
  330.       
  331.     for (i; i<missileVector.size(); i++)   
  332.     {  
  333.         if (TRUE == missileVector[i].flag)  
  334.         {  
  335.             //  
  336.             DrawPoint(&m_missileLayer,missileVector[i],"MISSILE.BMP");  
  337.               
  338.             //  
  339.             m_map.GetLayers().Item(3).GetSelection().ClearSelection();  
  340.             CMapXFeatures fts = m_map.GetLayers().Item(3).AllFeatures();          
  341.             m_map.GetLayers().Item(3).GetSelection().Add(fts.Item(i+1));  
  342.         }  
  343.         else 
  344.         {  
  345.             break;  
  346.         }         
  347.     }  
  348.     if (i<missileVector.size())  
  349.     {  
  350.         missileVector[i].flag = true;   //  
  351.     }  
  352.       
  353.     //  
  354.     if (i>1)  
  355.     {  
  356.         DrawLine(&m_trackLayer, missileVector[i-2], missileVector[i-1],miColorRed,57);  
  357.     }  
  358. }  
  359.  
  360. //  
  361. void  CLmtestView::RecordPlaneTrace(_planePositionVector &planeVector,Position &positionStart,int count)    
  362. {  
  363.     int vectorlength; //  
  364.  
  365.     Position  tempStartPosition;  //  
  366.     tempStartPosition = positionStart;  
  367.       
  368.     //  
  369.     planeVector.push_back(positionStart);  
  370.  
  371.     while ((vectorlength=planeVector.size()) < count)  
  372.     {  
  373.         Position  tempEndPosition;  //  
  374.         PlaneNextPosition(tempStartPosition,tempEndPosition); //    
  375.         planeVector.push_back(tempEndPosition);//  
  376.         tempStartPosition = tempEndPosition;  
  377.     }  
  378. }    
  379.  
  380. //  
  381. void  CLmtestView::RecordMissileTrace(_missilePositionVector &missileVector,Position &positionStart, int count)   
  382. {  
  383.     int vectorlength; //  
  384.       
  385.     Position  tempStartPosition;  //  
  386.     tempStartPosition = positionStart;  
  387.       
  388.     //  
  389.     missileVector.push_back(positionStart);  
  390.       
  391.     while ((vectorlength=missileVector.size()) < count)  
  392.     {  
  393.         Position  tempEndPosition;  //  
  394.         MissileNextPosition(tempStartPosition,tempEndPosition); //      
  395.         missileVector.push_back(tempEndPosition);//  
  396.         tempStartPosition = tempEndPosition;  
  397.     }  

좋은 웹페이지 즐겨찾기