Création d'un compte pour un collaborateur extérieur au laboratoire depuis l'intranet ICube : https://intranet.icube.unistra.fr/fr/labs/member/profile

tilings.cpp 12.2 KB
Newer Older
Lionel Untereiner's avatar
Lionel Untereiner committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/*******************************************************************************
* CGoGN: Combinatorial and Geometric modeling with Generic N-dimensional Maps  *
* version 0.1                                                                  *
* Copyright (C) 2009-2012, IGG Team, LSIIT, University of Strasbourg           *
*                                                                              *
* This library is free software; you can redistribute it and/or modify it      *
* under the terms of the GNU Lesser General Public License as published by the *
* Free Software Foundation; either version 2.1 of the License, or (at your     *
* option) any later version.                                                   *
*                                                                              *
* This library is distributed in the hope that it will be useful, but WITHOUT  *
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or        *
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License  *
* for more details.                                                            *
*                                                                              *
* You should have received a copy of the GNU Lesser General Public License     *
* along with this library; if not, write to the Free Software Foundation,      *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.           *
*                                                                              *
* Web site: http://cgogn.unistra.fr/                                           *
* Contact information: cgogn@unistra.fr                                        *
*                                                                              *
*******************************************************************************/

untereiner's avatar
untereiner committed
25
#include "tilings.h"
Lionel Untereiner's avatar
Lionel Untereiner committed
26
27
28

#include "Geometry/vector_gen.h"

untereiner's avatar
untereiner committed
29
30
31
32
33
#include "Algo/Import/import.h"
#include "Algo/Geometry/boundingbox.h"
#include "Utils/GLSLShader.h"
//#include "Algo/Geometry/area.h"
#include "Algo/Geometry/normal.h"
untereiner's avatar
untereiner committed
34
35
#include "Geometry/matrix.h"
#include "Geometry/transfo.h"
Lionel Untereiner's avatar
Lionel Untereiner committed
36

untereiner's avatar
untereiner committed
37
38
#include "Utils/cgognStream.h"
#include "Utils/chrono.h"
Lionel Untereiner's avatar
Lionel Untereiner committed
39
40
41
42
43
44
45
46
47

using namespace CGoGN ;

/**
 * Struct that contains some informations about the types of the manipulated objects
 * Mainly here to be used by the algorithms that are parameterized by it
 */
struct PFP: public PFP_STANDARD
{
48
49
	// definition of the map
	typedef EmbeddedMap2 MAP;
Lionel Untereiner's avatar
Lionel Untereiner committed
50
51
};

Pierre Kraemer's avatar
Pierre Kraemer committed
52
53
typedef PFP::MAP MAP;
typedef PFP::VEC3 VEC3;
untereiner's avatar
untereiner committed
54
55

PFP::MAP myMap;
Pierre Kraemer's avatar
Pierre Kraemer committed
56

57
58
59
VertexAttribute<VEC3, MAP> position;
VertexAttribute<VEC3, MAP> position2;
VertexAttribute<VEC3, MAP> normal;
untereiner's avatar
untereiner committed
60
61
62

void MyQT::cb_initGL()
{
63
64
	// create the render
	m_render = new Algo::Render::GL2::MapRender();
untereiner's avatar
untereiner committed
65

66
67
68
	// create VBO for position
	m_positionVBO = new Utils::VBO();
	m_positionVBO->updateData(position);
untereiner's avatar
untereiner committed
69

70
	m_normalVBO =  new Utils::VBO();
untereiner's avatar
untereiner committed
71

72
73
74
	m_shader = new Utils::ShaderSimpleColor();
	m_shader->setAttributePosition(m_positionVBO);
	m_shader->setColor(Geom::Vec4f(1.,1.,0.,0.));
untereiner's avatar
untereiner committed
75

76
77
78
79
80
	m_lines = new Utils::ShaderVectorPerVertex();
	m_lines->setAttributePosition(m_positionVBO);
	m_lines->setAttributeVector(m_normalVBO);
	m_lines->setScale(0.2f);
	m_lines->setColor(Geom::Vec4f(0.0f, 1.0f, 0.2f, 0.0f));
untereiner's avatar
untereiner committed
81

82
	Algo::Surface::Geometry::computeNormalVertices<PFP>(myMap, position, normal) ;
untereiner's avatar
untereiner committed
83

84
85
	m_render->initPrimitives<PFP>(myMap, Algo::Render::GL2::LINES);
	m_render->initPrimitives<PFP>(myMap, Algo::Render::GL2::POINTS);
untereiner's avatar
untereiner committed
86

87
88
	registerShader(m_shader);
	registerShader(m_lines);
untereiner's avatar
untereiner committed
89

90
	m_normalVBO->updateData(normal);
untereiner's avatar
untereiner committed
91
92
93
94
}

void MyQT::cb_redraw()
{
95
96
97
98
99
100
101
102
103
104
105
	m_render->draw(m_shader, Algo::Render::GL2::LINES);
	m_render->draw(m_lines, Algo::Render::GL2::POINTS);
}

void MyQT::squareTiling(int code)
{
	switch(code)
	{
		case 1:
		{
			std::cout << "square grid tiling" << std::endl;
106
107
			Algo::Surface::Tilings::Square::Grid<PFP> g(myMap, 10, 10, true);
			g.embedIntoGrid(position, 1.0, 1.0, 0.0);
untereiner's avatar
untereiner committed
108
109
110

			Geom::Matrix44f trf;
			trf.identity();
111
			Geom::translate<float>(0.5, 0.5, 0.0, trf);
untereiner's avatar
untereiner committed
112
			g.transform(position, trf);
113

untereiner's avatar
untereiner committed
114
115
			g.exportPositions(position, "grid.bs");

116
117
118
119
120
			break;
		}
		case 2:
		{
			std::cout << "square grid twisted strip tiling" << std::endl;
121
			Algo::Surface::Tilings::Square::Grid<PFP> g(myMap, 10, 10, true);
Sylvain Thery's avatar
Sylvain Thery committed
122
			g.embedIntoTwistedStrip(position, 0.2f, 0.7f, 5);
untereiner's avatar
untereiner committed
123
124
125

			Geom::Matrix44f trf;
			trf.identity();
126
			Geom::translate<float>(0.5, 0.5, 0.0, trf);
untereiner's avatar
untereiner committed
127
128
			g.transform(position, trf);

129

untereiner's avatar
untereiner committed
130
131
			g.exportPositions(position, "gridtwisted.bs");

132
133
134
135
			break;
		}
		case 3:
		{
untereiner's avatar
untereiner committed
136
			std::cout << "square grid helicoid tiling" << std::endl;
137
			Algo::Surface::Tilings::Square::Grid<PFP> g(myMap,20,20,true);
Sylvain Thery's avatar
Sylvain Thery committed
138
			g.embedIntoHelicoid(position, 0.2f,  0.3f, 0.8f, 2.0f);
untereiner's avatar
untereiner committed
139
140
141
142
143
144

//			Geom::Matrix44f trf;
//			trf.identity();
//			Geom::translate<float>(0.5,0.5,0.0,trf);
//			g.transform(position, trf);

145

untereiner's avatar
untereiner committed
146
147
			g.exportPositions(position, "gridhelicoid.bs");

148
149
150
151
152
153
			break;
		}
		case 4:
		{
			std::cout << "square cylinder tiling" << std::endl;
			Algo::Surface::Tilings::Square::Cylinder<PFP> c(myMap,20,20);
Sylvain Thery's avatar
Sylvain Thery committed
154
			c.embedIntoCylinder(position,0.5f,0.7f,1.0f);
untereiner's avatar
untereiner committed
155
156
157

			Geom::Matrix44f trf;
			trf.identity();
Sylvain Thery's avatar
Sylvain Thery committed
158
			Geom::translate<float>(0.5f,0.5f,0.0f,trf);
untereiner's avatar
untereiner committed
159
160
			c.transform(position, trf);

161

untereiner's avatar
untereiner committed
162
163
			c.exportPositions(position, "cylinder.bs");

164
165
166
167
168
169
170
171
			break;
		}
		case 5:
		{
			std::cout << "square cylinder tiling" << std::endl;
			Algo::Surface::Tilings::Square::Cylinder<PFP> c(myMap,20,20);
			c.triangleBottom();
			c.triangleTop();
Sylvain Thery's avatar
Sylvain Thery committed
172
			c.embedIntoCylinder(position,0.5f,0.7f,1.0f);
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191

			break;
		}
		case 6:
		{
			std::cout << "square cylinder sphere tiling" << std::endl;
			Algo::Surface::Tilings::Square::Cylinder<PFP> c(myMap,20,20);
			c.triangleTop();
			c.triangleBottom();
			c.embedIntoSphere(position,0.5);

			break;
		}
		case 7:
		{
			std::cout << "square cylinder cone tiling" << std::endl;
			Algo::Surface::Tilings::Square::Cylinder<PFP> c(myMap,20,20);
			c.triangleTop();
			c.triangleBottom();
untereiner's avatar
untereiner committed
192
			c.embedIntoCone(position,0.5, 1.0);
193
194
195
196
197

			break;
		}
		case 8:
		{
Lionel Untereiner's avatar
Lionel Untereiner committed
198
199
            std::cout << "square cube tiling" << std::endl;
            Algo::Surface::Tilings::Square::Cube<PFP> c(myMap,1,1,2);
untereiner's avatar
untereiner committed
200
201
202
203
204
205
			c.embedIntoCube(position,1.0, 1.0, 1.0);

			Geom::Matrix44f trf;
			trf.identity();
			Geom::translate<float>(0.5,0.5,0.5,trf);
			c.transform(position, trf);
206

untereiner's avatar
untereiner committed
207
208
			c.exportPositions(position, "cube.bs");

209
210
211
212
			break;
		}
		case 9:
		{
untereiner's avatar
untereiner committed
213
			std::cout << "square tore tiling" << std::endl;
214
			Algo::Surface::Tilings::Square::Tore<PFP> c(myMap,20,10);
Sylvain Thery's avatar
Sylvain Thery committed
215
			c.embedIntoTore(position, 0.9f, 0.5f);
216

untereiner's avatar
untereiner committed
217
			c.exportPositions(position, "tore.bs");
218
219
220
221
222
223
224
225
			break;
		}

		default:
		{
			break;
		}
	}
untereiner's avatar
untereiner committed
226
227

	myMap.check();
untereiner's avatar
untereiner committed
228
229
230
}

// mouse picking
231
void MyQT::triangularTiling(int code)
Lionel Untereiner's avatar
Lionel Untereiner committed
232
{
233
234
235
236
	switch(code)
	{
		case 1:
		{
untereiner's avatar
untereiner committed
237
			std::cout << "triangle grid tiling" << std::endl;
238
            Algo::Surface::Tilings::Triangular::Grid<PFP> g(myMap,1,5,true);
untereiner's avatar
untereiner committed
239
			g.embedIntoGrid(position,1,1);
240
241
242
243
244

			break;
		}
		case 2:
		{
untereiner's avatar
untereiner committed
245
246
			std::cout << "triangle grid twisted strip tiling" << std::endl;
			Algo::Surface::Tilings::Triangular::Grid<PFP> g(myMap,10,10,true);
Sylvain Thery's avatar
Sylvain Thery committed
247
			g.embedIntoTwistedStrip(position, 0.3f, 0.8f, 5);
248
249
250
251
252

			break;
		}
		case 3:
		{
untereiner's avatar
untereiner committed
253
254
			std::cout << "triangle grid helocoid tiling" << std::endl;
			Algo::Surface::Tilings::Triangular::Grid<PFP> g(myMap,20,20,true);
Sylvain Thery's avatar
Sylvain Thery committed
255
			g.embedIntoHelicoid(position, 0.3f,  0.8f, 5.0f, 2.0f);
256
257
258
259
260

			break;
		}
		case 4:
		{
untereiner's avatar
untereiner committed
261
262
			std::cout << "triangle cylinder tiling" << std::endl;
			Algo::Surface::Tilings::Triangular::Cylinder<PFP> c(myMap,20,20);
Sylvain Thery's avatar
Sylvain Thery committed
263
			c.embedIntoCylinder(position,0.5f,0.7f,5.0f);
264
265
266
267
268

			break;
		}
		case 5:
		{
untereiner's avatar
untereiner committed
269
270
271
272
			std::cout << "triangle cylinder tiling" << std::endl;
			Algo::Surface::Tilings::Triangular::Cylinder<PFP> c(myMap,20,20);
			c.triangleBottom();
			c.triangleTop();
Sylvain Thery's avatar
Sylvain Thery committed
273
			c.embedIntoCylinder(position,0.5f,0.7f,5.0f);
274
275
276
277
278

			break;
		}
		case 6:
		{
untereiner's avatar
untereiner committed
279
280
281
282
			std::cout << "triangle cylinder sphere tiling" << std::endl;
			Algo::Surface::Tilings::Triangular::Cylinder<PFP> c(myMap,20,20);
			c.triangleTop();
			c.triangleBottom();
Sylvain Thery's avatar
Sylvain Thery committed
283
			c.embedIntoSphere(position,0.5f);
284
285
286
287
288

			break;
		}
		case 7:
		{
untereiner's avatar
untereiner committed
289
290
291
292
			std::cout << "triangle cylinder cone tiling" << std::endl;
			Algo::Surface::Tilings::Triangular::Cylinder<PFP> c(myMap,20,20);
			c.triangleTop();
			c.triangleBottom();
Sylvain Thery's avatar
Sylvain Thery committed
293
			c.embedIntoCone(position,0.5f, 5.0f);
294
295
296
297
298

			break;
		}
		case 8:
		{
Lionel Untereiner's avatar
Lionel Untereiner committed
299
300
            std::cout << "triangle cube tiling" << std::endl;
            Algo::Surface::Tilings::Triangular::Cube<PFP> c(myMap,4,4,4);
Sylvain Thery's avatar
Sylvain Thery committed
301
            c.embedIntoCube(position,5.0f,5.0f, 5.0f);
302
303
304
305
306

			break;
		}
		case 9:
		{
Lionel Untereiner's avatar
Lionel Untereiner committed
307
308
            std::cout << "triangle tore tiling" << std::endl;
            Algo::Surface::Tilings::Triangular::Tore<PFP> c(myMap,20,10);
Sylvain Thery's avatar
Sylvain Thery committed
309
            c.embedIntoTore(position,5.0f,2.0f);
310
311
312
313
314
315
316
317
318

			break;
		}

		default:
		{
			break;
		}
	}
untereiner's avatar
untereiner committed
319
}
Lionel Untereiner's avatar
Lionel Untereiner committed
320

321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410

void MyQT::hexagonalTiling(int code)
{
    switch(code)
    {
        case 1:
        {
            std::cout << "hexagonal grid tiling" << std::endl;
            Algo::Surface::Tilings::Hexagonal::Grid<PFP> g(myMap,10,6,true);
            g.embedIntoGrid(position,1,1);

            break;
        }
        case 2:
        {
//            std::cout << "hexagonal grid twisted strip tiling" << std::endl;
//            Algo::Surface::Tilings::Triangular::Grid<PFP> g(myMap,10,10,true);
//            g.embedIntoTwistedStrip(position, 0.3, 0.8, 5);

            break;
        }
        case 3:
        {
//            std::cout << "hexagonal grid helocoid tiling" << std::endl;
//            Algo::Surface::Tilings::Triangular::Grid<PFP> g(myMap,20,20,true);
//            g.embedIntoHelicoid(position, 0.3,  0.8, 5.0, 2.0);

            break;
        }
        case 4:
        {
//            std::cout << "hexagonal cylinder tiling" << std::endl;
//            Algo::Surface::Tilings::Triangular::Cylinder<PFP> c(myMap,20,20);
//            c.embedIntoCylinder(position,0.5,0.7,5.0);

            break;
        }
        case 5:
        {
//            std::cout << "hexagonal cylinder tiling" << std::endl;
//            Algo::Surface::Tilings::Triangular::Cylinder<PFP> c(myMap,20,20);
//            c.triangleBottom();
//            c.triangleTop();
//            c.embedIntoCylinder(position,0.5,0.7,5.0);

            break;
        }
        case 6:
        {
//			std::cout << "hexagonal cylinder sphere tiling" << std::endl;
//			Algo::Surface::Tilings::Triangular::Cylinder<PFP> c(myMap,20,20);
//			c.triangleTop();
//			c.triangleBottom();
//			c.embedIntoSphere(position,0.5);

            break;
        }
        case 7:
        {
//			std::cout << "hexagonal cylinder cone tiling" << std::endl;
//			Algo::Surface::Tilings::Triangular::Cylinder<PFP> c(myMap,20,20);
//			c.triangleTop();
//			c.triangleBottom();
//			c.embedIntoCone(position,0.5, 5.0);

            break;
        }
        case 8:
        {
//            std::cout << "hexagonal cube tiling" << std::endl;
//            Algo::Surface::Tilings::Triangular::Cube<PFP> c(myMap,4,4,4);
//            c.embedIntoCube(position,5.0,5.0, 5.0);

            break;
        }
        case 9:
        {
//            std::cout << "hexagonal tore tiling" << std::endl;
//            Algo::Surface::Tilings::Triangular::Tore<PFP> c(myMap,20,10);
//            c.embedIntoTore(position,5.0,2.0);

            break;
        }

        default:
        {
            break;
        }
    }
}
untereiner's avatar
untereiner committed
411
412
int main(int argc, char **argv)
{
413
414
415
	// interface:
	QApplication app(argc, argv);
	MyQT sqt;
untereiner's avatar
untereiner committed
416

417
418
	sqt.statusMsg("Neww to create a sphere or Load for a mesh file");
	CGoGNStream::allToConsole(&sqt);
Lionel Untereiner's avatar
Lionel Untereiner committed
419

420
	if (!position.isValid())
421
		position = myMap.addAttribute<PFP::VEC3, VERTEX, MAP>("position");
Lionel Untereiner's avatar
Lionel Untereiner committed
422

423
	if (!normal.isValid())
424
		normal = myMap.addAttribute<PFP::VEC3, VERTEX, MAP>("normal");
untereiner's avatar
untereiner committed
425

426
427
428
429
430
431
	if(argc == 3)
	{
		if(argv[1][0] == 'S')
			sqt.squareTiling(atoi(argv[2]));
		else if(argv[1][0] == 'T')
			sqt.triangularTiling(atoi(argv[2]));
432
433
434
435
        else if(argv[1][0] == 'H')
            sqt.hexagonalTiling(atoi(argv[2]));
        else
            return -1;
436
	}
437
	myMap.check();
Lionel Untereiner's avatar
Lionel Untereiner committed
438

439
440
441
442
443
444
445
	//  bounding box
	Geom::BoundingBox<PFP::VEC3> bb = Algo::Geometry::computeBoundingBox<PFP>(myMap, position);
	float lWidthObj = std::max<PFP::REAL>(std::max<PFP::REAL>(bb.size(0), bb.size(1)), bb.size(2));
	Geom::Vec3f lPosObj = (bb.min() +  bb.max()) / PFP::REAL(2);
	CGoGNout << "lPosObj=" << lPosObj << CGoGNendl;
	CGoGNout << "lWidthObj=" << lWidthObj << CGoGNendl;
	sqt.setParamObject(lWidthObj,lPosObj.data());
untereiner's avatar
untereiner committed
446

447
448
	//	myMap.enableQuickTraversal<EDGE>() ;
	//	myMap.enableQuickTraversal<VERTEX>() ;
untereiner's avatar
untereiner committed
449

450
	sqt.show();
untereiner's avatar
untereiner committed
451

452
	return app.exec();
Lionel Untereiner's avatar
Lionel Untereiner committed
453
}