genericmap.h 17.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 26 27 28
* Contact information: cgogn@unistra.fr                                        *
*                                                                              *
*******************************************************************************/

#ifndef __GENERIC_MAP__
#define __GENERIC_MAP__

#include <iostream>
29
#include <string>
Pierre Kraemer's avatar
Pierre Kraemer committed
30 31 32 33 34 35
#include <sstream>
#include <fstream>
#include <iomanip>
#include <list>
#include <vector>
#include <map>
36

37
#include "Container/attributeContainer.h"
Sylvain Thery's avatar
Sylvain Thery committed
38
#include "Container/fakeAttribute.h"
39

Pierre Kraemer's avatar
Pierre Kraemer committed
40
#include "Topology/generic/dart.h"
41
#include "Topology/generic/cells.h"
Pierre Kraemer's avatar
Pierre Kraemer committed
42 43 44
#include "Topology/generic/marker.h"
#include "Topology/generic/functor.h"

Sylvain Thery's avatar
Sylvain Thery committed
45 46
#include <thread>
#include <mutex>
47

Sylvain Thery's avatar
Sylvain Thery committed
48
#include "Topology/dll.h"
Sylvain Thery's avatar
Sylvain Thery committed
49

Pierre Kraemer's avatar
Pierre Kraemer committed
50 51 52
namespace CGoGN
{

53 54 55 56 57
namespace Parallel
{
/**
 * @brief Number of threads used for // traversal foreach
 */
Sylvain Thery's avatar
Sylvain Thery committed
58
CGoGN_TOPO_API extern int NumberOfThreads;
59 60 61 62 63 64 65 66 67

/**
 * @brief get number of cores of computer (threads, /2 if hyperthreading)
 * @param hyperthreading
 * @return nb of core
 */
inline int getSystemNumberOfCores(bool hyperthreading=false)
{
	if (hyperthreading)
Sylvain Thery's avatar
Sylvain Thery committed
68 69
		return std::thread::hardware_concurrency()/2;
	return std::thread::hardware_concurrency();
70 71 72 73
}

}

74 75 76 77 78 79 80 81 82 83 84
// forward
class GenericMap;

// classs that store static pointer for copy in schnapps plugins
struct StaticPointers
{
	std::map<std::string, RegisteredBaseAttribute*>* att_registry;
	std::vector<GenericMap*>* instances;
	std::vector< std::vector<Dart>* >* vdartsBuffers;
	std::vector< std::vector<unsigned int>* >* vintsBuffers;
};
85

86
class AttributeHandlerGen ;
87 88
class DartMarkerGen ;
class CellMarkerGen ;
89
class MapManipulator;
90

Sylvain Thery's avatar
Sylvain Thery committed
91
class CGoGN_TOPO_API GenericMap
Pierre Kraemer's avatar
Pierre Kraemer committed
92
{
Pierre Kraemer's avatar
Pierre Kraemer committed
93 94 95 96 97 98
	template<typename T, unsigned int ORBIT, typename MAP> friend class AttributeHandler ;
	template<typename T, typename MAP> friend class DartAutoAttribute ;
	template<typename T, typename MAP> friend class VertexAutoAttribute ;
	template<typename T, typename MAP> friend class EdgeAutoAttribute ;
	template<typename T, typename MAP> friend class FaceAutoAttribute ;
	template<typename T, typename MAP> friend class VolumeAutoAttribute ;
Sylvain Thery's avatar
Sylvain Thery committed
99 100 101
//	friend class DartMarkerGen ;
//	friend class CellMarkerGen ;
//	template<typename MAP, unsigned int CELL> friend class CellMarkerBase ;
Pierre Kraemer's avatar
Pierre Kraemer committed
102 103

protected:
104 105 106
	// protected copy constructor to prevent the copy of map
	GenericMap(const GenericMap& ) {}

107 108 109 110 111 112
	/**
	 * @brief m_thread_ids
	 * vector of known thread ids, i.e. threads for which a mark vector,
	 * a Dart buffer or a uint buffer will be given when asked
	 */
	mutable std::vector<std::thread::id> m_thread_ids;
Sylvain Thery's avatar
Sylvain Thery committed
113 114

	/**
115 116
	 * @brief m_authorizeExternalThreads
	 * if true, getCurrentThreadIndex will give an index to an unknown thread
Sylvain Thery's avatar
Sylvain Thery committed
117
	 */
118 119
	bool m_authorizeExternalThreads;

Sylvain Thery's avatar
Sylvain Thery committed
120 121 122 123
public:
	/// compute thread index in the table of thread
	inline unsigned int getCurrentThreadIndex() const;

124 125 126 127 128
//	/// register the given thread ID for access to resources on this map
//	inline void addThreadId(const std::thread::id id);

	/// unregister the given thread to access resources on this map
	inline void removeThreadId(const std::thread::id id);
Sylvain Thery's avatar
Sylvain Thery committed
129

130 131
	/// add room for a new thread ID (will be set on thread start)
	inline std::thread::id& addEmptyThreadId();
Sylvain Thery's avatar
Sylvain Thery committed
132

133 134
	/// get a threadId based on its index
	inline std::thread::id getThreadId(unsigned int index) const;
Sylvain Thery's avatar
Sylvain Thery committed
135

136 137 138 139 140 141 142
	/**
	 * @brief setExternalThreadsAuthorization
	 * @param b
	 * if true, threads that did not created the map will be able to traverse it
	 * if false, traversal of the map by other threads will fail
	 */
	inline void setExternalThreadsAuthorization(bool b);
Sylvain Thery's avatar
Sylvain Thery committed
143 144

protected:
Pierre Kraemer's avatar
Pierre Kraemer committed
145 146 147
	/**
	 * Attributes Containers
	 */
148
	AttributeContainer m_attribs[NB_ORBITS] ;
Pierre Kraemer's avatar
Pierre Kraemer committed
149

150
	static std::map<std::string, RegisteredBaseAttribute*>* m_attributes_registry_map;
151

152
	/// buffer for less memory allocation
153 154
	mutable std::vector< std::vector<Dart>* > s_vdartsBuffers[NB_THREADS];
	mutable std::vector< std::vector<unsigned int>* > s_vintsBuffers[NB_THREADS];
155

156
public:
157
	/// table of instancied maps for Dart/CellMarker release
158
	static std::vector<GenericMap*>* s_instances;
Sylvain Thery's avatar
Sylvain Thery committed
159

160
protected:
Pierre Kraemer's avatar
Pierre Kraemer committed
161 162
	/**
	 * Direct access to the Dart attributes that store the orbits embeddings
163
	 * (only initialized when necessary, i.e. addEmbedding function)
Pierre Kraemer's avatar
Pierre Kraemer committed
164
	 */
165
	AttributeMultiVector<unsigned int>* m_embeddings[NB_ORBITS] ;
Pierre Kraemer's avatar
Pierre Kraemer committed
166

Pierre Kraemer's avatar
Pierre Kraemer committed
167 168 169 170 171
	/**
	 * Direct access to quick traversal attributes
	 * (initialized by enableQuickTraversal function)
	 */
	AttributeMultiVector<Dart>* m_quickTraversal[NB_ORBITS] ;
Sylvain Thery's avatar
Sylvain Thery committed
172 173 174
	AttributeMultiVector<NoTypeNameAttribute<std::vector<Dart> > >* m_quickLocalIncidentTraversal[NB_ORBITS][NB_ORBITS] ;
	AttributeMultiVector<NoTypeNameAttribute<std::vector<Dart> > >* m_quickLocalAdjacentTraversal[NB_ORBITS][NB_ORBITS] ;

175
	std::vector< AttributeMultiVector<MarkerBool>* > m_markVectors_free[NB_ORBITS][NB_THREADS] ;
Sylvain Thery's avatar
Sylvain Thery committed
176
	std::mutex m_MarkerStorageMutex[NB_ORBITS];
177

178 179
	unsigned int m_nextMarkerId;

180 181 182
	/**
	 * Reserved boundary markers
	 */
Sylvain Thery's avatar
Sylvain Thery committed
183
	AttributeMultiVector<MarkerBool>* m_boundaryMarkers[2];
184

185
	/**
Sylvain Thery's avatar
Sylvain Thery committed
186
	 * Store links to created AttributeHandlers
187
	 */
Sylvain Thery's avatar
Sylvain Thery committed
188
	std::multimap<AttributeMultiVectorGen*, AttributeHandlerGen*> attributeHandlers ;
Sylvain Thery's avatar
Sylvain Thery committed
189
	std::mutex attributeHandlersMutex;
190

Pierre Kraemer's avatar
Pierre Kraemer committed
191
public:
192
	static const unsigned int UNKNOWN_ATTRIB = AttributeContainer::UNKNOWN ;
Pierre Kraemer's avatar
Pierre Kraemer committed
193

194 195 196 197 198 199
	/// copy all static pointers: use in SCHNApps only
	static void copyAllStatics(const StaticPointers& sp);

	/// init all static and store in sp (if not null) : use in SCHNApps only
	static void initAllStatics(StaticPointers* sp);

200
	GenericMap() ;
Pierre Kraemer's avatar
Pierre Kraemer committed
201

Sylvain Thery's avatar
Sylvain Thery committed
202
	virtual ~GenericMap() ;
Pierre Kraemer's avatar
Pierre Kraemer committed
203

204 205
	static inline bool alive(GenericMap* map)
	{
206 207
		for (auto it=s_instances->begin(); it != s_instances->end(); ++it)
		{
208 209
			if (*it == map)
				return true;
210
		}
211 212 213
		return false;
	}

Sylvain Thery's avatar
Sylvain Thery committed
214 215
	inline std::vector<Dart>* askDartBuffer() const;
	inline void releaseDartBuffer(std::vector<Dart>* vd) const;
Sylvain Thery's avatar
Sylvain Thery committed
216

Sylvain Thery's avatar
Sylvain Thery committed
217 218
	inline std::vector<unsigned int>* askUIntBuffer() const;
	inline void releaseUIntBuffer(std::vector<unsigned int>* vd) const;
Sylvain Thery's avatar
Sylvain Thery committed
219

220
protected:
221
	void init(bool addBoundaryMarkers=true);
222 223

public:
224
	virtual std::string mapTypeName() const = 0 ;
225

226 227
	virtual unsigned int dimension() const = 0 ;

228 229 230 231 232 233 234
	/**
	 * Clear the map
	 * @param removeAttrib
	 *   if false -> data is deleted but all attributes remain (all AttributeHandlers are still valid)
	 *   if true -> data and attributes are deleted (AttributeHandlers are invalid)
	 */
	virtual void clear(bool removeAttrib) ;
Pierre Kraemer's avatar
Pierre Kraemer committed
235

236

237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
	/****************************************
	 *     MANIPULATOR MANAGEMENT           *
	 ****************************************/
protected:
	/// manipulator pointer to Manipulator object that currently work on map
	MapManipulator* m_manipulator;

public:
	/**
	 * @brief ask for associating manipulator to the map
	 * @param ptr Manipulator ptr
	 * @return ok or not
	 */
	bool askManipulate(MapManipulator* ptr);

	/**
	 * @brief release the map from manipulator
	 * @param ptr manipulator asking for release
	 * @return ok or not
	 */
	bool releaseManipulate(MapManipulator* ptr);

	/**
	 * @brief get the manipulator
	 * @return manipulator ptr
	 */
	MapManipulator* getManipulator();

Pierre Kraemer's avatar
Pierre Kraemer committed
265 266 267 268 269 270 271
	/****************************************
	 *           DARTS MANAGEMENT           *
	 ****************************************/
protected:
	/**
	 * Add a dart to the map
	 */
272
	virtual Dart newDart() ;
Pierre Kraemer's avatar
Pierre Kraemer committed
273 274 275 276

	/**
	 * Erase a dart of the map
	 */
277
	virtual void deleteDart(Dart d) = 0 ;
Pierre Kraemer's avatar
Pierre Kraemer committed
278

279 280 281
	/**
	 * create a copy of a dart (based on its index in m_attribs[DART]) and returns its index
	 */
282
	unsigned int copyDartLine(unsigned int index) ;
283

284 285
	/**
	 * Properly deletes a dart in m_attribs[DART]
286 287 288
	 */
	void deleteDartLine(unsigned int index) ;

289 290 291 292 293
public:
	/****************************************
	 *          ORBITS TRAVERSALS           *
	 ****************************************/

294 295 296 297 298
//	virtual void foreach_dart_of_vertex(Dart /*d*/, std::function<void (Dart)>& /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
//	virtual void foreach_dart_of_edge(Dart /*d*/, std::function<void (Dart)>& /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
//	virtual void foreach_dart_of_face(Dart /*d*/, std::function<void (Dart)>& /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
//	virtual void foreach_dart_of_volume(Dart /*d*/, std::function<void (Dart)>& /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
//	virtual void foreach_dart_of_cc(Dart /*d*/, std::function<void (Dart)>& /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
299

300 301
//	virtual void foreach_dart_of_vertex1(Dart /*d*/, std::function<void (Dart)>& /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
//	virtual void foreach_dart_of_edge1(Dart /*d*/, std::function<void (Dart)>& /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
302

303 304 305
//	virtual void foreach_dart_of_vertex2(Dart /*d*/, std::function<void (Dart)>& /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
//	virtual void foreach_dart_of_edge2(Dart /*d*/, std::function<void (Dart)>& /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
//	virtual void foreach_dart_of_face2(Dart /*d*/, std::function<void (Dart)>& /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
306

Pierre Kraemer's avatar
Pierre Kraemer committed
307 308 309
	/****************************************
	 *         EMBEDDING MANAGEMENT         *
	 ****************************************/
310

Pierre Kraemer's avatar
Pierre Kraemer committed
311 312 313
	/**
	 * tell if an orbit is embedded or not
	 */
314 315
	template <unsigned int ORBIT>
	bool isOrbitEmbedded() const ;
Pierre Kraemer's avatar
Pierre Kraemer committed
316

317
	bool isOrbitEmbedded(unsigned int orbit) const ;
Pierre Kraemer's avatar
Pierre Kraemer committed
318 319 320 321 322 323

	/**
	 * Allocation of some place in attrib table
	 * @param orbit the orbit of embedding
	 * @return the index to use as embedding
	 */
324 325
	template <unsigned int ORBIT>
	unsigned int newCell() ;
Pierre Kraemer's avatar
Pierre Kraemer committed
326 327 328 329 330 331 332

	/**
	 * Line of attributes i is overwritten with line j
	 * @param orbit attribute orbit to use
	 * @param i line destination of copy
	 * @param j line source of copy
	 */
333 334
	template <unsigned int ORBIT>
	void copyCell(unsigned int i, unsigned int j) ;
Pierre Kraemer's avatar
Pierre Kraemer committed
335 336 337 338 339 340

	/**
	 * Line of attributes i is initialized
	 * @param orbit attribute orbit to use
	 * @param i line to init
	 */
341 342
	template <unsigned int ORBIT>
	void initCell(unsigned int i) ;
Pierre Kraemer's avatar
Pierre Kraemer committed
343

Pierre Kraemer's avatar
Pierre Kraemer committed
344
	/****************************************
345
	 *   ATTRIBUTES CONTAINERS MANAGEMENT   *
Pierre Kraemer's avatar
Pierre Kraemer committed
346 347
	 ****************************************/

348 349 350 351 352 353
	/**
	 * get the number of cell in the attribute container of an orbit
	 * @param orb the orbit to get number of cells
	 */
	unsigned int getNbCells(unsigned int orbit);

Pierre Kraemer's avatar
Pierre Kraemer committed
354
	/**
355 356
	 * get the attrib container of a given orbit
	 * @param orbit the orbit !!! (bilbo the orbit !)
Pierre Kraemer's avatar
Pierre Kraemer committed
357
	 */
358 359
	template <unsigned int ORBIT>
	AttributeContainer& getAttributeContainer() ;
Pierre Kraemer's avatar
Pierre Kraemer committed
360

Sylvain Thery's avatar
Sylvain Thery committed
361 362 363
	template <unsigned int ORBIT>
	const AttributeContainer& getAttributeContainer() const;

Pierre Kraemer's avatar
Pierre Kraemer committed
364 365
	AttributeContainer& getAttributeContainer(unsigned int orbit) ;

Sylvain Thery's avatar
Sylvain Thery committed
366 367
	const AttributeContainer& getAttributeContainer(unsigned int orbit) const;

368 369 370 371 372 373 374 375
	/**
	 * @brief get a generic pointer to an existing attribute multi vector
	 * @param orbit the concerned orbit
	 * @param nameAttr attribute name
	 * @return a pointer to an AttributeMultiVectorGen
	 */
	inline AttributeMultiVectorGen* getAttributeVectorGen(unsigned int orbit, const std::string& nameAttr) ;

Pierre Kraemer's avatar
Pierre Kraemer committed
376
	/**
Sylvain Thery's avatar
Sylvain Thery committed
377 378 379
	 * @brief ask for a marker attribute
	 */
	template <unsigned int ORBIT>
Sylvain Thery's avatar
Sylvain Thery committed
380
	AttributeMultiVector<MarkerBool>* askMarkVector() ;
Sylvain Thery's avatar
Sylvain Thery committed
381 382 383

	/**
	 * @brief release allocated marker attribute
Pierre Kraemer's avatar
Pierre Kraemer committed
384
	 */
385
	template <unsigned int ORBIT>
Sylvain Thery's avatar
Sylvain Thery committed
386
	void releaseMarkVector(AttributeMultiVector<MarkerBool>* amv);
Sylvain Thery's avatar
Sylvain Thery committed
387

Sylvain Thery's avatar
Sylvain Thery committed
388 389 390 391 392 393 394 395 396 397 398
protected:
	/**
	 * @brief scan attributes for MarkerBool, clean them and store as free in thread 0
	 */
	void garbageMarkVectors();

	/**
	 * @brief scan attributes for MarkerBool and remove them
	 */
	void removeMarkVectors();
public:
Pierre Kraemer's avatar
Pierre Kraemer committed
399 400

	/**
401 402
	 * return a pointer to the Dart attribute vector that store the embedding of the given orbit
	 * (may be NULL if the orbit is not embedded)
Pierre Kraemer's avatar
Pierre Kraemer committed
403
	 */
404 405
	template <unsigned int ORBIT>
	AttributeMultiVector<unsigned int>* getEmbeddingAttributeVector() ;
Pierre Kraemer's avatar
Pierre Kraemer committed
406

407 408 409 410
	/**
	 * swap two attribute containers
	 */
	void swapEmbeddingContainers(unsigned int orbit1, unsigned int orbit2) ;
Pierre Kraemer's avatar
Pierre Kraemer committed
411 412 413 414 415 416 417

	/**
	 * static function for type registration
	 */
	template <typename R>
	static bool registerAttribute(const std::string &nameType) ;

418 419 420 421 422
	/**
	 * print attributes name of map in std::cout (for debugging)
	 */
	void viewAttributesTables() ;

423 424
	void printDartsTable();

425 426 427 428 429 430
	/****************************************
	 *   EMBEDDING ATTRIBUTES MANAGEMENT    *
	 ****************************************/
	/**
	 * Create the dart attribute to store the embedding of this orbit (for internal use only)
	 */
431 432
	template <unsigned int ORBIT>
	void addEmbedding() ;
433

434
protected:
435 436 437 438 439
	/****************************************
	 *  TOPOLOGICAL ATTRIBUTES MANAGEMENT   *
	 ****************************************/

	/**
440
	 * Add a topological relation in the map
441 442 443 444
	 * @param name name of relation
	 */
	AttributeMultiVector<Dart>* addRelation(const std::string& name) ;

445
	/**
Pierre Kraemer's avatar
Pierre Kraemer committed
446 447
	 * Get AttributeMultivector pointer of a relation attribute
	 * @param name name of the relation
448 449
	 * @return the attribute multi-vector pointer
	 */
Pierre Kraemer's avatar
Pierre Kraemer committed
450
	AttributeMultiVector<Dart>* getRelation(const std::string& name) ;
451

Pierre Kraemer's avatar
Pierre Kraemer committed
452 453 454
	/****************************************
	 *             SAVE & LOAD              *
	 ****************************************/
Pierre Kraemer's avatar
Pierre Kraemer committed
455
protected:
456
	/**
Pierre Kraemer's avatar
Pierre Kraemer committed
457
	 * restore embedding / markers / quick traversal shortcuts
458
	 */
Pierre Kraemer's avatar
Pierre Kraemer committed
459
	void restore_shortcuts();
460

Pierre Kraemer's avatar
Pierre Kraemer committed
461
public:
Pierre Kraemer's avatar
Pierre Kraemer committed
462 463 464 465 466
	/**
	 * Save map in a binary file
	 * @param filename the file name
	 * @return true if OK
	 */
467
	virtual bool saveMapBin(const std::string& filename) const = 0;
Pierre Kraemer's avatar
Pierre Kraemer committed
468 469 470 471 472 473

	/**
	 * Load map from a binary file
	 * @param filename the file name
	 * @return true if OK
	 */
474
	virtual bool loadMapBin(const std::string& filename) = 0 ;
Pierre Kraemer's avatar
Pierre Kraemer committed
475

476 477 478
	/**
	 * copy from another map (of same type)
	 */
479
	virtual bool copyFrom(const GenericMap& map) = 0 ;
480

481 482 483
	/**
	 * Dump attributes types and names per orbit
	 */
Pierre Kraemer's avatar
Pierre Kraemer committed
484
	void dumpAttributesAndMarkers() ;
485

Pierre Kraemer's avatar
Pierre Kraemer committed
486
protected:
487
	/**
488
	 * compact topo relations
489
	 */
490
	virtual void compactTopo() = 0 ;
491

Pierre Kraemer's avatar
Pierre Kraemer committed
492
public:
493 494
	/**
	 * compact the map
495
	 * @warning the quickTraversals needs to be updated
496
	 * @param topoOnly compact only the topo ?
497
	 */
498 499 500
	void compact(bool topoOnly = false) ;


501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
	/**
	 * compact a container (and update embedding attribute of topo)
	 * @param orbit orbit of container to compact
	 * @param frag minimum fragmentation value for compacting (default value 1.0 mean always compact)s
	 */
	void compactOrbitContainer(unsigned int orbit, float frag=1.0);

	/**
	 * @brief compact if containers are fragmented.
	 * @warning the quickTraversals needs to be updated
	 * @param frag if fragmentation (filling) of containers inferior to frag then compact
	 * @param topoOnly compact only the topo ?
	 */
	void compactIfNeeded(float frag, bool topoOnly = false) ;

516 517
	/**
	 * test if containers are fragmented
518 519
	 *  ~1.0 (full filled) no need to compact
	 *  ~0.0 (lots of holes) need to compact
520 521
	 */
	inline float fragmentation(unsigned int orbit);
522 523 524 525

	/**
	 * @brief dump all attributes of map in CSV format  (; separated columns)
	 */
526
	virtual void dumpCSV() const;
Sylvain Thery's avatar
Sylvain Thery committed
527 528 529 530 531 532 533

public:
	/**
	 * @brief move data (container && shortcuts from a map to this map
	 * @param mapf map from which data are moved);
	 */
	void moveData(GenericMap &mapf);
Pierre Kraemer's avatar
Pierre Kraemer committed
534 535
} ;

536

Sylvain Thery's avatar
Sylvain Thery committed
537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564
// DartBufferThread class that hide the usage of askDartBuffer & releaseDartBuffer
// scope of DartBuffer declaration use for auto release;
// typical usage:
//    DartBuffer buff(thread)
//    std::vector<DART>& vd=buff.vector();
//    vd.push_back(..)
//    ....

//class DartsBufferThread
//{
//protected:
//	std::vector<Dart>* m_vd;
//public:
//	inline DartsBufferThread()
//	{
//		m_vd = GenericMap::askDartBuffer();
//	}

//	inline ~DartsBufferThread()
//	{
//		GenericMap::releaseDartBuffer(m_vd);
//	}

//	inline std::vector<Dart>& vector() { return *m_vd;}
//};



Pierre Kraemer's avatar
Pierre Kraemer committed
565 566 567 568 569
} //namespace CGoGN

#include "Topology/generic/genericmap.hpp"

#endif