#include "stdafx.h"
#include "TEImpCabletry.h"
#include "TDbInterfaceMsgWrite.h"
#include "TDbPipeBase.h"
#include "math.h"
#include "dbobjptr.h"

// 三角线间隔
#define ARROWINTER 500
#define ARROWSEC 200

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif


Adesk::Boolean acedPostCommand( const TCHAR * );


TEImpCabletry::TEImpCabletry()
{
	m_pOwnerEnt = NULL;
}	

TEImpCabletry::TEImpCabletry(TDbPipeBase* pOwner)
{
	m_pOwnerEnt = pOwner;
	m_pXDataMap = pOwner->GetSpecialtyData();
}

TEImpCabletry::~TEImpCabletry()
{
}

Acad::ErrorStatus TEImpCabletry::getClassID(CLSID* pClsid) const
{
// #if (ADS < 16)
// 	CLSID CLSID_PipeBaseEntity = {0x46765BA5, 0xBD04, 0x11D3, { 0xB5, 0x79, 0x00, 0x10, 0xA4, 0x01, 0xA3, 0xC5 }};
// #endif
// 
// #if (ADS == 16)
// 	CLSID CLSID_PipeBaseEntity = {0x46765BA5, 0xBD04, 0x11D3, { 0xB5, 0x79, 0x00, 0x10, 0xA4, 0x01, 0xA3, 0xC6 }};
// #endif
// 
// #if (ADS == 17)
// 	CLSID CLSID_PipeBaseEntity = {0x46765BA5, 0xBD04, 0x11D3, { 0xB5, 0x79, 0x00, 0x10, 0xA4, 0x01, 0xA3, 0xC7 }};
// #endif
// 
// #if (ADS == 18)
// 	CLSID CLSID_PipeBaseEntity = {0x46765BA5, 0xBD04, 0x11D3, { 0xB5, 0x79, 0x00, 0x10, 0xA4, 0x01, 0xA3, 0xC8 }};
// #endif
// 
// #if (ADS == 19)
// 	CLSID CLSID_PipeBaseEntity = {0x46765BA5, 0xBD04, 0x11D3, { 0xB5, 0x79, 0x00, 0x10, 0xA4, 0x01, 0xA3, 0xC8 }};
// #endif

	return Acad::eOk;
}

BOOL TEImpCabletry::NotifyInterfaceToModify(const TInterfaceModifyMsg& iModiMsg,TInterfaceModifyMsgs& iModiMsgs)
{
	BOOL bMsgTranslate = FALSE;
	TDb::InterfaceOper eOper = iModiMsg.GetInterfaceOper();
	switch (eOper)
	{
	case TDb::eMoveGripPoint:
		{
			bMsgTranslate =	OnMoveGripPointMsgNotify(iModiMsg,iModiMsgs);
			break;
		}
	case TDb::eTransformBy:
		{
			bMsgTranslate =	OnTransformMsgNotify(iModiMsg,iModiMsgs);
			break;
		}
	case TDb::eSize:
		{
			break;
		}
	default:
		break;
	}
	if (m_pOwnerEnt != NULL) m_pOwnerEnt->recordGraphicsModified();
	return bMsgTranslate;
}

BOOL TEImpCabletry::OnMoveGripPointMsgNotify(const TInterfaceModifyMsg& iModiMsg,TInterfaceModifyMsgs& iModiMsgs)
{
	if (m_pXDataMap == NULL) return FALSE;
	BOOL bMsgTranslate = FALSE;
	AcDbObjectId id = iModiMsg.GetMsgOperateOn();
	if (id == m_pOwnerEnt->objectId()) // 消息发送目标正确
	{
		AcGePoint3d ptGeCon = iModiMsg.GetMsgPoint();
		AcGePoint3d ptGeSta = StartPoint();
		AcGePoint3d ptGeEnd = EndPoint();
		
		AcGePoint3d ptGeOldSta = ptGeSta;
		AcGePoint3d ptGeOldEnd = ptGeEnd;
		AcGeVector3d vtLine = ptGeEnd - ptGeSta;
		
		AcGeVector3d vtOffset = iModiMsg.GetMoveGripOffset();
//		if ( vtLine.isPerpendicularTo(vtOffset))// 垂直
		if (!vtLine.isParallelTo(vtOffset))
		{
			//接口更改
			ptGeSta += vtOffset;
			ptGeEnd += vtOffset;

			//更新自身模型空间的扩展字典的接口信息	
			SetStartPoint(ptGeSta);
			SetEndPoint(ptGeEnd);

			AcDbObjectId id1,id2;
			m_pXDataMap->GetAt(KEY_IDCNT1,id1);
			m_pXDataMap->GetAt(KEY_IDCNT2,id2);
			
			AcGeMatrix3d xform;
			xform.setToTranslation(vtOffset);

			// 构造新的接口传递消息,接口对象的均为Fitting基类派生
			AcDbObjectId idT;

			//sta 端
			if (FindConnect(ptGeOldSta,vtLine,m_pOwnerEnt->objectId(),idT)) // sta 点的接口
			{
				//if (idT == id1 || idT == id2)
				{
					TInterfaceModifyMsg msg;
					msg.SetMsgPoint(ptGeOldSta);
					msg.SetTransform(xform);
					msg.SetMsgOperateOn(idT);
					iModiMsgs.append(msg);
					bMsgTranslate = TRUE;
				}
			}
			
			//end  端
			if (FindConnect(ptGeOldEnd,vtLine,m_pOwnerEnt->objectId(),idT)) // end 点的接口
			{
				//if (idT == id1 || idT == id2)
				{
					TInterfaceModifyMsg msg;
					msg.SetMsgPoint(ptGeOldEnd);
					msg.SetTransform(xform);
					msg.SetMsgOperateOn(idT);
					iModiMsgs.append(msg);
					bMsgTranslate = TRUE;
				}
			}
			UpdateInterfaceRec(m_pOwnerEnt->objectId(),xform);
		}
//		else if (vtLine.isParallelTo(vtOffset)) //平行
		else if (vtLine.isParallelTo(vtOffset)) //平行
		{
			if (ptGeOldSta.distanceTo(ptGeCon) < 1.e-3 )//关联有效
			{
				ptGeSta += vtOffset;
				SetStartPoint(ptGeSta);

				//更新自身模型空间的扩展字典的接口信息
				AcGeMatrix3d xform;
				xform.setToTranslation(vtOffset);
				UpdateInterfaceRec(m_pOwnerEnt->objectId(),xform,&ptGeOldSta);

				//不在往下传递
			}

			if (ptGeOldEnd.distanceTo(ptGeCon) < 1.e-3)//关联有效
			{
				ptGeEnd += vtOffset;
				SetEndPoint(ptGeEnd);

				//更新自身模型空间的扩展字典的接口信息
				AcGeMatrix3d xform;
				xform.setToTranslation(vtOffset);
				UpdateInterfaceRec(m_pOwnerEnt->objectId(),xform,&ptGeOldEnd);

				//不在往下传递
			}
		}
		else //不平行,发送回流消息,支持斜拉伸功能
		{
			//求斜边的向量
			double dLen = vtOffset.angleTo(vtLine);
			dLen = fabs(cos(dLen));
			dLen = vtOffset.length() / dLen;
			vtLine.normalize();
			AcGeVector3d vtOffset2 = vtOffset.orthoProject(vtLine.perpVector());
			vtOffset2.normalize();
			vtOffset2 *= dLen;
			AcGeVector3d vtOffset1;

			AcDbObjectId idT;
			if (ptGeOldSta.distanceTo(ptGeCon) < 1.e-3 )//关联有效
			{
				ptGeSta += vtOffset2;
				SetStartPoint(ptGeSta);

				//更新自身模型空间的扩展字典的接口信息
				AcGeMatrix3d xform;
				xform.setToTranslation(vtOffset2);
				UpdateInterfaceRec(m_pOwnerEnt->objectId(),xform,&ptGeOldSta);

				//sta 端
				if (FindConnect(ptGeSta,vtLine,m_pOwnerEnt->objectId(),idT)) // sta 点的接口
				{
					vtOffset1 = vtOffset2 - vtOffset;
					
					//设置消息回溯标记,表示处理过的对象二次再接收消息处理
					iModiMsgs.SetFlowBackFlag(TRUE);
					TInterfaceModifyMsg msg;

					ptGeSta = ptGeOldSta + vtOffset;
					msg.SetMsgPoint(ptGeSta);
					msg.SetGripPosition(TDb::eStart);
					msg.SetMoveGripOffset(vtOffset1);
					msg.SetMsgOperateOn(idT);
					iModiMsgs.append(msg);
					bMsgTranslate = TRUE;
				}
			}

			if (ptGeOldEnd.distanceTo(ptGeCon) < 1.e-3)//关联有效
			{
				ptGeEnd += vtOffset2;
				SetEndPoint(ptGeEnd);

				//更新自身模型空间的扩展字典的接口信息
				AcGeMatrix3d xform;
				xform.setToTranslation(vtOffset2);
				UpdateInterfaceRec(m_pOwnerEnt->objectId(),xform,&ptGeOldEnd);

				//end  端
				if (FindConnect(ptGeEnd,vtLine,m_pOwnerEnt->objectId(),idT)) // end 点的接口
				{
					vtOffset1 = vtOffset2 - vtOffset;

					//设置消息回溯标记,表示处理过的对象二次再接收消息处理
					iModiMsgs.SetFlowBackFlag(TRUE);
					TInterfaceModifyMsg msg;
					ptGeEnd = ptGeOldEnd + vtOffset;
					msg.SetMsgPoint(ptGeEnd);
					msg.SetGripPosition(TDb::eEnd);
					msg.SetMoveGripOffset(vtOffset1);
					msg.SetMsgOperateOn(idT);
					iModiMsgs.append(msg);
					bMsgTranslate = TRUE;
				}
			}
		}
	}
	return bMsgTranslate;
}

BOOL TEImpCabletry::OnTransformMsgNotify(const TInterfaceModifyMsg& iModiMsg,TInterfaceModifyMsgs& iModiMsgs)
{
	if (m_pXDataMap == NULL) return FALSE;

	BOOL bMsgTranslate = FALSE;
	AcDbObjectId id = iModiMsg.GetMsgOperateOn();

	AcGePoint3d ptGeSta = StartPoint();
	AcGePoint3d ptGeEnd = EndPoint();
	
	AcGePoint3d ptGeOldSta = ptGeSta;
	AcGePoint3d ptGeOldEnd = ptGeEnd;
	AcGeVector3d vtLine = ptGeEnd - ptGeSta;
	
	//接口更改
	ptGeSta.transformBy(iModiMsg.GetTransform());
	ptGeEnd.transformBy(iModiMsg.GetTransform());

	AcGePoint3d ptGeMsgOn = iModiMsg.GetMsgPoint();
	AcGeVector3d vtLineE = ptGeEnd - ptGeOldEnd;
	AcGeVector3d vtLineS = ptGeSta - ptGeOldSta;

	// 平行  拉伸S端,不再传递新消息
	if (vtLineS.isParallelTo(vtLine) && ptGeMsgOn.distanceTo(ptGeOldSta) < 1.e-3) 
	{
		SetStartPoint(ptGeSta);

		//更新自身命名字典的接口信息
		UpdateInterfaceRec(m_pOwnerEnt->objectId(),ptGeOldSta,ptGeSta);
		return TRUE;
	}

	// 平行 拉伸E端,不再传递新消息
	if (vtLineE.isParallelTo(vtLine) && ptGeMsgOn.distanceTo(ptGeOldEnd) < 1.e-3)
	{
		SetEndPoint(ptGeEnd);

		//更新自身命名字典的接口信息
		UpdateInterfaceRec(m_pOwnerEnt->objectId(),ptGeOldEnd,ptGeEnd);
		return TRUE;
	}

	SetStartPoint(ptGeSta);
	SetEndPoint(ptGeEnd);

	//更新自身的接口信息
	UpdateInterfaceRec(m_pOwnerEnt->objectId(),iModiMsg.GetTransform());

	AcDbObjectId id1,id2;
	m_pXDataMap->GetAt(KEY_IDCNT1,id1);
	m_pXDataMap->GetAt(KEY_IDCNT2,id2);

	// 构造新的接口传递消息,接口对象的均为Fitting基类派生
	//sta 端
	AcDbEntity* pEntSta = NULL;
	if (Acad::eOk == acdbOpenAcDbEntity(pEntSta,id1,AcDb::kForRead))
	{
		TDbFittingBase* pFitting = TDbFittingBase::cast(pEntSta);
		if (pFitting != NULL)
		{
			if (pFitting->HasInterface(ptGeOldSta,vtLine))
			{
				//垂直 只有当垂直移动操作,才继续传递接口消息
				if (vtLineS.isPerpendicularTo(vtLine))
				{
					TInterfaceModifyMsg msg;
					msg.SetMsgPoint(ptGeOldSta);
					msg.SetTransform(iModiMsg.GetTransform());
					msg.SetMsgOperateOn(id1);
					iModiMsgs.append(msg);
					bMsgTranslate = TRUE;
				}
			}
		}
		pEntSta->close();
	}
	
	//end  端
	AcDbEntity* pEntEnd = NULL;
	if (Acad::eOk == acdbOpenAcDbEntity(pEntEnd,id2,AcDb::kForRead))
	{
		TDbFittingBase* pFitting = TDbFittingBase::cast(pEntEnd);
		if (pFitting != NULL)
		{
			if (pFitting->HasInterface(ptGeOldEnd,vtLine))
			{
				//垂直 只有当垂直移动操作,才继续传递接口消息
				if (vtLineE.isPerpendicularTo(vtLine))
				{
					TInterfaceModifyMsg msg;
					msg.SetMsgPoint(ptGeOldEnd);
					msg.SetTransform(iModiMsg.GetTransform());
					msg.SetMsgOperateOn(id2);
					iModiMsgs.append(msg);
					bMsgTranslate = TRUE;
				}
			}
		}
		pEntEnd->close();
	}
	return bMsgTranslate;
}

Acad::ErrorStatus TEImpCabletry::ExplodeOrDraw3d(XExplodeDraw &mode) const
{
	Acad::ErrorStatus errorState = Acad::eOk;

	if (m_pXDataMap == NULL) 
		return Acad::eNotImplementedYet;

	int nStyle = eC;
	m_pXDataMap->GetAt(KEY_STYLE,nStyle);
	
	switch (nStyle)
	{
	case TDb::eP:// 盘式桥架
		{
			errorState = ExplodeOrDraw3dOfP(mode);
			break;
		}
	case TDb::eC:// 槽式桥架
		{
			errorState = ExplodeOrDraw3dOfC(mode);
			break;
		}
	case TDb::eT:// 梯式桥架
		{
			errorState = ExplodeOrDraw3dOfT(mode);
			break;
		}
	default:
		break;
	}
	
	return errorState;
}

Acad::ErrorStatus TEImpCabletry::ExplodeOrDraw2d(XExplodeDraw &mode) const
{
	if (m_pXDataMap == NULL)
	{
		return Acad::eNotImplementedYet;
	}

	TComplexCurve cplCurve;
	MakeCurves(cplCurve);
	
	TDbExtentsEdge edage;
	edage.SetEdage(cplCurve);

	BOOL bWeight = 0;
	m_pXDataMap->GetAt(KEY_EDAGEWEIGHT,bWeight);
	
	AcDbObjectId idReal = ((TDbInterfacesObj*)m_pOwnerEnt)->layerId();
	AcDbObjectId idDash = ((TDbInterfacesObj*)m_pOwnerEnt)->DashLayer();
	AcDbObjectId idCent = ((TDbInterfacesObj*)m_pOwnerEnt)->CenterLayer();

	edage.ExplodeOrDraw2d(mode,idReal,idDash,idCent,NULL,bWeight,FALSE);

	/*TDb::TCurveElement el;
	memset(&el,0,sizeof(TDb::TCurveElement));
	for (int i = 0;i < cplCurve.length();i++)
	{
		el = cplCurve.at(i);
		if (el.ptGe[1].distanceTo(el.ptGe[2]) < 1.e-10)
		{
			mode->geometry().polyline(2,el.ptGe);
		}
		else
		{
			mode->geometry().circularArc(el.ptGe[0],el.ptGe[1],el.ptGe[2]);
		}
	}*/
	return Acad::eOk;
}

BOOL TEImpCabletry::NoneConectLineIfNeed(TComplexCurve& cplCurve) const
{
	TInterface inf;
	int nIndex = -1;
	int nInfCount = GetInterfaceCount();
	for (int i = 0;i < nInfCount;i++)
	{
		// 获取接口
		if (GetInterface(i,inf))
		{
			// 判断是否有连接物
			if (GetInterface(inf.GetPosition(),inf))
			{
				if (MakesureIsPipe(inf.GetConnectObject()))
				{
					continue;
				}
				// 获取连接点所在的线段索引号
				if (GetIndexOfPointIsOn(cplCurve,inf.GetPosition(),nIndex))
				{
					cplCurve.removeAt(nIndex);
				}
			}
		}
	}
	return TRUE;
}

// 判断实体是否为桥架
BOOL TEImpCabletry::MakesureIsPipe(const AcDbObjectId& id) const
{
	BOOL bSuc = FALSE;
	AcDbEntity* pEnt = NULL;
	if (acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead) == Acad::eOk)
	{
		TDbECabletry* pPipe = TDbECabletry::cast(pEnt);
		if (pPipe)
		{
			bSuc = TRUE;
		}
		pEnt->close();
	}
	return bSuc;
}

BOOL TEImpCabletry::GetIndexOfPointIsOn(TComplexCurve& cplCurv,const AcGePoint3d& ptOn,int& nIndex) const
{
	AcDbLine line;
	AcGePoint3d ptFind;
	for (int i = 0;i < cplCurv.length();i++)
	{
		line.setStartPoint(cplCurv[i].ptGe[0]);
		line.setEndPoint(cplCurv[i].ptGe[1]);

		line.getClosestPointTo(ptOn,ptFind);
		// 是否和最近点相同
		if (ptOn.distanceTo(ptFind) < 1.0e-3)
		{
			nIndex = i;
			return TRUE;
		}
	}
	return FALSE;
}

BOOL TEImpCabletry::MakeCurves(TComplexCurve& cplCurve) const
{
	if (m_pXDataMap == NULL) 
	{
		return FALSE;
	}
	
	int nCable = 0;
	m_pXDataMap->GetAt(KEY_CABLE,nCable);
	if (nCable == TDb::eArcCabletray)
	{
		return MakeArcCurves(cplCurve);
	}
	int nCover = 1;
	double dW = 0.0;
	double dH = 0.0;
	AcGeVector3d vtNorm;
	AcGePoint3d ptSta,ptEnd,ptGeT;

	m_pXDataMap->GetAt(KEY_B,dW);
	m_pXDataMap->GetAt(KEY_H,dH);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNorm);
	m_pXDataMap->GetAt(KEY_START,ptSta);
	m_pXDataMap->GetAt(KEY_END,ptEnd);
	m_pXDataMap->GetAt(KEY_COVER,nCover);
	vtNorm.normalize();

	// 简易模型投影
	/*
		3				  0
		+-----------------+
		|				  |
		+-----------------+
		|				  |
		+-----------------+
		2				  1
	*/

	/*  3    0
		----+
		a   |b
		----|
			|
		----+ 1
		2
	*/  
	AcGePoint3d ptGe[5];
	AcGeVector3d vtLine = ptEnd - ptSta;
	AcGeVector3d vtVer = vtLine;
	vtVer.rotateBy(PI / 2.0,vtNorm);
	vtVer.normalize();

	TDb::TCurveElement el;
	memset(&el,0,sizeof(TDb::TCurveElement));

	AcGeLine3d line3d(AcGePoint3d::kOrigin,AcGePoint3d::kOrigin + 5.0 * vtNorm);

	if(AcGePlane::kXYPlane.isParallelTo(line3d))
	{
		vtVer = vtNorm;

		vtVer.normalize();
		AcGeVector3d vt01 = vtVer;
		vt01.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
		
		ptGe[0] = ptEnd + dW / 2.0 * vt01;
		ptGe[1] = ptEnd - dW / 2.0 * vt01;
		ptGe[3] = ptGe[0] + dH * vtVer;
		ptGe[2] = ptGe[1] + dH * vtVer;
		ptGe[4] = ptGe[0];
	}
	else
	{
		ptGe[0] = ptEnd + dW / 2.0 * vtVer;
		ptGe[1] = ptEnd - dW / 2.0 * vtVer;
		ptGe[3] = ptSta + dW / 2.0 * vtVer;
		ptGe[2] = ptSta - dW / 2.0 * vtVer;
		ptGe[4] = ptGe[0];
	}

	if(!vtNorm.isParallelTo(AcGeVector3d::kZAxis))
	{
		//for (int i = 0; i <= 1; ++i)
		for (int i = 0; i <= 2; ++i)//modify by axc 2013.7.29修改边的循环索引值为2
		{
			el.ptGe[0] = ptGe[i];
			el.ptGe[1] = ptGe[i+1];
			el.ptGe[2] = ptGe[i+1];
			cplCurve.append(el);
		}
		//el.ptGe[0] = ptGe[0];
		el.ptGe[0] = ptGe[0];
		el.ptGe[1] = ptGe[3];
		el.ptGe[2] = ptGe[3];
		cplCurve.append(el);

		if (nCover)
		{
			el.ptGe[0] = ptGe[2];
			el.ptGe[1] = ptGe[3];
			el.ptGe[2] = ptGe[3];
			cplCurve.append(el);
		}
	}
	else
	{
		for (int i = 0; i <= 3; ++i)
		{
			el.ptGe[0] = ptGe[i];
			el.ptGe[1] = ptGe[i+1];
			el.ptGe[2] = ptGe[i+1];
			cplCurve.append(el);
		}
	}

	// 绘制桥架
	double dDist = ptEnd.distanceTo(ptSta);
	vtLine.normalize();
	vtLine *= dDist;

	// 是否显示连接线
	int nCnt = -1;
	m_pXDataMap->GetAt(KEY_SHOWCNTLINE,nCnt);
	if (nCnt == 0)
	{
		NoneConectLineIfNeed(cplCurve);
	}
	
	// 设置边线宽
	double dWidth = 0.0;
	m_pXDataMap->GetAt(KEY_EDAGEWIDTH,dWidth);
	
	memset(&el,0,sizeof(TDb::TCurveElement));
	
	for (int j = 0;j < cplCurve.length();j++)
	{
		el = cplCurve[j];
		el.dWidth = dWidth;
		cplCurve.setAt(j,el);
	}

	// 设置边线颜色
	int nColor = -1;
	if (m_pXDataMap->GetAt(KEY_BORLINECOLOR,nColor))
	{
	
		TDb::TCurveElement el;
		memset(&el,0,sizeof(TDb::TCurveElement));
		
		for (int j = 0;j < cplCurve.length();j++)
		{
			el = cplCurve[j];
			el.nColorIndex = nColor;
			cplCurve.setAt(j,el);
		}
	}

	//梯式, 槽式,盘式的分段画法
	MakeSeglineCurEls(ptGe[3],ptGe[2],vtLine,cplCurve);
 	
	return TRUE;
}

//弧形桥架边界
BOOL TEImpCabletry::MakeArcCurves(TComplexCurve& cplCurve) const
{
	int nCover = 1;
	double dW = 0.0;
	double dH = 0.0;
	AcGeVector3d vtNorm;
	AcGePoint3d ptSta,ptEnd,ptMid;

	m_pXDataMap->GetAt(KEY_B,dW);
	m_pXDataMap->GetAt(KEY_H,dH);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNorm);
	m_pXDataMap->GetAt(KEY_START,ptSta);
	m_pXDataMap->GetAt(KEY_END,ptEnd);
	m_pXDataMap->GetAt(KEY_MID,ptMid);
	m_pXDataMap->GetAt(KEY_COVER,nCover);
	vtNorm.normalize();
	
	AcGeCircArc3d arc(ptSta,ptMid,ptEnd);
	AcGePoint3d ptCenter = arc.center();

	TDb::TCurveElement el;
	memset(&el,0,sizeof(TDb::TCurveElement));

	AcGeLine3d line3d(AcGePoint3d::kOrigin,AcGePoint3d::kOrigin + 5.0 * vtNorm);
	if(AcGePlane::kXYPlane.isParallelTo(line3d))
	{
		//侧视
		AcGePoint3d ptGe[4];
		AcGeVector3d vtVer = vtNorm;
		vtVer.normalize();
		AcGeVector3d vt01 = vtVer;
		vt01.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

		ptGe[0] = ptEnd + dW / 2.0 * vt01;
		ptGe[1] = ptEnd - dW / 2.0 * vt01;
		ptGe[3] = ptGe[0] + dH * vtVer;
		ptGe[2] = ptGe[1] + dH * vtVer;

		el.ptGe[0] = ptGe[0];
		el.ptGe[1] = ptGe[1];
		el.ptGe[2] = ptGe[1];
		cplCurve.append(el);

		el.ptGe[0] = ptGe[0];
		el.ptGe[1] = ptGe[3];
		el.ptGe[2] = ptGe[3];
		cplCurve.append(el);

		el.ptGe[0] = ptGe[1];
		el.ptGe[1] = ptGe[2];
		el.ptGe[2] = ptGe[2];
		cplCurve.append(el);

		if (nCover)
		{
			//盖板
			el.ptGe[0] = ptGe[3];
			el.ptGe[1] = ptGe[2];
			el.ptGe[2] = ptGe[2];
			cplCurve.append(el);
		}
	}
	else
	{
		//俯视
		AcGePoint3d ptGe[6];
		AcGeVector3d vt1,vt2,vt3;
		vt1 = ptSta - ptCenter;
		vt2 = ptMid - ptCenter;
		vt3 = ptEnd - ptCenter;
		vt1.normalize();
		vt2.normalize();
		vt3.normalize();

		ptGe[0] = ptSta + vt1 * dW * 0.5;
		ptGe[1] = ptMid + vt2 * dW * 0.5;
		ptGe[2] = ptEnd + vt3 * dW * 0.5;
		ptGe[3] = ptEnd - vt3 * dW * 0.5;
		ptGe[4] = ptMid - vt2 * dW * 0.5;
		ptGe[5] = ptSta - vt1 * dW * 0.5;

		el.ptGe[0] = ptGe[0];
		el.ptGe[1] = ptGe[1];
		el.ptGe[2] = ptGe[2];
		cplCurve.append(el);

		el.ptGe[0] = ptGe[2];
		el.ptGe[1] = ptGe[3];
		el.ptGe[2] = ptGe[3];
		cplCurve.append(el);

		el.ptGe[0] = ptGe[3];
		el.ptGe[1] = ptGe[4];
		el.ptGe[2] = ptGe[5];
		cplCurve.append(el);

		el.ptGe[0] = ptGe[5];
		el.ptGe[1] = ptGe[0];
		el.ptGe[2] = ptGe[0];
		cplCurve.append(el);

		//分段画法
		AcGeCircArc3d arc(ptSta,ptMid,ptEnd);
		MakeArcSegLineCurEls(arc,dW,cplCurve);
	}

	// 设置边线宽
	double dWidth = 0.0;
	m_pXDataMap->GetAt(KEY_EDAGEWIDTH,dWidth);

	memset(&el,0,sizeof(TDb::TCurveElement));

	for (int j = 0;j < cplCurve.length();j++)
	{
		el = cplCurve[j];
		el.dWidth = dWidth;
		cplCurve.setAt(j,el);
	}

	// 设置边线颜色
	int nColor = -1;
	if (m_pXDataMap->GetAt(KEY_BORLINECOLOR,nColor))
	{
		TDb::TCurveElement el;
		memset(&el,0,sizeof(TDb::TCurveElement));

		for (int j = 0;j < cplCurve.length();j++)
		{
			el = cplCurve[j];
			el.nColorIndex = nColor;
			cplCurve.setAt(j,el);
		}
	}

	return TRUE;
}

// 绘制电缆沟
BOOL TEImpCabletry::MakeCurvesOfCableGouge(TComplexCurve& cplCurve) const
{
	NoneConectLineIfNeed(cplCurve);
	if (m_pXDataMap)
	{
		int nMode = -1;
		m_pXDataMap->GetAt(KEY_GMODE,nMode);
		switch(nMode)
		{
		case TDb::eGLSide:
		case TDb::eGRSide:
			{
				return MakeCurvesOfCableGougeSide(cplCurve);
			}
		case TDb::eGOrder:
			{
				return MakeCurvesOfCableGougeOrder(cplCurve);
			}
		case TDb::eGInter:
			{
				return MakeCurvesOfCableGougeInter(cplCurve);
			}
		default:
			break;
		}
	}
	return FALSE;
}

BOOL TEImpCabletry::MakeCurvesOfCableGougeSide(TComplexCurve& cplCurve) const
{
	if (m_pXDataMap == NULL)
	{
		return FALSE;
	}

	int nMode = -1;
	double dB = 0.0,dH = 0.0;
	double dL = 0.0,dInt = 0.0;
	AcGeVector3d vtNormal;
	AcGePoint3d ptStart,ptEnd;
	double dTWidth = 0.0;
	m_pXDataMap->GetAt(KEY_GTRAY_WIDTH,dTWidth);
	m_pXDataMap->GetAt(KEY_START,ptStart);
	m_pXDataMap->GetAt(KEY_END,ptEnd);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNormal);
	m_pXDataMap->GetAt(KEY_B,dB);
	m_pXDataMap->GetAt(KEY_GLEN,dL);
	m_pXDataMap->GetAt(KEY_GDIST,dInt);
	m_pXDataMap->GetAt(KEY_GMODE,nMode);
	if (dInt == 0)
	{
		return FALSE;
	}
	AcGeVector3d vtHor = ptEnd - ptStart;
	if (vtHor.length() == 0)
	{
		return FALSE;
	}
	AcGeVector3d vtVer = vtHor;
	vtVer.rotateBy(PI / 2,vtNormal);

	vtVer.normalize();
	vtHor.normalize();
	if (nMode == TDb::eGLSide)
	{
		vtVer *= -1;
	}
	TDb::TCurveElement el;
	memset(&el,0,sizeof(TDb::TCurveElement));

	double dLT = ptStart.distanceTo(ptEnd);
	ptStart -= vtVer * (dB / 2);
	AcGePoint3d ptT = ptStart;
	double dLT2 = 0.0;
	while (TRUE)
	{
		ptT += vtHor * dInt;
		dLT2 = ptT.distanceTo(ptStart);
		if (dLT2 < dLT)
		{
			el.ptGe[0] = ptT;
			el.ptGe[1] = ptT + vtVer * dL;
			el.ptGe[2] = ptT + vtVer * dL;
			el.dWidth = dTWidth;
			cplCurve.append(el);
		}
		else
		{
			break;
		}
	}

	return TRUE;
}

// 对立
BOOL TEImpCabletry::MakeCurvesOfCableGougeOrder(TComplexCurve& cplCurve) const
{
	if (m_pXDataMap == NULL)
	{
		return FALSE;
	}
	
	double dB = 0.0,dH = 0.0;
	double dL = 0.0,dInt = 0.0;
	AcGeVector3d vtNormal;
	AcGePoint3d ptStart,ptEnd;
	double dTWidth = 0.0;
	m_pXDataMap->GetAt(KEY_GTRAY_WIDTH,dTWidth);
	m_pXDataMap->GetAt(KEY_START,ptStart);
	m_pXDataMap->GetAt(KEY_END,ptEnd);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNormal);
	m_pXDataMap->GetAt(KEY_B,dB);
	m_pXDataMap->GetAt(KEY_H,dH);
	m_pXDataMap->GetAt(KEY_GLEN,dL);
	m_pXDataMap->GetAt(KEY_GDIST,dInt);
	if (dInt == 0)
	{
		return FALSE;
	}
	AcGeVector3d vtHor = ptEnd - ptStart;
	if (vtHor.length() == 0)
	{
		return FALSE;
	}
	AcGeVector3d vtVer = vtHor;
	vtVer.rotateBy(PI / 2,vtNormal);
	
	vtVer.normalize();
	vtHor.normalize();
	
	TDb::TCurveElement el;
	memset(&el,0,sizeof(TDb::TCurveElement));
	
	double dLT = ptStart.distanceTo(ptEnd);
	ptStart += vtVer * (dB / 2);
	AcGePoint3d ptT = ptStart;
	double dT = 0.0;
	AcGePoint3d ptT2;
	while (TRUE)
	{
		ptT += vtHor * dInt;
		dT = ptT.distanceTo(ptStart);
		if (dT < dLT)
		{
			el.ptGe[0] = ptT;
			el.ptGe[1] = ptT - vtVer * dL;
			el.ptGe[2] = ptT - vtVer * dL;
			el.dWidth = dTWidth;
			cplCurve.append(el);
			ptT2 = ptT - vtVer * dB;
			el.ptGe[0] = ptT2;
			el.ptGe[1] = ptT2 + vtVer * dL;
			el.ptGe[2] = ptT2 + vtVer * dL;
			el.dWidth = dTWidth;
			cplCurve.append(el);
		}
		else
		{
			break;
		}
	}
	
	return TRUE;
}

// 交错
BOOL TEImpCabletry::MakeCurvesOfCableGougeInter(TComplexCurve& cplCurve) const
{
	if (m_pXDataMap == NULL)
	{
		return FALSE;
	}
	double dB = 0.0,dH = 0.0;
	double dL = 0.0,dInt = 0.0;
	AcGeVector3d vtNormal;
	AcGePoint3d ptStart,ptEnd;
	double dTWidth = 0.0;
	m_pXDataMap->GetAt(KEY_GTRAY_WIDTH,dTWidth);
	m_pXDataMap->GetAt(KEY_START,ptStart);
	m_pXDataMap->GetAt(KEY_END,ptEnd);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNormal);
	m_pXDataMap->GetAt(KEY_B,dB);
	m_pXDataMap->GetAt(KEY_H,dH);
	m_pXDataMap->GetAt(KEY_GLEN,dL);
	m_pXDataMap->GetAt(KEY_GDIST,dInt);
	if (dInt == 0)
	{
		return FALSE;
	}
	
	AcGeVector3d vtHor = ptEnd - ptStart;
	AcGeVector3d vtVer = vtHor;
	vtVer.rotateBy(PI / 2,vtNormal);
	
	vtVer.normalize();
	vtHor.normalize();
		
	TDb::TCurveElement el;
	memset(&el,0,sizeof(TDb::TCurveElement));
	
	double dLT = ptStart.distanceTo(ptEnd);
	ptStart += vtVer * (dB / 2);
	AcGePoint3d ptT = ptStart;
	double dT = 0.0;
	while (TRUE)
	{
		ptT += vtHor * dInt;
		dT = ptT.distanceTo(ptStart);
		if (dT < dLT)
		{
			el.ptGe[0] = ptT;
			el.ptGe[1] = ptT - vtVer * dL;
			el.ptGe[2] = ptT - vtVer * dL;
			el.dWidth = dTWidth;
			cplCurve.append(el);
		}
		else
		{
			break;
		}
	}
	ptStart -= vtVer * dB;
	ptT = ptStart - vtHor * dL / 2;
	while (TRUE)
	{
		ptT += vtHor * dInt;
		dT = ptT.distanceTo(ptStart);
		if (dT < dLT)
		{
			el.ptGe[0] = ptT;
			el.ptGe[1] = ptT + vtVer * dL;
			el.ptGe[2] = ptT + vtVer * dL;
			el.dWidth = dTWidth;
			cplCurve.append(el);
		}
		else
		{
			break;
		}
	}

	return TRUE;
}

BOOL TEImpCabletry::MakeSeglineCurEls(AcGePoint3d& ptGe3,AcGePoint3d& ptGe2,AcGeVector3d& vtLine,TComplexCurve& cplCurve) const
{
	double dDist = vtLine.length();
	vtLine.normalize();
	AcGePoint3d ptGeT;
	TDb::TCurveElement el;
	memset(&el,0,sizeof(TDb::TCurveElement));

	//如果有分段
	int nStyle = 0,nShow = 0;
	double dSegLen = 2000.0,dDist2 = 0.0;
	if (m_pXDataMap->GetAt(KEY_SEGLEN,dSegLen)) //有分段
	{
		m_pXDataMap->GetAt(KEY_STYLE,nStyle);
		if (nStyle != TDb::eT) //非梯式
		{
			m_pXDataMap->GetAt(KEY_SEGSHOW,nShow);
			if (!nShow) return TRUE;
		}
		else //梯式
		{
			m_pXDataMap->GetAt(KEY_SEGSHOW,nShow);
			if (!nShow) return TRUE;
		}

		//梯式, 槽式,盘式的分段画法
		int i = 1;
		while(TRUE)
		{
			ptGeT = ptGe3 + i * dSegLen * vtLine;
			dDist2 = ptGeT.distanceTo(ptGe3);

			if (i * dSegLen - dDist < 1.e-10)
			{
				el.ptGe[0] = ptGe3 + i * dSegLen * vtLine;
				el.ptGe[1] = ptGe2 + i * dSegLen * vtLine;
				el.ptGe[2] = el.ptGe[1];
				el.gsMark = 0;
				cplCurve.append(el);
			}
			else
			{
				break;
			}
			i += 1;
		}
	}
	return TRUE;
}

BOOL TEImpCabletry::MakeArcSegLineCurEls(AcGeCircArc3d& arcMid,const double& dWidth,TComplexCurve& cplCurve) const
{
	//弧形桥架分段画法
	AcGePoint3d ptUp,ptDown,ptMid,ptCen;
	TDb::TCurveElement el;
	memset(&el,0,sizeof(TDb::TCurveElement));

	//如果有分段
	int nStyle = 0,nShow = 0;
	double dSegLen = 2000.0,dDist2 = 0.0;
	if (m_pXDataMap->GetAt(KEY_SEGLEN,dSegLen)) //有分段
	{
		m_pXDataMap->GetAt(KEY_SEGSHOW,nShow);
		if (!nShow) return TRUE;

		double dStartParam = arcMid.paramOf(arcMid.startPoint());
		double dEndParam = arcMid.paramOf(arcMid.endPoint());
		double dLength = arcMid.length(dStartParam,dEndParam);

		int nSegment = 1;
		double dSegParam = 0;
		AcGeVector3d vtSeg;

		ptCen = arcMid.center();

		while(1)
		{
			if (dLength - nSegment * dSegLen > 1e-6)
			{
				//够分段
				dSegParam = arcMid.paramAtLength(dStartParam,nSegment * dSegLen);
				ptMid = arcMid.evalPoint(dSegParam);

				vtSeg = ptMid - ptCen;
				vtSeg.normalize();

				ptUp = ptMid + vtSeg * dWidth * 0.5;
				ptDown = ptMid - vtSeg * dWidth * 0.5;

				el.ptGe[0] = ptUp;
				el.ptGe[1] = ptDown;
				el.ptGe[2] = ptDown;
				cplCurve.append(el);
			}
			else
				break;

			nSegment++;
		}
	}

	return TRUE;
}

BOOL TEImpCabletry::GetCurvesInSide(TComplexCurve& compCurve) const
{
	if (m_pXDataMap == NULL)
	{
		return FALSE;	
	}
	int nCable = 0;
	m_pXDataMap->GetAt(KEY_CABLE,nCable);

	if (nCable == TDb::eArcCabletray)
	{
		//弧形桥架
		return GetArcCurvesInSide(compCurve);
	}

	AcGePoint3d ptSta,ptEnd;
	m_pXDataMap->GetAt(KEY_START,ptSta);
	m_pXDataMap->GetAt(KEY_END,ptEnd);

	double dW = 0.0,dH = 0.0;
	m_pXDataMap->GetAt(KEY_B,dW);
	m_pXDataMap->GetAt(KEY_H,dH);

	AcGeVector3d vtNorm;
	m_pXDataMap->GetAt(KEY_NORMAL,vtNorm);

	TDb::TCurveElement el;
	memset(&el,0,sizeof(TDb::TCurveElement));

	int nShowCenLine = 0;
	m_pXDataMap->GetAt(KEY_HASCENLINE,nShowCenLine);
	if (nShowCenLine)
	{
		el.ptGe[0] = ptSta;
		el.ptGe[1] = ptEnd;
		el.ptGe[2] = ptEnd;
		el.gsMark = -1;
		
		compCurve.append(el);
	}

	double dWidth = 0.0;
	m_pXDataMap->GetAt(KEY_CENLWIDTH,dWidth);
	
	for (int j = 0;j < compCurve.length();j++)
	{
		el = compCurve[j];
		el.dWidth = dWidth;
		compCurve.setAt(j,el);
	}

	int nClapboard = -1,nHaveClap = -1;
	m_pXDataMap->GetAt(KEY_HAVE_CLAPBOARD,nHaveClap);
	m_pXDataMap->GetAt(KEY_SHOW_CLAPBOARD,nClapboard);
	
	dWidth = 0.0;
	m_pXDataMap->GetAt(KEY_EDAGEWIDTH, dWidth);
	// 是否显示隔板
	if (nClapboard == TDb::eShowBoard &&
		nHaveClap == TDb::eBoard)
	{
		AcGeVector3d vtMainBoard;
		if (m_pXDataMap->GetAt(KEY_CLAPBOARD_MAINBR,vtMainBoard))
		{
			AcGeLine3d line3d(AcGePoint3d::kOrigin,AcGePoint3d::kOrigin + 5.0 * vtNorm);
			AcGePlane::kXYPlane.isParallelTo(line3d);
			if(AcGePlane::kXYPlane.isParallelTo(line3d))
			{
				vtNorm.normalize();
				vtMainBoard.normalize();
				
				TSupportFunc spFun;
				AcGeDoubleArray arDime;
				spFun.GetClapboardDimension(m_pXDataMap, arDime);
				
				double dOffset = 0.0;
				for (int i = 0;i < arDime.length();++i)
				{
					dOffset = arDime[i];
					
					el.ptGe[0] = ptSta - vtMainBoard * (dW/2-dOffset);
					el.ptGe[1] = el.ptGe[0] + vtNorm * dH;
					el.ptGe[2] = el.ptGe[1];
					el.dWidth = dWidth;
					el.gsMark = -2;
					el.nColorIndex = KEY_CLP_COLORINDEX;
					
					compCurve.append(el);
				}
			}
			else
			{
				vtMainBoard.normalize();
				
				TSupportFunc spFun;
				AcGeDoubleArray arDime;
				spFun.GetClapboardDimension(m_pXDataMap, arDime);
				
				double dOffset = 0.0;
				for (int i = 0;i < arDime.length();++i)
				{
					dOffset = arDime[i];
					
					el.ptGe[0] = ptSta - vtMainBoard * (dW/2-dOffset);
					el.ptGe[1] = ptEnd - vtMainBoard * (dW/2-dOffset);
					el.ptGe[2] = el.ptGe[1];
					el.dWidth = dWidth;
					el.gsMark = -2;
					el.nColorIndex = KEY_CLP_COLORINDEX;
					compCurve.append(el);
				}
			}
		}
	}
		
	AcGePoint3d ptGe[5],ptGeT;
	AcGeVector3d vtLine = ptEnd - ptSta;
	AcGeVector3d vtVer = vtLine;
	vtVer.rotateBy(PI / 2.0,vtNorm);
	vtVer.normalize();

	ptGe[0] = ptEnd + dW / 2.0 * vtVer;
	ptGe[1] = ptEnd - dW / 2.0 * vtVer;
	ptGe[3] = ptSta + dW / 2.0 * vtVer;
	ptGe[2] = ptSta - dW / 2.0 * vtVer;
	ptGe[4] = ptGe[0];

	//梯式, 槽式,盘式的分段画法
	MakeSeglineCurEls(ptGe[3],ptGe[2],vtLine,compCurve);

	if (fabs(ptSta.z - ptEnd.z) > 1e-3)
	{
		AddArrowLinesWhenDifEl(compCurve);
	}

	return compCurve.length() > 0;
}

BOOL TEImpCabletry::GetArcCurvesInSide(TComplexCurve& compCurve) const
{
	AcGePoint3d ptSta,ptEnd,ptMid;
	m_pXDataMap->GetAt(KEY_START,ptSta);
	m_pXDataMap->GetAt(KEY_END,ptEnd);
	m_pXDataMap->GetAt(KEY_MID,ptMid);

	double dW = 0.0,dH = 0.0;
	m_pXDataMap->GetAt(KEY_B,dW);
	m_pXDataMap->GetAt(KEY_H,dH);

	AcGeVector3d vtNorm;
	m_pXDataMap->GetAt(KEY_NORMAL,vtNorm);

	TDb::TCurveElement el;
	memset(&el,0,sizeof(TDb::TCurveElement));

	int nShowCenLine = 0;
	m_pXDataMap->GetAt(KEY_HASCENLINE,nShowCenLine);
	if (nShowCenLine)
	{
		el.ptGe[0] = ptSta;
		el.ptGe[1] = ptMid;
		el.ptGe[2] = ptEnd;
		el.gsMark = -1;

		compCurve.append(el);
	}

	double dWidth = 0.0;
	m_pXDataMap->GetAt(KEY_CENLWIDTH,dWidth);

	for (int j = 0;j < compCurve.length();j++)
	{
		el = compCurve[j];
		el.dWidth = dWidth;
		compCurve.setAt(j,el);
	}

	//隔板

	int nClapboard = -1,nHaveClap = -1;
	m_pXDataMap->GetAt(KEY_HAVE_CLAPBOARD,nHaveClap);
	m_pXDataMap->GetAt(KEY_SHOW_CLAPBOARD,nClapboard);

	m_pXDataMap->GetAt(KEY_EDAGEWIDTH, dWidth);
	// 是否显示隔板
	if (nClapboard == TDb::eShowBoard &&
		nHaveClap == TDb::eBoard)
	{
		AcGeVector3d vtMainBoard,vtM,vtS,vtE;
		AcGeCircArc3d arc(ptSta,ptMid,ptEnd);
		AcGePoint3d ptCenter = arc.center();
		vtM = ptMid - ptCenter;
		vtS = ptSta - ptCenter;
		vtE = ptEnd - ptCenter;
		vtS.normalize();
		vtM.normalize();
		vtE.normalize();
		if (m_pXDataMap->GetAt(KEY_CLAPBOARD_MAINBR,vtMainBoard))
		{
			vtNorm.normalize();
			vtMainBoard.normalize();

			TSupportFunc spFun;
			AcGeDoubleArray arDime;
			spFun.GetClapboardDimension(m_pXDataMap, arDime);

			double dOffset = 0.0;
			for (int i = 0;i < arDime.length();++i)
			{
				dOffset = arDime[i];

				if (!vtM.isCodirectionalTo(vtMainBoard))
				{
					//反向
					el.ptGe[0] = ptSta + vtS*(dW * 0.5 - dOffset);
					el.ptGe[1] = ptMid + vtM*(dW * 0.5 - dOffset);
					el.ptGe[2] = ptEnd + vtE*(dW * 0.5 - dOffset);
				}
				else
				{
					el.ptGe[0] = ptSta - vtS*(dW * 0.5 - dOffset);
					el.ptGe[1] = ptMid - vtM*(dW * 0.5 - dOffset);
					el.ptGe[2] = ptEnd - vtE*(dW * 0.5 - dOffset);
				}

				el.dWidth = dWidth;
				el.gsMark = -2;
				el.nColorIndex = KEY_CLP_COLORINDEX;

				compCurve.append(el);
			}
		}
	}

	return TRUE;
}

void TEImpCabletry::GetClapDirByPt(const AcGePoint3d& pt,AcGeVector3d& vtDir)
{
	//仅适用于弧形桥架.
	AcGePoint3d ptSta,ptMid,ptEnd;
	ptSta = StartPoint();
	ptEnd = EndPoint();
	m_pXDataMap->GetAt(KEY_MID,ptMid);

	AcGeVector3d vtMainBoard,vtM,vtS,vtE;
	AcGeCircArc3d arc(ptSta,ptMid,ptEnd);
	AcGePoint3d ptCenter = arc.center();

	vtM = ptMid - ptCenter;

	if (m_pXDataMap->GetAt(KEY_CLAPBOARD_MAINBR,vtMainBoard))
	{
		if (vtM.isCodirectionalTo(vtMainBoard))
		{
			vtDir = pt - ptCenter;
		}
		else
		{
			vtDir = ptCenter - pt;
		}
		vtDir.normalize();
	}
}

// 首尾标高不同添加线段
void TEImpCabletry::AddArrowLinesWhenDifEl(TComplexCurve& compCurve) const
{
	if (m_pXDataMap == NULL)
	{
		return;	
	}
	AcGeVector3d vtNor;
	AcGePoint3d ptSta,ptEnd;
	double dB = 0.0;
	m_pXDataMap->GetAt(KEY_START,ptSta);
	m_pXDataMap->GetAt(KEY_END,ptEnd);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNor);
	m_pXDataMap->GetAt(KEY_B,dB);
	// 桥架等分
	AcGeVector3d vtVer = ptEnd - ptSta;
	vtVer.rotateBy(PI / 2,vtNor);
	vtVer.normalize();
	// 四等份宽度
	dB /= 8;
	AcGePoint3d ptS = ptSta;
	AcGePoint3d ptE = ptEnd;
	ptS.z = 0;
	ptE.z = 0;
	AcGeVector3d vtDir;
	if (ptSta.z > ptEnd.z)
	{
		vtDir = ptE - ptS;
	}
	else
	{
		vtDir = ptS - ptE;
 		AcGePoint3d ptT = ptE;
 		ptE = ptS;
 		ptS = ptT;
	}

	vtDir.normalize();
	
	double dL = ptS.distanceTo(ptE);

	TDb::TCurveElement el;
	memset(&el,0,sizeof(TDb::TCurveElement));

	AcGePoint3d ptL1,ptL2,ptL3;
	ptL2 = ptS + ARROWINTER * vtDir;
	double dLT = 0.0;
	int nT = 0;
	for (int i = 0;;i++)
	{
		ptL2 = ptL2 + vtDir * ARROWINTER;
		dLT = ptL2.distanceTo(ptS);
		if (dLT > (dL - ARROWINTER))
		{
			break;
		}
		ptL1 = ptL2 - ARROWSEC / 2 * vtDir;
		ptL1 += vtVer * 3 * dB;
		ptL3 = ptL1 - vtVer * 6 * dB;
		el.ptGe[0] = ptL1;
		el.ptGe[1] = ptL2;
		el.ptGe[2] = ptL2;
		compCurve.append(el);
		el.ptGe[0] = ptL2;
		el.ptGe[1] = ptL3;
		el.ptGe[2] = ptL3;
		compCurve.append(el);
		nT++;
	}
	if (nT == 0)
	{
		ptL2 = TSupportFunc::Mid(ptS,ptE);
		if (ptL2.distanceTo(ptS) < ARROWSEC)
		{
			return;
		}
		ptL1 = ptL2 - ARROWSEC * vtDir;
		ptL1 += vtVer * dB;
		ptL3 = ptL1 - vtVer * 2 * dB;
		el.ptGe[0] = ptL1;
		el.ptGe[1] = ptL2;
		el.ptGe[2] = ptL2;
		compCurve.append(el);
		el.ptGe[0] = ptL2;
		el.ptGe[1] = ptL3;
		el.ptGe[2] = ptL3;
		compCurve.append(el);
	}
}


double GetArc3dBugle(const AcGeCircArc3d &arc);//lsd add 2013-11-6

AcDbPolyline* TEImpCabletry::MakePolyCurve() const
{
	if (m_pXDataMap == NULL) return FALSE;

	//该函数用于处理遮挡关系时提供Polyline线;
	double dW = 0.0;
	double dEl = 0.0;
	double dH = 0.0;
	AcGeVector3d vtNorm;
	AcGePoint3d ptSta,ptEnd;

	m_pXDataMap->GetAt(KEY_B,dW);
	m_pXDataMap->GetAt(KEY_H,dH);
	m_pXDataMap->GetAt(KEY_EL,dEl);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNorm);
	m_pXDataMap->GetAt(KEY_START,ptSta);
	m_pXDataMap->GetAt(KEY_END,ptEnd);

	// 简易模型投影
	/*
		3				  0
		+-----------------+
		|				  |
ptsta	+				  +  ptend
		|				  |
		+-----------------+
		2				  1
	*/

	AcGePoint3d ptGe[5];
	AcGeVector3d vtLine = ptEnd - ptSta;
	AcGeVector3d vtVer = vtLine;
	vtVer.rotateBy(PI / 2.0,vtNorm);
	vtVer.normalize();

	ptGe[0] = ptEnd + dW / 2.0 * vtVer;
	ptGe[1] = ptEnd - dW / 2.0 * vtVer;
	ptGe[3] = ptSta + dW / 2.0 * vtVer;
	ptGe[2] = ptSta - dW / 2.0 * vtVer;
	ptGe[4] = ptGe[0];

	//lsd 2013-11-6
	double arBugle[4] = {0.0,0.0,0.0,0.0};
	int nCable = -1;
	m_pXDataMap->GetAt(KEY_CABLE,nCable);
	if (nCable == TDb::eArcCabletray)
	{
		AcGePoint3d ptMid,ptCenter;
		m_pXDataMap->GetAt(KEY_MID,ptMid);
		AcGeCircArc3d arcM(ptSta,ptMid,ptEnd);//桥架中线弧形
		ptCenter = arcM.center();
		AcGeVector3d vtS,vtM,vtE;
		vtS = ptSta - ptCenter;
		vtS.normalize();
		vtM = ptMid - ptCenter;
		vtM.normalize();
		vtE = ptEnd - ptCenter;
		vtE.normalize();

		AcGeCircArc3d arcS(ptEnd - vtE * dW / 2.0,ptMid - vtM * dW /2.0,ptSta - vtS * dW /2.0);//内侧弧
		arBugle[1] = GetArc3dBugle(arcS);

		AcGeCircArc3d arcL(ptSta + vtS * dW / 2.0,ptMid + vtM * dW /2.0,ptEnd + vtE * dW /2.0);//外侧弧
		arBugle[3] = GetArc3dBugle(arcL);

		ptGe[0] = ptEnd + dW / 2.0 * vtE;
		ptGe[1] = ptEnd - dW / 2.0 * vtE;
		ptGe[3] = ptSta + dW / 2.0 * vtS;
		ptGe[2] = ptSta - dW / 2.0 * vtS;
		ptGe[4] = ptGe[0];
	}
	//end
	AcGePlane plan(ptGe[0],ptGe[1],ptGe[2]);
	AcGePoint3d ptOrth = AcGePoint3d::kOrigin.orthoProject(plan);
	plan.set(ptOrth,normal());
	
	dEl = ptOrth.asVector().length();
	if (!ptOrth.asVector().isCodirectionalTo(normal()))
	{
		dEl *= -1.0;
	}

	AcDbPolyline* pPl = new AcDbPolyline;
	for (int i = 0;i < 4;i++)
	{
		pPl->addVertexAt(i,ptGe[i].convert2d(plan),arBugle[i]);//modified lsd 2013-11-6
	}

	pPl->setElevation(dEl);
	pPl->setNormal(plan.normal());
	pPl->setClosed(Adesk::kTrue);

	return pPl;
}

BOOL TEImpCabletry::MakePolyCurveFaces(AcDbVoidPtrArray& arFaces)
{
	if (m_pXDataMap == NULL) return FALSE;

	//该函数用于处理遮挡关系时提供Polyline线;
	double dW = 0.0;
	double dEl = 0.0;
	double dH = 0.0;
	AcGeVector3d vtNorm;
	AcGePoint3d ptSta,ptEnd;

	m_pXDataMap->GetAt(KEY_B,dW);
	m_pXDataMap->GetAt(KEY_H,dH);
	m_pXDataMap->GetAt(KEY_EL,dEl);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNorm);
	m_pXDataMap->GetAt(KEY_START,ptSta);
	m_pXDataMap->GetAt(KEY_END,ptEnd);

	// 简易模型投影
	/*
		0				  1
		+-----------------+
		|				  |
		+                 +
		|				  |
		+-----------------+
		3				  2
	*/

	AcGePoint3d ptGe[4];
	AcGeVector3d vtLine = ptEnd - ptSta;
	AcGeVector3d vtVer = vtLine;
	vtVer.rotateBy(PI / 2.0,vtNorm);
	vtVer.normalize();

	ptGe[0] = ptEnd + dW / 2.0 * vtVer;
	ptGe[2] = ptEnd - dW / 2.0 * vtVer;
	ptGe[1] = ptSta + dW / 2.0 * vtVer;
	ptGe[3] = ptSta - dW / 2.0 * vtVer;

	AcDbFace* pFace = new AcDbFace;
	pFace->setVertexAt(0,ptGe[0]);
	pFace->setVertexAt(1,ptGe[1]);
	pFace->setVertexAt(2,ptGe[3]);
	pFace->setVertexAt(3,ptGe[2]);
	arFaces.append(pFace);

	return arFaces.length() > 0;
}

Acad::ErrorStatus TEImpCabletry::transformBy(const AcGeMatrix3d& xform)
{
	if (m_pXDataMap == NULL) return Acad::eNotImplementedYet;
	
	AcGePoint3d ptSta = StartPoint();
	AcGePoint3d ptEnd = EndPoint();
	AcGePoint3d ptMid;//

	ptSta.transformBy(xform);
	ptEnd.transformBy(xform);
	
	AcGeVector3d vtClap;
	m_pXDataMap->GetAt(KEY_CLAPBOARD_MAINBR,vtClap);
	vtClap.transformBy(xform);
	m_pXDataMap->SetAt(KEY_CLAPBOARD_MAINBR,vtClap);

	// 2012/9/28 add by wzh 解决弧形桥架复制，弧形中点滞留问题
	int nType = -1;
	m_pXDataMap->GetAt(KEY_CABLE, nType);
	if (nType == TDb::eArcCabletray)
	{
		m_pXDataMap->GetAt(KEY_MID, ptMid);
		ptMid.transformBy(xform);
		m_pXDataMap->SetAt(KEY_MID, ptMid);
	}
	///////////////////////////////////////////////////////////////

	AcDbObjectId idOwner = m_pOwnerEnt->objectId();
	if (m_pOwnerEnt != NULL && idOwner.isValid())
	{
		SetEndPoint(ptEnd);
		SetStartPoint(ptSta);

		// 如果实体不是在当前模型空间中,不做写消息,更新接口处理
		AcDbDatabase* pDb = m_pOwnerEnt->database();
		if (pDb == NULL) pDb = acdbCurDwg();

		AcDbObjectId idModel;
		AcDbBlockTable* pTable = NULL;
		pDb->getBlockTable(pTable,AcDb::kForRead);
		if (pTable != NULL)
		{
			pTable->getAt(ACDB_MODEL_SPACE,idModel);
			pTable->close();
		}
		
		// 如果实体不是在当前模型空间中,不做写消息,更新接口处理
		if (idModel == m_pOwnerEnt->blockId())
		{
			// 写入接口更改消息
			TInterfaceModifyMsg iMsg;
			iMsg.SetInterfaceOper(TDb::eTransformBy);
			iMsg.SetMsgValidate(TRUE);
			iMsg.SetTransform(xform);
			iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());

			TDbInterfaceMsgWrite msgWrite;
			msgWrite.WriteInterfaceMsg(iMsg);

			//更新接口记录接口信息
			UpdateInterfaceRec(m_pOwnerEnt->objectId(),xform);
		}
	}
	else
	{
		SetEndPoint(ptEnd);
		SetStartPoint(ptSta);
	}
	return Acad::eOk;
}

TDb::Position TEImpCabletry::ExplainGripIndex(int nIndex) const
{
	TDb::Position ePos = TDb::eStart;
	switch(nIndex)
	{
	case 0:
		{
			ePos = TDb::eStart;
			break;
		}
	case 1:
		{
			ePos = TDb::eMid;
			break;
		}
	case 2:
		{
			ePos = TDb::eEnd;
			break;
		}
	case 3:
		{
			ePos = TDb::eCommand0;
			break;
		}
	case 4:
		{
			ePos = TDb::eCommand1;
			break;
		}
	case 5:
		{
			ePos = TDb::eCommand2;
			break;
		}
	default:
		break;
	}
	return ePos;
}

Acad::ErrorStatus TEImpCabletry::getGripPoints(AcGePoint3dArray& gripPoints,
													 AcDbIntArray& osnapModes,
													 AcDbIntArray& geomIds) const
{
	if (m_pXDataMap == NULL) return Acad::eOk;

	AcGePoint3d ptMid = TSupportFunc::Mid(StartPoint(),EndPoint());

	double dW = 0.0;
	double dEl = 0.0;
	double dH = 0.0;
	AcGeVector3d vtNorm;
	AcGePoint3d ptSta,ptEnd;
	int nCable = 0;

	m_pXDataMap->GetAt(KEY_B,dW);
	m_pXDataMap->GetAt(KEY_H,dH);
	m_pXDataMap->GetAt(KEY_EL,dEl);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNorm);
	m_pXDataMap->GetAt(KEY_START,ptSta);
	m_pXDataMap->GetAt(KEY_END,ptEnd);
	m_pXDataMap->GetAt(KEY_CABLE,nCable);

	if (nCable == TDb::eSilo)
	{
		//竖井
		gripPoints.append(ptMid);
		return Acad::eOk;
	}

	//增加弧形桥架夹点
	if (nCable == TDb::eArcCabletray)
	{
		m_pXDataMap->GetAt(KEY_MID,ptMid);
		gripPoints.append(StartPoint());
		gripPoints.append(ptMid);
		gripPoints.append(EndPoint());

		//弧形桥架命令夹点
		m_pXDataMap->GetAt(KEY_MID,ptMid);
		AcGeCircArc3d arc(ptSta,ptMid,ptEnd);
		AcGePoint3d ptCenter = arc.center();

		AcGeVector3d vtCmd0 = ptSta - ptCenter;
		vtCmd0.rotateBy(PI * 0.5,vtNorm);
		vtCmd0.normalize();

		AcGeVector3d vtCmd1 = ptEnd - ptCenter;
		vtCmd1.rotateBy(PI * 0.5,vtNorm);
		vtCmd1.normalize();

		AcGeVector3d vtCmd2 = ptMid - ptCenter;
		vtCmd2.normalize();
		
		AcGePoint3d ptCmd[3]; 
		//按 10 个像素点
		double dCmd = TSupportFunc::PixelToWcs(10);
		ptCmd[0] = ptSta + dCmd * vtCmd0;
		ptCmd[1] = ptEnd - dCmd * vtCmd1;
		ptCmd[2] = ptMid + dCmd * vtCmd2; 
		gripPoints.append(ptCmd[0]);
		gripPoints.append(ptCmd[1]);
		gripPoints.append(ptCmd[2]);
		return Acad::eOk;
	}
	// 简易模型投影
	/*
		0				  1
		+-----------------+
		|				  |
		+-----------------+
		|				  |
		+-----------------+
		2				  3
	*/

	gripPoints.append(StartPoint());
	gripPoints.append(ptMid);
	gripPoints.append(EndPoint());

	AcGePoint3d ptGe[4];
	AcGeVector3d vtLine = ptEnd - ptSta;
	AcGeVector3d vtVer = vtLine;
	vtVer.rotateBy(PI / 2.0,vtNorm);
	vtVer.normalize();

	ptGe[0] = ptEnd + dW / 2.0 * vtVer;
	ptGe[2] = ptEnd - dW / 2.0 * vtVer;
	ptGe[1] = ptSta + dW / 2.0 * vtVer;
	ptGe[3] = ptSta - dW / 2.0 * vtVer;


	//增加三个命令夹点
	AcGePoint3d ptCmd[3]; //Cmd 0,1
	vtLine.normalize();
	
	//按 10 个像素点
	double dCmd = TSupportFunc::PixelToWcs(10);
	ptCmd[0] = ptSta - dCmd * vtLine;
	ptCmd[1] = ptEnd + dCmd * vtLine;
	ptMid = TSupportFunc::Mid(ptGe[0],ptGe[1]);
	ptCmd[2] = ptMid + dCmd * vtVer; 

	gripPoints.append(ptCmd[0]);
	gripPoints.append(ptCmd[1]);
	gripPoints.append(ptCmd[2]);

	return Acad::eOk;
}

Acad::ErrorStatus TEImpCabletry::getOsnapPoints(AcDb::OsnapMode osnapMode,
												 INT_PTR gsSelectionMark,
												 const AcGePoint3d& pickPoint,
												 const AcGePoint3d& lastPoint,
												 const AcGeMatrix3d& viewXform,
												 AcGePoint3dArray& snapPoints,
												 AcDbIntArray& geomIds) const
{
	if (m_pXDataMap == NULL) return Acad::eOk;
	AcGePoint3d ptMid = TSupportFunc::Mid(StartPoint(),EndPoint());

	double dW = 0.0;
	double dEl = 0.0;
	double dH = 0.0;
	AcGeVector3d vtNorm;
	AcGePoint3d ptSta,ptEnd;

	m_pXDataMap->GetAt(KEY_B,dW);
	m_pXDataMap->GetAt(KEY_H,dH);
	m_pXDataMap->GetAt(KEY_EL,dEl);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNorm);
	m_pXDataMap->GetAt(KEY_START,ptSta);
	m_pXDataMap->GetAt(KEY_END,ptEnd);

	// 简易模型投影
	/*
		0				  1
		+-----------------+
		|				  |
		+-----------------+
		|				  |
		+-----------------+
		2				  3
	*/

	AcGePoint3d ptGe[4];
	AcGeVector3d vtLine = ptEnd - ptSta;
	AcGeVector3d vtVer = vtLine;
	vtVer.rotateBy(PI / 2.0,vtNorm);
	vtVer.normalize();

	ptGe[0] = ptEnd + dW / 2.0 * vtVer;
	ptGe[2] = ptEnd - dW / 2.0 * vtVer;
	ptGe[1] = ptSta + dW / 2.0 * vtVer;
	ptGe[3] = ptSta - dW / 2.0 * vtVer;

	// tsj modify 2009.7.14
	switch(osnapMode)
	{
	case AcDb::kOsModeEnd:
		{
			snapPoints.append(ptGe[0]);
			snapPoints.append(ptGe[1]);
			snapPoints.append(ptGe[2]);
			snapPoints.append(ptGe[3]);
			snapPoints.append(ptSta);
			snapPoints.append(ptEnd);

			break;
		}
	case AcDb::kOsModeMid:
		{
			snapPoints.append(ptMid);

			break;
		}
	case AcDb::kOsModePerp:
		{
			AcGePoint3d ptVerFoot;
			if (GetVerticalFootPoint(pickPoint, lastPoint, ptVerFoot))
			{
				snapPoints.append(ptVerFoot);
			}

			break;
		}		
	case AcDb::kOsModeNear:
		{
			AcGePoint3d ptNear;
			if (GetNearestPoint(pickPoint, ptNear))
			{
				snapPoints.append(ptNear);
			}

			break;
		}
	}

	return Acad::eOk;
}

// 获取垂足点
BOOL TEImpCabletry::GetVerticalFootPoint(const AcGePoint3d& pickPoint,const AcGePoint3d& lastPoint,AcGePoint3d& ptVerFoot) const
{
	BOOL bIsSuc = FALSE;
	TComplexCurve cplCurve;
	if (MakeCurves(cplCurve))
	{
		GetCableMidLine(cplCurve);

		TSupportFunc spFun;
		bIsSuc = spFun.GetVerticalFootPoint(cplCurve, pickPoint, lastPoint, ptVerFoot);
	}
	return bIsSuc;
}

// 获取最近点
BOOL TEImpCabletry::GetNearestPoint(const AcGePoint3d& pickPoint,AcGePoint3d& ptNear) const
{
	BOOL bIsFind = FALSE;
	TComplexCurve cplCurve;
	if (MakeCurves(cplCurve))
	{
		GetCableMidLine(cplCurve);

		TSupportFunc spFun;
		bIsFind = spFun.GetNearestPoint(cplCurve, pickPoint, ptNear);
	}
	return bIsFind;
}

// 获取中心线
BOOL TEImpCabletry::GetCableMidLine(TComplexCurve& compCurve) const
{
	return GetCurvesInSide(compCurve);
}

void TEImpCabletry::UpdateNormal(const AcGePoint3d& ptOld,const AcGePoint3d& ptNew)
{
	AcGePoint3d ptSta = StartPoint();
	AcGePoint3d ptEnd = EndPoint();
	AcGeVector3d vtLineOld = ptEnd - ptSta;
	double dAngle = 0.0;
	AcGeVector3d vtOrth,vtNorm,vtLineNew;
	m_pXDataMap->GetAt(KEY_NORMAL,vtNorm);

	if (ptSta.distanceTo(ptOld) < 1.e-3) //改动sta
	{
		vtOrth = ptEnd - ptNew;

		//2. 算法向量
		if (!vtOrth.isParallelTo(vtLineOld)) //不平行
		{
			AcGePlane plan(ptEnd,ptOld,ptNew);
			if (!plan.normal().isParallelTo(vtNorm)) //不在同一面上
			{
				vtLineNew = ptNew - ptEnd;
				dAngle = vtLineNew.angleTo(vtLineOld);
				vtLineOld.rotateBy(-dAngle,plan.normal());

				if (vtLineOld.isCodirectionalTo(vtLineNew))
				{
					vtNorm.rotateBy(-dAngle,plan.normal());
				}
				else
				{
					vtNorm.rotateBy(dAngle,plan.normal());
				}
				m_pXDataMap->SetAt(KEY_NORMAL,vtNorm);
			}
		}
	}
	else if (ptEnd.distanceTo(ptOld) < 1.e-3) //改动end
	{
		vtOrth = ptNew - ptSta;

		//2. 算法向量
		if (!vtOrth.isParallelTo(vtLineOld)) //不平行
		{
			AcGePlane plan(ptSta,ptEnd,ptNew);
			if (!plan.normal().isParallelTo(vtNorm)) //不在同一面上
			{
				vtLineNew = ptNew - ptSta;
				dAngle = vtLineNew.angleTo(vtLineOld);
				vtLineOld.rotateBy(-dAngle,plan.normal());

				if (vtLineOld.isCodirectionalTo(vtLineNew))
				{
					vtNorm.rotateBy(-dAngle,plan.normal());
				}
				else
				{
					vtNorm.rotateBy(dAngle,plan.normal());
				}
				m_pXDataMap->SetAt(KEY_NORMAL,vtNorm);
			}
		}
	}
}

Acad::ErrorStatus TEImpCabletry::moveGripPointsAt(const AcDbIntArray& indices,const AcGeVector3d& offset)
{
	if (m_pXDataMap == NULL) return Acad::eOk;

	int nCount = indices.length();
	AcGeVector3d vtOrth,vtNorm;
	AcGePoint3d ptSta = StartPoint();
	AcGePoint3d ptEnd = EndPoint();
	AcGeVector3d vtLine = ptEnd - ptSta;
	AcGeVector3d vtLineOld = vtLine;
	AcGePoint3d ptStaOld = ptSta;
	AcGePoint3d ptEndOld = ptEnd;
	int nCable = 0;
	m_pXDataMap->GetAt(KEY_CABLE,nCable);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNorm);
	double dAngle = 0.0;
	AcGeVector3d vtNormNew = vtNorm;

	/*
	只针对单夹点操作，夹点多选选择第一夹点操作
	*/

	if (nCount == 1) //关联移动
	{
		int nIndex = (TDb::Position)indices.first();
		TDb::Position ePos = ExplainGripIndex(nIndex);
		switch (ePos)
		{
		case TDb::eStart:
			{
				AcGeVector3d vt1 = ptSta - ptEnd;
				
				ptSta += offset;
				SetStartPoint(ptSta);
				//如果弧形桥架更新mid点
				if (nCable == TDb::eArcCabletray)
				{
					AcGePoint3d ptMid;
					m_pXDataMap->GetAt(KEY_MID,ptMid);
					XArc arc(ptSta,ptMid,ptEnd);
					ptMid = arc.MidPoint();
					m_pXDataMap->SetAt(KEY_MID,ptMid);
				}
				ModyfyClapVector(vt1,ptSta - ptEnd);

				if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
				{
					// 写入接口更改消息
					TInterfaceModifyMsg iMsg;
					iMsg.SetMsgPoint(ptStaOld);//new pos
					iMsg.SetGripPosition(TDb::eStart);
					iMsg.SetMoveGripOffset(vtOrth);
					iMsg.SetMsgValidate(TRUE);
					iMsg.SetInterfaceOper(TDb::eMoveGripPoint);
					iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());

					TDbInterfaceMsgWrite msgWrite;
					msgWrite.WriteInterfaceMsg(iMsg);
					
					//更新自身模型空间的扩展字典的接口信息
					UpdateInterfaceRec(m_pOwnerEnt->objectId(),ptStaOld,ptSta);
				}
				break;
			}
		case TDb::eEnd:
			{
				AcGeVector3d vt1 = ptEnd - ptSta;
				
				ptEnd += offset;
				SetEndPoint(ptEnd);
				//如果弧形桥架更新mid点
				if (nCable == TDb::eArcCabletray)
				{
					AcGePoint3d ptMid;
					m_pXDataMap->GetAt(KEY_MID,ptMid);
					XArc arc(ptSta,ptMid,ptEnd);
					ptMid = arc.MidPoint();
					m_pXDataMap->SetAt(KEY_MID,ptMid);
				}
				ModyfyClapVector(vt1,ptEnd - ptSta);

				// 3. 传输消息
				if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
				{
					// 写入接口更改消息
					TInterfaceModifyMsg iMsg;
					iMsg.SetMsgPoint(ptEndOld);//new pos
					iMsg.SetGripPosition(TDb::eEnd);
					iMsg.SetMoveGripOffset(vtOrth);
					iMsg.SetMsgValidate(TRUE);
					iMsg.SetInterfaceOper(TDb::eMoveGripPoint);
					iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());

					TDbInterfaceMsgWrite msgWrite;
					msgWrite.WriteInterfaceMsg(iMsg);
					
					//更新自身模型空间的扩展字典的接口信息
					UpdateInterfaceRec(m_pOwnerEnt->objectId(),ptEndOld,ptEnd);
				}
				break;
			}
		case TDb::eMid:
			{
				if (nCable == TDb::eSilo)
				{
					ptSta.transformBy(offset);
					ptEnd.transformBy(offset);

					SetStartPoint(ptSta);
					SetEndPoint(ptEnd);
					break;
				}
				if(nCable == TDb::eArcCabletray)
				{
					//弧形桥架，暂不支持联动
					ptSta.transformBy(offset);
					ptEnd.transformBy(offset);

					SetStartPoint(ptSta);
					SetEndPoint(ptEnd);

					AcGePoint3d ptMid;
					m_pXDataMap->GetAt(KEY_MID,ptMid);
					ptMid.transformBy(offset);
					m_pXDataMap->SetAt(KEY_MID,ptMid);
					break;
				}
				//modify by bsl 增加移动方向控制。按照构件正方向移动，如果2端都连有构件，需正方向平行方可移动。
				AcGeVector3d vtMove;
				if (GetMoveDirect(vtMove))
				{
					vtLine = vtMove;
				}

				vtOrth = offset.orthoProject(vtLine);
				if (!vtOrth.isZeroLength())
				{
					ptSta += vtOrth;
					ptEnd += vtOrth;

					SetStartPoint(ptSta);
					SetEndPoint(ptEnd);

					if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
					{
						// 写入接口更改消息
						TInterfaceModifyMsg iMsg;
						iMsg.SetMsgPoint(TSupportFunc::Mid(ptStaOld,ptEndOld));//new pos
						iMsg.SetGripPosition(TDb::eMid);
						iMsg.SetMoveGripOffset(vtOrth);
						iMsg.SetMsgValidate(TRUE);
						iMsg.SetInterfaceOper(TDb::eMoveGripPoint);
						iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());

						TDbInterfaceMsgWrite msgWrite;
						msgWrite.WriteInterfaceMsg(iMsg);

						//更新自身模型空间的扩展字典的接口信息
						AcGeMatrix3d xform;
						xform.setToTranslation(vtOrth);
						UpdateInterfaceRec(m_pOwnerEnt->objectId(),xform);
					}
				}
				break;
			}
		case TDb::eCommand0:
			{	
				// 写入接口更改消息
				TInterfaceModifyMsg iMsg;
				iMsg.SetMsgPoint(ptSta);//new pos
				iMsg.SetGripPosition(TDb::eCommand0);
				iMsg.SetMoveGripOffset(vtLine);
				iMsg.SetMsgValidate(TRUE);
				iMsg.SetInterfaceOper(TDb::eNewCommand);
				iMsg.SetPreviewObjToCreate(TDb::eCabletry,0);
				
				AcDbSoftPointerId idOwner;
				m_pXDataMap->GetAt(KEY_THISID,idOwner);
				iMsg.SetMsgOperateOn(idOwner);
				TDbInterfaceMsgWrite msgWrite;
				msgWrite.WriteInterfaceMsg(iMsg);
				
				acedPostCommand(_T("\33"));
				CString sCmd;
				GetGlobalContext(KEY_CABGRIPCMD,sCmd);
				if (!sCmd.IsEmpty())
				{
					sCmd += _T("\n");
					acedPostCommand(sCmd);
				}
				break;
			}
		case TDb::eCommand1:
			{
				
    			// 写入接口更改消息
				TInterfaceModifyMsg iMsg;
				iMsg.SetMsgPoint(ptEnd);//new pos
				iMsg.SetGripPosition(TDb::eCommand1);
				iMsg.SetMoveGripOffset(vtLine);
				iMsg.SetMsgValidate(TRUE);
				iMsg.SetInterfaceOper(TDb::eNewCommand);
				iMsg.SetPreviewObjToCreate(TDb::eCabletry,0);
				
				AcDbSoftPointerId idOwner;
				m_pXDataMap->GetAt(KEY_THISID,idOwner);
				iMsg.SetMsgOperateOn(idOwner);
				TDbInterfaceMsgWrite msgWrite;
				msgWrite.WriteInterfaceMsg(iMsg);
				
				acedPostCommand(_T("\33"));
				CString sCmd;
				GetGlobalContext(KEY_CABGRIPCMD,sCmd);
				if (!sCmd.IsEmpty())
				{
					sCmd += _T("\n");
					acedPostCommand(sCmd);
				}
				break;
			}
		case TDb::eCommand2:
			{	
				if (nCable == eArcCabletray)
				{
					break;
				}
				// 写入接口更改消息
				AcGePoint3d ptM = TSupportFunc::Mid(ptSta,ptEnd);
				TInterfaceModifyMsg iMsg;
				iMsg.SetMsgPoint(ptM);//new pos
				iMsg.SetGripPosition(TDb::eCommand2);
				iMsg.SetMoveGripOffset(vtLine);
				iMsg.SetMsgValidate(TRUE);
				iMsg.SetInterfaceOper(TDb::eNewCommand);
				iMsg.SetPreviewObjToCreate(TDb::eTee,TDb::eTHorEqualR);
				
				AcDbSoftPointerId idOwner;
				m_pXDataMap->GetAt(KEY_THISID,idOwner);
				iMsg.SetMsgOperateOn(idOwner);
				TDbInterfaceMsgWrite msgWrite;
				msgWrite.WriteInterfaceMsg(iMsg);
				
				acedPostCommand(_T("\33"));
				CString sCmd;
				GetGlobalContext(KEY_CABGRIPCMD,sCmd);
				if (!sCmd.IsEmpty())
				{
					sCmd += _T("\n");
					acedPostCommand(sCmd);
				}
				break;
			}
		default:
			break;
		}		
	}
	else if (nCount > 1)
	{
		//支持stretch操作。
		if (nCount == 2)
		{
			//2个拉伸点
			TDb::Position ePos;
			int nIndex = (TDb::Position)indices.first();
			TDb::Position ePos1 = ExplainGripIndex(nIndex);
			nIndex = (TDb::Position)indices.last();
			TDb::Position ePos2 = ExplainGripIndex(nIndex);
			if (ePos1 == TDb::eMid)
				ePos = ePos2;
			else
				ePos = ePos1;

			switch(ePos)
			{
			case TDb::eStart:
				{
					AcGeVector3d vt1 = ptSta - ptEnd;

					ptSta += offset;
					SetStartPoint(ptSta);

					ModyfyClapVector(vt1,ptSta - ptEnd);

					if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
					{
						// 写入接口更改消息
						TInterfaceModifyMsg iMsg;
						iMsg.SetMsgPoint(ptStaOld);//new pos
						iMsg.SetGripPosition(TDb::eStart);
						iMsg.SetMoveGripOffset(vtOrth);
						iMsg.SetMsgValidate(TRUE);
						iMsg.SetInterfaceOper(TDb::eMoveGripPoint);
						iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());

						TDbInterfaceMsgWrite msgWrite;
						msgWrite.WriteInterfaceMsg(iMsg);

						//更新自身模型空间的扩展字典的接口信息
						UpdateInterfaceRec(m_pOwnerEnt->objectId(),ptStaOld,ptSta);
					}
					break;
				}
			case TDb::eEnd:
				{
					AcGeVector3d vt1 = ptEnd - ptSta;

					ptEnd += offset;
					SetEndPoint(ptEnd);

					ModyfyClapVector(vt1,ptEnd - ptSta);

					// 3. 传输消息
					if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
					{
						// 写入接口更改消息
						TInterfaceModifyMsg iMsg;
						iMsg.SetMsgPoint(ptEndOld);//new pos
						iMsg.SetGripPosition(TDb::eEnd);
						iMsg.SetMoveGripOffset(vtOrth);
						iMsg.SetMsgValidate(TRUE);
						iMsg.SetInterfaceOper(TDb::eMoveGripPoint);
						iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());

						TDbInterfaceMsgWrite msgWrite;
						msgWrite.WriteInterfaceMsg(iMsg);

						//更新自身模型空间的扩展字典的接口信息
						UpdateInterfaceRec(m_pOwnerEnt->objectId(),ptEndOld,ptEnd);
					}
					break;
				}
			}
		}
		else
		{
			//3个以上,整体移动
			//vtOrth = offset.orthoProject(vtLine);
			if (!offset.isZeroLength())
			{
				ptSta += offset;
				ptEnd += offset;

				SetStartPoint(ptSta);
				SetEndPoint(ptEnd);

				if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
				{
					// 写入接口更改消息
					TInterfaceModifyMsg iMsg;
					iMsg.SetMsgPoint(TSupportFunc::Mid(ptStaOld,ptEndOld));//new pos
					iMsg.SetGripPosition(TDb::eMid);
					iMsg.SetMoveGripOffset(vtOrth);
					iMsg.SetMsgValidate(TRUE);
					iMsg.SetInterfaceOper(TDb::eMoveGripPoint);
					iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());

					TDbInterfaceMsgWrite msgWrite;
					msgWrite.WriteInterfaceMsg(iMsg);

					//更新自身模型空间的扩展字典的接口信息
					AcGeMatrix3d xform;
					xform.setToTranslation(vtOrth);
					UpdateInterfaceRec(m_pOwnerEnt->objectId(),xform);
				}
			}
		}
	}
	return Acad::eOk;
}

CString TEImpCabletry::GetCurrentTypeName() const
{
	CString strName = _T("");
	if (m_pXDataMap != NULL)
	{		
		strName = (_T("槽式直通电缆桥架"));
		int nStyle = 0;
		m_pXDataMap->GetAt(KEY_STYLE,nStyle);

		switch(nStyle)
		{
		case TDb::eP:
			{
				strName.Replace(_T("槽式"),_T("盘式"));
				break;
			}
			
		case TDb::eT:
			{
				strName.Replace(_T("槽式"),_T("梯式"));
				break;
			}
			
		default:
			break;
		}
	}
	return strName;
}

void TEImpCabletry::list() const
{
	if (m_pXDataMap != NULL)
	{
		double dW = 0.0;
		double dH = 0.0;
		AcGePoint3d ptSta,ptEnd;
		CString strType = _T("");

		m_pXDataMap->GetAt(KEY_B,dW);
		m_pXDataMap->GetAt(KEY_H,dH);
		m_pXDataMap->GetAt(KEY_START,ptSta);
		m_pXDataMap->GetAt(KEY_END,ptEnd);
		m_pXDataMap->GetAt(KEY_TYPE,strType);

		acutPrintf(_T("\n\t\t\t\t\t\t\t\t%s\n"),GetCurrentTypeName());
		acutPrintf(_T("\n\t\t\t\t\t型号: %s"),strType);
		double dL = ptSta.distanceTo(ptEnd);
		acutPrintf(_T("\n\t\t\t\t\t长度: %.0f"),dL);
		acutPrintf(_T("\n\t\t\t\t\t宽度: %.0f"),dW);
		acutPrintf(_T("\n\t\t\t\t\t高度: %.0f\n"),dH);
	}
}

void TEImpCabletry::GetTips(CMapStringToString& mapLable2Tip) const
{
	if (m_pXDataMap != NULL)
	{
		double dH = 0.0,dB = 0.0,dL = 0.0;
		AcGePoint3d ptS,ptE;
		
		CString strTemp = _T("");

		m_pXDataMap->GetAt(KEY_START,ptS);
		m_pXDataMap->GetAt(KEY_END,ptE);
		m_pXDataMap->GetAt(KEY_H,dH);
		m_pXDataMap->GetAt(KEY_B,dB);
		m_pXDataMap->GetAt(KEY_TYPE,strTemp);
		
		dL = ptS.distanceTo(ptE) ;

		mapLable2Tip.SetAt(_T("对象类型"), GetCurrentTypeName());
		mapLable2Tip.SetAt(_T("型号"), strTemp);

		strTemp.Format(_T("%d"),(int)ptS.z);
		mapLable2Tip.SetAt(_T("起点标高"), strTemp);

		strTemp.Format(_T("%d"),(int)ptE.z);
		mapLable2Tip.SetAt(_T("终点标高"), strTemp);

		strTemp.Format(_T("%d"),(int)dB);
		mapLable2Tip.SetAt(_T("宽度"), strTemp);

		strTemp.Format(_T("%d"),(int)dL);
		mapLable2Tip.SetAt(_T("长度"), strTemp);

		strTemp.Format(_T("%d"),(int)dH);
		mapLable2Tip.SetAt(_T("高度"), strTemp);
	}
}

//获取三维的壳对象
int TEImpCabletry::GetXBaseShell(TXShell& xShell)
{
	if (m_pXDataMap == NULL) return 0;
	
	double dW = 0.0;
	double dH = 0.0;
	double dEl = 0.0;
	double dHeight = 100.0;
	AcGeVector3d vtNorm;
	AcGePoint3d ptSta,ptEnd;
	int nCable = 0;
	
	m_pXDataMap->GetAt(KEY_B,dW);
	m_pXDataMap->GetAt(KEY_H,dH);
	m_pXDataMap->GetAt(KEY_EL,dEl);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNorm);
	m_pXDataMap->GetAt(KEY_START,ptSta);
	m_pXDataMap->GetAt(KEY_END,ptEnd);
	m_pXDataMap->GetAt(KEY_CABLE,nCable);
	vtNorm.normalize();

	if (nCable == TDb::eSilo)
	{
		//竖井不参与碰撞检查
		return 0;
	}
	
	AcGePoint3d ptGe[8];
	AcGeVector3d vtLine = ptEnd - ptSta;
	AcGeVector3d vtVer = vtLine;
	vtVer.rotateBy(PI / 2.0,vtNorm);
	vtVer.normalize();
	
	ptGe[0] = ptSta + vtVer*dW/2;
	ptGe[1] = ptSta - vtVer*dW/2;
	ptGe[2] = ptEnd + vtVer*dW/2;
	ptGe[3] = ptEnd - vtVer*dW/2;
	
	ptGe[4] = ptGe[0] + vtNorm*dH;
	ptGe[5] = ptGe[1] + vtNorm*dH;
	ptGe[6] = ptGe[2] + vtNorm*dH;
	ptGe[7] = ptGe[3] + vtNorm*dH;

	xShell.AppendFace(new AcDbFace(ptGe[0],ptGe[1],ptGe[3],ptGe[2]));
	xShell.AppendFace(new AcDbFace(ptGe[4],ptGe[5],ptGe[7],ptGe[6]));
	xShell.AppendFace(new AcDbFace(ptGe[0],ptGe[1],ptGe[5],ptGe[4]));
	xShell.AppendFace(new AcDbFace(ptGe[5],ptGe[1],ptGe[3],ptGe[7]));
	xShell.AppendFace(new AcDbFace(ptGe[7],ptGe[3],ptGe[2],ptGe[6]));
	xShell.AppendFace(new AcDbFace(ptGe[0],ptGe[2],ptGe[6],ptGe[4]));

	return 1;
}

//获取体的范围方块
int TEImpCabletry::GetBodyBox(AcDbExtents& ext)
{
	if (m_pXDataMap == NULL) return 0;
	
	double dW = 0.0;
	double dH = 0.0;
	double dEl = 0.0;
	double dHeight = 100.0;
	AcGeVector3d vtNorm;
	AcGePoint3d ptSta,ptEnd;
	
	m_pXDataMap->GetAt(KEY_B,dW);
	m_pXDataMap->GetAt(KEY_H,dH);
	m_pXDataMap->GetAt(KEY_EL,dEl);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNorm);
	m_pXDataMap->GetAt(KEY_START,ptSta);
	m_pXDataMap->GetAt(KEY_END,ptEnd);
	vtNorm.normalize();
	
	AcGePoint3d ptGe[8];
	AcGeVector3d vtLine = ptEnd - ptSta;
	AcGeVector3d vtVer = vtLine;
	vtVer.rotateBy(PI / 2.0,vtNorm);
	vtVer.normalize();

	ptGe[0] = ptSta + vtVer*dW/2;
	ptGe[1] = ptSta - vtVer*dW/2;
	ptGe[2] = ptEnd + vtVer*dW/2;
	ptGe[3] = ptEnd - vtVer*dW/2;

	ptGe[4] = ptGe[0] + vtNorm*dH;
	ptGe[5] = ptGe[1] + vtNorm*dH;
	ptGe[6] = ptGe[2] + vtNorm*dH;
	ptGe[7] = ptGe[3] + vtNorm*dH;

	double dMaxX = ptGe[0].x;
	double dMaxY = ptGe[0].y;
	double dMaxZ = ptGe[0].z;
	double dMinX = dMaxX;
	double dMinY = dMaxY;
	double dMinZ = dMaxZ;

	for (int i = 0; i < 8; ++i)
	{
		if (dMaxX < ptGe[i].x)
			dMaxX = ptGe[i].x;

		if (dMaxY < ptGe[i].y)
			dMaxY = ptGe[i].y;

		if (dMaxZ < ptGe[i].z)
			dMaxZ = ptGe[i].z;

		if (dMinX > ptGe[i].x)
			dMinX = ptGe[i].x;

		if (dMinY > ptGe[i].y)
			dMinY = ptGe[i].y;

		if (dMinZ > ptGe[i].z)
			dMinZ = ptGe[i].z;
	}

	AcGePoint3d ptMax(dMaxX,dMaxY,dMaxZ);
	AcGePoint3d ptMin(dMinX,dMinY,dMinZ);

	ext.set(ptMin,ptMax);

	return 1;
}

// 盘式桥架
Acad::ErrorStatus TEImpCabletry::ExplodeOrDraw3dOfP(XExplodeDraw &mode) const
{
	return ExplodeOrDraw3dOfC(mode);
}

// 槽式桥架
Acad::ErrorStatus TEImpCabletry::ExplodeOrDraw3dOfC(XExplodeDraw &mode) const
{
	int nCable = 0;
	m_pXDataMap->GetAt(KEY_CABLE,nCable);
	if (nCable == TDb::eArcCabletray)
	{
		return ExplodeOrDrawArc3dOfC(mode);
	}

	double dW = 0.0;
	double dH = 0.0;
	double dEl = 0.0;
	double dHeight = 100.0;
	AcGeVector3d vtNorm;
	AcGePoint3d ptSta,ptEnd;
	int nCover = 1;

	m_pXDataMap->GetAt(KEY_B,dW);
	m_pXDataMap->GetAt(KEY_H,dH);
	m_pXDataMap->GetAt(KEY_EL,dEl);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNorm);
	m_pXDataMap->GetAt(KEY_START,ptSta);
	m_pXDataMap->GetAt(KEY_END,ptEnd);
	m_pXDataMap->GetAt(KEY_COVER,nCover);
	vtNorm.normalize();

	AcGePoint3d *pVerList = NULL;
	AcGeVector3d vtLine = ptEnd - ptSta;
	AcGeVector3d vtVer = vtLine;
	vtVer.rotateBy(PI / 2.0,vtNorm);
	vtVer.normalize();

	int nRow = 0;
	int nCol = 0;
	if (nCover)
	{
		nRow = 5;
		nCol = 2;
		pVerList = new AcGePoint3d[nRow*nCol];
		pVerList[2] = ptSta + dW / 2.0 * vtVer;
		pVerList[3] = ptEnd + dW / 2.0 * vtVer;
		pVerList[4] = ptSta - dW / 2.0 * vtVer;
		pVerList[5] = ptEnd - dW / 2.0 * vtVer;

		pVerList[0] = pVerList[2];
		pVerList[0] += dH*vtNorm;
		pVerList[1] = pVerList[3];
		pVerList[1] += dH*vtNorm;
		pVerList[6] = pVerList[4];
		pVerList[6] += dH*vtNorm;
		pVerList[7] = pVerList[5];
		pVerList[7] += dH*vtNorm;
		pVerList[8] = pVerList[0];
		pVerList[9] = pVerList[1];
	}
	else
	{
		nRow = 4;
		nCol = 2;
		pVerList = new AcGePoint3d[nRow*nCol];
		pVerList[2] = ptSta + dW / 2.0 * vtVer;
		pVerList[3] = ptEnd + dW / 2.0 * vtVer;
		pVerList[4] = ptSta - dW / 2.0 * vtVer;
		pVerList[5] = ptEnd - dW / 2.0 * vtVer;
		pVerList[0] = pVerList[2];
		pVerList[0] += dH*vtNorm;
		pVerList[1] = pVerList[3];
		pVerList[1] += dH*vtNorm;
		pVerList[6] = pVerList[4];
		pVerList[6] += dH*vtNorm;
		pVerList[7] = pVerList[5];
		pVerList[7] += dH*vtNorm;	
	}

	Adesk::UInt16 nOldColor = mode.GetColor();

	if (pVerList != NULL)
	{		
		Adesk::UInt16 curColor = m_pOwnerEnt->colorIndex();
		mode.SetColor(curColor);
		
		mode.DrawMesh(nRow, nCol, pVerList, NULL);
	
		delete []pVerList;
	}

	int nClpBoard = -1,nHaveClap = -1;
	m_pXDataMap->GetAt(KEY_HAVE_CLAPBOARD, nHaveClap);
	m_pXDataMap->GetAt(KEY_SHOW_CLAPBOARD, nClpBoard);
	if (nClpBoard == TDb::eShowBoard &&
		nHaveClap == TDb::eBoard )
	{
		AcGeVector3d vtMainBoard;
		if (m_pXDataMap->GetAt(KEY_CLAPBOARD_MAINBR,vtMainBoard))
		{
			vtMainBoard.normalize();
			
			TSupportFunc spFun;
			AcGeDoubleArray arDime;
			spFun.GetClapboardDimension(m_pXDataMap, arDime);
			
			double dOffset = 0.0;
			for (int i = 0;i < arDime.length();++i)
			{
				dOffset = arDime[i];
				pVerList = new AcGePoint3d[4];
				
				pVerList[0] = ptSta - vtMainBoard * (dW/2-dOffset);
				pVerList[1] = pVerList[0] + vtNorm * dH;
				pVerList[2] = ptEnd - vtMainBoard * (dW/2-dOffset);
				pVerList[3] = pVerList[2] + vtNorm * dH;
				
				mode.DrawMesh(2, 2, pVerList, NULL);
				
				delete []pVerList;
			}
		}
	}

	mode.SetColor(nOldColor);

	return Acad::eOk;
}


//槽式弧形桥架
Acad::ErrorStatus TEImpCabletry::ExplodeOrDrawArc3dOfC(XExplodeDraw &mode) const
{
	double dW = 0.0;
	double dH = 0.0;
	double dEl = 0.0;
	double dHeight = 100.0;
	AcGeVector3d vtNorm;
	AcGePoint3d ptSta,ptEnd,ptMid;
	int nCover = 1;

	m_pXDataMap->GetAt(KEY_B,dW);
	m_pXDataMap->GetAt(KEY_H,dH);
	m_pXDataMap->GetAt(KEY_EL,dEl);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNorm);
	m_pXDataMap->GetAt(KEY_START,ptSta);
	m_pXDataMap->GetAt(KEY_END,ptEnd);
	m_pXDataMap->GetAt(KEY_MID,ptMid);
	m_pXDataMap->GetAt(KEY_COVER,nCover);
	vtNorm.normalize();

	AcGeCircArc3d arc(ptSta,ptMid,ptEnd);
	double dStartParm = arc.paramOf(ptSta);
	double dEndParm = arc.paramOf(ptEnd);
	double dLength = arc.length(dStartParm,dEndParm);

	double dAngle = arc.endAng() - arc.startAng();
	double dSAngle = (10.0 / 360.0) * PI;
	int nSect = 1;
	nSect = (int)ceil(dAngle / dSAngle);
	double dSectL = dLength / nSect;
	AcGePoint3d ptSectS,ptSectE,ptCenter;
	ptSectS = ptSta;
	ptCenter = arc.center();

	int nClpBoard = -1,nHaveClap = -1;
	m_pXDataMap->GetAt(KEY_HAVE_CLAPBOARD, nHaveClap);
	m_pXDataMap->GetAt(KEY_SHOW_CLAPBOARD, nClpBoard);
	AcGeVector3d vtMainBoard,vtS,vtE,vtM;
	vtM = ptMid - ptCenter;
	AcGePoint3d pVerList[4];
	for (int i = 1;i <= nSect;++i)
	{
		ptSectE = arc.evalPoint(arc.paramAtLength(dStartParm,i * dSectL));
		DrawArcSect(mode,ptSectS,ptSectE,ptCenter,vtNorm,dW,dH,nCover);

		//隔板
		if (nClpBoard == TDb::eShowBoard &&	nHaveClap == TDb::eBoard )
		{
			if (m_pXDataMap->GetAt(KEY_CLAPBOARD_MAINBR,vtMainBoard))
			{
				vtMainBoard.normalize();
				TSupportFunc spFun;
				AcGeDoubleArray arDime;
				spFun.GetClapboardDimension(m_pXDataMap, arDime);

				vtS = ptSectS - ptCenter;
				vtE = ptSectE - ptCenter;
				vtS.normalize();
				vtE.normalize();

				double dOffset = 0.0;
				for (int i = 0;i < arDime.length();++i)
				{
					dOffset = arDime[i];
					if (!vtM.isCodirectionalTo(vtMainBoard))
					{
						pVerList[0] = ptSectS + vtS * (dW/2-dOffset);
						pVerList[2] = ptSectE + vtE * (dW/2-dOffset);
					}
					else
					{
						pVerList[0] = ptSectS - vtS * (dW/2-dOffset);
						pVerList[2] = ptSectE - vtE * (dW/2-dOffset);
					}
					pVerList[1] = pVerList[0] + vtNorm * dH;
					pVerList[3] = pVerList[2] + vtNorm * dH;

					mode.DrawMesh(2, 2, pVerList, NULL);
				}
			}
		}

		ptSectS = ptSectE;
	}
	
	return Acad::eOk;
}

//lsd 2013-11-1
//梯式弧形桥架
Acad::ErrorStatus TEImpCabletry::ExplodeOrDrawArc3dOfT(XExplodeDraw &mode) const
{
	double dDist = 400; //间距
	double dLadderWidth = 50; //梯宽
	double dSideWidth = 30;  //侧面宽 
	double dThick = 10;  //梯厚度

	double dW = 0.0;
	double dH = 0.0;
	AcGeVector3d vtNorm;
	AcGePoint3d ptSta,ptEnd,ptMid;

	double dEl = 0.0;
	double dHeight = 100.0;
	int nCover = 1;

	m_pXDataMap->GetAt(KEY_B,dW);
	m_pXDataMap->GetAt(KEY_H,dH);
	m_pXDataMap->GetAt(KEY_EL,dEl);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNorm);
	m_pXDataMap->GetAt(KEY_START,ptSta);
	m_pXDataMap->GetAt(KEY_END,ptEnd);
	m_pXDataMap->GetAt(KEY_MID,ptMid);
	m_pXDataMap->GetAt(KEY_COVER,nCover);
	vtNorm.normalize();

	AcGeCircArc3d arc(ptSta,ptMid,ptEnd);
	double dStartParm = arc.paramOf(ptSta);
	double dEndParm = arc.paramOf(ptEnd);
	double dLength = arc.length(dStartParm,dEndParm);

	double dAngle = arc.endAng() - arc.startAng();
	double dSAngle = (10.0 / 360.0) * PI;
	int nSect = 1;
	nSect = (int)ceil(dAngle / dSAngle);
	double dSectL = dLength / nSect;
	AcGePoint3d ptSectS,ptSectE,ptCenter;
	ptSectS = ptSta;
	ptCenter = arc.center();  

	int nClpBoard = -1,nHaveClap = -1;
	m_pXDataMap->GetAt(KEY_HAVE_CLAPBOARD, nHaveClap);
	m_pXDataMap->GetAt(KEY_SHOW_CLAPBOARD, nClpBoard);
	AcGeVector3d vtMainBoard,vtS,vtE,vtM;
	vtM = ptMid - ptCenter;
	AcGePoint3d pVerList[4];
	for (int i = 1;i <= nSect;++i)
	{
		ptSectE = arc.evalPoint(arc.paramAtLength(dStartParm,i * dSectL));
		
		DrawArcSectT(mode,ptSectS,ptSectE,ptCenter,vtNorm,dW,dH,nCover);

		ptSectS = ptSectE;
	}

	return Acad::eOk;
}


Acad::ErrorStatus TEImpCabletry::DrawArcSect(XExplodeDraw &mode,const AcGePoint3d& ptS,const AcGePoint3d& ptE,const AcGePoint3d& ptCenter,const AcGeVector3d& vtNor,double dW,double dH,BOOL bCover) const
{
	AcGeVector3d vtDir = ptE - ptS;
	vtDir.normalize();
	
	AcGeVector3d vtVerS = ptS - ptCenter;
	AcGeVector3d vtVerE = ptE - ptCenter;
	vtVerS.normalize();
	vtVerE.normalize();

	AcGePoint3d pVerLst[10];

	pVerLst[2] = ptS + vtVerS * dW * 0.5;
	pVerLst[0] = pVerLst[2] + vtNor * dH;
	pVerLst[3] = ptE + vtVerE * dW * 0.5;
	pVerLst[1] = pVerLst[3] + vtNor * dH;
	pVerLst[4] = ptS - vtVerS * dW * 0.5;
	pVerLst[5] = ptE - vtVerE * dW * 0.5;
	pVerLst[6] = pVerLst[4] + vtNor * dH;
	pVerLst[7] = pVerLst[5] + vtNor * dH;
	pVerLst[8] = pVerLst[0];
	pVerLst[9] = pVerLst[1];

	if (bCover)
	{
		mode.DrawMesh(5,2,pVerLst);
	}
	else
		mode.DrawMesh(4,2,pVerLst);
	
	return Acad::eOk;
}
// 梯式桥架
Acad::ErrorStatus TEImpCabletry::ExplodeOrDraw3dOfT(XExplodeDraw &mode) const
{
	//lsd 2013-11-1 增加对弧形桥架的处理
	int nCable = 0;
	m_pXDataMap->GetAt(KEY_CABLE,nCable);
	if (nCable == TDb::eArcCabletray)
	{
		return ExplodeOrDrawArc3dOfT(mode);
	}
	//end

	double dDist = 400; //间距
	double dLadderWidth = 50; //梯宽
	double dSideWidth = 30;  //侧面宽 
	double dThick = 10;  //梯厚度

	double dW = 0.0;
	double dH = 0.0;
	AcGeVector3d vtNorm;
	AcGePoint3d ptSta,ptEnd;
	
	m_pXDataMap->GetAt(KEY_B,dW);
	m_pXDataMap->GetAt(KEY_H,dH);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNorm);
	m_pXDataMap->GetAt(KEY_START,ptSta);
	m_pXDataMap->GetAt(KEY_END,ptEnd);
	vtNorm.normalize();
	
	AcGePoint3d *pVerList = NULL;
	AcGeVector3d vtLine = ptEnd - ptSta;
	AcGeVector3d vtVer = vtLine;
	vtVer.rotateBy(PI / 2.0,vtNorm);
	vtVer.normalize();
	
	int nRow = 2;
	int nCol = 2;

	std::vector<AcGePoint3d> ptVec(4);

	Adesk::UInt16 curColor = m_pOwnerEnt->colorIndex();
	mode.SetColor(curColor);

	ptVec[2] = ptSta + dW / 2.0 * vtVer;
	ptVec[3] = ptEnd + dW / 2.0 * vtVer;
	ptVec[0] = ptVec[2] + dH*vtNorm;
	ptVec[1] = ptVec[3] + dH*vtNorm;
	
	DrawCube(mode, vtVer, ptVec, dSideWidth);
	
	ptVec[0] = ptSta - dW / 2.0 * vtVer;
	ptVec[1] = ptEnd - dW / 2.0 * vtVer;
	ptVec[2] = ptVec[0] + dH*vtNorm;
	ptVec[3] = ptVec[1] + dH*vtNorm;

 	DrawCube(mode, -vtVer, ptVec, dSideWidth);

	double dLen = ptSta.distanceTo(ptEnd);
	vtLine.normalize();
	AcGePoint3d ptTemp = ptSta - dW / 2.0 * vtVer;

	for (double i = dDist; i <= dLen; i += dDist)
	{
		ptVec[2] = ptTemp + i * vtLine;
		ptVec[3] = ptVec[2] + vtVer * dW;
		ptVec[0] = ptVec[2] - vtLine * dLadderWidth;
		ptVec[1] = ptVec[3] - vtLine * dLadderWidth;
		
		DrawCube(mode, vtNorm, ptVec, dThick);
	}

	return Acad::eOk;
}

//lsd 2013-11-1
//画梯式桥架的弧形桥架段
Acad::ErrorStatus TEImpCabletry::DrawArcSectT(XExplodeDraw &mode,const AcGePoint3d& ptS,const AcGePoint3d& ptE,const AcGePoint3d& ptCenter,const AcGeVector3d& vtNor,double dW,double dH,BOOL bCover) const
{
	double dDist = 400; //间距
	double dLadderWidth = 50; //梯宽
	double dThick = 10;  //梯厚度

	AcGeVector3d vtLine = ptE - ptS;
	vtLine.normalize();

	double dSideWidth = 30.0;

	AcGeVector3d vtVerS = ptS - ptCenter;
	AcGeVector3d vtVerE = ptE - ptCenter;
	vtVerS.normalize();
	vtVerE.normalize();

	std::vector<AcGePoint3d> ptVec(4);

	Adesk::UInt16 curColor = m_pOwnerEnt->colorIndex();

	ptVec[2] = ptS + dW / 2.0 * vtVerS;
	ptVec[3] = ptE + dW / 2.0 * vtVerE;
	ptVec[0] = ptVec[2] + dH*vtNor;
	ptVec[1] = ptVec[3] + dH*vtNor;

	AcGeVector3d vtDir = vtLine;
	vtDir.rotateBy(PI/2,vtNor);
	if(vtDir.dotProduct(vtVerS) < 0)
		vtDir.rotateBy(PI,vtNor);//修正vtDir偏向弧圆心一边
	DrawCube(mode, vtDir, ptVec, dSideWidth);

	ptVec[2] = ptS - dW / 2.0 * vtVerS;
	ptVec[3] = ptE - dW / 2.0 * vtVerE;
	ptVec[0] = ptVec[2] + dH*vtNor;
	ptVec[1] = ptVec[3] + dH*vtNor;
	DrawCube(mode, -vtDir, ptVec, dSideWidth);

	double dLen = ptS.distanceTo(ptE);
	AcGePoint3d ptTemp = ptS + dW / 2.0 * vtDir;

	//若是间距比桥架片段还长，取总长一半加一点
	//在中段附近画横梯(梯宽不能比总长还大)
	if(dDist > dLen && dLadderWidth < dLen)
		dDist = dLen/2 + 10;
	for (double i = dDist; i <= dLen; i += dDist)
	{
		ptVec[2] = ptTemp + i * vtLine;
		ptVec[3] = ptVec[2] - vtDir * dW;
		ptVec[0] = ptVec[2] - vtLine * dLadderWidth;
		ptVec[1] = ptVec[3] - vtLine * dLadderWidth;

		DrawCube(mode, vtNor, ptVec, dThick);
	}

	return Acad::eOk;
}

void TEImpCabletry::DrawCube(XExplodeDraw &mode,const AcGeVector3d &vtDir, const std::vector<AcGePoint3d> &pVerList, double dThick) const
{
	if (pVerList.size() == 4)
	{
		AcGePoint3d *pVerList1 = new AcGePoint3d[10];
		
		int nRow = 0;
		int nCol = 0;
		
		if (pVerList1 != NULL)
		{
			nRow = 5;
			nCol = 2;
			pVerList1[0] = pVerList[0];
			pVerList1[1] = pVerList[1];
			pVerList1[2] = pVerList[2];
			pVerList1[3] = pVerList[3];
			
			pVerList1[4] = pVerList[2] + vtDir * dThick;
			pVerList1[5] = pVerList[3] + vtDir * dThick;
			pVerList1[6] = pVerList[0] + vtDir * dThick;
			pVerList1[7] = pVerList[1] + vtDir * dThick;
			
			pVerList1[8] = pVerList[0];
			pVerList1[9] = pVerList[1];
			
			mode.DrawMesh(nRow, nCol, pVerList1,NULL);
			
			AcGePoint3d *pVerList2 = new AcGePoint3d[4];
			if (pVerList2 != NULL)
			{
				nRow = 2;
				nCol = 2;

				pVerList2[0] = pVerList1[1];
				pVerList2[1] = pVerList1[3];
				pVerList2[2] = pVerList1[7];
				pVerList2[3] = pVerList1[5];
				
				mode.DrawMesh(nRow, nCol, pVerList2,NULL);
				
				pVerList2[0] = pVerList1[0];
				pVerList2[1] = pVerList1[2];
				pVerList2[2] = pVerList1[6];
				pVerList2[3] = pVerList1[4];
				
				mode.DrawMesh(nRow, nCol, pVerList2,NULL);
				
				delete []pVerList2;
				pVerList2 = NULL;
			}
			
			delete []pVerList1;
			pVerList1 = NULL;
		}
	}
}

Acad::ErrorStatus TEImpCabletry::intersectWith(const AcDbEntity* pEnt,
												AcDb::Intersect intType,
												const AcGePlane& projPlane,
												AcGePoint3dArray& points,
												INT_PTR thisGsMarker,
												INT_PTR otherGsMarker) const
{
	Acad::ErrorStatus es;

	AcDbLine line,lineUp,lineDown;
	//1. 中心求交
	line.setStartPoint(StartPoint());
	line.setEndPoint(EndPoint());
	
	//取上下边线
	AcGePoint3d ptTL, ptTR, ptBL, ptBR;		// 左上, 右上, 左下, 右下 add by wzh 2012/12/10
	double dWidth = 0.0;
	AcGeVector3d vtNor;
	m_pXDataMap->GetAt(KEY_B,dWidth);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNor);
	AcGeVector3d vtTemp = EndPoint() - StartPoint();
	vtTemp.rotateBy(PI/2,vtNor);
	vtTemp.normalize();

	ptTL = StartPoint() + vtTemp*dWidth/2;
	ptTR = EndPoint() + vtTemp*dWidth/2;
	lineUp.setStartPoint(ptTL);
	lineUp.setEndPoint(ptTR);

	ptBL = StartPoint() - vtTemp*dWidth/2;
	ptBR = EndPoint() - vtTemp*dWidth/2;
	lineDown.setStartPoint(ptBL);
	lineDown.setEndPoint(ptBR);

	TDbPipeBase* pPipe = TDbPipeBase::cast(pEnt);
	if (pPipe != NULL)
	{
		//支持弧形桥架
		int nCable1 = 0,nCable2 = 0;
		int nCount = 0;
		AcGePoint3d ptS,ptE,ptM1,ptM2;
		m_pXDataMap->GetAt(KEY_CABLE,nCable1);
		pPipe->GetSpecialtyData()->GetAt(KEY_CABLE,nCable2);
		m_pXDataMap->GetAt(KEY_MID,ptM1);
		pPipe->GetSpecialtyData()->GetAt(KEY_MID,ptM2);
		XPoint pt1,pt2;
		if (nCable2 == TDb::eArcCabletray && nCable2 != nCable1)
		{
			XLine line1(asDblArray(StartPoint()),asDblArray(EndPoint()));
			XArc arc2(pPipe->StartPoint(),ptM2,pPipe->EndPoint());
			
			nCount = arc2.Intersection(&line1,pt1,pt2);
		}
		else if (nCable1 == TDb::eArcCabletray && nCable2 != nCable1)
		{
			XArc arc1(StartPoint(),ptM1,EndPoint());
			XLine line2(asDblArray(pPipe->StartPoint()),asDblArray(pPipe->EndPoint()));

			nCount = arc1.Intersection(&line2,pt1,pt2);
		}
		else if (nCable1 == TDb::eArcCabletray && nCable2 == nCable1)
		{
			XArc arc1(StartPoint(),ptM1,EndPoint());
			XArc arc2(pPipe->StartPoint(),ptM2,pPipe->EndPoint());

			nCount = arc1.Intersection(&arc2,pt1,pt2);
		}
		else
		{
			AcDbLine line2(pPipe->StartPoint(),pPipe->EndPoint());
			es = line.intersectWith(&line2,intType,projPlane,points,thisGsMarker,otherGsMarker);
		}

		if (nCount > 0)
		{
			points.append(pt1.AsAcGePoint3d());
		}
		if (nCount > 1)
		{
			points.append(pt2.AsAcGePoint3d());
		}
	}
	else
	{
		//bsl 2011.1.5 支持参照CAD实体延伸(extend,trim..)
		//es = line.intersectWith(pEnt,intType,projPlane,points,thisGsMarker,otherGsMarker); // 2012/9/4 comment by wzh
		//es = TDbImpPipeBase::intersectWith(pEnt,intType,projPlane,points,thisGsMarker,otherGsMarker);
		
		// 2012/9/4 解开注释 by wzh
		AcDbCurve* pCurve = AcDbCurve::cast(pEnt);
		// change by hh 2011-05-12 判断条件错误
		// if (pEnt != NULL)
		if (pCurve != NULL)
		{
			AcGePoint3d ptS,ptE,ptM,pt1,pt2;
			pCurve->getStartPoint(ptS);
			pCurve->getEndPoint(ptE);
	
			// 2012/12/10 add by wzh
			AcDbLine line2(ptS, ptE); // 
			AcGePoint3d ptCross;
			BOOL bFlag = FALSE;
			AcGePoint3dArray arPt;
			line.intersectWith(&line2, AcDb::kExtendBoth, arPt);
			if (arPt.length())
			{
				ptCross = arPt[0];
				if (ptCross.x > ptBL.x && ptCross.x < ptBR.x
					&& ptCross.y > ptBL.y && ptCross.y < ptTL.y)
				{
					// 交点在桥架内
					bFlag = TRUE;	// 线 延伸至 桥架
				}
				else
					bFlag = FALSE;	// 桥架 延伸至 线
			}
			if (bFlag)
			{
				ptM = AcGePoint3d((ptS.x + ptE.x)/2,(ptS.y + ptE.y)/2,(ptS.z + ptE.z)/2);
				lineUp.getClosestPointTo(ptM,pt1);
				lineDown.getClosestPointTo(ptM,pt2);
				//取距离较近的边线
				if (pt1.distanceTo(ptM) < pt2.distanceTo(ptM))
				{
					line.copyFrom(&lineUp);
				}
				else
					line.copyFrom(&lineDown);
			}
			///////// 2012/12/10 add by wzh /////////
			

			// 2012/12/10 comment by wzh
// 			ptM = AcGePoint3d((ptS.x + ptE.x)/2,(ptS.y + ptE.y)/2,(ptS.z + ptE.z)/2);
// 			lineUp.getClosestPointTo(ptM,pt1);
// 			lineDown.getClosestPointTo(ptM,pt2);
// 			//取距离较近的边线
// 			if (pt1.distanceTo(ptM) < pt2.distanceTo(ptM))
// 			{
// 				line.copyFrom(&lineUp);
// 			}
// 			else
// 				line.copyFrom(&lineDown);
			//// 2012/12/10 comment by wzh ////
		}
		es = line.intersectWith(pEnt,intType,projPlane,points,thisGsMarker,otherGsMarker);
		/////////////////// 2012/9/4 解开注释 by wzh
	}

	return es;
}

Acad::ErrorStatus TEImpCabletry::intersectWith(const AcDbEntity* pEnt,
												AcDb::Intersect intType,
												AcGePoint3dArray& points,
												INT_PTR thisGsMarker,
												INT_PTR otherGsMarker) const
{
	Acad::ErrorStatus es = Acad::eOk;

	AcDbLine line,lineUp,lineDown;
	//1. 中心求交
	line.setStartPoint(StartPoint());
	line.setEndPoint(EndPoint());

	double dWidth = 0.0;
	AcGeVector3d vtNor;
	m_pXDataMap->GetAt(KEY_B,dWidth);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNor);

	AcGeVector3d vtTemp = EndPoint() - StartPoint();
	vtTemp.rotateBy(PI/2,vtNor);
	vtTemp.normalize();
	
	lineUp.setStartPoint(StartPoint() + vtTemp*dWidth/2);
	lineUp.setEndPoint(EndPoint() + vtTemp*dWidth/2);

	lineDown.setStartPoint(StartPoint() - vtTemp*dWidth/2);
	lineDown.setEndPoint(EndPoint() - vtTemp*dWidth/2);

	TDbPipeBase* pPipe = TDbPipeBase::cast(pEnt);
	if (pPipe != NULL)
	{
// 		AcDbLine line2(pPipe->StartPoint(),pPipe->EndPoint());
// 		es = line.intersectWith(&line2,intType,points,thisGsMarker,otherGsMarker);

		//支持弧形桥架
		int nCable1 = 0,nCable2 = 0;
		int nCount = 0;
		AcGePoint3d ptS,ptE,ptM1,ptM2;
		m_pXDataMap->GetAt(KEY_CABLE,nCable1);
		pPipe->GetSpecialtyData()->GetAt(KEY_CABLE,nCable2);
		m_pXDataMap->GetAt(KEY_MID,ptM1);
		pPipe->GetSpecialtyData()->GetAt(KEY_MID,ptM2);
		XPoint pt1,pt2;
		if (nCable2 == TDb::eArcCabletray && nCable2 != nCable1)
		{
			XLine line1(asDblArray(StartPoint()),asDblArray(EndPoint()));
			XArc arc2(pPipe->StartPoint(),ptM2,pPipe->EndPoint());

			nCount = arc2.Intersection(&line1,pt1,pt2);
		}
		else if (nCable1 == TDb::eArcCabletray && nCable2 != nCable1)
		{
			XArc arc1(StartPoint(),ptM1,EndPoint());
			XLine line2(asDblArray(pPipe->StartPoint()),asDblArray(pPipe->EndPoint()));

			nCount = arc1.Intersection(&line2,pt1,pt2);
		}
		else if (nCable1 == TDb::eArcCabletray && nCable2 == nCable1)
		{
			XArc arc1(StartPoint(),ptM1,EndPoint());
			XArc arc2(pPipe->StartPoint(),ptM2,pPipe->EndPoint());

			nCount = arc1.Intersection(&arc2,pt1,pt2);
		}
		else
		{
			AcDbLine line2(pPipe->StartPoint(),pPipe->EndPoint());
			es = line.intersectWith(&line2,intType,points,thisGsMarker,otherGsMarker);
		}

		if (nCount > 0)
		{
			points.append(pt1.AsAcGePoint3d());
		}
		if (nCount > 1)
		{
			points.append(pt2.AsAcGePoint3d());
		}
	}
	else
	{
		AcDbCurve* pCurve = AcDbCurve::cast(pEnt);
		// change by hh 2011-05-12 判断条件错误
		// if (pEnt != NULL)
		if (pCurve != NULL)
		{
			AcGePoint3d ptS,ptE,ptM,pt1,pt2;
			pCurve->getStartPoint(ptS);
			pCurve->getEndPoint(ptE);

			ptM = AcGePoint3d((ptS.x + ptE.x)/2,(ptS.y + ptE.y)/2,(ptS.z + ptE.z)/2);
			lineUp.getClosestPointTo(ptM,pt1);
			lineDown.getClosestPointTo(ptM,pt2);
			//取距离较近的边线
			if (pt1.distanceTo(ptM) < pt2.distanceTo(ptM))
			{
				line.copyFrom(&lineUp);
			}
			else
				line.copyFrom(&lineDown);

		}
		else
			es = line.intersectWith(pEnt,intType,points,thisGsMarker,otherGsMarker);
	}

	return es;
}

void TEImpCabletry::ModyfyClapVector(const AcGeVector3d& vtOld,const AcGeVector3d& vtNew)
{
	if (m_pXDataMap != NULL)
	{
		AcGeVector3d vtNor,vtClap;
		m_pXDataMap->GetAt(KEY_NORMAL,vtNor);
		m_pXDataMap->GetAt(KEY_CLAPBOARD_MAINBR,vtClap);

		// 计算偏移角度
		double dAng = vtOld.angleTo(vtNew);

		// 计算偏移方向
		AcGeVector3d vtTmp = vtNew;
		vtTmp.rotateBy(dAng, vtNor);
		if (vtTmp.isCodirectionalTo(vtOld))
		{
			vtClap.rotateBy(-dAng,vtNor);
			m_pXDataMap->SetAt(KEY_CLAPBOARD_MAINBR,vtClap);
		}
		else
		{
			vtClap.rotateBy(dAng,vtNor);
			m_pXDataMap->SetAt(KEY_CLAPBOARD_MAINBR,vtClap);
		}
	}
}

CString TEImpCabletry::GetXml() const
{
	if (m_pXDataMap == NULL || m_pOwnerEnt == NULL)
	{
		return _T("");
	}

	int nValue(0);
	double dValue(0.0);
	int nSizePreci(3), nPtPreci(6);	// 尺寸、位置精度

	TXmlTree xmlTree;
	CString csText;
	AcGePoint3d pt;
	AcGePoint3dArray arPts;
	AcGeVector3d vtDir;
	CString csX, csY, csZ;

	POSITION posRoot = xmlTree.Insert(_T("ATS_CABLETRY"), NULL, NULL);
	{
		xmlTree.SetAttribute(posRoot, _T("name"), _T("桥架"));
		xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
	}
	POSITION nowPos = xmlTree.Insert(KEY_STYLE,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("类型"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("0:槽式,1:盘式,2:梯式"));
		m_pXDataMap->GetAt(KEY_STYLE,nValue);
		csText.Format(_T("%d"),nValue);
		xmlTree.SetItemText(nowPos,csText);
	}

	nowPos = xmlTree.Insert(KEY_START,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("起点"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("起点"));
		m_pXDataMap->GetAt(KEY_START,pt);
		TAuxTools::DoubleToString(pt.x,nPtPreci,csX);
		TAuxTools::DoubleToString(pt.y,nPtPreci,csY);
		TAuxTools::DoubleToString(pt.z,nPtPreci,csZ);
		csText.Format(_T("%s,%s,%s"),csX,csY,csZ);
		xmlTree.SetItemText(nowPos,csText);
	}

	nowPos = xmlTree.Insert(KEY_END,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("终点"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("终点"));
		m_pXDataMap->GetAt(KEY_END,pt);
		TAuxTools::DoubleToString(pt.x,nPtPreci,csX);
		TAuxTools::DoubleToString(pt.y,nPtPreci,csY);
		TAuxTools::DoubleToString(pt.z,nPtPreci,csZ);
		csText.Format(_T("%s,%s,%s"),csX,csY,csZ);
		xmlTree.SetItemText(nowPos,csText);
	}

	nowPos = xmlTree.Insert(KEY_B,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("宽度"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("宽度"));
		m_pXDataMap->GetAt(KEY_B,dValue);
		TAuxTools::DoubleToString(dValue,nSizePreci,csText);
		xmlTree.SetItemText(nowPos,csText);
	}
	nowPos = xmlTree.Insert(KEY_H,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("高度"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("高度"));
		m_pXDataMap->GetAt(KEY_H,dValue);
		TAuxTools::DoubleToString(dValue,nSizePreci,csText);
		xmlTree.SetItemText(nowPos,csText);
	}
	nowPos = xmlTree.Insert(KEY_EL,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("标高"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("标高"));
		m_pXDataMap->GetAt(KEY_EL,dValue);
		TAuxTools::DoubleToString(dValue,nSizePreci,csText);
		xmlTree.SetItemText(nowPos,csText);
	}

	nowPos = xmlTree.Insert(KEY_NORMAL,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("法相量"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("法相量"));
		m_pXDataMap->GetAt(KEY_NORMAL,vtDir);
		TAuxTools::DoubleToString(vtDir.x,nPtPreci,csX);
		TAuxTools::DoubleToString(vtDir.y,nPtPreci,csY);
		TAuxTools::DoubleToString(vtDir.z,nPtPreci,csZ);
		csText.Format(_T("%s,%s,%s"),csX,csY,csZ);
		xmlTree.SetItemText(nowPos,csText);
	}

	nowPos = xmlTree.Insert(KEY_HAVE_CLAPBOARD,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("有无隔板"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("0:无,1:有"));
		m_pXDataMap->GetAt(KEY_HAVE_CLAPBOARD,nValue);
		csText.Format(_T("%d"),nValue);
		xmlTree.SetItemText(nowPos,csText);
	}
	nowPos = xmlTree.Insert(KEY_SHOW_CLAPBOARD,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("隔板"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("0:不显示,1:显示"));
		m_pXDataMap->GetAt(KEY_SHOW_CLAPBOARD,nValue);
		csText.Format(_T("%d"),nValue);
		xmlTree.SetItemText(nowPos,csText);
	}
	nowPos = xmlTree.Insert(KEY_CLAPBOARD_MAINBR,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("隔板主向量"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("隔板主向量"));
		m_pXDataMap->GetAt(KEY_CLAPBOARD_MAINBR,vtDir);
		TAuxTools::DoubleToString(vtDir.x,nPtPreci,csX);
		TAuxTools::DoubleToString(vtDir.y,nPtPreci,csY);
		TAuxTools::DoubleToString(vtDir.z,nPtPreci,csZ);
		csText.Format(_T("%s,%s,%s"),csX,csY,csZ);
		xmlTree.SetItemText(nowPos,csText);
	}

	nowPos = xmlTree.Insert(KEY_CLAPBOARD_DATA,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("隔板数据"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("隔板尺寸*通道码;隔板尺寸*通道码;"));
		m_pXDataMap->GetAt(KEY_CLAPBOARD_DATA,csText);
		xmlTree.SetItemText(nowPos,csText);
	}

	nowPos = xmlTree.Insert(KEY_COVER,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("盖板"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("0:不显示,1:显示"));
		m_pXDataMap->GetAt(KEY_COVER,nValue);
		csText.Format(_T("%d"),nValue);
		xmlTree.SetItemText(nowPos,csText);
	}

	nowPos = xmlTree.Insert(_T("Object_ID"),posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos,_T("name"),_T("ID"));
		xmlTree.SetAttribute(nowPos,_T("comment"),_T("桥架ID"));
		LONG_PTR nid = m_pOwnerEnt->objectId().asOldId();
		
		csText.Format(_T("%ld"),nid);
		xmlTree.SetItemText(nowPos,csText);
	}
	// add by sps 2013.4.23 增加导出已敷设电缆
	CStringArray arXData;
	struct resbuf* pRb = NULL;
	pRb = m_pOwnerEnt->xData(_T("CableLay_XData_Name"));

	struct resbuf* pTemp = NULL;
	if (pRb != NULL)
		for (pTemp = pRb->rbnext; pTemp != NULL; pTemp = pTemp->rbnext)
			if (pTemp->restype == AcDb::kDxfXdAsciiString)
				arXData.Add(pTemp->resval.rstring);
	acutRelRb(pRb);

	int nLaySize = arXData.GetSize();
	POSITION posTemp;
	int i = 0;
	if (nLaySize > 0)
	{
		nowPos = xmlTree.Insert(_T("CableLay"),posRoot,NULL);
		xmlTree.SetAttribute(nowPos, _T("name"), _T("敷设电缆"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("已敷设电缆"));

		for(; i < nLaySize; i++)
		{
			csText.Format(_T("CableNo_%d"), i + 1);
			posTemp = xmlTree.Insert(csText, nowPos, NULL);
			csText.Format(_T("电缆编号_%d"), i + 1);
			xmlTree.SetAttribute(posTemp, _T("name"), csText);
			xmlTree.SetItemText(posTemp, arXData.GetAt(i));
		}
	}

	CString csXml = xmlTree.GetXml();

	return csXml;
}

CString TEImpCabletry::GetXml(const AcGeMatrix3d& mat) const
{
	if (m_pXDataMap == NULL || m_pOwnerEnt == NULL)
	{
		return _T("");
	}

	int nValue(0);
	double dValue(0.0);
	int nSizePreci(3), nPtPreci(6);	// 尺寸、位置精度

	TXmlTree xmlTree;
	CString csText;
	AcGePoint3d pt;
	AcGePoint3dArray arPts;
	AcGeVector3d vtDir;
	CString csX, csY, csZ;

	POSITION posRoot = xmlTree.Insert(_T("ATS_CABLETRY"), NULL, NULL);
	{
		xmlTree.SetAttribute(posRoot, _T("name"), _T("桥架"));
		xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
	}
	POSITION nowPos = xmlTree.Insert(KEY_STYLE,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("类型"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("0:槽式,1:盘式,2:梯式"));
		m_pXDataMap->GetAt(KEY_STYLE,nValue);
		csText.Format(_T("%d"),nValue);
		xmlTree.SetItemText(nowPos,csText);
	}

	nowPos = xmlTree.Insert(KEY_START,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("起点"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("起点"));
		m_pXDataMap->GetAt(KEY_START,pt);
		pt.transformBy(mat);
		TAuxTools::DoubleToString(pt.x,nPtPreci,csX);
		TAuxTools::DoubleToString(pt.y,nPtPreci,csY);
		TAuxTools::DoubleToString(pt.z,nPtPreci,csZ);
		csText.Format(_T("%s,%s,%s"),csX,csY,csZ);
		xmlTree.SetItemText(nowPos,csText);
	}

	nowPos = xmlTree.Insert(KEY_END,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("终点"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("终点"));
		m_pXDataMap->GetAt(KEY_END,pt);
		pt.transformBy(mat);
		TAuxTools::DoubleToString(pt.x,nPtPreci,csX);
		TAuxTools::DoubleToString(pt.y,nPtPreci,csY);
		TAuxTools::DoubleToString(pt.z,nPtPreci,csZ);
		csText.Format(_T("%s,%s,%s"),csX,csY,csZ);
		xmlTree.SetItemText(nowPos,csText);
	}

	nowPos = xmlTree.Insert(KEY_B,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("宽度"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("宽度"));
		m_pXDataMap->GetAt(KEY_B,dValue);
		TAuxTools::DoubleToString(dValue,nSizePreci,csText);
		xmlTree.SetItemText(nowPos,csText);
	}
	nowPos = xmlTree.Insert(KEY_H,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("高度"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("高度"));
		m_pXDataMap->GetAt(KEY_H,dValue);
		TAuxTools::DoubleToString(dValue,nSizePreci,csText);
		xmlTree.SetItemText(nowPos,csText);
	}
	nowPos = xmlTree.Insert(KEY_EL,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("标高"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("标高"));
		m_pXDataMap->GetAt(KEY_EL,dValue);
		TAuxTools::DoubleToString(dValue,nSizePreci,csText);
		xmlTree.SetItemText(nowPos,csText);
	}

	nowPos = xmlTree.Insert(KEY_NORMAL,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("法相量"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("法相量"));
		m_pXDataMap->GetAt(KEY_NORMAL,vtDir);
		vtDir.transformBy(mat);
		TAuxTools::DoubleToString(vtDir.x,nPtPreci,csX);
		TAuxTools::DoubleToString(vtDir.y,nPtPreci,csY);
		TAuxTools::DoubleToString(vtDir.z,nPtPreci,csZ);
		csText.Format(_T("%s,%s,%s"),csX,csY,csZ);
		xmlTree.SetItemText(nowPos,csText);
	}

	nowPos = xmlTree.Insert(KEY_HAVE_CLAPBOARD,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("有无隔板"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("0:无,1:有"));
		m_pXDataMap->GetAt(KEY_HAVE_CLAPBOARD,nValue);
		csText.Format(_T("%d"),nValue);
		xmlTree.SetItemText(nowPos,csText);
	}
	nowPos = xmlTree.Insert(KEY_SHOW_CLAPBOARD,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("隔板"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("0:不显示,1:显示"));
		m_pXDataMap->GetAt(KEY_SHOW_CLAPBOARD,nValue);
		csText.Format(_T("%d"),nValue);
		xmlTree.SetItemText(nowPos,csText);
	}
	nowPos = xmlTree.Insert(KEY_CLAPBOARD_MAINBR,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("隔板主向量"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("隔板主向量"));
		m_pXDataMap->GetAt(KEY_CLAPBOARD_MAINBR,vtDir);
		vtDir.transformBy(mat);
		TAuxTools::DoubleToString(vtDir.x,nPtPreci,csX);
		TAuxTools::DoubleToString(vtDir.y,nPtPreci,csY);
		TAuxTools::DoubleToString(vtDir.z,nPtPreci,csZ);
		csText.Format(_T("%s,%s,%s"),csX,csY,csZ);
		xmlTree.SetItemText(nowPos,csText);
	}
	//add by axc 增加隔板数据
	nowPos = xmlTree.Insert(KEY_CLAPBOARD_DATA,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("隔板数据"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("隔板尺寸*通道码;隔板尺寸*通道码;"));
		m_pXDataMap->GetAt(KEY_CLAPBOARD_DATA,csText);
		xmlTree.SetItemText(nowPos,csText);
	}
	//add end

	nowPos = xmlTree.Insert(KEY_COVER,posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos, _T("name"), _T("盖板"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("0:不显示,1:显示"));
		m_pXDataMap->GetAt(KEY_COVER,nValue);
		csText.Format(_T("%d"),nValue);
		xmlTree.SetItemText(nowPos,csText);
	}

	nowPos = xmlTree.Insert(_T("Object_ID"),posRoot,NULL);
	{
		xmlTree.SetAttribute(nowPos,_T("name"),_T("ID"));
		xmlTree.SetAttribute(nowPos,_T("comment"),_T("桥架ID"));
		LONG_PTR nid = m_pOwnerEnt->objectId().asOldId();

		csText.Format(_T("%ld"),nid);
		xmlTree.SetItemText(nowPos,csText);
	}

	// add by sps 2013.4.23 增加导出已敷设电缆
	CStringArray arXData;
	struct resbuf* pRb = NULL;
	pRb = m_pOwnerEnt->xData(_T("CableLay_XData_Name"));
	struct resbuf* pTemp = NULL;
	if (pRb != NULL)
		for (pTemp = pRb->rbnext; pTemp != NULL; pTemp = pTemp->rbnext)
			if (pTemp->restype == AcDb::kDxfXdAsciiString)
				arXData.Add(pTemp->resval.rstring);
	acutRelRb(pRb);
	
	int nLaySize = arXData.GetSize();
	POSITION posTemp;
	int i = 0;
	if (nLaySize > 0)
	{
		nowPos = xmlTree.Insert(_T("CableLay"),posRoot,NULL);
		xmlTree.SetAttribute(nowPos, _T("name"), _T("敷设电缆"));
		xmlTree.SetAttribute(nowPos, _T("comment"), _T("已敷设电缆"));

		for(; i < nLaySize; i++)
		{
			csText.Format(_T("CableNo_%d"), i + 1);
			posTemp = xmlTree.Insert(csText, nowPos, NULL);
			csText.Format(_T("电缆编号_%d"), i + 1);
			xmlTree.SetAttribute(posTemp, _T("name"), csText);
			xmlTree.SetItemText(posTemp, arXData.GetAt(i));
		}
	}

	CString csXml = xmlTree.GetXml();

	return csXml;
}

void TEImpCabletry::GetCirCenter(std::vector<double> &vecRadius,std::vector<AcGePoint3d> &vecCenter,double &dCableWidth) const
{
	double dW = 0.0;
	double dH = 0.0;
	AcGePoint3d ptStart,ptEnd;
	AcGeVector3d vt,vector;

	vector = vector.normalize();

	m_pXDataMap->GetAt(KEY_B,dW);
	m_pXDataMap->GetAt(KEY_H,dH);

	//3.获得起始点和终止点
	getStartPoint(ptStart);
	getEndPoint(ptEnd);

	vector = ptEnd - ptStart;
	//旋转
	vt = vector.rotateBy(PI/2,normal());
	vt = vt.normalize();
	vt *= dW/2;

	AcGePoint3d ptLUp,ptRBottom,ptLow,ptUp;
	ptRBottom = ptEnd + vt;

	vt = vector.rotateBy(PI,normal());
	vt = vt.normalize();
	vt *= dW/2;

	ptLow = ptEnd + vt;

	ptUp.x = ptRBottom.x;
	ptUp.y = ptRBottom.y;
	ptUp.z = ptRBottom.z + dH;
	
	ptLUp.x = ptLow.x;
	ptLUp.y = ptLow.y;
	ptLUp.z = ptLow.z + dH;
	
	//判断桥架类型,如果是梯式桥架,则应加上梯厚底10
	int nStyle;
	m_pXDataMap->GetAt(KEY_STYLE,nStyle);
	if (2 == nStyle)
	{
		ptLow.z += 10;
		ptRBottom.z += 10;
		ptEnd.z += 10;
	}

	std::vector<double>::iterator iteRadius = vecRadius.begin();
	
	AcGeVector3d vcTemp = ptEnd - ptLow;
	AcGePoint3d ptCenter = ptLow;

	for (; iteRadius != vecRadius.end(); ++iteRadius)
	{	
		vcTemp = vcTemp.normalize(); 
		ptCenter = ptCenter + vcTemp * (*iteRadius + dCableWidth);
		ptCenter.z = ptCenter.z + *iteRadius;

		vecCenter.push_back(ptCenter);
		
		vcTemp = vcTemp.normalize();
		ptCenter = ptCenter + vcTemp * (*iteRadius);
		ptCenter.z = ptLow.z;

	}	
}

void TEImpCabletry::FittingCircle(std::vector<AcGePoint3d> &vecpt3d,double &dRadius
								  ,AcGePoint3d &ptCenter) const//拟合圆函数
{
	AcGePoint3d ptStart,ptEnd;
	getStartPoint(ptStart);
	getEndPoint(ptEnd);

	AcGeVector3d vcNormal = ptEnd - ptStart;
	AcGeVector3d vcRadius = vcNormal.perpVector();
	vcRadius = vcRadius.normalize() * dRadius;

	int iIndex = 32;
	AcGePoint3d ptCirStart,ptCirEnd;
	while (iIndex)
	{
		ptCirStart = ptCenter + vcRadius;
		vecpt3d.push_back(ptCirStart);

		vcRadius.rotateBy(PI/16,vcNormal);

		ptCirEnd = ptCenter + vcRadius;
		vecpt3d.push_back(ptCirEnd);

		iIndex--;
	}
}

bool TEImpCabletry::GetSection(const AcDbFace &face, const AcGeVector3d &vtPlaneSecDir, 
						std::vector<TObjSectionRecord> &sectionRecord, AcDbVoidPtrArray& arFillPtrs) const
{
	if (NULL == m_pOwnerEnt || NULL == m_pXDataMap)
		return false;

	// 基本参数	
	AcDbObjectId idObj = m_pOwnerEnt->objectId();
	AcDbObjectId idLayer = m_pOwnerEnt->layerId();
	TGGeSectionPlane section_pln(face, vtPlaneSecDir); // 构造一个辅助剖面
	AcDbVoidPtrArray arFaces;
	XExplodeStream dc(arFaces);
	ExplodeOrDraw3d(dc);	
	
	double dElevation = 0;
	AcDbEntity* pEnt = NULL;
	AcDbFace* pFace = NULL;

	// add by axc 2013.6.25 增加敷设电缆显示
	//获得电缆半径
	struct resbuf* pRb = NULL;
	pRb = m_pOwnerEnt->xData(_T("CableLay_XData_Name"));
	std::vector<double>vecRadius;
	struct resbuf* pTemp = NULL;
	int nCableNum = 0;
	double dCableLen = 0.0;
	double dW = 0.0,dPerCableWidth = 0.0;

	if (pRb != NULL)
	{
		CString strRel(_T(""));
		int iStartPos,iEndPos;
		for (pTemp = pRb->rbnext; pTemp != NULL; pTemp = pTemp->rbnext)
		{
			if (pTemp->restype == AcDb::kDxfXdAsciiString)
			{
				strRel = pTemp->resval.rstring;
				iStartPos = strRel.Find('[');
				iEndPos = strRel.Find(']');
				strRel = strRel.Mid(iStartPos+1,iEndPos-iStartPos-1);
				dCableLen += _ttof(strRel) * 2;
				vecRadius.push_back(_ttof(strRel));
				nCableNum++;
			}
		}
	}
	acutRelRb(pRb);
	//对半径进行排序
	std::sort(vecRadius.begin(), vecRadius.end(), std::greater<double>());
	
	std::vector<AcGePoint3d> vecCenter;

	m_pXDataMap->GetAt(KEY_B,dW);
	dPerCableWidth = (dW - dCableLen) / (nCableNum + 1);
	//获得电缆圆心
	GetCirCenter(vecRadius,vecCenter,dPerCableWidth);
	
	int nLen = arFaces.length();
	for(int i = 0; i < arFaces.length(); ++i)
	{
		pEnt = (AcDbEntity*)arFaces[i];
		if (NULL == pEnt)
			continue;		
		pFace = AcDbFace::cast(pEnt);
		if (pFace)
		{
			TGGeSectionPlane pln(*pFace, vtPlaneSecDir);
			TGGePoly2D poly;
			dElevation = SectionUtility::Projection_plane2plane(section_pln, pln, poly);
			
			if (poly.Length())
			{
				TObjSectionRecord obj(idObj, idLayer, TObjSectionRecord::eTCH_CABLETRY, dElevation, poly);
				sectionRecord.push_back(obj);
			}
								
		}		
		delete pEnt;
	}
	
	//将电缆圆心往剖切面投影
	AcGeLineSeg3d out_seg;
	AcGePoint3d ptTemp;
	TADSGePoint3d ptTADS;
	short sElevation;
	std::vector<AcGePoint3d>::iterator ite = vecCenter.begin();
	std::vector<double>::iterator iteRadius = vecRadius.begin();

	for (; ite != vecCenter.end(); ++ite)
	{
		AcGePoint3d ptStart,ptEnd;
		getStartPoint(ptStart);
		getEndPoint(ptEnd);
		AcGeVector3d vtTemp = ptStart - ptEnd;
		AcGeLineSeg3d in_seg((*ite),vtTemp);
		//投影
		sElevation = SectionUtility::Projection_line2plane(section_pln, in_seg, out_seg ,ptTemp);

		//判断是否垂直
		if (1 == sElevation)
		{
			//根据投影点进行拟合
 			std::vector<AcGePoint3d> vecpt3d;
			
			if (iteRadius != vecRadius.end())
			{
				FittingCircle(vecpt3d,*iteRadius,ptTemp);
				++iteRadius;
			}
 
 			std::vector<AcGePoint3d>::iterator itePt3d = vecpt3d.begin();
 			TGGePoly2D poly;

 			for (; itePt3d != vecpt3d.end(); ++itePt3d)
 			{
 				TADSGePoint3d ptPoly(*itePt3d);
 				poly.AppendNode(ptPoly);
 			}
 
 			if (poly.Length())
 			{
 				TObjSectionRecord objCircle(idObj, idLayer, TObjSectionRecord::eTCH_CABLETRY, sElevation, poly);
 				sectionRecord.push_back(objCircle);
 			}
		}

	}
	return true;
}

// 剖切用，返回Z坐标最高、最低点
Acad::ErrorStatus TEImpCabletry::GetExtents(TADSGePoint3d &ptLow, TADSGePoint3d &ptUp) const
{
	AcGePoint3d ptS,ptE;
	double dHight = 0.0,dDist = 0.0;
	AcGeVector3d vtNor;
	m_pXDataMap->GetAt(KEY_START,ptS);
	m_pXDataMap->GetAt(KEY_END,ptE);
	m_pXDataMap->GetAt(KEY_H,dHight);
	m_pXDataMap->GetAt(KEY_NORMAL,vtNor);

	AcGeVector3d vtZ = AcGeVector3d::kZAxis;
	double dAngle = 0.0;
	dAngle = vtNor.angleTo(vtZ);
	if (abs(dAngle) < 1e-3)
	{
		dDist = dHight;
	}
	else
	{
		if (abs(cos(dAngle)) < 1e-3)
		{
			dDist = 0.0;
		}
		else
			dDist = dHight/cos(dAngle);
	}

	if (ptS.z > ptE.z)
	{
		ptLow = ptE;
		ptUp = ptS;
		ptUp.z += dDist;
	}
	else
	{
		ptLow = ptS;
		ptUp = ptE;
		ptUp.z += dDist;
	}
	
	return Acad::eOk;
}

BOOL TEImpCabletry::GetMoveDirect(AcGeVector3d& vtDir)
{
	//获取移动方向
	AcGePoint3d ptS,ptE;
	m_pXDataMap->GetAt(KEY_START,ptS);
	m_pXDataMap->GetAt(KEY_END,ptE);
	AcGeVector3d vtCable = ptE - ptS;

	AcGeVector3d vtMove1(0.0,0.0,0.0),vtMove2(0.0,0.0,0.0);
	AcDbObjectId id1,id2;
	int nType = 0;
	m_pXDataMap->GetAt(KEY_IDCNT1,id1);
	m_pXDataMap->GetAt(KEY_IDCNT2,id2);

	AcDbObjectPointer<TDbFittingBase> pFitting1(id1,AcDb::kForRead);
	if (pFitting1.openStatus() == Acad::eOk)
	{
		TDbXDataMap* pDatamap = pFitting1->GetSpecialtyData();
		
		pDatamap->GetAt(KEY_RUNTIME,nType);
		switch(nType)
		{
		case TDb::eElbow:         //弯通
		case TDb::eTee:			 //三通
			{
				AcGeVector3d vtMaj,vtMin;
				pDatamap->GetAt(KEY_MAJBR,vtMaj);
				pDatamap->GetAt(KEY_MINBR,vtMin);

				if (vtCable.isParallelTo(vtMaj))
					vtMove1 = vtMin;
				else
					vtMove1 = vtMaj;

				break;
			}
		case TDb::eCross:		 //四通
			{
				AcGeVector3d vtMaj,vtMin;
				pDatamap->GetAt(KEY_MAINDIR,vtMaj);
				pDatamap->GetAt(KEY_MINBR,vtMin);

				if (vtCable.isParallelTo(vtMaj))
					vtMove1 = vtMin;
				else
					vtMove1 = vtMaj;
				break;
			}
		default:
			break;
		}
	}

	AcDbObjectPointer<TDbFittingBase> pFitting2(id2,AcDb::kForRead);
	if (pFitting2.openStatus() == Acad::eOk)
	{
		TDbXDataMap* pDatamap = pFitting2->GetSpecialtyData();

		pDatamap->GetAt(KEY_RUNTIME,nType);
		switch(nType)
		{
		case TDb::eElbow:         //弯通
		case TDb::eTee:			 //三通
			{
				AcGeVector3d vtMaj,vtMin;
				pDatamap->GetAt(KEY_MAJBR,vtMaj);
				pDatamap->GetAt(KEY_MINBR,vtMin);

				if (vtCable.isParallelTo(vtMaj))
					vtMove2 = vtMin;
				else
					vtMove2 = vtMaj;

				break;
			}
		case TDb::eCross:		 //四通
			{
				AcGeVector3d vtMaj,vtMin;
				pDatamap->GetAt(KEY_MAINDIR,vtMaj);
				pDatamap->GetAt(KEY_MINBR,vtMin);

				if (vtCable.isParallelTo(vtMaj))
					vtMove2 = vtMin;
				else
					vtMove2 = vtMaj;
				break;
			}
		default:
			break;
		}
	}

	if (vtMove1.isZeroLength() && vtMove2.isZeroLength())
		return FALSE;

	if (!vtMove1.isZeroLength() && 
		!vtMove2.isZeroLength() && 
		!vtMove1.isParallelTo(vtMove2))
		return FALSE;

	vtDir = vtMove1.isZeroLength() ? vtMove2 : vtMove1;

	vtDir.rotateBy(PI * 0.5,AcGeVector3d::kZAxis);

	return TRUE;
}


//added lsd 2013-11-6
//计算AcGeCircArc3d 对象的凸度
double GetArc3dBugle(const AcGeCircArc3d &arc)
{
	AcGePoint3d ptCenter;
	AcGePoint3d ptS,ptE,ptM;
	AcGeVector3d vtS,vtE,vtM,vtX;

	ptCenter = arc.center();
	ptS = arc.startPoint();
	ptE = arc.endPoint();
	if(ptS.distanceTo(ptE) < 1e-3)
		return 0.0;
	double dStartParm = arc.paramOf(ptS);
	double dEndParm = arc.paramOf(ptE);
	
	double dMidParm = arc.paramAtLength(dStartParm,arc.length(dStartParm,dEndParm)/2.0);;
	ptM = arc.evalPoint(dMidParm);

	vtS = ptS - ptCenter;
	vtE = ptE - ptCenter;
	vtM = ptM - ptCenter;
	vtX = AcGeVector3d::kXAxis;

	double dEndAngle = vtX.angleTo(vtE,AcGeVector3d::kZAxis);
	double dStartAngle = vtX.angleTo(vtS,AcGeVector3d::kZAxis);
	double dMidAngle = vtX.angleTo(vtM,AcGeVector3d::kZAxis);

	double dScale = 1;
	if (dStartAngle - dEndAngle > 1e-3)
	{
		double dTemp = dStartAngle;
		dStartAngle = dEndAngle;
		dEndAngle = dTemp;
		dScale = -1;
	}

	double dAngle = 0;

	if (dMidAngle - dStartAngle > 1e-3 && dEndAngle - dMidAngle > 1e-3)
	{
		dAngle = dEndAngle - dStartAngle;
	}
	else
	{
		dAngle = (2 * PI - dEndAngle + dStartAngle) * -1;
	}

	return tan(dAngle * dScale * 0.25);
}