//------------------------------------------------------------------------+
// Copyright (C), 1998-2011, Beijing Tangent Software Co. Ltd.
// = FileName	:   TGGeVisibilityPoly2D类
// = Version	:   ver1.0
// = Author		:   cet
// = CreateDate	:   2011-04-13
// = Description:   具有可见性属性的poly2d类实现
// = Maintainers: 
//                  
//------------------------------------------------------------------------+

#include "stdafx.h"
#include "TGGeVisibilityPoly2D.h"
#include "TchGlobalDef.h"

namespace
{
	bool IsOnSameLine(const AcGePoint3d &pt1, const AcGePoint3d &pt2, const AcGePoint3d &pt3)
	{
		AcGeVector3d vt1 = pt2 - pt1, vt2 = pt3 - pt2;
		return (vt1.isParallelTo(vt2) == Adesk::kTrue ? true : false);
	}

	// 求三点构成的弧的角度(pt2为弧中一点， pt1, pt3 为端点)
	double GetAngleBy3Pt(const TADSGePoint3d &pt1, const TADSGePoint3d &pt2, const TADSGePoint3d &pt3)
	{
		AcGeVector3d vt1 = pt1 - pt2;
		AcGeVector3d vt2 = pt3 - pt2;
		double dAngle = vt1.angleTo(vt2);  // 夹角
		dAngle = (PI - dAngle) * 2; // 根据圆内接四边形对角互补，并且四边形任意一角是其对应圆心角的一半
		return dAngle;
	}
}

TGGeVisibilityPoly2D::TGGeVisibilityPoly2D()
{
	m_arnVisibility.Reset();
}

TGGeVisibilityPoly2D::TGGeVisibilityPoly2D( const TGGeVisibilityPoly2D & src )
{
	TADSGePointList::copyFrom(src);
	m_ardbulges.Reset();
	m_ardbulges.copyFrom( src.m_ardbulges );
	m_arnVisibility.Reset();
	m_arnVisibility.copyFrom(src.m_arnVisibility);
	m_nFlag = src.GetFlag();
}

TGGeVisibilityPoly2D::~TGGeVisibilityPoly2D()
{

}

void TGGeVisibilityPoly2D::Reset()
{
	TGGePoly2D::Reset();
	m_arnVisibility.Reset();
}

bool TGGeVisibilityPoly2D::SetAcDbCurve( AcDbCurve* pCurve )
{
	AcDbPolyline* pLwPoly = AcDbPolyline::cast(pCurve);
	if (pLwPoly == NULL )
	{
		return false;
	}

	Reset(); // 清空数据

	double dElev = pLwPoly->elevation(); // 标高
	AcDb::Visibility visible = pLwPoly->visibility(); // 可见性
	AcGePoint2d pt;
	double dBulge = 0.0;

	for (long i = 0; i < (long)pLwPoly->numVerts(); i++)
	{
		pLwPoly->getPointAt(i, pt);
		pLwPoly->getBulgeAt(i, dBulge);
		dBulge = atan(dBulge) * 4; // 角度，直线时为0，弧线时为弧的角度
		AppendNode(TADSGePoint3d(pt.x, pt.y, dElev), dBulge, visible);
	}

	if (pLwPoly->isClosed())
	{
		m_nFlag = 1;
	}
	else
	{
		m_nFlag = 0;
	}

	return true;
}

int TGGeVisibilityPoly2D::Nth( int nIndex, TGGeLine &xline, TGGeArc &xarc, AcDb::Visibility *pVal /*= NULL*/ ) const
{
	if (!IsValid(nIndex)) // 判断索引是否有效
	{
		return RTERROR;
	}

	int nLen = Length();
	TADSGePoint3d p1 = (*this)[nIndex]; // 索引nIndex所对应线段的第一个点
	TADSGePoint3d p2;
	if (nIndex == nLen - 1) // 第二个点
	{
		p2 = (*this)[0];
	}
	else
	{
		p2 = (*this)[nIndex + 1];
	}

	// 线段的可见性
	if (pVal != NULL)
	{
		AcDb::Visibility val = m_arnVisibility[nIndex];
		*pVal = val;
	}

	double dAng = m_ardbulges[nIndex];
	if (fabs(dAng) > 1.0E-6) // 线段为弧线
	{
		xarc.Set(p1,p2,dAng);
		return ARC_SEGMENT;
	}
	else // 线段为直线
	{
		xline.m_startPoint = p1;
		xline.m_endPoint = p2;
		return LINE_SEGMENT;
	}
}

int TGGeVisibilityPoly2D::Nth( int nIndex, TGGeCurveSegment & cvCurve, AcDb::Visibility *pVal /*= NULL*/ ) const
{
	if (!IsValid(nIndex))
	{
		return RTERROR;
	}

	static TGGeLine ln;
	static TGGeArc arc;
	int nflg = Nth(nIndex, ln, arc,pVal);
	int nFlag = cvCurve.m_nFlag;
	int nRet = RTNORM;

	switch(nflg)
	{
	case LINE_SEGMENT:
		cvCurve.m_startPoint = ln.m_startPoint;
		cvCurve.m_endPoint = ln.m_endPoint;
		cvCurve.m_dBulge = 0.0;
		break;
	case ARC_SEGMENT:
		cvCurve = arc;
		break;
	default:
		nRet = RTERROR;
	}
	cvCurve.m_nFlag = nFlag;
	return nRet;
}

int TGGeVisibilityPoly2D::Nth( int nIndex, TGGeDirectionCurve &curve, AcDb::Visibility *pVal /*= NULL*/ ) const
{
	if (!IsValid(nIndex))
	{
		return RTERROR;
	}

	int nLen = Length();
	TADSGePoint3d p1 = (*this)[nIndex], p2;
	if (nIndex == nLen - 1)
	{
		p2 = (*this)[0];
	}
	else
	{
		p2 = (*this)[nIndex + 1];
	}

	if (pVal != NULL)
	{
		*pVal = m_arnVisibility[nIndex];
	}

	double dAng = m_ardbulges[nIndex];
	curve.m_startPoint = p1;
	curve.m_endPoint = p2;
	curve.m_dBulge = dAng;
	return RTNORM;
}

int TGGeVisibilityPoly2D::Reverse()
{
	if (Length() < 2)
	{
		return RTERROR;
	}

	TGGeVisibilityPoly2D destPoly;
	int nTotalSeg = TotalSegments();
	TGGeDirectionCurve cv;
	AcDb::Visibility visible = AcDb::kVisible;

	for (int i = nTotalSeg - 1; i >= 0; i--)
	{
		Nth(i, cv, &visible);
		destPoly.AppendNode(cv.EndPoint(), -cv.GetBulge(), visible);
	}

	if (!(m_nFlag & 0x01)) // 不闭合，添加原pline的第一个点
	{
		destPoly.AppendNode(*((*this)[0]), -(*m_ardbulges[nTotalSeg]), *m_arnVisibility[nTotalSeg]);
	}

	destPoly.SetFlag(m_nFlag);
	*this = destPoly;
	return RTNORM;
}

int TGGeVisibilityPoly2D::Compress( bool bUnionCurve )
{
	int nLen = Length();
	if (nLen < 1)
	{
		return RTERROR;
	}

	// 删除重复点
	int nIndex = -1; // 重复点索引
	for (int i = 0; i < nLen; i++)
	{
		if (nIndex == -1)
		{
			nIndex = i;
			continue;
		}

		TADSGePoint3d &pt1 = *((*this)[nIndex]); 
		TADSGePoint3d &pt2 = *((*this)[i]);
		if (pt1.Distance(pt2) < _DIST_SNAP) // 两点重合
		{
			RemoveNode(nIndex); // 删除前一个重合点
			--i; // 调整i值使其仍指向pt2点的索引 
			--nLen;
		}
	
		nIndex = i;
	}

	// 检查最后一点和第一点是否重合(闭合时)
	if (m_nFlag == 1 && (*((*this)[0])).Distance(*((*this)[nLen - 1])) < _DIST_SNAP) // 两点重合
	{
		RemoveNode(nLen - 1); // 删除最后一点
	}
    
	if (!bUnionCurve)
	{
		return RTNORM;
	}

	// 合并可见性相同的共线或共圆的线段
	nIndex = -1; // nIndex代表需要和当前索引i对应的线段对比的线段索引(前一点索引)
	int bMerged = 0; // 是否可合并
	TGGeArc arc1, arc2;
	TGGeLine line1, line2;
	int nType1 = 0, nType2 = 0; // 线型
	int nNextIndex = -1; // 下一点索引
	for (i = 0; i < Length(); i++)
	{
		if (nIndex == -1)
		{
			nIndex = i;
			continue;
		}

		nNextIndex = i + 1;
		if (i == Length() - 1 && m_nFlag == 1) // 曲线闭合在最后一点时，修改索引值
		{
			nNextIndex = 0;
		} 
		else if (i == Length() - 1 && m_nFlag == 0) // 曲线不闭合在最后一点时，退出
		{
			break;
		}

		if (*(m_arnVisibility[nIndex]) == *(m_arnVisibility[i])) // 可见性相同
		{
			 nType1 = Nth(nIndex, line1, arc1, NULL);
			 nType2 = Nth(i, line2, arc2,NULL);

			 if (nType1 == nType2 && nType1 == LINE_SEGMENT) // 同为直线
			 {
				if (IsOnSameLine(*((*this)[nIndex]), *((*this)[i]), *((*this)[nNextIndex]))) // 共线
				{
					RemoveNode(i); // 删除共线直线相交的点
					--i;		   // 调整i值使其指向合并后的直线对应索引
				}
			 }
			 else if (nType1 == nType2 && nType1 == ARC_SEGMENT) // 同为弧线
			 {
				if (fabs(arc1.GetRadius() - arc2.GetRadius()) < _DIST_SNAP && arc1.GetCenterPt() == arc2.GetCenterPt()) // 共圆
				{
					double dAngle = GetAngleBy3Pt(*((*this)[nIndex]), *((*this)[i]), *((*this)[nNextIndex])); // 合并后的新弧的角度
					double dBugle = tan(dAngle/4); // 新弧凸度值
					dBugle = tan(*(m_ardbulges[nIndex]) / 4) < g_angleZero ? fabs(dBugle) * (-1) : fabs(dBugle); // 根据TGGeVisibilityPoly2D在nIndex的凸度值确定合并后的弧段的凸度值
					*(m_ardbulges[nIndex]) = atan(dBugle) * 4; // 修改nIndex的凸度值
					RemoveNode(i); // 删除共线直线相交的点
					--i;		   // 调整i值使其指向合并后的直线对应索引
				}
			 }
		}
		nIndex = i;
	}

	// 曲线闭合时处理最后一段和第一段
	nLen = Length();
	if (m_nFlag == 1 && nLen > 1 && *(m_arnVisibility[0]) == *(m_arnVisibility[nLen - 1]))
	{
		nType1 = Nth(0, line1, arc1, NULL);
		nType2 = Nth(nLen - 1, line2, arc2,NULL);

		if (nType1 == nType2 && nType1 == LINE_SEGMENT) // 同为直线
		{
			// 检查是否共线
			if (IsOnSameLine(*((*this)[nLen - 1]), *((*this)[0]), *((*this)[1]))) // 共线
			{
				RemoveNode(0); // 删除共线直线相交的点
			}
		}
		else if (nType1 == nType2 && nType1 == ARC_SEGMENT) // 同为弧线
		{
			if (fabs(arc1.GetRadius() - arc2.GetRadius()) < _DIST_SNAP && arc1.GetCenterPt() == arc2.GetCenterPt()) // 共圆
			{
				double dAngle = GetAngleBy3Pt(*((*this)[nLen - 1]), *((*this)[0]), *((*this)[1])); // 合并后的新弧的角度
				double dBugle = tan(dAngle/4); // 新弧凸度值
				dBugle = *(m_ardbulges[nLen - 1]) < g_angleZero ? fabs(dBugle) * (-1) : fabs(dBugle); // 根据TGGeVisibilityPoly2D在nIndex的凸度值确定合并后的弧段的凸度值
				*(m_ardbulges[nLen - 1]) = atan(dBugle) * 4; // 修改nIndex的凸度值
				RemoveNode(0); // 删除共线直线相交的点
			}
		}
	}

	return RTNORM;
}

int TGGeVisibilityPoly2D::Make( LPCTSTR szLay /*= NULL*/ ) const
{
	int nLen = Length();
	if (nLen <= 1)
	{
		return RTERROR;
	}

	std::vector<std::vector<int> > vecIndex; // 保存需绘制的所有pline的索引
	std::vector<int> vec;
	bool bExist = false;  // 是否在已有的vec中添加索引
	for (int i = 0; i < nLen; i++)
	{
		if (!bExist)
		{
			vec.clear();
			bExist = true;
		}
		
		if (m_arnVisibility[i] == AcDb::kVisible)
		{
			vec.push_back(i);
		}
		else 
		{
			bExist = false;
			if (!vec.empty())
			{
				vec.push_back(i);
				vecIndex.push_back(vec);
			}
		}
	}

	if (!vec.empty())
	{
		vecIndex.push_back(vec);
	}

	// 当TGGeVisibilityPoly2D的第一个点和最后一个点均可见并且是闭合线时, 合并第一条和最后一条pline
	int nSize = vecIndex.size();
	std::vector<int>::iterator it;
	if (m_nFlag == 1  // 闭合
		&& m_arnVisibility[0] == AcDb::kVisible && m_arnVisibility[nLen - 1] == AcDb::kVisible // 第一点和最后一点均可见
		&& nSize > 1) // 存在多条pline
	{
		std::vector<int> &vec1 = vecIndex[0], &vec2 = vecIndex[nSize - 1];
		for (it = vec1.begin(); it != vec1.end(); it++)
		{
			vec2.push_back(*it);
		}

		vecIndex.erase(vecIndex.begin());
	}

	// 绘制pline
	int nIndex = 0;
	std::vector<std::vector<int> >::iterator it2;
	for (it2 = vecIndex.begin(); it2 != vecIndex.end(); it2++)
	{
		AcDbPolyline *pLine = new AcDbPolyline;
		for (it = (*it2).begin(), nIndex = 0; it != (*it2).end(); it++, nIndex++)
		{
			double dBuge = tan(m_ardbulges[*it] / 4.0);
			pLine->addVertexAt(nIndex, (*this)[*it].AsAcGePoint2d(), dBuge);
		}

		if (nSize == 1 && m_nFlag == 1 && (*it2).size() == nLen) // 所有点可见并且是闭合线
		{
			pLine->setClosed(Adesk::kTrue);
		}
		
		if (szLay)
		{
			AssureLayer(szLay, LAYSTAT_UNLOCK);
			pLine->setLayer(szLay);
		}

		double dThickness = 0.0;
		TGGetVar(_T("THICKNESS"), &dThickness);

		pLine->setThickness(dThickness);
		pLine->setElevation((*this)[0].z);
		AddToModelSpace(pLine, Adesk::kTrue);
	}
		
	return RTNORM;
}

int TGGeVisibilityPoly2D::MakeSegments( LPCTSTR szLay /*= NULL*/ ) const
{
	int nLen = Length();
	for (int i = 0; i < nLen; i++)
	{
		MakeSegment(i, szLay);
	}

	return RTNORM;
}

int TGGeVisibilityPoly2D::MakeSegment( int nIndex, LPCTSTR szLay /*= NULL*/ ) const
{
	TGGeLine line;
	TGGeArc arc;
	AcDb::Visibility eVal;
	int nrc = Nth(nIndex, line, arc, &eVal);
	if (nrc == LINE_SEGMENT && eVal == AcDb::kVisible)
	{
		line.Make(szLay);
	}
	else if (nrc == ARC_SEGMENT  && eVal == AcDb::kVisible)
	{
		arc.Make(szLay);
	}

	return RTNORM;
}

void TGGeVisibilityPoly2D::TransformBy( const AcGeMatrix3d &mat )
{
	TGGePoly2D::TransformBy(mat);
}

void TGGeVisibilityPoly2D::RemoveNode( long nIndex )
{
	TGGePoly2D::RemoveNode(nIndex);
	m_arnVisibility.Remove(nIndex);
}

void TGGeVisibilityPoly2D::InsertNodeAt( int nIndex, const TADSGePoint3d &pt, double dBulge, AcDb::Visibility eVal )
{
	if (nIndex >= Length() - 1)
	{
		AppendNode(pt, dBulge, eVal);
	}
	else
	{
		(*this)[nIndex + 1];
		Insert(new TADSGePoint3d(pt));
		m_ardbulges[nIndex + 1];
		m_ardbulges.Insert(new double(dBulge));
		AcDb::Visibility *pVal = new AcDb::Visibility();
		*pVal = eVal;
		m_arnVisibility[nIndex + 1];
		m_arnVisibility.Insert(pVal);
	}
}

void TGGeVisibilityPoly2D::InsertNodeAt( const TADSGePoint3d &ptOn, AcDb::Visibility eVal )
{
	// 检查ptOn是否在线上
	int nLen = Length();
	if (nLen == 2) // 只有一段线时
	{
		TGGeLine line;
		TGGeArc arc;
		int nType = Nth(0, line, arc, NULL); // 获得线段
		if (nType == LINE_SEGMENT)
		{
			TADSGePoint3d ptS = line.StartPoint(), ptE = line.EndPoint();
			double dDist1 = ptS.Distance(ptOn);
			double dDist2 = ptE.Distance(ptOn);
			double dDist = ptS.Distance(ptE);
			if (fabs(dDist - dDist1 - dDist2) > _DIST_SNAP) // 检查点ptOn是否在直线上
			{
				return;
			}
		}
		else if (nType == ARC_SEGMENT)
		{
			if (!(arc.PtOnArc(ptOn))) // 检查点ptOn是否在弧线上
			{
				return;
			}
		}
		else
		{
			return;
		}
	}
	else if ((ptOn & (*this)) != PR_EDGE)  // 存在多段线段，并且ptOn不在线上
	{
		return;
	}

	// ptOn在顶点上
	for (int i = 0; i < nLen; i++)  
	{
		TADSGePoint3d pt = *((*this)[i]);
		if (pt.Distance(ptOn) < _DIST_SNAP)
		{
			*(m_arnVisibility[i]) = eVal; // ptOn在顶点上时直接修改其可见性即可
			return;
		}
	} 

	// ptOn在线上并且不为顶点
	TGGeLine line;
	TGGeArc arc;
	TADSGePoint3d pt1, pt2;
	for (i = 0; i < nLen; i++)
	{
		int nType = Nth(i, line, arc); // 获取索引i对应的线段
		if (nType == LINE_SEGMENT)
		{
			line.GetStartPoint(pt1);
			line.GetEndPoint(pt2);

			double dDist = pt1.Distance(pt2); // 直线长度
			double dDist2 = pt1.Distance(ptOn) + pt2.Distance(ptOn); // ptOn到直线段两点距离之和

			if (fabs(dDist2 - dDist) < _DIST_SNAP) // 判断点是否在直线上
			{
				if (i == nLen - 1)
				{
					(*this).Append(new TADSGePoint3d(ptOn));
					m_ardbulges.Append(new double(0.0));
					AcDb::Visibility *pVal = new AcDb::Visibility();
					*pVal = eVal;
					m_arnVisibility.Append(pVal);
				} 
				else
				{
					(*this)[i+1];
					(*this).Insert(new TADSGePoint3d(ptOn));
					m_ardbulges[i+1];
					m_ardbulges.Insert(new double(0.0));
					AcDb::Visibility *pVal = new AcDb::Visibility();
					*pVal = eVal;
					m_arnVisibility[i+1];
					m_arnVisibility.Insert(pVal);
				}
				break;
			}
		} 
		else if (nType == ARC_SEGMENT)
		{
			if(arc.PtOnArc(ptOn)) // 判断点是否在弧上
			{
				pt1 = *((*this)[i]);
				if (i == nLen - 1)
				{
					pt2 = *((*this)[0]);
				}
				else
				{
					pt2 = *((*this)[i + 1]);
				}

				// 求被ptOn分为两段的弧的凸度值
				TADSGePoint3d pt;
				arc.GetStartPoint(pt);
				double dAngle1 = 0.0; // pt1与ptOn弧段的角度
				double dAngle2 = 0.0; // pt2与ptOn弧段的角度
				if (pt1.Distance(pt) < _DIST_SNAP) //pt1为弧起点
				{
					pt = arc.GetCenterPt();
					AcGeVector3d vt1 = pt1 - pt;
					AcGeVector3d vt2 = ptOn - pt;
					AcGeVector3d vt3 = pt2 - pt;
					dAngle1 = vt1.angleTo(vt2, AcGeVector3d::kZAxis);
					dAngle2 = vt2.angleTo(vt3, AcGeVector3d::kZAxis);
				}
				else // pt2为弧起点
				{
					pt = arc.GetCenterPt();
					AcGeVector3d vt1 = pt1 - pt;
					AcGeVector3d vt2 = ptOn - pt;
					AcGeVector3d vt3 = pt2 - pt;
					dAngle1 = vt2.angleTo(vt1, AcGeVector3d::kZAxis);
					dAngle2 = vt3.angleTo(vt2, AcGeVector3d::kZAxis);
				}

 				double dBugle1 = tan(dAngle1 / 4); // 凸度值
 				double dBugle2 = tan(dAngle2 / 4);

 				// 根据原弧的凸度正负值确定新弧凸度值
 				double dBugle = tan(*(m_ardbulges[i]) / 4);
 				dBugle1 = dBugle > g_angleZero ? fabs(dBugle1) : fabs(dBugle1) * (-1);
 				dBugle2 = dBugle > g_angleZero ? fabs(dBugle2) : fabs(dBugle2) * (-1);
 
 				dAngle1 = atan(dBugle1) * 4;
 				dAngle2 = atan(dBugle2) * 4;

				// 插入ptOn点
				*(m_ardbulges[i]) = dAngle1; // 修改原弧凸度值
				AcDb::Visibility *pVal = new AcDb::Visibility();
				*pVal = eVal;
				if (i == nLen - 1)
				{
					m_ardbulges.Append(new double(dAngle2));
					m_arnVisibility.Append(pVal);
					(*this).Append(new TADSGePoint3d(ptOn));
				} 
				else
				{
					m_ardbulges[i+1];
					m_ardbulges.Insert(new double(dAngle2));
					m_arnVisibility[i+1];
					m_arnVisibility.Insert(pVal);
					(*this)[i+1];
					(*this).Insert(new TADSGePoint3d(ptOn));
				}
				
				break;
			}
		}
	}
}

void TGGeVisibilityPoly2D::InsertNodeAt(const TADSGePoint3d &ptOn1, const TADSGePoint3d &ptOn2,AcDb::Visibility eVal)
{
	int nIndex1 = HitTestOnCurve(ptOn1);
	int nIndex2 = HitTestOnCurve(ptOn2);
	if (nIndex1 == 0 || nIndex2 == 0) // 有点不在线上
	{
		return;
	}

	AcDb::Visibility eValTemp1 = AcDb::kVisible;
	AcDb::Visibility eValTemp2 = AcDb::kVisible;

	if (nIndex1 < 0) // 非顶点
	{
		eValTemp1 = GetVisibleAt(-nIndex1 - 1);
	}

	if (nIndex2 < 0) // 非顶点
	{
		eValTemp2 = GetVisibleAt(-nIndex2 - 1);
	}

	if (nIndex1 < 0) // 非顶点
	{
		InsertNodeAt(ptOn1,eValTemp1);
	}

	if (nIndex2 < 0) // 非顶点
	{
		InsertNodeAt(ptOn2,eValTemp2);
	}

	nIndex1 = HitTestOnCurve(ptOn1);
	nIndex2 = HitTestOnCurve(ptOn2);

	if (nIndex1 <= 0)
	{
		return;
	}
	if (nIndex2 <= 0)
	{
		return;
	}

	--nIndex1;	
	--nIndex2;

	int nMin = nIndex1 < nIndex2 ? nIndex1 : nIndex2;
	int nMax = nIndex2 < nIndex1 ? nIndex1 : nIndex2;
	for(int i = nMin; i < nMax; i++)
	{
		SetVisibleAt(i, eVal);
	}
}

void TGGeVisibilityPoly2D::AppendNode( const TADSGePoint3d &pt, ads_real dBulge, AcDb::Visibility eVal )
{
	TGGePoly2D::AppendNode(pt, dBulge);
	AcDb::Visibility *pVal = new AcDb::Visibility();
	*pVal = eVal;
	m_arnVisibility.Append(pVal);
}

TGGeVisibilityPoly2D& TGGeVisibilityPoly2D::operator=( const TGGeVisibilityPoly2D &src )
{
	if (this != &src)
	{
		Reset();
		m_nFlag = src.m_nFlag;
		for(int i = 0; i < src.Length(); i++) 
		{
			const TADSGePoint3d &pt = src[i];
			double val = src.m_ardbulges[i];
			AcDb::Visibility *pVal = new AcDb::Visibility();
			*pVal = src.GetVisibleAt(i);
			Append(new TADSGePoint3d(pt));
			m_ardbulges.Append(new ads_real(val));
			m_arnVisibility.Append(pVal);
		}
	}
	return *this;
}

void TGGeVisibilityPoly2D::SetVisible( AcDb::Visibility dNewVal )
{
	int nLen = Length();
	for (int i = 0; i < nLen; i++)
	{
		*m_arnVisibility[i] = dNewVal;
	}
}

void TGGeVisibilityPoly2D::SetVisibleAt( int nIndex, AcDb::Visibility dNewVal )
{
	if (!IsValid(nIndex))
	{
		return;
	}

	*m_arnVisibility[nIndex] = dNewVal;
}

void TGGeVisibilityPoly2D::SetVisibleAt( const TADSGePoint3d& ptOn, AcDb::Visibility dNewVal )
{
	int nLen = Length();
	for (int i = 0; i < nLen; i++) 
	{
		if (ptOn.Distance(*((*this)[i])) < _DIST_SNAP)
		{
			*m_arnVisibility[i] = dNewVal;
			break;  
		}
	}
}

void TGGeVisibilityPoly2D::SetVisibleAt( int nFrom, int nTo, AcDb::Visibility dNewVal )
{
	int nLen = Length();
	if (IsValid(nFrom) && IsValid(nTo) && nFrom <= nTo)
	{
		for (int i = nFrom; i <= nTo; i++)
		{
			*m_arnVisibility[i] = dNewVal;
		}
	}
}

AcDb::Visibility TGGeVisibilityPoly2D::GetVisibleAt( int nIndex ) const
{
	AcDb::Visibility eVal = AcDb::kVisible;
	if (IsValid(nIndex))
	{
		eVal = m_arnVisibility[nIndex];
	}

	return eVal;
}

AcDb::Visibility TGGeVisibilityPoly2D::GetVisibleAt( const TADSGePoint3d& ptOn ) const
{
	AcDb::Visibility eVal = AcDb::kVisible;
	int nLen = Length();
	for (int i = 0; i < nLen; i++) 
	{
		if ((*this)[i] == ptOn)
		{
			eVal = m_arnVisibility[i];
			break;
		}
	}

	return eVal;
}

int TGGeVisibilityPoly2D::SetVisibilities( TDPtrList<AcDb::Visibility> &arnVisibility )
{
	if (arnVisibility.Length() > 0)
	{
		m_arnVisibility.copyFrom(arnVisibility);
		return m_arnVisibility.Length();
	}
	return -1;
}

int TGGeVisibilityPoly2D::GetVisibilities( TDPtrList<AcDb::Visibility> &arnVisibility )
{
	if (m_arnVisibility.Length() > 0)
	{
		arnVisibility.copyFrom(m_arnVisibility);
		return arnVisibility.Length();
	}
	return -1;
}

TDPtrList<AcDb::Visibility>& TGGeVisibilityPoly2D::GetVisibilities()
{
	return m_arnVisibility;
}

// add by xlc on 110427 获得poly离pt点近的一端指向poly内的方向
// 返回值：true：成功；false：失败
bool TGGeVisibilityPoly2D::GetIDirection(AcGePoint3d pt, double& dDir)
{
	if (TotalSegments() < 1)
	{
		return false;
	}

	TGGeCurveSegment cvSeg;
	if (pt.distanceTo(*(*this)[0]) < pt.distanceTo(*(*this)[Length()-1]))
	{
		Nth(0, cvSeg);
		if (cvSeg.GetBulge() < _angSnap)	//直线段
		{
			dDir = cvSeg.IDirection(0);
		}
		else
		{
			if (pt.distanceTo(cvSeg.StartPoint()) < pt.distanceTo(cvSeg.EndPoint()))
			{
				dDir = cvSeg.IDirection(0);
			}
			else
			{
				dDir = cvSeg.IDirection(1);
			}
		}
	}
	else
	{
		Nth(TotalSegments()-1, cvSeg);
		if (cvSeg.GetBulge() < _angSnap)	//直线段
		{
			dDir = cvSeg.IDirection(1);
		}
		else
		{
			if (pt.distanceTo(cvSeg.StartPoint()) < pt.distanceTo(cvSeg.EndPoint()))
			{
				dDir = cvSeg.IDirection(0);
			}
			else
			{
				dDir = cvSeg.IDirection(1);
			}
		}
	}
	return true;
}