#include "env_map.h"
#include "niddle.h"
#include "segment.h"
using namespace CGoGN ;



EnvMap::EnvMap()
{



#ifndef SPATIAL_HASHING

//	RegisteredEdges = map.addAttribute<PFP::SegmentVECT, FACE>("Segments") ;
//	neighborRegisteredEdges = map.addAttribute<PFP::SegmentVECT, FACE>("neighborSegments") ;
//	subdivisableFace = map.addAttribute<PFP::BOOLATTRIB, FACE>("subdivisableFace") ;

//	refineCandidate.reserve(100) ;
//	coarsenCandidate.reserve(100) ;
#endif
}

void EnvMap::init(int argc, char **argv)
{
	std::cout << "Init EnvMap" << std::endl ;
	if (argc>1)
	{
        std::string filename(argv[1]);
        open_file(filename);
	}
	else
	{
//Intialisation map MR

//		map.initImplicitProperties();
        int nb = 5;
		Algo::Volume::Tilings::Cubic::Grid<PFP> cubic(map, nb, nb, nb);


        ///// initialisation attributs
        position = map.addAttribute<VEC3, VERTEX, MAP>("position");
        color = map.addAttribute<VEC3, VOLUME, MAP>("color");
        RegisteredEdges=map.addAttribute<ARETES,VOLUME, MAP>("RegisteredEdges");
        RegisteredNeighborEdges=map.addAttribute<ARETES,VOLUME, MAP>("RegisteredNeighborEdges");
        cubic.embedIntoGrid(position, 1.0f, 1.0f, 1.0f);
        TraversorV<MAP> tv(map);
        for(Dart d = tv.begin() ; d != tv.end() ; d = tv.next())
        {
            position[d] *= 10;
        }

        TraversorW<MAP> tra(map);
        for (Dart d = tra.begin(); d != tra.end(); d = tra.next())
        {
            color[d] = position[d]/10 + VEC3(0.5,0.5,0.5);
        }

//        //// affichage positions
//        CellMarkerStore<MAP, VOLUME> m(map) ;
//        for (Dart d = map.begin(); d != map.end(); map.next(d))
//        {
//            if (!m.isMarked(d))
//            {
//                m.mark(d) ;
//               CGoGNout<<"Dart "<<d.index<<" en : "<<position[d]<<CGoGNendl;
//            }
//        }



/////////////////////////// Subdivision
//		std::cout << "level :"<<map.getCurrentLevel() << std::endl ;
//		Dart d =Algo::Volume::IHM::subdivideVolumeClassic<PFP>(map,map.phi2(map.begin()), position);
//		std::cout << "centralDart : "<< d.index << std::endl ;
//		map.setCurrentLevel(1);
//		std::cout << "level :"<<map.getCurrentLevel() << std::endl ;





	}


}

///// a coder

//Dart EnvMap::getBelongingCell(const PFP::VEC3& pos)
//{
////	assert(map.getCurrentLevel() == map.getMaxLevel()) ;

////    CellMarkerStore<MAP, VOLUME> m(map) ;
////    for (Dart d = map.begin(); d != map.end(); map.next(d))
////    {
////        if (!m.isMarked(d))
////        {
////            m.mark(d) ;
////            if (Testinside(d))
////                return d ;
////        }
////    }

////    std::cout << "ERROR : pos not in map for getBelongingCell " << pos << std::endl ;
//    return map.begin() ;
//}









//
void EnvMap::open_file(std::string filename)
{
    map.clear(true);
    std::vector<std::string> attrNames ;

    size_t pos = filename.rfind(".");    // position of "." in filename
    std::string extension = filename.substr(pos);

    if(extension == std::string(".off"))
    {
        if(!Algo::Volume::Import::importMeshToExtrude<PFP>(map, filename, attrNames))
        {
            std::cerr << "could not import " << filename << std::endl ;

        }
        else
        {
            position = map.getAttribute<VEC3, VERTEX, MAP>(attrNames[0]) ;
            map.closeMap();
        }
    }
    else
    {


        if(extension == std::string(".map"))
        {
            map.loadMapBin(filename);
            position = map.getAttribute<VEC3, VERTEX, MAP>("position") ;
        }
        else
        {
            //			if(!Algo::Volume::Import::importMesh<PFP>(map, filename, attrNames))
            //			{
            //				std::cerr << "could not import " << filename << std::endl ;
            //				return ;
            //			}
            //			else
            //                position = map.getAttribute<VEC3, VERTEX>(attrNames[0]) ;
        }

        color = map.addAttribute<VEC3, VOLUME, MAP>("colorVol");

        TraversorCell<MAP, VOLUME> tra(map);
        float maxV = 0.0f;
        for (Dart d = tra.begin(); d != tra.end(); d = tra.next())
        {
            float v = Algo::Geometry::tetrahedronVolume<PFP>(map, d, position);
            color[d] = VEC3(v,0,0);
            if (v>maxV)
                maxV=v;

            //			if(envMap.map.isVolumeIncidentToBoundary(d))
            //				color[d] = VEC3(0,0,0);
            //			else
            color[d] = VEC3(v,0,0);
        }

        for (unsigned int i = color.begin(); i != color.end(); color.next(i))
        {
            color[i][0] /= maxV;
            color[i][2] = 1.0f - color[i][0];
        }
    }
}


//void EnvMap::subdivideAllToMaxLevel()
//{
//	bool subdiv ;
//	do
//	{
//		subdiv = false ;
//		{
//			CellMarker<FACE> subd(map) ;
//			for (Dart d = map.begin(); d != map.end(); map.next(d))
//			{
//				if (!subd.isMarked(d))
//				{
//					subd.mark(d) ;
//					if (!buildingMark.isMarked(d))
//					{
//						//check if subdivision is authorized
//						float minDistSq = Agent::neighborDistSq_ ;
//						bool subdivisable = true ;
//						Dart old = map.faceOldestDart(d) ;
//						unsigned int fLevel = map.faceLevel(old) ;
//						map.setCurrentLevel(fLevel) ;
//						PFP::VEC3 fCenter = Algo::Surface::Geometry::faceCentroid<PFP>(map, old, position) ;
//						Dart fd = old ;
//						do
//						{
//							PFP::VEC3& p = position[fd] ;
//							PFP::VEC3 edge = Algo::Surface::Geometry::vectorOutOfDart<PFP>(map, fd,
//							                                                      position) ;
//							PFP::VEC3 proj = fCenter
//							    - (p + (edge * (fCenter - p) / edge.norm2()) * edge) ;
//							if (proj.norm2() < minDistSq)
//							{
//								subdivisable = false ;
//								break ;
//							}
//							fd = map.phi1(fd) ;
//						} while (fd != old) ;
//
//						if (subdivisable)
//						{
//							map.setCurrentLevel(fLevel) ;
//							Algo::Surface::IHM::subdivideFace<PFP>(map, old, position) ;
//							subdiv = true ;
//						}
//						map.setCurrentLevel(map.getMaxLevel()) ;
//					}
//				}
//			}
//		}
//	} while (subdiv) ;
//}
//
//void EnvMap::subdivideToProperLevel()
//{
//	bool subdiv ;
//	do
//	{
//		subdiv = false ;
//		{
//			CellMarker<FACE> subd(map) ;
//			for (Dart d = map.begin(); d != map.end(); map.next(d))
//			{
//				if (!subd.isMarked(d))
//				{
//					subd.mark(d) ;
//					if (!refineMark.isMarked(d) && agentvect[d].size() > nbAgentsToSubdivide)
//					{
//						std::pair<bool, bool>& sf = subdivisableFace[d] ;
//						if (sf.first == false || (sf.first == true && sf.second))
//						{
//							subdiv = true ;
//							refineMark.mark(d) ;
//							refineCandidate.push_back(d) ;
//						}
//					}
//				}
//			}
//			subd.unmarkAll() ;
//		}
//		updateMap() ;
//		refineCandidate.clear() ;
//		map.setCurrentLevel(map.getMaxLevel()) ;
//	} while (subdiv) ;
//}

//
//
void EnvMap::FirstRegistrationSegment(Segment * o)// réenregistre l'Segment en question
{

    Niddle * mo = o->nid;
    if (mo != NULL)
    {
        int n = o->index;
#ifdef DEBUG_affichage
        CGoGNout<<"First Registration arete "<<n<<CGoGNendl;
#endif
        VEC3 p1 = o->p1;
        VEC3 p2 =  o->p2;

        Dart d1=NIL;
        Dart d2=NIL;
        std::vector<Dart> memo;
        d1=mo->parts_[n]->d;
        d2=mo->parts_[n+1]->d;
        memo = getMemoCross(p1,p2,d1);

        if(map.sameVolume(d1,d2))
        {
            pushAOneCellSegment(o , d1);
        }
        else
        {

            pushSegmentInSetOfCells(o, memo);
        }
    }
}

Dart EnvMap::popAndPushSegment(Segment* o)// maj de l'enregistrement
{
#ifdef DEBUG_affichage
        CGoGNout<<"pop&push arete "<<o->index<<CGoGNendl;
#endif
    popSegment(o);
    FirstRegistrationSegment(o);

    return o->nid->parts_[o->index]->d;;
}

void EnvMap::pushAOneCellSegment(Segment * o, Dart d)
{
    int n = o->index;
    Niddle * mo = o->nid;
#ifdef DEBUG_affichage
    CGoGNout<<"Push in one cell segment arete "<<n<<CGoGNendl;
#endif
    assert(map.getCurrentLevel() == map.getMaxLevel());

    addElementToVector<Segment*>(RegisteredEdges[d],o);

    mo->belonging_cells[n].push_back(d);
    mo->addGeneralCell (d);
    Traversor* tra = TraversorFactory<PFP::MAP>::createAdjacent(map,d, 3, 4, 1);
    for (Dart d = tra->begin(); d != tra->end(); d = tra->next())
    {
        if (!map.isBoundaryMarked<3>(d))
        {
            pushSegmentInCellAsNeighbor(o, d);
             mo->neighbor_cells[n].push_back(d);
        }
    }
    tra->~Traversor();

}

void EnvMap::pushSegmentInSetOfCells(Segment* o, const std::vector<Dart>& memo_cross)
{
    int n = o->index;
#ifdef DEBUG_affichage
    CGoGNout<<"Push in set of cells segment arete "<<n<<CGoGNendl;
#endif
    assert(!memo_cross.empty());
    Niddle * mo = o->nid;

    mo->belonging_cells[n] = memo_cross;
    for (std::vector<Dart>::iterator it = mo->belonging_cells[n].begin();	it != mo->belonging_cells[n].end(); ++it)
    {

            addElementToVector<Segment*>(RegisteredEdges[*it],o);
            mo->addGeneralCell (*it);

    }
    FindNeighborCellsOfSegment(mo->belonging_cells[n], &(mo->neighbor_cells[n]));

    for (std::vector<Dart>::iterator it = mo->neighbor_cells[n].begin(); it != mo->neighbor_cells[n].end(); ++it)
    {
        if (!map.isBoundaryMarked<3>(*it))
        {
            addElementToVector<Segment*>(RegisteredNeighborEdges[*it],o);
        }
    }
}

void EnvMap::popSegment(Segment* o)
{
    Niddle * mo = o->nid;
    int n = o->index;
    assert(map.getCurrentLevel() == map.getMaxLevel()) ;

    if (mo != NULL)
    {
        for (std::vector<Dart>::iterator it = mo->belonging_cells[n].begin();	it != mo->belonging_cells[n].end(); ++it)
        {
            removeElementFromVector<Segment*>(RegisteredEdges[*it], o) ;
            mo->removeGeneralCell (*it);
        }
        for (std::vector<Dart>::iterator it = mo->neighbor_cells[n].begin(); it != mo->neighbor_cells[n].end(); ++it)
        {
            if (!map.isBoundaryMarked<3>(*it))
            {
                removeElementFromVector<Segment*>(RegisteredNeighborEdges[*it], o) ;
            }
        }
        mo->belonging_cells[n].clear();
        mo->neighbor_cells[n].clear();
    }
}
//
//
//void EnvMap::refine()
//{
////	CGoGNout<<"refine"<<CGoGNendl;
//	for (std::vector<Dart>::iterator it = refineCandidate.begin(); it != refineCandidate.end(); ++it)
//	{
//		Dart d = (*it) ;
//		refineMark.unmark(d) ;
//
//		//if the number of agents is big enough
//		if (agentvect[d].size() > nbAgentsToSubdivide)
//		{
//			int fLevel = -1 ;
//			Dart old = map.faceOldestDart(d) ;
//
//			bool subdivisable = true ;
//
//			//check if faces resulting from a subdivision are big enough
//			std::pair<bool, bool>& sf = subdivisableFace[old] ;
//			if (sf.first == true)
//				subdivisable = sf.second ;
//			else
//			{
////				float minSizeSq = minCellSize * minCellSize ; // diametre de vision de l'agent au carré
//				float minSizeSq = Agent::neighborDistSq_;
//
//				fLevel = map.faceLevel(old) ;
//				map.setCurrentLevel(fLevel) ;
//				PFP::VEC3 fCenter = Algo::Surface::Geometry::faceCentroid<PFP>(map, old, position) ;
//				Dart fd = old ;
//				do
//				{
//					PFP::VEC3& p = position[fd] ;
//					PFP::VEC3 edge = Algo::Surface::Geometry::vectorOutOfDart<PFP>(map, fd, position) ;
//					PFP::VEC3 proj = fCenter - (p + (edge * (fCenter - p) / edge.norm2()) * edge) ;
//					if (proj.norm2() < minSizeSq)
//					{
//						subdivisable = false ;
//						break ;
//					}
//					fd = map.phi1(fd) ;
//				} while (fd != old) ;
//				map.setCurrentLevel(map.getMaxLevel()) ;
//
//				sf.first = true ;
//				sf.second = subdivisable ;
//			}
//
//			if (subdivisable)
//			{
//				if (fLevel == -1)
//					fLevel = map.faceLevel(old) ;
//
//				sf.first = false ;
//
//				PFP::AGENTS oldAgents(agentvect[old]) ;
//				PFP::SegmentVECT oldObst(RegisteredEdges[old]) ;
//				PFP::SegmentVECT oldNeighborObst(neighborRegisteredEdges[old]) ;
//
//				for (PFP::AGENTS::iterator ait = oldAgents.begin(); ait != oldAgents.end(); ++ait)
//				{
//					popAgentInCells(*ait, old) ;
//				}
//				for (PFP::SegmentVECT::iterator ait = oldObst.begin(); ait != oldObst.end(); ++ait)
//					this->popSegment(*ait) ;
//				for (PFP::SegmentVECT::iterator ait = oldNeighborObst.begin();ait != oldNeighborObst.end(); ++ait)
//					this->popSegment(*ait) ;
//				neighborAgentvect[old].clear() ;
//
//				map.setCurrentLevel(fLevel) ;
//				Algo::Surface::IHM::subdivideFace<PFP>(map, old, position) ;
//				CellMarkerStore<FACE> newF(map) ;
//				unsigned int degree = 0 ;
//				Dart dd = old ;
//				do
//				{
//					++degree ;
//					newF.mark(dd) ;
//					dd = map.phi1(dd) ;
//				} while (dd != old) ;
//				map.setCurrentLevel(fLevel+1) ;
//				if (degree == 3)
//				{
//					Dart centerFace = map.phi2(map.phi1(old)) ;
//					newF.mark(centerFace) ;
//				}
//
//				map.setCurrentLevel(map.getMaxLevel()) ;
//				//retrieve neighbors agents from onering cells
//				dd = old ;
//				do
//				{
//					Dart d3 = dd ;
//
//					do
//					{
//						Dart d4 = map.alpha1(map.alpha1(d3)) ;
//						PFP::AGENTS& nad3 = neighborAgentvect[d3] ;
//						while (d4 != d3)
//						{
//							if (!newF.isMarked(d4))
//							{
//								PFP::AGENTS& ad4 = agentvect[d4] ;
//								nad3.insert(nad3.end(), ad4.begin(), ad4.end()) ;
//							}
//							d4 = map.alpha1(d4) ;
//						}
//						d3 = map.phi1(d3) ;
//					} while (d3 != dd) ;
//
//					map.setCurrentLevel(fLevel) ;
//					dd = map.phi1(dd) ;
//					map.setCurrentLevel(map.getMaxLevel()) ;
//				} while (dd != old) ;
//
//
//
//				if (degree == 3)
//				{
//					map.setCurrentLevel(fLevel+1) ;
//					Dart centerFace = map.phi2(map.phi1(old)) ;
//					map.setCurrentLevel(map.getMaxLevel()) ;
//					Dart d3 = centerFace ;
//					do
//					{
//						Dart d4 = map.alpha1(map.alpha1(d3)) ;
//						PFP::AGENTS& nad3 = neighborAgentvect[d3] ;
//						while (d4 != d3)
//						{
//							if (!newF.isMarked(d4))
//							{
//								PFP::AGENTS& ad4 = agentvect[d4] ;
//								nad3.insert(neighborAgentvect[d3].end(), ad4.begin(), ad4.end()) ;
//							}
//							d4 = map.alpha1(d4) ;
//						}
//						d3 = map.phi1(d3) ;
//					} while (d3 != centerFace) ;
//				}
//
//				//agents contained in the subdivided cell are pushed correctly
//				for (PFP::AGENTS::iterator ait = oldAgents.begin(); ait != oldAgents.end(); ++ait)
//				{
////					CGoGNout<<"reseting Agents"<<CGoGNendl;
//					resetAgentInFace(*ait) ;
//					pushAgentInCells(*ait, (*ait)->part_.d) ;
//				}
//
//				//same for Segments contained
//				for (PFP::SegmentVECT::iterator ait = oldObst.begin(); ait != oldObst.end(); ++ait)
//				{
////					CGoGNout<<"reseting Segments"<<CGoGNendl;
//					resetPartSubdiv(*ait);
//					pushSegmentInSetOfCells(*ait);
//
//				}
//
//				//same for adjacent Segments
//				for (PFP::SegmentVECT::iterator ait = oldNeighborObst.begin();
//					ait != oldNeighborObst.end(); ++ait)
//				{
//					pushSegmentInSetOfCells(*ait) ;
//				}
//
//
////				CGoGNout<<"fin refine"<<CGoGNendl;
//			}
//		}
//	}
//	refineCandidate.clear() ;
//
//}
//
//
//void EnvMap::coarse()
//{
////	CGoGNout<<"coarse"<<CGoGNendl;
//	// On recrée une liste des faces à simplifier en empêchant les doublons
//	// On en profite pour vérifier les conditions de simplifications
//	std::vector<Dart> checkCoarsenCandidate ;
//	checkCoarsenCandidate.reserve(coarsenCandidate.size()) ;
//
//	for (unsigned int it = 0; it < coarsenCandidate.size(); ++it)
//	{
//		Dart old = coarsenCandidate[it] ;
//		bool oldIsMarked = coarsenMark.isMarked(old) ;
//		coarsenMark.unmark(old) ;
//
//		unsigned int fLevel = map.faceLevel(old) ;
//
//		if (oldIsMarked && fLevel > 0 && map.getDartLevel(old) < fLevel)
//		{
//			unsigned int cur = map.getCurrentLevel() ;
//			map.setCurrentLevel(fLevel - 1) ;
//
//			if (map.faceIsSubdividedOnce(old))
//			{
//				// on compte le nombre d'agents dans les sous-faces
//				// on en profite pour compter le degré de la face grossière
//				unsigned int degree = 0 ;
//				unsigned int nbAgents = 0 ;
//				Dart fit = old ;
//				do
//				{
//					nbAgents += agentvect[fit].size() ;
//					++degree ;
//					coarsenMark.unmark(fit) ;
//					fit = map.phi1(fit) ;
//				} while (fit != old) ;
//
//
//				//Loop subdivision
//				if (degree == 3)
//				{
//					map.setCurrentLevel(fLevel) ;
//					Dart centerFace = map.phi2(map.phi1(old)) ;
//					nbAgents += agentvect[centerFace].size() ;
//					coarsenMark.unmark(centerFace) ;
//					map.setCurrentLevel(fLevel - 1) ;
//				}
//				if (nbAgents < nbAgentsToSimplify) checkCoarsenCandidate.push_back(old) ;
//			}
//			map.setCurrentLevel(cur) ;
//		}
//	}
//	coarsenCandidate.clear() ;
//
////		 On réalise la simplification (les conditions ont déjà été vérifiées)
//	for (unsigned int it = 0; it < checkCoarsenCandidate.size(); ++it)
//	{
//		Dart old = checkCoarsenCandidate[it] ;
//
//		unsigned int fLevel = map.faceLevel(old) ;
//		unsigned int cur = map.getCurrentLevel() ;
//		map.setCurrentLevel(fLevel - 1) ;
//
//		// on compte le degré de la face grossière
//		unsigned int degree = 0 ;
//		Dart fit = old ;
//		do
//		{
//			++degree ;
//			fit = map.phi1(fit) ;
//		} while (fit != old) ;
//
//		PFP::AGENTS agents ;
//		PFP::SegmentVECT obst ;
//		PFP::SegmentVECT neighborObst ;
//		//premier tour pour les darts qui vont disparaitre
//		fit = old ;
//		do
//		{
//			Dart nf = map.phi2(fit) ;
//			if (!map.faceIsSubdivided(nf))
//			{
//				map.setCurrentLevel(fLevel) ;
//				PFP::AGENTS& an = agentvect[nf] ;
//				PFP::SegmentVECT resetob = RegisteredEdges[nf] ;
//				for (PFP::AGENTS::iterator ait = an.begin(); ait != an.end(); ++ait)
//				{
//					if ((*ait)->part_.d == map.phi1(nf)) (*ait)->part_.d = nf ;
//				}
//				for (PFP::SegmentVECT::iterator ait = resetob.begin(); ait != resetob.end(); ++ait)
//				{
//
//						resetPart(*ait,nf) ;
//
//				}
//				map.setCurrentLevel(fLevel - 1) ;
//			}
//
//			fit = map.phi1(fit) ;
//		} while (fit != old) ;
//		//deuxieme tour pour les présents
//		fit = old ;
//		do
//		{
//			PFP::AGENTS a(agentvect[fit]) ;
//			PFP::SegmentVECT ob(RegisteredEdges[fit]) ;
//
//			agents.insert(agents.end(), a.begin(), a.end()) ;
//
//			map.setCurrentLevel(map.getMaxLevel()) ;
//			for(PFP::SegmentVECT::iterator ait = ob.begin(); ait != ob.end(); ++ait)
//			{
////				resetObstPartInFace(*ait, fit,fLevel);
//				this->popSegment(*ait) ;
//				obst.push_back(*ait);
//			}
//
//
//
//			for (PFP::AGENTS::iterator ait = a.begin(); ait != a.end(); ++ait)
//				popAgentInCells(*ait, fit) ;
//			map.setCurrentLevel(fLevel - 1) ;
//
//			fit = map.phi1(fit) ;
//		} while (fit != old) ;
//
//		if (degree == 3)
//		{
//			map.setCurrentLevel(fLevel) ;
//			Dart centerFace = map.phi2(map.phi1(old)) ;
//			PFP::AGENTS a(agentvect[centerFace]) ;
//			PFP::SegmentVECT ob(RegisteredEdges[centerFace]) ;
//
//			agents.insert(agents.end(), a.begin(), a.end()) ;
//			map.setCurrentLevel(map.getMaxLevel()) ;
//			for(PFP::SegmentVECT::iterator ait = ob.begin(); ait != ob.end(); ++ait)
//			{
////				resetObstPartInFace(*ait, fit,Level);
//				this->popSegment(*ait) ;
//				obst.push_back(*ait);
//			}
//			for (PFP::AGENTS::iterator ait = a.begin(); ait != a.end(); ++ait)
//				popAgentInCells(*ait, centerFace) ;
//			map.setCurrentLevel(fLevel - 1) ;
//		}
//
//		//dernier tour concernant les voisins
//		fit = old ;
//		do
//		{
//			PFP::SegmentVECT nob(neighborRegisteredEdges[fit]) ;
//
//			map.setCurrentLevel(map.getMaxLevel()) ;
//			for(PFP::SegmentVECT::iterator ait = nob.begin(); ait != nob.end(); ++ait)
//			{
//				this->popSegment(*ait) ;
//				neighborObst.push_back(*ait);
//			}
//			map.setCurrentLevel(fLevel - 1) ;
//
//			fit = map.phi1(fit) ;
//		} while (fit != old) ;
//
//		if (degree == 3)
//		{
//			map.setCurrentLevel(fLevel) ;
//			Dart centerFace = map.phi2(map.phi1(old)) ;
//			PFP::SegmentVECT nob(neighborRegisteredEdges[centerFace]) ;
//			map.setCurrentLevel(map.getMaxLevel()) ;
//			for(PFP::SegmentVECT::iterator ait = nob.begin(); ait != nob.end(); ++ait)
//			{
//				this->popSegment(*ait) ;
//				neighborObst.push_back(*ait);
//			}
//			map.setCurrentLevel(fLevel - 1) ;
//		}
//
//
//
//
//
//		map.setCurrentLevel(fLevel - 1) ;
//
//		Algo::Surface::IHM::coarsenFace<PFP>(map, old, position) ;
//
//		std::pair<bool, bool>& sf = subdivisableFace[old] ;
//		sf.first = true ;
//		sf.second = true ;
//
//		map.setCurrentLevel(map.getMaxLevel()) ;
//
//		neighborAgentvect[old].clear() ;
//
//		for (PFP::AGENTS::iterator itA = agents.begin(); itA != agents.end(); ++itA)
//		{
//			(*itA)->part_.d = old ;
//			pushAgentInCells(*itA, old) ;
//		}
//		for (PFP::SegmentVECT::iterator ait = obst.begin(); ait != obst.end(); ++ait)
//		{
//			resetObstPartInFace(*ait, old);
//			pushSegmentInSetOfCells(*ait) ;
//		}
//		for (PFP::SegmentVECT::iterator ait = neighborObst.begin(); ait != neighborObst.end(); ++ait)
//		{
//			pushSegmentInSetOfCells(*ait) ;
//		}
//
//		Dart dd = old ;
//		do
//		{
//			Dart ddd = map.alpha1(map.alpha1(dd)) ;
//			while (ddd != dd)
//			{
//				neighborAgentvect[old].insert(neighborAgentvect[old].end(), agentvect[ddd].begin(), agentvect[ddd].end()) ;
//				ddd = map.alpha1(ddd) ;
//			}
//			dd = map.phi1(dd) ;
//		} while (dd != old) ;
//
//		if (fLevel > 1 && !coarsenMark.isMarked(old) && agentvect[old].size() < nbAgentsToSimplify)
//		{
//			coarsenMark.mark(old) ;
//			coarsenCandidate.push_back(map.faceOldestDart(old)) ;
//		}
//
//		map.setCurrentLevel(cur) ;
//	}
//	map.setCurrentLevel(map.getMaxLevel()) ;
//
//	if (coarsenCandidate.size() > 0)
//		updateMap() ;
//}
//
//void EnvMap::updateMap()
//{
//	assert(map.getCurrentLevel() == map.getMaxLevel()) ;
//
//	refine();
//	coarse();
//}