forgotten files

Apps/Benches/bench_compact.cpp

+#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 "Algo/Geometry/boundingbox.h"
+#include "Algo/Geometry/normal.h"
+
+#include "Algo/Modelisation/subdivision.h"
+#include "Algo/Decimation/decimation.h"
+
+#include "Utils/chrono.h"
+#include "Algo/Filtering/average.h"
+
+using namespace CGoGN ;
+
+struct PFP: public PFP_STANDARD
+{
+	// definition of the map
+	typedef EmbeddedMap2 MAP ;
+};
+
+typedef PFP::MAP MAP ;
+typedef PFP::VEC3 VEC3;
+
+
+int main(int argc, char **argv)
+{
+
+	if(argc != 2)
+		return 1;
+
+	MAP myMap;
+
+	std::vector<std::string> attrNames ;
+	if(!Algo::Surface::Import::importMesh<PFP>(myMap, argv[1], attrNames))
+	{
+		CGoGNerr << "could not import " << argv[1] << CGoGNendl ;
+		return 2;
+	}
+
+	VertexAttribute<PFP::VEC3, MAP> position = myMap.getAttribute<PFP::VEC3,VERTEX,MAP>( attrNames[0]) ;
+
+	FaceAttribute<VEC3, MAP> center = myMap.addAttribute<VEC3, FACE, MAP>("centerFace");
+	foreach_cell<FACE>(myMap, [&](Face f)
+	{
+		center[f] =Algo::Surface::Geometry::faceCentroid<PFP>(myMap,f,position);
+	});
+
+	EdgeAttribute<float, MAP> edge_att = myMap.addAttribute<float, EDGE, MAP>("pipoEdge");
+	foreach_cell<EDGE>(myMap, [&](Edge e)
+	{
+		edge_att[e] = position[e.dart][0];
+	});
+
+
+	Utils::Chrono chrono;
+	chrono.start();
+
+	Algo::Surface::Modelisation::LoopSubdivision<PFP>(myMap, position) ;
+	Algo::Surface::Modelisation::LoopSubdivision<PFP>(myMap, position) ;
+	Algo::Surface::Modelisation::LoopSubdivision<PFP>(myMap, position) ;
+	Algo::Surface::Modelisation::LoopSubdivision<PFP>(myMap, position) ;
+	unsigned int nbVertices = Algo::Topo::getNbOrbits<VERTEX>(myMap) ;
+
+	std::cout << "4 passes loop -> "<< std::endl;
+	std::cout << "  NB Faces "<< Algo::Topo::getNbOrbits<FACE>(myMap) << std::endl;
+	std::cout << "  NB Vertices "<< nbVertices << std::endl;
+
+	std::vector<VertexAttribute<typename PFP::VEC3, MAP> *> attr;
+	attr.push_back(&position);
+	Algo::Surface::Decimation::decimate<PFP>(myMap, Algo::Surface::Decimation::S_QEM, Algo::Surface::Decimation::A_QEM, attr, nbVertices * 0.05) ;
+
+	VertexAttribute<PFP::VEC3, MAP> normal = myMap.addAttribute<PFP::VEC3,VERTEX,MAP>( "normal") ;
+	VertexAttribute<PFP::VEC3, MAP> position2 = myMap.addAttribute<PFP::VEC3,VERTEX,MAP>( "pos2") ;
+
+	CGoGNout << "creating "<< chrono.elapsed() << " ms"<< CGoGNendl;
+
+	std::cout << "decimation 5% -> "<< std::endl;
+	std::cout << "  NB Faces "<< Algo::Topo::getNbOrbits<FACE>(myMap) << std::endl;
+	std::cout << "  NB Vertices "<<  Algo::Topo::getNbOrbits<VERTEX>(myMap) << std::endl;
+
+
+	chrono.start();
+	for (int i=0; i < 100; ++i)
+	{
+		Geom::BoundingBox<PFP::VEC3> bb = Algo::Geometry::computeBoundingBox<PFP>(myMap, position) ;
+		Algo::Surface::Geometry::computeNormalVertices<PFP>(myMap, position, normal) ;
+		Algo::Surface::Filtering::filterAverageAttribute_OneRing<PFP,PFP::VEC3>(myMap,position,position2, Algo::Surface::Filtering::INSIDE);
+		myMap.swapAttributes(position,position2);
+	}
+
+
+	CGoGNout << "BenchTime process "<< chrono.elapsed() << " ms"<< CGoGNendl;
+
+	std::cout << "Topologie fragmentation: "<<myMap.fragmentation(DART)<< std::endl;
+	std::cout << "Vertex fragmentation: "<<myMap.fragmentation(VERTEX)<< std::endl;
+	std::cout << "Face fragmentation: "<<myMap.fragmentation(FACE)<< std::endl;
+
+	chrono.start();
+	myMap.compact();
+	std::cout << std::endl << "compacting in "<< chrono.elapsed() << " ms"<< std::endl << std::endl;
+
+
+	std::cout << "Topologie fragmentation: "<<myMap.fragmentation(DART)<< std::endl;
+	std::cout << "Vertex fragmentation: "<<myMap.fragmentation(VERTEX)<< std::endl;
+	std::cout << "Face fragmentation: "<<myMap.fragmentation(FACE)<< std::endl;
+
+
+	chrono.start();
+
+	for (int i=0; i < 100; ++i)
+	{
+		Geom::BoundingBox<PFP::VEC3> bb = Algo::Geometry::computeBoundingBox<PFP>(myMap, position) ;
+		Algo::Surface::Geometry::computeNormalVertices<PFP>(myMap, position, normal) ;
+		Algo::Surface::Filtering::filterAverageAttribute_OneRing<PFP,PFP::VEC3>(myMap,position,position2, Algo::Surface::Filtering::INSIDE);
+		myMap.swapAttributes(position,position2);
+	}
+
+
+	CGoGNout << "BenchTime after compact "<< chrono.elapsed() << " ms"<< CGoGNendl;
+
+
+	Algo::Surface::Export::exportOFF<PFP>(myMap,position,"bench_res.off");
+
+	return 0;
+}

Apps/Tests/reusememory.cpp

+/*******************************************************************************
+* 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 "Topology/generic/parameters.h"
+#include "Topology/map/embeddedMap2.h"
+#include "Algo/Tiling/Surface/square.h"
+#include "Algo/Geometry/area.h"
+#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 PFP2: public PFP_STANDARD
+{
+	// definition of the type of the map
+	typedef EmbeddedMap2 MAP;
+};
+
+
+typedef PFP2::MAP MAP;
+typedef PFP2::VEC3 VEC3;
+
+
+int main()
+{
+	// declare a map to handle the mesh
+	MAP myMap;
+
+	// add position attribute on vertices and get handler on it
+	VertexAttribute<VEC3, MAP> position = myMap.addAttribute<VEC3, VERTEX, MAP>("position");
+	Algo::Surface::Tilings::Square::Cube<PFP2> cube(myMap, 2, 2, 2);
+	cube.embedIntoCube(position, 10.0f, 10.0f, 10.0f);
+
+//	FaceAttribute<VEC3, MAP> color = myMap.addAttribute<VEC3, FACE, MAP>("colorFace");
+
+//	foreach_cell<FACE>(myMap, [&](Face f)
+//	{
+//		color[f] =(Algo::Surface::Geometry::faceCentroid<PFP2>(myMap,f,position)+ VEC3(5,5,5))/10.0f;
+//	});
+
+
+	CGoGNout.toStd(false);
+	CGoGNout.toFile("reuse_init.csv");
+	myMap.dumpCSV();
+	std::cout << "MAP dumped in reuse_init.csv"<< std::endl;
+
+	// mark central vertex of each face of the cube
+	CellMarker<MAP,VERTEX> cm(myMap);
+	foreach_cell<VERTEX>(myMap, [&](Vertex v)
+	{
+		int nb=0;
+		if (position[v][0] == 0.0f)
+			nb++;
+		if (position[v][1] == 0.0f)
+			nb++;
+		if (position[v][2] == 0.0f)
+			nb++;
+
+		if (nb == 2)
+			cm.mark(v);
+	});
+
+	// remove central vertex of each face of the cube
+	foreach_cell<VERTEX>(myMap, [&](Vertex v)
+	{
+		if (cm.isMarked(v))
+			myMap.deleteVertex(v);
+	});
+
+	// remove middle points of each edge of the cube
+	foreach_cell<EDGE>(myMap, [&](Edge e)
+	{
+		Vertex v(e.dart);
+		if (myMap.vertexDegree(v)==2)
+			myMap.uncutEdge(myMap.phi_1(v));
+	});
+
+	CGoGNout.toFile("reuse_before.csv");
+	myMap.dumpCSV();
+	std::cout << "MAP with holes dumped in reuse_before.csv"<< std::endl;
+
+	Algo::Surface::Modelisation::quadranguleFaces<PFP2>(myMap,position);
+
+	CGoGNout.toFile("reuse_after.csv");
+	myMap.dumpCSV();
+	std::cout << "after subdivide, MAP dumped in reuse_after.csv"<< std::endl;
+
+	myMap.saveMapBin("reused_map2.map");
+
+	return 0;
+}