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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 分形几何 > 查看源码
dtriangulationView.cpp
资源名称：package.rar　[点击查看]
上传用户：chinasdcnc
上传日期：2022-07-02
资源大小：2702k
文件大小：28k
源码类别：

分形几何

开发平台：

Visual C++

dtriangulationView.cpp：源码内容
  1. // dtriangulationView.cpp : CdtriangulationView 类的实现
  2. //
  4. #include "stdafx.h"
  5. #include "dtriangulation.h"
  6. #include "dcel.h"
  8. #include "dtriangulationDoc.h"
  9. #include "dtriangulationView.h"
  10. #include "GenPoints.h"
  11. #include "utility.h"
  12. #include <vector>
  14. #include "base.h"
  16. #include <stdlib.h>
  17. #include <time.h>
  19. #include <gl/GL.h>
  20. #include <gl/GLU.h>
  22. using namespace std;
  23. #ifdef _DEBUG
  24. #define new DEBUG_NEW
  25. #endif
  27. #define MAXMANINPUTPOINTS 1000
  29. // CdtriangulationView
  31. IMPLEMENT_DYNCREATE(CdtriangulationView, CView)
  33. BEGIN_MESSAGE_MAP(CdtriangulationView, CView)
  34. // 标准打印命令
  35. ON_COMMAND(ID_FILE_PRINT, &CView::OnFilePrint)
  36. ON_COMMAND(ID_FILE_PRINT_DIRECT, &CView::OnFilePrint)
  37. ON_COMMAND(ID_FILE_PRINT_PREVIEW, &CView::OnFilePrintPreview)
  38.     ON_COMMAND(ID_GENERATEPOINTS, &CdtriangulationView::OnGeneratePoints)
  39.     ON_COMMAND(ID_INPUTPOINTS, &CdtriangulationView::OnInputPoints)
  40.     ON_WM_LBUTTONDOWN()
  41.     ON_COMMAND(ID_TRIANGULATION, &CdtriangulationView::OnTriangulation)
  42.     ON_COMMAND(ID_FILE_NEW, &CdtriangulationView::OnFileNew)
  43.     ON_COMMAND(ID_FILE_OPEN, &CdtriangulationView::OnFileOpen)
  44.     ON_COMMAND(ID_FILE_SAVE, &CdtriangulationView::OnFileSave)
  45. ON_WM_KEYDOWN()
  46.     ON_WM_CREATE()
  47.     ON_WM_DESTROY()
  48.     ON_WM_ERASEBKGND()
  49.     ON_WM_SIZE()
  50. ON_WM_LBUTTONUP()
  51.     ON_COMMAND(ID_DCEL_TEST, &CdtriangulationView::OnDcelTest)
  52. ON_COMMAND(ID_CIRCLE_TEST, &CdtriangulationView::OnCircleTest)
  53.     ON_WM_MOUSEMOVE()
  54.     ON_COMMAND(ID_SHOW_ENLARGE, &CdtriangulationView::OnShowEnlarge)
  55.     ON_COMMAND(ID_SHOW_REVERT, &CdtriangulationView::OnShowRevert)
  56.     ON_WM_TIMER()
  57. ON_COMMAND(ID_DT_DEMO, &CdtriangulationView::OnDtDemo)
  58. END_MESSAGE_MAP()
  60. // CdtriangulationView 构造/析构
  62. CdtriangulationView::CdtriangulationView()
  63. {
  64.     isManInputState = false;
  65.     isLButtonDown = false;
  66.     isTest = false;
  67. isCircleTest = false;
  68.     isEnLarge = true;
  69.     isOne = false;
  70.     isPro = false;
  71. isDTDemo = false;
  72. circleTri = NULL;
  73. }
  75. CdtriangulationView::~CdtriangulationView()
  76. {
  77.     testTris.clear();
  78. }
  80. BOOL CdtriangulationView::PreCreateWindow(CREATESTRUCT& cs)
  81. {
  82. //  CREATESTRUCT cs 来修改窗口类或样式
  84. return CView::PreCreateWindow(cs);
  85. }
  87. // CdtriangulationView 绘制
  89. void CdtriangulationView::OnDraw(CDC* pDC)
  90. {
  91. CdtriangulationDoc* pDoc = GetDocument();
  92. ASSERT_VALID(pDoc);
  93. if (!pDoc)
  94. return;
  96. wglMakeCurrent(pDC->m_hDC, m_hRC);
  98.     glClearColor(1.0, 1.0, 1.0, 1.0);
  99.     glClear(GL_COLOR_BUFFER_BIT);
  101.     glMatrixMode(GL_MODELVIEW);
  102.     glLoadIdentity();
  104. // draw points
  105.     glColor4f(1.0, 0.0, 0.0, 1.0);
  106.     glPointSize(3.0f);
  107.     glBegin(GL_POINTS);
  109. for(int i = 0; i < pDoc->nPoints; ++i)
  110.         glVertex2d(pDoc->point(i)->x, pDoc->point(i)->y);
  112.     glEnd();
  114.     // draw lines
  115. if(pDoc->myDT.isFinished)
  116. {
  117. drawDT(pDoc->myDT.maxEdge.le);
  118. drawDT(pDoc->myDT.maxEdge.re);
  119. resetVisitedState(pDoc->myDT.maxEdge.le);
  120. resetVisitedState(pDoc->myDT.maxEdge.re);
  121. }
  123. // draw dt demo
  124. if(isDTDemo)
  125. {
  126. std::vector<MaxEdge>::iterator iter;
  127. //while(!maxEdges.empty())
  128. //{
  129. for(iter = maxEdges.begin(); iter != maxEdges.end(); iter++)
  130. {
  131. drawDT((*iter).le);
  132. drawDT((*iter).re);
  133. resetVisitedState((*iter).le);
  134. resetVisitedState((*iter).re);
  135. }
  136.     
  137. //}
  139. }
  142. // draw circle test
  143. if (isCircleTest && circleTri != NULL)
  144. {
  145.     GLUquadric* qd = gluNewQuadric();
  146.     glColor4f(0.4f, 0.0f, 1.0f, 0.4f);
  147.     gluQuadricDrawStyle(qd, GLU_FILL);
  148.     glPushMatrix();
  149.     glTranslated(cirTestCenter.x, cirTestCenter.y, 0.0);
  150.     gluDisk(qd, 0.0, cirTestRadius, 50, 4);
  151.     glPopMatrix();
  152.     gluDeleteQuadric(qd);
  153. }
  155.     // draw DCEL test
  156.     if(testTris.size() > 0 && isTest)
  157.     {
  158.         // draw tris
  159.         Point2d ps[3];
  160.         vector<Edge *>::iterator iter;
  161.         Edge *initEdge, *circleEdge;
  162.         int i;
  163.         glColor4f(0.0, 1.0f, 0.0, 0.3f);
  164.         glBegin(GL_TRIANGLES);
  165.         if (!isPro)
  166.         {
  167.             for(iter = testTris.begin(); iter != testTris.end(); ++iter)
  168.             {
  169.                 initEdge = *iter;
  170.                 circleEdge = initEdge;
  171.                 i = 0;
  172.                 do
  173.                 {
  174.                     ps[i].x = circleEdge->org2d().x;
  175.                     ps[i].y = circleEdge->org2d().y;
  176.                     ++i;
  177.                     circleEdge = circleEdge->lNext();
  178.                 }while(circleEdge != initEdge);
  180.                 glVertex2d(ps[0].x, ps[0].y);
  181.                 glVertex2d(ps[1].x, ps[1].y);
  182.                 glVertex2d(ps[2].x, ps[2].y);
  183.             }
  184.         }
  185.         else
  186.         {
  187.             int tmp = 0;
  188.             for(iter = testTris.begin(); iter != testTris.end(); ++iter)
  189.             {
  190.                 if (tmp++ > tempCount)
  191.                     break;
  193.                 initEdge = *iter;
  194.                 circleEdge = initEdge;
  195.                 i = 0;
  196.                 do
  197.                 {
  198.                     ps[i].x = circleEdge->org2d().x;
  199.                     ps[i].y = circleEdge->org2d().y;
  200.                     ++i;
  201.                     circleEdge = circleEdge->lNext();
  202.                 }while(circleEdge != initEdge);
  204.                 glVertex2d(ps[0].x, ps[0].y);
  205.                 glVertex2d(ps[1].x, ps[1].y);
  206.                 glVertex2d(ps[2].x, ps[2].y);
  207.             }
  208.         }
  209.         glEnd();
  210.     }
  212. if (isTest)
  213. {
  214.         // draw test line
  215.         glColor4f(1.0, 0.0, 1.0, 1.0);
  216.         glBegin(GL_LINES);
  217.         glVertex2d(startTestPoint.x, startTestPoint.y);
  218.         glVertex2d(finishTestPoint.x, finishTestPoint.y);
  219.         glEnd();
  220. }
  222.     if (isTest && isLButtonDown && isEnLarge)
  223.     {
  224.         // draw temp test line
  225.         glColor4f(1.0, 0.0, 1.0, 1.0);
  226.         glBegin(GL_LINES);
  227.         glVertex2d(startTestPoint.x, startTestPoint.y);
  228.         glVertex2d(tempTestPoint.x, tempTestPoint.y);
  229.         glEnd();
  230.     }
  231.     else if (isLButtonDown && !isEnLarge && isOne)
  232.     {
  233.         // draw rectangle
  234.         glColor4f(0.0f, 0.0, 1.0f, 0.4f);
  235.         glBegin(GL_QUADS);
  236.         glVertex2d(startRectPoint.x, startRectPoint.y);
  237.         glVertex2d(startRectPoint.x, tempRectPoint.y);
  238.         glVertex2d(tempRectPoint.x, tempRectPoint.y);
  239.         glVertex2d(tempRectPoint.x, startRectPoint.y);
  240.         glEnd();
  241.     }
  243.     glFlush();
  244.     SwapBuffers(pDC->m_hDC);
  245.     wglMakeCurrent(NULL, NULL);
  246. }
  248. // CdtriangulationView 打印
  250. BOOL CdtriangulationView::OnPreparePrinting(CPrintInfo* pInfo)
  251. {
  252. // 默认准备
  253. return DoPreparePrinting(pInfo);
  254. }
  256. void CdtriangulationView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  257. {
  258. // TODO: 添加额外的打印前进行的初始化过程
  259. }
  261. void CdtriangulationView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  262. {
  263. // TODO: 添加打印后进行的清除过程
  264. }
  266. void CdtriangulationView::resetVisitedState(Edge* e)
  267. {
  268.     DCEL *pDcel;
  269. Edge *edge;
  271. std::stack<Edge *>dcelStack;
  272. dcelStack.push(e);
  273. while(!dcelStack.empty())
  274. {
  275. edge = dcelStack.top();
  276. pDcel = (DCEL *)(edge->qEdge());
  277. dcelStack.pop();
  278.     if(pDcel->visited)
  279. {
  280. pDcel->visited = false;
  281.  
  282. dcelStack.push(edge->oNext());
  283. dcelStack.push(edge->oPrev());
  284. dcelStack.push(edge->dNext());
  285. dcelStack.push(edge->dPrev());
  286. }
  287. }
  290. }
  291. void CdtriangulationView::drawDT(Edge* e)
  292. {
  293.     CdtriangulationDoc* pDoc = GetDocument();
  294. DCEL *pDcel;
  295. Edge *edge;
  297. std::stack<Edge *>dcelStack;
  298. dcelStack.push(e);
  300.     glColor4f(0.0, 0.0, 0.0, 0.5);
  301.     glBegin(GL_LINES);
  303. while(!dcelStack.empty())
  304. {
  305. edge = dcelStack.top();
  306. pDcel = (DCEL *)(edge->qEdge());
  307. dcelStack.pop();
  308.     if(!pDcel->visited)
  309. {
  310.             glVertex2d(edge->org()->x, edge->org()->y);
  311.             glVertex2d(edge->dest()->x, edge->dest()->y);
  313. pDcel->visited = true;
  314. dcelStack.push(edge->oNext());
  315. dcelStack.push(edge->oPrev());
  316. dcelStack.push(edge->dNext());
  317. dcelStack.push(edge->dPrev());
  318. }
  319. }
  320.     glEnd();
  321. }
  326. // CdtriangulationView 诊断
  328. #ifdef _DEBUG
  329. void CdtriangulationView::AssertValid() const
  330. {
  331. CView::AssertValid();
  332. }
  334. void CdtriangulationView::Dump(CDumpContext& dc) const
  335. {
  336. CView::Dump(dc);
  337. }
  339. CdtriangulationDoc* CdtriangulationView::GetDocument() const // 非调试版本是内联的
  340. {
  341. ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CdtriangulationDoc)));
  342. return (CdtriangulationDoc*)m_pDocument;
  343. }
  344. #endif //_DEBUG
  346. // CdtriangulationView 消息处理程序
  348. void CdtriangulationView::OnGeneratePoints(void)
  349. {
  350.     isManInputState = false;
  351.     isTest = false;
  352. isCircleTest = false;
  353.     CdtriangulationDoc* pDoc = GetDocument();
  354.     ASSERT_VALID(pDoc);
  355.     if (!pDoc)
  356.         return;
  358.     CGenPoints genPointDlg;
  359.     if (genPointDlg.DoModal() == IDOK)
  360.     {
  361.         pDoc->nPoints = genPointDlg.points;
  362.         if (pDoc->points != NULL)
  363.         {
  364.             pDoc->myDT.destroy();
  365.             delete[] pDoc->points;
  366.         }
  367.         testTris.clear();
  369.         pDoc->points = new Point2d[pDoc->nPoints];
  371.         CRect rect;
  372.         GetClientRect(&rect);
  373.         int maxHeight = rect.Height() - 5, maxWidth = rect.Width() - 5;
  374.         srand(unsigned(time(NULL)));
  375.         for (int i = 0; i < pDoc->nPoints; ++i)
  376.         {
  377.             double px = random(5, maxWidth) + random();
  378.             double py = random(5, maxHeight) + random();
  379.             pDoc->points[i].x = px;
  380.             pDoc->points[i].y = py;
  381.         }
  383.         Invalidate();
  384.     }
  385. }
  387. void CdtriangulationView::OnInputPoints(void)
  388. {
  389.     CdtriangulationDoc* pDoc = GetDocument();
  390.     ASSERT_VALID(pDoc);
  391.     if (!pDoc)
  392.         return;
  394.     if (!isEnLarge)
  395.         return;
  397.     pDoc->nPoints = 0;
  398.     testTris.clear();
  399.     if (pDoc->points != NULL)
  400.     {
  401.         pDoc->myDT.destroy();
  402.         delete[] pDoc->points;
  403.     }
  405.     pDoc->points = new Point2d[MAXMANINPUTPOINTS];
  406.     isManInputState = true;
  407.     isCircleTest = false;
  408.     isTest = false;
  410.     Invalidate();
  411. }
  413. void CdtriangulationView::OnTriangulation(void)
  414. {
  415. QueryPerformanceFrequency(&Freq);
  417.     isManInputState = false;
  418.     isCircleTest = false;
  419.     isTest = false;
  421.     CdtriangulationDoc* pDoc = GetDocument();
  422.     ASSERT_VALID(pDoc);
  423.     if (!pDoc)
  424.         return;
  426.     if (pDoc->nPoints <= 1)
  427.     {
  428.         MessageBox("Not enough points.", "warning");
  429.         return;
  430.     }
  432.     QueryPerformanceCounter(&BeginTime);
  433.     pDoc->myDT.initial(&(pDoc->nPoints), pDoc->points);
  434.     pDoc->myDT.doDelaunayTriangulation();
  435. QueryPerformanceCounter(&EndTime);
  437. // output runtime of delaunay triangulation.
  438. CString s;
  439. s.Format("三角剖分用时:%d us", (EndTime.QuadPart - BeginTime.QuadPart) * 1000000 / Freq.QuadPart);
  440. CStatusBar* pStatusBar = (CStatusBar*)AfxGetMainWnd()->GetDescendantWindow(AFX_IDW_STATUS_BAR);
  441. pStatusBar->SetPaneText(pStatusBar->CommandToIndex(ID_INDICATOR_RUNTIME),s);
  443.     Invalidate();
  444. }
  446. void CdtriangulationView::OnFileNew(void)
  447. {
  448.     isManInputState = false;
  449.     isTest = false;
  451.     CdtriangulationDoc* pDoc = GetDocument();
  452.     ASSERT_VALID(pDoc);
  453.     if (!pDoc)
  454.         return;
  456.     pDoc->nPoints = 0;
  457.     pDoc->myDT.destroy();
  458.     delete[] pDoc->points;
  459.     testTris.clear();
  460.     pDoc->points = NULL;
  462.     CClientDC dc(this);
  463.     wglMakeCurrent(dc.m_hDC, m_hRC);
  465.     glMatrixMode(GL_PROJECTION);
  466.     glLoadIdentity();
  468.     CRect rect;
  469.     GetClientRect(&rect);
  470.     int maxHeight = rect.Height(), maxWidth = rect.Width();
  471.     gluOrtho2D(0, (double)maxWidth, (double)maxHeight, 0);
  473.     glViewport(0, 0, maxWidth, maxHeight);
  475.     wglMakeCurrent(NULL, NULL);
  476.     isEnLarge = true;
  477.     isCircleTest = false;
  478.     isOne = false;
  480.     Invalidate();
  481. }
  483. void CdtriangulationView::OnFileOpen(void)
  484. {
  485.     CFileDialog pCFileDialog(true, NULL, NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
  486.                              TEXT("POINT files (*.point)|*.point|ALL files (*.*)|*.*||"), NULL);
  487.     pCFileDialog.m_ofn.lpstrTitle = TEXT("Open point file");
  489.     USES_CONVERSION;
  491.     if (pCFileDialog.DoModal() == IDOK)
  492.     {
  493.         CString strPathName = pCFileDialog.GetPathName();
  494.         if (!GetDocument()->load(T2A(strPathName.GetBuffer(strPathName.GetLength()))))
  495.         {
  496.             MessageBox(TEXT("Failing to open this file."), TEXT("Warning"));
  497.         }
  498.     }
  499.     isCircleTest = false;
  500.     isTest = false;
  501.     Invalidate();
  502. }
  504. void CdtriangulationView::OnFileSave(void)
  505. {
  506.     CFileDialog pCFileDialog(false, NULL, NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
  507.                              TEXT("POINT files (*.point)|*.point|ALL files (*.*)|*.*||"), NULL);
  508.     pCFileDialog.m_ofn.lpstrTitle = TEXT("Save points file");
  510.     USES_CONVERSION;
  511.     if (pCFileDialog.DoModal() == IDOK)
  512.     {
  513.         CString strPathName = pCFileDialog.GetPathName();
  514.         if (!GetDocument()->save(T2A(strPathName.GetBuffer(strPathName.GetLength()))))
  515.         {
  516.             MessageBox(TEXT("Failing to save this file."), TEXT("Warning"));
  517.         }
  518.     }
  519.     isCircleTest = false;
  520.     isTest = false;
  521.     Invalidate();
  522. }
  524. void CdtriangulationView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  525. {
  526. // TODO: 在此添加消息处理程序代码和/或调用默认值
  527.     isTest = false;
  528.     testTris.clear();
  529.     if(0x0d == nChar)
  530. {
  531. isCircleTest = false;
  532.     CdtriangulationDoc* pDoc = GetDocument();
  533. ASSERT_VALID(pDoc);
  534. if (!pDoc)
  535. return;
  536. if (pDoc->nPoints <= 1)
  537.     pDoc->nPoints = 100;
  538.         if (pDoc->points != NULL)
  539.         {
  540.             pDoc->myDT.destroy();
  541.             delete[] pDoc->points;
  542.         }
  544.         pDoc->points = new Point2d[pDoc->nPoints];
  546.         CRect rect;
  547.         GetClientRect(&rect);
  548.         int maxHeight = rect.Height() - 5, maxWidth = rect.Width() - 5;
  549.         srand(unsigned(time(NULL)));
  550.         for (int i = 0; i < pDoc->nPoints; ++i)
  551.         {
  552.             double px = random(5, maxWidth) + random();
  553.             double py = random(5, maxHeight) + random();
  554.             pDoc->points[i].x = px;
  555.             pDoc->points[i].y = py;
  556.         }
  558.         QueryPerformanceFrequency(&Freq);
  560.         QueryPerformanceCounter(&BeginTime);
  561.         pDoc->myDT.initial(&(pDoc->nPoints), pDoc->points);
  562.         pDoc->myDT.doDelaunayTriangulation();
  563.         QueryPerformanceCounter(&EndTime);
  565.         // output runtime of delaunay triangulation.
  566.         CString s;
  567.         s.Format("%d us", (EndTime.QuadPart - BeginTime.QuadPart) * 1000000 / Freq.QuadPart);
  568.         CStatusBar* pStatusBar = (CStatusBar*)AfxGetMainWnd()->GetDescendantWindow(AFX_IDW_STATUS_BAR);
  569.         pStatusBar->SetPaneText(pStatusBar->CommandToIndex(ID_INDICATOR_RUNTIME),s);
  571.         Invalidate();
  572. }
  573. CView::OnKeyDown(nChar, nRepCnt, nFlags);
  574. }
  576. int CdtriangulationView::OnCreate(LPCREATESTRUCT lpCreateStruct)
  577. {
  578.     if (CView::OnCreate(lpCreateStruct) == -1)
  579.         return -1;
  581.     CClientDC dc(this);
  582.     PIXELFORMATDESCRIPTOR pdf;
  583.     memset(&pdf, 0, sizeof(PIXELFORMATDESCRIPTOR));
  584.     pdf.nSize = sizeof(PIXELFORMATDESCRIPTOR);
  585.     pdf.nVersion = 1;
  586.     pdf.dwFlags = PFD_DRAW_TO_WINDOW |
  587.                   PFD_SUPPORT_OPENGL |
  588.                   PFD_DOUBLEBUFFER;
  589.     pdf.iPixelType = PFD_TYPE_RGBA;
  590.     pdf.cColorBits = 24;
  591.     pdf.cDepthBits = 32;
  592.     int pixelFormat = ChoosePixelFormat(dc.m_hDC, &pdf);
  593.     SetPixelFormat(dc.m_hDC, pixelFormat, &pdf);
  594.     m_hRC = wglCreateContext(dc.m_hDC);
  596.     return 0;
  597. }
  599. void CdtriangulationView::OnDestroy()
  600. {
  601.     CView::OnDestroy();
  603.     wglMakeCurrent(NULL, NULL);
  604.     wglDeleteContext(m_hRC);
  605.     m_hRC = NULL;
  606. }
  608. BOOL CdtriangulationView::OnEraseBkgnd(CDC* pDC)
  609. {
  610.     //return CView::OnEraseBkgnd(pDC);
  611.     return true;
  612. }
  614. void CdtriangulationView::OnSize(UINT nType, int cx, int cy)
  615. {
  616.     CView::OnSize(nType, cx, cy);
  618.     CClientDC dc(this);
  619.     wglMakeCurrent(dc.m_hDC, m_hRC);
  621.     glMatrixMode(GL_PROJECTION);
  622.     glLoadIdentity();
  624.     glEnable(GL_LINE_SMOOTH);
  625.     glEnable(GL_BLEND);
  626.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  627.     glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
  629.     CRect rect;
  630.     GetClientRect(&rect);
  631.     int maxHeight = rect.Height(), maxWidth = rect.Width();
  633.     gluOrtho2D(0, (double)maxWidth, (double)maxHeight, 0);
  635.     glViewport(0, 0, cx, cy);
  637.     wglMakeCurrent(NULL, NULL);
  638. }
  640. void CdtriangulationView::OnLButtonDown(UINT nFlags, CPoint point)
  641. {
  642.     CdtriangulationDoc* pDoc = GetDocument();
  643.     ASSERT_VALID(pDoc);
  644.     if (!pDoc)
  645.         return;
  647.     if (isManInputState)
  648.     {
  649.         if (pDoc->nPoints >= MAXMANINPUTPOINTS)
  650.         {
  651.             MessageBox("Too many input points!", "warning");
  652.         }
  653.         else
  654.         {
  655.             Point2d tp(point.x, point.y);
  656.             pDoc->points[pDoc->nPoints++] = tp;
  657.             Invalidate();
  658.         }
  659.     }
  660.     else if (!isEnLarge)
  661.     {
  662.         startRectPoint.x = point.x;
  663.         startRectPoint.y = point.y;
  664.         isLButtonDown = true;
  665.     }
  666. else if (isTest)
  667. {
  668. testTris.clear();
  669.     startTestPoint.x = point.x;
  670. startTestPoint.y = point.y;
  671.         finishTestPoint.x = point.x;
  672.     finishTestPoint.y = point.y;
  673.         isLButtonDown = true;
  674. }
  675. else if (isCircleTest)
  676. {
  677.     if(pDoc->myDT.isFinished)
  678.     {
  679. circleTri = locate(Point2d(point.x, point.y), pDoc->myDT.maxEdge.le);
  680.     if (circleTri != NULL)
  681. {
  682. circumCircle(circleTri->org2d(), circleTri->next()->org2d(),
  683.          circleTri->next()->dest2d(), &cirTestCenter,
  684.  &cirTestRadius);
  685. Invalidate();
  686. }
  687.     }
  688. }
  690.     CView::OnLButtonDown(nFlags, point);
  691. }
  693. void CdtriangulationView::OnLButtonUp(UINT nFlags, CPoint point)
  694. {
  695. // TODO: 在此添加消息处理程序代码和/或调用默认值
  697.     if (isTest && isEnLarge)
  698.     {
  699.         finishTestPoint.x = point.x;
  700.     finishTestPoint.y = point.y;
  701.     
  702.     CdtriangulationDoc* pDoc = GetDocument();
  703.     ASSERT_VALID(pDoc);
  705.     if(pDoc->myDT.isFinished)
  706.     {
  707.     intersectedTris(startTestPoint, finishTestPoint, testTris, pDoc->myDT.maxEdge.le);
  708.             isPro = true;
  709.             int detal = 100;
  710.             if (pDoc->nPoints > 500)
  711.                 detal = 50;
  712.             else if (pDoc->nPoints > 5000)
  713.                 detal = 10;
  715.             m_nTimer = SetTimer(1, detal, 0);
  716.             tempCount = -1;
  717.     Invalidate();
  718.     }
  719.     }
  720.     else if (isOne && !isEnLarge)
  721.     {
  722.         endRectPoint.x = point.x;
  723.         endRectPoint.y = point.y;
  725.         CClientDC dc(this);
  726.         wglMakeCurrent(dc.m_hDC, m_hRC);
  728.         glMatrixMode(GL_PROJECTION);
  729.         glLoadIdentity();
  731.         CRect rect;
  732.         GetClientRect(&rect);
  733.         int maxHeight = rect.Height(), maxWidth = rect.Width();
  735.         double maxw = getMax(startRectPoint.x, endRectPoint.x);
  736.         double minw = getMin(startRectPoint.x, endRectPoint.x);
  737.         double maxh = getMax(startRectPoint.y, endRectPoint.y);
  738.         double minh = getMin(startRectPoint.y, endRectPoint.y);
  740.         gluOrtho2D(getMax(minw, 1.0), getMax(maxw, 1.0), getMax(maxh, 1.0), getMax(minh, 1.0));
  742.         glViewport(0, 0, maxWidth, maxHeight);
  744.         wglMakeCurrent(NULL, NULL);
  745.         isOne = false;
  746.         Invalidate();
  747.     }
  749.     isLButtonDown = false;
  750. CView::OnLButtonUp(nFlags, point);
  751. }
  753. void CdtriangulationView::OnDcelTest(void)
  754. {
  755.     if (GetDocument()->nPoints <= 1 || !GetDocument()->myDT.isFinished || !isEnLarge)
  756.     {
  757.         MessageBox("Can not do DCEL test!", "warning");
  758.         Invalidate();
  759.         return;
  760.     }
  761.     isTest = true;
  762.     isManInputState = false;
  763. isCircleTest = false;
  764.     tempCount = -1;
  765. }
  767. void CdtriangulationView::OnCircleTest(void)
  768. {
  769.     if (GetDocument()->nPoints <= 2 || !GetDocument()->myDT.isFinished || !isEnLarge) // delete !isEnlarge
  770.     {
  771.         MessageBox("Can not do circle test!", "warning");
  772.         Invalidate();
  773.         return;
  774.     }
  775. isCircleTest = true;
  776.     isTest = false;
  777.     isManInputState = false;
  778. }
  780. void CdtriangulationView::OnMouseMove(UINT nFlags, CPoint point)
  781. {
  782.     CdtriangulationDoc* pDoc = GetDocument();
  783.     ASSERT_VALID(pDoc);
  785.     if (isLButtonDown && !isEnLarge && isOne)
  786.     {
  787.         tempRectPoint.x = point.x;
  788.         tempRectPoint.y = point.y;
  790.         Invalidate();
  791.     }
  792.     if ((pDoc->myDT.isFinished && isTest && isLButtonDown))
  793.     {
  794.         tempTestPoint.x = point.x;
  795.         tempTestPoint.y = point.y;
  797.         Invalidate();
  798.     }
  800.     CView::OnMouseMove(nFlags, point);
  801. }
  803. void CdtriangulationView::OnShowEnlarge(void)
  804. {
  805.     if (isEnLarge)
  806.     {
  807.         isEnLarge = false;
  808.         isOne = true;
  809.         isManInputState = false;
  811.         CString s = "放大状态，不能进行其他操作";
  812.         CStatusBar* pStatusBar = (CStatusBar*)AfxGetMainWnd()->GetDescendantWindow(AFX_IDW_STATUS_BAR);
  813.         pStatusBar->SetPaneText(pStatusBar->CommandToIndex(ID_INDICATOR_RUNTIME),s);
  814.     }
  815. }
  817. void CdtriangulationView::OnShowRevert(void)
  818. {
  819.     if (!isEnLarge)
  820.     {
  821.         CClientDC dc(this);
  822.         wglMakeCurrent(dc.m_hDC, m_hRC);
  824.         glMatrixMode(GL_PROJECTION);
  825.         glLoadIdentity();
  827.         CRect rect;
  828.         GetClientRect(&rect);
  829.         int maxHeight = rect.Height(), maxWidth = rect.Width();
  830.         gluOrtho2D(0, (double)maxWidth, (double)maxHeight, 0);
  832.         glViewport(0, 0, maxWidth, maxHeight);
  834.         wglMakeCurrent(NULL, NULL);
  835.         isEnLarge = true;
  836.         isOne = false;
  838.         CString s = "视图状态恢复正常";
  839.         CStatusBar* pStatusBar = (CStatusBar*)AfxGetMainWnd()->GetDescendantWindow(AFX_IDW_STATUS_BAR);
  840.         pStatusBar->SetPaneText(pStatusBar->CommandToIndex(ID_INDICATOR_RUNTIME),s);
  842.         Invalidate();
  843.     }
  844. }
  846. void CdtriangulationView::OnTimer(UINT_PTR nIDEvent)
  847. {
  848.     if (nIDEvent == m_nTimer)
  849.     {
  850.         if (tempCount == testTris.size())
  851.         {
  852.             KillTimer(m_nTimer);
  853.             isPro = false;
  854.         }
  855.         else
  856.         {
  857.             ++tempCount;
  858.         }
  859.         Invalidate();
  860.     }
  861.     CView::OnTimer(nIDEvent);
  862. }
  864. void CdtriangulationView::OnDtDemo()
  865. {
  866. // TODO: 在此添加命令处理程序代码
  867.     CdtriangulationDoc* pDoc = GetDocument();
  868.     ASSERT_VALID(pDoc);
  869.     if (!pDoc)
  870.         return;
  872.     if (pDoc->nPoints <= 1)
  873.         return;
  875. this->isTest = false;
  876. this->isCircleTest = false;
  877. this->isManInputState = false;
  878. this->isDTDemo = true;
  880.     if (pDoc->myDT.nPoints >= 100000)
  881.     {
  882.         MessageBox("too many points!", "warning");
  883.         return;
  884.     }
  886. while(!maxEdges.empty())
  887. {
  888. maxEdges.clear();
  889. }
  890.    
  891.     pDoc->myDT.initial(&(pDoc->nPoints), pDoc->points);
  892.     if (pDoc->myDT.nPoints >= 2)
  893.     {
  894. pDoc->myDT.maxEdge = delaunayDemo(0, pDoc->myDT.nPoints - 1, 1000 / pDoc->nPoints);
  895.         pDoc->myDT.isFinished = true;
  896.     }
  897. this->isDTDemo = false;
  898. }
  900. MaxEdge CdtriangulationView::delaunayDemo(int begin, int end, int timeInterval)
  901. {
  902.     // the number of points
  903.     int size = end - begin + 1;
  904.     // max edge
  905.     MaxEdge ret;
  906. // doc
  907. CdtriangulationDoc* pDoc = GetDocument();
  908.     ASSERT_VALID(pDoc);
  910.     // delaunay triangulation
  911.     if(size == 2) // only two points
  912.     {
  913.         // let s1, s2 be two sites in sorted order.
  914.         // create an edge a from s1 to s2
  915.         Edge* a = makeEdge();
  916. a->endPoints(pDoc->myDT.point(begin), pDoc->myDT.point(end));
  918.         ret.le = a;
  919.         ret.re = a->twin();
  921. maxEdges.insert(maxEdges.end(), ret);
  922. // demo
  923. Sleep(timeInterval);
  925. pDoc->myDT.maxEdge = ret;
  926. OnDraw(GetDC());
  928.         return ret;
  929.     }
  930.     else if(size == 3) // only three points
  931.     {
  932.         // let s1, s2, s3 be the three sites, in sorted order,
  933.         // create edges a connecting s1 to s2 and b connecting s2 to s3
  934.         Edge* a = makeEdge();
  935.         Edge* b = makeEdge();
  936.         splice(a->twin(), b);
  937.         a->endPoints(pDoc->myDT.point(begin), pDoc->myDT.point(begin + 1));
  938.         b->endPoints(pDoc->myDT.point(begin + 1), pDoc->myDT.point(end));
  940.         // close the triangle
  941.         Edge* c;
  942.         if(ccw(*pDoc->myDT.point(begin), *pDoc->myDT.point(begin + 1), *pDoc->myDT.point(end)))
  943.         {
  944.             c = connect(b, a);
  946.             ret.le = a;
  947.             ret.re = b->twin();
  948.         }
  949.         else if(ccw(*pDoc->myDT.point(begin), *pDoc->myDT.point(end), *pDoc->myDT.point(begin + 1)))
  950.         {
  951.             c = connect(b, a);
  953.             ret.le = c->twin();
  954.             ret.re = c;
  955.         }
  956.         else  // the three points are collinear
  957.         {
  958.             ret.le = a;
  959.             ret.re = b->twin();
  960.         }
  962. maxEdges.insert(maxEdges.end(), ret);
  963. // demo
  964. Sleep(timeInterval);
  966. pDoc->myDT.maxEdge = ret;
  967. OnDraw(GetDC());
  969.         return ret;
  970.     }
  971.     else // |sites| >= 4
  972.     {
  973.         Edge *ldo, *ldi; // left half result
  974.         Edge *rdo, *rdi; // right half result
  976.         // recursively delaunay triangulation L and R halves
  977.         MaxEdge leftRet = delaunayDemo(begin, begin + (size / 2) - 1, timeInterval);
  978.         MaxEdge rightRet = delaunayDemo(begin + (size / 2), end, timeInterval);
  979.         ldo = leftRet.le;
  980.         ldi = leftRet.re;
  981.         rdi = rightRet.le;
  982.         rdo = rightRet.re;
  984.         // Compute the lower commom tangent of L and R
  985.         while(1)
  986.         {
  987.             if(leftOf(*(rdi->org()), ldi))
  988.             {
  989.                 ldi = ldi->lNext();
  990.             }
  991.             else if(rightOf(*(ldi->org()), rdi))
  992.             {
  993.                 rdi = rdi->rPrev();
  994.             }
  995.             else
  996.             {
  997.                 break;
  998.             }
  999.         }
  1001.         // create a first edge basel from rdi.org to ldi.org
  1002.         Edge* basel = connect(rdi->twin(), ldi);
  1003.         if((ldi->org()) == (ldo->org()))
  1004.         {
  1005.             ldo = basel->twin();
  1006.         }
  1007.         if((rdi->org()) == (rdo->org()))
  1008.         {
  1009.             rdo = basel;
  1010.         }
  1012.         // merge
  1013.         while(1)
  1014.         {
  1015.             // locate the first L point (lcand.Dest) to be encountered by the rising bubble
  1016.             // and delete L edges out of basel.Dest that fail the circle test
  1017.             Edge* lcand = basel->twin()->oNext();
  1018.             Edge* t;
  1019.             if(valid(lcand, basel))
  1020.             {
  1021.                 while(inCircle(*(basel->dest()), *(basel->org()), *(lcand->dest()), 
  1022.                                *(lcand->oNext()->dest())))
  1023.                 {
  1024.                     t = lcand->oNext();
  1025.                     deleteEdge(lcand);
  1026.                     lcand = t;
  1027.                 }
  1028.             }
  1030.             // symmetrically, locate the first R point to be hit, and delete R edges
  1031.             Edge* rcand = basel->oPrev();
  1032.             if(valid(rcand, basel))
  1033.             {
  1034.                 while(inCircle(*(basel->dest()), *(basel->org()), *(rcand->dest()), 
  1035.                                *(rcand->oPrev()->dest())))
  1036.                 {
  1037.                     t = rcand->oPrev();
  1038.                     deleteEdge(rcand);
  1039.                     rcand = t;
  1040.                 }
  1041.             }
  1043.             // if both lcand and rcand are invalid, then basel is the upper common tangent
  1044.             if((!valid(lcand, basel)) && (!valid(rcand, basel)))
  1045.             {
  1046.                 break;
  1047.             }
  1049.             // the next cross edge is to be connected to either lcand.Dest or rcand.Dest
  1050.             // if both are valid, then choose the appropriate one using the inCircle test
  1051.             if((!valid(lcand, basel)) || (valid(rcand, basel)
  1052.                     && inCircle(*(lcand->dest()), *(lcand->org()),
  1053.                                 *(rcand->org()), *(rcand->dest()))))
  1054.             {
  1055.                 // add cross edge basel from rcand.Dest to basel.Dest
  1056.                 basel = connect(rcand, basel->twin());
  1057.             }
  1058.             else
  1059.             {
  1060.                 // add cross edge basel from basel.org to lcand.Dest
  1061.                 basel = connect(basel->twin(), lcand->twin());
  1062.             }
  1063.         }
  1064.         ret.le = ldo;
  1065.         ret.re = rdo;
  1067. maxEdges.erase(maxEdges.end() - 1);
  1068. maxEdges.erase(maxEdges.end() - 1);
  1069. maxEdges.insert(maxEdges.end(), ret);
  1071. // demo
  1072. Sleep(timeInterval);
  1074. pDoc->myDT.maxEdge = ret;
  1075. OnDraw(GetDC());
  1076.         return ret;
  1077.     }
  1078. }