genericmap.cpp 31.2 KB
Newer Older
Pierre Kraemer's avatar
Pierre Kraemer committed
1
2
3
/*******************************************************************************
* CGoGN: Combinatorial and Geometric modeling with Generic N-dimensional Maps  *
* version 0.1                                                                  *
4
* Copyright (C) 2009-2012, IGG Team, LSIIT, University of Strasbourg           *
Pierre Kraemer's avatar
Pierre Kraemer committed
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
*                                                                              *
* 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.           *
*                                                                              *
20
* Web site: http://cgogn.unistra.fr/                                           *
Pierre Kraemer's avatar
Pierre Kraemer committed
21
22
23
24
25
* Contact information: cgogn@unistra.fr                                        *
*                                                                              *
*******************************************************************************/

#include "Topology/generic/genericmap.h"
26
#include "Topology/generic/attributeHandler.h"
Pierre Kraemer's avatar
Pierre Kraemer committed
27
#include "Topology/generic/dartmarker.h"
Sylvain Thery's avatar
Sylvain Thery committed
28
29
#include "Topology/generic/traversorCell.h"

Pierre Kraemer's avatar
Pierre Kraemer committed
30
31
#include "Geometry/vector_gen.h"
#include "Geometry/matrix.h"
32
#include "Container/registered.h"
Pierre Kraemer's avatar
Pierre Kraemer committed
33
34
35

namespace CGoGN
{
36
37

std::map<std::string, RegisteredBaseAttribute*>* GenericMap::m_attributes_registry_map = NULL ;
38

39
GenericMap::GenericMap() : m_nbThreads(1)
Pierre Kraemer's avatar
Pierre Kraemer committed
40
{
41
	if(m_attributes_registry_map == NULL)
42
		m_attributes_registry_map = new std::map<std::string, RegisteredBaseAttribute*> ;
43

Pierre Kraemer's avatar
Pierre Kraemer committed
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
	// register all known types
	registerAttribute<Dart>("Dart");
	registerAttribute<Mark>("Mark");

	registerAttribute<long>("long");
	registerAttribute<int>("int");
	registerAttribute<short>("short");
	registerAttribute<char>("char");

	registerAttribute<unsigned long>("unsigned long");
	registerAttribute<unsigned int>("unsigned int");
	registerAttribute<unsigned short>("unsigned short");
	registerAttribute<unsigned char>("unsigned char");

	registerAttribute<Geom::Vec2f>(Geom::Vec2f::CGoGNnameOfType());
	registerAttribute<Geom::Vec3f>(Geom::Vec3f::CGoGNnameOfType());
	registerAttribute<Geom::Vec4f>(Geom::Vec4f::CGoGNnameOfType());

	registerAttribute<Geom::Vec2d>(Geom::Vec2d::CGoGNnameOfType());
	registerAttribute<Geom::Vec3d>(Geom::Vec3d::CGoGNnameOfType());
	registerAttribute<Geom::Vec4d>(Geom::Vec4d::CGoGNnameOfType());

	registerAttribute<Geom::Matrix33f>(Geom::Matrix33f::CGoGNnameOfType());
	registerAttribute<Geom::Matrix44f>(Geom::Matrix44f::CGoGNnameOfType());

	registerAttribute<Geom::Matrix33d>(Geom::Matrix33d::CGoGNnameOfType());
	registerAttribute<Geom::Matrix44d>(Geom::Matrix44d::CGoGNnameOfType());

72
	for(unsigned int i = 0; i < NB_ORBITS; ++i)
Pierre Kraemer's avatar
Pierre Kraemer committed
73
	{
74
		m_attribs[i].setOrbit(i) ;
75
		m_attribs[i].setRegistry(m_attributes_registry_map) ;
Pierre Kraemer's avatar
Pierre Kraemer committed
76
		m_embeddings[i] = NULL ;
77
78
79
		for(unsigned int j = 0; j < NB_THREAD; ++j)
		{
			m_marksets[i][j].clear() ;
Pierre Kraemer's avatar
Pierre Kraemer committed
80
			m_markTables[i][j] = NULL ;
81
		}
Pierre Kraemer's avatar
Pierre Kraemer committed
82
	}
83

84
85
86
	dartMarkers.reserve(16) ;
	cellMarkers.reserve(16) ;

87
88
	// get & lock marker for boundary
	m_boundaryMarker =  m_marksets[DART][0].getNewMark();
89
90
91
92

#ifndef CGoGN_FORCE_MR
	m_isMultiRes = false;
#endif
Pierre Kraemer's avatar
Pierre Kraemer committed
93
94
95
96
}

GenericMap::~GenericMap()
{
97
98
99
	// release marker for boundary
	m_marksets[DART][0].releaseMark(m_boundaryMarker);

Pierre Kraemer's avatar
Pierre Kraemer committed
100
101
102
103
104
	for(unsigned int i = 0; i < NB_ORBITS; ++i)
	{
		if(isOrbitEmbedded(i))
			m_attribs[i].clear(true) ;
	}
105
106
107
108
109

	for(std::multimap<AttributeMultiVectorGen*, AttributeHandlerGen*>::iterator it = attributeHandlers.begin(); it != attributeHandlers.end(); ++it)
		(*it).second->setInvalid() ;
	attributeHandlers.clear() ;

110
111
112
113
114
115
116
117
	for(std::vector<DartMarkerGen*>::iterator it = dartMarkers.begin(); it != dartMarkers.end(); ++it)
		(*it)->setReleaseOnDestruct(false) ;
	dartMarkers.clear() ;

	for(std::vector<CellMarkerGen*>::iterator it = cellMarkers.begin(); it != cellMarkers.end(); ++it)
		(*it)->setReleaseOnDestruct(false) ;
	cellMarkers.clear() ;

118
	if(m_attributes_registry_map)
119
	{
120
		delete m_attributes_registry_map;
121
122
		m_attributes_registry_map = NULL;
	}
Pierre Kraemer's avatar
Pierre Kraemer committed
123
124
}

125
126
void GenericMap::clear(bool removeAttrib)
{
Sylvain Thery's avatar
Sylvain Thery committed
127
	if (removeAttrib)
128
	{
Sylvain Thery's avatar
Sylvain Thery committed
129
		for(unsigned int i = 0; i < NB_ORBITS; ++i)
130
		{
Sylvain Thery's avatar
Sylvain Thery committed
131
			m_attribs[i].clear(true) ;
132
133
			m_embeddings[i] = NULL ;
		}
134
135
		for(std::multimap<AttributeMultiVectorGen*, AttributeHandlerGen*>::iterator it = attributeHandlers.begin(); it != attributeHandlers.end(); ++it)
			(*it).second->setInvalid() ;
136
		attributeHandlers.clear() ;
137
	}
Sylvain Thery's avatar
Sylvain Thery committed
138
139
140
141
142
	else
	{
		for(unsigned int i = 0; i < NB_ORBITS; ++i)
			m_attribs[i].clear(false) ;
	}
143
144

	if (m_isMultiRes)
145
		initMR() ;
146
147
}

Pierre Kraemer's avatar
Pierre Kraemer committed
148
149
150
151
/****************************************
 *           MULTIRES                   *
 ****************************************/

Pierre Kraemer's avatar
Pierre Kraemer committed
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
void GenericMap::printMR()
{
	std::cout << std::endl ;

	for(unsigned int j = 0; j < m_mrNbDarts.size(); ++j)
		std::cout << m_mrNbDarts[j] << " / " ;
	std::cout << std::endl << "==========" << std::endl ;

	for(unsigned int i = m_mrattribs.begin(); i != m_mrattribs.end(); m_mrattribs.next(i))
	{
		std::cout << (*m_mrLevels)[i] << " / " ;
		for(unsigned int j = 0; j < m_mrDarts.size(); ++j)
			std::cout << (*m_mrDarts[j])[i] << " ; " ;
		std::cout << std::endl ;
	}
}

void GenericMap::initMR()
{
#ifndef CGoGN_FORCE_MR
	m_isMultiRes = true;
#endif

	m_mrattribs.clear(true) ;
Sylvain Thery's avatar
Sylvain Thery committed
176
177
	m_mrattribs.setRegistry(m_attributes_registry_map) ;

Pierre Kraemer's avatar
Pierre Kraemer committed
178
179
180
181
182
183
184
185
186
187
188
189
	m_mrDarts.clear() ;
	m_mrDarts.reserve(16) ;
	m_mrNbDarts.clear();
	m_mrNbDarts.reserve(16);
	m_mrLevelStack.clear() ;
	m_mrLevelStack.reserve(16) ;

	m_mrLevels = m_mrattribs.addAttribute<unsigned int>("MRLevel") ;
	addLevel() ;
	setCurrentLevel(0) ;
}

Pierre Kraemer's avatar
Pierre Kraemer committed
190
191
void GenericMap::addLevel()
{
Pierre Kraemer's avatar
Pierre Kraemer committed
192
	unsigned int newLevel = m_mrDarts.size() ;
Pierre Kraemer's avatar
Pierre Kraemer committed
193
	std::stringstream ss ;
Pierre Kraemer's avatar
Pierre Kraemer committed
194
	ss << "MRdart_"<< newLevel ;
195
	AttributeMultiVector<unsigned int>* newAttrib = m_mrattribs.addAttribute<unsigned int>(ss.str()) ;
Pierre Kraemer's avatar
Pierre Kraemer committed
196

197
	m_mrDarts.push_back(newAttrib) ;
Pierre Kraemer's avatar
Pierre Kraemer committed
198
	m_mrNbDarts.push_back(0) ;
Pierre Kraemer's avatar
Pierre Kraemer committed
199
200

	if(m_mrDarts.size() > 1)
Pierre Kraemer's avatar
Pierre Kraemer committed
201
	{
Pierre Kraemer's avatar
Pierre Kraemer committed
202
203
		AttributeMultiVector<unsigned int>* prevAttrib = m_mrDarts[newLevel - 1] ;	// copy the indices of
		m_mrattribs.copyAttribute(newAttrib->getIndex(), prevAttrib->getIndex()) ;	// previous level into new level
204
205
206

//		for(unsigned int i = m_mrattribs.begin(); i != m_mrattribs.end(); m_mrattribs.next(i))
//		{
Pierre Kraemer's avatar
Pierre Kraemer committed
207
208
//			unsigned int oldi = (*prevAttrib)[i] ;	// get the index of the dart in previous level
//			(*newAttrib)[i] = copyDartLine(oldi) ;	// copy the dart and affect it to the new level
209
//		}
Pierre Kraemer's avatar
Pierre Kraemer committed
210
211
212
213
214
	}
}

void GenericMap::removeLevel()
{
Pierre Kraemer's avatar
Pierre Kraemer committed
215
216
	unsigned int maxL = getMaxLevel() ;
	if(maxL > 0)
Pierre Kraemer's avatar
Pierre Kraemer committed
217
	{
Pierre Kraemer's avatar
Pierre Kraemer committed
218
219
		AttributeMultiVector<unsigned int>* maxMR = m_mrDarts[maxL] ;
		AttributeMultiVector<unsigned int>* prevMR = m_mrDarts[maxL - 1] ;
Pierre Kraemer's avatar
Pierre Kraemer committed
220
221
		for(unsigned int i = m_mrattribs.begin(); i != m_mrattribs.end(); m_mrattribs.next(i))
		{
Pierre Kraemer's avatar
Pierre Kraemer committed
222
223
224
225
226
227
228
229
230
231
232
			unsigned int idx = (*maxMR)[i] ;
			if((*m_mrLevels)[i] == maxL)	// if the MRdart was introduced on the level we're removing
			{
				deleteDartLine(idx) ;		// delete the pointed dart line
				m_mrattribs.removeLine(i) ;	// delete the MRdart line
			}
			else							// if the dart was introduced on a previous level
			{
				if(idx != (*prevMR)[i])		// delete the pointed dart line only if
					deleteDartLine(idx) ;	// it is not shared with previous level
			}
Pierre Kraemer's avatar
Pierre Kraemer committed
233
234
		}

Pierre Kraemer's avatar
Pierre Kraemer committed
235
		m_mrattribs.removeAttribute<unsigned int>(maxMR->getIndex()) ;
Pierre Kraemer's avatar
Pierre Kraemer committed
236
237
238
239
240
		m_mrDarts.pop_back() ;
		m_mrNbDarts.pop_back() ;

		if(m_mrCurrentLevel == maxL)
			--m_mrCurrentLevel ;
Pierre Kraemer's avatar
Pierre Kraemer committed
241
242
243
	}
}

Pierre Kraemer's avatar
Pierre Kraemer committed
244
245
246
247
248
249
250
/****************************************
 *         EMBEDDING MANAGEMENT         *
 ****************************************/

void GenericMap::setDartEmbedding(unsigned int orbit, Dart d, unsigned int emb)
{
	assert(isOrbitEmbedded(orbit) || !"Invalid parameter: orbit not embedded");
Pierre Kraemer's avatar
Pierre Kraemer committed
251

Pierre Kraemer's avatar
Pierre Kraemer committed
252
	unsigned int old = getEmbedding(orbit, d);
Pierre Kraemer's avatar
Pierre Kraemer committed
253

Pierre Kraemer's avatar
Pierre Kraemer committed
254
255
256
257
	if (old == emb)	// if same emb
		return;		// nothing to do

	if (old != EMBNULL)	// if different
258
	{
Pierre Kraemer's avatar
Pierre Kraemer committed
259
		if(m_attribs[orbit].unrefLine(old))	// then unref the old emb
260
		{
Pierre Kraemer's avatar
Pierre Kraemer committed
261
262
			for (unsigned int t = 0; t < m_nbThreads; ++t)	// clear the markers if it was the
				(*m_markTables[orbit][t])[old].clear();		// last unref of the line
263
		}
264
	}
Pierre Kraemer's avatar
Pierre Kraemer committed
265

Pierre Kraemer's avatar
Pierre Kraemer committed
266
	if (emb != EMBNULL)
Pierre Kraemer's avatar
Pierre Kraemer committed
267
268
269
		m_attribs[orbit].refLine(emb);	// ref the new emb

	(*m_embeddings[orbit])[dartIndex(d)] = emb ;	// finally affect the embedding to the dart
Pierre Kraemer's avatar
Pierre Kraemer committed
270
271
272
273
274
275
}

/****************************************
 *        ATTRIBUTES MANAGEMENT         *
 ****************************************/

276
void GenericMap::swapEmbeddingContainers(unsigned int orbit1, unsigned int orbit2)
Pierre Kraemer's avatar
Pierre Kraemer committed
277
{
278
279
280
281
282
283
284
285
286
287
	assert(orbit1 != orbit2 || !"Cannot swap a container with itself") ;
	assert((orbit1 != DART && orbit2 != DART) || !"Cannot swap the darts container") ;

	m_attribs[orbit1].swap(m_attribs[orbit2]) ;
	m_attribs[orbit1].setOrbit(orbit1) ;	// to update the orbit information
	m_attribs[orbit2].setOrbit(orbit2) ;	// in the contained AttributeMultiVectors

	m_embeddings[orbit1]->swap(m_embeddings[orbit2]) ;

	for(unsigned int t = 0; t < m_nbThreads; ++t)
Pierre Kraemer's avatar
Pierre Kraemer committed
288
	{
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
		AttributeMultiVector<Mark>* m = m_markTables[orbit1][t] ;
		m_markTables[orbit1][t] = m_markTables[orbit2][t] ;
		m_markTables[orbit2][t] = m ;

		MarkSet ms = m_marksets[orbit1][t] ;
		m_marksets[orbit1][t] = m_marksets[orbit2][t] ;
		m_marksets[orbit2][t] = ms ;
	}

	for(std::vector<CellMarkerGen*>::iterator it = cellMarkers.begin(); it != cellMarkers.end(); ++it)
	{
		if((*it)->m_cell == orbit1)
			(*it)->m_cell = orbit2 ;
		else if((*it)->m_cell == orbit2)
			(*it)->m_cell = orbit1 ;
Pierre Kraemer's avatar
Pierre Kraemer committed
304
305
306
307
308
309
310
311
312
	}
}

template <typename R>
bool GenericMap::registerAttribute(const std::string &nameType)
{
	RegisteredBaseAttribute* ra = new RegisteredAttribute<R>;
	if (ra == NULL)
	{
313
		CGoGNerr << "Erreur enregistrement attribut" << CGoGNendl;
Pierre Kraemer's avatar
Pierre Kraemer committed
314
315
316
317
318
		return false;
	}

	ra->setTypeName(nameType);

319
	m_attributes_registry_map->insert(std::pair<std::string, RegisteredBaseAttribute*>(nameType,ra));
Pierre Kraemer's avatar
Pierre Kraemer committed
320
321
322
	return true;
}

323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
void GenericMap::initOrbitEmbedding(unsigned int orbit, bool realloc)
{
	assert(isOrbitEmbedded(orbit) || !"Invalid parameter: orbit not embedded") ;
	DartMarker mark(*this) ;
	for(Dart d = begin(); d != end(); next(d))
	{
		if(!mark.isMarked(d))
		{
			mark.markOrbit(orbit, d) ;
			if(realloc || getEmbedding(orbit, d) == EMBNULL)
				embedNewCell(orbit, d) ;
		}
	}
}

Pierre Kraemer's avatar
Pierre Kraemer committed
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
void GenericMap::viewAttributesTables()
{
	std::cout << "======================="<< std::endl ;
	for (unsigned int i = 0; i < NB_ORBITS; ++i)
	{
		std::cout << "ATTRIBUTE_CONTAINER " << i << std::endl ;
		AttributeContainer& cont = m_attribs[i] ;

		// get the list of attributes
		std::vector<std::string> listeNames ;
		cont.getAttributesNames(listeNames) ;
		for (std::vector<std::string>::iterator it = listeNames.begin(); it != listeNames.end(); ++it)
			std::cout << "    " << *it << std::endl ;
		std::cout << "-------------------------" << std::endl ;
	}
	std::cout << "m_embeddings: " << std::hex ;
	for (unsigned int i = 0; i < NB_ORBITS; ++i)
		std::cout << (long)(m_embeddings[i]) << " / " ;
	std::cout << std::endl << "-------------------------" << std::endl ;

	std::cout << "m_markTables: " ;
	for (unsigned int i = 0; i < NB_ORBITS; ++i)
		std::cout << (long)(m_markTables[i][0]) << " / " ;
	std::cout << std::endl << "-------------------------" << std::endl << std::dec ;
}

Sylvain Thery's avatar
Sylvain Thery committed
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
/****************************************
 *   EMBEDDING ATTRIBUTES MANAGEMENT    *
 ****************************************/

void GenericMap::addEmbedding(unsigned int orbit)
{
	assert(!isOrbitEmbedded(orbit) || !"Invalid parameter: orbit already embedded") ;

	std::ostringstream oss;
	oss << "EMB_" << orbit;

	AttributeContainer& dartCont = m_attribs[DART] ;
	AttributeMultiVector<unsigned int>* amv = dartCont.addAttribute<unsigned int>(oss.str()) ;
	m_embeddings[orbit] = amv ;

	// set new embedding to EMBNULL for all the darts of the map
	for(unsigned int i = dartCont.begin(); i < dartCont.end(); dartCont.next(i))
Pierre Kraemer's avatar
Pierre Kraemer committed
381
		(*amv)[i] = EMBNULL ;
Sylvain Thery's avatar
Sylvain Thery committed
382
383
}

384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
/****************************************
 *          THREAD MANAGEMENT           *
 ****************************************/

void GenericMap::addThreadMarker(unsigned int nb)
{
	unsigned int th ;

	for (unsigned int j = 0; j < nb; ++j)
	{
		th = m_nbThreads ;
		m_nbThreads++ ;

		for (unsigned int i = 0; i < NB_ORBITS; ++i)
		{
399
400
401
402
403
			std::stringstream ss ;
			ss << "Mark_"<< th ;
			AttributeContainer& cellCont = m_attribs[i] ;
			AttributeMultiVector<Mark>* amvMark = cellCont.addAttribute<Mark>(ss.str()) ;
			m_markTables[i][th] = amvMark ;
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
		}
	}
}

unsigned int GenericMap::getNbThreadMarkers()
{
	return m_nbThreads;
}

void GenericMap::removeThreadMarker(unsigned int nb)
{
	unsigned int th = 0;
	while ((m_nbThreads > 1) && (nb > 0))
	{
		th = --m_nbThreads ;
		--nb;
		for (unsigned int i = 0; i < NB_ORBITS; ++i)
		{
422
423
424
425
426
			std::stringstream ss ;
			ss << "Mark_"<< th ;
			AttributeContainer& cellCont = m_attribs[i] ;
			cellCont.removeAttribute<Mark>(ss.str()) ;
			m_markTables[i][th] = NULL ;
427
428
429
		}
	}
}
Pierre Kraemer's avatar
Pierre Kraemer committed
430
431
432
433
434
435
436
437
438
439

/****************************************
 *             SAVE & LOAD              *
 ****************************************/

bool GenericMap::saveMapBin(const std::string& filename)
{
	CGoGNostream fs(filename.c_str(), std::ios::out|std::ios::binary);
	if (!fs)
	{
440
		CGoGNerr << "Unable to open file for writing: " << filename << CGoGNendl;
Pierre Kraemer's avatar
Pierre Kraemer committed
441
442
443
444
445
		return false;
	}

	// Entete
	char* buff = new char[256];
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
446
	for (int i = 0; i < 256; ++i)
Pierre Kraemer's avatar
Pierre Kraemer committed
447
		buff[i] = char(255);
448
449
450
451
452
453
454
455
456
457
	if (m_isMultiRes)
	{
		const char* cgogn = "CGoGN_MRMap";
		memcpy(buff, cgogn, 12);
	}
	else
	{
		const char* cgogn = "CGoGN_Map";
		memcpy(buff, cgogn, 10);
	}
Pierre Kraemer's avatar
Pierre Kraemer committed
458
459
	std::string mt = mapTypeName();
	const char* mtc = mt.c_str();
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
460
461
	memcpy(buff+32, mtc, mt.size()+1);
	unsigned int *buffi = reinterpret_cast<unsigned int*>(buff + 64);
Pierre Kraemer's avatar
Pierre Kraemer committed
462
463
464
465
	*buffi = NB_ORBITS;
	fs.write(reinterpret_cast<const char*>(buff), 256);
	delete buff;

Sylvain Thery's avatar
Sylvain Thery committed
466
	// save all attribs
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
467
468
	for (unsigned int i = 0; i < NB_ORBITS; ++i)
		m_attribs[i].saveBin(fs, i);
Pierre Kraemer's avatar
Pierre Kraemer committed
469

470
	if (m_isMultiRes)
Sylvain Thery's avatar
Sylvain Thery committed
471
	{
472
473
		m_mrattribs.saveBin(fs, 00);

Sylvain Thery's avatar
Sylvain Thery committed
474
475
476
477
478
479
480
		fs.write(reinterpret_cast<const char*>(&m_mrCurrentLevel), sizeof(unsigned int));

		unsigned int nb = m_mrNbDarts.size();
		fs.write(reinterpret_cast<const char*>(&nb), sizeof(unsigned int));
		fs.write(reinterpret_cast<const char*>(&(m_mrNbDarts[0])), nb *sizeof(unsigned int));
	}

Pierre Kraemer's avatar
Pierre Kraemer committed
481
482
483
484
485
	return true;
}

bool GenericMap::loadMapBin(const std::string& filename)
{
Sylvain Thery's avatar
Sylvain Thery committed
486

Pierre Kraemer's avatar
Pierre Kraemer committed
487
488
489
	CGoGNistream fs(filename.c_str(), std::ios::in|std::ios::binary);
	if (!fs)
	{
490
		CGoGNerr << "Unable to open file for loading" << CGoGNendl;
Pierre Kraemer's avatar
Pierre Kraemer committed
491
492
493
		return false;
	}

Sylvain Thery's avatar
Sylvain Thery committed
494
495
496
	GenericMap::clear(true);

	// read info
Pierre Kraemer's avatar
Pierre Kraemer committed
497
498
499
500
501
	char* buff = new char[256];
	fs.read(reinterpret_cast<char*>(buff), 256);

	std::string buff_str(buff);
	// Check file type
502
	if (m_isMultiRes)
Pierre Kraemer's avatar
Pierre Kraemer committed
503
	{
504
505
506
507
508
509
510
511
512
513
		if (buff_str == "CGoGN_Map")
		{
			CGoGNerr<< "Wrong binary file format, file is not a MR-Map"<< CGoGNendl;
			return false;
		}
		if (buff_str != "CGoGN_MRMap")
		{
			CGoGNerr<< "Wrong binary file format"<< CGoGNendl;
			return false;
		}
Pierre Kraemer's avatar
Pierre Kraemer committed
514
	}
515
516
517
518
519
520
521
522
523
524
525
526
527
528
	else
	{
		if (buff_str == "CGoGN_MRMap")
		{
			CGoGNerr<< "Wrong binary file format, file is a MR-Map"<< CGoGNendl;
			return false;
		}
		if (buff_str != "CGoGN_Map")
		{
			CGoGNerr<< "Wrong binary file format"<< CGoGNendl;
			return false;
		}
	}

Pierre Kraemer's avatar
Pierre Kraemer committed
529
530

	// Check map type
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
531
	buff_str = std::string(buff + 32);
Pierre Kraemer's avatar
Pierre Kraemer committed
532
533

	std::string localType = this->mapTypeName();
Sylvain Thery's avatar
Sylvain Thery committed
534
535

	std::string fileType = buff_str;
Pierre Kraemer's avatar
Pierre Kraemer committed
536
537
538

	if (fileType != localType)
	{
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
539
		CGoGNerr << "Not possible to load "<< fileType << " into " << localType << " object" << CGoGNendl;
Pierre Kraemer's avatar
Pierre Kraemer committed
540
541
542
543
		return false;
	}

	// Check max nb orbit
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
544
	unsigned int *ptr_nbo = reinterpret_cast<unsigned int*>(buff + 64);
Pierre Kraemer's avatar
Pierre Kraemer committed
545
546
547
	unsigned int nbo = *ptr_nbo;
	if (nbo != NB_ORBITS)
	{
548
		CGoGNerr << "Wrond max orbit number in file" << CGoGNendl;
Pierre Kraemer's avatar
Pierre Kraemer committed
549
550
551
552
		return  false;
	}

	// load attrib container
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
553
	for (unsigned int i = 0; i < NB_ORBITS; ++i)
Pierre Kraemer's avatar
Pierre Kraemer committed
554
	{
555
		unsigned int id = AttributeContainer::loadBinId(fs);
Pierre Kraemer's avatar
Pierre Kraemer committed
556
557
558
		m_attribs[id].loadBin(fs);
	}

559
	if (m_isMultiRes)
Sylvain Thery's avatar
Sylvain Thery committed
560
561
	{
		AttributeContainer::loadBinId(fs); // not used but need to read to skip
562
563
		m_mrattribs.loadBin(fs);

Sylvain Thery's avatar
Sylvain Thery committed
564
565
566
567
568
569
570
571
		fs.read(reinterpret_cast<char*>(&m_mrCurrentLevel), sizeof(unsigned int));
		unsigned int nb;
		fs.read(reinterpret_cast<char*>(&nb), sizeof(unsigned int));
		m_mrNbDarts.resize(nb);
		fs.read(reinterpret_cast<char*>(&(m_mrNbDarts[0])), nb *sizeof(unsigned int));
	}


572
	// retrieve m_embeddings (from m_attribs)
Pierre Kraemer's avatar
Pierre Kraemer committed
573
	update_m_emb_afterLoad();
574

Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
575
	// recursive call from real type of map (for topo relation attributes pointers) down to GenericMap (for Marker_cleaning & pointers)
Sylvain Thery's avatar
Sylvain Thery committed
576
	update_topo_shortcuts();
Sylvain Thery's avatar
Sylvain Thery committed
577

Pierre Kraemer's avatar
Pierre Kraemer committed
578
579
580
	return true;
}

Sylvain Thery's avatar
Sylvain Thery committed
581
582
583
584
585
586
587
588
589
590
591
592
void GenericMap::update_m_emb_afterLoad()
{
	// get container of dart orbit
	AttributeContainer& cont = m_attribs[DART] ;

	// get the list of attributes
	std::vector<std::string> listeNames;
	cont.getAttributesNames(listeNames);

	// check if there are EMB_X attributes
	for (unsigned int i = 0;  i < listeNames.size(); ++i)
	{
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
593
		std::string sub = listeNames[i].substr(0, listeNames[i].size() - 1);
Sylvain Thery's avatar
Sylvain Thery committed
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
		if (sub == "EMB_")
		{
			unsigned int orb = listeNames[i][4]-'0'; // easy atoi computation for one char;
			AttributeMultiVector<unsigned int>* amv = cont.getDataVector<unsigned int>(i);
			m_embeddings[orb] = amv ;
		}
	}
}

void GenericMap::update_topo_shortcuts()
{
	for(unsigned int orbit = 0; orbit < NB_ORBITS; ++orbit)
	{
		AttributeContainer& cont = m_attribs[orbit];

		// get the list of attributes of orbit container
		std::vector<std::string> listeNames;
		cont.getAttributesNames(listeNames);

		for (unsigned int i = 0;  i < listeNames.size(); ++i)
		{
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
615
			std::string sub = listeNames[i].substr(0, 5);
Sylvain Thery's avatar
Sylvain Thery committed
616
617
618
619
			if (sub == "Mark_")
			{
				// get thread number
				unsigned int thread = listeNames[i][5]-'0';
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
620
				if (listeNames[i].size() > 6) 					// thread number is >9
Sylvain Thery's avatar
Sylvain Thery committed
621
622
623
624
625
					thread = 10*thread + listeNames[i][6]-'0';

				AttributeMultiVector<Mark>* amvMark = cont.getDataVector<Mark>(i);
				m_markTables[orbit][thread] = amvMark ;

Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
626
				if ((orbit == DART) && (thread == 0))	// for Marker of dart of thread O keep the boundary marker
Sylvain Thery's avatar
Sylvain Thery committed
627
628
629
				{
					Mark m(m_boundaryMarker);
					m.invert();
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
630
					for (unsigned int i = cont.begin(); i != cont.end(); cont.next(i))
Sylvain Thery's avatar
Sylvain Thery committed
631
632
633
634
						amvMark->operator[](i).unsetMark(m);
				}
				else								// for others clear all
				{
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
635
					for (unsigned int i = cont.begin(); i != cont.end(); cont.next(i))
Sylvain Thery's avatar
Sylvain Thery committed
636
637
638
639
640
						amvMark->operator[](i).clear();
				}
			}
		}
	}
641
642
643
644
645
646
647
648
649
650
651
652
653
654

	if (m_isMultiRes)
	{
		std::vector<std::string> names;
		m_mrattribs.getAttributesNames(names);
		m_mrDarts.resize(names.size()-1);
		for (unsigned int i=0; i<m_mrDarts.size(); ++i)
			m_mrDarts[i] = NULL;

		for (unsigned int i = 0;  i < names.size(); ++i)
		{
			std::string sub = names[i].substr(0, 7);

			if (sub=="MRLevel")
655
				m_mrLevels = m_mrattribs.getDataVector<unsigned int>(i);
656
657
658
659
660
661
662
663

			if (sub=="MRdart_")
			{
				sub = names[i].substr(7);	// compute number following MT_Dart_
				unsigned int idx=0;
				for (unsigned int j=0; j < sub.length(); j++)
					idx = 10*idx+(sub[j]-'0');
				if (idx < names.size()-1)
664
					m_mrDarts[idx] = m_mrattribs.getDataVector<unsigned int>(i);
665
666
667
668
669
670
671
672
673
674
675
				else
					CGoGNerr<<"Warning problem updating MR_DARTS" << CGoGNendl;
			}
		}
		// check if all pointers are != NULL
		for (unsigned int i=0; i<m_mrDarts.size(); ++i)
		{
			if (m_mrDarts[i] == NULL)
				CGoGNerr<<"Warning problem MR_DARTS = NULL" << CGoGNendl;
		}
	}
Sylvain Thery's avatar
Sylvain Thery committed
676
677
678
679
}

void GenericMap::dumpAttributesAndMarkers()
{
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
680
	for (unsigned int i = 0; i < NB_ORBITS; ++i)
Sylvain Thery's avatar
Sylvain Thery committed
681
682
	{
		std::vector<std::string> names;
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
683
		names.reserve(32); 				//just to limit reallocation
Sylvain Thery's avatar
Sylvain Thery committed
684
685
		m_attribs[i].getAttributesNames(names);
		unsigned int nb = names.size();
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
686
		if (nb > 0)
Sylvain Thery's avatar
Sylvain Thery committed
687
		{
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
688
			CGoGNout << "ORBIT "<< i << CGoGNendl;
Sylvain Thery's avatar
Sylvain Thery committed
689
690
691
			std::vector<std::string> types;
			types.reserve(nb);
			m_attribs[i].getAttributesTypes(types);
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
692
693
			for (unsigned int j = 0; j < nb; ++j)
				CGoGNout << "    " << j << " : " << types[j] << " " << names[j] << CGoGNendl;
Sylvain Thery's avatar
Sylvain Thery committed
694
695
696
		}
	}
	CGoGNout << "RESERVED MARKERS "<< CGoGNendl;
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
697
	for (unsigned int i = 0; i < NB_ORBITS; ++i)
Sylvain Thery's avatar
Sylvain Thery committed
698
	{
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
699
		for (unsigned int j = 0; j < NB_THREAD; ++j)
Sylvain Thery's avatar
Sylvain Thery committed
700
701
702
703
		{
			MarkSet ms = m_marksets[i][j];
			if (!ms.isClear())
			{
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
704
				CGoGNout << "Orbit " << i << "  thread " << j << " : ";
Sylvain Thery's avatar
Sylvain Thery committed
705
				Mark m(1);
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
706
				for (unsigned i = 0; i < Mark::getNbMarks(); ++i)
Sylvain Thery's avatar
Sylvain Thery committed
707
708
				{
					if (ms.testMark(m))
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
709
						CGoGNout << m.getMarkVal() << ", ";
Sylvain Thery's avatar
Sylvain Thery committed
710
711
712
713
714
715
716
717
					m.setMarkVal(m.getMarkVal()<<1);
				}
				CGoGNout << CGoGNendl;
			}
		}
	}
}

718
719
void GenericMap::compact()
{
720
721
722
723
	// if MR compact the MR attrib container
	std::vector<unsigned int> oldnewMR;
	if (m_isMultiRes)
		m_mrattribs.compact(oldnewMR);
724
725

	// compacting the orbits attributes
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
//	for (unsigned int orbit = 0; orbit < NB_ORBITS; ++orbit)
//	{
//		if ((orbit != DART) && (isOrbitEmbedded(orbit)))
//		{
//			m_attribs[orbit].compact(oldnew);
//
//			for (unsigned int i = m_attribs[DART].begin(); i != m_attribs[DART].end(); m_attribs[DART].next(i))
//			{
//				unsigned int& idx = m_embeddings[orbit]->operator [](i);
//				unsigned int jdx = oldnew[idx];
//				if ((jdx != 0xffffffff) && (jdx != idx))
//					idx = jdx;
//			}
//		}
//	}

	// compact embedding attribs
	std::vector< std::vector<unsigned int>* > oldnews;
	oldnews.resize(NB_ORBITS);
745
746
747
748
	for (unsigned int orbit = 0; orbit < NB_ORBITS; ++orbit)
	{
		if ((orbit != DART) && (isOrbitEmbedded(orbit)))
		{
749
750
751
752
			oldnews[orbit] = new std::vector<unsigned int>;
			m_attribs[orbit].compact(*(oldnews[orbit]));
		}
	}
753

754
755
756
757
758
759
	// update embedding indices of topo
	for (unsigned int i = m_attribs[DART].begin(); i != m_attribs[DART].end(); m_attribs[DART].next(i))
	{
		for (unsigned int orbit = 0; orbit < NB_ORBITS; ++orbit)
		{
			if ((orbit != DART) && (isOrbitEmbedded(orbit)))
760
			{
761
762
				unsigned int& idx = m_embeddings[orbit]->operator[](i);
				unsigned int jdx = oldnews[orbit]->operator[](idx);
Pierre Kraemer's avatar
merges    
Pierre Kraemer committed
763
				if ((jdx != 0xffffffff) && (jdx != idx))
764
765
766
767
					idx = jdx;
			}
		}
	}
768
769
770
771
772
	// delete allocated vectors
	for (unsigned int orbit = 0; orbit < NB_ORBITS; ++orbit)
		if ((orbit != DART) && (isOrbitEmbedded(orbit)))
			delete[] oldnews[orbit];

773
774

	//compacting the topo
775
	std::vector<unsigned int> oldnew;
776
777
	m_attribs[DART].compact(oldnew);

778
779
780
781
782
783
784
785
786

	// update MR indices to attribs[DART]
	if (m_isMultiRes)
	{
		unsigned int nbl = m_mrDarts.size();
		for (unsigned int i = m_mrattribs.begin(); i != m_mrattribs.end(); m_mrattribs.next(i))
		{
			for (unsigned int j=0; j<nbl; ++j)
			{
787
				unsigned int d_index = m_mrDarts[j]->operator[](i);
788
				if (d_index != oldnew[d_index])
789
					m_mrDarts[j]->operator[](i) = oldnew[d_index];
790
791
792
793
794
795
			}
		}
	}

		// update topo relations from real map
	compactTopoRelations(oldnewMR);
796
797
798
799

//	dumpAttributesAndMarkers();
}

Pierre Kraemer's avatar
Pierre Kraemer committed
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
/****************************************
 *           DARTS TRAVERSALS           *
 ****************************************/

bool GenericMap::foreach_dart(FunctorType& f, const FunctorSelect& good)
{
	for (Dart d = begin(); d != end(); next(d))
	{
		if(good(d))
			if (f(d))
				return true;
	}
	return false;
}

Sylvain Thery's avatar
Sylvain Thery committed
815
bool GenericMap::foreach_dart_of_orbit(unsigned int orbit, Dart d, FunctorType& f, unsigned int thread)
Pierre Kraemer's avatar
Pierre Kraemer committed
816
817
818
{
	switch(orbit)
	{
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
//		case DART: return f(d);
//		case VERTEX: return foreach_dart_of_vertex(d, f, thread);
//		case EDGE: return foreach_dart_of_edge(d, f, thread);
//		case ORIENTED_FACE: return foreach_dart_of_oriented_face(d, f, thread);
//		case FACE: return foreach_dart_of_face(d, f, thread);
//		case VOLUME: return foreach_dart_of_volume(d, f, thread);

		case DART:		return f(d);
		case VERTEX: 	return foreach_dart_of_vertex(d, f, thread);
		case EDGE: 		return foreach_dart_of_edge(d, f, thread);
		case FACE: 		return foreach_dart_of_face(d, f, thread);
		case VOLUME: 	return foreach_dart_of_volume(d, f, thread);
		case VERTEX1: 	return foreach_dart_of_vertex1(d, f, thread);
		case EDGE1: 	return foreach_dart_of_edge1(d, f, thread);
		case VERTEX2: 	return foreach_dart_of_vertex2(d, f, thread);
		case EDGE2:		return foreach_dart_of_edge2(d, f, thread);
		case FACE2:		return foreach_dart_of_face2(d, f, thread);
Sylvain Thery's avatar
Sylvain Thery committed
836
837
		default: assert(!"Cells of this dimension are not handled");break;

Pierre Kraemer's avatar
Pierre Kraemer committed
838
839
840
841
	}
	return false;
}

Sylvain Thery's avatar
Sylvain Thery committed
842
bool GenericMap::foreach_orbit(unsigned int orbit, FunctorType& fonct, const FunctorSelect& good, unsigned int thread)
Pierre Kraemer's avatar
Pierre Kraemer committed
843
{
844
	TraversorCell<GenericMap> trav(*this, orbit, good, true, thread);
845
	bool found = false;
Pierre Kraemer's avatar
Pierre Kraemer committed
846

Sylvain Thery's avatar
Sylvain Thery committed
847
	for (Dart d = trav.begin(); !found && d != trav.end(); d = trav.next())
Pierre Kraemer's avatar
Pierre Kraemer committed
848
	{
849
		if ((fonct)(d))
Pierre Kraemer's avatar
Pierre Kraemer committed
850
			found = true;
Pierre Kraemer's avatar
Pierre Kraemer committed
851
852
853
854
855
856
857
858
859
860
861
	}
	return found;
}

unsigned int GenericMap::getNbOrbits(unsigned int orbit, const FunctorSelect& good)
{
	FunctorCount fcount;
	foreach_orbit(orbit, fcount, good);
	return fcount.getNb();
}

862
863
void GenericMap::boundaryMark(Dart d)
{
Pierre Kraemer's avatar
Pierre Kraemer committed
864
	m_markTables[DART][0]->operator[](dartIndex(d)).setMark(m_boundaryMarker);
865
866
867
868
}

void GenericMap::boundaryUnmark(Dart d)
{
Pierre Kraemer's avatar
Pierre Kraemer committed
869
	m_markTables[DART][0]->operator[](dartIndex(d)).unsetMark(m_boundaryMarker);
870
871
872
873
}

bool GenericMap::isBoundaryMarked(Dart d)
{
Pierre Kraemer's avatar
Pierre Kraemer committed
874
	return m_markTables[DART][0]->operator[](dartIndex(d)).testMark(m_boundaryMarker);
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
}

void GenericMap::boundaryMarkOrbit(unsigned int orbit, Dart d)
{
	FunctorMark<GenericMap> fm(*this, m_boundaryMarker, m_markTables[DART][0]) ;
	foreach_dart_of_orbit(orbit, d, fm, 0) ;
}

void GenericMap::boundaryUnmarkOrbit(unsigned int orbit, Dart d)
{
	FunctorUnmark<GenericMap> fm(*this, m_boundaryMarker, m_markTables[DART][0]) ;
	foreach_dart_of_orbit(orbit, d, fm, 0) ;
}

void GenericMap::boundaryUnmarkAll()
{
	AttributeContainer& cont = getAttributeContainer(DART) ;
	for (unsigned int i = cont.begin(); i != cont.end(); cont.next(i))
		m_markTables[DART][0]->operator[](i).unsetMark(m_boundaryMarker);
}

Pierre Kraemer's avatar
Pierre Kraemer committed
896
} // namespace CGoGN
Sylvain Thery's avatar
Sylvain Thery committed
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070

//
//bool GenericMap::saveMapXml(const std::string& filename, bool compress)
//{
//	xmlTextWriterPtr writer = xmlNewTextWriterFilename(filename.c_str(), 0);
//	xmlTextWriterStartDocument(writer,NULL,NULL,NULL);
//
//	// Entete
//	int rc = xmlTextWriterStartElement(writer, BAD_CAST "CGoGN_Map");
//	rc = xmlTextWriterWriteAttribute(writer,  BAD_CAST "type", BAD_CAST this->mapTypeName().c_str());
//	rc = xmlTextWriterWriteFormatAttribute(writer,  BAD_CAST "nb_max_orbits","%u",NB_ORBITS);
//
//	// save m_attribs
//	for (unsigned int i=0; i<NB_ORBITS; ++i)
//	{
//		m_attribs[i].saveXml(writer,i);
//	}
//
//	// save m_orbMarker
//	rc = xmlTextWriterStartElement(writer, BAD_CAST "Orbit_MarkerSet");
//	for (unsigned int i=0; i<NB_ORBITS; ++i)
//	{
//		int rc = xmlTextWriterStartElement(writer, BAD_CAST "MarkerSet");
//		rc = xmlTextWriterWriteFormatAttribute(writer,  BAD_CAST "orbit", "%u", i);
//		rc = xmlTextWriterWriteFormatAttribute(writer,  BAD_CAST "val", "%u", m_marksets[i][0].getMarkVal());
////		rc = xmlTextWriterWriteAttribute(writer,  BAD_CAST "bin", BAD_CAST m_marksets[i][0].getMarkerAsBinaryString().c_str());
////		m_marksets[i] ;
//		rc = xmlTextWriterEndElement(writer);
//	}
//	rc = xmlTextWriterEndElement(writer);
//
//	// save m_BoundaryMarkerVal
////	rc = xmlTextWriterStartElement(writer, BAD_CAST "Boundary_Marker");
////	rc = xmlTextWriterWriteFormatAttribute(writer,  BAD_CAST "val", "%u", m_BoundaryMarkerVal.getMarkVal());
////	rc = xmlTextWriterEndElement(writer);
//
//	rc = xmlTextWriterEndElement(writer); // of map
//
//	xmlTextWriterEndDocument(writer);
//	xmlFreeTextWriter(writer);
//
//	return true;
//}
//
//
//bool GenericMap::loadMapXml(const std::string& filename, bool compress)
//{
//
//	xmlDocPtr doc = xmlReadFile(filename.c_str(), NULL, 0);
//	xmlNodePtr map_node = xmlDocGetRootElement(doc);
//
//	// Check if it is a CGoGN_Map file
////	if (strcmp((char*)(map_node->name),(char*)"CGoGN_Map")!=0)
//	if (!chechXmlNode(map_node,"CGoGN_Map"))
//	{
//		CGoGNerr << "Wrong xml format: Root node != CGoGN_Map"<< CGoGNendl;
//		return false;
//	}
//
//	// check the file type
//	xmlChar *prop = xmlGetProp(map_node, BAD_CAST "type");
//	CGoGNout << "Loading "<< prop <<" xml file"<< CGoGNendl;
//
//	// check the nb max orbits
//	prop = xmlGetProp(map_node, BAD_CAST "nb_max_orbits");
//	unsigned int nbo = atoi((char*)prop);
//	if (nbo != NB_ORBITS)
//	{
//		CGoGNerr << "Wrong nb max orbits in xml map"<< CGoGNendl;
//		return false;
//	}
//
//	/***********************************************
//	*	 			 load attributs
//	************************************************/
//	for (xmlNode* cur_node = map_node->children; cur_node; cur_node = cur_node->next)
//	{
//		// for each attribute
////		if (strcmp((char*)(cur_node->name),(char*)"Attributes_Container")==0)
//		if (chechXmlNode(cur_node, "Attributes_Container"))
//		{
//			CGoGNout << "LOAD ATTRIBUT"<< CGoGNendl;
//			// get the orbit id
//			unsigned int id = AttributeContainer::getIdXmlNode(cur_node);
//			// and load container
//			unsigned int nba = m_attribs[id].getNbAttributes();
//
//
//			CGoGNout << "attribut "<<id<<" size="<< m_attribs[id].size()<< "  nbatt="<< nba<< CGoGNendl;
//
//			m_attribs[id].loadXml(cur_node);
//		}
//	}
//
//	/***********************************************
//	*   creation of the m_embeddings pointers table
//	************************************************/
////	// get attribute names of dart orbit
////	AttributeContainer& contDart = m_attribs[DART] ;
////	std::vector< std::string > tableNames;
////	contDart.getAttributesStrings(tableNames);
////
////	// find orbit frome name and store pointer in right place
////	for (unsigned int i = 0; i< tableNames.size(); ++i)
////	{
//////		CGoGNout << i <<" : "<< tableNames[i]<<CGoGNendl;
////
////		std::string& name = tableNames[i];
////		std::string is_an_emb = name.substr(0,4);
////		if (is_an_emb == "EMB_")
////		{
////			AttributeMultiVector<unsigned int>& amv = contDart.getDataVector<unsigned int>(i) ;
////
////			std::string orbitname = name.substr(4, name.size()-4);
////			std::istringstream iss(orbitname);
////			unsigned int orbit;
////			iss >> orbit;
////
////			m_embeddings[orbit] = &amv ;
////		}
////	}
////
////
//	update_m_emb_afterLoad();
//
//	/***********************************************
//	*	 load Orbit_MarkerSet & BoundaryMarker
//	************************************************/
//	xmlNode* cur_node = map_node->children;
//	bool read1=false;
//	bool read2=false;
//	while (!(read1 || read2) && cur_node)// scan nodes to find the one with right name
//	{
////		if (strcmp((char*)(cur_node->name),(char*)"Orbit_MarkerSet") == 0)
//		if (chechXmlNode(cur_node, "Orbit_MarkerSet"))
//		{
//			for (xmlNode* mark_node = cur_node->children; mark_node; mark_node = mark_node->next)
//			{
//				xmlChar* prop = xmlGetProp(mark_node, BAD_CAST "orbit");
//				unsigned int orb = atoi((char*)prop);
//				prop = xmlGetProp(mark_node, BAD_CAST "val");
//				unsigned int val = atoi((char*)prop);
//				m_marksets[orb][0].setMarkVal(val);
//			}
//			read1 =true;
//		}
//		else
//		{
////			if (strcmp((char*)(cur_node->name),(char*)"Boundary_Marker") == 0)
//			CGoGNout << "Orbit_MarkerSet"<<CGoGNendl;
////			if (chechXmlNode(cur_node, "Boundary_Marker"))
////			{
////				xmlChar* prop = xmlGetProp(cur_node, BAD_CAST "val");
////				unsigned int val = atoi((char*)prop);
////				m_BoundaryMarkerVal.setMarkVal(val);
////				read2 =true;
////			}
//		}
//		// next node
//		cur_node = cur_node->next;
//	}
//
//	if (!(read1 && read2))
//	{
//		CGoGNerr <<"Error reading Marker in xml node"<<CGoGNendl;
//		return false;
//	}
//
//	xmlFreeDoc(doc);
//
//	update_m_emb_afterLoad();
//
//	return true ;
//}