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

tuto_dual2.cpp 5.25 KB
Newer Older
untereiner's avatar
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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
/*******************************************************************************
* 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                                        *
*                                                                              *
*******************************************************************************/

#include <iostream>

#include "Topology/generic/parameters.h"
#include "Topology/map/embeddedMap2.h"

#include "Geometry/vector_gen.h"

#include "Algo/Import/import.h"
#include "Algo/Export/export.h"
#include <typeinfo>

#include "Algo/Modelisation/subdivision.h"

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
{
	// definition of the map
	typedef EmbeddedMap2 MAP;
};

int main(int argc, char **argv)
{
	if(argc != 2)
	{
		CGoGNout << "Usage : " << argv[0] << " filename" << CGoGNendl;
		return 0;
	}

	std::string filename(argv[1]);

	// declaration of the map
	PFP::MAP myMap;

	std::vector<std::string> attrNames ;
untereiner's avatar
untereiner committed
64
	Algo::Surface::Import::importMesh<PFP>(myMap, argv[1], attrNames);
untereiner's avatar
untereiner committed
65
66
67
68
69

	// get a handler to the 3D vector attribute created by the import
	VertexAttribute<PFP::VEC3> position = myMap.getAttribute<PFP::VEC3, VERTEX>(attrNames[0]);


70
71
72
	//
	// Dual
	//
untereiner's avatar
untereiner committed
73
74
75
76
77
78
79
80
	//	FaceAttribute<PFP::VEC3> positionF = myMap.getAttribute<PFP::VEC3, FACE>("position") ;
	//	if(!positionF.isValid())
	//		positionF = myMap.addAttribute<PFP::VEC3, FACE>("position") ;
	//
	//	Algo::Surface::Geometry::computeCentroidFaces<PFP>(myMap, position, positionF) ;
	//	myMap.computeDual();
	//	position = positionF ;

untereiner's avatar
untereiner committed
81

untereiner's avatar
untereiner committed
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
//	AttributeHandler<PFP::VEC3, PFP::MAP::EDGE_OF_PARENT> positionE = myMap.getAttribute<PFP::VEC3, PFP::MAP::EDGE_OF_PARENT>("position") ;
//	if(!positionE.isValid())
//		positionE = myMap.addAttribute<PFP::VEC3, PFP::MAP::EDGE_OF_PARENT>("position") ;
//
//	SelectorDartBoundary<PFP::MAP> sdb(myMap);
//	TraversorE<PFP::MAP> te(myMap, sdb);
//	for(Dart dit = te.begin() ; dit != te.end() ; dit = te.next())
//	{
//		positionE[dit] = (position[dit] + position[myMap.phi1(dit)]) * PFP::REAL(0.5);
//	}
//
//	std::cout << "boundary edges centroids : ok" << std::endl;
//
//	//triangule old boundary faces
//	std::vector<Dart> oldb;
//
//	std::cout << "nb darts : " << myMap.getNbDarts() << std::endl;
//
//	CellMarker<FACE> cmf(myMap);
//	for(Dart d = myMap.begin(); d != myMap.end(); myMap.next(d))
//	{
//		if(!cmf.isMarked(d) && myMap.isBoundaryMarked2(d))
//		{
//			oldb.push_back(d);
//			cmf.mark(d);
//			std::cout << "d = " << d << std::endl;
//		}
//	}
//
//	for(std::vector<Dart>::iterator it = oldb.begin() ; it != oldb.end() ; ++it)
//	{
//		Dart db = *it;
//		Dart d1 = myMap.phi1(db);
//		myMap.splitFace(db, d1) ;
//		myMap.cutEdge(myMap.phi_1(db)) ;
//		Dart x = myMap.phi2(myMap.phi_1(db)) ;
//		Dart dd = myMap.phi1(myMap.phi1(myMap.phi1(x)));
//		while(dd != x)
//		{
//			Dart next = myMap.phi1(dd) ;
//			myMap.splitFace(dd, myMap.phi1(x)) ;
//			dd = next ;
//		}
//
//	}
//
//	std::cout << "boundary face triangulation : ok" << std::endl;
//
//	myMap.swapEmbeddingContainers(FACE, PFP::MAP::EDGE_OF_PARENT) ;
//
//	std::cout << "swap containers : ok" << std::endl;
//
//	FaceAttribute<PFP::VEC3> positionF;
//	positionF = positionE;
136
137
//
//	Algo::Surface::Geometry::computeCentroidFaces<PFP>(myMap, position, positionF) ;
untereiner's avatar
untereiner committed
138
139
140
141
142
143
144
145
//
//	for(std::vector<Dart>::iterator it = oldb.begin() ; it != oldb.end() ; ++it)
//	{
//		myMap.fillHole(*it);
//	}
//
//	std::cout << "fillHole : ok" << std::endl;
//
146
//	myMap.computeDual();
untereiner's avatar
untereiner committed
147
148
149
//
//	//myMap.closeMap();
//
150
//	position = positionF ;
untereiner's avatar
untereiner committed
151
152
//
//	myMap.check();
untereiner's avatar
untereiner committed
153

untereiner's avatar
untereiner committed
154
	Algo::Surface::Export::exportOFF<PFP>(myMap, position, "result.off");
untereiner's avatar
untereiner committed
155
156
157
158
	std::cout << "Exported" << std::endl;

	return 0;
}