C++ で Delaunay 分割（ただし2次元）

ちょっと学業の方が忙しくなってしまい、ウェブログを放置していました……。

忘れていたわけじゃないんだよ。ただちょっとモチベーションが足りなかっただけ。

今日は、某所（CG 系の研究室）で需要がありそうだったので、以前 Processing で書いていた Delaunay 分割を C++ で実装し直してみる事にしました。

ただし、C++ はものすごく苦手なので、ちょっと残念なソースになってしまっています。 ⇒ 11月20日追記：もうちょっと内部実装がマシになりました。

ソースコード上部の「view plain」という文字をクリックするとコピペ用の窓が出ますので、使いたい方はご自由にどうぞ。

---

【アルゴリズム部分（Delaunay2d.h）】

+ expand sourceview plainprint?

1. #ifndef ___TERCEL_DELAUNAY2D  
2. #define ___TERCEL_DELAUNAY2D  
3.   
4. #include <cfloat>  
5. #include <cmath>  
6. #include <list>  
7.   
8. namespace Tercel   
9. {  
10.     struct Vector   
11.     {  
12.         double x, y;  
13.   
14.         bool operator==(const Vector& v) const   
15.         {  
16.             return (x == v.x && y == v.y);  
17.         }  
18.     };  
19.   
20.   
21.     struct Circle   
22.     {  
23.         Vector center;  // 中心座標  
24.         double radius;  // 半径  
25.     };  
26.   
27.   
28.     class Triangle   
29.     {  
30.     public:  
31.         const Vector* p1, * p2, * p3;    // 頂点座標  
32.   
33.     public:  
34.         // ======================================    
35.         // 等価性の判定  
36.         // ======================================     
37.         bool operator==(const Triangle& t) const   
38.         {  
39.             return(*p1 == *t.p1 && *p2 == *t.p2 && *p3 == *t.p3 ||  
40.                    *p1 == *t.p2 && *p2 == *t.p3 && *p3 == *t.p1 ||  
41.                    *p1 == *t.p3 && *p2 == *t.p1 && *p3 == *t.p2 ||  
42.   
43.                    *p1 == *t.p3 && *p2 == *t.p2 && *p3 == *t.p1 ||  
44.                    *p1 == *t.p2 && *p2 == *t.p1 && *p3 == *t.p3 ||  
45.                    *p1 == *t.p1 && *p2 == *t.p3 && *p3 == *t.p2 );  
46.         }  
47.   
48.         // ======================================    
49.         // 他の三角形と共有点を持つか    
50.         // ======================================     
51.         bool hasCommonPoints(const Triangle& t)   
52.         {  
53.             return(*p1 == *t.p1 || *p1 == *t.p2 || *p1 == *t.p3 ||  
54.                    *p2 == *t.p1 || *p2 == *t.p2 || *p2 == *t.p3 ||  
55.                    *p3 == *t.p1 || *p3 == *t.p2 || *p3 == *t.p3 );  
56.         }  
57.     };  
58.   
59.       
60.     class Delaunay2d   
61.     {  
62.     private:  
63.         static void manageDuplicativeTriangles(std::list<Triangle>* newTriangleList,  
64.                                         std::list<Triangle>* duplicativeTriangleList,   
65.                                         const Triangle& t)   
66.         {  
67.             typedef std::list<Triangle>::iterator triIter;  
68.   
69.             bool existsInNewTriangleList = false;  
70.             for(triIter iter = newTriangleList->begin();  
71.                 iter != newTriangleList->end(); iter++)   
72.             {  
73.                   
74.                 if(*iter == t) {  
75.                     existsInNewTriangleList = true;  
76.                     bool existsInDuplicativeTriangleList = false;  
77.   
78.                     for(triIter iter2 = duplicativeTriangleList->begin();  
79.                         iter2 != duplicativeTriangleList->end(); iter2++)   
80.                     {  
81.                         if(*iter2 == t)   
82.                         {   
83.                             existsInDuplicativeTriangleList = true;  
84.                             break;  
85.                         }  
86.   
87.                     }  
88.                     if(!existsInDuplicativeTriangleList)   
89.                     {  
90.                         duplicativeTriangleList->push_back(t);  
91.                     }  
92.                     break;  
93.                 }  
94.             }  
95.             if(!existsInNewTriangleList) newTriangleList->push_back(t);  
96.         }  
97.   
98.     public:  
99.         static void getDelaunayTriangles(const std::list<Vector>& vertexList,   
100.             std::list<Triangle>* triangleList)   
101.         {  
102.             typedef std::list<Vector>::const_iterator cVtxIter;  
103.             typedef std::list<Triangle>::iterator     triIter;  
104.   
105.             Triangle hugeTriangle;  
106.             {  
107.                 // ======================================    
108.                 // 外部三角形を作る    
109.                 // ======================================    
110.                 double maxX, maxY; maxX = maxY = DBL_MIN;  
111.                 double minX, minY; minX = minY = DBL_MAX;  
112.                 for(cVtxIter it = vertexList.begin(); it != vertexList.end(); ++it)   
113.                 {  
114.                     double x = it->x;  
115.                     double y = it->y;  
116.                     if(maxX < x) maxX = x; if(minX > x) minX = x;  
117.                     if(maxY < y) maxY = y; if(minY > y) minY = y;  
118.                 }  
119.                   
120.                 // すべての点を包含する矩形の外接円  
121.                 double centerX  = (maxX - minX) * 0.5;          // 中心x座標  
122.                 double centerY  = (maxY - minY) * 0.5;          // 中心y座標  
123.   
124.                 double dX     = maxX - centerX;  
125.                 double dY     = maxY - centerY;  
126.                 double radius = sqrt(dX * dX + dY * dY) + 1.0;  // 半径  
127.   
128.                 Vector* p1 = new Vector;    // メモリ確保（266行目で解放）  
129.                 p1->x      = centerX - sqrt(3.0) * radius;  
130.                 p1->y      = centerY - radius;  
131.   
132.                 Vector* p2 = new Vector;    // メモリ確保（267行目で解放）  
133.                 p2->x      = centerX + sqrt(3.0) * radius;  
134.                 p2->y      = centerY - radius;  
135.   
136.                 Vector* p3 = new Vector;    // メモリ確保（268行目で解放）  
137.                 p3->x      = centerX;  
138.                 p3->y      = centerY + 2.0 * radius;  
139.   
140.                 hugeTriangle.p1 = p1;  
141.                 hugeTriangle.p2 = p2;  
142.                 hugeTriangle.p3 = p3;  
143.             }  
144.   
145.             triangleList->push_back(hugeTriangle);  
146.   
147.             // --------------------------------------    
148.             // 点を逐次添加し、反復的に三角分割を行う    
149.             // --------------------------------------    
150.             for(cVtxIter vIter = vertexList.begin(); vIter != vertexList.end(); ++vIter)   
151.             {  
152.                 const Vector* p = &(*vIter);  
153.   
154.                 // --------------------------------------    
155.                 // 追加候補の三角形を保持する一時リスト    
156.                 // --------------------------------------    
157.                 std::list<Triangle> newTriangleList;          // 新規分割された三角形                  
158.                 std::list<Triangle> duplicativeTriangleList;  // 重複リスト  
159.                   
160.   
161.                 // --------------------------------------    
162.                 // 現在の三角形セットから要素を一つずつ取り出して、    
163.                 // 与えられた点が各々の三角形の外接円の中に含まれるかどうか判定    
164.                 // --------------------------------------    
165.                 for(triIter tIter = triangleList->begin(); tIter != triangleList->end(); )   
166.                 {  
167.                     // 三角形セットから三角形を取りだして…  
168.                     Triangle t = *tIter;  
169.   
170.                     // その外接円を求める。    
171.                     Circle   c;  
172.                     {  
173.                         // 三角形の各頂点座標を (x1, y1), (x2, y2), (x3, y3) とし、    
174.                         // その外接円の中心座標を (x, y) とすると、    
175.                         //     (x - x1) * (x - x1) + (y - y1) * (y - y1)    
176.                         //   = (x - x2) * (x - x2) + (y - y2) * (y - y2)    
177.                         //   = (x - x3) * (x - x3) + (y - y3) * (y - y3)    
178.                         // より、以下の式が成り立つ    
179.                         //    
180.                         // x = { (y3 - y1) * (x2 * x2 - x1 * x1 + y2 * y2 - y1 * y1)    
181.                         //     + (y1 - y2) * (x3 * x3 - x1 * x1 + y3 * y3 - y1 * y1)} / c    
182.                         //    
183.                         // y = { (x1 - x3) * (x2 * x2 - x1 * x1 + y2 * y2 - y1 * y1)    
184.                         //     + (x2 - x1) * (x3 * x3 - x1 * x1 + y3 * y3 - y1 * y1)} / c    
185.                         //    
186.                         // ただし、    
187.                         //   c = 2 * {(x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1)}   
188.   
189.                         double x1 = t.p1->x;    double y1 = t.p1->y;  
190.                         double x2 = t.p2->x;    double y2 = t.p2->y;  
191.                         double x3 = t.p3->x;    double y3 = t.p3->y;  
192.   
193.                         double m = 2.0 * ((x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1));    
194.                         double x = ((y3 - y1) * (x2 * x2 - x1 * x1 + y2 * y2 - y1 * y1)    
195.                                   + (y1 - y2) * (x3 * x3 - x1 * x1 + y3 * y3 - y1 * y1)) / m;    
196.                         double y = ((x1 - x3) * (x2 * x2 - x1 * x1 + y2 * y2 - y1 * y1)    
197.                                   + (x2 - x1) * (x3 * x3 - x1 * x1 + y3 * y3 - y1 * y1)) / m;  
198.   
199.                         c.center.x = x;   
200.                         c.center.y = y;  
201.   
202.                         // 外接円の半径 r は、半径から三角形の任意の頂点までの距離に等しい   
203.                         double dx     = t.p1->x - x;  
204.                         double dy     = t.p1->y - y;  
205.                         double radius = sqrt(dx * dx + dy * dy);  
206.   
207.                         c.radius = radius;  
208.                     }  
209.   
210.                     double dx   = c.center.x - p->x;  
211.                     double dy   = c.center.y - p->y;  
212.                     double dist = sqrt(dx * dx + dy * dy);  
213.   
214.                     // ======================================    
215.                     // 一時リストを使って重複判定    
216.                     // ======================================    
217.                     if(dist < c.radius)   
218.                     {  
219.                         // 再分割  
220.   
221.                         Triangle t1;  
222.                         t1.p1 = p; t1.p2 = t.p1; t1.p3 = t.p2;  
223.                         manageDuplicativeTriangles(&newTriangleList, &duplicativeTriangleList, t1);  
224.   
225.                         Triangle t2;  
226.                         t2.p1 = p; t2.p2 = t.p2; t2.p3 = t.p3;  
227.                         manageDuplicativeTriangles(&newTriangleList, &duplicativeTriangleList, t2);  
228.   
229.                         Triangle t3;  
230.                         t3.p1 = p; t3.p2 = t.p3; t3.p3 = t.p1;  
231.                         manageDuplicativeTriangles(&newTriangleList, &duplicativeTriangleList, t3);  
232.   
233.                         tIter = triangleList->erase(tIter);  
234.                     }   
235.                     else ++tIter;  
236.                 }  
237.   
238.                 // --------------------------------------    
239.                 // 一時リストのうち、重複のないものを三角形リストに追加     
240.                 // --------------------------------------    
241.                 for(triIter iter = newTriangleList.begin();  
242.                     iter != newTriangleList.end(); ++iter)   
243.                 {  
244.                     bool exists = false;  
245.                     for(triIter iter2 = duplicativeTriangleList.begin();  
246.                         iter2 != duplicativeTriangleList.end(); ++iter2)  
247.                     {  
248.                         if(*iter == *iter2)   
249.                         {  
250.                             exists = true;  
251.                             break;  
252.                         }  
253.                     }  
254.                     if(!exists) triangleList->push_back(*iter);  
255.                 }  
256.             }  
257.   
258.             // 最後に、外部三角形の頂点を削除  
259.             for(triIter tIter = triangleList->begin(); tIter != triangleList->end(); )   
260.             {  
261.                 if(hugeTriangle.hasCommonPoints(*tIter)) tIter = triangleList->erase(tIter);  
262.                 else ++tIter;  
263.             }  
264.   
265.             // 巨大三角形の頂点を解放  
266.             delete hugeTriangle.p1;  
267.             delete hugeTriangle.p2;  
268.             delete hugeTriangle.p3;  
269.         }  
270.     };  
271. }  
272.   
273. #endif  

#ifndef ___TERCEL_DELAUNAY2D
#define ___TERCEL_DELAUNAY2D

#include <cfloat>
#include <cmath>
#include <list>

namespace Tercel 
{
    struct Vector 
    {
        double x, y;

        bool operator==(const Vector& v) const 
        {
            return (x == v.x && y == v.y);
        }
    };


    struct Circle 
    {
        Vector center;  // 中心座標
        double radius;  // 半径
    };


    class Triangle 
    {
    public:
        const Vector* p1, * p2, * p3;    // 頂点座標

    public:
        // ======================================  
        // 等価性の判定
        // ======================================   
        bool operator==(const Triangle& t) const 
        {
            return(*p1 == *t.p1 && *p2 == *t.p2 && *p3 == *t.p3 ||
                   *p1 == *t.p2 && *p2 == *t.p3 && *p3 == *t.p1 ||
                   *p1 == *t.p3 && *p2 == *t.p1 && *p3 == *t.p2 ||

                   *p1 == *t.p3 && *p2 == *t.p2 && *p3 == *t.p1 ||
                   *p1 == *t.p2 && *p2 == *t.p1 && *p3 == *t.p3 ||
                   *p1 == *t.p1 && *p2 == *t.p3 && *p3 == *t.p2 );
        }

        // ======================================  
        // 他の三角形と共有点を持つか  
        // ======================================   
        bool hasCommonPoints(const Triangle& t) 
        {
            return(*p1 == *t.p1 || *p1 == *t.p2 || *p1 == *t.p3 ||
                   *p2 == *t.p1 || *p2 == *t.p2 || *p2 == *t.p3 ||
                   *p3 == *t.p1 || *p3 == *t.p2 || *p3 == *t.p3 );
        }
    };

    
    class Delaunay2d 
    {
    private:
        static void manageDuplicativeTriangles(std::list<Triangle>* newTriangleList,
                                        std::list<Triangle>* duplicativeTriangleList, 
                                        const Triangle& t) 
        {
            typedef std::list<Triangle>::iterator triIter;

            bool existsInNewTriangleList = false;
            for(triIter iter = newTriangleList->begin();
                iter != newTriangleList->end(); iter++) 
            {
                
                if(*iter == t) {
                    existsInNewTriangleList = true;
                    bool existsInDuplicativeTriangleList = false;

                    for(triIter iter2 = duplicativeTriangleList->begin();
                        iter2 != duplicativeTriangleList->end(); iter2++) 
                    {
                        if(*iter2 == t) 
                        { 
                            existsInDuplicativeTriangleList = true;
                            break;
                        }

                    }
                    if(!existsInDuplicativeTriangleList) 
                    {
                        duplicativeTriangleList->push_back(t);
                    }
                    break;
                }
            }
            if(!existsInNewTriangleList) newTriangleList->push_back(t);
        }

    public:
        static void getDelaunayTriangles(const std::list<Vector>& vertexList, 
            std::list<Triangle>* triangleList) 
        {
            typedef std::list<Vector>::const_iterator cVtxIter;
            typedef std::list<Triangle>::iterator     triIter;

            Triangle hugeTriangle;
            {
                // ======================================  
                // 外部三角形を作る  
                // ======================================  
                double maxX, maxY; maxX = maxY = DBL_MIN;
                double minX, minY; minX = minY = DBL_MAX;
                for(cVtxIter it = vertexList.begin(); it != vertexList.end(); ++it) 
                {
                    double x = it->x;
                    double y = it->y;
                    if(maxX < x) maxX = x; if(minX > x) minX = x;
                    if(maxY < y) maxY = y; if(minY > y) minY = y;
                }
                
                // すべての点を包含する矩形の外接円
                double centerX  = (maxX - minX) * 0.5;          // 中心x座標
                double centerY  = (maxY - minY) * 0.5;          // 中心y座標

                double dX     = maxX - centerX;
                double dY     = maxY - centerY;
                double radius = sqrt(dX * dX + dY * dY) + 1.0;  // 半径

                Vector* p1 = new Vector;    // メモリ確保（266行目で解放）
                p1->x      = centerX - sqrt(3.0) * radius;
                p1->y      = centerY - radius;

                Vector* p2 = new Vector;    // メモリ確保（267行目で解放）
                p2->x      = centerX + sqrt(3.0) * radius;
                p2->y      = centerY - radius;

                Vector* p3 = new Vector;    // メモリ確保（268行目で解放）
                p3->x      = centerX;
                p3->y      = centerY + 2.0 * radius;

                hugeTriangle.p1 = p1;
                hugeTriangle.p2 = p2;
                hugeTriangle.p3 = p3;
            }

            triangleList->push_back(hugeTriangle);

            // --------------------------------------  
            // 点を逐次添加し、反復的に三角分割を行う  
            // --------------------------------------  
            for(cVtxIter vIter = vertexList.begin(); vIter != vertexList.end(); ++vIter) 
            {
                const Vector* p = &(*vIter);

                // --------------------------------------  
                // 追加候補の三角形を保持する一時リスト  
                // --------------------------------------  
                std::list<Triangle> newTriangleList;          // 新規分割された三角形                
                std::list<Triangle> duplicativeTriangleList;  // 重複リスト
                

                // --------------------------------------  
                // 現在の三角形セットから要素を一つずつ取り出して、  
                // 与えられた点が各々の三角形の外接円の中に含まれるかどうか判定  
                // --------------------------------------  
                for(triIter tIter = triangleList->begin(); tIter != triangleList->end(); ) 
                {
                    // 三角形セットから三角形を取りだして…
                    Triangle t = *tIter;

                    // その外接円を求める。  
                    Circle   c;
                    {
                        // 三角形の各頂点座標を (x1, y1), (x2, y2), (x3, y3) とし、  
                        // その外接円の中心座標を (x, y) とすると、  
                        //     (x - x1) * (x - x1) + (y - y1) * (y - y1)  
                        //   = (x - x2) * (x - x2) + (y - y2) * (y - y2)  
                        //   = (x - x3) * (x - x3) + (y - y3) * (y - y3)  
                        // より、以下の式が成り立つ  
                        //  
                        // x = { (y3 - y1) * (x2 * x2 - x1 * x1 + y2 * y2 - y1 * y1)  
                        //     + (y1 - y2) * (x3 * x3 - x1 * x1 + y3 * y3 - y1 * y1)} / c  
                        //  
                        // y = { (x1 - x3) * (x2 * x2 - x1 * x1 + y2 * y2 - y1 * y1)  
                        //     + (x2 - x1) * (x3 * x3 - x1 * x1 + y3 * y3 - y1 * y1)} / c  
                        //  
                        // ただし、  
                        //   c = 2 * {(x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1)} 

                        double x1 = t.p1->x;    double y1 = t.p1->y;
                        double x2 = t.p2->x;    double y2 = t.p2->y;
                        double x3 = t.p3->x;    double y3 = t.p3->y;

                        double m = 2.0 * ((x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1));  
                        double x = ((y3 - y1) * (x2 * x2 - x1 * x1 + y2 * y2 - y1 * y1)  
                                  + (y1 - y2) * (x3 * x3 - x1 * x1 + y3 * y3 - y1 * y1)) / m;  
                        double y = ((x1 - x3) * (x2 * x2 - x1 * x1 + y2 * y2 - y1 * y1)  
                                  + (x2 - x1) * (x3 * x3 - x1 * x1 + y3 * y3 - y1 * y1)) / m;

                        c.center.x = x; 
                        c.center.y = y;

                        // 外接円の半径 r は、半径から三角形の任意の頂点までの距離に等しい 
                        double dx     = t.p1->x - x;
                        double dy     = t.p1->y - y;
                        double radius = sqrt(dx * dx + dy * dy);

                        c.radius = radius;
                    }

                    double dx   = c.center.x - p->x;
                    double dy   = c.center.y - p->y;
                    double dist = sqrt(dx * dx + dy * dy);

                    // ======================================  
                    // 一時リストを使って重複判定  
                    // ======================================  
                    if(dist < c.radius) 
                    {
                        // 再分割

                        Triangle t1;
                        t1.p1 = p; t1.p2 = t.p1; t1.p3 = t.p2;
                        manageDuplicativeTriangles(&newTriangleList, &duplicativeTriangleList, t1);

                        Triangle t2;
                        t2.p1 = p; t2.p2 = t.p2; t2.p3 = t.p3;
                        manageDuplicativeTriangles(&newTriangleList, &duplicativeTriangleList, t2);

                        Triangle t3;
                        t3.p1 = p; t3.p2 = t.p3; t3.p3 = t.p1;
                        manageDuplicativeTriangles(&newTriangleList, &duplicativeTriangleList, t3);

                        tIter = triangleList->erase(tIter);
                    } 
                    else ++tIter;
                }

                // --------------------------------------  
                // 一時リストのうち、重複のないものを三角形リストに追加   
                // --------------------------------------  
                for(triIter iter = newTriangleList.begin();
                    iter != newTriangleList.end(); ++iter) 
                {
                    bool exists = false;
                    for(triIter iter2 = duplicativeTriangleList.begin();
                        iter2 != duplicativeTriangleList.end(); ++iter2)
                    {
                        if(*iter == *iter2) 
                        {
                            exists = true;
                            break;
                        }
                    }
                    if(!exists) triangleList->push_back(*iter);
                }
            }

            // 最後に、外部三角形の頂点を削除
            for(triIter tIter = triangleList->begin(); tIter != triangleList->end(); ) 
            {
                if(hugeTriangle.hasCommonPoints(*tIter)) tIter = triangleList->erase(tIter);
                else ++tIter;
            }

            // 巨大三角形の頂点を解放
            delete hugeTriangle.p1;
            delete hugeTriangle.p2;
            delete hugeTriangle.p3;
        }
    };
}

#endif

【テスト用の GUI （Main.cpp）】

+ expand sourceview plainprint?

1. // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-  
2. //  
3. // 結果表示用のウィンドウ  
4. //  
5. // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-  
6. #include <windows.h>  
7.   
8. #include "Delaunay2d.h"  
9.   
10. // アプリケーションとウィンドウの初期化に必要な定数  
11. // ----------------------------------------  
12. const LPCTSTR APP_NAME   = TEXT("APP_TERCEL_TECH");  
13. const LPCTSTR MUTEX_NAME = TEXT("MUTEX_TERCEL_TECH");  
14.   
15. // クライアント領域の幅と高さ  
16. // ----------------------------------------  
17. const UINT WIDTH  = 400;  
18. const UINT HEIGHT = 300;  
19.   
20. // ----------------------------------------  
21. // 頂点集合、およびそれらを基に  
22. // Delaunay 分割された三角形を格納しておくSTLコンテナ  
23. // ----------------------------------------  
24. std::list<Tercel::Vector>   vertices;  
25. std::list<Tercel::Triangle> triangles;  
26.   
27.   
28. // コールバック関数（メッセージ処理）  
29. // ========================================  
30. LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg,  
31.                             WPARAM wParam, LPARAM lParam)  
32. {  
33.     switch(uMsg)  
34.     {  
35.     case WM_DESTROY:  
36.         PostQuitMessage(0);  
37.         return 0;  
38.   
39.     case WM_CREATE:  
40.         {  
41.             // ======================================    
42.             // 頂点集合にランダムでデータをセット  
43.             // ======================================    
44.             for(int i = 0; i < 200; ++i) {  
45.                 Tercel::Vector v;  // ベクトルを宣言  
46.                 v.x   = rand() % WIDTH;  
47.                 v.y   = rand() % HEIGHT;  
48.                 vertices.push_back(v);  
49.             }  
50.   
51.             // ======================================    
52.             // Delaunay分割を行う関数  
53.             // ======================================    
54.               
55.             // 結果は第2引数（std::list<Tercel::Triangle> 型）に格納される。  
56.             //   
57.             // Tercel::Triangle のメンバには、3つの頂点p1, p2, p3 があって、  
58.             // いずれも Tercel::Vertex オブジェクトへのポインタになっている  
59.             // これらのポインタは、vertices リストの要素を参照している。  
60.             Tercel::Delaunay2d::getDelaunayTriangles(vertices, &triangles);  
61.             //                                       ~~~~~~~~  ~~~~~~~~~~  
62.             //                                       頂点集合  三角形集合  
63.             //                                       （参照） （ポインタ）  
64.         }  
65.         return 0;  
66.   
67.     case WM_PAINT:  
68.         {  
69.             typedef std::list<Tercel::Triangle> triangleList;  
70.   
71.             PAINTSTRUCT ps;  
72.             HDC         hdc  = BeginPaint(hWnd, &ps);  
73.             HPEN        hPen = CreatePen(PS_SOLID, 1, RGB(0, 0, 0));  
74.               
75.             SelectObject(hdc, hPen);  
76.   
77.             // ======================================    
78.             // Delaunay分割された三角形の集合を一つ一つ描画  
79.             // ======================================    
80.             for(triangleList::iterator it = triangles.begin();  
81.                 it != triangles.end(); ++it)   
82.             {  
83.                 Tercel::Triangle t = *it;  // 三角形取得  
84.                 int x, y;  
85.   
86.                 x = int(t.p1->x + 0.5);  
87.                 y = int(t.p1->y + 0.5);  
88.   
89.                 MoveToEx(hdc, x, y, NULL);  
90.   
91.                 x = int(t.p2->x + 0.5);  
92.                 y = int(t.p2->y + 0.5);  
93.   
94.                 LineTo(hdc, x, y);  
95.                 MoveToEx(hdc, x, y, NULL);  
96.   
97.                 x = int(t.p3->x + 0.5);  
98.                 y = int(t.p3->y + 0.5);  
99.   
100.                 LineTo(hdc, x, y);  
101.                 MoveToEx(hdc, x, y, NULL);  
102.   
103.                 x = int(t.p1->x + 0.5);  
104.                 y = int(t.p1->y + 0.5);  
105.   
106.                 LineTo(hdc, x, y);  
107.             }  
108.             DeleteObject(hPen);  
109.             EndPaint(hWnd, &ps);              
110.         }  
111.         return 0;  
112.     }  
113.     return DefWindowProc(hWnd, uMsg, wParam, lParam);  
114. }  
115.   
116.   
117. // エントリポイント  
118. // ========================================  
119. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,  
120.                    LPSTR lpCmdLine, int nCmdShow)  
121. {  
122.   
123.     // 多重起動防止  
124.     HANDLE hMutex = CreateMutex(NULL, TRUE, MUTEX_NAME);  
125.     if(GetLastError() == ERROR_ALREADY_EXISTS)  
126.     {  
127.         // 多重起動を検知した際には、  
128.         // 既存のウィンドウを最前面に表示してプログラムを終了する  
129.         HWND existingWnd = FindWindow(APP_NAME, NULL);  
130.         if(existingWnd != NULL)  
131.         {  
132.             if(IsIconic(existingWnd))  
133.                 ShowWindowAsync(existingWnd, SW_RESTORE);  
134.   
135.             SetForegroundWindow(existingWnd);  
136.         }  
137.         return -1;  
138.     }  
139.   
140.     // ウィンドウクラス登録  
141.     WNDCLASSEX wc;  
142.     wc.cbSize        = sizeof(WNDCLASSEX);  
143.     wc.style         = CS_HREDRAW | CS_VREDRAW;  
144.     wc.lpfnWndProc   = WindowProc;  
145.     wc.cbClsExtra    = 0;  
146.     wc.cbWndExtra    = sizeof(LONG_PTR);  
147.     wc.hInstance     = hInstance;  
148.     wc.hIcon         = (HICON)LoadImage(NULL,  
149.                            MAKEINTRESOURCE(IDI_APPLICATION),  
150.                            IMAGE_ICON,  
151.                            0,  
152.                            0,  
153.                            LR_DEFAULTSIZE | LR_SHARED);  
154.     wc.hCursor       = (HICON)LoadImage(NULL,  
155.                            MAKEINTRESOURCE(IDC_ARROW),  
156.                            IMAGE_CURSOR,  
157.                            0,  
158.                            0,  
159.                            LR_DEFAULTSIZE | LR_SHARED);  
160.     wc.hbrBackground = (HBRUSH)COLOR_BACKGROUND + 1;  
161.     wc.lpszMenuName  = NULL;  
162.     wc.lpszClassName = APP_NAME;  
163.     wc.hIconSm = (HICON)LoadImage(NULL,  
164.                            MAKEINTRESOURCE(IDI_APPLICATION),  
165.                            IMAGE_ICON,  
166.                            0,  
167.                            0,  
168.                            LR_DEFAULTSIZE | LR_SHARED);  
169.     if(!RegisterClassEx(&wc)) return -1;  
170.   
171.     // クライアント領域のサイズから、ウィンドウそのものの幅と高さを計算  
172.     UINT windowWidth  = WIDTH  + GetSystemMetrics(SM_CXFIXEDFRAME) * 2;  
173.     UINT windowHeight = HEIGHT + GetSystemMetrics(SM_CYFIXEDFRAME) * 2  
174.                                + GetSystemMetrics(SM_CYCAPTION);  
175.     // ウィンドウ生成  
176.     HWND hWnd = CreateWindow(APP_NAME,  
177.                     TEXT("はじめてのDelaunay分割"),  
178.                     WS_OVERLAPPEDWINDOW^WS_THICKFRAME^WS_MAXIMIZEBOX,  
179.                     CW_USEDEFAULT,  
180.                     CW_USEDEFAULT,  
181.                     windowWidth,  
182.                     windowHeight,  
183.                     NULL,  
184.                     NULL,  
185.                     hInstance,  
186.                     NULL);  
187.     if(!hWnd) return -1;  
188.   
189.     // ウィンドウ表示  
190.     ShowWindow(hWnd, nCmdShow);  
191.     UpdateWindow(hWnd);  
192.   
193.     // メッセージループ  
194.     MSG msg;  
195.     while(TRUE)  
196.     {  
197.         if(PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))  
198.         {  
199.             if(msg.message == WM_QUIT) break;  
200.             TranslateMessage(&msg);  
201.             DispatchMessage(&msg);  
202.         }  
203.     }  
204.     CloseHandle(hMutex);  
205.   
206.     return (int)msg.wParam;  
207. }  

// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
//
// 結果表示用のウィンドウ
//
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#include <windows.h>

#include "Delaunay2d.h"

// アプリケーションとウィンドウの初期化に必要な定数
// ----------------------------------------
const LPCTSTR APP_NAME   = TEXT("APP_TERCEL_TECH");
const LPCTSTR MUTEX_NAME = TEXT("MUTEX_TERCEL_TECH");

// クライアント領域の幅と高さ
// ----------------------------------------
const UINT WIDTH  = 400;
const UINT HEIGHT = 300;

// ----------------------------------------
// 頂点集合、およびそれらを基に
// Delaunay 分割された三角形を格納しておくSTLコンテナ
// ----------------------------------------
std::list<Tercel::Vector>   vertices;
std::list<Tercel::Triangle> triangles;


// コールバック関数（メッセージ処理）
// ========================================
LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg,
                            WPARAM wParam, LPARAM lParam)
{
    switch(uMsg)
    {
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;

    case WM_CREATE:
        {
            // ======================================  
            // 頂点集合にランダムでデータをセット
            // ======================================  
            for(int i = 0; i < 200; ++i) {
                Tercel::Vector v;  // ベクトルを宣言
                v.x   = rand() % WIDTH;
                v.y   = rand() % HEIGHT;
                vertices.push_back(v);
            }

            // ======================================  
            // Delaunay分割を行う関数
            // ======================================  
            
            // 結果は第2引数（std::list<Tercel::Triangle> 型）に格納される。
            // 
            // Tercel::Triangle のメンバには、3つの頂点p1, p2, p3 があって、
            // いずれも Tercel::Vertex オブジェクトへのポインタになっている
            // これらのポインタは、vertices リストの要素を参照している。
            Tercel::Delaunay2d::getDelaunayTriangles(vertices, &triangles);
            //                                       ~~~~~~~~  ~~~~~~~~~~
            //                                       頂点集合  三角形集合
            //                                       （参照） （ポインタ）
        }
        return 0;

    case WM_PAINT:
        {
            typedef std::list<Tercel::Triangle> triangleList;

            PAINTSTRUCT ps;
            HDC         hdc  = BeginPaint(hWnd, &ps);
            HPEN        hPen = CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
            
            SelectObject(hdc, hPen);

            // ======================================  
            // Delaunay分割された三角形の集合を一つ一つ描画
            // ======================================  
            for(triangleList::iterator it = triangles.begin();
                it != triangles.end(); ++it) 
            {
                Tercel::Triangle t = *it;  // 三角形取得
                int x, y;

                x = int(t.p1->x + 0.5);
                y = int(t.p1->y + 0.5);

                MoveToEx(hdc, x, y, NULL);

                x = int(t.p2->x + 0.5);
                y = int(t.p2->y + 0.5);

                LineTo(hdc, x, y);
                MoveToEx(hdc, x, y, NULL);

                x = int(t.p3->x + 0.5);
                y = int(t.p3->y + 0.5);

                LineTo(hdc, x, y);
                MoveToEx(hdc, x, y, NULL);

                x = int(t.p1->x + 0.5);
                y = int(t.p1->y + 0.5);

                LineTo(hdc, x, y);
            }
            DeleteObject(hPen);
            EndPaint(hWnd, &ps);            
        }
        return 0;
    }
    return DefWindowProc(hWnd, uMsg, wParam, lParam);
}


// エントリポイント
// ========================================
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                   LPSTR lpCmdLine, int nCmdShow)
{

    // 多重起動防止
    HANDLE hMutex = CreateMutex(NULL, TRUE, MUTEX_NAME);
    if(GetLastError() == ERROR_ALREADY_EXISTS)
    {
        // 多重起動を検知した際には、
        // 既存のウィンドウを最前面に表示してプログラムを終了する
        HWND existingWnd = FindWindow(APP_NAME, NULL);
        if(existingWnd != NULL)
        {
            if(IsIconic(existingWnd))
                ShowWindowAsync(existingWnd, SW_RESTORE);

            SetForegroundWindow(existingWnd);
        }
        return -1;
    }

    // ウィンドウクラス登録
    WNDCLASSEX wc;
    wc.cbSize        = sizeof(WNDCLASSEX);
    wc.style         = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc   = WindowProc;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = sizeof(LONG_PTR);
    wc.hInstance     = hInstance;
    wc.hIcon         = (HICON)LoadImage(NULL,
                           MAKEINTRESOURCE(IDI_APPLICATION),
                           IMAGE_ICON,
                           0,
                           0,
                           LR_DEFAULTSIZE | LR_SHARED);
    wc.hCursor       = (HICON)LoadImage(NULL,
                           MAKEINTRESOURCE(IDC_ARROW),
                           IMAGE_CURSOR,
                           0,
                           0,
                           LR_DEFAULTSIZE | LR_SHARED);
    wc.hbrBackground = (HBRUSH)COLOR_BACKGROUND + 1;
    wc.lpszMenuName  = NULL;
    wc.lpszClassName = APP_NAME;
    wc.hIconSm = (HICON)LoadImage(NULL,
                           MAKEINTRESOURCE(IDI_APPLICATION),
                           IMAGE_ICON,
                           0,
                           0,
                           LR_DEFAULTSIZE | LR_SHARED);
    if(!RegisterClassEx(&wc)) return -1;

    // クライアント領域のサイズから、ウィンドウそのものの幅と高さを計算
    UINT windowWidth  = WIDTH  + GetSystemMetrics(SM_CXFIXEDFRAME) * 2;
    UINT windowHeight = HEIGHT + GetSystemMetrics(SM_CYFIXEDFRAME) * 2
                               + GetSystemMetrics(SM_CYCAPTION);
    // ウィンドウ生成
    HWND hWnd = CreateWindow(APP_NAME,
                    TEXT("はじめてのDelaunay分割"),
                    WS_OVERLAPPEDWINDOW^WS_THICKFRAME^WS_MAXIMIZEBOX,
                    CW_USEDEFAULT,
                    CW_USEDEFAULT,
                    windowWidth,
                    windowHeight,
                    NULL,
                    NULL,
                    hInstance,
                    NULL);
    if(!hWnd) return -1;

    // ウィンドウ表示
    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);

    // メッセージループ
    MSG msg;
    while(TRUE)
    {
        if(PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
        {
            if(msg.message == WM_QUIT) break;
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    CloseHandle(hMutex);

    return (int)msg.wParam;
}

---

テスト用の GUI プログラムの方は、思いっきり Windows 依存です。

ただ、Delaunay 分割のアルゴリズムは完全に分離してあるので、他の環境で使いたい場合は Delaunay2d.h だけを持っていって、表示部はがんばって自分で作れば OK です。

肝心の使い方は以下の通りです（Main.cpp のコールバック関数内に実際のサンプルがあります）。

1. 頂点リスト（std::list オブジェクト）を宣言します。
2. 先ほどの頂点リストに、適当な頂点オブジェクトを格納します。
3. 三角形リスト（std::list オブジェクト）を宣言します。
4. Tercel::Delaunay2d::getDelaunayTriangles() 関数を呼びます。

このとき、getDelaunayTriangles() の第一引数に頂点リストの『参照』を、第2引数には三角形リストの『ポインタ』を渡します。

一見すると奇妙な仕様ですが、関数内で中身が変更されるオブジェクトに関してはポインタ渡し、そうでないものは参照渡しで構文を使い分けているためです。

特に関数を呼び出す側（ここでは Main.cpp ）から見ると、参照渡しは値渡しのように見えるため、関数の中でオブジェクトが変更されないような印象になります。

Delaunay 分割された結果は三角形リストに格納されます。三角形（Tercel::Triangle 構造体）は、メンバに頂点（Tercel::Vertex オブジェクト）のポインタを保持します。ここでは、最初に作った頂点リストの要素を参照する形になります。

ですので、頂点リストの要素を削除した場合、三角形の頂点は不正なポインタになってしまう事に注意する必要があります。