panda
/
COMPASSi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
COMPASSi/trunk/code/projects/OCC/OCCLib/ClosedFinder.cpp

840 lines
22 KiB
C++
Raw Normal View History

first commit
2025-06-25 15:06:42 +08:00
#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;
}