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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 传真(Fax)编程 > 查看源码
TIFFView.cpp
资源名称：GTIFFSample.zip　[点击查看]
上传用户：lbr_007
上传日期：2019-05-31
资源大小：282k
文件大小：19k
源码类别：

传真(Fax)编程

开发平台：

Visual C++

TIFFView.cpp：源码内容
  1. // TIFFView.cpp : implementation of the TIFFView class
  2. //
  4. #include "stdafx.h"
  5. #include "TIFFSample.h"
  7. #include "TIFFFrame.h"
  8. #include "TIFFDoc.h"
  9. #include "TIFFView.h"
  11. #include "RegPtDLG.h"
  12. #include "FlightDLG.h"
  14. #include <string>
  15. #include <geo.h>
  16. #include <dibijg.h>
  18. using namespace std;
  20. #ifdef _DEBUG
  21. #define new DEBUG_NEW
  22. #undef THIS_FILE
  23. static char THIS_FILE[] = __FILE__;
  24. #endif
  26. TIFFView * g_view = 0;
  27. extern CStatusBar * g_statusBar;
  29. /////////////////////////////////////////////////////////////////////////////
  30. // TIFFView
  32. IMPLEMENT_DYNCREATE(TIFFView, CScrollView)
  34. BEGIN_MESSAGE_MAP(TIFFView, CScrollView)
  35. //{{AFX_MSG_MAP(TIFFView)
  36. ON_WM_LBUTTONDOWN()
  37. ON_WM_LBUTTONUP()
  38. ON_WM_MOUSEMOVE()
  39. ON_UPDATE_COMMAND_UI(ID_VIEW_IMGBAR, OnUpdateImageList)
  40. ON_COMMAND(ID_VIEW_IMGBAR, OnImageList)
  41. ON_UPDATE_COMMAND_UI(ID_VIEW_2D, OnUpdateView2D)
  42. ON_COMMAND(ID_VIEW_2D, OnView2D)
  43. ON_UPDATE_COMMAND_UI(ID_VIEW_3D, OnUpdateView3D)
  44. ON_COMMAND(ID_VIEW_3D, OnView3D)
  45. ON_UPDATE_COMMAND_UI(ID_VIEW_REG, OnUpdateRegistration)
  46. ON_COMMAND(ID_VIEW_REG, OnRegistration)
  47. ON_WM_SIZE()
  48. ON_UPDATE_COMMAND_UI(ID_TOOLS_FLY, OnUpdateToolsFly)
  49. ON_COMMAND(ID_TOOLS_FLY, OnToolsFly)
  50. ON_WM_TIMER()
  51. ON_UPDATE_COMMAND_UI(ID_VIEW_STOPFLIGHT, OnUpdateViewStopflight)
  52. ON_COMMAND(ID_VIEW_STOPFLIGHT, OnViewStopflight)
  53. //}}AFX_MSG_MAP
  54. // Standard printing commands
  55. ON_COMMAND(ID_FILE_PRINT, CScrollView::OnFilePrint)
  56. ON_COMMAND(ID_FILE_PRINT_DIRECT, CScrollView::OnFilePrint)
  57. ON_COMMAND(ID_FILE_PRINT_PREVIEW, CScrollView::OnFilePrintPreview)
  58. END_MESSAGE_MAP()
  60. /////////////////////////////////////////////////////////////////////////////
  61. // TIFFView construction/destruction
  63. TIFFView::TIFFView() : m_cs(0,0)
  64. {
  65. m_shownImage = 0;
  66. g_view = this;
  67. m_leftDown = false;
  68. m_isGeo = false;
  69. m_scaleFactor = 1.0;
  70. m_view2D = true;
  71. m_registrationMode = false;
  72. }
  74. TIFFView::~TIFFView()
  75. {
  76. }
  78. BOOL TIFFView::PreCreateWindow(CREATESTRUCT& cs)
  79. {
  80. // TODO: Modify the Window class or styles here by modifying
  81. //  the CREATESTRUCT cs
  83. return CScrollView::PreCreateWindow(cs);
  84. }
  86. /////////////////////////////////////////////////////////////////////////////
  87. // TIFFView drawing
  89. void TIFFView::OnDraw(CDC* pDC)
  90. {
  91. TIFFDoc* pDoc = GetDocument();
  92. ASSERT_VALID(pDoc);
  94. if (pDC->IsPrinting())
  95. {
  96. DIBSection * dib = GetDocument()->GetDIB(m_shownImage);
  97. if (dib && dib->IsCreated())
  98. {
  99. int wpix = pDC->GetDeviceCaps(HORZRES);
  100. int hpix = pDC->GetDeviceCaps(VERTRES);
  101. int imgWidth = dib->Width();
  102. int imgHeight = dib->Height();
  104. double horzScale = (double)wpix / (double)imgWidth;
  105. double vertScale = (double)hpix / (double)imgHeight;
  107. DIBSection tmpDIB;
  109. if (horzScale < vertScale)
  110. {
  111. hpix = (int)(imgHeight*horzScale);
  112. }
  113. else
  114. {
  115. wpix = (int)(imgWidth*vertScale);
  116. }
  118. BeginWaitCursor();
  119. {
  120. dib->ResizeImage(tmpDIB, wpix, hpix);
  121. }
  122. EndWaitCursor();
  124. pDC->BitBlt( 0, 0, wpix, hpix, tmpDIB.GetDC(), 0, 0, SRCCOPY);
  125. }
  126. }
  127. else
  128. {
  129. ShowImage();
  130. }
  131. }
  133. void TIFFView::StretchImage(double scale_factor)
  134. {
  135. if (m_view2D)
  136. {
  137. double delta = fabs(scale_factor - m_scaleFactor);
  139. if (delta > 0.01)
  140. {
  141. DIBSection * dib = GetDocument()->GetDIB(m_shownImage);
  142. if (dib && dib->IsCreated())
  143. {
  144. int w = (int)(0.50 + scale_factor * dib->Width());
  145. int h = (int)(0.50 + scale_factor * dib->Height());
  147. BeginWaitCursor();
  148. {
  149. dib->ResizeImage(m_viewDIB, w, h);
  150. }
  151. EndWaitCursor();
  153. m_cs.cx = w;
  154. m_cs.cy = h;
  156. SetScrollSizes(MM_TEXT, m_cs);
  158. ShowImage();
  159. }
  161. m_scaleFactor = scale_factor;
  162. }
  163. }
  164. else
  165. {
  166. m_view_matrix = m_earth3D.GetModelState();
  167. m_view_matrix.SetScale(scale_factor,scale_factor,scale_factor);
  168. m_earth3D.SetModelState(m_view_matrix);
  170. ShowImage();
  171. }
  172. }
  174. void TIFFView::Stretched2Unstretched(int xin, int yin, int& xout, int& yout)
  175. {
  176. xout = (int)(0.50 + (double)xin / m_scaleFactor);
  177. yout = (int)(0.50 + (double)yin / m_scaleFactor);
  178. }
  180. void TIFFView::OnInitialUpdate()
  181. {
  182. CScrollView::OnInitialUpdate();
  184. CSize sizeTotal;
  186. sizeTotal.cx = sizeTotal.cy = 100;
  187. SetScrollSizes(MM_TEXT, sizeTotal);
  189. if (m_dlg.m_hWnd == NULL)
  190. {
  191. m_dlg.Create(IDD_TIFFDIR_DLG, this);
  192. }
  194. if (!m_earth3D.IsInitialized())
  195. {
  196. CRect r;
  197. GetClientRect(&r);
  198. m_earth3D.CreateImage(r.Width(),r.Height());
  199. //m_earth3D.RebuildEarth();
  200. //m_earth3D.RebuildTexture();
  201. }
  203. //DIBSection tmpDIB;
  204. //OpenIJG2DIB("land1024x512.jpg",tmpDIB);
  205. //m_earth3D.SetTexture(tmpDIB);
  207. TIFFFrame * frm = (TIFFFrame *)GetParentFrame();
  208. if (frm)
  209. {
  210. frm->HideList();
  211. }
  212. }
  214. void TIFFView::ShowImage(void)
  215. {
  216. if (m_view2D)
  217. {
  218. if (m_viewDIB.IsCreated())
  219. {
  220. CClientDC dc(this);
  221. CPoint sp = GetScrollPosition();
  223. CRect r;
  224. GetClientRect(&r);
  225. UINT32 w = m_viewDIB.Width();
  226. UINT32 h = m_viewDIB.Height();
  228. if (w < r.Width())
  229. {
  230. dc.PatBlt(w,0,r.Width(),r.Height(), WHITENESS);
  231. }
  233. if (h < r.Height())
  234. {
  235. dc.PatBlt(0,h,r.Width(),r.Height(), WHITENESS);
  236. }
  238. m_viewDIB.Draw(&dc, sp.x, sp.y);
  240. PlotClickPoints(dc);
  241. }
  242. }
  243. else
  244. {
  245. if (m_earth3D.IsInitialized())
  246. {
  247. m_earth3D.RenderImage();
  248. m_earth3D.DrawImage(this);
  249. }
  250. }
  251. }
  253. void TIFFView::PlotClickPoints(CClientDC& dc)
  254. {
  255. if (m_isGeo)
  256. {
  257. double x, y;
  258. COLORREF cr = RGB(255,64,64);
  259. COLORREF cr2 = RGB(255,255,255);
  261. CPoint sp = GetScrollPosition();
  263. int size = m_pts.size();
  264. for (int i = 0; i < size; i++){
  265. m_utmProj.forward(m_pts[i].m_lat,m_pts[i].m_lon,x,y);
  266. x -= m_gr.m_tieX;
  267. y = m_gr.m_tieY - y;
  269. x /= m_gr.m_resX;
  270. y /= m_gr.m_resY;
  272. x *= m_scaleFactor;
  273. y *= m_scaleFactor;
  275. x -= sp.x;
  276. y -= sp.y;
  278. dc.FillSolidRect((int)x-2,(int)y-2,6,6,cr2);
  279. dc.FillSolidRect((int)x-3,(int)y-3,6,6,cr);
  280. }
  281. }
  282. }
  284. /////////////////////////////////////////////////////////////////////////////
  285. // TIFFView printing
  287. BOOL TIFFView::OnPreparePrinting(CPrintInfo* pInfo)
  288. {
  289. // default preparation
  290. return DoPreparePrinting(pInfo);
  291. }
  293. void TIFFView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  294. {
  295. // TODO: add extra initialization before printing
  296. }
  298. void TIFFView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  299. {
  300. // TODO: add cleanup after printing
  301. }
  303. /////////////////////////////////////////////////////////////////////////////
  304. // TIFFView diagnostics
  306. #ifdef _DEBUG
  307. void TIFFView::AssertValid() const
  308. {
  309. CScrollView::AssertValid();
  310. }
  312. void TIFFView::Dump(CDumpContext& dc) const
  313. {
  314. CScrollView::Dump(dc);
  315. }
  317. TIFFDoc* TIFFView::GetDocument() // non-debug version is inline
  318. {
  319. ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(TIFFDoc)));
  320. return (TIFFDoc*)m_pDocument;
  321. }
  322. #endif //_DEBUG
  324. /////////////////////////////////////////////////////////////////////////////
  325. // TIFFView message handlers
  327. void TIFFView::OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint) 
  328. {
  329. bool showList = false;
  331. m_pts.clear();
  332. TIFFDoc * doc = GetDocument();
  333. if (doc)
  334. {
  335. TIFFFrame * frm = (TIFFFrame *)GetParentFrame();
  336. if (frm)
  337. {
  338. frm->HideList();
  339. }
  340. ArrayContainer<DIBSection *> * dibs = doc->GetDIBs();
  341. if (dibs)
  342. {
  343. int size = dibs->GetSize();
  344. m_dlg.SetImageCount(size);
  346. m_shownImage = 0;
  348. if (size > 1)
  349. {
  350. showList = true;
  351. }
  353. DIBSection * dib = doc->GetDIB(m_shownImage);
  355. m_isGeo = false;
  357. if (dib && dib->IsCreated())
  358. {
  359. m_isGeo = dib->IsGeoImage();
  361. int w = (int)(0.50 + m_scaleFactor * dib->Width());
  362. int h = (int)(0.50 + m_scaleFactor * dib->Height());
  364. BeginWaitCursor();
  365. {
  366. dib->ResizeImage(m_viewDIB, w, h);
  367. }
  368. EndWaitCursor();
  370. m_cs.cx = w;
  371. m_cs.cy = h;
  373. if (m_isGeo)
  374. {
  375. m_gr = dib->GetGeoReference();
  376. m_isGeo = true;
  378. string ellps;
  380. switch (m_gr.m_ellipse){
  381. case GEORef::Clarke1866:
  382. {
  383. ellps = "clrk66";
  384. }
  385. break;
  386. case GEORef::WGS84:
  387. {
  388. ellps = "WGS84";
  389. }
  390. break;
  391. case GEORef::WGS72:
  392. {
  393. ellps = "WGS72";
  394. }
  395. break;
  396. case GEORef::UnknownEllipsoid:
  397. {
  398. ellps = "WGS84";
  399. }
  400. break;
  401. }
  403. m_utmProj.setup(m_gr.m_zone,ellps.c_str());
  405. m_earth3D.SetGeoImage(dib, &m_utmProj);
  406. m_earth3D.RebuildImage();
  407. }
  408. }
  409. else
  410. {
  411. CRect r;
  412. GetClientRect(&r);
  413. m_cs.cx = r.Width();
  414. m_cs.cy = r.Height();
  415. }
  417. SetScrollSizes(MM_TEXT, m_cs);
  419. InvalidateRect(NULL, true);
  420. }
  421. }
  423. if (m_dlg.m_hWnd)
  424. {
  425. m_dlg.ShowWindow( showList ? SW_SHOW : SW_HIDE );
  426. m_dlg.UpdateList();
  427. }
  428. }
  430. void TIFFView::SetImage(UINT32 ndx)
  431. {
  432. DIBSection * dib = GetDocument()->GetDIB(ndx);
  433. if (dib && dib->IsCreated())
  434. {
  435. int w = (int)(0.50 + m_scaleFactor * dib->Width());
  436. int h = (int)(0.50 + m_scaleFactor * dib->Height());
  438. BeginWaitCursor();
  439. {
  440. dib->ResizeImage(m_viewDIB, w, h);
  441. }
  442. EndWaitCursor();
  444. m_cs.cx = w;
  445. m_cs.cy = h;
  447. SetScrollSizes(MM_TEXT, m_cs);
  449. m_shownImage = ndx;
  451. ShowImage();
  452. }
  453. }
  455. void TIFFView::OnLButtonDown(UINT nFlags, CPoint point) 
  456. {
  457. if (m_registrationMode)
  458. {
  459. CPoint sp = GetScrollPosition();
  460. point.x += sp.x;
  461. point.y += sp.y;
  463. int xout, yout;
  465. Stretched2Unstretched(point.x,point.y,xout,yout);
  467. if (m_isGeo)
  468. {
  469. double lat, lon;
  471. if (m_view2D)
  472. {
  473. double x = m_gr.m_tieX+m_gr.m_resX*(double)xout;
  474. double y = m_gr.m_tieY-m_gr.m_resY*(double)yout;
  476. m_utmProj.inverse(x,y,lat,lon);
  478. RegPtDLG dlg;
  479. dlg.SetPosition(lat,lon);
  480. if (dlg.DoModal() == IDOK)
  481. {
  482. ClickPoint pt(dlg.GetLat(),dlg.GetLon(),dlg.GetName(),dlg.GetAltitude());
  483. m_pts.push_back(pt);
  485. TIFFFrame * frm = (TIFFFrame *)GetParentFrame();
  486. if (frm)
  487. {
  488. frm->UpdateList();
  489. frm->ShowList();
  490. }
  492. ShowImage();
  493. }
  494. }
  495. else
  496. {
  497. int id;
  498. m_earth3D.PickObject(point.x,point.y,id);
  499. if (m_earth3D.PickedPoint())
  500. {
  501. lat = m_earth3D.GetPickedLat();
  502. lon = m_earth3D.GetPickedLon();
  504. RegPtDLG dlg;
  506. dlg.SetPosition(lat,lon);
  508. if (dlg.DoModal() == IDOK)
  509. {
  510. ClickPoint pt(dlg.GetLat(),dlg.GetLon(),dlg.GetName(),dlg.GetAltitude());
  511. m_pts.push_back(pt);
  513. TIFFFrame * frm = (TIFFFrame *)GetParentFrame();
  514. if (frm)
  515. {
  516. frm->UpdateList();
  517. frm->ShowList();
  518. }
  520. ShowImage();
  521. }
  522. }
  523. }
  524. }
  526. m_registrationMode = false;
  527. }
  528. else
  529. {
  530. m_leftDown = true;
  531. m_clickPoint = point;
  533. if (m_view2D)
  534. {
  535. }
  536. else
  537. {
  538. m_view_matrix = m_earth3D.GetModelState();
  539. }
  540. }
  542. CScrollView::OnLButtonDown(nFlags, point);
  543. }
  545. void TIFFView::OnLButtonUp(UINT nFlags, CPoint point) 
  546. {
  547. m_leftDown = false;
  549. //CScrollView::OnLButtonUp(nFlags, point);
  550. }
  552. void TIFFView::OnMouseMove(UINT nFlags, CPoint point) 
  553. {
  554. CPoint sp = GetScrollPosition();
  556. memset(m_status, 0, (size_t)80);
  557. memset(m_status1, 0, (size_t)80);
  558. memset(m_status2, 0, (size_t)80);
  559. memset(m_status3, 0, (size_t)80);
  561. if (m_view2D)
  562. {
  563. if (m_leftDown)
  564. {
  565. int xDelta = point.x - m_clickPoint.x;
  566. int yDelta = point.y - m_clickPoint.y;
  567. m_clickPoint = point;
  569. sp.x -= xDelta;
  570. sp.y -= yDelta;
  572. sp.x =  (sp.x < 0) ? 0 : sp.x;
  573. sp.y = (sp.y < 0) ? 0 : sp.y;
  576. sp.x = (sp.x > m_cs.cx) ? m_cs.cx : sp.x;
  577. sp.y = (sp.y > m_cs.cy) ? m_cs.cy : sp.y;
  579. CRect r;
  580. GetClientRect(&r);
  582. int spxMax = m_viewDIB.Width() - r.Width();
  583. int spyMax = m_viewDIB.Height() - r.Height();
  585. if (spxMax < 0) spxMax = 0;
  586. if (spyMax < 0) spyMax = 0;
  588. sp.x = (sp.x < spxMax) ? sp.x : spxMax;
  589. sp.y = (sp.y < spyMax) ? sp.y : spyMax;
  591. ScrollToPosition(sp);
  592. ShowImage();
  593. }
  595. int xin = sp.x + point.x;
  596. int yin = sp.y + point.y;
  597. int xout, yout;
  599. Stretched2Unstretched( xin, yin, xout, yout );
  601. sprintf(m_status1,"%dx%d", xin, yin);
  603. if (g_statusBar)
  604. {
  605. g_statusBar->SetPaneText(1, m_status1);
  606. }
  608. if (m_isGeo)
  609. {
  610. double lat, lon;
  611. double x = m_gr.m_tieX+m_gr.m_resX*(double)xout;
  612. double y = m_gr.m_tieY-m_gr.m_resY*(double)yout;
  614. sprintf(m_status2,"( %.1f, %.1f )",x,y);
  616. m_utmProj.inverse(x,y,lat,lon);
  618. INT32 latDeg, latMin, lonDeg, lonMin;
  619. double latSec, lonSec;
  621. m_utmProj.DD2DMS(lat,latDeg,latMin,latSec);
  622. m_utmProj.DD2DMS(lon,lonDeg,lonMin,lonSec);
  624. sprintf(m_status3,"( %d-%.2d-%2.1f %c, %d-%.2d-%2.1f %c )",
  625. latDeg,latMin,latSec,(lat<0.0)?'S':'N', lonDeg, lonMin, lonSec,
  626. (lon<0.0)?'W':'E');
  627. }
  628. }
  629. else
  630. {
  631. if (m_leftDown)
  632. {
  633. int xdiff = point.x - m_clickPoint.x;
  634. int ydiff = point.y - m_clickPoint.y;
  636. double yrot = (double)xdiff/9.0;
  637. double xrot = (double)ydiff/9.0;
  638. double zrot = 0.0;
  640. while (xrot < 0.0) xrot += 360.0;
  641. while (xrot > 360.0) xrot -= 360.00000001;
  643. while (yrot < 0.0) yrot += 360.0;
  644. while (yrot > 360.0) yrot -= 360.00000001;
  646. Matrix3D mat = m_view_matrix;
  647. mat.AddRotation(xrot,yrot,zrot);
  649. m_earth3D.SetModelState(mat);
  651. ShowImage();
  652. }
  653. }
  655. if (g_statusBar)
  656. {
  657. g_statusBar->SetPaneText(2, m_status2);
  658. g_statusBar->SetPaneText(3, m_status3);
  659. }
  661. CScrollView::OnMouseMove(nFlags, point);
  662. }
  664. void TIFFView::OnUpdateImageList(CCmdUI* pCmdUI) 
  665. {
  666. pCmdUI->Enable();
  667. pCmdUI->SetCheck(m_dlg.IsWindowVisible());
  668. }
  670. void TIFFView::OnImageList() 
  671. {
  672. m_dlg.ShowWindow(m_dlg.IsWindowVisible() ? SW_HIDE : SW_SHOW);
  673. }
  676. void TIFFView::OnUpdateView2D(CCmdUI* pCmdUI) 
  677. {
  678. pCmdUI->Enable();
  679. pCmdUI->SetCheck(m_view2D);
  680. }
  682. void TIFFView::OnView2D() 
  683. {
  684. m_view2D = true;
  685. m_registrationMode = false;
  687. CSize cs;
  688. cs.cx = m_viewDIB.Width();
  689. cs.cy = m_viewDIB.Height();
  691. SetScrollSizes(MM_TEXT, cs);
  693. ShowImage();
  694. }
  696. void TIFFView::OnUpdateView3D(CCmdUI* pCmdUI) 
  697. {
  698. pCmdUI->Enable();
  699. pCmdUI->SetCheck(!m_view2D);
  700. }
  702. void TIFFView::OnView3D() 
  703. {
  704. m_view2D = false;
  705. m_registrationMode = false;
  707. CRect r;
  708. GetClientRect(&r);
  709. m_earth3D.SizeImage(r.Width(),r.Height());
  710. m_earth3D.RebuildImage();
  712. //
  713. // we don't want any scroll bars
  714. //
  715. CSize cs;
  716. cs.cx = 5;
  717. cs.cy = 5;
  718. SetScrollSizes(MM_TEXT, cs);
  720. ShowImage();
  721. }
  723. void TIFFView::OnUpdateRegistration(CCmdUI* pCmdUI)
  724. {
  725. pCmdUI->Enable();
  726. }
  728. void TIFFView::OnRegistration(void)
  729. {
  730. m_registrationMode = m_registrationMode ? false : true;
  731. }
  733. void TIFFView::OnSize(UINT nType, int cx, int cy) 
  734. {
  735. CScrollView::OnSize(nType, cx, cy);
  737. if ((cx > 0) && (cy > 0))
  738. {
  739. if (m_view2D)
  740. {
  741. CSize cs;
  742. cs.cx = m_viewDIB.Width();
  743. cs.cy = m_viewDIB.Height();
  745. SetScrollSizes(MM_TEXT, cs);
  746. }
  747. else
  748. {
  749. CRect r;
  750. GetClientRect(&r);
  752. //
  753. // we don't want any scroll bars
  754. //
  755. CSize cs;
  756. cs.cx = 5;
  757. cs.cy = 5;
  758. SetScrollSizes(MM_TEXT, cs);
  760. bool skip = false;
  761. DIBSection * dib = m_earth3D.GetDIB();
  762. if (dib)
  763. {
  764. if ((dib->Width() == r.Width()) && (dib->Height() == r.Height()))
  765. skip = true;
  766. }
  768. if (!skip)
  769. {
  770. m_earth3D.SizeImage(r.Width(),r.Height());
  771. m_earth3D.RebuildImage();
  772. m_earth3D.RebuildEarth();
  773. }
  775. ShowImage();
  776. }
  777. }
  778. }
  780. void TIFFView::OnUpdateToolsFly(CCmdUI* pCmdUI) 
  781. {
  782. //
  783. // we only want to enable user to fly if they are in 3D mode,
  784. // and if the image they are looking at is a geo image, and if
  785. // they have defined some points to fly...
  786. //
  787. bool showFlyMenu = m_view2D ? false : (m_pts.size()>1) ? m_isGeo : false;
  788. pCmdUI->Enable(showFlyMenu);
  789. }
  791. void TIFFView::OnToolsFly() 
  792. {
  793. FlightDLG dlg;
  794. if (dlg.DoModal() == IDOK)
  795. {
  796. m_flyFirstPerson = dlg.GetFirstPerson();
  797. m_flyDuration = dlg.GetDuration();
  799. // basically going to setup 100 equally spaced points along the
  800. // route (i.e. from the first point to the last)
  801. m_totalFrames = 100;
  803. double dx, u[3], v[3], lat1, lon1, lat2, lon2, alt1, alt2;
  804. double D = 0.0;
  805. int i, j;
  806. int size = m_pts.size();
  808. for (i = 0; i < (size-1); i++){
  809. lat1 = m_pts[i].m_lat;
  810. lon1 = m_pts[i].m_lon;
  811. lat2 = m_pts[i+1].m_lat;
  812. lon2 = m_pts[i+1].m_lon;
  813. D += GeoCalc::GCDistance(lat1,lon1,lat2,lon2);
  814. }
  816. // dividing the total distance by the number of divisions
  817. dx = D / (m_totalFrames-1);
  819. // following loop sets up the individual way points to fly through
  820. // ultimately we will be interpolating between these points.
  821. V3D v3d;
  823. m_flyWayPoints.clear();
  825. for (i = 0; i < (size-1); i++){
  826. lat1 = m_pts[i].m_lat;
  827. lon1 = m_pts[i].m_lon;
  828. lat2 = m_pts[i+1].m_lat;
  829. lon2 = m_pts[i+1].m_lon;
  830. alt1 = m_pts[i].m_alt;
  831. alt2 = m_pts[i+1].m_alt;
  833. int total = (int)GeoCalc::GCDistance(lat1,lon1,lat2,lon2)/dx;
  835. m_earth3D.GeoToXYZ(lat1, lon1, u[0], u[1], u[2],1.0 + alt1/GEO::ERADM);
  836. m_earth3D.GeoToXYZ(lat2, lon2, v[0], v[1], v[2],1.0 + alt2/GEO::ERADM);
  838. for (j = 0; j < total; j++){
  839. double p = (double)j/(double)total;
  840. v3d.m_x = u[0] + p * (v[0] - u[0]);
  841. v3d.m_y = u[1] + p * (v[1] - u[1]);
  842. v3d.m_z = u[2] + p * (v[2] - u[2]);
  843. m_flyWayPoints.push_back(v3d);
  844. }
  845. }
  847. // get the start time (in ticks)
  848. m_flyStart = GetTickCount();
  849. m_earth3D.SetFlyMode(true);
  851. SetTimer(m_flyTimer, 3, NULL);
  852. }
  853. }
  855. void TIFFView::OnTimer(UINT nIDEvent) 
  856. {
  857. if (nIDEvent == m_flyTimer)
  858. {
  859. UINT32 ticks = GetTickCount();
  860. double comp = (double)m_flyWayPoints.size() * (double)(ticks - m_flyStart)/((double)m_flyDuration*1000.0);
  862. if (comp < (double)(m_flyWayPoints.size() - 1))
  863. {
  864. double u[3], v[3];
  866. UINT32 last = (UINT32)comp;
  867. UINT32 next = last + 1;
  869. // interpolate the current position
  870. u[0] = m_flyWayPoints[last].m_x + (comp - (double)last) * (m_flyWayPoints[next].m_x - m_flyWayPoints[last].m_x);
  871. u[1] = m_flyWayPoints[last].m_y + (comp - (double)last) * (m_flyWayPoints[next].m_y - m_flyWayPoints[last].m_y);
  872. u[2] = m_flyWayPoints[last].m_z + (comp - (double)last) * (m_flyWayPoints[next].m_z - m_flyWayPoints[last].m_z);
  874. // this is an attempt to make the turns a little smoother
  875. if (last < 98)
  876. next++;
  878. // v is the where the nose of the airplane is pointing to
  879. v[0] = m_flyWayPoints[next].m_x;
  880. v[1] = m_flyWayPoints[next].m_y;
  881. v[2] = m_flyWayPoints[next].m_z;
  883. // setting the position, the look-at point, and the flight mode
  884. m_earth3D.SetFlyPosition(u,v,m_flyFirstPerson);
  885. m_earth3D.RenderImage();
  886. m_earth3D.DrawImage(this);
  887. }
  888. else
  889. {
  890. KillTimer(m_flyTimer);
  892. m_earth3D.SetFlyMode(false);
  893. m_earth3D.RebuildImage();
  894. m_flyWayPoints.clear();
  895. ShowImage();
  896. }
  897. }
  899. CScrollView::OnTimer(nIDEvent);
  900. }
  902. void TIFFView::OnUpdateViewStopflight(CCmdUI* pCmdUI) 
  903. {
  904. pCmdUI->Enable(m_earth3D.GetFlyMode());
  905. }
  907. void TIFFView::OnViewStopflight() 
  908. {
  909. KillTimer(m_flyTimer);
  910. m_flyWayPoints.clear();
  911. m_earth3D.SetFlyMode(false);
  912. m_earth3D.RebuildImage();
  913. ShowImage();
  914. }