#include "Stdafx.h"
#include "ClosedFinder.h"

//////////////////////////////////////////////////////////////////////////
ClosedFinder::ClosedFinder(void)
{
  tCurMaxSize = 0;
}

ClosedFinder::~ClosedFinder(void)
{
  for (std::map<Point_Key, sPoint*>::iterator pit =mPointsSrc.begin();
    pit != mPointsSrc.end();++pit)
  {
    if(pit->second != NULL)
    {
      delete pit->second;
      pit->second = NULL;
    }
  }
  for (std::map<Arc_Key , sArc* >::iterator pit =mArcsSrc.begin();
    pit != mArcsSrc.end();++pit)
  {
    if(pit->second != NULL)
    {
      delete pit->second;
      pit->second = NULL;
    }
  }
  mPointsSrc.clear();
  mArcsSrc.clear();
}

bool ClosedFinder::getArcHalfEdgeBeginEnd(const std::list<sArcHalfEdge>& lstEdge, const sPoint* & ptFist , const sPoint* & ptEnd)
{
  if (!lstEdge.empty())
  {
    //sArcHalfEdge::ArcHalfEdge_const_iterator itFirst(&(*lstEdge.begin()));
    //sArcHalfEdge::ArcHalfEdge_const_iterator itEnd(&(*lstEdge.rbegin()));

    ////ptFist = itFirst.First();
    ////ptEnd = itEnd.GetEnd();

	 if(lstEdge.size() == 1)
	 {
		  sArcHalfEdge::ArcHalfEdge_const_iterator itFirst(&(*lstEdge.begin()));
		  ptFist = itFirst.First();
		  ptEnd = itFirst.GetEnd();
	 }
	 else
	 {  
		  std::list<sArcHalfEdge>::const_iterator iter = lstEdge.begin();
		  sArcHalfEdge::ArcHalfEdge_const_iterator itFirst(&(*iter++));
		   sArcHalfEdge::ArcHalfEdge_const_iterator itEnd(&(*iter));
		   const sPoint* sp1 = itFirst.First();
		   const sPoint* ep1 = itFirst.GetEnd();
		   const sPoint* sp2 = itEnd.First();
		   const sPoint* ep2 = itEnd.GetEnd();

		   if(sp1->m_Id == sp2->m_Id || sp1->m_Id == ep2->m_Id)
		   {
			   ptFist = ep1;
			   ptEnd = sp1;
		   }
		   else if(ep1->m_Id == sp2->m_Id || ep1->m_Id == ep2->m_Id)
		   {
			   ptFist = sp1;
			   ptEnd = ep1;
		   }

		   for(;iter != lstEdge.end(); iter++)
		   {
			   sArcHalfEdge::ArcHalfEdge_const_iterator it(&(*iter));
			   const sPoint* sp = it.First();
			   const sPoint* ep = it.GetEnd();
			   if(sp->m_Id != ptEnd->m_Id)
			   {
				   ptEnd = sp;
			   }
			   else
			   {
				   ptEnd = ep;
			   }
		   }
	 }
  }

  return !lstEdge.empty();

}

bool ClosedFinder::addPoint( Point_Key key, sPoint* pPoint, bool bCheck /*= true*/ )
{
  std::map<Point_Key, sPoint*>::iterator it = mPointsSrc.find(key);
  if (it != mPointsSrc.end() && bCheck)
  {
   // ASSERT(0);
  }

  mPointsSrc[key] = pPoint;

  return true;
}

bool ClosedFinder::addArc( Arc_Key key , sArc* pArc , bool bCheck /*= true*/ )
{
  bool bRe = !pArc->mPoints.empty();
  if (bRe)
  {
    //保存数据
    std::map<Arc_Key, sArc*>::iterator it = mArcsSrc.find(key);
    if (it != mArcsSrc.end() && bCheck)
    {
      //ASSERT(0);
    }
    //
    mArcsSrc[key] = pArc;

    //保存过端点的linkData
    {
      //起点的半边数据
      sArcHalfEdge halfEdge(pArc);
      halfEdge.mDirection = EAD_Begin2End;
      //
      AddHaldEdge(halfEdge);

      //终点的半边数据
      halfEdge.mDirection = EAD_End2Begin;
      //
      AddHaldEdge(halfEdge);
    }
  }

  return bRe;
}

void ClosedFinder::AddHaldEdge( const sArcHalfEdge &halfEdge )
{
  sArcHalfEdge::ArcHalfEdge_const_iterator itHalfEdge(&halfEdge);
  const sPoint* pt = itHalfEdge.First();
  if (pt)
  {
    std::map<Arc_Key, sArcHalfEdge>* pData = getMapValue(mPointLinkData, pt->m_Id, true);
    if (pData)
    {
      (*pData) [halfEdge.mpArc->m_Id] = halfEdge;
    }
  }
}

//#define __LILIN_DEBUG_
#ifdef __LILIN_DEBUG_
#include <time.h> 
#endif

//搜索的最大多边形
#define STEPMAX  60

//生成多边形，返回值为多边形的个数
int ClosedFinder::GeneralPolygon()
{
  mCurPolygon_Key = 1;

  //int MaxSizeArr[STEPMAX * 2/* + 1*/] = {0};
  //{
  //  //MaxSizeArr[0] = 2;
  //  for(int i = 0; i < STEPMAX; i++)
  //  {
  //    MaxSizeArr[2 * i/*+1*/] = 2 + i;    //第一次
  //    MaxSizeArr[2*i + 1/*+1*/] = 2 + i;  //第二次
  //  }
  //}

  

#ifdef __LILIN_DEBUG_
  time_t t = time( 0 ); 
  char tmp[64]; 
  strftime( tmp, sizeof(tmp), "%Y/%m/%d %X %A 本年第%j天 %z", 
    localtime(&t) ); 
std::string str(tmp);
#endif

int count = 0;
int lastCount = 2;
count = GetMaxEdgeSet();

while(count > 0)
{
	for(int i = lastCount; i < count + 1; i++)
	{
		tCurMaxSize = i;
		tmapGen.clear();
		bool isExist = false;

		std::map<Point_Key, std::map<Arc_Key, sArcHalfEdge> >::iterator it = mPointLinkData.begin();
		for(; it != mPointLinkData.end(); it++)
		{
			sPolygon polygon;

			std::map<Arc_Key, sArcHalfEdge>& linkDatas = it->second;  

			bool bReture = __GeneralPolygon(polygon, linkDatas);

			if (bReture)
			{
				tmapGen[it->first] = it->first;
				isExist = true;
			}
		}

		if(isExist)
		{
			i--;
		}
	}

	lastCount = count +1;
	//itTmp = mPointLinkData.begin();
	//std::map<Arc_Key, sArcHalfEdge>& linkDatas = itTmp->second;  
	//count = SearchGeneralPolygon(polygonTmp, linkDatas);
	count = GetMaxEdgeSet();
	if(lastCount > count)
		break;
}

//for(int i = 0; i < STEPMAX; i++)
//{
//  tCurMaxSize = i + 2;
//  tmapGen.clear();
//  bool isExist = false;
//
//  std::map<Point_Key, std::map<Arc_Key, sArcHalfEdge> >::iterator it = mPointLinkData.begin();
//  for(; it != mPointLinkData.end(); it++)
//  {
//    sPolygon polygon;
//
//    std::map<Arc_Key, sArcHalfEdge>& linkDatas = it->second;  
//
//    bool bReture = __GeneralPolygon(polygon, linkDatas);
//
//    if (bReture)
//    {
//      tmapGen[it->first] = it->first;
//	  isExist = true;
//    }
//  }
//
//  if(isExist)
//  {
//	  i--;
//  }
//}
//2012-5-21  srq  针对bug  网格线，当输入的数据不能创建面时，系统总非法退出，建议给提示信息。 注：交点少于2个是不可能成面的
if(mPolygons.size()<1)
	return 0;

ClearMaxEdgePolygon();
  __CombinPolygon();


#ifdef __LILIN_DEBUG_
  {
    time_t t = time( 0 ); 
    char tmp[64]; 
    strftime( tmp, sizeof(tmp), "%Y/%m/%d %X %A 本年第%j天 %z", 
      localtime(&t) ); 
   std::string str1(tmp);

    str = str + str1;
  }
  AfxMessageBox(str);
#endif

  return mPolygons.size();
}

bool ClosedFinder::__GeneralPolygon(sPolygon polygon, std::map<Arc_Key, sArcHalfEdge>& linkDatas )
{
  bool bReturn = false;
  size_t iSize = polygon.mArcHalfEdge.size() + 1;
  std::multimap<TimeofSearch, sArcHalfEdge*> tmapHalfEdgebyTime = SortPointLinkEdge(linkDatas);


  Point_Key polyFirstId = 0; //当前的多边形弧段集合的起始点号
  Arc_Key arcPreId = 0;  //上一个ARC的ID
  if (!polygon.mArcHalfEdge.empty())
  {
	  sArcHalfEdge::ArcHalfEdge_const_iterator itArcHalfEdge(&(*polygon.mArcHalfEdge.begin()));
	  polyFirstId = itArcHalfEdge.First()->m_Id;

	  arcPreId = polygon.mArcHalfEdge.rbegin()->mpArc->m_Id;
  }

  std::multimap<TimeofSearch, sArcHalfEdge*>::const_iterator itLink = tmapHalfEdgebyTime.begin();
  for(; itLink != tmapHalfEdgebyTime.end(); ++itLink)
  {
    sPolygon polygonCur(polygon);  //创建临时多边形,防止污源被污染
    //
    const sArcHalfEdge& halEdge = *itLink->second;
    const sArc *mpArc = halEdge.mpArc; 

    if (arcPreId == mpArc->m_Id) {continue;}  //不能为上一段线
    //
    if (mpArc->mTimeofSearch == 2)
    {
      //此边及其以后的所有边为死边，返回(因为已经排过顺序)
      break;
    }
    else
    {
      sArcHalfEdge::ArcHalfEdge_const_iterator itArcHalfEdge(&halEdge);
      Point_Key ptFirstId = itArcHalfEdge.First()->m_Id;
      Point_Key ptEndId = itArcHalfEdge.GetEnd()->m_Id;

      if (tmapGen.find(polyFirstId) == tmapGen.end() &&
        tmapGen.find(ptFirstId) == tmapGen.end()) //不为生成过的点
      {
        if (iSize == tCurMaxSize)
        {
          //判断最后一点和第一点是否相等，是的话，则加入到结果封闭区域中
          if (ptEndId == polyFirstId)
          {
            //恭喜，找到封闭的区域
            //if (tCurMaxSize == 2) //TODO : 为两边的时候比较特殊 
            //{
              //tmapGen[ptFirstId] = ptFirstId;
            //}

            AddEdge(polygonCur, halEdge);

            if(_AddPolygon(polygonCur))
            {
              bReturn = true;
              break;
            }
          }
          else
          {
            //失败，不处理
          }
        }
        else
        {
          if (polygonCur.ExistPoint(ptEndId))
          {
            continue;
            //continue;
          }
           if (tCurMaxSize > 2 && polyFirstId == ptEndId)
           {
             continue;
           }
           //不满足最大边，得到最后一点，递归(深度优先)
           AddEdge(polygonCur, halEdge);
          //polygonCur.AddEdge(halEdge);

          std::map<Arc_Key, sArcHalfEdge>* pData = getMapValue(mPointLinkData, ptEndId, false);
          if (pData)
          {
            bReturn = __GeneralPolygon(polygonCur, *pData);
            if (bReturn)
            {
              break;
            }
          }
          else
          {
           // ASSERT(0);
          }
        }
      }
    }
  }

  return bReturn;
}

//搜索多边形， 返回多边形边数，没有 返回-1
int ClosedFinder::SearchGeneralPolygon(sPolygon polygon, std::map<Arc_Key, sArcHalfEdge>& linkDatas )
{
	bool bReturn = false;
	size_t iSize = polygon.mArcHalfEdge.size() + 1;
	std::multimap<TimeofSearch, sArcHalfEdge*> tmapHalfEdgebyTime = SortPointLinkEdge(linkDatas);


	Point_Key polyFirstId = 0; //当前的多边形弧段集合的起始点号
	Arc_Key arcPreId = 0;  //上一个ARC的ID
	if (!polygon.mArcHalfEdge.empty())
	{
		sArcHalfEdge::ArcHalfEdge_const_iterator itArcHalfEdge(&(*polygon.mArcHalfEdge.begin()));
		polyFirstId = itArcHalfEdge.First()->m_Id;

		arcPreId = polygon.mArcHalfEdge.rbegin()->mpArc->m_Id;
	}

	std::multimap<TimeofSearch, sArcHalfEdge*>::const_iterator itLink = tmapHalfEdgebyTime.begin();
	for(; itLink != tmapHalfEdgebyTime.end(); ++itLink)
	{
		sPolygon polygonCur(polygon);  //创建临时多边形,防止污源被污染
		//
		const sArcHalfEdge& halEdge = *itLink->second;
		const sArc *mpArc = halEdge.mpArc; 

		if (arcPreId == mpArc->m_Id) {continue;}  //不能为上一段线
		//
		if (mpArc->mTimeofSearch == 2)
		{
			//此边及其以后的所有边为死边，返回(因为已经排过顺序)
			break;
		}
		else
		{
			sArcHalfEdge::ArcHalfEdge_const_iterator itArcHalfEdge(&halEdge);
			Point_Key ptFirstId = itArcHalfEdge.First()->m_Id;
			Point_Key ptEndId = itArcHalfEdge.GetEnd()->m_Id;

			if (tmapGen.find(polyFirstId) == tmapGen.end() &&
				tmapGen.find(ptFirstId) == tmapGen.end()) //不为生成过的点
			{
					//判断最后一点和第一点是否相等，是的话，则加入到结果封闭区域中
				if (ptEndId == polyFirstId)
				{
					//恭喜，找到封闭的区域
					//if (tCurMaxSize == 2) //TODO : 为两边的时候比较特殊 
					//{
					//tmapGen[ptFirstId] = ptFirstId;
					//}

					AddEdge(polygonCur, halEdge);

					//return polygonCur.mArcHalfEdge.size();
					polygonCur.CalMark();
					if(tmapExistPolygon.find(polygonCur.mMarkType) == tmapExistPolygon.end())
					{
						return polygonCur.mArcHalfEdge.size();
					}
				}
				else
				{
					if (polygonCur.ExistPoint(ptEndId))
					{
						int index = polygonCur.GetPointIndex(ptEndId);
						return polygonCur.mArcHalfEdge.size() - index + 1;
						//continue;
					}
					if (tCurMaxSize > 2 && polyFirstId == ptEndId)
					{
						continue;
					}
					//不满足最大边，得到最后一点，递归(深度优先)
					AddEdge(polygonCur, halEdge);
					//polygonCur.AddEdge(halEdge);

					std::map<Arc_Key, sArcHalfEdge>* pData = getMapValue(mPointLinkData, ptEndId, false);
					if (pData)
					{
						int count = SearchGeneralPolygon(polygonCur, *pData);
						if (count > 0)
						{
							return count;
						}
					}
					else
					{
						// ASSERT(0);
					}
				}
			}
		}
	}

	return -1;
}

int ClosedFinder::GetMaxEdgeSet()
{
	int count = 0;
	int lastCount = 2;

	std::map<Point_Key, std::map<Arc_Key, sArcHalfEdge> >::iterator itTmp = mPointLinkData.begin();

	for(; itTmp != mPointLinkData.end(); itTmp++)
	{
		sPolygon polygonTmp;
		std::map<Arc_Key, sArcHalfEdge>& linkDatas = itTmp->second;  
		count = SearchGeneralPolygon(polygonTmp, linkDatas);
		if(count > 0)
		{
			return count;
		}
	}
	return count;
}

bool ClosedFinder::_AddPolygon( sPolygon &polygonCur)
{
  polygonCur.m_Id = mCurPolygon_Key; 
  polygonCur.CalMark();

// 
   if(!(/*tCurMaxSize == 3 &&*/ ExistPolygon(polygonCur)))//没有存在多边形
  {

	  // 判断多边形的边是否都在 border中  yc 20130724
	  bool isAll = true; 
	  std::vector<sArcHalfEdge>::iterator iter = polygonCur.mArcHalfEdge.begin();
	  for(; iter != polygonCur.mArcHalfEdge.end(); iter ++)
	  {
		  int i = 0;
		  for(; i < (int)border.size(); i++)
		  {
			  if(border[i] == iter->mpArc->m_IdSrc)
			  {
				  break;
			  }
		  }
		  if( i == (int)border.size())
		  {
			  isAll = false;
			  break;
		  }
	  }

	  if(isAll)
	  {
		  return false;
	  }


    mCurPolygon_Key++ ;
    //把多边形的边的计算数加1
#ifdef _DEBUG
   std::string str;
#endif
    {
#ifdef _DEBUG
      //str.Format(_T("(%d): "), polygonCur.m_Id);
      str = "(" + std::to_string(polygonCur.m_Id) + "): ";
#endif
      std::vector<sArcHalfEdge>::iterator itpl = polygonCur.mArcHalfEdge.begin();
      polygonCur.mIsIland = true;
      for(; itpl != polygonCur.mArcHalfEdge.end(); itpl ++)
      {
        itpl->mpArc->mTimeofSearch += 1;
        //去掉孤岛标志
        sArcHalfEdge& halfEdge = *itpl;
        PostIsland(polygonCur, halfEdge);

#ifdef _DEBUG
        sArcHalfEdge::ArcHalfEdge_const_iterator halfIter(&(*itpl));
        std::string strT; 
        //strT.Format(_T("%d(%c,%d-%d), "), itpl->mpArc->m_Id, 'a' + itpl->mpArc->m_Id - 1,
        //  halfIter.First()->m_Id, halfIter.GetEnd()->m_Id);
        char arcChar = 'a' + itpl->mpArc->m_Id - 1; 
        strT = std::to_string(itpl->mpArc->m_Id) + "(" + arcChar + "," +
        std::to_string(halfIter.First()->m_Id) + "-" + std::to_string(halfIter.GetEnd()->m_Id) + "), ";

        str = str + strT;
#endif
      }
    }

    //如果为孤岛,需要把孤岛的边再次加1,这样，就不会再次搜索
    if (polygonCur.mIsIland)
    {
      std::vector<sArcHalfEdge>::iterator itpl = polygonCur.mArcHalfEdge.begin();
      for(; itpl != polygonCur.mArcHalfEdge.end(); itpl ++)
      {
        itpl->mpArc->mTimeofSearch += 1;
      }
#ifdef _DEBUG
      str = str + "(island)";
#endif
    }

    mPolygons[polygonCur.m_Id] = polygonCur;

#ifdef _DEBUG
    str = str + "\n";
    //OutputDebugString(str.c_str());
#endif

    //缓存所有两变形面
    _PostPolygon2edge(polygonCur);

    //AfxMessageBox(str);
	return true;
  }
   return false;
}

bool ClosedFinder::ExistPolygon( const sPolygon &polygonCur )
{
  bool bExist = false;
  std::map<T_MARK_TYPE, Polygon_Key>::const_iterator it = tmapExistPolygon.find(polygonCur.mMarkType);   //已经被生成过的多边形，

  if (it != tmapExistPolygon.end())//存在
  {
    bExist = true;
  }
  else
  {
    //缓存已经存在的东东
    tmapExistPolygon[polygonCur.mMarkType] = polygonCur.m_Id;
  }

  return bExist;
}


void ClosedFinder::PostIsland( sPolygon &polygonCur, sArcHalfEdge& halfEdge )
{
  if (polygonCur.mIsIland)
  {
    sArcHalfEdge::ArcHalfEdge_const_iterator itHalfEdge(&(halfEdge));
    const sPoint* pt = itHalfEdge.First();
    const std::map<Arc_Key, sArcHalfEdge>*pDate = getMapValue_Const
      <Point_Key, std::map<Arc_Key, sArcHalfEdge> >(mPointLinkData, pt->m_Id);
    //
    if (pDate && pDate->size() > 2) //非孤岛 
    {
      polygonCur.mIsIland = false;
    }
  }
}

TimeofSearch ClosedFinder::_GetMaxTimeOfSearch( sPolygon &polygonCur)
{
  TimeofSearch mTimeofSearch = 0;
  std::vector<sArcHalfEdge>::const_iterator it = polygonCur.mArcHalfEdge.begin();
  for(; it != polygonCur.mArcHalfEdge.end(); it++)
  {
    mTimeofSearch = max(it->mpArc->mTimeofSearch, mTimeofSearch);
  }
  return mTimeofSearch;
}

//
std::multimap<TimeofSearch, sArcHalfEdge*> ClosedFinder::SortPointLinkEdge( std::map<Arc_Key, sArcHalfEdge> &linkDatas )
{
  std::multimap<TimeofSearch, sArcHalfEdge*> tmapHalfEdgebyTime;
  tmapHalfEdgebyTime.clear();
  std::map<Arc_Key, sArcHalfEdge>::iterator itLink = linkDatas.begin();
  for(; itLink != linkDatas.end(); itLink++)
  {
    TimeofSearch timesS = itLink->second.mpArc->mTimeofSearch;
    //tmapHalfEdgebyTime.insert(std::make_pair<TimeofSearch, sArcHalfEdge*>(timesS, &itLink->second));   //pj change
    tmapHalfEdgebyTime.insert(std::make_pair(timesS, &itLink->second)); 
  }

  return tmapHalfEdgebyTime;
}

void ClosedFinder::_PostPolygon2edge(const sPolygon &polygonCur )
{
  //return;
  if (polygonCur.mArcHalfEdge.size() == 2)
  {
    CompositeKey compKey(0,0);
    if (polygonCur.GetBE_CompositeKey(compKey))
    {
      //mp
      std::map<Point_Key, std::map<Arc_Key, sArcHalfEdge> >* pCompData = 
        getMapValue<CompositeKey, std::map<Point_Key, std::map<Arc_Key, sArcHalfEdge> > >
        (mmapLinkArcs2, compKey, true);;   //弧段所属的等同段

      if (pCompData)
      {
        polygonCur.GetBE_HalfEdge(*pCompData);
      }
    }
  }
}
void ClosedFinder::AddEdge( sPolygon &polygonCur, const sArcHalfEdge& halEdge )
{
  sArcHalfEdge halEdgeT(halEdge);
  //判断最后当前的半边数据结构是否存在两边形
  if (!mmapLinkArcs2.empty() && !polygonCur.mArcHalfEdge.empty())
  {
    sArcHalfEdge::ArcHalfEdge_const_iterator itHalf(&halEdgeT);
    CompositeKey compKey(0,0);
    compKey.mKey1 = min(itHalf.First()->m_Id, itHalf.GetEnd()->m_Id);
    compKey.mKey2 = max(itHalf.First()->m_Id, itHalf.GetEnd()->m_Id);

    //
    const std::map<Point_Key, std::map<Arc_Key, sArcHalfEdge> >* pCompData = 
      getMapValue_Const<CompositeKey, std::map<Point_Key, std::map<Arc_Key, sArcHalfEdge> > >
      (mmapLinkArcs2, compKey);;   //弧段所属的等同段

    //存在，求最小的距离
    if (pCompData)
    {
       //std::map<Point_Key, std::map<Arc_Key, sArcHalfEdge> >::const_iterator& itArcs = pCompData->find(compKey.mKey1);        //pj
       auto itArcs = pCompData->find(compKey.mKey1);
       if (itArcs != pCompData->end())
       {
         const std::map<Arc_Key, sArcHalfEdge>& arcs = itArcs->second;
         std::map<double/*distance*/, const sArcHalfEdge*> tHalfByDis;

         gp_Point pt(0,0,0);
         polygonCur.GetAverageMarkPoint(pt);

         {
           std::map<Arc_Key, sArcHalfEdge>::const_iterator it = arcs.begin();
           for(; it != arcs.end(); it++)
           {
             const gp_Point& ptCur = it->second.mpArc->mMarkPoint;
             double dbl = (pt.X() - ptCur.X())*((pt.X() - ptCur.X())) + 
               (pt.Y() - ptCur.Y())*(pt.Y() - ptCur.Y()) + 
               (pt.Z() - ptCur.Z()) * (pt.Z() - ptCur.Z()); 

             tHalfByDis[dbl] = &it->second;
           }
         }

         //
         if (!tHalfByDis.empty())
         {
           std::map<double, const sArcHalfEdge*>::const_iterator it =  tHalfByDis.begin();
           for(; it != tHalfByDis.end(); it ++)
           {
             const sArcHalfEdge* psArcHalfEdge = it->second;
             if (psArcHalfEdge->mpArc->mTimeofSearch < 2 && 
               !polygonCur.ExistArc(psArcHalfEdge->mpArc->m_Id))
             {
               halEdgeT = * it->second;
               break;
             }
           }
         }
       }
    }
  }

  //添加
  polygonCur.AddEdge(halEdgeT);
}

bool ClosedFinder::__CombinPolygon()
{

  //
  std::map<Polygon_Key, sPolygon >::const_iterator itpl = mPolygons.begin();
  for(; itpl != mPolygons.end(); itpl++)
  {
    const sPolygon& pl = itpl->second;

    const std::vector<sArcHalfEdge>& mArcHalfEdge = pl.mArcHalfEdge;
    if (!mArcHalfEdge.empty())
    {
      std::list<std::pair<Arc_Key, std::list<sArcHalfEdge> > >&  lstPolygon = 
        *getMapValue<Polygon_Key, std::list<std::pair<Arc_Key, std::list<sArcHalfEdge> > > >(mPolygonsCombin, itpl->first, true);

      std::pair<Arc_Key, std::list<sArcHalfEdge> > pairEdge;
      std::vector<sArcHalfEdge>::const_iterator it = mArcHalfEdge.begin();
      //
      const sArcHalfEdge* edgeSrc = &(*it++);
      pairEdge.first = edgeSrc->mpArc->m_IdSrc;
      pairEdge.second.push_back(*edgeSrc);
      for(; it != mArcHalfEdge.end(); it++)
      {
        const sArcHalfEdge* edgeCur = &(*it);
        if (edgeCur->mpArc->m_IdSrc == pairEdge.first)
        {
          pairEdge.second.push_back(*edgeCur);
        }
        else
        {
          lstPolygon.push_back(pairEdge);
          //
          edgeSrc = edgeCur;
          pairEdge.first = edgeSrc->mpArc->m_IdSrc;
          pairEdge.second.clear();
          pairEdge.second.push_back(*edgeSrc);
        }
      }
      //尾首合并
	  //--- yangchen 2012.5.15 start
	  std::pair<Arc_Key, std::list<sArcHalfEdge> > pairEdgeTmp = lstPolygon.front();
	  if(pairEdgeTmp.first == pairEdge.first)
	  {
		  std::list<sArcHalfEdge> edgeSet = pairEdge.second;
		  std::list<sArcHalfEdge> edgeSetTmp = pairEdgeTmp.second;
		  for(std::list<sArcHalfEdge>::reverse_iterator iter = edgeSet.rbegin(); iter != edgeSet.rend(); iter++)
		  {
			  pairEdgeTmp.second.push_front(*iter);
		  }
		  lstPolygon.pop_front();
		  lstPolygon.push_front(pairEdgeTmp);
	  }
      else
		//--- yangchen 2012.5.15 end
		  lstPolygon.push_back(pairEdge);
    }
  }

  return true;
}

bool ClosedFinder::ClearMaxEdgePolygon()
{
	std::map<Polygon_Key, sPolygon >::reverse_iterator itpl = mPolygons.rbegin();

	sPolygon pl = itpl->second;
	Polygon_Key ikey = itpl->first;
	vector<Point_Key> keySet1 = pl.GetPointKeySet();
	//CompositeKey ckey;
	//pl.GetBE_CompositeKey(ckey);

	itpl++;
	for (;itpl!=mPolygons.rend();++itpl)
	{
		if(IsIncludeClosedPolygon(keySet1,itpl->second.GetPointKeySet()))
		{
			mPolygons.erase(ikey);
			break;
		}
	}
	return true;
}

bool ClosedFinder::IsIncludeClosedPolygon(vector<Point_Key>& keySet1, vector<Point_Key> keySet2)
{
	int count = 0;

	for(vector<Point_Key>::iterator iter1 = keySet1.begin();iter1 != keySet1.end(); iter1++)
	{

		for(vector<Point_Key>::iterator iter2 = keySet2.begin();iter2 != keySet2.end(); iter2++)
		{
			if(*iter1 == *iter2)
			{
				count++;
				break;
			}
		}
	}
	return count > 2;
}