1 /****************************************************************************
2 * VCGLib o o *
3 * Visual and Computer Graphics Library o o *
4 * _ O _ *
5 * Copyright(C) 2009 \/)\/ *
6 * Pablo Castellano García-Saavedra /\/| *
7 * | *
8 * \ *
9 * All rights reserved. *
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
20 * for more details. *
21 * *
22 ****************************************************************************/
23
24 #ifndef __VCGLIB_ARCHIMEDEAN_H
25 #define __VCGLIB_ARCHIMEDEAN_H
26
27 #include <vcg/math/base.h>
28 #include <vcg/complex/allocate.h>
29 #include <vcg/complex/algorithms/refine.h>
30 #include <vcg/complex/algorithms/update/flag.h>
31
32 namespace vcg {
33 namespace tri {
34
35 template <class MeshType>
Truncated_Tetrahedron(MeshType & in)36 void Truncated_Tetrahedron(MeshType &in)
37 {
38 //F = 8, V = 12
39 // 4 triangles and 4 hexagons
40 /* (+3,+1,+1), (+1,+3,+1), (+1,+1,+3)
41 (−3,−1,+1), (−1,−3,+1), (−1,−1,+3)
42 (−3,+1,−1), (−1,+3,−1), (−1,+1,−3)
43 (+3,−1,−1), (+1,−3,−1), (+1,−1,−3)
44 */
45
46 typedef typename MeshType::CoordType CoordType;
47 typedef typename MeshType::VertexPointer VertexPointer;
48 typedef typename MeshType::VertexIterator VertexIterator;
49 typedef typename MeshType::FaceIterator FaceIterator;
50
51 in.Clear();
52 Allocator<MeshType>::AddVertices(in, 12);
53 Allocator<MeshType>::AddFaces(in, 4*4+4); //20 triangles
54
55 VertexPointer ivp[12];
56 VertexIterator vi;
57
58 int vertexes[36] = {
59 3, 1, 1, 1, 3, 1, 1, 1, 3, -3,-1, 1,
60 -1,-3, 1, -1,-1, 3, -3, 1,-1, -1, 3,-1,
61 -1, 1,-3, 3,-1,-1, 1,-3,-1, 1,-1,-3 };
62
63 int triangles[12] = {
64 3, 4, 5, 0, 1, 2, 8, 6, 7, 9,10,11 };
65
66 int hexagons[24] = {
67 3, 5, 2, 1, 7, 6, 9, 0, 2, 5, 4,10,
68 8,11,10, 4, 3, 6, 0, 9,11, 8, 7, 1 };
69
70 int i;
71 for(i=0, vi=in.vert.begin(); vi!=in.vert.end(); i++, vi++) {
72 ivp[i]=&*vi; vi->P()=CoordType ( vertexes[3*i], vertexes[3*i+1], vertexes[3*i+2]);
73 }
74
75 FaceIterator fi=in.face.begin();
76
77 for(int i=0; i<4; i++) {
78 fi->V(0)=ivp[triangles[i*3]]; fi->V(1)=ivp[triangles[i*3+1]]; fi->V(2)=ivp[triangles[i*3+2]]; ++fi;
79 }
80
81 for(int i=0; i<4; i++) {
82 fi->V(0)=ivp[hexagons[i*6]]; fi->V(1)=ivp[hexagons[i*6+1]]; fi->V(2)=ivp[hexagons[i*6+2]];
83 fi->SetF(0); fi->SetF(2); ++fi;
84 fi->V(0)=ivp[hexagons[i*6]]; fi->V(1)=ivp[hexagons[i*6+2]]; fi->V(2)=ivp[hexagons[i*6+3]];
85 fi->SetF(0); fi->SetF(2); ++fi;
86 fi->V(0)=ivp[hexagons[i*6]]; fi->V(1)=ivp[hexagons[i*6+3]]; fi->V(2)=ivp[hexagons[i*6+4]];
87 fi->SetF(0); fi->SetF(2); ++fi;
88 fi->V(0)=ivp[hexagons[i*6]]; fi->V(1)=ivp[hexagons[i*6+4]]; fi->V(2)=ivp[hexagons[i*6+5]];
89 fi->SetF(0); fi->SetF(2); ++fi;
90 }
91 //
92 // if (in.HasPerFaceFlags()) {
93 // FaceIterator fi=in.face.begin();
94 // for (int k=0; k<20; k++) {
95 // fi->SetF(1); fi++;
96 // }
97 // }
98
99 }
100
101 template <class MeshType>
Cuboctahedron(MeshType & in)102 void Cuboctahedron(MeshType &in)
103 {
104 //F = 14, V = 12
105 //8 triangles and 6 squares
106 /*
107 (±1,±1,0)
108 (±1,0,±1)
109 (0,±1,±1)
110 */
111
112 typedef typename MeshType::CoordType CoordType;
113 typedef typename MeshType::VertexPointer VertexPointer;
114 typedef typename MeshType::VertexIterator VertexIterator;
115 typedef typename MeshType::FaceIterator FaceIterator;
116
117 in.Clear();
118 Allocator<MeshType>::AddVertices(in, 12);
119 Allocator<MeshType>::AddFaces(in, 6*2+8); //20 triangles
120
121 VertexPointer ivp[12];
122 VertexIterator vi;
123
124 int vertexes[36] = {
125 1, 1, 0, 1,-1, 0, -1,-1, 0, -1, 1, 0,
126 1, 0, 1, -1, 0, 1, -1, 0,-1, 1, 0,-1,
127 0, 1, 1, 0, 1,-1, 0,-1, 1, 0,-1,-1 };
128
129 int triangles[24] = {
130 5, 8, 3, 4, 0, 8, 7, 9, 0, 1,11, 7,
131 10, 1, 4, 5, 2,10, 9, 6, 3, 6,11, 2 };
132
133 int squares[24] = {
134 3, 6, 2, 5, 7, 0, 4, 1, 0, 9, 3, 8, 11, 1,10, 2,
135 9, 7,11, 6, 4, 8, 5,10 };
136
137 int i;
138 for(i=0, vi=in.vert.begin(); vi!=in.vert.end(); i++, vi++) {
139 ivp[i]=&*vi; vi->P()=CoordType ( vertexes[3*i], vertexes[3*i+1], vertexes[3*i+2]);
140 }
141
142 FaceIterator fi=in.face.begin();
143
144 for(int i=0; i<8; i++) {
145 fi->V(0)=ivp[triangles[i*3]]; fi->V(1)=ivp[triangles[i*3+1]]; fi->V(2)=ivp[triangles[i*3+2]]; ++fi;
146 }
147
148 for(int i=0; i<6; i++) {
149 fi->V(0)=ivp[squares[i*4]]; fi->V(1)=ivp[squares[i*4+1]]; fi->V(2)=ivp[squares[i*4+2]]; ++fi;
150 fi->V(0)=ivp[squares[i*4]]; fi->V(1)=ivp[squares[i*4+2]]; fi->V(2)=ivp[squares[i*4+3]]; ++fi;
151 }
152
153 if (in.HasPerFaceFlags()) {
154 FaceIterator fi=in.face.begin();
155 for (int k=0; k<20; k++) {
156 fi->SetF(1); fi++;
157 }
158 }
159
160 }
161
162
163 template <class MeshType>
Truncated_Cube(MeshType & in)164 void Truncated_Cube(MeshType &in)
165 {
166 // F = 14, V = 24
167 // 8 triangles and 6 octagons
168 /* Perm(±ξ, ±1, ±1)
169 where ξ = √2 - 1
170 */
171
172 typedef typename MeshType::CoordType CoordType;
173 typedef typename MeshType::VertexPointer VertexPointer;
174 typedef typename MeshType::VertexIterator VertexIterator;
175 typedef typename MeshType::FaceIterator FaceIterator;
176
177 in.Clear();
178 Allocator<MeshType>::AddVertices(in, 24);
179 Allocator<MeshType>::AddFaces(in, 6*6+8); //44 faces
180
181 VertexPointer ivp[24];
182 VertexIterator vi=in.vert.begin();
183
184 double E = sqrt(2)-1;
185 double vertexes[72] = {
186 E, 1, 1, E, 1,-1, E,-1, 1, E,-1,-1,
187 -E, 1, 1, -E, 1,-1, -E,-1, 1, -E,-1,-1,
188 1, E, 1, 1, E,-1, 1,-E, 1, 1,-E,-1,
189 -1, E, 1, -1, E,-1, -1,-E, 1, -1,-E,-1,
190 1, 1, E, 1, 1,-E, 1,-1, E, 1,-1,-E,
191 -1, 1, E, -1, 1,-E, -1,-1, E, -1,-1,-E };
192
193 int i;
194 for(i=0, vi=in.vert.begin(); vi!=in.vert.end(); i++, vi++) {
195 ivp[i]=&*vi; vi->P()=CoordType ( vertexes[3*i], vertexes[3*i+1], vertexes[3*i+2]);
196 }
197
198 int triangles[24] = {
199 18,10, 2, 6,14,22, 0, 8,16, 13,21, 5,
200 9, 1,17, 19, 3,11, 23,15, 7, 12, 4,20 };
201
202 int octagons[48] = {
203 12,20,21,13,15,23,22,14, 22,23, 7, 3,19,18, 2, 6,
204 10, 8, 0, 4,12,14, 6, 2, 19,11, 9,17,16, 8,10,18,
205 11, 3, 7,15,13, 5, 1, 9, 17, 1, 5,21,20, 4, 0,16 };
206
207 FaceIterator fi=in.face.begin();
208
209 for(int i=0; i<8; i++) {
210 fi->V(0)=ivp[triangles[i*3]]; fi->V(1)=ivp[triangles[i*3+1]]; fi->V(2)=ivp[triangles[i*3+2]]; ++fi;
211 }
212
213 for(int i=0; i<6; i++) {
214 fi->V(0)=ivp[octagons[i*8]]; fi->V(1)=ivp[octagons[i*8+1]]; fi->V(2)=ivp[octagons[i*8+2]]; ++fi;
215 fi->V(0)=ivp[octagons[i*8]]; fi->V(1)=ivp[octagons[i*8+2]]; fi->V(2)=ivp[octagons[i*8+3]]; ++fi;
216 fi->V(0)=ivp[octagons[i*8]]; fi->V(1)=ivp[octagons[i*8+3]]; fi->V(2)=ivp[octagons[i*8+4]]; ++fi;
217 fi->V(0)=ivp[octagons[i*8]]; fi->V(1)=ivp[octagons[i*8+4]]; fi->V(2)=ivp[octagons[i*8+5]]; ++fi;
218 fi->V(0)=ivp[octagons[i*8]]; fi->V(1)=ivp[octagons[i*8+5]]; fi->V(2)=ivp[octagons[i*8+6]]; ++fi;
219 fi->V(0)=ivp[octagons[i*8]]; fi->V(1)=ivp[octagons[i*8+6]]; fi->V(2)=ivp[octagons[i*8+7]]; ++fi;
220 }
221
222 if (in.HasPerFaceFlags()) {
223 FaceIterator fi=in.face.begin();
224 for (int k=0; k<44; k++) {
225 fi->SetF(1); fi++;
226 }
227 }
228
229 }
230
231 template <class MeshType>
Truncated_Octahedron(MeshType & in)232 void Truncated_Octahedron(MeshType &in)
233 {
234 // 6 squares and 8 hexagons
235 /* F = 14, V = 24
236 Perm(0, ±1, ±2)
237 */
238
239 typedef typename MeshType::CoordType CoordType;
240 typedef typename MeshType::VertexPointer VertexPointer;
241 typedef typename MeshType::VertexIterator VertexIterator;
242 typedef typename MeshType::FaceIterator FaceIterator;
243
244 in.Clear();
245 Allocator<MeshType>::AddVertices(in, 24);
246 Allocator<MeshType>::AddFaces(in, 6*2+8*4); // 44 faces
247
248 VertexPointer ivp[24];
249 VertexIterator vi;
250
251 int vertexes[72] = {
252 0, 1, 2, 0, 1,-2, 0,-1, 2, 0,-1,-2,
253 0, 2, 1, 0, 2,-1, 0,-2, 1, 0,-2,-1,
254 1, 0, 2, 1, 0,-2, 1, 2, 0, 1,-2, 0,
255 -1, 0, 2, -1, 0,-2, -1, 2, 0, -1,-2, 0,
256 2, 0, 1, 2, 0,-1, -2, 0, 1, -2, 0,-1,
257 2, 1, 0, 2,-1, 0, -2, 1, 0, -2,-1, 0 };
258
259 int i;
260 for(i=0, vi=in.vert.begin(); vi!=in.vert.end(); i++, vi++) {
261 ivp[i]=&*vi; vi->P()=CoordType ( vertexes[3*i], vertexes[3*i+1], vertexes[3*i+2]);
262 }
263
264 int squares[24] = {
265 10, 5,14, 4, 6,15, 7,11, 21,17,20,16,
266 18,22,19,23, 8, 0,12, 2, 3,13, 1, 9 };
267
268 int hexagons[48] = {
269 20,10, 4, 0, 8,16, 12,18,23,15, 6, 2, 23,19,13, 3, 7,15,
270 4,14,22,18,12, 0, 11, 7, 3, 9,17,21, 17, 9, 1, 5,10,20,
271 21,16, 8, 2, 6,11, 14, 5, 1,13,19,22 };
272
273 FaceIterator fi=in.face.begin();
274
275 for(int i=0; i<6; i++) {
276 fi->V(0)=ivp[squares[i*4]]; fi->V(1)=ivp[squares[i*4+1]]; fi->V(2)=ivp[squares[i*4+2]]; ++fi;
277 fi->V(0)=ivp[squares[i*4]]; fi->V(1)=ivp[squares[i*4+2]]; fi->V(2)=ivp[squares[i*4+3]]; ++fi;
278 }
279
280 for(int i=0; i<8; i++) {
281 fi->V(0)=ivp[hexagons[i*6]]; fi->V(1)=ivp[hexagons[i*6+1]]; fi->V(2)=ivp[hexagons[i*6+2]]; ++fi;
282 fi->V(0)=ivp[hexagons[i*6]]; fi->V(1)=ivp[hexagons[i*6+2]]; fi->V(2)=ivp[hexagons[i*6+3]]; ++fi;
283 fi->V(0)=ivp[hexagons[i*6]]; fi->V(1)=ivp[hexagons[i*6+3]]; fi->V(2)=ivp[hexagons[i*6+4]]; ++fi;
284 fi->V(0)=ivp[hexagons[i*6]]; fi->V(1)=ivp[hexagons[i*6+4]]; fi->V(2)=ivp[hexagons[i*6+5]]; ++fi;
285 }
286
287 if (in.HasPerFaceFlags()) {
288 FaceIterator fi=in.face.begin();
289 for (int k=0; k<44; k++) {
290 fi->SetF(1); fi++;
291 }
292 }
293
294 }
295
296 template <class MeshType>
Rhombicuboctahedron(MeshType & in)297 void Rhombicuboctahedron(MeshType &in)
298 {
299 // 8 triangles and 18 squares
300 /* F = 26, V = 24
301 Perm(±1, ±1, ±(1+√2))
302 */
303
304 typedef typename MeshType::CoordType CoordType;
305 typedef typename MeshType::VertexPointer VertexPointer;
306 typedef typename MeshType::VertexIterator VertexIterator;
307 typedef typename MeshType::FaceIterator FaceIterator;
308
309 double E = 1 + sqrt(2);
310
311 in.Clear();
312 Allocator<MeshType>::AddVertices(in, 24);
313 Allocator<MeshType>::AddFaces(in, 18*2+8); //44 faces
314
315 VertexPointer ivp[24];
316 VertexIterator vi;
317
318 double vertexes[72] = {
319 1, 1, E, 1, 1,-E, 1,-1, E, 1,-1,-E,
320 1, E, 1, 1, E,-1, 1,-E, 1, 1,-E,-1,
321 -1, 1, E, -1, 1,-E, -1,-1, E, -1,-1,-E,
322 -1, E, 1, -1, E,-1, -1,-E, 1, -1,-E,-1,
323 E, 1, 1, E, 1,-1, E,-1, 1, E,-1,-1,
324 -E, 1, 1, -E, 1,-1, -E,-1, 1, -E,-1,-1 };
325
326 int i;
327 for(i=0, vi=in.vert.begin(); vi!=in.vert.end(); i++, vi++) {
328 ivp[i]=&*vi; vi->P()=CoordType ( vertexes[3*i], vertexes[3*i+1], vertexes[3*i+2]);
329 }
330
331 int triangles[24] = {
332 16, 4, 0, 8,12,20, 21,13, 9, 1, 5,17,
333 19, 7, 3, 11,15,23, 22,14,10, 2, 6,18 };
334
335 int squares[72] = {
336 4,12, 8, 0, 0, 8,10, 2, 2,10,14, 6, 6,14,15, 7,
337 7,15,11, 3, 3,11, 9, 1, 1, 9,13, 5, 5,13,12, 4,
338 5, 4,16,17, 17,16,18,19, 19,18, 6, 7, 19, 3, 1,17,
339 15,14,22,23, 23,22,20,21, 21,20,12,13, 22,10, 8,20,
340 21, 9,11,23, 2,18,16, 0 };
341
342 FaceIterator fi=in.face.begin();
343
344 for(int i=0; i<8; i++) {
345 fi->V(0)=ivp[triangles[i*3]]; fi->V(1)=ivp[triangles[i*3+1]]; fi->V(2)=ivp[triangles[i*3+2]]; ++fi;
346 }
347
348 for(int i=0; i<18; i++) {
349 fi->V(0)=ivp[squares[i*4]]; fi->V(1)=ivp[squares[i*4+1]]; fi->V(2)=ivp[squares[i*4+2]]; ++fi;
350 fi->V(0)=ivp[squares[i*4]]; fi->V(1)=ivp[squares[i*4+2]]; fi->V(2)=ivp[squares[i*4+3]]; ++fi;
351 }
352
353 if (in.HasPerFaceFlags()) {
354 FaceIterator fi=in.face.begin();
355 for (int k=0; k<44; k++) {
356 fi->SetF(1); fi++;
357 }
358 }
359 }
360
361 template <class MeshType>
Truncated_Cuboctahedron(MeshType & in)362 void Truncated_Cuboctahedron(MeshType &in)
363 {
364 // 12 squares, 8 hexagons and 6 octagons
365 /* F = 26, V = 48
366 Perm(±1, ±(1+√2), ±(1+√8))
367 */
368
369 typedef typename MeshType::CoordType CoordType;
370 typedef typename MeshType::VertexPointer VertexPointer;
371 typedef typename MeshType::VertexIterator VertexIterator;
372 typedef typename MeshType::FaceIterator FaceIterator;
373
374 double E = 1 + sqrt(2);
375 double F = 1 + sqrt(8);
376
377 in.Clear();
378 Allocator<MeshType>::AddVertices(in, 48);
379 Allocator<MeshType>::AddFaces(in, 12*2+8*4+6*6); //92 faces
380
381 VertexPointer ivp[48];
382 VertexIterator vi;
383
384 double vertexes[144] = {
385 1, E, F, 1, E,-F, 1,-E, F, 1,-E,-F,
386 -1, E, F, -1, E,-F, -1,-E, F, -1,-E,-F,
387 1, F, E, 1, F,-E, 1,-F, E, 1,-F,-E,
388 -1, F, E, -1, F,-E, -1,-F, E, -1,-F,-E,
389 E, 1, F, E, 1,-F, E,-1, F, E,-1,-F,
390 -E, 1, F, -E, 1,-F, -E,-1, F, -E,-1,-F,
391 E, F, 1, E, F,-1, E,-F, 1, E,-F,-1,
392 -E, F, 1, -E, F,-1, -E,-F, 1, -E,-F,-1,
393 F, 1, E, F, 1,-E, F,-1, E, F,-1,-E,
394 -F, 1, E, -F, 1,-E, -F,-1, E, -F,-1,-E,
395 F, E, 1, F, E,-1, F,-E, 1, F,-E,-1,
396 -F, E, 1, -F, E,-1, -F,-E, 1, -F,-E,-1 };
397
398 int i;
399 for(i=0, vi=in.vert.begin(); vi!=in.vert.end(); i++, vi++) {
400 ivp[i]=&*vi; vi->P()=CoordType ( vertexes[3*i], vertexes[3*i+1], vertexes[3*i+2]);
401 }
402
403 int squares[48] = {
404 0, 8,12, 4, 10, 2, 6,14, 3,11,15, 7, 9, 1, 5,13,
405 28,29,45,44, 46,47,31,30, 26,27,43,42, 40,41,25,24,
406 22,20,36,38, 39,37,21,23, 19,17,33,35, 34,32,16,18 };
407
408 int hexagons[48] = {
409 25,41,33,17, 1, 9, 2,10,26,42,34,18, 27,11, 3,19,35,43,
410 16,32,40,24, 8, 0, 20, 4,12,28,44,36, 37,45,29,13, 5,21,
411 7,15,31,47,39,23, 14, 6,22,38,46,30};
412
413 int octagons[48] = {
414 12, 8,24,25, 9,13,29,28, 27,26,10,14,30,31,15,11,
415 23,21, 5, 1,17,19, 3, 7, 2,18,16, 0, 4,20,22, 6,
416 39,47,46,38,36,44,45,37, 34,42,43,35,33,41,40,32 };
417
418 FaceIterator fi=in.face.begin();
419
420 for(int i=0; i<12; i++) {
421 fi->V(0)=ivp[squares[i*4]]; fi->V(1)=ivp[squares[i*4+1]]; fi->V(2)=ivp[squares[i*4+2]];
422 fi->SetF(0); fi->SetF(2); ++fi;
423 fi->V(0)=ivp[squares[i*4]]; fi->V(1)=ivp[squares[i*4+2]]; fi->V(2)=ivp[squares[i*4+3]];
424 fi->SetF(0); fi->SetF(2); ++fi;
425 }
426
427 for(int i=0; i<8; i++) {
428 fi->V(0)=ivp[hexagons[i*6]]; fi->V(1)=ivp[hexagons[i*6+1]]; fi->V(2)=ivp[hexagons[i*6+2]]; ++fi;
429 fi->V(0)=ivp[hexagons[i*6]]; fi->V(1)=ivp[hexagons[i*6+2]]; fi->V(2)=ivp[hexagons[i*6+3]]; ++fi;
430 fi->V(0)=ivp[hexagons[i*6]]; fi->V(1)=ivp[hexagons[i*6+3]]; fi->V(2)=ivp[hexagons[i*6+4]]; ++fi;
431 fi->V(0)=ivp[hexagons[i*6]]; fi->V(1)=ivp[hexagons[i*6+4]]; fi->V(2)=ivp[hexagons[i*6+5]]; ++fi;
432 }
433
434 for(int i=0; i<6; i++) {
435 fi->V(0)=ivp[octagons[i*8]]; fi->V(1)=ivp[octagons[i*8+1]]; fi->V(2)=ivp[octagons[i*8+2]]; ++fi;
436 fi->V(0)=ivp[octagons[i*8]]; fi->V(1)=ivp[octagons[i*8+2]]; fi->V(2)=ivp[octagons[i*8+3]]; ++fi;
437 fi->V(0)=ivp[octagons[i*8]]; fi->V(1)=ivp[octagons[i*8+3]]; fi->V(2)=ivp[octagons[i*8+4]]; ++fi;
438 fi->V(0)=ivp[octagons[i*8]]; fi->V(1)=ivp[octagons[i*8+4]]; fi->V(2)=ivp[octagons[i*8+5]]; ++fi;
439 fi->V(0)=ivp[octagons[i*8]]; fi->V(1)=ivp[octagons[i*8+5]]; fi->V(2)=ivp[octagons[i*8+6]]; ++fi;
440 fi->V(0)=ivp[octagons[i*8]]; fi->V(1)=ivp[octagons[i*8+6]]; fi->V(2)=ivp[octagons[i*8+7]]; ++fi;
441 }
442
443 }
444
445
446 // Are vertexes ok? Something goes wrong..
447 template <class MeshType>
Snub_Cube(MeshType & in)448 void Snub_Cube(MeshType &in)
449 {
450 // 32 triangles and 6 squares
451 /* F = 38, V = 24
452 Only Even Perm(±1, ±ξ, ±1/ξ)
453 where ξ3+ξ2+ξ=1
454 */
455
456 typedef typename MeshType::CoordType CoordType;
457 typedef typename MeshType::VertexPointer VertexPointer;
458 typedef typename MeshType::VertexIterator VertexIterator;
459 typedef typename MeshType::FaceIterator FaceIterator;
460
461 //double E = (pow(17+3*sqrt(33), 1/3.0) - pow(-17+3*sqrt(33), 1/3.0) -1) / 3.0; //en
462 //double E = (pow(19+3*sqrt(33), 1/3.0) + pow(19-3*sqrt(33), 1/3.0) +1) / 3.0; //cat
463 double E = (pow(19+3*sqrt(33), 1/3.0) + pow(19-3*sqrt(33), 1/3.0) -2) / 6.0; //de
464
465 in.Clear();
466 Allocator<MeshType>::AddVertices(in, 24);
467 // Allocator<MeshType>::AddFaces(in, 32+6*2); //44 faces
468 Allocator<MeshType>::AddFaces(in, 9);
469
470 VertexPointer ivp[24];
471 VertexIterator vi;
472
473 double vertexes[72] = {
474 1, E, 1/E, 1, E,-1/E, 1,-E, 1/E, 1,-E,-1/E,
475 -1, E, 1/E, -1, E,-1/E, -1,-E, 1/E, -1,-E,-1/E,
476 E, 1/E, 1, E, 1/E,-1, E,-1/E, 1, E,-1/E,-1,
477 -E, 1/E, 1, -E, 1/E,-1, -E,-1/E, 1, -E,-1/E,-1,
478 1/E, 1, E, 1/E, 1,-E, 1/E,-1, E, 1/E,-1,-E,
479 -1/E, 1, E, -1/E, 1,-E, -1/E,-1, E, -1/E,-1,-E };
480
481 int i;
482 for(i=0, vi=in.vert.begin(); vi!=in.vert.end(); i++, vi++) {
483 ivp[i]=&*vi; vi->P()=CoordType ( vertexes[3*i], vertexes[3*i+1], vertexes[3*i+2]);
484 }
485
486 int triangles[48] = {
487 16, 8, 0, 18, 2,10, 14, 6,22, 20, 4,12,
488 1, 9,17, 7,15,23, 21,13, 5, 11, 3,19,
489 5,21,13,
490 };
491
492 FaceIterator fi=in.face.begin();
493
494 for(int i=0; i<9; i++) {
495 fi->V(0)=ivp[triangles[i*3]]; fi->V(1)=ivp[triangles[i*3+1]]; fi->V(2)=ivp[triangles[i*3+2]]; ++fi;
496 }
497
498
499 }
500
501
502 template <class MeshType>
Icosidodecahedron(MeshType & in)503 void Icosidodecahedron(MeshType &in)
504 {
505 // 20 triangles and 12 pentagons
506 /* F = 32, V = 30
507 Cyclic permutations of (0,0,±τ) and (±1/2, ±τ/2, ±(1+τ)/2)
508 where τ is the golden ratio, (1+√5)/2
509 */
510
511 typedef typename MeshType::CoordType CoordType;
512 typedef typename MeshType::VertexPointer VertexPointer;
513 typedef typename MeshType::VertexIterator VertexIterator;
514 typedef typename MeshType::FaceIterator FaceIterator;
515
516 in.Clear();
517 Allocator<MeshType>::AddVertices(in, 30);
518 Allocator<MeshType>::AddFaces(in, 20+12*3); //56 faces
519
520 VertexPointer ivp[30];
521 VertexIterator vi;
522
523 double G = (1 + sqrt(5))/2;
524
525 double vertexes[90] = {
526 0,0,G, 0,0,-G, G,0,0, -G,0,0, 0,G,0, 0,-G,0,
527 0.5, G/2, (1+G)/2, 0.5, G/2,-(1+G)/2, 0.5,-G/2, (1+G)/2, 0.5,-G/2,-(1+G)/2,
528 -0.5, G/2, (1+G)/2, -0.5, G/2,-(1+G)/2, -0.5,-G/2, (1+G)/2, -0.5,-G/2,-(1+G)/2,
529 (1+G)/2, 0.5, G/2, (1+G)/2, 0.5,-G/2, (1+G)/2,-0.5, G/2, (1+G)/2,-0.5,-G/2,
530 -(1+G)/2, 0.5, G/2, -(1+G)/2, 0.5,-G/2, -(1+G)/2,-0.5, G/2, -(1+G)/2,-0.5,-G/2,
531 G/2, (1+G)/2, 0.5, G/2, (1+G)/2,-0.5, G/2,-(1+G)/2, 0.5, G/2,-(1+G)/2,-0.5,
532 -G/2, (1+G)/2, 0.5, -G/2, (1+G)/2,-0.5, -G/2,-(1+G)/2, 0.5, -G/2,-(1+G)/2,-0.5,
533 };
534
535 int i;
536 for(i=0, vi=in.vert.begin(); vi!=in.vert.end(); i++, vi++) {
537 ivp[i]=&*vi; vi->P()=CoordType ( vertexes[3*i], vertexes[3*i+1], vertexes[3*i+2]);
538 }
539
540 int triangles[60] = {
541 26,18,10, 22, 6,14, 16, 8,24, 5,28,29, 13,29,21,
542 11,19,27, 18, 3,20, 24, 5,25, 17,25, 9, 4,27,26,
543 22,23, 4, 6,10, 0, 2,14,16, 1, 9,13, 3,19,21,
544 17,15, 2, 8, 0,12, 28,12,20, 11, 7, 1, 23,15, 7 };
545
546 int pentagons[60] = {
547 8,16,14, 6, 0, 14, 2,15,23,22, 23, 7,11,27, 4, 1,13,21,19,11,
548 27,19, 3,18,26, 13, 9,25, 5,29, 3,21,29,28,20, 18,20,12, 0,10,
549 4,26,10, 6,22, 24, 8,12,28, 5, 17, 2,16,24,25, 7,15,17, 9, 1 };
550
551 FaceIterator fi=in.face.begin();
552
553 for(int i=0; i<20; i++) {
554 fi->V(0)=ivp[triangles[i*3]]; fi->V(1)=ivp[triangles[i*3+1]]; fi->V(2)=ivp[triangles[i*3+2]]; ++fi;
555 }
556
557 for(int i=0; i<12; i++) {
558 fi->V(0)=ivp[pentagons[i*5]]; fi->V(1)=ivp[pentagons[i*5+1]]; fi->V(2)=ivp[pentagons[i*5+2]]; ++fi;
559 fi->V(0)=ivp[pentagons[i*5]]; fi->V(1)=ivp[pentagons[i*5+2]]; fi->V(2)=ivp[pentagons[i*5+3]]; ++fi;
560 fi->V(0)=ivp[pentagons[i*5]]; fi->V(1)=ivp[pentagons[i*5+3]]; fi->V(2)=ivp[pentagons[i*5+4]]; ++fi;
561 }
562
563
564
565
566 }
567
568
569 template <class MeshType>
Truncated_Dodecahedron(MeshType & in)570 void Truncated_Dodecahedron(MeshType &in)
571 {
572 // 20 triangles and 12 decagons
573 /* F = 32, V = 60
574 (0, ±1/τ, ±(2+τ))
575 (±(2+τ), 0, ±1/τ)
576 (±1/τ, ±(2+τ), 0)
577 (±1/τ, ±τ, ±2τ)
578 (±2τ, ±1/τ, ±τ)
579 (±τ, ±2τ, ±1/τ)
580 (±τ, ±2, ±τ2)
581 (±τ2, ±τ, ±2)
582 (±2, ±τ2, ±τ)
583 where τ = (1+√5)/2 is the golden ratio
584 */
585
586 }
587
588 // (soccer ball, for friends)
589 template <class MeshType>
Truncated_Icosahedron(MeshType & in)590 void Truncated_Icosahedron(MeshType &in)
591 {
592 // 12 pentagons and 20 hexagons
593 /* F = 32, V = 60
594 (0,±1,±3φ), (±1,±3φ,0), (±3φ,0,±1)
595 (±2,±(1+2φ),±φ), (±(1+2φ),±φ,±2), (±φ,±2,±(1+2φ))
596 (±1,±(2+φ),±2φ), (±(2+φ),±2φ,±1), (±2φ,±1,±(2+φ))
597 where φ = (1+√5)/2
598 */
599
600 typedef typename MeshType::CoordType CoordType;
601 typedef typename MeshType::VertexPointer VertexPointer;
602 typedef typename MeshType::VertexIterator VertexIterator;
603 typedef typename MeshType::FaceIterator FaceIterator;
604
605 //Why isn't golden ratio defined in math.h ?!?!
606 double G = (1 + sqrt(5))/2;
607 //double G3 = 3*G; double G2 = 2*G; double A = 1+G2;
608
609 in.Clear();
610 Allocator<MeshType>::AddVertices(in, 60);
611 Allocator<MeshType>::AddFaces(in, 12*3+20*4); //116 faces!!!
612
613 int pentagons[5*12]= {
614 16, 6, 17, 49, 48, 0, 28, 36, 40, 32,
615 39, 43, 35, 3, 31, 55, 53, 21, 9, 23,
616 15, 47, 46, 14, 5, 29, 1, 33, 41, 37,
617 24, 10, 26, 58, 56, 22, 8, 20, 52, 54,
618 42, 38, 30, 2, 34, 19, 7, 18, 50, 51,
619 59, 27, 11, 25, 57, 44, 45, 13, 4, 12 };
620
621 int hexagons[20*6]= {
622 3, 1, 29, 53, 55, 31, 56, 32, 40, 16, 48, 24,
623 24, 48, 49, 25, 11, 10, 2, 0, 32, 56, 58, 34,
624 18, 42, 34, 58, 26, 50, 43, 19, 51, 27, 59, 35,
625 49, 17, 41, 33, 57, 25, 21, 53, 29, 37, 13, 45,
626 52, 20, 44, 12, 36, 28, 35, 59, 57, 33, 1, 3,
627 15, 39, 31, 55, 23, 47, 46, 47, 23, 9, 8, 22,
628 38, 14, 46, 22, 54, 30, 4, 13, 37, 41, 17, 6,
629 12, 4, 6, 16, 40, 36, 54, 52, 28, 0, 2, 30,
630 8, 9, 21, 45, 44, 20, 7, 5, 14, 38, 42, 18,
631 43, 39, 15, 5, 7, 19, 10, 11, 27, 51, 50, 26 };
632
633 double vertexes[180] = {
634 0, 1, 3*G, 0, 1,-3*G, 0,-1, 3*G, 0,-1,-3*G,
635 1, 3*G, 0, 1,-3*G, 0, -1, 3*G, 0, -1,-3*G, 0,
636 3*G, 0, 1, 3*G, 0,-1, -3*G, 0, 1, -3*G, 0,-1,
637 2, 1+2*G, G, 2, 1+2*G,-G, 2,-1-2*G, G, 2,-1-2*G,-G,
638 -2, 1+2*G, G, -2, 1+2*G,-G, -2,-1-2*G, G, -2,-1-2*G,-G,
639 1+2*G, G, 2, 1+2*G, G,-2, 1+2*G,-G, 2, 1+2*G,-G,-2,
640 -1-2*G, G, 2, -1-2*G, G,-2, -1-2*G,-G, 2, -1-2*G,-G,-2,
641 G, 2, 1+2*G, G, 2,-1-2*G, G,-2, 1+2*G, G,-2,-1-2*G,
642 -G, 2, 1+2*G, -G, 2,-1-2*G, -G,-2, 1+2*G, -G,-2,-1-2*G,
643 1, 2+G, 2*G, 1, 2+G,-2*G, 1,-2-G, 2*G, 1,-2-G,-2*G,
644 -1, 2+G, 2*G, -1, 2+G,-2*G, -1,-2-G, 2*G, -1,-2-G,-2*G,
645 2+G, 2*G, 1, 2+G, 2*G,-1, 2+G,-2*G, 1, 2+G,-2*G,-1,
646 -2-G, 2*G, 1, -2-G, 2*G,-1, -2-G,-2*G, 1, -2-G,-2*G,-1,
647 2*G, 1, 2+G, 2*G, 1,-2-G, 2*G,-1, 2+G, 2*G,-1,-2-G,
648 -2*G, 1, 2+G, -2*G, 1,-2-G, -2*G,-1, 2+G, -2*G,-1,-2-G };
649
650 VertexPointer ivp[60];
651 VertexIterator vi;
652 int i;
653
654 for(i=0, vi=in.vert.begin(); vi!=in.vert.end(); i++, vi++) {
655 ivp[i]=&*vi; vi->P()=CoordType ( vertexes[3*i], vertexes[3*i+1], vertexes[3*i+2]);
656 }
657
658 FaceIterator fi=in.face.begin();
659
660 for(int i=0; i<12; i++) {
661 fi->V(0)=ivp[pentagons[i*5]]; fi->V(1)=ivp[pentagons[i*5+1]]; fi->V(2)=ivp[pentagons[i*5+2]]; ++fi;
662 fi->V(0)=ivp[pentagons[i*5]]; fi->V(1)=ivp[pentagons[i*5+2]]; fi->V(2)=ivp[pentagons[i*5+3]]; ++fi;
663 fi->V(0)=ivp[pentagons[i*5]]; fi->V(1)=ivp[pentagons[i*5+3]]; fi->V(2)=ivp[pentagons[i*5+4]]; ++fi;
664 }
665
666 for(int i=0; i<20; i++) {
667 fi->V(0)=ivp[hexagons[i*6]]; fi->V(1)=ivp[hexagons[i*6+1]]; fi->V(2)=ivp[hexagons[i*6+2]]; ++fi;
668 fi->V(0)=ivp[hexagons[i*6]]; fi->V(1)=ivp[hexagons[i*6+2]]; fi->V(2)=ivp[hexagons[i*6+3]]; ++fi;
669 fi->V(0)=ivp[hexagons[i*6]]; fi->V(1)=ivp[hexagons[i*6+3]]; fi->V(2)=ivp[hexagons[i*6+4]]; ++fi;
670 fi->V(0)=ivp[hexagons[i*6]]; fi->V(1)=ivp[hexagons[i*6+4]]; fi->V(2)=ivp[hexagons[i*6+5]]; ++fi;
671 }
672
673 if (in.HasPerFaceFlags()) {
674 FaceIterator fi=in.face.begin();
675 for (int k=0; k<116; k++) {
676 fi->SetF(1); fi++;
677 }
678 }
679
680 }
681
682 template <class MeshType>
Rhombicosidodecahedron(MeshType & in)683 void Rhombicosidodecahedron(MeshType &in)
684 {
685 /*
686 */
687
688 }
689
690 template <class MeshType>
Truncated_Icosidodecahedron(MeshType & in)691 void Truncated_Icosidodecahedron(MeshType &in)
692 {
693 /*
694 */
695
696 }
697
698 template <class MeshType>
Snub_Dodecahedron(MeshType & in)699 void Snub_Dodecahedron(MeshType &in)
700 {
701 /*
702 */
703
704 }
705
706 } // End Namespace TriMesh
707 } // End Namespace vcg
708
709 #endif // __VCGLIB_ARCHIMEDEAN_H
710