// TDbPipeCanal.cpp: implementation of the TDbPipeCanal class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "DbPipeCanal.h"
#include <DbCurveMesh.h>
#include <DbPolyMesh.h>
#include "PipeTools.h"
#include "DbFlangeFitting.h"
#include <map>
#include <vector>
#include <Algorithm>
#include "DbCanalFitting.h"

extern void DrawWeight(XExplodeDraw &dc,double dWeight,XCurveSegment &seg,int nColorIndex, double nScale);
// cet 2011.6.27 add
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);
}

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
ACRX_DXF_DEFINE_MEMBERS(ATSPipeCanal, ATSPipe, AcDb::kDHL_CURRENT, 
                        AcDb::kMReleaseCurrent, 1, ATS_PIPECANAL,
						"ATS_PIPECANAL图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
IMPLEMENT_TENTBASE(TDbPipeCanal);
const Adesk::UInt8 TDbPipeCanal::g_nVersion = 1;

TDbPipeCanal::TDbPipeCanal()
{
    m_nWidth = 800;
	m_nHeight = 800;
	m_sSpare = _T("");
	m_nCanalType = Canal_Corner5;
	m_nSpare = 0.0; 
	m_dRate = 0.0;
	m_nCanalType = 0;   
	m_nEntType = 0;    
}

TDbPipeCanal::~TDbPipeCanal()
{

}

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

void TDbPipeCanal::CopyPropertiesFrom(AcDbEntity *pSrc,unsigned gMatchFlag)
{
    assertWriteEnabled();
    TDbPipe::CopyPropertiesFrom(pSrc, gMatchFlag);
    TDbPipeCanal *pPipe = TDbPipeCanal::cast(pSrc);
    if(pPipe) {
        m_nWidth = pPipe->m_nWidth;
        m_nHeight = pPipe->m_nHeight;
		m_nSpare = pPipe->m_nSpare;
		m_dRate = pPipe->m_dRate;
		m_nCanalType = pPipe->m_nCanalType;
		m_nEntType = pPipe->m_nEntType;
		m_sSpare = pPipe->m_sSpare;
		m_idDoteLayer = pPipe->m_idDoteLayer;
    }	
}

Acad::ErrorStatus 
TDbPipeCanal::subGetOsnapPoints(AcDb::OsnapMode	   osnapMode,
                        INT_PTR               gsSelectionMark,
                        const AcGePoint3d&    ptPick,
                        const AcGePoint3d&    lastPoint,
                        const AcGeMatrix3d&   viewXform,
                        AcGePoint3dArray&     snapPoints,
                        AcDbIntArray&         geomIds) const
{
	if(IsVertical() && Is(CURVE_LINE) && GetExplodeMode()==DRAW_2D)  //立管
	{
		XPoint ptMid = MidPoint();
		ptMid.z=0;
		snapPoints.append(ptMid);
	}
	else
	{
				snapPoints.append(StartPoint());
				snapPoints.append(EndPoint());
		XPoint ptMid = MidPoint();
		snapPoints.append(ptMid);
		// 捕捉中线
		XCurveSegment seg = this->GetCurve();
		AcDbCurve *pCurve = seg.AsAcDbCurve();
		if (pCurve != NULL)
		{
			pCurve->getOsnapPoints(osnapMode, gsSelectionMark, ptPick, lastPoint, viewXform, snapPoints, geomIds, viewXform);
			delete pCurve;
		}
	}
	return Acad::eOk;
}

// 取得所有的夹点
Acad::ErrorStatus 
TDbPipeCanal::subGetGripPoints(AcGePoint3dArray&  gripPoints, AcDbIntArray&  osnapModes, AcDbIntArray&  geomIds) const
{
    assertReadEnabled();
    Acad::ErrorStatus es=Acad::eOk;
//  es=TDbPipe::subGetGripPoints(gripPoints, osnapModes, geomIds); // cet 2010.6.9 del

	// cet 2010.6.9 add 删除标注点夹点
	// TDbPipe::subGetGripPoints
	if(IsVertical() && Is(CURVE_LINE) && GetExplodeMode()==DRAW_2D)  //立管
	{
		XPoint ptMid = MidPoint();
		ptMid.z=0;
		gripPoints.append(ptMid);
	}
	else
	{
		gripPoints.append(StartPoint());
		gripPoints.append(EndPoint());
		XPoint ptMid = MidPoint();
		gripPoints.append(ptMid);
	}

	// TDbPipePrototype::subGetGripPoints
	if(!IsVertical() && g_bSPipeFDir)
	{
		XPoint ptMid = MidPoint();
		double dDir(0);
		if(m_flowDir==TPipeSys::kFromEnd)
			dDir = ads_angle(GetEndPoint(), GetStartPoint());
		else
			dDir = ads_angle(GetStartPoint(), GetEndPoint());
		XPoint p1;
		ads_polar(ptMid, dDir, GetPScale()*2, p1);
		gripPoints.append(p1);
	}
    return es;  
}

// 取得夹点说明
Acad::ErrorStatus TDbPipeCanal::GetGripText(int idx, CString &cs) const
{
    Acad::ErrorStatus es=Acad::eOk;
    es = TDbPipe::GetGripText(idx,cs);
    return es;
}
 

// 从DWG读入数据:
Acad::ErrorStatus 
TDbPipeCanal::dwgInFields(AcDbDwgFiler* pFiler)
{
    assertWriteEnabled();
    
    Acad::ErrorStatus es = TDbPipe::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_nWidth);
    pFiler->readItem(&m_nHeight);
    pFiler->readItem(&m_nSpare);
    pFiler->readItem(&m_idDoteLayer);
	pFiler->readItem(&m_dRate);
    pFiler->readUInt16(&m_nCanalType);
	pFiler->readUInt16(&m_nEntType);
	ReadString(pFiler,m_sSpare);
	
    return pFiler->filerStatus();
}

Acad::ErrorStatus 
TDbPipeCanal::dwgOutFields(AcDbDwgFiler* pFiler) const
{
    assertReadEnabled();
    Acad::ErrorStatus es = TDbPipe::dwgOutFields(pFiler);
    if(es != Acad::eOk) return es;
    
    pFiler->writeItem(g_nVersion);
    pFiler->writeItem(m_nWidth);
    pFiler->writeItem(m_nHeight);
    pFiler->writeItem(m_nSpare);
    pFiler->writeItem(m_idDoteLayer);
	pFiler->writeItem(m_dRate);
	pFiler->writeItem(m_nCanalType);
	pFiler->writeItem(m_nEntType);
	pFiler->writeString(m_sSpare);
    return pFiler->filerStatus();
}


Acad::ErrorStatus 
TDbPipeCanal::dxfInFields(AcDbDxfFiler* pFiler)
{
    assertWriteEnabled();
    Acad::ErrorStatus es=Acad::eOk;
    es=TDbPipe::dxfInFields(pFiler);
    if(es!=Acad::eOk) return es;
    
    if (!pFiler->atSubclassData(_T("TDbPipeCanal"))) {
        return Acad::eBadDxfSequence;
    }
    
    resbuf rb;
    while((es==Acad::eOk) && ((es=pFiler->readResBuf(&rb))==Acad::eOk)) {
        switch (rb.restype) {
        case AcDb::kDxfXReal:
            m_nWidth=rb.resval.rreal;
            break;
        default:
            pFiler->pushBackItem();
            es = Acad::eEndOfFile;
            break;
        }
    }
    if(es!=Acad::eEndOfFile)
        return Acad::eInvalidResBuf;
    
    return pFiler->filerStatus();
}

Acad::ErrorStatus 
TDbPipeCanal::dxfOutFields(AcDbDxfFiler* pFiler) const
{
    Acad::ErrorStatus es=Acad::eOk;
    es=TDbPipe::dxfOutFields(pFiler);
    assert(es==Acad::eOk);
    es=pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbPipeCanal"));
    assert(es==Acad::eOk);
    
    pFiler->writeDouble(AcDb::kDxfXReal, m_nWidth);
    
    return es;
}

void TDbPipeCanal::ResetDrawSpeed()
{
    assertWriteEnabled();
    double dSpeedLength=0, dSpeedSubMid=0;//初始化
    
	if (m_nodeEnd.m_idNode.isValid())
	{
		OPENOBJ_BEGIN(m_nodeEnd.m_idNode,AcDb::kForRead,TDbPipeNode,pNode);
		if(pNode!=NULL) {
			if(pNode->IsHidePipe()) { //是否节点遮挡管线
				double dWidth = pNode->GetWidth(this);
				if (dWidth>1.0E-3) {
					dSpeedLength -= dWidth;
					dSpeedSubMid -= dWidth/2;
				}
			}
		}
		OPENOBJ_END();
	}
    
	if (m_nodeStart.m_idNode.isValid())
	{
		OPENOBJ_BEGIN(m_nodeStart.m_idNode,AcDb::kForRead,TDbPipeNode,pNode);
		if (pNode!=NULL) {
			if (pNode->IsHidePipe()) {
				double dWidth = pNode->GetWidth(this);
				if (dWidth>1.0E-3) {
					dSpeedLength -= dWidth;
					dSpeedSubMid += dWidth/2;
				}
			}
		}
		OPENOBJ_END();
	}
    
    if(fabs(dSpeedLength)>1.0E-3 || fabs(dSpeedSubMid)>1.0E-3) {
        XCurveSegment cv=GetCurve();
        cv.SetElevation(0);//设置为二维，z＝0
        double dLength = cv.GetLength();
        m_dSpeedLength = dLength + dSpeedLength;
        m_dSpeedSubMid = dLength/2 + dSpeedSubMid;
    } else {
        m_dSpeedLength = 0;
        m_dSpeedSubMid = 0;
    }
}


 

// 通过管件附件打断的曲线，二维，z＝0
void TDbPipeCanal::GetBrokenCurves(const XCurveSegment &cv,
                              DList<XCurveSegment> &lstCurve) const
{
	lstCurve.Append(new XCurveSegment(cv));
	return;
}  


// 考虑遮挡的当前曲线，二维，z＝0
void TDbPipeCanal::GetHideCurve(XCurveSegment& cvHide) const
{
    XCurveSegment cvHideTemp=GetCurve();
    cvHideTemp.SetElevation(0);//设置为二维，z＝0
    
    //该为将数据写入数据库加速二维显示速度
    if (fabs(m_dSpeedLength)>1.0E-3 && fabs(m_dSpeedSubMid)>1.0E-3) {
        double dChordLength = cvHideTemp.GetChordLength(m_dSpeedLength);
        XPointDir2d ptSubMid;
        cvHideTemp.Polar(m_dSpeedSubMid,ptSubMid);
        cvHideTemp.GetSubSegment(ptSubMid,dChordLength,cvHide);
        return;
    }
    
    cvHide = cvHideTemp;
}


void  TDbPipeCanal::ExplodeOrDrawPipeCanalCenLine(XExplodeDraw &dc) const
{
	// cet 2016.8.15 add 有盖板不绘制中心线
	if (GetCoverType() != 0)
	{
		return;
	}
	// 判断是否绘制中线 cet 2012.10.11 add
	TDbPsConfig *pConfig = GetDwgPsGlobal(AcDb::kForRead);
	if (pConfig != NULL && !pConfig->IsShowPipeCanalMidLine())
	{
		pConfig->close();
		return;
	}
	else if (pConfig != NULL)
	{
		pConfig->close();
	}

	XCurveSegment cvHide=GetCurve();//二维，z＝0
	
    //绘制中心线
    DList<XCurveSegment> lstCurve;
    GetBrokenCurves(cvHide, lstCurve);
    int nCount = lstCurve.Length();
	//2008－5－28 指定中心线图层，从而改变中心线的线形，这种方法不对，打印的时候仍然是实线
	// SR 修改如下： 读取图层的线形，强制设置dc的线形，同时取消中心线图层
	// 对于炸开，仍然采用图层
	
	if(_tcsicmp(dc.Desc(), XExplodeStream::Descriptor())==0) {  //另存旧版,炸开  2图层
		AcDbObjectId idLayerOld=dc.GetLayerId();
		AcDbObjectId idDoteLayer=m_idDoteLayer;
		if(idDoteLayer.isValid())
			dc.SetLayer(idDoteLayer);
		dc.SetColorLayer(colorIndex(), idDoteLayer);
		for (int i=0; i<nCount; i++) {
			XCurveSegment &seg = *lstCurve[i];
			dc << seg;	
		}
		dc.SetLayer(idLayerOld);
		dc.SetColorLayer(colorIndex(), idLayerOld);
	}
	else{                    //自定义实体   1个图层
		AcDbObjectId idLineTypeOld = dc.GetLineTypeId();
		int iColorOld = dc.GetColor();
		AcDbObjectId idLineType = NULL;

		if (m_idDoteLayer.isValid())
		{
			OPENOBJ_BEGIN(m_idDoteLayer,AcDb::kForRead,AcDbLayerTableRecord,pLayer);
			if(pLayer){
				idLineType = pLayer->linetypeObjectId();
				AcCmColor Color = pLayer->color();
				int iColIdx = Color.colorIndex();
				dc.SetColor(iColIdx);
				dc.SetLineType(idLineType);
			}
			OPENOBJ_END();
		}

		for (int i=0; i<nCount; i++) {
			XCurveSegment &seg = *lstCurve[i];
			dc << seg;	
		}
		dc.SetLineType(idLineTypeOld);
		dc.SetColor(iColorOld);
	}
}

Acad::ErrorStatus 
TDbPipeCanal::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
    Acad::ErrorStatus es=Acad::eOk;
	// 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; 
    }
	//绘制中线
	ExplodeOrDrawPipeCanalCenLine(dc);
	//绘制方沟上线和下线
	ExplodeOrDrawPipeCanal(dc);
    return es;
}


AOLAPI double g_nAcadVer;

Acad::ErrorStatus 
TDbPipeCanal::ExplodeOrDraw3d(XExplodeDraw &dc) const
{ 
	//垂直管线
	XVector3D vtLocation=EndPoint()-StartPoint();
	if(fabs(vtLocation.x)<1.0E-6 && fabs(vtLocation.y)<1.0E-6)  //垂直管线  
	{ 
		return Acad::eOk; 
	}
	//绘制
	Draw3dType(dc);
	return Acad::eOk;
}

 
//取动态属性显示数据
void TDbPipeCanal::GetTips(DList<TObjInfoUnit> &lstInfo) const
{

    if(IsHorizontal()) {
        lstInfo.Append(new TObjInfoUnit(_T("标高"), Dist2Str(GetStartPoint().z)));
    } else {
        lstInfo.Append(new TObjInfoUnit(_T("起点标高"), Dist2Str(GetStartPoint().z)));
        lstInfo.Append(new TObjInfoUnit(_T("终点标高"), Dist2Str(GetEndPoint().z)));
    }
    double nDist=0.0;
    getDistAtPoint(EndPoint(), nDist);
    lstInfo.Append(new TObjInfoUnit(_T("长度"), Dist2Str(nDist)));
    
 
    lstInfo.Append(new TObjInfoUnit(_T("宽度"), Dist2Str(m_nWidth)));
    lstInfo.Append(new TObjInfoUnit(_T("高度"), Dist2Str(m_nHeight)));
 
}
 
 


// 功能: 夹点操作
Acad::ErrorStatus 
TDbPipeCanal::subMoveGripPointsAt(
								   const AcDbIntArray& indices,
								   const AcGeVector3d& offset)
{
    assertWriteEnabled();
	Acad::ErrorStatus es=Acad::eOk;
	int nCount=indices.length();

	
	int idx = indices[0];
	if(idx == 2 && !IsVertical() && Is(CURVE_LINE)){
		es=MoveGSPointsAt(indices,offset,TRUE);
	}
	else
		es=TDbPipePrototype::subMoveGripPointsAt(indices, offset);
	if(es!=Acad::eOk) return es;

 
 
	
	return es;
}

Acad::ErrorStatus 
TDbPipeCanal::MoveGSPointsAt(const AcDbIntArray& indices,
								  const AcGeVector3d& offset,
								  BOOL bGrip)	
{
	Acad::ErrorStatus es=Acad::eOk;
  
	AcGeVector3d vtOffset=offset;
    AcGeMatrix3d mat;
    mat.setToTranslation(vtOffset);

	BOOL bApply=objectId().isValid();
	AcGeVector3d vtPipe(EndPoint() - StartPoint());
    XPoint ptStartOld = StartPoint();
	XPoint ptEndOld = EndPoint();

	Transform(mat, bApply,bGrip);
	
	if(bApply == NULL || !vtOffset.isPerpendicularTo(vtPipe))  //如果平移向量不垂直于管线，就返回
		return es;
	
	//联动修改所接管线
	AcDbObjectId id1 = GetNode(0);
	AcDbObjectId id2 = GetNode(1);

	if (id1.isValid() && id2.isValid())
	{
		OPENOBJ_BEGIN(id1,AcDb::kForRead,TDbPipeNode,pNode);
		if(pNode!=NULL) { // 节点
			if(pNode->IsAutoLiving()){ // 需自动生成的节点
				if(pNode->GetInterfaceNum() == 2){
					XPoint ptLoc = pNode->GetLocation();
					for(int j=0; j<2; j++) { // 接口
						const AcDbObjectId &idPipe=pNode->GetIPipe(j);
						if(idPipe != objectId()) {
							XPoint ptStart, ptEnd;
							OPENOBJ_BEGIN(idPipe,AcDb::kForWrite,TDbPipeCanal,pPipe);
							if(pPipe != NULL && !pPipe->IsVertical()) {
								ptStart = pPipe->StartPoint();
								ptEnd = pPipe->EndPoint();
								
								if(ptLoc == ptStart){
									XPoint ptOffset=ptStart+offset;
									pPipe->SetStartPoint(ptOffset);
								}
								else if(ptLoc == ptEnd){
									XPoint ptOffset=ptEnd+offset;
									pPipe->SetEndPoint(ptOffset);
								}
							}	
							OPENOBJ_END();
						}
					}
				}
			}
		}
		OPENOBJ_END();

		//同上，代码直接COPY
		OPENOBJ_BEGIN(id2,AcDb::kForRead,TDbPipeNode,pNode);
		if(pNode!=NULL) { // 节点
			if(pNode->IsAutoLiving()){ // 需自动生成的节点
				if(pNode->GetInterfaceNum() == 2){
					XPoint ptLoc = pNode->GetLocation();
					
					for(int j=0; j<2; j++) { // 接口
						const AcDbObjectId &idPipe=pNode->GetIPipe(j);
						if(idPipe != objectId()) {
							XPoint ptStart, ptEnd;
							OPENOBJ_BEGIN(idPipe,AcDb::kForWrite,TDbPipeCanal,pPipe);
							if(pPipe != NULL && !pPipe->IsVertical()) {
								ptStart = pPipe->StartPoint();
								ptEnd = pPipe->EndPoint();
								
								if(ptLoc == ptStart){
									XPoint ptOffset=ptStart+offset;
									pPipe->SetStartPoint(ptOffset);
								}
								else if(ptLoc == ptEnd){
									XPoint ptOffset=ptEnd+offset;
									pPipe->SetEndPoint(ptOffset);
								}
							}	
							OPENOBJ_END();
						}
					}
				}
			}
		}
		OPENOBJ_END();
	}	

    return es;
}

//调整方沟位置
void  TDbPipeCanal::ExplodeOrDrawPipeCanal(XExplodeDraw &dc) const
{
//	ExplodeOrDrawCanalType1(dc);
	
	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  TDbPipeCanal::ExplodeOrDrawCanalType1(XExplodeDraw &dc) const
{
//  cet 2016.8.15 modify 重新实现方沟绘制	
// 	//得到方沟两端节点
// 	AcDbObjectId idNode1(NULL), idNode2(NULL);
// 	AcDbObjectIdArray arIds;
//     idNode1 = GetNode(0);
//     idNode2 = GetNode(1);
// 	arIds.append(idNode1);
// 	arIds.append(idNode2);
// 	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_dPipeWeight;
// 	if (g_bPipeWeight) 
// 	{
// 		DrawWeight(dc, dWeight, segUp, colorIndex(), linetypeScale());
// 		DrawWeight(dc, dWeight, segDown, colorIndex(), linetypeScale());
// 	}
// 	else
// 	{
// 		dc << segUp;
// 		dc << segDown;
// 	}
	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);
	// 起点方沟边线连接点
	XPoint pt1 = segUp.StartPoint();
	XPoint pt2 = segDown.StartPoint();
	OPENOBJ_BEGIN(GetNode(0), AcDb::kForRead, TDbPipeFitting, pFitting);
	if (pFitting != NULL)
	{
		TDbCanalFitting fitting(pFitting);
		fitting.IntersectWith(this->objectId(), pt1, pt2);
	}
	OPENOBJ_END();
	// 终点方沟边线连接点
	XPoint pt3 = segUp.EndPoint();
	XPoint pt4 = segDown.EndPoint();
	OPENOBJ_BEGIN(GetNode(1), AcDb::kForRead, TDbPipeFitting, pFitting);
	if (pFitting != NULL)
	{
		TDbCanalFitting fitting(pFitting);
		fitting.IntersectWith(this->objectId(), pt4, pt3);
	}
	OPENOBJ_END();
	segUp.SetPoints(pt1, pt3);
	segDown.SetPoints(pt2, pt4);
	// 设置线型
	AcDbObjectId idLineStyle = GetLinetypeIdFromString(_T("CanalDASH"), database()); // 给排水线型（linetype.dbf中）绘制方沟时已加载
	if (idLineStyle.isNull())
	{
		idLineStyle = InitLineType(_T("DASH"), database());
	}
	AcDbObjectId idOldStyle = dc.GetLineTypeId();
	if (IsBlineDrain() && idLineStyle.isValid()) // 暗沟
	{
		dc.SetLineType(idLineStyle);
	}
	// 线宽
	double dWeight = GetPScale() * m_dPipeWeight;
	if (!IsShowPipeCanalLineWeight(this->database()))
	{
		dWeight = 0.0;
	}
	// 绘制边线
	DrawWeight(dc, dWeight, segUp, colorIndex(), linetypeScale());
	DrawWeight(dc, dWeight, segDown, colorIndex(), linetypeScale());
	// 闭合端点 cet 2018.1.16 add
	if (LinkedPipeCanalNum(0) == 0 && IsClosePipeCancalPointEnd()) // 闭合起点
	{
		XCurveSegment seg(pt1, pt2, 0.0);
		DrawWeight(dc, dWeight, seg, colorIndex(), linetypeScale());
	}
	if (LinkedPipeCanalNum(1) == 0 && IsClosePipeCancalPointEnd()) // 闭合终点
	{
		XCurveSegment seg(pt3, pt4, 0.0);
		DrawWeight(dc, dWeight, seg, colorIndex(), linetypeScale());
	}
	// 恢复线型
	if (IsBlineDrain() && idLineStyle.isValid()) // 暗沟
	{
		dc.SetLineType(idOldStyle);
	}
	// 绘制盖板
	DrawCover(dc, segUp, segDown);
}

void  TDbPipeCanal::ExplodeOrDrawCanalType2(XExplodeDraw &dc) const
{
//  cet 2016.8.15 modify 重新绘制方沟
// 	//得到方沟两端节点
// 	AcDbObjectId idNode1(NULL), idNode2(NULL);
// 	AcDbObjectIdArray arIds;
//     idNode1 = GetNode(0);
//     idNode2 = GetNode(1);
// 	arIds.append(idNode1);
// 	arIds.append(idNode2);
// 	
// 	AcGePoint3d pt1,pt2,pt3,pt4;
// 	//分别得到方沟的一端上两点
// 	AcArray<CornerLine> map1,map2;
// 	GetCannalPts(idNode1,pt1,pt2,map1);
// 	GetCannalPts(idNode2,pt3,pt4,map2);
// 	
// 	double dWeight = GetPScale()*m_dPipeWeight;
// 	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 (m_nCanalType == Canal_Corner4 || m_nCanalType == Canal_Corner5)
// 	//	dAng = -PI/4;
// 	if (g_bPipeWeight) 
// 	{
// 		DrawWeight(dc, dWeight, segUp, colorIndex(), linetypeScale());
// 		DrawWeight(dc, dWeight, segDown, colorIndex(), linetypeScale());
// 		for (int i = 0; i < map1.length(); ++i)
// 		{
// 			XCurveSegment segCorn(map1[i].pair.first,map1[i].pair.second,map1[i].dAng);
// 			DrawWeight(dc, dWeight, segCorn, colorIndex(), linetypeScale());
// 		}
// 		
// 		for (int j = 0; j < map2.length(); ++j)
// 		{
// 			XCurveSegment segCorn(map2[j].pair.first,map2[j].pair.second,map2[j].dAng);
// 			DrawWeight(dc, dWeight, segCorn, colorIndex(), linetypeScale());
// 		}
// 	}
// 	else
// 	{
// 		dc << segUp;
// 		dc << segDown;
// 		for (int i = 0; i < map1.length(); ++i)
// 		{
// 			XCurveSegment segCorn(map1[i].pair.first,map1[i].pair.second,map1[i].dAng);
// 			dc << segCorn;
// 		}
// 		
// 		for (int j = 0; j < map2.length(); ++j)
// 		{
// 			XCurveSegment segCorn(map2[j].pair.first,map2[j].pair.second,map2[j].dAng);
// 			dc << segCorn;
// 		}
// 	}
	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);
	// 起点方沟边线连接点
	int nSLinkedOtherCanalsNum = LinkedPipeCanalNum(0);
	int nELinkedOtherCanalsNum = LinkedPipeCanalNum(1);
	bool bSLinkedOtherCanals = nSLinkedOtherCanalsNum > 0;
	bool bELinkedOtherCanals = nELinkedOtherCanalsNum > 0;
	XPoint pt1 = segUp.StartPoint();
	XPoint pt2 = segDown.StartPoint();
	OPENOBJ_BEGIN(GetNode(0), AcDb::kForRead, TDbPipeFitting, pFitting);
	if (pFitting != NULL)
	{
		TDbCanalFitting fitting(pFitting);
		if (fitting.IntersectWith(this->objectId(), pt1, pt2))
		{
			XPoint pt11 = pt1;
			XPoint pt22 = pt2;
			if (segUp.Is(CURVE_LINE))
			{
				AcGeVector3d vtDir1 = segUp.EndPoint() - segUp.StartPoint();
				AcGeVector3d vtDir2 = segDown.EndPoint() - segDown.StartPoint();
				vtDir1.z = 0.0;
				vtDir2.z = 0.0;
				vtDir1.normalize();
				vtDir2.normalize();
				if (bELinkedOtherCanals && bSLinkedOtherCanals && segUp.GetLength() > m_nSpare * 2 + 0.001 && segDown.GetLength() > m_nSpare * 2 + 0.001 ||  // 两端连接着方沟，倒角半径的2倍应小于曲线长度
					(bSLinkedOtherCanals ^ bELinkedOtherCanals) && segUp.GetLength() > m_nSpare + 0.001 && segDown.GetLength() > m_nSpare + 0.001)          // 一端连接着方沟，倒角半径应大于曲线长度
				{
					pt1 += vtDir1 * m_nSpare;
					pt2 += vtDir2 * m_nSpare;
				}
			} 
			else
			{
				if (bELinkedOtherCanals && bSLinkedOtherCanals && segUp.GetLength() > m_nSpare * 2 + 0.001 && segDown.GetLength() > m_nSpare * 2 + 0.001 ||  // 两端连接着方沟，倒角半径的2倍应小于曲线长度
					(bSLinkedOtherCanals ^ bELinkedOtherCanals) && segUp.GetLength() > m_nSpare + 0.001 && segDown.GetLength() > m_nSpare + 0.001)          // 一端连接着方沟，倒角半径应大于曲线长度
				{
					XArc arcUp = segUp.GetArc();
					XArc arcDown = segDown.GetArc();
					AcGeVector3d vtDirUp = pt1 - arcUp.GetCenterPt();
					AcGeVector3d vtDirDown = pt2 - arcDown.GetCenterPt();
					vtDirUp.normalize();
					vtDirDown.normalize();
					double dAngleUp = m_nSpare / arcUp.GetRadius();
					double dAngleDown = m_nSpare / arcDown.GetRadius();
					vtDirUp.rotateBy(dAngleUp, AcGeVector3d::kZAxis);
					vtDirDown.rotateBy(dAngleDown, AcGeVector3d::kZAxis);
					pt1 = arcUp.GetCenterPt() + vtDirUp * arcUp.GetRadius();
					pt2 = arcDown.GetCenterPt() + vtDirDown * arcDown.GetRadius();
				}
			}
	 		// 样式2和样式3弯头连接时 （端点只和一个方沟有连接）,只有一条边线需要创建倒角半径
			int nRet = NeedModifyInt(0, pFitting);
			if (nRet == 1) 
			{
				pt1 = pt11;
			}
			else if (nRet == 2)
			{ 
				pt2 = pt22;
			}
		}
	}
	OPENOBJ_END();
	// 终点方沟边线连接点
	XPoint pt3 = segUp.EndPoint();
	XPoint pt4 = segDown.EndPoint();
	OPENOBJ_BEGIN(GetNode(1), AcDb::kForRead, TDbPipeFitting, pFitting);
	if (pFitting != NULL)
	{
		TDbCanalFitting fitting(pFitting);
		if (fitting.IntersectWith(this->objectId(), pt4, pt3))
		{
			XPoint pt33 = pt3;
			XPoint pt44 = pt4;
			if (segUp.Is(CURVE_LINE))
			{
				AcGeVector3d vtDir1 = segUp.EndPoint() - segUp.StartPoint();
				AcGeVector3d vtDir2 = segDown.EndPoint() - segDown.StartPoint();
				vtDir1.z = 0.0;
				vtDir2.z = 0.0;
				vtDir1.normalize();
				vtDir2.normalize();
				if (bELinkedOtherCanals && bSLinkedOtherCanals && segUp.GetLength() > m_nSpare * 2 + 0.001 && segDown.GetLength() > m_nSpare * 2 + 0.001 ||  // 两端连接着方沟，倒角半径的2倍应小于曲线长度
					(bSLinkedOtherCanals ^ bELinkedOtherCanals) && segUp.GetLength() > m_nSpare + 0.001 && segDown.GetLength() > m_nSpare + 0.001)          // 一端连接着方沟，倒角半径应大于曲线长度
				{
					pt3 -= vtDir1 * m_nSpare;
					pt4 -= vtDir2 * m_nSpare;
				}
			}
			else
			{
				XArc arcUp = segUp.GetArc();
				XArc arcDown = segDown.GetArc();
				AcGeVector3d vtDirUp = pt3 - arcUp.GetCenterPt();
				AcGeVector3d vtDirDown = pt4 - arcDown.GetCenterPt();
				vtDirUp.normalize();
				vtDirDown.normalize();
				double dAngleUp = m_nSpare / arcUp.GetRadius();
				double dAngleDown = m_nSpare / arcDown.GetRadius();
				vtDirUp.rotateBy(-dAngleUp, AcGeVector3d::kZAxis);
				vtDirDown.rotateBy(-dAngleDown, AcGeVector3d::kZAxis);
				pt3 = arcUp.GetCenterPt() + vtDirUp * arcUp.GetRadius();
				pt4 = arcDown.GetCenterPt() + vtDirDown * arcDown.GetRadius();
			}
			// 样式2和样式3弯头连接时 （端点只和一个方沟有连接）,只有一条边线需要创建倒角半径
			int nRet = NeedModifyInt(1, pFitting);
			if (nRet == 1)
			{
				pt3 = pt33;
			}
			else if (nRet == 2)
			{
				 pt4 = pt44;
			}
		}
	}
	OPENOBJ_END();
	segUp.SetPoints(pt1, pt3);
	segDown.SetPoints(pt2, pt4);
	AcDbObjectId idLineStyle = GetLinetypeIdFromString(_T("CanalDASH"), database()); // 给排水线型（linetype.dbf中）绘制方沟时已加载
	if (idLineStyle.isNull())
	{
		idLineStyle = InitLineType(_T("DASH"), database());
	}
	AcDbObjectId idOldStyle = dc.GetLineTypeId();
	if (IsBlineDrain() && idLineStyle.isValid()) // 暗沟
	{
		dc.SetLineType(idLineStyle);
	}
	double dWeight = GetPScale()*m_dPipeWeight;
	if (!IsShowPipeCanalLineWeight(this->database()))
	{
		dWeight = 0.0;
	}
		DrawWeight(dc, dWeight, segUp, colorIndex(), linetypeScale());
		DrawWeight(dc, dWeight, segDown, colorIndex(), linetypeScale());
	if (IsBlineDrain() && idLineStyle.isValid()) // 暗沟
		{
		dc.SetLineType(idOldStyle);
	}
	// 绘制盖板
	DrawCover(dc, segUp, segDown);
}

//对方沟按逆时针排序
void  TDbPipeCanal::SortPipeCanal(const AcGePoint3d &ptOr,const AcDbObjectIdArray &arIds,AcArray<XCurveSegment, AcArrayObjectCopyReallocator<XCurveSegment> > &arSeg) const
{
	AcDbObjectId idSelf = GetSelfObjectId();
	AcGeMatrix3d mat;
	ads_matrix	 matAds;
	GetOffsetMatrix(idSelf, mat);
	AcArray<XCurveSegment, AcArrayObjectCopyReallocator<XCurveSegment> > arSegSort;
	for (int i = 0; i < arIds.length(); ++i)
	{
		if (idSelf == arIds[i])
		{
			XCurveSegment seg;
			seg = GetCurve();

			XCurveSegment segUp, segDown;
			XDirectionCurve segDir(seg.StartPoint(), seg.EndPoint(), seg.GetBulge());
			segUp = segDir.Offset(GetWidth()/2, LS_FINITE);
			segDown = segDir.Offset(-GetWidth()/2, LS_FINITE);

			arSegSort.append(segUp);
			arSegSort.append(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;
					XDirectionCurve segDir(seg.StartPoint(), seg.EndPoint(), seg.GetBulge());
					segUp = segDir.Offset(pCanal->GetWidth()/2, LS_FINITE);
					segDown = segDir.Offset(-pCanal->GetWidth()/2, LS_FINITE);

					arSegSort.append(segUp);
					arSegSort.append(segDown);
				}
				OPENOBJ_END();
			}
		}
	}

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

	std::sort(vecT.begin(),vecT.end());
	for (UINT k = 0; k < vecT.size(); ++k)
	{
		double dT = vecT[k];
		XCurveSegment seg = map[dT];
		arSeg.append(seg);
	}

	int nLen = arSeg.length();
}

//求排序后方沟的交点
void  TDbPipeCanal::GetInterPts(const AcArray<XCurveSegment, AcArrayObjectCopyReallocator<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].StartPoint() - arSeg[i].EndPoint();
			AcGeVector3d vt2 = arSeg[nNext].StartPoint() - arSeg[nNext].EndPoint();
			if (vt1.isParallelTo(vt2))
				continue;

			AcGePoint3dArray arPtsT;
			AcGePoint3d ptS = arSeg[i].StartPoint();
			AcGePoint3d ptST = arSeg[nNext].StartPoint();
			AcGePoint3d ptE = arSeg[i].EndPoint();
			AcGePoint3d ptET = arSeg[nNext].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的交点
					GetCorner2InterPts(arSeg[i],arSeg[nNext],arPtsT[0],arSeg.length(),arPts,map1);
				}
			}
			else
			{
				if (arSeg.length() == 4)
				{
					//弯头
					AcGePoint3dArray arPtsT;
					AcGePoint3d ptS = arSeg[i].StartPoint();
					AcGePoint3d ptST = arSeg[nNext].StartPoint();
					AcGePoint3d ptE = arSeg[i].EndPoint();
					AcGePoint3d ptET = arSeg[nNext].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);
					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的交点
							GetCorner2InterPts(arSeg[i],arSeg[nNext],arPtsT[0],arSeg.length(),arPts,map1);
						}
					}
				}
			}
		}
	}
}

void  TDbPipeCanal::GetInterPts(const AcArray<XCurveSegment, AcArrayObjectCopyReallocator<XCurveSegment> > &arSeg,AcArray<AcGePoint3d> &arPts) 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].StartPoint() - arSeg[i].EndPoint();
			AcGeVector3d vt2 = arSeg[nNext].StartPoint() - arSeg[nNext].EndPoint();
			if (vt1.isParallelTo(vt2))
				continue;
			
			AcGePoint3dArray arPtsT;
			AcGePoint3d ptS = arSeg[i].StartPoint();
			AcGePoint3d ptST = arSeg[nNext].StartPoint();
			AcGePoint3d ptE = arSeg[i].EndPoint();
			AcGePoint3d ptET = arSeg[nNext].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)
			{
				arPts.append(arPtsT[0]);
			}
			else
			{
				if (arSeg.length() == 4)
				{
					//弯头
					AcGePoint3dArray arPtsT;
					AcGePoint3d ptS = arSeg[i].StartPoint();
					AcGePoint3d ptST = arSeg[nNext].StartPoint();
					AcGePoint3d ptE = arSeg[i].EndPoint();
					AcGePoint3d ptET = arSeg[nNext].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);
					if (line1.intersectWith(&line2,AcDb::kExtendBoth,arPtsT) == Acad::eOk)
					{
						arPts.append(arPtsT[0]);
					}
				}
			}
		}
	}
}

//调整方沟位置
void  TDbPipeCanal::ChangePipeCanalPosition(const AcArray<AcGePoint3d> &arPts,const AcGePoint3d &ptCen,int nSegLen,AcGePoint3d &pt1,AcGePoint3d &pt2) const
{
	double dWeight = GetPScale()*m_dPipeWeight;
	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);
	
	AcDbLine lineUp(segUp.StartPoint(),segUp.EndPoint());
	AcDbLine lineDown(segDown.StartPoint(),segDown.EndPoint());

	if (lineUp.startPoint().distanceTo(ptCen) > lineUp.endPoint().distanceTo(ptCen))
		pt1 = lineUp.endPoint();
	else
		pt1 = lineUp.startPoint();

	if (lineDown.startPoint().distanceTo(ptCen) > lineDown.endPoint().distanceTo(ptCen))
		pt2 = lineDown.endPoint();
	else
		pt2 = lineDown.startPoint();
	
	AcGePoint3d ptS = lineUp.startPoint();
	AcGePoint3d ptST = lineDown.startPoint();
	AcGePoint3d ptE = lineUp.endPoint();
	AcGePoint3d ptET = lineDown.endPoint();

	ptS.z = 0.0;
	ptE.z = 0.0;
	ptST.z = 0.0;
	ptET.z = 0.0;
	lineUp.setStartPoint(ptS);
	lineUp.setEndPoint(ptE);
	lineDown.setStartPoint(ptST);
	lineDown.setEndPoint(ptET);

	for (int i = 0; i < arPts.length(); ++i)
	{
		AcGePoint3d ptNear;
		//交点个数为2,边数为4表示生成弯头
		//交点个数为4表示四通
		AcGePoint3d ptTt = arPts[i];
		switch(m_nCanalType)
		{
		case Canal_Corner1:
			if (arPts.length() == 2 && nSegLen == 4)
				lineUp.getClosestPointTo(arPts[i],ptNear,Adesk::kTrue);
			else
				lineUp.getClosestPointTo(arPts[i],ptNear);
			break;
		case Canal_Corner2:
		case Canal_Corner3:
		case Canal_Corner4:
		case Canal_Corner5:
			if (arPts.length() == 3 && nSegLen == 4)
				lineUp.getClosestPointTo(arPts[i],ptNear,Adesk::kTrue);
			else
				lineUp.getClosestPointTo(arPts[i],ptNear);
			break;
		default:
			break;
		}

		if (arPts[i].distanceTo(ptNear) < 1e-3)
		{
			pt1 = arPts[i];
		}

		switch(m_nCanalType)
		{
		case Canal_Corner1:
			if (arPts.length() == 2 && nSegLen == 4)
				lineDown.getClosestPointTo(arPts[i],ptNear,Adesk::kTrue);
			else
				lineDown.getClosestPointTo(arPts[i],ptNear);
			break;
		case Canal_Corner2:
		case Canal_Corner3:
		case Canal_Corner4:
		case Canal_Corner5:
			if (arPts.length() == 3 && nSegLen == 4)
				lineDown.getClosestPointTo(arPts[i],ptNear,Adesk::kTrue);
			else
				lineDown.getClosestPointTo(arPts[i],ptNear);
			break;
		default:
			break;
		}

		if (arPts[i].distanceTo(ptNear) < 1e-3)
		{
			pt2 = arPts[i];
		}
	}
}

//得到NODE方向方沟两点
void  TDbPipeCanal::GetCannalPts(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<XCurveSegment, AcArrayObjectCopyReallocator<XCurveSegment> > arSeg;
				SortPipeCanal(pNode->GetLocation(),arCanal,arSeg);
				
				//求出排序后线的交点
				AcArray<AcGePoint3d> arPts;
				GetInterPts(arSeg,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  TDbPipeCanal::ChangePipeCanalPosition(const AcDbObjectIdArray& arId,const AcDbObjectId& idNode,const AcGePoint3d& ptNodeLoc,double dLen,AcGePoint3d& pt1,AcGePoint3d& pt2,AcArray<CornerLine> &map1) const
{
	map1.setLogicalLength(0);
	if (arId.length() != 2)
		return;

	AcDbObjectId id1 = GetNode(0);
	AcDbObjectId id2 = GetNode(1);

	if (!id1.isValid() || !id2.isValid())
	{
		return;
	}

	// 处理连接点
	AcGeVector3d vtHor;
	AcGePoint3d ptT;
	if (id1 == idNode)
	{
		OPENOBJ_BEGIN(id2, AcDb::kForRead, TDbPipeNode, pNode);
		if (pNode)
		{
			ptT = pNode->GetLocation();
		}
		OPENOBJ_END();
		vtHor = ptT - ptNodeLoc;
		vtHor.normalize();
		pt1 += vtHor * dLen / 2;
		pt2 += vtHor * dLen / 2;
	}
	else if (id2 == idNode)
	{
		OPENOBJ_BEGIN(id1, AcDb::kForRead, TDbPipeNode, pNode);
		if (pNode)
		{
			ptT = pNode->GetLocation();
		}
		OPENOBJ_END();
		vtHor = ptT - ptNodeLoc;
		vtHor.normalize();
		pt1 += vtHor * dLen / 2;
		pt2 += vtHor * dLen / 2;
	}
	
	// 处理变径的边
	double dWidth = 0.0;
	if (!GetAnotherCanalWidth(ptT,ptNodeLoc,arId,dWidth))
		return;

	AcGeVector3d vtVer = vtHor;
	vtVer.rotateBy(PI / 2,AcGeVector3d::kZAxis);
	vtVer.normalize();

	AcGePoint3d ptT1,ptT2;
	ptT1 = ptNodeLoc - vtVer * dWidth / 2;
	ptT1 -= vtHor * dLen / 2;
	ptT2 = ptNodeLoc + vtVer * dWidth / 2;
	ptT2 -= vtHor * dLen / 2;

	AppendMap(pt1,ptT1,ptT2,map1);
	AppendMap(pt2,ptT1,ptT2,map1);
}

//添加映射
void  TDbPipeCanal::AppendMap(const AcGePoint3d& ptBase,const AcGePoint3d& pt1,const AcGePoint3d& pt2,AcArray<CornerLine> &map1) const
{
	double dLen1 = ptBase.distanceTo(pt1);
	double dLen2 = ptBase.distanceTo(pt2);

	std::pair<AcGePoint3d,AcGePoint3d> pair;
	pair.first = ptBase;
	if (dLen1 > dLen2)
		pair.second = pt2;
	else
		pair.second = pt1;

	CornerLine corner;
	corner.pair = pair;
	corner.dAng = 0.0;
	map1.append(corner);
}

//得到另一个管子的宽度
BOOL  TDbPipeCanal::GetAnotherCanalWidth(const AcGePoint3d& pt1,const AcGePoint3d& pt2,const AcDbObjectIdArray& arId,double& dWidth) const
{
	BOOL bSuc = FALSE;
	AcDbObjectId idT;
	AcGePoint3d ptS,ptE;
	for (int i = 0;i < arId.length();i++)
	{
		if (arId[i].isValid())
		{
			OPENOBJ_BEGIN(arId[i], AcDb::kForRead, TDbPipeCanal, pCanal);
			if (pCanal)
			{
				ptS = pCanal->StartPoint();
				ptE = pCanal->EndPoint();
			}
			OPENOBJ_END();
			if (pt1.distanceTo(ptS) < 1e-3 &&
				pt2.distanceTo(ptE) < 1e-3 )
			{
				idT = arId[i];
				bSuc = TRUE;
				break;
			}
			else if (pt1.distanceTo(ptE) < 1e-3 &&
				pt2.distanceTo(ptS) < 1e-3 )
			{
				idT = arId[i];
				bSuc = TRUE;
				break;
			}
		}
	}

	AcDbObjectId idOther;
	AcDbObjectIdArray arT;
	if (bSuc)
	{
		arT.append(arId);
		arT.remove(idT);

		if (arT.length() > 0)
			idOther = arT[0];
		else
			bSuc = FALSE;
	}

	if (bSuc)
	{
		if (idOther.isValid())
		{
			OPENOBJ_BEGIN(idOther, AcDb::kForRead, TDbPipeCanal, pCanal);
			if (pCanal)
			{
				dWidth = pCanal->m_nWidth;
			}
			OPENOBJ_END();
		}
	}

	return dWidth > 0;
}

//是否创建变径
BOOL  TDbPipeCanal::MakesureCreateReducer(const AcDbObjectIdArray& arId,double& dTotal) const
{
	if (arId.length() != 2)
		return FALSE;

	AcGeVector3d vt1,vt2;
	double dB1 = 0.0,dB2 = 0.0;

	if (arId[0].isValid())
	{
		OPENOBJ_BEGIN(arId[0], AcDb::kForRead, TDbPipeCanal, pCanal);
		if (pCanal)
		{
			dB1 = pCanal->m_nWidth;
			vt1 = pCanal->EndPoint() - pCanal->StartPoint();
			vt1.normalize();
		}
		OPENOBJ_END();
	}

	if (arId[1].isValid())
	{
		OPENOBJ_BEGIN(arId[1], AcDb::kForRead, TDbPipeCanal, pCanal);
		if (pCanal)
		{
			dB2 = pCanal->m_nWidth;
			vt2 = pCanal->EndPoint() - pCanal->StartPoint();
			vt2.normalize();
		}
		OPENOBJ_END();
	}

	if (fabs(dB1-dB2) < 1e-3)//等宽
		return FALSE;
	
	if (!vt1.isParallelTo(vt2))//不平行
		return FALSE;
	
	dTotal = dB1 + dB2;

	return TRUE;
}

void  TDbPipeCanal::GetCannalPts(const AcDbObjectId &id,AcGePoint3d &pt1,AcGePoint3d &pt2) 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<XCurveSegment, AcArrayObjectCopyReallocator<XCurveSegment> > arSeg;
				SortPipeCanal(pNode->GetLocation(),arCanal,arSeg);
				
				//求出排序后线的交点
				AcArray<AcGePoint3d> arPts;
				GetInterPts(arSeg,arPts);
				
				//调整方沟位置
				ChangePipeCanalPositionNor(arPts,pNode->GetLocation(),arSeg.length(),pt1,pt2);
			}
			
		}
		OPENOBJ_END();
	}
}

//过滤掉无用的方沟
/*
BOOL  TDbPipeCanal::FilterCannal(AcDbObjectIdArray &arIds) const
{

	BOOL bFilter = FALSE;
	PickSet ssDel(SS_FREE);
	for (int i = 0; i < arIds.length(); ++i)
	{
		if (arIds[i].isValid())
		{
			OPENOBJ_BEGIN(arIds[i], AcDb::kForRead, TDbPipeCanal, pCanal);
			if (pCanal != NULL)
			{
				XCurveSegment seg1 = pCanal->GetCurve();
				
				for (int j = 0; j < arIds.length(); ++j)
				{
					if (j == i)
						continue;
					OPENOBJ_BEGIN(arIds[j], AcDb::kForRead, TDbPipeCanal, pCanT);
					if (pCanT != NULL)
					{
						XCurveSegment seg2 = pCanT->GetCurve();
						AcGeVector3d vt1 = seg1.StartPoint() - seg1.EndPoint();
						AcGeVector3d vt2 = seg2.StartPoint() - seg2.EndPoint();
						if (!vt1.isParallelTo(vt2))
						{
							XCurveSegment segUp,segDown;
							XDirectionCurve segDir(seg2.StartPoint(), seg2.EndPoint(), seg2.bulge);
							segUp = segDir.Offset(m_nWidth/2, LS_FINITE);
							segDown = segDir.Offset(-m_nWidth/2, LS_FINITE);
							XPoint pt1,pt2;
							
							AcGePoint3dArray arPts;
							AcDbLine line1(seg1.StartPoint(),seg1.EndPoint());
							AcDbLine line2(segUp.StartPoint(),segUp.EndPoint());
							AcDbLine line3(segDown.StartPoint(),segDown.EndPoint());
							line1.intersectWith(&line2,AcDb::kExtendArg,arPts);
							line1.intersectWith(&line3,AcDb::kExtendArg,arPts);
							if (arPts.length() < 1)
							{
								ssDel += arIds[i];
								ssDel += pCanal->GetNode(0);
								ssDel += pCanal->GetNode(1);
								bFilter = TRUE;
							}
							
						}
					}
					OPENOBJ_END();
					
				}
			}
			OPENOBJ_END();
		}
	}

	for (long l = 0; l < ssDel.Length(); ++l)
		ssDel[l].Erase();
	
	return bFilter;
}
*/

//过滤掉无用的方沟
BOOL  TDbPipeCanal::FilterCannal(AcDbObjectIdArray &arIds) const
{	
	BOOL bFilter = FALSE;
	PickSet ssDel(SS_FREE);
	double dB = 0.0;
	for (int i = 0; i < arIds.length(); ++i)
	{
		if (arIds[i].isValid())
		{
			OPENOBJ_BEGIN(arIds[i], AcDb::kForRead, TDbPipeCanal, pCanal);
			if (pCanal != NULL)
			{
				XCurveSegment seg1 = pCanal->GetCurve();
				dB = pCanal->GetWidth();
				if (seg1.GetLength() < dB/2)
				{
					ssDel += pCanal->objectId();
					ssDel += pCanal->GetNode(0);
					ssDel += pCanal->GetNode(1);
					bFilter = TRUE;
				}
			
			}
			OPENOBJ_END();
		}
	}
	
	for (long l = 0; l < ssDel.Length(); ++l)
		ssDel[l].Erase();
	
	return bFilter;
}

//得到类型2的交点
void  TDbPipeCanal::GetCorner2InterPts(const XCurveSegment &seg1,const XCurveSegment &seg2,const AcGePoint3d &pt,int nSegCount,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+m_nSpare-m_nWidth*tan(PI/8));
	else
		ptIns1 = pt - vtDir1*m_nSpare; 
	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+m_nSpare-m_nWidth*tan(PI/8));
	else
		ptIns2 = pt - vtDir2*m_nSpare; 
	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  TDbPipeCanal::ChangePipeCanalPositionNor(const AcArray<AcGePoint3d> &arPts,const AcGePoint3d &ptCen,int nSegLen,AcGePoint3d &pt1,AcGePoint3d &pt2) const
{
	double dWeight = GetPScale()*m_dPipeWeight;
	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);
	
	AcDbLine lineUp(segUp.StartPoint(),segUp.EndPoint());
	AcDbLine lineDown(segDown.StartPoint(),segDown.EndPoint());
	
	if (lineUp.startPoint().distanceTo(ptCen) > lineUp.endPoint().distanceTo(ptCen))
		pt1 = lineUp.endPoint();
	else
		pt1 = lineUp.startPoint();
	
	if (lineDown.startPoint().distanceTo(ptCen) > lineDown.endPoint().distanceTo(ptCen))
		pt2 = lineDown.endPoint();
	else
		pt2 = lineDown.startPoint();
	
	AcGePoint3d ptS = lineUp.startPoint();
	AcGePoint3d ptST = lineDown.startPoint();
	AcGePoint3d ptE = lineUp.endPoint();
	AcGePoint3d ptET = lineDown.endPoint();
	
	ptS.z = 0.0;
	ptE.z = 0.0;
	ptST.z = 0.0;
	ptET.z = 0.0;
	lineUp.setStartPoint(ptS);
	lineUp.setEndPoint(ptE);
	lineDown.setStartPoint(ptST);
	lineDown.setEndPoint(ptET);
	
	for (int i = 0; i < arPts.length(); ++i)
	{
		AcGePoint3d ptNear;
		//交点个数为2,边数为4表示生成弯头
		//交点个数为4表示四通

		if (arPts.length() == 2 && nSegLen == 4)
			lineUp.getClosestPointTo(arPts[i],ptNear,Adesk::kTrue);
		else
			lineUp.getClosestPointTo(arPts[i],ptNear);
		
		if (arPts[i].distanceTo(ptNear) < 1e-3)
		{
			pt1 = arPts[i];
		}
		
		if (arPts.length() == 2 && nSegLen == 4)
			lineDown.getClosestPointTo(arPts[i],ptNear,Adesk::kTrue);
		else
			lineDown.getClosestPointTo(arPts[i],ptNear);
	
		if (arPts[i].distanceTo(ptNear) < 1e-3)
		{
			pt2 = arPts[i];
		}
	}
}

//设置方沟类型
void  TDbPipeCanal::SetCannalSameType(const AcDbObjectIdArray &arIds) const
{
	for (int i = 0; i < arIds.length(); ++i)
	{
		if (arIds[i].isValid())
		{
			OPENOBJ_BEGIN(arIds[i], AcDb::kForWrite, TDbPipeCanal, pCanal);
			if (pCanal != NULL)
			{
				pCanal->SetCanalType(m_nCanalType);
			}
			OPENOBJ_END();
		}
	}
}

//////////////////////////////////////////////////////////////////////////

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

AcDbObjectId TDbPipeCanal::GetSelfObjectId() const
{
	AcDbObjectId idSelf = objectId();
	if (idSelf.isValid())
	{
		return idSelf;
	}

	//挑选
	AcDbObjectIdArray arNode1,arNode2;
	AcDbObjectId idNode = GetNode(0);

	OPENOBJ_BEGIN(idNode, AcDb::kForRead, TDbPipeNode, pNode);
	if (pNode != NULL)
	{
		AcDbObjectId id;
		for (int i = 0; i < pNode->GetInterfaceNum(); ++i)
		{
			id = pNode->GetIPipe(i);
			arNode1.append(id);
		}
	}
	OPENOBJ_END();

	if (arNode1.length() == 1)
	{
		idSelf = arNode1.first();
		return idSelf;
	}

	idNode = GetNode(1);
	OPENOBJ_BEGIN(idNode, AcDb::kForRead, TDbPipeNode, pNode);
	if (pNode != NULL)
	{
		AcDbObjectId id;
		for (int i = 0; i < pNode->GetInterfaceNum(); ++i)
		{
			id = pNode->GetIPipe(i);
			arNode2.append(id);
		}
	}
	OPENOBJ_END();

	if (arNode2.length() == 1)
	{
		idSelf = arNode2.first();
		return idSelf;
	}

	for (int j = 0;j < arNode1.length();++j)
	{
		for (int p = 0;p < arNode2.length();++p)
		{
			if (arNode1[j] == arNode2[p])
			{
				idSelf = arNode1[j];
				return idSelf;
			}
		}
	}

	return idSelf;
}

void TDbPipeCanal::GetOffsetMatrix(const AcDbObjectId& id, AcGeMatrix3d& matOffset) const
{
	matOffset.setToIdentity();
	if (id.isValid())
	{
		OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipeCanal, pPipe);
		if (pPipe != NULL)
		{
			XCurveSegment seg,segSelf;
			seg = pPipe->GetCurve();
			segSelf = GetCurve();

			AcGeVector3d vt = segSelf.MidPoint() - seg.MidPoint();
			matOffset.setToTranslation(vt);
		}
		OPENOBJ_END();
	}
}


// 获取指定端坐标
XPoint TDbPipeCanal::GetVertexPt(const TPipeSys::PtLoction nSide) const
{
	XPoint pt(GetStartPoint());
	if (nSide == TPipeSys::kEndPt)
	{
		pt = EndPoint();
	}
	return pt;
}

Acad::ErrorStatus TDbPipeCanal::subTransformBy(const AcGeMatrix3d& xform)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = TDbPipe::subTransformBy(xform);

	//在transform的时候不停的打开对象，一次命令中以读方式打开超过256次，出现崩溃错误，加次判断条件，jig拖动结束时处理对象更新
	if (!acedIsDragging())
	{
		BOOL bApplyToNode(TRUE); // 是否提供变化给节点

		XString &sCmd = GetCurDocData()->m_sCurCommand;
		if (_tcsicmp(sCmd, _T("MIRROR"))==0 || _tcsicmp(sCmd, _T("COPY"))==0 ||
			_tcsicmp(sCmd, _T("COPYCLIP"))==0 || _tcsicmp(sCmd, _T("PASTECLIP"))==0)
		{
			bApplyToNode = FALSE; // 管线的复制、镜像操作，不提供变化给节点
		}

		if (!bApplyToNode)
		{
			return es;
		}

		AcDbObjectId idNode;
		for (int i = 0;i < 2;++i)
		{
			idNode = GetNode(i);
			if (idNode.isValid())
			{
				TPipeSys::PtLoction nSide = (TPipeSys::PtLoction)i;
				XPoint ptSide = GetVertexPt(nSide);


				OPENOBJ_BEGIN(GetNode(i), AcDb::kForRead, TDbPipeFitting, pFit);
				if (pFit != NULL)
				{
					if (pFit->upgradeOpen() == Acad::eOk)
					{
						// 更新节点
						pFit->SetLocation(ptSide); // 修改m_ptLocation
						for (int p = 0;p < pFit->GetInterfaceNum();++p)
						{
							pFit->SetILocation(p,ptSide);
						}

						pFit->downgradeOpen();
					}
				}
				OPENOBJ_END();
			}
		}
	}


	return es;
}

Acad::ErrorStatus TDbPipeCanal::subGetTransformedCopy(const AcGeMatrix3d& xform,
										AcDbEntity*& pEnt) const
{
	assertReadEnabled();

	pEnt = new TDbPipeCanal;
	pEnt->copyFrom(this);
	pEnt->transformBy(xform);
	return Acad::eOk;
}


// 增加Node的wbclone
Acad::ErrorStatus TDbPipeCanal::subWblockClone(AcRxObject*    pOwner,
								 AcDbObject*&   pClonedObject,
								 AcDbIdMapping& idMap,
								 Adesk::Boolean isPrimary) const
{
	Acad::ErrorStatus es=TDbPipe::subWblockClone(pOwner, pClonedObject, idMap, isPrimary);
	if(es!=Acad::eOk)
		return es;

	es=subSubWblockClone(m_nodeStart.m_idNode,pOwner, pClonedObject, idMap, isPrimary);
	es=subSubWblockClone(m_nodeEnd.m_idNode,pOwner, pClonedObject, idMap, isPrimary);

	return Acad::eOk;
}

Acad::ErrorStatus TDbPipeCanal::subSubWblockClone(const AcDbObjectId& idCloning,
												AcRxObject*    pOwner,
												AcDbObject*&   pClonedObject,
												AcDbIdMapping& idMap,
												Adesk::Boolean isPrimary) const
{
	Acad::ErrorStatus es = Acad::eInvalidInput;
	if (!idCloning.isValid())
		return es;

	AcDbIdPair idPairOpening(idCloning, (AcDbObjectId)NULL,false, isPrimary? true : false);
	if (idMap.compute(idPairOpening))
		return es;    

	AcDbObject *pSubObject=NULL;
	AcDbObject *pClonedSubObject=NULL;
	if (acdbOpenAcDbObject(pSubObject, idCloning, AcDb::kForRead) == Acad::eOk)
	{
		es = pSubObject->wblockClone(pOwner,pClonedSubObject,idMap, isPrimary);
		pSubObject->close();

		if (es == Acad::eOk)
		{
			pClonedSubObject->close();
		}
	}
	
	return Acad::eOk;
}

// 根据连接点点过滤相连接的方沟
BOOL TDbPipeCanal::IsHasMorePipes(const AcDbObjectId& idNode) const
{
	int num = GetNodeCntPipeNumber(idNode);
	
	if (num > 1)// 有连接
	{
		return FALSE;
	}
	
	return TRUE;
}

// 节点连接的管子个数
int TDbPipeCanal::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;
}

// 获取垂足点
BOOL TDbPipeCanal::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 TDbPipeCanal::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 TDbPipeCanal::FreeBuffer(AcArray<AcDbLine*>& cplCurve) const
{
	for (int i = 0;i < cplCurve.length();i++)
	{
		delete cplCurve[i];
	}
}

void TDbPipeCanal::SetCoverLineWidth(double dLineWidth)
{
	assertWriteEnabled();
	TEntityFields &fd = Fields();
	fd.SFD(_T("COVER_LINEWIDTH"), dLineWidth);
}

double TDbPipeCanal::GetCoverLineWidth() const
{
	assertReadEnabled();
	const TEntityFields &fd = GetFields();
	double dLineWidth = 0.0;
	fd.GFD(_T("COVER_LINEWIDTH"), dLineWidth);
	return dLineWidth;
}

void TDbPipeCanal::SetBlindDrain(bool bVal)
{
	assertWriteEnabled();
	TEntityFields &fd = Fields();
	fd.SFD(_T("BLIND_DRAIN"), bVal ? Adesk::kTrue : Adesk::kFalse);
}

bool TDbPipeCanal::IsBlineDrain() const
{
	assertReadEnabled();
	const TEntityFields &fd = GetFields();
	Adesk::Boolean bFlag = Adesk::kFalse;
	fd.GFD(_T("BLIND_DRAIN"), bFlag);
	return bFlag == Adesk::kTrue ? true : false;
}

void TDbPipeCanal::SetCoverType(int nType)
{
	assertWriteEnabled();
	TEntityFields &fd = Fields();
	fd.SFD(_T("COVER_TYPE"), (Adesk::UInt8)nType);
}

int TDbPipeCanal::GetCoverType() const
{
	assertReadEnabled();
	const TEntityFields &fd = GetFields();
	Adesk::UInt8 nType = 0;
	fd.GFD(_T("COVER_TYPE"), nType);
	return (int)nType;
}

void TDbPipeCanal::SetCoverHorDist(double dDist)
{
	assertWriteEnabled();
	TEntityFields &fd = Fields();
	fd.SFD(_T("COVER_HOR_DIST"), dDist);
}

double TDbPipeCanal::GetCoverHorDist() const
{
	assertReadEnabled();
	const TEntityFields &fd = GetFields();
	double dDist = 0.0;
	fd.GFD(_T("COVER_HOR_DIST"), dDist);
	return dDist;
}

void TDbPipeCanal::SetCoverVerDist(double dDist)
{
	assertWriteEnabled();
	TEntityFields &fd = Fields();
	fd.SFD(_T("COVER_VER_DIST"), dDist);
}

double TDbPipeCanal::GetCoverVerDist() const
{
	assertReadEnabled();
	const TEntityFields &fd = GetFields();
	double dDist = 0.0;
	fd.GFD(_T("COVER_VER_DIST"), dDist);
	return dDist;
}

void TDbPipeCanal::DrawCover(XExplodeDraw &dc, XCurveSegment &segUp, XCurveSegment &segDown) const
{
	double dWeight = GetPScale() * GetCoverLineWidth();
	if (!IsShowPipeCanalLineWeight(this->database()))
	{
		dWeight = 0.0;
	}
	AcGePoint3d pt1 = segUp.StartPoint();
	AcGePoint3d pt3 = segUp.EndPoint();
	AcGePoint3d pt2 = segDown.StartPoint();
	AcGePoint3d pt4 = segDown.EndPoint();
	pt1.z = 0.0;
	pt2.z = 0.0;
	pt3.z = 0.0;
	pt4.z = 0.0;
	int nCoverType = GetCoverType();
	if (!IsBlineDrain() && nCoverType != 0)
	{
		if (segDown.Is(CURVE_LINE))  // 直线型方沟
		{
			// 获得两条边线平行重叠部分 
			AcDbLine line(pt1, pt3);
			AcGePoint3d pt21, pt41;
			line.getClosestPointTo(pt2, pt21);
			line.getClosestPointTo(pt4, pt41);
			AcGePoint3d ptS = pt1;
			if (fabs(pt2.distanceTo(pt21) - m_nWidth) < 0.001)
			{
				ptS = pt21;
			}
			AcGePoint3d ptE = pt3;
			if (fabs(pt4.distanceTo(pt41) - m_nWidth) < 0.001)
			{
				ptE = pt41;
			}
			// 绘制盖板
			AcGePoint3d ptTemp;
			line.getClosestPointTo(pt2, ptTemp, Adesk::kTrue);
			AcGePoint3d ptS1 = ptS, ptS2 = ptS + pt2 - ptTemp;
			AcGeVector3d vtDir = pt41 - pt21;
			vtDir.normalize();
			if (nCoverType == 1)
			{
				// 纵向
				double dLen = ptS.distanceTo(ptE);
				double dDist = 0.0, dHorDist = GetCoverHorDist();
				XCurveSegment segTemp;
				bool bELinkedEntity = IsLinkedEntity(1);
				while (dDist < dLen + 0.001)
				{
					segTemp.SetPoints(ptS1 + vtDir * dDist, ptS2 + vtDir * dDist);
					DrawWeight(dc, dWeight, segTemp, colorIndex(), linetypeScale());
					if (dDist + dHorDist > dLen + 0.001 && dDist < dLen - 0.001) // 末端
					{
						if (bELinkedEntity)
						{
							break;
						}
						dDist = dLen;
					}
					else
					{
						dDist += dHorDist;
					}
				}
			}
			else if (nCoverType == 2)
			{
				// 纵向
				XCurveSegment segTemp;
				if (!IsLinkedEntity(0)) // 起点未连接实体
				{
					segTemp.SetPoints(ptS1, ptS2);
					DrawWeight(dc, dWeight, segTemp, colorIndex(), linetypeScale());
				}
				if (!IsLinkedEntity(1)) // 终点未连接实体
				{
					double dLen = ptS.distanceTo(ptE);
					segTemp.SetPoints(ptS1 + vtDir * dLen, ptS2 + vtDir * dLen);
					DrawWeight(dc, dWeight, segTemp, colorIndex(), linetypeScale());
				}
				// 横向
				AcDbLine line(pt1, pt3);
				AcDbLine lineS(pt1, pt2), lineE(pt3, pt4);
				AcGeVector3d vtVer = ptS2 - ptS1;
				vtVer.normalize();
				double dDist = GetCoverVerDist(), dVerDist = dDist;
				AcGePoint3dArray arrPt1, arrPt2;
				while (dDist < m_nWidth - 0.001)
				{
					line.transformBy(vtVer * dVerDist);
					line.intersectWith(&lineS, AcDb::kExtendBoth, arrPt1);
					line.intersectWith(&lineE, AcDb::kExtendBoth, arrPt2);
					if (arrPt1.length() == 1 && arrPt2.length() == 1)
					{
						segTemp.SetPoints(arrPt1[0], arrPt2[0]);
						DrawWeight(dc, dWeight, segTemp, colorIndex(), linetypeScale());
					}
					arrPt1.setLogicalLength(0);
					arrPt2.setLogicalLength(0);
					dDist += dVerDist;
				}
			}
			else if (nCoverType == 3)
			{
				// 纵向
				double dLen = ptS.distanceTo(ptE);
				double dDist = 0.0, dHorDist = GetCoverHorDist();
				XCurveSegment segTemp;
				bool bELinkedEntity = IsLinkedEntity(1);
				while (dDist < dLen + 0.001)
				{
					segTemp.SetPoints(ptS1 + vtDir * dDist, ptS2 + vtDir * dDist);
					DrawWeight(dc, dWeight, segTemp, colorIndex(), linetypeScale());
					if (dDist + dHorDist > dLen + 0.001 && dDist < dLen - 0.001) // 终点
					{
						if(bELinkedEntity)
						{
							break;
						}
						dDist = dLen;
					}
					else
					{
						dDist += dHorDist;
					}
				}
				// 横向
				AcDbLine line(pt1, pt3);
				AcDbLine lineS(pt1, pt2), lineE(pt3, pt4);
				AcGeVector3d vtVer = ptS2 - ptS1;
				vtVer.normalize();
				dDist = GetCoverVerDist();
				double dVerDist = dDist;
				AcGePoint3dArray arrPt1, arrPt2;
				while (dDist < m_nWidth - 0.001)
				{
					line.transformBy(vtVer * dVerDist);
					line.intersectWith(&lineS, AcDb::kExtendBoth, arrPt1);
					line.intersectWith(&lineE, AcDb::kExtendBoth, arrPt2);
					if (arrPt1.length() == 1 && arrPt2.length() == 1)
					{
						segTemp.SetPoints(arrPt1[0], arrPt2[0]);
						DrawWeight(dc, dWeight, segTemp, colorIndex(), linetypeScale());
					}
					arrPt1.setLogicalLength(0);
					arrPt2.setLogicalLength(0);
					dDist += dVerDist;
				}
			}
		}
		else // 弧线型方沟
		{
			// 获得两条边线重叠部分 
			XArc arcUp = segUp.GetArc();
			XArc arcDown = segDown.GetArc();
			XArc arcCenter = this->GetCurve().GetArc();
			XPoint ptCenter = arcCenter.GetCenterPt();
			ptCenter.z = 0.0;
			AcDbArc arc(ptCenter, arcUp.GetRadius(), arcUp.GetStarAngle(), arcUp.GetEndAngle());
			double dUpRadius = arcUp.GetRadius();
			double dDownRadius = arcDown.GetRadius();
			double dRadius = (dUpRadius > dDownRadius ? dDownRadius : dUpRadius) + fabs(dUpRadius - dDownRadius) * 0.5;
			AcGePoint3d pt21, pt41;
			arc.getClosestPointTo(pt2, pt21);
			arc.getClosestPointTo(pt4, pt41);
			AcGePoint3d ptS = pt1;
			if (fabs(pt2.distanceTo(pt21) - m_nWidth) < 0.001)
			{
				ptS = pt21;
			}
			AcGePoint3d ptE = pt3;
			if (fabs(pt4.distanceTo(pt41) - m_nWidth) < 0.001)
			{
				ptE = pt41;
			}
			// 重叠部分端点转换到中心线上
			AcGeVector3d vtS = ptS - ptCenter.AsAcGePoint3d();
			AcGeVector3d vtE = ptE - ptCenter.AsAcGePoint3d();
			vtS.z = 0.0;
			vtE.z = 0.0;
			vtS.normalize();
			vtE.normalize();
			ptS = ptCenter + vtS * dRadius;
			ptE = ptCenter + vtE * dRadius;
			double dAngle = vtS.angleTo(vtE, AcGeVector3d::kZAxis);
			// 重叠不错在中线处的弧线及中点
			AcGeVector3d vtMid = vtS;
			vtMid.rotateBy(dAngle * 0.5, AcGeVector3d::kZAxis);
			XPoint ptMid = ptCenter + vtMid * dRadius; 
			XArc arcTemp(ptS, ptMid, ptE);
			AcDbArc arcMid(arcTemp.GetCenterPt(), arcTemp.GetRadius(), arcTemp.GetStarAngle(), arcTemp.GetEndAngle());
			// 确定端点node索引
			if (nCoverType == 1)
			{
				// 纵向
				double dLen = vtS.angleTo(vtE, AcGeVector3d::kZAxis) * dRadius;
				double dDist = 0.0, dHorDist = GetCoverHorDist();
				XCurveSegment segTemp;
				bool bSLinkeEntity = IsLinkedEntity(StartPoint());
				bool bELinkedEntity = IsLinkedEntity(EndPoint());
				while (dDist < dLen + 0.001)
				{
					double dAngle = dDist / dRadius;
					AcGeVector3d vtTemp = vtS;
					vtTemp.rotateBy(dAngle, AcGeVector3d::kZAxis);
					segTemp.SetPoints(ptCenter + vtTemp * dUpRadius, ptCenter + vtTemp * dDownRadius);
					DrawWeight(dc, dWeight, segTemp, colorIndex(), linetypeScale());
					if (dDist + dHorDist > dLen + 0.001 && dDist < dLen - 0.001) // 终点
					{
						if(bELinkedEntity)
						{
							break;
						}
						dDist = dLen;
					}
					else
					{
						dDist += dHorDist;
					}
				}
			}
			else if (nCoverType == 2)
			{
				// 纵向
				XCurveSegment segTemp;
				if (!IsLinkedEntity(0)) // 起点未连接实体
				{
					segTemp.SetPoints(ptCenter + vtS * dUpRadius, ptCenter + vtS * dDownRadius);
					DrawWeight(dc, dWeight, segTemp, colorIndex(), linetypeScale());
				}
				if (!IsLinkedEntity(1)) // 终点未连接实体
				{
					segTemp.SetPoints(ptCenter + vtE * dUpRadius, ptCenter + vtE * dDownRadius);
					DrawWeight(dc, dWeight, segTemp, colorIndex(), linetypeScale());
				}
				// 横向
				double dMinRadius = dDownRadius > dUpRadius ? dUpRadius : dDownRadius;
				double dDist = GetCoverVerDist(), dVerDist = dDist;
				AcGePoint3dArray arrPt1, arrPt2;
				while (dDist < m_nWidth - 0.001)
				{
					double dOffset = dDist + dMinRadius - dRadius;
					segTemp = XArc(ptCenter, dMinRadius + dDist, arcMid.startAngle(), arcMid.endAngle());
					DrawWeight(dc, dWeight, segTemp, colorIndex(), linetypeScale());
					dDist += dVerDist;
				}
			}
			else if (nCoverType == 3)
			{
				// 纵向
				double dLen = vtS.angleTo(vtE, AcGeVector3d::kZAxis) * dRadius;
				double dDist = 0.0, dHorDist = GetCoverHorDist();
				XCurveSegment segTemp;
				bool bSLinkeEntity = IsLinkedEntity(StartPoint());
				bool bELinkedEntity = IsLinkedEntity(EndPoint());
				while (dDist < dLen + 0.001)
				{
					double dAngle = dDist / dRadius;
					AcGeVector3d vtTemp = vtS;
					vtTemp.rotateBy(dAngle, AcGeVector3d::kZAxis);
					segTemp.SetPoints(ptCenter + vtTemp * dUpRadius, ptCenter + vtTemp * dDownRadius);
					DrawWeight(dc, dWeight, segTemp, colorIndex(), linetypeScale());
					if (dDist + dHorDist > dLen + 0.001 && dDist < dLen - 0.001 ) // 终点
					{
						if(bELinkedEntity)
						{
							break;
						}
						dDist = dLen;
					}
					else
					{
						dDist += dHorDist;
					}
				}
				// 横向
				double dMinRadius = dDownRadius > dUpRadius ? dUpRadius : dDownRadius;
			    dDist = GetCoverVerDist();
				double dVerDist = dDist;
				AcGePoint3dArray arrPt1, arrPt2;
				while (dDist < m_nWidth - 0.001)
				{
					double dOffset = dDist + dMinRadius - dRadius;
					segTemp = XArc(ptCenter, dMinRadius + dDist, arcMid.startAngle(), arcMid.endAngle());
					DrawWeight(dc, dWeight, segTemp, colorIndex(), linetypeScale());
					dDist += dVerDist;
				}
			}
		}
	}
}

bool TDbPipeCanal::IsLinkedEntity(int nPos) const
{
	AcDbObjectId id = GetNode(nPos);
	if (!id.isValid())
	{
		return false;
	}
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipeNode, pNode);
	if(pNode != NULL)
	{
		int num = pNode->GetInterfaceNum();
		for (int i = 0; i < num; ++i)
		{
			const AcDbObjectId &idTemp = pNode->GetIPipe(i);
			if (idTemp.isValid() && idTemp != this->id())
			{
				return true;
			}
		}
	}
	OPENOBJ_END();
	return false;
}

bool TDbPipeCanal::IsLinkedEntity(XPoint pt) const
{
	for (int i = 0; i < 2; ++i)
	{
		OPENOBJ_BEGIN(GetNode(i), AcDb::kForRead, TDbPipeNode, pNode);
		if(pNode != NULL)
		{
			XPoint ptLoc = pNode->GetLocation();
			if (ptLoc.Distance2d(pt) > 0.001)
			{
				continue;
			}
			int num = pNode->GetInterfaceNum();
			for (int i = 0; i < num; ++i)
			{
				const AcDbObjectId &idTemp = pNode->GetIPipe(i);
				if (idTemp.isValid() && idTemp != this->id())
				{
					return true;
				}
			}
		}
		OPENOBJ_END();
	}
	return false;
}

int TDbPipeCanal::LinkedPipeCanalNum(int nPos) const
{
	AcDbObjectId id = GetNode(nPos);
	if (!id.isValid())
	{
		return 0;
	}
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipeFitting, pNode);
	if(pNode != NULL)
	{
		int num = pNode->GetInterfaceNum();
		return num - 1;
	}
	OPENOBJ_END();
	return 0;
}

int TDbPipeCanal::NeedModifyInt(int nPos, const TDbPipeFitting *pFitting) const
{
	int nLinkNum = pFitting->GetInterfaceNum() - 1;
	// 样式2和样式3弯头连接时 （端点只和一个方沟有连接）
	if (nLinkNum == 1 && (m_nCanalType == 2 || m_nCanalType == 3))
	{
		XPoint pt = nPos == 0 ? StartPoint() : EndPoint();
		for (int i = 0; i < pFitting->GetInterfaceNum(); ++i)
		{
			AcDbObjectId id = pFitting->GetIPipe(i);
			if (id == this->objectId())
			{
				continue;
			}
			OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipeCanal, pCanal);
			if (pCanal != NULL)
			{
				// 确定方沟间的夹角位置
				XCurveSegment segBase = pCanal->GetCurve();
				AcGeVector3d vt1;
				if (segBase.Is(CURVE_LINE)) // 直线
				{
					vt1 = segBase.MidPoint() - pt;
				}
				else // 弧线
				{
					vt1 = segBase.GetArc().GetCenterPt() - pt;
					vt1.z = 0.0;
					if (pt.Distance2d(segBase.StartPoint()) < 0.001)
					{
						vt1.rotateBy(-PI * 0.5, AcGeVector3d::kZAxis);
					}
					else
					{
						vt1.rotateBy(PI * 0.5, AcGeVector3d::kZAxis);
					}
				}
				XCurveSegment cenCurve = GetCurve();
				AcGeVector3d vt2;
				if (cenCurve.Is(CURVE_LINE)) // 直线
				{
					vt2 = cenCurve.MidPoint() - pt;
				}
				else // 弧线
				{
					vt2 = cenCurve.GetArc().GetCenterPt() - pt;
					vt2.z = 0.0;
					vt2.rotateBy(-PI * 0.5, AcGeVector3d::kZAxis);
				}
				vt1.z = 0.0;
				vt2.z = 0.0;
				double dAngle = vt2.angleTo(vt1, AcGeVector3d::kZAxis);
				if (nPos == 0) // 起点
				{
					if (dAngle < PI)
					{
						return 1;
					} 
					else
					{
						return 2;
					}
				} 
				else // 终点
				{
					if (dAngle < PI)
					{
						return 2;
					} 
					else
					{
						return 1;
					}
				}
			}
			OPENOBJ_END();
		}
	}
	return 0;
}

void TDbPipeCanal::Draw3dType(XExplodeDraw &dc) const
{
	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);
	// 起点方沟边线连接点
	XPoint pt1 = segUp.StartPoint();
	XPoint pt2 = segDown.StartPoint();
	OPENOBJ_BEGIN(GetNode(0), AcDb::kForRead, TDbPipeFitting, pFitting);
	if (pFitting != NULL)
	{
		TDbCanalFitting fitting(pFitting);
		fitting.IntersectWith(this->objectId(), pt1, pt2);
	}
	OPENOBJ_END();
	// 终点方沟边线连接点
	XPoint pt3 = segUp.EndPoint();
	XPoint pt4 = segDown.EndPoint();
	OPENOBJ_BEGIN(GetNode(1), AcDb::kForRead, TDbPipeFitting, pFitting);
	if (pFitting != NULL)
	{
		TDbCanalFitting fitting(pFitting);
		fitting.IntersectWith(this->objectId(), pt4, pt3);
	}
	OPENOBJ_END();
	if (cenCurve.Is(CURVE_LINE)) // 直线方沟
	{
		XLine lineUp1 = segUp.GetLine();
		XLine lineDown1 = segDown.GetLine();
		pt1 = ProjectAlongZAxis(lineUp1, pt1);
		pt3 = ProjectAlongZAxis(lineUp1, pt3);
		pt2 = ProjectAlongZAxis(lineDown1, pt2);
		pt4 = ProjectAlongZAxis(lineDown1, pt4);
		// 底面
		AcGePoint3dArray arrPts;
		arrPts.append(pt1);
		arrPts.append(pt3);
		arrPts.append(pt2);
		arrPts.append(pt4);
		dc.DrawMesh(2, 2, arrPts.asArrayPtr());
		// 根据起始点高度，计算顶面边线 
		XPoint ptUpS = segUp.StartPoint(), ptUpE = segUp.EndPoint();
		XPoint ptDownS = segDown.StartPoint(), ptDownE = segDown.EndPoint();
		ptUpS.z += GetStartHeight();
		ptDownS.z = ptUpS.z;
		ptUpE.z += GetEndHeight();
		ptDownE.z = ptUpE.z;
		XLine lineUp2(ptUpS, ptUpE);
		XLine lineDown2(ptDownS, ptDownE);
		XPoint pt11 = ProjectAlongZAxis(lineUp2, pt1);
		XPoint pt33 = ProjectAlongZAxis(lineUp2, pt3);
		XPoint pt22 = ProjectAlongZAxis(lineDown2, pt2);
		XPoint pt44 = ProjectAlongZAxis(lineDown2, pt4);
	    // 绘制边界面
		arrPts.setLogicalLength(0);
		arrPts.append(pt1);
		arrPts.append(pt11);
		arrPts.append(pt3); 
		arrPts.append(pt33);
		dc.DrawMesh(2, 2, arrPts.asArrayPtr());
		arrPts.setLogicalLength(0);
		arrPts.append(pt2);
		arrPts.append(pt22);
		arrPts.append(pt4);
		arrPts.append(pt44);
		dc.DrawMesh(2, 2, arrPts.asArrayPtr());
	}
	else // 弧线方沟
	{
		XArc arcUp1 = segUp.GetArc();
		XArc arcDown1 = segDown.GetArc();
		// 计算融合前底面边线
		XPoint ptUpS1, ptUpE1;
		arcUp1.GetStartPoint(ptUpS1);
		arcUp1.GetEndPoint(ptUpE1);
		XPoint ptUpMid1 = arcUp1.MidPoint();
		ptUpS1.z = StartPoint().z;
		ptUpE1.z = EndPoint().z;
		ptUpMid1.z = (ptUpS1.z + ptUpE1.z) * 0.5;
		AcGeCircArc3d cirUp1(ptUpS1, ptUpMid1, ptUpE1);
		XPoint ptDownS1, ptDownE1;
		arcDown1.GetStartPoint(ptDownS1);
		arcDown1.GetEndPoint(ptDownE1);
		XPoint ptDownMid1 = arcDown1.MidPoint();
		ptDownS1.z = StartPoint().z ;
		ptDownE1.z = EndPoint().z;
		ptDownMid1.z = (ptDownS1.z + ptDownE1.z) * 0.5;
		AcGeCircArc3d cirDown1(ptDownS1, ptDownMid1, ptDownE1);
		// 融合后底面边线
		pt1 = ProjectAlongZAxis(cirUp1, pt1);
		pt3 = ProjectAlongZAxis(cirUp1, pt3);
		pt2 = ProjectAlongZAxis(cirDown1, pt2); 
		pt4 = ProjectAlongZAxis(cirDown1, pt4);
		// 中点
		AcGeVector3d vt1 = pt1 - arcUp1.GetCenterPt();
		AcGeVector3d vt2 = pt3 - arcUp1.GetCenterPt();
		vt1.z = 0.0;
		vt2.z = 0.0;
		double dAngle = vt1.angleTo(vt2, AcGeVector3d::kZAxis);
		vt1.rotateBy(dAngle * 0.5, AcGeVector3d::kZAxis);
		vt1.normalize();
		XPoint pt5 = arcUp1.GetCenterPt() + vt1 * arcUp1.GetRadius();
		pt5 = ProjectAlongZAxis(cirUp1, pt5);
		AcGeVector3d vt3 = pt2 - arcDown1.GetCenterPt();
		AcGeVector3d vt4 = pt4 - arcDown1.GetCenterPt();
		vt3.z = 0.0;
		vt4.z = 0.0;
		dAngle = vt3.angleTo(vt4, AcGeVector3d::kZAxis);
		vt3.rotateBy(dAngle * 0.5, AcGeVector3d::kZAxis);
		vt3.normalize();
		XPoint pt6 = arcDown1.GetCenterPt() + vt3 * arcDown1.GetRadius();
		pt6 = ProjectAlongZAxis(cirDown1, pt6);
		AcGeCircArc3d arc1(pt1, pt5, pt3);
		AcGeCircArc3d arc2(pt2, pt6, pt4);
		// 绘制底面
		int nSplitNum = 10;
		AcGePoint3dArray arr1, arr2, arr;
		arc1.getSamplePoints(nSplitNum, arr1);
		arc2.getSamplePoints(nSplitNum, arr2);
		for (int i = 0; i < arr1.length(); ++i)
		{
			arr.append(arr1.at(i));
			arr.append(arr2.at(i));
		}
		dc.DrawMesh(arr.length() / 2, 2, arr.asArrayPtr());
		// 边界面
		XPoint ptUpS2 = ptUpS1;
		XPoint ptUpE2 = ptUpE1;
		ptUpS2.z += GetStartHeight();
		ptUpE2.z += GetEndHeight();
		XPoint ptUpMid2 = ptUpMid1;
		ptUpMid2.z = (ptUpS2.z + ptUpE2.z) * 0.5;
		AcGeCircArc3d cirUp2(ptUpS2, ptUpMid2, ptUpE2);
		XPoint ptDownS2 = ptDownS1;
		XPoint ptDownE2 = ptDownE1;
		ptDownS2.z += GetStartHeight();
		ptDownE2.z += GetEndHeight();
		XPoint ptDownMid2 = ptDownMid1;
		ptDownMid2.z = (ptDownS2.z + ptDownE2.z) * 0.5;
		AcGeCircArc3d cirDown2(ptDownS2, ptDownMid2, ptDownE2);
		pt1 = ProjectAlongZAxis(cirUp2, pt1);
		pt3 = ProjectAlongZAxis(cirUp2, pt3);
		pt5 = ProjectAlongZAxis(cirUp2, pt5);
		pt2 = ProjectAlongZAxis(cirDown2, pt2); 
		pt4 = ProjectAlongZAxis(cirDown2, pt4);
		pt6 = ProjectAlongZAxis(cirDown2, pt6);
		AcGeCircArc3d arc3(pt1, pt5, pt3);
		AcGeCircArc3d arc4(pt2, pt6, pt4);
		// 绘制边界面
		AcGePoint3dArray arr3, arr4;
		arc3.getSamplePoints(nSplitNum, arr3);
		arc4.getSamplePoints(nSplitNum, arr4);
		arr.setLogicalLength(0);
		for (int i = 0; i < arr3.length(); ++i)
		{
			arr.append(arr1.at(i));
			arr.append(arr3.at(i));
		}
		dc.DrawMesh(arr.length() * 0.5, 2, arr.asArrayPtr());
		arr.setLogicalLength(0);
		for (int i = 0; i < arr4.length(); ++i)
		{
			arr.append(arr2.at(i));
			arr.append(arr4.at(i));
		}
		dc.DrawMesh(arr.length() * 0.5, 2, arr.asArrayPtr());
	}
}

double TDbPipeCanal::GetStartHeight() const
{
	assertReadEnabled();
	const TEntityFields &fd = GetFields();
	double dHeight = m_nHeight;
	fd.GFD(_T("START_HEIGHT"), dHeight);
	return dHeight;
}

void TDbPipeCanal::SetStartHeight(double dHeight)
{
	assertWriteEnabled();
	TEntityFields &fd = Fields();
	fd.SFD(_T("START_HEIGHT"), dHeight);
}

double TDbPipeCanal::GetEndHeight() const
{
	assertReadEnabled();
	const TEntityFields &fd = GetFields();
	double dHeight = m_nHeight;
	fd.GFD(_T("END_HEIGHT"), dHeight);
	return dHeight;
}

void TDbPipeCanal::SetEndHeight(double dHeight)
{
	assertWriteEnabled();
	TEntityFields &fd = Fields();
	fd.SFD(_T("END_HEIGHT"), dHeight);
}

XPoint TDbPipeCanal::ProjectAlongZAxis(XLine &line, const XPoint &pt) const
{
	XPoint ptRet = pt;
	AcDbLine lineTemp(line.StartPoint(), line.EndPoint());
	lineTemp.getClosestPointTo(pt, AcGeVector3d::kZAxis, ptRet, Adesk::kTrue);
	return ptRet;
}

AcGePoint3d TDbPipeCanal::ProjectAlongZAxis(AcGeCircArc3d &cir, const XPoint &pt) const
{
	AcGePoint3d ptRet = pt;
	AcGePlane plane(cir.center(), cir.normal());
	AcGeLine3d line(pt, AcGeVector3d::kZAxis);
	AcGePoint3d ptInt;
	if (plane.intersectWith(line, ptInt) == Adesk::kTrue)
	{
		ptRet = ptInt;
	}
	return ptRet;
}

double TDbPipeCanal::GetGradient() const
{
	assertReadEnabled();
	double dSEle = this->StartPoint().z;
	double dEEle = this->EndPoint().z;
	double dGradient = 0.0;
	if (fabs(dSEle - dEEle) > 0.000001)
	{
		double dLen = this->StartPoint().Distance2d(this->EndPoint());
		dGradient = (dSEle - dEEle) / dLen;
	}
	return dGradient;
}

void TDbPipeCanal::SetGradient(double dGradient)
{
	assertWriteEnabled();
	if (fabs(dGradient) < 0.000001)
	{
		EndPoint().z = StartPoint().z;
	}
	else 
	{
		double dLen = this->StartPoint().Distance2d(this->EndPoint());
		if (dGradient > 0.0)
		{
			EndPoint().z += dLen * dGradient;
		}
		else
		{
			StartPoint().z += dLen * dGradient;
		}
	}
}