#include "stdafx.h"
#include "DbGouge.h"
#include "PipeTools.h"
#include "DbTrenchFitting.h"

extern void DrawWeight(XExplodeDraw &dc,double dWeight,XCurveSegment &seg,int nColorIndex, double nScale);

ACRX_DXF_DEFINE_MEMBERS(ATSCableTrench, ATSPipeCanal, AcDb::kDHL_CURRENT, 
                        AcDb::kMReleaseCurrent, 1, ATS_TRENCH,
						"ATS_TRENCH图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
IMPLEMENT_TENTBASE(TDbCableTrench);

static AcGePoint3d Mid(AcGePoint3d ptGe1, AcGePoint3d ptGe2)
{
	return AcGePoint3d((ptGe1.x + ptGe2.x) / 2.0,(ptGe1.y + ptGe2.y) / 2.0,(ptGe1.z + ptGe2.z) / 2.0);
}

void InitTDbCableTrench(BOOL bTrue)
{
    if(bTrue) {
        TDbCableTrench::rxInit();
        TDbCableTrench::InitMatchProtocol(TRUE);
    } else {
        TDbCableTrench::InitMatchProtocol(FALSE);
        deleteAcRxClass(TDbCableTrench::desc());
    }
}

const Adesk::UInt8 TDbCableTrench::g_nVersion = 1;

TDbCableTrench::TDbCableTrench()
{
	m_dGougeLineW = 0.0;
	m_nBracketMode = 0;
	m_dBracketLen = 250.0;
	m_dBracketDis = 1000.0;
	m_dBracketLineW = 0.0;
	m_nCornerType = 0;
		
	m_sSpare = _T("");
	m_sTrenchNo = _T("");
    m_dSpare = 0;
	m_nSpare = 0;
}

TDbCableTrench::~TDbCableTrench()
{

}

Acad::ErrorStatus TDbCableTrench::subGetClassID(CLSID* pClsid) const
{
    return Acad::eOk;
}

Acad::ErrorStatus TDbCableTrench::dwgInFields (AcDbDwgFiler* pFiler)
{
	assertWriteEnabled();
    
    Acad::ErrorStatus es = TDbPipeCanal::dwgInFields(pFiler);
    if(es != Acad::eOk) return es;
    Adesk::UInt8  nVer;
    pFiler->readItem(&nVer);
    if(nVer>g_nVersion) {// Version is too new
        return Acad::eMakeMeProxy;
    }

	pFiler->readItem(&m_dGougeLineW);
	pFiler->readItem(&m_nBracketMode);
	pFiler->readItem(&m_dBracketLen);
	pFiler->readItem(&m_dBracketDis);
	pFiler->readItem(&m_dBracketLineW);

	//备用
	pFiler->readItem(&m_nSpare);
	pFiler->readItem(&m_dSpare);
	ReadString(pFiler,m_sSpare);

	ReadString(pFiler,m_sTrenchNo);
	return Acad::eOk;
}

Acad::ErrorStatus TDbCableTrench::dwgOutFields(AcDbDwgFiler*pFiler) const
{
    assertReadEnabled();
    Acad::ErrorStatus es = TDbPipeCanal::dwgOutFields(pFiler);
    if(es != Acad::eOk) return es;
    
    pFiler->writeItem(g_nVersion);
	pFiler->writeItem(m_dGougeLineW);
	pFiler->writeItem(m_nBracketMode);
	pFiler->writeItem(m_dBracketLen);
	pFiler->writeItem(m_dBracketDis);
	pFiler->writeItem(m_dBracketLineW);

	pFiler->writeItem(m_nSpare);
	pFiler->writeItem(m_dSpare);
	pFiler->writeString(m_sSpare);
	pFiler->writeString(m_sTrenchNo);
	return Acad::eOk;
}

Acad::ErrorStatus TDbCableTrench::dxfInFields (AcDbDxfFiler* pFiler)
{
	assertWriteEnabled();
    Acad::ErrorStatus es=Acad::eOk;
    es=TDbPipeCanal::dxfInFields(pFiler);
    if(es!=Acad::eOk) return es;
    
    if (!pFiler->atSubclassData(_T("TDbCableTrench"))) {
        return Acad::eBadDxfSequence;
    }

	return Acad::eOk;
}

Acad::ErrorStatus TDbCableTrench::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	Acad::ErrorStatus es=Acad::eOk;
    es=TDbPipeCanal::dxfOutFields(pFiler);
    assert(es==Acad::eOk);
    es=pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbCableTrench"));
    assert(es==Acad::eOk);

	return Acad::eOk;
}

void TDbCableTrench::CopyPropertiesFrom(AcDbEntity *pSrc,unsigned gMatchFlag)
{
    assertWriteEnabled();
    TDbPipeCanal::CopyPropertiesFrom(pSrc, gMatchFlag);
    TDbCableTrench *pGouge = TDbCableTrench::cast(pSrc);
    if(pGouge) 
	{
		m_dGougeLineW = pGouge->m_dGougeLineW;
		m_nBracketMode = pGouge->m_nBracketMode;
		m_dBracketLen = pGouge->m_dBracketLen;
		m_dBracketDis = pGouge->m_dBracketDis;
		m_dBracketLineW = pGouge->m_dBracketLineW;
		m_nCornerType = pGouge->m_nCornerType;
    }	
}

BOOL TDbCableTrench::CanMergeWith(const TDbPipePrototype &other, int *iPosThis,
								  int *iPosOther) const
{
	if (GetSysType() != other.GetSysType())	// 1、系统类型相同
	{
		return FALSE;
	}
	
	// 是否等宽 // 是否向量平行
	TDbCableTrench* pTrench = (TDbCableTrench*)&other;
	if (pTrench != NULL)
	{
		// 向量
		AcGeVector3d vtHor = pTrench->EndPoint() - pTrench->StartPoint();
		AcGeVector3d vtHor2 = EndPoint() - StartPoint();

		if (!vtHor.isParallelTo(vtHor2))
		{
			return FALSE;
		}
		// 宽
		double dWidth = pTrench->m_nWidth;
		double dHeight = pTrench->GetGougeHeight();
		if (fabs(dWidth-m_nWidth) < 1e-3 && fabs(m_nHeight-dHeight) < 1e-3)
		{
			return TDbPipePrototype::CanMergeWith(other,iPosThis,iPosOther);
		}
	}

	return FALSE;
}

// 自动增加节点到当前数据库，ids－该节点自动连接的管线
AcDbObjectId TDbCableTrench::AddAutoNodeToDb(const XPoint &ptAt, const DList<AcDbObjectId> &ids) const
{
	//modify liaoy 2016-8-9
	TDbTrenchFitting *pFitting=new TDbTrenchFitting;
	pFitting->SetVisible(FALSE);
	for(int i=0; i<ids.Length(); i++) 
	{
		const AcDbObjectId id=ids[i];
		TPipeInterface iFace;
		iFace.m_idPipe=id;
		iFace.m_ptLocation=ptAt;
		pFitting->AddInterface(iFace);
	}
	pFitting->UpdateLinkage(ptAt, GetSysType(), ids);
	TCHAR *layer;
	layer = this->layer();
	TCHAR szLayer[256];
	_tcscpy(szLayer, layer);
	pFitting->setLayer(szLayer);
	return pFitting->AddToCSpace(Adesk::kTrue);
	/*
	AcDbObjectId id;
	if(ids.Length()) 
	{
		TDbTrenchFitting *pFitting = new TDbTrenchFitting;
		pFitting->UpdateLinkage(ptAt, GetSysType(), ids);
        TCHAR *layer;
        layer = this->layer();
        TCHAR szLayer[256];
        _tcscpy(szLayer, layer);
		pFitting->setLayer(szLayer);

		id=AddToCurrentSpace(pFitting, Adesk::kTrue);

        delete [] layer;
	}
	return id;
	*/
	//modify end
}

Acad::ErrorStatus 
TDbCableTrench::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
	// cet 2016.10.17 add 图层关闭时，实体不显示，不进行绘制（打印时，也不会绘制）
	AcDbLayerTableRecordPointer player(this->layerId(), AcDb::kForRead);
	if (player.openStatus() == Acad::eOk && player->isOff())
	{
		return Acad::eOk;
	}
	XAcGiViewDraw &viewDraw = (XAcGiViewDraw &)dc;
    //垂直管线
    XVector3D vtLocation=EndPoint()-StartPoint();
    if(fabs(vtLocation.x)<1.0E-6 && fabs(vtLocation.y)<1.0E-6) { //垂直管线
		
        return Acad::eOk; 
    }
	
	//绘制电缆沟上线和下线
	ExplodeOrDrawPipeCanal(dc);

	return Acad::eOk;
}

//调整电缆沟位置
void  TDbCableTrench::ExplodeOrDrawPipeCanal(XExplodeDraw &dc) const
{	
	switch(m_nCanalType)
	{
	case Canal_Corner1:
		ExplodeOrDrawCanalType1(dc);
		break;
	case Canal_Corner2:
	case Canal_Corner3:
	case Canal_Corner4:
	case Canal_Corner5:
		ExplodeOrDrawCanalType2(dc);
		break;
	default:
		break;
	}
}

void  TDbCableTrench::ExplodeOrDrawCanalType1(XExplodeDraw &dc) const
{
	//得到电缆沟两端节点
	AcDbObjectId idNode1(NULL), idNode2(NULL);

    idNode1 = GetNode(0);
    idNode2 = GetNode(1);

	if (!idNode1.isValid() || !idNode2.isValid())
	{
		return;
	}
	
	AcGePoint3d pt1,pt2,pt3,pt4;
	//分别得到电缆沟的一端上两点
	AcArray<CornerLine> map1,map2;
	GetCannalPts(idNode1,pt1,pt2,map1);
	GetCannalPts(idNode2,pt3,pt4,map2);
	
	XCurveSegment cenCurve = GetCurve();
	XCurveSegment segUp,segDown;
	XDirectionCurve segDir(cenCurve.StartPoint(), cenCurve.EndPoint(), cenCurve.GetBulge());
    segUp = segDir.Offset(m_nWidth/2, LS_FINITE);
    segDown = segDir.Offset(-m_nWidth/2, LS_FINITE);
	segUp.SetPoints(pt1,pt3);
	segDown.SetPoints(pt2,pt4);
	
	double dWeight = GetPScale()*m_dGougeLineW;
	if (dWeight > 1e-3)
	{
		DrawWeight(dc, dWeight, segUp, colorIndex(), linetypeScale());
		//绘制电缆沟支架
		DrawWeight(dc, dWeight, segDown, colorIndex(), linetypeScale());
	}
	else
	{
		dc << segUp;
		dc << segDown;
	}

	for (int i = 0; i < map1.length(); ++i)
	{
		XCurveSegment segCorn(map1[i].pair.second,map1[i].pair.first,map1[i].dAng);
		if(dWeight > 1e-3)
			DrawWeight(dc, dWeight, segCorn, colorIndex(), linetypeScale());
		else
			dc << segCorn;
	}
	
	for (int j = 0; j < map2.length(); ++j)
	{
		XCurveSegment segCorn(map2[j].pair.second,map2[j].pair.first,map2[j].dAng);
		if(dWeight > 1e-3)
			DrawWeight(dc, dWeight, segCorn, colorIndex(), linetypeScale());
		else
			dc << segCorn;
	}

	// 是否需要绘制连接线
	if (IsHasMorePipes(idNode1))
	{
		XCurveSegment segCnt;
		segCnt.SetPoints(pt1,pt2);
		if (dWeight > 1e-3)
			DrawWeight(dc, dWeight, segCnt, colorIndex(), linetypeScale());
		else
			dc << segCnt;
	}
	if (IsHasMorePipes(idNode2))
	{
		XCurveSegment segCnt;
		segCnt.SetPoints(pt3,pt4);
		if(dWeight > 1e-3)
			DrawWeight(dc, dWeight, segCnt, colorIndex(), linetypeScale());
		else
			dc << segCnt;
	}
	//绘制电缆沟支架
	DrawBrackets(dc,cenCurve);
}

//////////////////////////////////////////////////////////////////////////
void CurveSegmentOffset(const XCurveSegment& seg,double dWidth,XCurveSegment& segUp, XCurveSegment& segDown)
{
	XDirectionCurve segDir(seg.StartPoint(), seg.EndPoint(), seg.GetBulge());
	segUp = segDir.Offset(dWidth/2, LS_FINITE);
	segDown = segDir.Offset(-dWidth/2, LS_FINITE);
}
void  TDbCableTrench::SortPipeCanalTrench(const AcGePoint3d &ptOr,const AcDbObjectIdArray &arIds,AcArray<std::pair<AcDbObjectId,XCurveSegment>>& arPairSeg) const
{
	AcDbObjectId idSelf = GetSelfObjectId();
	AcGeMatrix3d mat;
	ads_matrix	 matAds;
	GetOffsetMatrix(idSelf, mat);
	AcArray<std::pair<AcDbObjectId,XCurveSegment>> arPairSegTmp;
	for (int i = 0; i < arIds.length(); ++i)
	{
		if (idSelf == arIds[i])
		{
			XCurveSegment seg;
			seg = GetCurve();

			XCurveSegment segUp, segDown;
			CurveSegmentOffset(seg,GetWidth(),segUp,segDown);
			arPairSegTmp.append(std::make_pair(arIds[i],segUp));
			arPairSegTmp.append(std::make_pair(arIds[i],segDown));
		}
		else
		{
			if (arIds[i].isValid())
			{
				//防止在三维状态下在实体内部自己打开自己
				OPENOBJ_BEGIN(arIds[i], AcDb::kForRead, TDbPipeCanal, pCanal);
				if (pCanal != NULL)
				{
					XCurveSegment seg;
					seg = pCanal->GetCurve();

					memcpy(matAds, &mat, sizeof(AcGeMatrix3d));
					seg.TransformBy(matAds);

					XCurveSegment segUp, segDown;
					CurveSegmentOffset(seg,GetWidth(),segUp,segDown);
					arPairSegTmp.append(std::make_pair(arIds[i],segUp));
					arPairSegTmp.append(std::make_pair(arIds[i],segDown));
				}
				OPENOBJ_END();
			}
		}
	}

	XPoint pt = ptOr;
	std::map<double,std::pair<AcDbObjectId,XCurveSegment>> map;
	double dPar = 0.0;
	std::vector<double> vecT;
	AcDbCircle circle(ptOr,AcGeVector3d::kZAxis,m_nWidth/5);
	for (int j = 0; j < arPairSegTmp.length(); ++j)
	{
		AcGePoint3d ptNear;
		circle.getClosestPointTo(arPairSegTmp[j].second.MidPoint(),AcGeVector3d::kZAxis,ptNear);
		circle.getParamAtPoint(ptNear,dPar);
		map[dPar] = arPairSegTmp[j];
		vecT.push_back(dPar);
	}

	std::sort(vecT.begin(),vecT.end());
	for (UINT k = 0; k < vecT.size(); ++k)
	{
		double dT = vecT[k];
		arPairSeg.append(map[dT]);
	}
}
void  TDbCableTrench::GetCorner2InterPtsTrench(const std::pair<AcDbObjectId,XCurveSegment> &seg1,const const std::pair<AcDbObjectId,XCurveSegment> &seg2,const AcGePoint3d &pt,int nSegCount,AcGePoint3dArray &arPts,AcArray<CornerLine> &map1) const
{
	BOOL bEqulaWidth = FALSE;
	double dCornerR1(-1),dCornerR2(-1);
	OPENOBJ_BEGIN(seg1.first,AcDb::kForRead,TDbCableTrench,pTrench);
	if (pTrench)
	{
		dCornerR1 = pTrench->GetCornerRadius();
	}
	OPENOBJ_END();
	OPENOBJ_BEGIN(seg2.first,AcDb::kForRead,TDbCableTrench,pTrench);
	if (pTrench)
	{
		dCornerR2 = pTrench->GetCornerRadius();
	}
	OPENOBJ_END();
	if (dCornerR1 > 0 && dCornerR2 > 0 && fabs(dCornerR1 - dCornerR2) > TOL)//不等拐角半径
	{
		//以拐角半径大的为准
		GetCorner2InterPtsTrench(seg1.second,seg2.second,pt,nSegCount,max(dCornerR1,dCornerR2),arPts,map1);
	}
	else
	{
		
		GetCorner2InterPtsTrench(seg1.second,seg2.second,pt,nSegCount,GetCornerRadius(),arPts,map1);
	}
}
void   TDbCableTrench::GetCorner2InterPtsTrench(const XCurveSegment &seg1,const XCurveSegment &seg2,const AcGePoint3d &pt,int nSegCount,double dSpare,AcGePoint3dArray &arPts,AcArray<CornerLine> &map1) const
{
	XPoint ptInter = pt;
	AcGeVector3d vtDir1,vtDir2;
	AcGePoint3d ptIns1,ptIns2;
	BOOL bMoreLen = FALSE; //用来判断弯头的弧线是朝内还是朝外
	AcGeVector3d vtT;
	XCurveSegment seg1T,seg2T;
	AcGePoint3d ptSegS1,ptSegE1,ptSegS2,ptSegE2;
	//将曲线Z坐标置0
	ptSegS1 = seg1.StartPoint();
	ptSegS2 = seg2.StartPoint();
	ptSegE1 = seg1.EndPoint();
	ptSegE2 = seg2.EndPoint();

	ptSegS1.z = 0;
	ptSegS2.z = 0;
	ptSegE1.z = 0;
	ptSegE2.z = 0;
	seg1T.SetPoints(ptSegS1,ptSegE1);
	seg2T.SetPoints(ptSegS2,ptSegE2);
	if (seg1T.StartPoint().Distance(ptInter) > seg1T.EndPoint().Distance(ptInter))
	{
		vtDir1 = seg1T.EndPoint() - seg1T.StartPoint();
		vtT = seg1T.StartPoint() - pt;
	}
	else
	{
		vtDir1 = seg1T.StartPoint() - seg1T.EndPoint();
		vtT = seg1T.EndPoint() - pt;
	}

	if (vtT.length() > seg1T.GetLength())
		bMoreLen = TRUE;
	XPoint ptT1,ptT2;
	vtDir1.normalize();
	//判断是否是无交点的拐角
	if (seg1T.Intersection(seg2T,ptT1,ptT2) == 0)
		//	ptIns1 = pt - vtDir1*m_nWidth*tan(PI/8);
		ptIns1 = pt - vtDir1*(m_nWidth+dSpare-m_nWidth*tan(PI/8));
	else
		ptIns1 = pt - vtDir1*dSpare; 
	arPts.append(ptIns1);

	if (seg2T.StartPoint().Distance(ptInter) > seg2T.EndPoint().Distance(ptInter))
		vtDir2 = seg2T.EndPoint() - seg2T.StartPoint();
	else
		vtDir2 = seg2T.StartPoint() - seg2T.EndPoint();

	vtDir2.normalize();
	//判断是否是无交点的拐角
	if (seg1T.Intersection(seg2T,ptT1,ptT2) == 0)
		//	ptIns2 = pt - vtDir2*m_nWidth*tan(PI/8);
		ptIns2 = pt - vtDir2*(m_nWidth+dSpare-m_nWidth*tan(PI/8));
	else
		ptIns2 = pt - vtDir2*dSpare; 
	arPts.append(ptIns2);

	std::pair<AcGePoint3d,AcGePoint3d> pair;
	pair.first = ptIns1;
	pair.second = ptIns2;

	CornerLine corner;
	corner.pair = pair;

	if (m_nCanalType == Canal_Corner2 || m_nCanalType == Canal_Corner3)
	{
		corner.dAng = 0.0;
	}
	else
	{
		if (nSegCount > 4)
		{
			corner.dAng = vtDir1.angleTo(vtDir2) - PI;
		}
		else
		{
			if (bMoreLen)
				corner.dAng = PI - vtDir1.angleTo(vtDir2);
			else
				corner.dAng = vtDir1.angleTo(vtDir2) - PI;
		}
	}
	map1.append(corner);
}
void  TDbCableTrench::GetInterPtsTrench(const AcArray<std::pair<AcDbObjectId,XCurveSegment>> &arSeg,AcArray<AcGePoint3d> &arPts,AcArray<CornerLine> &map1) const
{
	BOOL bIsInter = FALSE;
	XPoint ptInter1,ptInter2;
	if (arSeg.length() > 1)
	{
		int nNext = 0;
		for (int i = 0; i < arSeg.length(); i++)
		{
			if (i != arSeg.length() - 1)
				nNext = i + 1;
			else
				nNext = 0;
			AcGeVector3d vt1 = arSeg[i].second.StartPoint() - arSeg[i].second.EndPoint();
			AcGeVector3d vt2 = arSeg[nNext].second.StartPoint() - arSeg[nNext].second.EndPoint();
			if (vt1.isParallelTo(vt2))
				continue;

			AcGePoint3dArray arPtsT;
			AcGePoint3d ptS = arSeg[i].second.StartPoint();
			AcGePoint3d ptST = arSeg[nNext].second.StartPoint();
			AcGePoint3d ptE = arSeg[i].second.EndPoint();
			AcGePoint3d ptET = arSeg[nNext].second.EndPoint();

			ptS.z = 0.0;
			ptE.z = 0.0;
			ptST.z = 0.0;
			ptET.z = 0.0;
			AcDbLine line1(ptS,ptE);
			AcDbLine line2(ptST,ptET);

			line1.intersectWith(&line2,AcDb::kOnBothOperands,arPtsT);
			if (arPtsT.length() > 0)
			{
				if(m_nCanalType == Canal_Corner1) 
					arPts.append(arPtsT[0]);
				else if (m_nCanalType == Canal_Corner2 || m_nCanalType == Canal_Corner3 || m_nCanalType == Canal_Corner4 || m_nCanalType == Canal_Corner5)
				{
					//得到类型2的交点
					GetCorner2InterPtsTrench(arSeg[i],arSeg[nNext],arPtsT[0],arSeg.length(),arPts,map1);
				}
			}
			else
			{
				if (arSeg.length() == 4)
				{
					arPtsT.removeAll();
					if (line1.intersectWith(&line2,AcDb::kExtendBoth,arPtsT) == Acad::eOk)
					{
						if(m_nCanalType == Canal_Corner1 || m_nCanalType == Canal_Corner3 || m_nCanalType == Canal_Corner4) 
							arPts.append(arPtsT[0]);
						else if (m_nCanalType == Canal_Corner2 || m_nCanalType == Canal_Corner5)
						{
							//得到类型2的交点
							GetCorner2InterPtsTrench(arSeg[i],arSeg[nNext],arPtsT[0],arSeg.length(),arPts,map1);
						}
					}
				}
			}
		}
	}
}
void  TDbCableTrench::GetCannalPtsTrench(const AcDbObjectId &id,AcGePoint3d &pt1,AcGePoint3d &pt2,AcArray<CornerLine> &map1) const
{
	if (id.isValid())
	{
		//通过节点得到几段线
		AcDbObjectIdArray arCanal;
		OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipeNode, pNode);
		if(pNode)
		{
			int num = pNode->GetInterfaceNum();
			if (num > 0)
			{
				for (int i = 0; i < num; ++i)
				{
					TPipeInterface inter;
					//	pNode->GetInterface(i,inter);
					AcDbObjectId id = pNode->GetIPipe(i);
					arCanal.append(id);
				}

				if (num > 3)
				{
					FilterCannal(arCanal);
				}

				//将线按逆时针排序
				AcArray<std::pair<AcDbObjectId,XCurveSegment>> arPairSeg;
				SortPipeCanalTrench(pNode->GetLocation(),arCanal,arPairSeg);
				AcArray<XCurveSegment, AcArrayObjectCopyReallocator<XCurveSegment> > arSeg;
				for (int i = 0;i < arPairSeg.length();i++)
					arSeg.append(arPairSeg[i].second);

				//求出排序后线的交点
				AcArray<AcGePoint3d> arPts;
				GetInterPtsTrench(arPairSeg,arPts,map1);

				//调整方沟位置
				ChangePipeCanalPosition(arPts,pNode->GetLocation(),arSeg.length(),pt1,pt2);

				// 如果连接点为2则判断是否要添加变径条件:1,vt 2,width
				if (num == 2 && arPts.length() == 0)
				{
					double dLen = 0.0;//变径长度 = b1+b2
					if (MakesureCreateReducer(arCanal,dLen))
						ChangePipeCanalPosition(arCanal,id,pNode->GetLocation(),dLen,pt1,pt2,map1);
				}
			}
		}
		OPENOBJ_END();
	}
}
//////////////////////////////////////////////////////////////////////////
void  TDbCableTrench::ExplodeOrDrawCanalType2(XExplodeDraw &dc) const
{
	//得到电缆沟两端节点
	AcDbObjectId idNode1(NULL), idNode2(NULL);

    idNode1 = GetNode(0);
    idNode2 = GetNode(1);

	if (!idNode1.isValid() || !idNode2.isValid())
	{
		return;
	}
	
	AcGePoint3d pt1,pt2,pt3,pt4;
	//分别得到电缆沟的一端上两点
	AcArray<CornerLine> map1,map2;
	//GetCannalPts(idNode1,pt1,pt2,map1);
	//GetCannalPts(idNode2,pt3,pt4,map2);
	GetCannalPtsTrench(idNode1,pt1,pt2,map1);
	GetCannalPtsTrench(idNode2,pt3,pt4,map2);

	double dWeight = GetPScale()*m_dGougeLineW;
	XCurveSegment cenCurve = GetCurve();
	XCurveSegment segUp,segDown;
	XDirectionCurve segDir(cenCurve.StartPoint(), cenCurve.EndPoint(), cenCurve.GetBulge());
    segUp = segDir.Offset(m_nWidth/2, LS_FINITE);
    segDown = segDir.Offset(-m_nWidth/2, LS_FINITE);
	segUp.SetPoints(pt1,pt3);
	segDown.SetPoints(pt2,pt4);
	
	double dAng = 0.0;

	if (dWeight > 1e-3)
	{
		DrawWeight(dc, dWeight, segUp, colorIndex(), linetypeScale());
		DrawWeight(dc, dWeight, segDown, colorIndex(), linetypeScale());
	}
	else
	{
		dc << segUp;
		dc << segDown;
	}

	DrawBrackets(dc,cenCurve);

	for (int i = 0; i < map1.length(); ++i)
	{
		XCurveSegment segCorn(map1[i].pair.second,map1[i].pair.first,map1[i].dAng);
		if (dWeight > 1e-3)
			DrawWeight(dc, dWeight, segCorn, colorIndex(), linetypeScale());
		else
			dc << segCorn;
	}
	
	for (int j = 0; j < map2.length(); ++j)
	{
		XCurveSegment segCorn(map2[j].pair.second,map2[j].pair.first,map2[j].dAng);
		if(dWeight > 1e-3)
			DrawWeight(dc, dWeight, segCorn, colorIndex(), linetypeScale());
		else
			dc << segCorn;
	}

	// 是否需要绘制连接线
	if (IsHasMorePipes(idNode1))
	{
		XCurveSegment segCnt;
		segCnt.SetPoints(pt1,pt2);
		if(dWeight > 1e-3)
			DrawWeight(dc, dWeight, segCnt, colorIndex(), linetypeScale());
		else
			dc << segCnt;
	}
	if (IsHasMorePipes(idNode2))
	{
		XCurveSegment segCnt;
		segCnt.SetPoints(pt3,pt4);
		if(dWeight > 1e-3)
			DrawWeight(dc, dWeight, segCnt, colorIndex(), linetypeScale());
		else
			dc << segCnt;
	}
}

// 根据连接点点过滤相连接的电缆沟
BOOL TDbCableTrench::IsHasMorePipes(const AcDbObjectId& idNode) const
{
	int num = GetNodeCntPipeNumber(idNode);

	if (num > 1)// 有连接
	{
		return FALSE;
	}
	
	return TRUE;
}

// 节点连接的管子个数
int TDbCableTrench::GetNodeCntPipeNumber(const AcDbObjectId& idNode) const
{
	int nNum = 0;
	if (idNode.isValid())
	{
		OPENOBJ_BEGIN(idNode, AcDb::kForRead, TDbPipeNode, pNode);
		if(pNode)
		{
			nNum = pNode->GetInterfaceNum();
		}
		OPENOBJ_END();
	}
	
	return nNum;
}

// 绘制电缆沟支架
Acad::ErrorStatus 
TDbCableTrench::DrawBrackets(XExplodeDraw &dc,XCurveSegment& cenSeg) const
{
	AcArray<XCurveSegment, AcArrayObjectCopyReallocator<XCurveSegment> > arBracket;
	switch(m_nBracketMode)
	{
	case eGNull:
		{
			break;
		}
	case eGCover: // 支架长度等于沟宽	
	case eGLSide:
	case eGRSide:	
		{
			MakeCurvesOfCableGougeSide(arBracket,cenSeg);
			break;
		}
	case eGOrder:
		{
			MakeCurvesOfCableGougeOrder(arBracket,cenSeg);
			break;
		}
	case eGInter:
		{
			MakeCurvesOfCableGougeInter(arBracket,cenSeg);
			break;
		}
	default:
		break;
	}

	// 绘制
	if (arBracket.length() > 0)
	{
		double dWeight = GetPScale() * m_dBracketLineW;
		for (int i = 0;i < arBracket.length();i++)
		{
			if (dWeight > 1e-3)
				DrawWeight(dc, dWeight , arBracket[i], colorIndex(), linetypeScale());
			else
				dc << arBracket[i];
		}
	}

	return Acad::eOk;
}

// 单边
BOOL TDbCableTrench::MakeCurvesOfCableGougeSide(AcArray<XCurveSegment, AcArrayObjectCopyReallocator<XCurveSegment> >& arBracket,XCurveSegment& cenSeg) const
{
	arBracket.setLogicalLength(0);

	//得到电缆沟两端节点
	AcDbObjectId idNode1(NULL), idNode2(NULL);
    idNode1 = GetNode(0);
    idNode2 = GetNode(1);

	if (!idNode1.isValid() || !idNode2.isValid())
	{
		return FALSE;
	}

	AcGeVector3d vtHor = cenSeg.EndPoint() - cenSeg.StartPoint();
	AcGeVector3d vtVer = vtHor;
	vtVer.rotateBy(PI / 2,AcGeVector3d::kZAxis);
	vtHor.normalize();
	vtVer.normalize();
	// 预览还是创建
	if (idNode1 != AcDbObjectId::kNull && idNode2 != AcDbObjectId::kNull) // 创建
	{		
		AcGePoint3d pt1,pt2,pt3,pt4;
		//分别得到电缆沟的一端上两点
		AcArray<CornerLine> map1,map2;
		GetCannalPts(idNode1,pt1,pt2,map1);
		GetCannalPts(idNode2,pt3,pt4,map2);	

		AcGePoint3d ptS,ptE;
		if (m_nBracketMode == eGLSide || m_nBracketMode == eGCover)
		{
			ptS = pt2;
			ptE = pt4;
			
			int nNum = GetNodeCntPipeNumber(idNode2);
			if (map2.length() > 0 && (nNum > 0 && nNum < 3))
				DrawBracketOfCorner(ptE,map2,arBracket,idNode2);
		}
		else if (m_nBracketMode == eGRSide)
		{
			ptS = pt1;
			ptE = pt3;

			int nNum = GetNodeCntPipeNumber(idNode2);
			if (map2.length() > 0 && (nNum > 0 && nNum < 3))
				DrawBracketOfCorner(ptE,map2,arBracket,idNode2);
		}
		else
		{
			return FALSE;
		}

		// 修复开始和结束点
		if (!IsHasMorePipes(idNode1)) // 存在连接
			ReConstructBracketLine(ptS,ptE,idNode1);			
		if (!IsHasMorePipes(idNode2))
			ReConstructBracketLine(ptS,ptE,idNode2);
		
		if (m_nBracketMode == eGRSide)
			vtVer *= -1;

		DrawBracketsFun(vtHor,-vtVer,ptS,ptE,arBracket);
	}
	else// 预览
	{
		AcGePoint3d ptS = cenSeg.StartPoint();
		AcGePoint3d ptE = cenSeg.EndPoint();
		if (m_nBracketMode == eGLSide || m_nBracketMode == eGCover)
		{
			ptS += vtVer * m_nWidth / 2;
			ptE += vtVer * m_nWidth / 2;
			DrawBracketsFun(vtHor,-vtVer,ptS,ptE,arBracket);
		}
		else if (m_nBracketMode == eGRSide)
		{
			ptS -= vtVer * m_nWidth / 2;
			ptE -= vtVer * m_nWidth / 2;
			DrawBracketsFun(vtHor,vtVer,ptS,ptE,arBracket);
		}
	}

	return TRUE;
}

// 对立
BOOL TDbCableTrench::MakeCurvesOfCableGougeOrder(AcArray<XCurveSegment, AcArrayObjectCopyReallocator<XCurveSegment> >& arBracket,XCurveSegment& cenSeg) const
{
	arBracket.setLogicalLength(0);

	//得到电缆沟两端节点
	AcDbObjectId idNode1(NULL), idNode2(NULL);

    idNode1 = GetNode(0);
    idNode2 = GetNode(1);

	if (!idNode1.isValid() || !idNode2.isValid())
	{
		return FALSE;
	}
	
	AcGeVector3d vtHor = cenSeg.EndPoint() - cenSeg.StartPoint();
	AcGeVector3d vtVer = vtHor;
	vtVer.rotateBy(PI / 2,AcGeVector3d::kZAxis);
	vtHor.normalize();
	vtVer.normalize();
	// 预览还是创建
	if (idNode1 != AcDbObjectId::kNull && idNode2 != AcDbObjectId::kNull) // 创建
	{
		AcGePoint3d pt1,pt2,pt3,pt4;
		//分别得到电缆沟的一端上两点
		AcArray<CornerLine> map1,map2;
		GetCannalPts(idNode1,pt1,pt2,map1);
		GetCannalPts(idNode2,pt3,pt4,map2);

		AcGePoint3d ptS = pt1;
		AcGePoint3d ptE = pt3;
		int nNum = GetNodeCntPipeNumber(idNode2);
		if (map2.length() > 0 && (nNum > 0 && nNum < 3))
			DrawBracketOfCorner(ptE,map2,arBracket,idNode2);
		// 修复开始和结束点
		if (!IsHasMorePipes(idNode1)) // 存在连接
			ReConstructBracketLine(ptS,ptE,idNode1);
		if (!IsHasMorePipes(idNode2))
			ReConstructBracketLine(ptS,ptE,idNode2);
		DrawBracketsFun(vtHor,vtVer,ptS,ptE,arBracket);
		AcDbLine l1(ptS,ptE);
		ptS = pt2;
		ptE = pt4;
		nNum = GetNodeCntPipeNumber(idNode2);
		if (map2.length() > 0 && (nNum > 0 && nNum < 3))
			DrawBracketOfCorner(ptE,map2,arBracket,idNode2);
		// 修复开始和结束点
		if (!IsHasMorePipes(idNode1)) // 存在连接
			ReConstructBracketLine(ptS,ptE,idNode1);
		if (!IsHasMorePipes(idNode2))
			ReConstructBracketLine(ptS,ptE,idNode2);

		AcGePoint3d ptS1,ptTemp;
		l1.getStartPoint(ptS1);
		l1.getClosestPointTo(ptS,ptTemp,Adesk::kTrue);
		int dDist = ptS1.distanceTo(ptTemp);

		if (dDist != 0)
		{
			AcGeVector3d vtTemp = ptE - ptS;
			AcGeVector3d vtTemp1 = ptS1 - ptS;
			int dDist1 = 0;
			if (vtTemp1.angleTo(vtTemp) <= PI/2)
			{
				dDist1 = dDist%(int)m_dBracketDis;
			}
			else
				dDist1 = m_dBracketDis - dDist%(int)m_dBracketDis;

			vtTemp.normalize();
			ptS += dDist1*vtTemp;
		}
	
		DrawBracketsFun(vtHor,-vtVer,ptS,ptE,arBracket);
	}
	else//预览
	{		
		AcGePoint3d ptS,ptE;

		ptS = cenSeg.StartPoint() + vtVer * m_nWidth / 2;
		ptE = cenSeg.EndPoint() + vtVer * m_nWidth / 2;
		DrawBracketsFun(vtHor,-vtVer,ptS,ptE,arBracket);

		ptS = cenSeg.StartPoint() - vtVer * m_nWidth / 2;
		ptE = cenSeg.EndPoint() - vtVer * m_nWidth / 2;
		DrawBracketsFun(vtHor,vtVer,ptS,ptE,arBracket);
	}
	
	return TRUE;
}

// 交错
BOOL TDbCableTrench::MakeCurvesOfCableGougeInter(AcArray<XCurveSegment, AcArrayObjectCopyReallocator<XCurveSegment> >& arBracket,XCurveSegment& cenSeg) const
{
	arBracket.setLogicalLength(0);
	
	//得到电缆沟两端节点
	AcDbObjectId idNode1(NULL), idNode2(NULL);
	
    idNode1 = GetNode(0);
    idNode2 = GetNode(1);

	if (!idNode1.isValid() || !idNode2.isValid())
	{
		return FALSE;
	}
	
	AcGeVector3d vtHor = cenSeg.EndPoint() - cenSeg.StartPoint();
	AcGeVector3d vtVer = vtHor;
	vtVer.rotateBy(PI / 2,AcGeVector3d::kZAxis);
	vtHor.normalize();
	vtVer.normalize();
	// 预览还是创建
	if (idNode1 != AcDbObjectId::kNull && idNode2 != AcDbObjectId::kNull) // 创建
	{
		AcGePoint3d pt1,pt2,pt3,pt4;
		//分别得到电缆沟的一端上两点
		AcArray<CornerLine> map1,map2;
		GetCannalPts(idNode1,pt1,pt2,map1);
		GetCannalPts(idNode2,pt3,pt4,map2);
		
		AcGePoint3d ptS = pt2;
		AcGePoint3d ptE = pt4;

		int nNum = GetNodeCntPipeNumber(idNode2);
		if (map2.length() > 0 && (nNum > 0 && nNum < 3))
			DrawBracketOfCorner(ptE,map2,arBracket,idNode2);
		// 修复开始和结束点
		if (!IsHasMorePipes(idNode1)) // 存在连接
			ReConstructBracketLine(ptS,ptE,idNode1);
		if (!IsHasMorePipes(idNode2))
			ReConstructBracketLine(ptS,ptE,idNode2);
		DrawBracketsFun(vtHor,-vtVer,ptS,ptE,arBracket);
		
		// 下边
		AcGePoint3d ptST = ptS;// 用于校正另一边便宜间距的一半
		ptS = pt1;
		ptE = pt3;
		nNum = GetNodeCntPipeNumber(idNode2);
		if (map2.length() > 0 && (nNum > 0 && nNum < 3))
			DrawBracketOfCorner(ptE,map2,arBracket,idNode2);
		// 修复开始和结束点
		if (!IsHasMorePipes(idNode1)) // 存在连接
			ReConstructBracketLine(ptS,ptE,idNode1);
		if (!IsHasMorePipes(idNode2))
			ReConstructBracketLine(ptS,ptE,idNode2);
		// 偏移
		AcGePoint3d ptS2T = ptS + vtVer * m_nWidth;
		double dDist = ptS2T.distanceTo(ptST);
		double dOff = 0.0;
		if (dDist < 1e-2)
		{
			dOff = m_dBracketDis / 2;
		}
		else
		{
			// 剩余
			int nSpareNum = 0;
			if (m_dBracketDis != 0)
				nSpareNum = int(dDist / m_dBracketDis);
			double dSpare = m_dBracketDis * nSpareNum;
			dSpare = dDist - dSpare;
			if (dSpare < (m_dBracketDis / 2))
			{
				dOff = m_dBracketDis / 2 - dSpare;
			}
			else
			{
				dOff = m_dBracketDis * 3 / 2 - dSpare;
			}
		}

		ptS += vtHor * dOff;
		DrawBracketsFun(vtHor,vtVer,ptS,ptE,arBracket);
	}
	else//预览
	{		
		AcGePoint3d ptS,ptE;

		ptS = cenSeg.StartPoint() + vtVer * m_nWidth / 2;
		ptE = cenSeg.EndPoint() + vtVer * m_nWidth / 2;
		DrawBracketsFun(vtHor,-vtVer,ptS,ptE,arBracket);

		ptS = cenSeg.StartPoint() - vtVer * m_nWidth / 2;
		ptE = cenSeg.EndPoint() - vtVer * m_nWidth / 2;

		ptS += vtHor * m_dBracketDis / 2;
		DrawBracketsFun(vtHor,vtVer,ptS,ptE,arBracket);
	}

	return TRUE;
}

// 得到相连的另一条沟的宽度和倒角半径
void TDbCableTrench::GetAnotherTrenchParam(const AcGeVector3d& vtHor,const AcDbObjectId& idNode,double& dWidth,double& dRadius) const
{
	if (!idNode.isValid())
	{
		return;
	}

	dWidth = 0.0;
	dRadius = 0.0;
	AcDbObjectId id;
	AcDbObjectIdArray arId;
	OPENOBJ_BEGIN(idNode, AcDb::kForRead, TDbPipeNode, pNode);
	if(pNode)
	{
		int nNum = pNode->GetInterfaceNum();
		if (nNum == 2)
		{
			for (int i = 0;i < nNum;i++)
			{
				id = pNode->GetIPipe(i);
				arId.append(id);
			}
		}
	}
	OPENOBJ_END();
	if (arId.length() != 2)
		return;
	
	// 读取另一条沟的数据
	AcGeVector3d vt;
	for (int i = 0;i < arId.length();i++)
	{
		if (arId[i].isValid())
		{
			OPENOBJ_BEGIN(arId[i], AcDb::kForRead, TDbCableTrench, pTrench);
			if(pTrench)
			{
				vt = pTrench->StartPoint() - pTrench->EndPoint();
				if (!vt.isParallelTo(vtHor))
				{
					dWidth = pTrench->m_nWidth;
					dRadius = pTrench->m_dSpare;
					break;
				}
			}
			OPENOBJ_END();
		}
	}
}

// 重新构建绘制支架的线
BOOL TDbCableTrench::ReConstructBracketLine(AcGePoint3d& ptS,AcGePoint3d& ptE,const AcDbObjectId& idNode) const
{
	if (!idNode.isValid())
	{
		return FALSE;
	}

	AcGePoint3d ptNode;
	OPENOBJ_BEGIN(idNode, AcDb::kForRead, TDbPipeNode, pNode);
	if(pNode)
	{
		ptNode = pNode->GetLocation();
	}
	OPENOBJ_END();
	
	// 挑出距离节点较近的点
	double dLn1 = ptS.distanceTo(ptNode);
	double dLn2 = ptE.distanceTo(ptNode);

	if (dLn1 > dLn2)//ptE
	{
		AcGeVector3d vtHor = ptE - ptS;
		vtHor.normalize();

		AcGePointOnCurve3d ptT;
		AcGeLine3d line(ptNode,vtHor);
		line.getClosestPointTo(ptE,ptT);

		AcGeVector3d vtT = ptT.point3d() - ptNode;
		vtT.normalize();
		if (vtT.isCodirectionalTo(vtHor))//同向:一端较长的边
		{
			ptE -= vtHor * MINDIST;
		}
		else// 短线
		{
			switch(m_nCanalType)
			{
			case Canal_Corner1://直角
				{
					double dWidth = 0.0,dRadius = 0.0;
					GetAnotherTrenchParam(vtHor,idNode,dWidth,dRadius);

					if (dWidth < 500)
						ptE -= vtHor * (MINDIST - dWidth);
					break;
				}
			case Canal_Corner2://双倒角	
			case Canal_Corner3://单倒角
				{
					double dWidth = 0.0,dRadius = 0.0;
					GetAnotherTrenchParam(vtHor,idNode,dWidth,dRadius);
					dWidth += dRadius;

					if (dWidth < 500)
						ptE -= vtHor * (MINDIST - dWidth);
					break;
				}
			default:
				break;
			}
		}
	}
	else//ptS
	{
		AcGeVector3d vtHor = ptS - ptE;
		vtHor.normalize();
		
		AcGePointOnCurve3d ptT;
		AcGeLine3d line(ptNode,vtHor);
		line.getClosestPointTo(ptS,ptT);
		
		AcGePoint3d pp = ptT.point3d();
		AcGeVector3d vtT = ptT.point3d() - ptNode;
		vtT.normalize();
		if (vtT.isCodirectionalTo(vtHor))//同向:一端较长的边
		{
			ptS -= vtHor * MINDIST;
		}
		else// 短线
		{
			switch(m_nCanalType)
			{
			case Canal_Corner1://直角
				{
					double dWidth = 0.0,dRadius = 0.0;
					GetAnotherTrenchParam(vtHor,idNode,dWidth,dRadius);

					if (dWidth < 500)
						ptS -= vtHor * (MINDIST - dWidth);
					break;
				}
			case Canal_Corner2://双倒角	
			case Canal_Corner3://单倒角
				{
					double dWidth = 0.0,dRadius = 0.0;
					GetAnotherTrenchParam(vtHor,idNode,dWidth,dRadius);
					dWidth += dRadius;

					if (dWidth < 500)
						ptS -= vtHor * (MINDIST - dWidth);
					break;
				}
			default:
				break;
			}
		}
	}

	return TRUE;
}

// 绘制拐角处支架
void TDbCableTrench::DrawBracketOfCorner(const AcGePoint3d& ptRef,AcArray<CornerLine>& mapPt,AcArray<XCurveSegment, AcArrayObjectCopyReallocator<XCurveSegment> >& arBracket,const AcDbObjectId& idNode) const
{
// 	if (mapPt.length() < 1)
// 		return;
// 
// 	CornerLine cnrLine;
// 	if (!GetCornerPtMap(ptRef,mapPt,cnrLine))
// 		return;
// 
// 	AcGePoint3d ptS = cnrLine.pair.first;
// 	AcGePoint3d ptE = cnrLine.pair.second;
// 
// 	AcGePoint3d ptLoc;
// 	OPENOBJ_BEGIN(idNode, AcDb::kForRead, TDbPipeNode, pNode);
// 	if(pNode)
// 	{
// 		ptLoc = pNode->GetLocation();
// 	}
// 	OPENOBJ_END();
// 
// 	AcDbLine line(ptS,ptE);
// 	AcGePoint3d ptT;
// 	line.getClosestPointTo(ptLoc,ptT,Adesk::kTrue);
// 
// 	AcGeVector3d vtHor = ptE - ptS;
// 	AcGeVector3d vtVer = ptLoc - ptT;
// 	vtVer.normalize();
// 	vtHor.normalize();
// 
// 	ptS += vtHor * MINDIST;
// 	ptE -= vtHor * MINDIST;
// 
// 
// 	DrawBracketsFun(vtHor,vtVer,ptS,ptE,arBracket);
}

// 得到指定连接点的拐角点组
BOOL TDbCableTrench::GetCornerPtMap(const AcGePoint3d& ptRef,AcArray<CornerLine>& mapPt,CornerLine& temOut) const
{
	if (mapPt.length() < 1)
		return FALSE;

	AcGePoint3d ptT;
	for (int i = 0;i < mapPt.length();i++)
	{
		temOut = mapPt[i];
		ptT = temOut.pair.first;
		if (ptT.distanceTo(ptRef) < 1e-3)
		{
			return TRUE;
		}
		ptT = temOut.pair.second;
		if (ptT.distanceTo(ptRef) < 1e-3)
		{
			return TRUE;
		}
	}

	return FALSE;
}

// 绘制支架
void TDbCableTrench::DrawBracketsFun(const AcGeVector3d& vtHor,const AcGeVector3d& vtVer,const AcGePoint3d& ptStart,const AcGePoint3d& ptEnd,AcArray<XCurveSegment, AcArrayObjectCopyReallocator<XCurveSegment> >& arBracket) const
{
	double dLen = ptStart.distanceTo(ptEnd);

	DrawBracketsFun(vtHor,vtVer,ptStart,dLen,arBracket);
}

void TDbCableTrench::DrawBracketsFun(const AcGeVector3d& vtHor,const AcGeVector3d& vtVer,const AcGePoint3d& ptStart,double dLen,AcArray<XCurveSegment, AcArrayObjectCopyReallocator<XCurveSegment> >& arBracket) const
{	
	double dBLen = m_dBracketLen;
	if (m_nBracketMode == eGCover)
		dBLen = m_nWidth;
	XCurveSegment segTemp;
	AcGePoint3d ptT = ptStart,pt2;
	double dT = 0.0;
	while (TRUE)
	{
		dT = ptT.distanceTo(ptStart);
		if (dT < dLen)
		{
			pt2 = ptT + vtVer * dBLen;
			segTemp.SetPoints(ptT,pt2);
			arBracket.append(segTemp);
		}
		else
		{
			break;
		}
		ptT += vtHor * m_dBracketDis;
	}
}

Acad::ErrorStatus 
TDbCableTrench::ExplodeOrDraw3d(XExplodeDraw &dc) const
{
	//得到电缆沟两端节点
	//得到方沟两端节点
	AcDbObjectId idNode1(NULL), idNode2(NULL);
	AcDbObjectIdArray arIds;
    idNode1 = GetNode(0);
    idNode2 = GetNode(1);

	if (!idNode1.isValid() || !idNode2.isValid())
	{
		return Acad::eInvalidInput;
	}

	arIds.append(idNode1);
	arIds.append(idNode2);
	
	AcGePoint3d pt1,pt2,pt3,pt4,ptS,ptE;
	
	XCurveSegment cvHide,segUp, segDown;
	cvHide = GetCurve();
	XDirectionCurve segDir(cvHide.StartPoint(), cvHide.EndPoint(), cvHide.GetBulge());
	segUp = segDir.Offset(m_nWidth/2, LS_FINITE);
	segDown = segDir.Offset(-m_nWidth/2, LS_FINITE);
	pt1 = segUp.StartPoint();
	pt3 = segUp.EndPoint();
	pt2 = segDown.StartPoint();
	pt4 = segDown.EndPoint();
	ptS = cvHide.StartPoint();
	ptE = cvHide.EndPoint();
	
	double dW = m_nWidth;
	double dH = m_nHeight;
	
	AcGeVector3d vtNorm = AcGeVector3d::kZAxis;
	AcGeVector3d vtDir = pt3 - pt1;
	AcArray<CornerLine> map;
	if (!vtDir.isPerpendicularTo(AcGeVector3d::kZAxis))
	{	
		AcGeVector3d vtT = vtDir.orthoProject(AcGeVector3d::kZAxis);
		vtT.rotateBy(PI/2,AcGeVector3d::kZAxis);
		AcGeVector3d vtT2 =  vtDir.crossProduct(vtT);
		vtNorm = vtT2;
		vtNorm.normalize();
	}
	else
	{
		//分别得到方沟的一端上两点
		GetCannalPts(idNode1,pt1,pt2);
		GetCannalPts(idNode2,pt3,pt4);
	}
	


	// 下降电缆沟
	double dDeep = GetHeight();
	
	pt1 -= vtNorm * dDeep;
	pt2 -= vtNorm * dDeep;
	pt3 -= vtNorm * dDeep;
	pt4 -= vtNorm * dDeep;
	ptS -= vtNorm * dDeep;
	ptE -= vtNorm * dDeep;

	AcGePoint3d *pVerList = NULL;
	
	int nRow = 0;
	int nCol = 0;
	
	nRow = 5;
	nCol = 2;
	pVerList = new AcGePoint3d[nRow*nCol];
	if (pVerList != NULL)
	{
		pVerList[0] = pt1 + m_nHeight*vtNorm;
		pVerList[1] = pt3 + m_nHeight*vtNorm;
		pVerList[2] = pt1;
		pVerList[3] = pt3;
		pVerList[4] = ptS;
		pVerList[5] = ptE;
		pVerList[6] = pt2;
		pVerList[7] = pt4;
		pVerList[8] = pt2 + m_nHeight*vtNorm;
		pVerList[9] = pt4 + m_nHeight*vtNorm;

		dc.DrawMesh(nRow, nCol, pVerList,NULL);
		
		delete []pVerList;
	}

	return Acad::eOk;
}

//宽度
void TDbCableTrench::SetGougeWidth(double dWidth)
{
	SetWidth(dWidth);
}

//高度
void TDbCableTrench::SetGougeHeight(double dHeight)
{
	assertWriteEnabled();
	SetHeight(dHeight);
}

//倒角半径
void TDbCableTrench::SetCornerRadius(double dRadius)
{
	assertWriteEnabled();
	SetSpare(dRadius);
}

//电缆沟线宽
void TDbCableTrench::SetGougeLineWidth(double dLineW)
{
	assertWriteEnabled();
	m_dGougeLineW = dLineW;
}

//电缆沟支架形式
void TDbCableTrench::SetGougeMode(Adesk::UInt16 nType)
{
	assertWriteEnabled();
	m_nBracketMode = nType;
}

//支架长度
void TDbCableTrench::SetBracketLen(double dLen)
{
	assertWriteEnabled();
	m_dBracketLen = dLen;
}

//支架间距
void TDbCableTrench::SetBracketDis(double dDis)
{
	assertWriteEnabled();
	m_dBracketDis = dDis;
}

//支架线宽
void TDbCableTrench::SetBracketLineWidth(double dLineW)
{
	assertWriteEnabled();
	m_dBracketLineW = dLineW;
}

//宽度
double TDbCableTrench::GetGougeWidth()
{
	return GetWidth();
}

//高度
double TDbCableTrench::GetGougeHeight()
{
	return GetHeight();
}

//电缆沟线宽
double TDbCableTrench::GetGougeLineWidth()
{
	return m_dGougeLineW;
}

//电缆沟支架形式
Adesk::UInt16    TDbCableTrench::GetGougeMode()
{
	return m_nBracketMode;
}

//支架长度
double TDbCableTrench::GetBracketLen()
{
	return m_dBracketLen;
}

//支架间距
double TDbCableTrench::GetBracketDis()
{
	return m_dBracketDis;
}

//支架线宽
double TDbCableTrench::GetBracketLineWidth()
{
	return m_dBracketLineW;
}

//拐角类别
void TDbCableTrench::SetCornerType(Adesk::UInt16 nType)
{
	assertWriteEnabled();

	switch(nType)
	{
	case 0:
		SetCanalType(Canal_Corner1);
		break;
	case 1:
		SetCanalType(Canal_Corner3);
		break;
	case 2:
		SetCanalType(Canal_Corner2);
		break;	
	default:
		break;
	}
}

Adesk::UInt16 TDbCableTrench::GetCornerType()
{
	Adesk::UInt16 nType = GetCanalType();

	switch(nType)
	{
	case Canal_Corner1:
		nType = 0;
		break;
	case Canal_Corner2:
		nType = 2;
		break;
	case Canal_Corner3:
		nType = 1;
		break;
	default:
		break;
	}

	return nType;
}

//倒角半径
double TDbCableTrench::GetCornerRadius() const
{
	return GetSpare();
}


Acad::ErrorStatus 
TDbCableTrench::subGetOsnapPoints(AcDb::OsnapMode	   osnapMode,
							 INT_PTR               gsSelectionMark,
							 const AcGePoint3d&    ptPick,
							 const AcGePoint3d&    lastPoint,
							 const AcGeMatrix3d&   viewXform,
							 AcGePoint3dArray&     snapPoints,
							 AcDbIntArray&         geomIds) const
{
	switch(osnapMode)
	{
	case AcDb::kOsModeEnd:
		{
			AcDbObjectId idNode1(NULL), idNode2(NULL);
			
			idNode1 = GetNode(0);
			idNode2 = GetNode(1);

			if (idNode1.isValid() && idNode2.isValid())
			{
				AcGePoint3d pt1,pt2,pt3,pt4;
				//分别得到电缆沟的一端上两点
				AcArray<CornerLine> map1,map2;
				GetCannalPts(idNode1,pt1,pt2,map1);
				GetCannalPts(idNode2,pt3,pt4,map2);

				snapPoints.append(pt1);
				snapPoints.append(pt2);
				snapPoints.append(pt3);
				snapPoints.append(pt4);
				snapPoints.append(StartPoint());
				snapPoints.append(EndPoint());
			}
			
			break;
		}
		
	case AcDb::kOsModeMid:
		{
			AcDbObjectId idNode1(NULL), idNode2(NULL);
			
			idNode1 = GetNode(0);
			idNode2 = GetNode(1);
			
			if (idNode1.isValid() && idNode2.isValid())
			{
				AcGePoint3d ptMid = Mid(GetStartPoint(),GetEndPoint());
				snapPoints.append(ptMid);
				if (!IsHasMorePipes(idNode1))
				{
					OPENOBJ_BEGIN(idNode1, AcDb::kForRead, TDbPipeNode, pNode);
					if(pNode)
					{
						ptMid = pNode->GetLocation();
						snapPoints.append(ptMid);
					}
					OPENOBJ_END();
				}
				if (!IsHasMorePipes(idNode2))
				{
					OPENOBJ_BEGIN(idNode2, AcDb::kForRead, TDbPipeNode, pNode);
					if(pNode)
					{
						ptMid = pNode->GetLocation();
						snapPoints.append(ptMid);
					}
					OPENOBJ_END();
				}
			}

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

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

			break;
		}
		
	case AcDb::kOsModeNode: 
		break;
	}

	return Acad::eOk;
}

// 获取垂足点
BOOL TDbCableTrench::GetVerticalFootPoint(const AcGePoint3d& pickPoint,const AcGePoint3d& lastPoint,AcGePoint3d& ptVerFoot) const
{
	AcDbObjectId idNode1(NULL), idNode2(NULL);
	
    idNode1 = GetNode(0);
    idNode2 = GetNode(1);

	if (!idNode1.isValid() || !idNode2.isValid())
	{
		return FALSE;
	}
	
	AcGePoint3d pt1,pt2,pt3,pt4;
	//分别得到电缆沟的一端上两点
	AcArray<CornerLine> map1,map2;
	GetCannalPts(idNode1,pt1,pt2,map1);
	GetCannalPts(idNode2,pt3,pt4,map2);
	AcArray<AcDbLine*> cplCurve;
	AcDbLine *pLine = NULL;
	
	if (!IsHasMorePipes(idNode1))
	{
		pLine = new AcDbLine;
		pLine->setStartPoint(pt1);
		pLine->setEndPoint(pt2);
		cplCurve.append(pLine);
	}

	pLine = new AcDbLine;
	pLine->setStartPoint(pt1);
	pLine->setEndPoint(pt3);
	cplCurve.append(pLine);

	if (!IsHasMorePipes(idNode2))
	{
		pLine = new AcDbLine;
		pLine->setStartPoint(pt4);
		pLine->setEndPoint(pt3);
		cplCurve.append(pLine);
	}

	pLine = new AcDbLine;
	pLine->setStartPoint(pt4);
	pLine->setEndPoint(pt2);
	cplCurve.append(pLine);

	for (int t = 0;t < map1.length();t++)
	{
		pLine = new AcDbLine;
		pLine->setStartPoint(map1[t].pair.first);
		pLine->setEndPoint(map1[t].pair.second);
		cplCurve.append(pLine);
	}
	
	for (int j = 0;j < map2.length();j++)
	{
		pLine = new AcDbLine;
		pLine->setStartPoint(map2[j].pair.first);
		pLine->setEndPoint(map2[j].pair.second);
		cplCurve.append(pLine);
	}

	BOOL bFind = FALSE;
	if (cplCurve.length() > 0)
	{
		double dDisToLine = 0.0;
		double dDisOld = 100000.0;
		AcGePoint3d ptOnLine;
		int nIndex = -1;
		
		// 挑选离pick点最近的线
		for (int i = 0;i < cplCurve.length();i++)
		{		
			if (cplCurve[i]->getClosestPointTo(pickPoint, ptOnLine,Adesk::kTrue) == Acad::eOk)
			{
				dDisToLine = pickPoint.distanceTo(ptOnLine);
				if (dDisOld > dDisToLine)
				{
					dDisOld = dDisToLine;
					nIndex = i;
				}
			}
		}
		
		// 找到第一次取的点到该线的垂点
		if (nIndex != -1)
		{		
			if (cplCurve[nIndex]->getClosestPointTo(lastPoint, ptOnLine,Adesk::kTrue) == Acad::eOk)
			{
				ptVerFoot = ptOnLine;
				bFind = TRUE;
			}
		}
	}

	FreeBuffer(cplCurve);

	return bFind;
}

// 获取最近点
BOOL TDbCableTrench::GetNearestPoint(const AcGePoint3d& pickPoint,AcGePoint3d& ptNear) const
{
	AcDbObjectId idNode1(NULL), idNode2(NULL);
	
    idNode1 = GetNode(0);
    idNode2 = GetNode(1);

	if (!idNode1.isValid() || !idNode2.isValid())
	{
		return FALSE;
	}
	
	AcGePoint3d pt1,pt2,pt3,pt4;
	//分别得到电缆沟的一端上两点
	AcArray<CornerLine> map1,map2;
	GetCannalPts(idNode1,pt1,pt2,map1);
	GetCannalPts(idNode2,pt3,pt4,map2);
	AcArray<AcDbLine*> cplCurve;
	AcDbLine *pLine = NULL;

	if (!IsHasMorePipes(idNode1))
	{
		pLine = new AcDbLine;
		pLine->setStartPoint(pt1);
		pLine->setEndPoint(pt2);
		cplCurve.append(pLine);
	}
	
	pLine = new AcDbLine;
	pLine->setStartPoint(pt1);
	pLine->setEndPoint(pt3);
	cplCurve.append(pLine);
	
	if (!IsHasMorePipes(idNode2))
	{
		pLine = new AcDbLine;
		pLine->setStartPoint(pt4);
		pLine->setEndPoint(pt3);
		cplCurve.append(pLine);
	}
	
	pLine = new AcDbLine;
	pLine->setStartPoint(pt4);
	pLine->setEndPoint(pt2);
	cplCurve.append(pLine);

	for (int t = 0;t < map1.length();t++)
	{
		pLine = new AcDbLine;
		pLine->setStartPoint(map1[t].pair.first);
		pLine->setEndPoint(map1[t].pair.second);
		cplCurve.append(pLine);
	}

	for (int j = 0;j < map2.length();j++)
	{
		pLine = new AcDbLine;
		pLine->setStartPoint(map2[j].pair.first);
		pLine->setEndPoint(map2[j].pair.second);
		cplCurve.append(pLine);
	}

	BOOL bFind = FALSE;
	if (cplCurve.length() > 0)
	{
		double dDisToLine = 0.0;
		double dDisOld = 100000.0;
		AcGePoint3d ptOnLine;
		// 挑选离pick点最近的线

		for (int i = 0;i < cplCurve.length();i++)
		{			
			if (cplCurve[i]->getClosestPointTo(pickPoint, ptOnLine) == Acad::eOk)
			{
				dDisToLine = pickPoint.distanceTo(ptOnLine);
				if (dDisOld > dDisToLine)
				{
					dDisOld = dDisToLine;
					ptNear = ptOnLine;
					bFind = TRUE;
				}
			}
		}
	}

	FreeBuffer(cplCurve);

	return bFind;
}

// 释放内存
void TDbCableTrench::FreeBuffer(AcArray<AcDbLine*>& cplCurve) const
{
	for (int i = 0;i < cplCurve.length();i++)
	{
		delete cplCurve[i];
	}
}

//电缆编号
void TDbCableTrench::SetTrenchNo(LPCTSTR lpNo)
{
	if (lpNo != NULL)
		m_sTrenchNo = lpNo;
}

//得到电缆编号
void TDbCableTrench::GetTrenchNo(CString &sNo)
{
	sNo = m_sTrenchNo;
}

CString TDbCableTrench::GetXml(const AcGeMatrix3d& mat) const
{
	CString csXml;
	int nValue(0);
	double dValue(0.0);
	int nSizePreci(3), nPtPreci(6);	// 尺寸、位置精度

	TXmlTree xmlTree;
	CString csText;
	CString csX, csY, csZ;

	AcDbObjectId idNode1(NULL), idNode2(NULL);
	AcDbObjectIdArray arIds;
	idNode1 = GetNode(0);
	idNode2 = GetNode(1);

	if (!idNode1.isValid() || !idNode2.isValid())
	{
		return csXml;
	}

	arIds.append(idNode1);
	arIds.append(idNode2);

	AcGePoint3d pt1,pt2,pt3,pt4,ptS,ptE;

	XCurveSegment cvHide,segUp, segDown;
	cvHide = GetCurve();
	XDirectionCurve segDir(cvHide.StartPoint(), cvHide.EndPoint(), cvHide.GetBulge());
	segUp = segDir.Offset(m_nWidth/2, LS_FINITE);
	segDown = segDir.Offset(-m_nWidth/2, LS_FINITE);
	pt1 = segUp.StartPoint();
	pt3 = segUp.EndPoint();
	pt2 = segDown.StartPoint();
	pt4 = segDown.EndPoint();
	ptS = cvHide.StartPoint();
	ptE = cvHide.EndPoint();

	double dW = m_nWidth;
	double dH = m_nHeight;

	AcGeVector3d vtNorm = AcGeVector3d::kZAxis;
	AcGeVector3d vtDir = pt3 - pt1;
	AcArray<CornerLine> map;
	if (!vtDir.isPerpendicularTo(AcGeVector3d::kZAxis))
	{	
		AcGeVector3d vtT = vtDir.orthoProject(AcGeVector3d::kZAxis);
		vtT.rotateBy(PI/2,AcGeVector3d::kZAxis);
		AcGeVector3d vtT2 =  vtDir.crossProduct(vtT);
		vtNorm = vtT2;
		vtNorm.normalize();
	}
	else
	{
		//分别得到方沟的一端上两点
		GetCannalPts(idNode1,pt1,pt2);
		GetCannalPts(idNode2,pt3,pt4);
	}

	// 下降电缆沟
	double dDeep = GetHeight();

	pt1 -= vtNorm * dDeep;
	pt2 -= vtNorm * dDeep;
	pt3 -= vtNorm * dDeep;
	pt4 -= vtNorm * dDeep;
	ptS -= vtNorm * dDeep;
	ptE -= vtNorm * dDeep;

	AcGePoint3d *pVerList = NULL;

	int nRow = 0;
	int nCol = 0;

	nRow = 5;
	nCol = 2;
	pVerList = new AcGePoint3d[nRow*nCol];
	if (pVerList != NULL)
	{
		pVerList[0] = pt1 + m_nHeight*vtNorm;
		pVerList[1] = pt3 + m_nHeight*vtNorm;
		pVerList[2] = pt1;
		pVerList[3] = pt3;
		pVerList[4] = ptS;
		pVerList[5] = ptE;
		pVerList[6] = pt2;
		pVerList[7] = pt4;
		pVerList[8] = pt2 + m_nHeight*vtNorm;
		pVerList[9] = pt4 + m_nHeight*vtNorm;

		POSITION posRoot = xmlTree.Insert(_T("TCH_GOUGE"), NULL, NULL);
		{
			xmlTree.SetAttribute(posRoot, _T("name"), _T("电缆沟"));
			xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
		}
	
		// 点组
		POSITION nowPos;
		for (int i = 0; i<(nRow*nCol); i++)
		{
			CString strName, strCName;
			strName.Format(_T("pt_%d"), i);
			strCName.Format(_T("点_%d"), i);
			nowPos = xmlTree.Insert(strName, posRoot,NULL);
			{
				xmlTree.SetAttribute(nowPos, _T("name"),strCName);
				xmlTree.SetAttribute(nowPos, _T("comment"), strCName);
				AcGePoint3d pt = pVerList[i];
				csX.Format(_T("%.6f"),pt.x);
				csY.Format(_T("%.6f"),pt.y);
				csZ.Format(_T("%.6f"),pt.z);
				csText.Format(_T("%s,%s,%s"),csX,csY,csZ);
				xmlTree.SetItemText(nowPos,csText);
			}
		}
		// 宽度
		nowPos = xmlTree.Insert(_T("Width"),posRoot,NULL);
		{
			xmlTree.SetAttribute(nowPos, _T("name"), _T("宽度"));
			xmlTree.SetAttribute(nowPos, _T("comment"), _T("宽度"));
			csText.Format(_T("%.3f"),m_nWidth);
			xmlTree.SetItemText(nowPos,csText);
		}
		// 高度
		nowPos = xmlTree.Insert(_T("Height"),posRoot,NULL);
		{
			xmlTree.SetAttribute(nowPos, _T("name"), _T("高度"));
			xmlTree.SetAttribute(nowPos, _T("comment"), _T("高度"));
			csText.Format(_T("%.3f"),m_nHeight);
			xmlTree.SetItemText(nowPos,csText);
		}
		// id
		nowPos = xmlTree.Insert(_T("Object_ID"),posRoot,NULL);
		{
			xmlTree.SetAttribute(nowPos, _T("name"), _T("ID"));
			xmlTree.SetAttribute(nowPos, _T("comment"), _T("电缆沟ID"));
			csText.Format(_T("%ld"), objectId().asOldId());
			xmlTree.SetItemText(nowPos, csText);
		}
		delete []pVerList;
	}

	csXml = xmlTree.GetXml();
	int nIndex = -1;
	nIndex = csXml.Find(_T("</TCH_GOUGE>"));
	if (nIndex != -1)
	{
		CString sTemp = TDbCurveEntity::GetXml(mat); 
		csXml.Insert(nIndex, sTemp);
	}

	return csXml;
}

bool TDbCableTrench::GetSection(const AcDbFace &face, const AcGeVector3d &vtPlaneSecDir, 
							   std::vector<TObjSectionRecord> &sectionRecord, AcDbVoidPtrArray& arFillPtrs) const
{
	// 基本参数	
	AcDbObjectId idObj = this->objectId();
	AcDbObjectId idLayer = this->layerId();
	TGGeSectionPlane section_pln(face, vtPlaneSecDir); // 构造一个辅助剖面
	AcDbVoidPtrArray arFaces;
	XExplodeStream dc(arFaces);
	ExplodeOrDraw3d(dc);	

	double dElevation = 0;
	AcDbEntity* pEnt = NULL;
	AcDbFace* pFace = NULL;
	int i = 0;
	for(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() > 0)
			{
				sectionRecord.push_back(TObjSectionRecord(idObj, idLayer, TObjSectionRecord::eTCH_WALL, dElevation, poly));	
			}
		}
		delete pEnt;
	}

	return true;
}

// 剖切用，返回Z坐标最高、最低点
Acad::ErrorStatus TDbCableTrench::GetExtents(TADSGePoint3d &ptLow, TADSGePoint3d &ptUp) const
{
	AcDbObjectId idNode1(NULL), idNode2(NULL);
	AcDbObjectIdArray arIds;
	idNode1 = GetNode(0);
	idNode2 = GetNode(1);

	if (!idNode1.isValid() || !idNode2.isValid())
	{
		return Acad::eInvalidInput;
	}

	arIds.append(idNode1);
	arIds.append(idNode2);

	AcGePoint3d pt1,pt2,pt3,pt4,ptS,ptE;

	XCurveSegment cvHide,segUp, segDown;
	cvHide = GetCurve();
	ptUp = cvHide.StartPoint();
	ptLow = ptUp;
	ptLow.z -= m_nHeight;
	return Acad::eOk;
}

int TDbCableTrench::GetBodyBox(AcDbExtents& ext)
{
	//得到电缆沟两端节点
	//得到方沟两端节点
	AcDbObjectId idNode1(NULL), idNode2(NULL);
	AcDbObjectIdArray arIds;
	idNode1 = GetNode(0);
	idNode2 = GetNode(1);

	if (!idNode1.isValid() || !idNode2.isValid())
	{
		return Acad::eInvalidInput;
	}

	arIds.append(idNode1);
	arIds.append(idNode2);

	AcGePoint3d pt1,pt2,pt3,pt4,ptS,ptE;

	XCurveSegment cvHide,segUp, segDown;
	cvHide = GetCurve();
	XDirectionCurve segDir(cvHide.StartPoint(), cvHide.EndPoint(), cvHide.GetBulge());
	segUp = segDir.Offset(m_nWidth/2, LS_FINITE);
	segDown = segDir.Offset(-m_nWidth/2, LS_FINITE);
	pt1 = segUp.StartPoint();
	pt3 = segUp.EndPoint();
	pt2 = segDown.StartPoint();
	pt4 = segDown.EndPoint();
	ptS = cvHide.StartPoint();
	ptE = cvHide.EndPoint();

	double dW = m_nWidth;
	double dH = m_nHeight;

	AcGeVector3d vtNorm = AcGeVector3d::kZAxis;
	AcGeVector3d vtDir = pt3 - pt1;
	AcArray<CornerLine> map;
	if (!vtDir.isPerpendicularTo(AcGeVector3d::kZAxis))
	{	
		AcGeVector3d vtT = vtDir.orthoProject(AcGeVector3d::kZAxis);
		vtT.rotateBy(PI/2,AcGeVector3d::kZAxis);
		AcGeVector3d vtT2 =  vtDir.crossProduct(vtT);
		vtNorm = vtT2;
		vtNorm.normalize();
	}
	else
	{
		//分别得到方沟的一端上两点
		GetCannalPts(idNode1,pt1,pt2);
		GetCannalPts(idNode2,pt3,pt4);
	}

	// 下降电缆沟
	double dDeep = GetHeight();

	pt1 -= vtNorm * dDeep;
	pt2 -= vtNorm * dDeep;
	pt3 -= vtNorm * dDeep;
	pt4 -= vtNorm * dDeep;
	ptS -= vtNorm * dDeep;
	ptE -= vtNorm * dDeep;
/*
	AcGePoint3d *pVerList = NULL;

	int nRow = 0;
	int nCol = 0;

	nRow = 5;
	nCol = 2;
	pVerList = new AcGePoint3d[nRow*nCol];
	*/

	AcGePoint3d		pVerList[10];

	pVerList[0] = pt1 + m_nHeight*vtNorm;
	pVerList[1] = pt3 + m_nHeight*vtNorm;
	pVerList[2] = pt1;
	pVerList[3] = pt3;
	pVerList[4] = ptS;
	pVerList[5] = ptE;
	pVerList[6] = pt2;
	pVerList[7] = pt4;
	pVerList[8] = pt2 + m_nHeight*vtNorm;
	pVerList[9] = pt4 + m_nHeight*vtNorm;

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

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

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

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

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

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

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

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

	ext.set(ptMin,ptMax);

	return 1;
}