#include "stdafx.h"
#include "AecPipeLineTool.h"
#include "AecDbEwPipe.h"
#include "AecDbEwFitting.h"
#include "uiiado.h"
//#include "UITools.h"
#include "CoreTools.h"
#include "AecDb3dRoadAxisLine.h"
#include <vector>
#include <algorithm>

#ifndef Plumbing_DB
#define Plumbing_DB _T("\\Plumbing.db")
#endif

typedef struct PointParam
{
	AcGePoint3d ptOn;
	double dParam;
}POINTPARAM;

static bool ComparePtparam(PointParam ptParam1,PointParam ptParam2)
{
	if (ptParam1.dParam - ptParam2.dParam < 1.e-10)
	{
		return true;
	}
	return false;
}

void SortPoints(AcGePoint3dArray& points,AcDbCurve* pLine)
{
	PointParam ptParam;
	std::vector<PointParam> points2;

	for (int i = 0;i < points.length();i++)
	{
		ptParam.ptOn = points.at(i);
		pLine->getParamAtPoint(points.at(i),ptParam.dParam);
		points2.push_back(ptParam);
	}
	std::sort(points2.begin(),points2.end(),ComparePtparam);

	points.setLogicalLength(0);
	std::vector<PointParam>::iterator it;
	for (it = points2.begin(); it < points2.end(); it++)
	{
		points.append((*it).ptOn);
	}
}

Acad::ErrorStatus AddToModelSpace(AcDbEntity* pEnt, AcDbDatabase* pDb = NULL, bool bClose = true)
{
	if (pDb == NULL)
		pDb = acdbHostApplicationServices()->workingDatabase();

	Acad::ErrorStatus es;

	AcDbBlockTable* pTbl = NULL;
	if (Acad::eOk == (es = pDb->getBlockTable(pTbl, AcDb::kForRead)))
	{
		AcDbBlockTableRecord* pBTR = NULL;
		if (Acad::eOk == (es = pTbl->getAt(ACDB_MODEL_SPACE, pBTR, AcDb::kForWrite)))
		{
			es = pBTR->appendAcDbEntity(pEnt);
			if (bClose)
				pEnt->close();

			pBTR->close();
		}
		pTbl->close();
	}
	return es;
}

double AecPipeLineTool::m_dRRato = 0.5;

AecPipeLineTool::AecPipeLineTool(void)
{
}

AecPipeLineTool::~AecPipeLineTool(void)
{
}

bool AecPipeLineTool::CreatePipe(AecDbEwPipe* pPipe,const AcGePoint3dArray& arPtsPath,AcDbVoidPtrArray& arPipePtrs,AcDbVoidPtrArray& arFittPtrs)
{
	AecDb3dRoadAxisLine* pALine = new AecDb3dRoadAxisLine;

	double dD = 0.0,dRatio =1.5;
	pPipe->GetSpecialtyData()->GetAt(PIPE_DN,dD);
	pPipe->GetSpecialtyData()->GetAt(PIPE_RATIO,dRatio);

	if (m_dRRato > 1.0)
		dRatio = m_dRRato;

	if ( pALine->Create3dRoadAxisLine(dD,dRatio,arPtsPath) )
	{
		AecDbObjXDataMap* pMap = pPipe->GetSpecialtyData();
		AecDbEwPipe* pPipeNew = NULL;
		 AecDbEwFitting* pElbow = NULL;
		AcDbCurve* pCurve = NULL;

		for (int i = 0;i < pALine->GetCurveSegCount();i++)
		{
			pCurve = pALine->GetCurveSeg(i);

			AcDbLine* pLn = AcDbLine::cast(pCurve);
			if (pLn != NULL)
			{
				pPipeNew = CreatePipe(pMap,pLn->startPoint(),pLn->endPoint());
				if (pPipeNew != NULL)
				{
					arPipePtrs.append(pPipeNew);
				}
			}

			AcDbArc* pArc = AcDbArc::cast(pCurve);
			if (pArc != NULL)
			{
				pElbow = CreateElbow(pMap,pArc,dRatio);
				if (pElbow != NULL)
				{
					arFittPtrs.append(pElbow);
				}
			}
		}
	}
	DELETE_PTR(pALine);
	return !arPipePtrs.isEmpty();
}

bool AecPipeLineTool::ElbowJoinHere(AecDbEwPipe* pPipe1,AecDbEwPipe* pPipe2)
{
	if (pPipe1 == NULL || pPipe2 == NULL)
		return false;

	AcGePoint3d pt0 = pPipe1->StartPoint();
	AcGePoint3d pt1 = pPipe1->EndPoint();

	AcGePoint3d pt2 = pPipe2->StartPoint();
	AcGePoint3d pt3 = pPipe2->EndPoint();

	//首先约定管线是首尾连接
	double dDist1= pt1.distanceTo(pt2);
	if (dDist1 < 5.0)
		return true;

	dDist1 = pt3.distanceTo(pt0);
	if (dDist1 < 5.0)
		return true;

	return false;
}

AecDbEwFitting* AecPipeLineTool::CreateElbow(AecDbObjXDataMap* pMap,AcDbArc* pArc,double dRRato)
{
	if (pArc != NULL)
	{
		double dSta = 0.0;
		double dEnd = 0.0;
		pArc->getStartParam(dSta);
		pArc->getEndParam(dEnd);

		AcGeVector3d vtMaj,vtMin;
		pArc->getFirstDeriv(dSta,vtMaj);
		pArc->getFirstDeriv(dEnd,vtMin);

		AcGePoint3d ptSta,ptEnd;
		pArc->getStartPoint(ptSta);
		pArc->getEndPoint(ptEnd);

		AcDbXline ln1,ln2;
		ln1.setBasePoint(ptSta);
		ln1.setUnitDir(vtMaj);
		ln2.setBasePoint(ptEnd);
		ln2.setUnitDir(vtMin);

		AcGePoint3dArray arPts;
		ln1.intersectWith(&ln2,AcDb::kOnBothOperands,arPts);
		if (!arPts.isEmpty())
		{
			AcGePoint3d ptMid = arPts.first();
			vtMaj = ptSta - ptMid;
			vtMin = ptEnd - ptMid;

			AecDbEwFitting* pElbow = CreateElbow(pMap,vtMaj,vtMin,ptMid,dRRato);
			if (pElbow != NULL)
			{
				return pElbow;
			}
		}
	}
	return NULL;
}

bool AecPipeLineTool::QueryTeeData(double dDn,double dDn2,double& dLen1,double& dLen2)
{
	CUIISQLiteServer dbSQLite;
	CString path = FilePath::GetSysDir() + Plumbing_DB;
	if (!dbSQLite.InitADOServer(path))
	{
		AfxMessageBox(CString(_T("数据库初始化失败，请检查 sys")) + Plumbing_DB + _T("文件是否存在."));
		return FALSE;
	}

	//查询三通尺寸
	int nDn1 = (int)(dDn + 0.1);
	int nDn2 = (int)(dDn2 + 0.1);

	if (nDn1 < nDn2)//交换
	{
		acutPrintf(_T("\n三通主进口公称直径必须大于等于分支口公称直径!"));
		return false;
	}

	CString sSQL;
	sSQL.Format(_T("select [长度L],[长度S] from AecTeeData where [公称直径L]=%d AND [公称直径S]=%d"),nDn1,nDn2);

	CStringArray arVals;
	dbSQLite.GetSelData(sSQL,arVals);

	if (arVals.IsEmpty())
	{
		//再从AecTeeData中查找
		sSQL.Format(_T("select [结构长度] from AecTeeTData where [公称直径]=%d"),nDn1);
		dbSQLite.GetSelData(sSQL,arVals);

		if (arVals.IsEmpty())
		{
			sSQL.Format(_T("\n查不到公称直径为 %d 的三通结构尺寸!"),nDn1);
			acutPrintf(sSQL);
			return false;
		}
		else
		{
			//水处理系统为毫米
			//dLen1 = AS_MUNIT(_ttof(arVals.GetAt(0)));
			dLen1 = _ttof(arVals.GetAt(0));
		}

		arVals.RemoveAll();
		sSQL.Format(_T("select [结构长度] from AecTeeTData where [公称直径]=%d"),nDn2);
		dbSQLite.GetSelData(sSQL,arVals);

		if (arVals.IsEmpty())
		{
			sSQL.Format(_T("\n查不到公称直径为 %d 的三通结构尺寸!"),nDn2);
			acutPrintf(sSQL);
			return false;
		}
		else
		{
			//dLen2 = AS_MUNIT(_ttof(arVals.GetAt(0)));
			//水处理系统为毫米
			dLen2 = _ttof(arVals.GetAt(0));
		}
	}
	else
	{
		if (arVals.GetSize() >= 2)
		{
			//dLen1 = AS_MUNIT(_ttof(arVals.GetAt(0)));
			//dLen2 = AS_MUNIT(_ttof(arVals.GetAt(1)));

			//水处理系统为毫米
			dLen1 = _ttof(arVals.GetAt(0));
			dLen2 = _ttof(arVals.GetAt(1));

		}
	}
	return true;
}

AecDbEwPipe* AecPipeLineTool::CreatePipe(AecDbObjXDataMap* pMap,const AcGePoint3d& pt2,const AcGePoint3d& pt3)
{
	AecDbEwPipe* pPipeNew = new AecDbEwPipe;
	pPipeNew->GetSpecialtyData()->CopyFrom(pMap);
	pPipeNew->SetBaseCurve(pt2,pt3);

	double dDn = 0.0,dt = 0.0;
	pMap->GetAt(PIPE_DN,dDn);
	pMap->GetAt(PIPE_THICK,dt);
	pPipeNew->SetSection(dDn,0.0);
	return pPipeNew;
}

AecDbEwPipe* AecPipeLineTool::BreakPipe(AecDbEwPipe* pPipe1,AcGePoint3d& pt22,double dLen )
{
	AcGePoint3d pt2;
	pPipe1->getClosestPointTo(pt22,pt2,Adesk::kTrue);

	if (pt22.distanceTo(pt2) < 1.e-3)//pt2落在pipe1上
	{
		AecInterface inf;
		pPipe1->GetInterface(1,inf);

		AcGeVector3d vtDir = inf.vtDir;//sta-->end
		vtDir.normalize();

		AcGePoint3d ptSta = pt22 - vtDir * 0.5 * dLen;
		AcGePoint3d ptEnd = pt22 + vtDir * 0.5 * dLen;
		pPipe1->SetEndPoint(ptSta);

		AecDbEwPipe* pNewPipe = new AecDbEwPipe;
		pNewPipe->GetSpecialtyData()->CopyFrom(pPipe1->GetSpecialtyData());
		pNewPipe->SetBaseCurve(ptEnd,inf.ptPos);

		double dDn = 0.0;
		pPipe1->GetSpecialtyData()->GetAt(PIPE_DN,dDn);
		pNewPipe->SetSection(dDn,0.0);
		return pNewPipe;
	}
	return NULL;
}

AecDbEwPipe* AecPipeLineTool::PointOnPipeConnect(AecDbObjXDataMap* pMap,const AcGePoint3d& pt2,const AcGePoint3d& pt3,AecDbEwPipe* pPipe1,AecDbEwFitting*& pTee,AecDbEwPipe*& pPipeNew)
{
	AcGePoint3d ptNewSta = pt2;

	double dLen1 = 0.0,dLen2 = 0.0,dDn = 0.0,dDn1 = 0.0;
	pMap->GetAt(PIPE_DN,dDn);
	pPipe1->GetSpecialtyData()->GetAt(PIPE_DN,dDn1);

	AcGePoint3d pt22;
	pPipe1->getClosestPointTo(pt2,pt22,Adesk::kTrue);

	if (pt22.distanceTo(pt2) < 1.e-3)//pt2落在pipe1上
	{
		//水处理为毫米
		//if ( QueryTeeData(AS_M2MM(dDn1),AS_M2MM(dDn),dLen1,dLen2) )
		if ( QueryTeeData(dDn1,dDn,dLen1,dLen2) )
		{
			double dInterfaceL = 0.0;
			pPipe1->GetSpecialtyData()->GetAt(PIPE_INTERFACEL,dInterfaceL);
			if (dInterfaceL > 1.e-3)//法兰管
			{
				dLen1 += dInterfaceL;
				dLen2 += dInterfaceL;
			}

			AecInterface inf1;
			pPipe1->GetInterface(1,inf1);
			AcGeVector3d vtPipe1 = inf1.vtDir;
			AcGeVector3d vtMin = pt3 - pt2;

			pTee = new AecDbEwFitting;

			pTee->GetSpecialtyData()->CopyFrom(pPipe1->GetSpecialtyData());
			pTee->GetSpecialtyData()->SetAt(KEY_RUNTIME,eTee);
			pTee->GetSpecialtyData()->SetAt(PIPE_DN,dDn1);
			pTee->GetSpecialtyData()->SetAt(PIPE_TDN,dDn);

			pTee->GetSpecialtyData()->SetAt(KEY_FITSRV,KEY_FITWPIPE);

			pTee->GetSpecialtyData()->SetAt(KEY_MAJBR,vtPipe1);
			pTee->GetSpecialtyData()->SetAt(KEY_MINBR,vtMin);
			pTee->GetSpecialtyData()->SetAt(KEY_MID,pt22);

			AcGeVector3d vtNro = vtMin.crossProduct(vtPipe1);
			pTee->GetSpecialtyData()->SetAt(KEY_NORMAL,vtNro);

			pTee->GetSpecialtyData()->SetAt(KEY_L,2.0 * dLen1 );
			pTee->GetSpecialtyData()->SetAt(KEY_T,dLen2 );

			AecInterface inf2;
			pTee->GetInterface(2,inf2);

			pPipeNew = CreatePipe(pMap,inf2.ptPos,pt3);
			CopyPipeLayerAndLineTypeFromTo(pPipe1,pPipeNew);

			return BreakPipe(pPipe1,pt22,2.0 * dLen1);
		}
	}

	AcGePoint3d pt33;
	pPipe1->getClosestPointTo(pt3,pt33,Adesk::kTrue);

	if (pt3.distanceTo(pt33) < 1.e-3)//pt2落在pipe1上
	{
		//水处理已经是毫米
		//if ( QueryTeeData(AS_M2MM(dDn1),AS_M2MM(dDn),dLen1,dLen2) )
		if ( QueryTeeData(dDn1,dDn,dLen1,dLen2) )
		{
			double dInterfaceL = 0.0;
			pPipe1->GetSpecialtyData()->GetAt(PIPE_INTERFACEL,dInterfaceL);
			if (dInterfaceL > 1.e-3)//法兰管
			{
				dLen1 += dInterfaceL;
				dLen2 += dInterfaceL;
			}

			AecInterface inf1;
			pPipe1->GetInterface(1,inf1);
			AcGeVector3d vtPipe1 = inf1.vtDir;
			AcGeVector3d vtMin = pt2 - pt3;

			pTee = new AecDbEwFitting;

			pTee->GetSpecialtyData()->CopyFrom(pPipe1->GetSpecialtyData());
			pTee->GetSpecialtyData()->SetAt(KEY_RUNTIME,eTee);
			pTee->GetSpecialtyData()->SetAt(PIPE_DN,dDn1);
			pTee->GetSpecialtyData()->SetAt(PIPE_TDN,dDn);

			pTee->GetSpecialtyData()->SetAt(KEY_FITSRV,KEY_FITWPIPE);

			pTee->GetSpecialtyData()->SetAt(KEY_MAJBR,vtPipe1);
			pTee->GetSpecialtyData()->SetAt(KEY_MINBR,vtMin);
			pTee->GetSpecialtyData()->SetAt(KEY_MID,pt33);

			AcGeVector3d vtNro = vtMin.crossProduct(vtPipe1);
			pTee->GetSpecialtyData()->SetAt(KEY_NORMAL,vtNro);

			pTee->GetSpecialtyData()->SetAt(KEY_L,2.0 * dLen1 );
			pTee->GetSpecialtyData()->SetAt(KEY_T,dLen2 );

			AecInterface inf2;
			pTee->GetInterface(2,inf2);

			pPipeNew = CreatePipe(pMap,inf2.ptPos,pt2);
			CopyPipeLayerAndLineTypeFromTo(pPipe1,pPipeNew);

			return BreakPipe(pPipe1,pt33,2.0 * dLen1);
		}
	}

	return NULL;
}

//创建管子时 自动判断连接是否加三通
AecDbEwPipe* AecPipeLineTool::CreatePipe(AecDbObjXDataMap* pMap,const AcGePoint3d& pt2,const AcGePoint3d& pt3,AecDbEwPipe* pPipe1,AecDbEwPipe* pPipe2,int nWeldType,AecDbEwFitting*& pTee,AecDbEwPipe*& pPipeOther)
{	
	//取最小
	pPipeOther = NULL;
	if (nWeldType == 1)//焊接连接
	{
		return CreatePipe(pMap,pt2,pt3);
	}

	AecDbEwPipe* pPipeNew = NULL;
	//可能 和1 产生三通
	if (pPipe1 != NULL && NULL != ( pPipeOther = PointOnPipeConnect(pMap,pt2,pt3,pPipe1,pTee,pPipeNew) ) )
	{
		return pPipeNew;
	}

	//可能 和2 产生三通
	if (pPipe2 != NULL && NULL != ( pPipeOther = PointOnPipeConnect(pMap,pt2,pt3,pPipe2,pTee,pPipeNew) ) )
	{
		return pPipeNew;
	}
	return CreatePipe(pMap,pt2,pt3);
}

//创建弯头,vtMaj为背向管嘴的方向
AecDbEwFitting* AecPipeLineTool::CreateElbow(AecDbObjXDataMap* pMap,const AcGeVector3d& vtMaj,const AcGeVector3d& vtMin,const AcGePoint3d& ptMid,double dRRato)
{
	AcGeVector3d vtMaj2 = vtMaj;
	vtMaj2.negate();

	AecDbEwFitting* pFit = new AecDbEwFitting;
	pFit->GetSpecialtyData()->CopyFrom(pMap);

	double dSweepAngle = vtMin.angleTo(vtMaj2);
	AcGeVector3d vtNorm = vtMaj2.crossProduct(vtMin);

	pFit->GetSpecialtyData()->SetAt(KEY_RUNTIME,eElbow);
	pFit->GetSpecialtyData()->SetAt(PIPE_RATIO,dRRato);
	pFit->GetSpecialtyData()->SetAt(PIPE_ELBOWANG,dSweepAngle);
	pFit->GetSpecialtyData()->SetAt(KEY_FITSRV,KEY_FITWPIPE);
	pFit->GetSpecialtyData()->SetAt(KEY_MAJBR,vtMaj2);
	pFit->GetSpecialtyData()->SetAt(KEY_MINBR,vtMin);
	pFit->GetSpecialtyData()->SetAt(KEY_NORMAL,vtNorm);
	pFit->GetSpecialtyData()->SetAt(KEY_MID,ptMid);

	return pFit;
}

AecDbEwFitting* AecPipeLineTool::CreateElbow(AecDbEwPipe* pPipe1,AecDbEwPipe* pPipe2,double dRRato)
{
	if (pPipe1 == NULL || pPipe2 == NULL)
		return NULL;

	AcDbCurve* pCrv1 = pPipe1->GetBaseCurve();
	AcDbCurve* pCrv2 = pPipe2->GetBaseCurve();

	if (pCrv1->isKindOf(AcDbArc::desc()) || pCrv2->isKindOf(AcDbArc::desc()))
	{
		return NULL;
	}

	AcGeVector3d vt1 = pPipe1->EndPoint() - pPipe1->StartPoint();
	AcGeVector3d vt2 = pPipe2->EndPoint() - pPipe2->StartPoint();
	vt1.normalize();vt2.normalize();

	AcGePoint3d ptSta1,ptEnd1;
	ptSta1 = pPipe1->StartPoint();
	ptEnd1 = pPipe1->EndPoint();
	if (vt1.dotProduct(vt2) < -1.e-10)//方向相反
	{
		//修改pipe1的方向 reverse
		pPipe1->SetStartPoint(ptEnd1);
		pPipe1->SetEndPoint(ptSta1);
	}

	//角度非常小的情况下
	AcGePoint3d ptMid;
	AcGeTol tol;
	tol.setEqualPoint(1.e-2);
	tol.setEqualVector(1.e-2);
	if (vt1.isParallelTo(vt2,tol))
	{
		ptMid = CoreTools::MidPt(pPipe1->EndPoint(),pPipe2->StartPoint());
		pPipe1->SetEndPoint(ptMid);
		pPipe2->SetStartPoint(ptMid);
		return NULL;
	}

	AcGePoint3dArray arPts;
	AecInterface inf1,inf2;
	AecInterface inf3,inf4;

	arPts.removeAll();

	AcGePlane plan;
	AcGeVector3d vtNorm = vt2.crossProduct(vt1);
	plan.set(ptEnd1,vtNorm);
	pCrv1->intersectWith(pCrv2,AcDb::kExtendBoth,plan,arPts);

	if (arPts.length() == 1)
	{
		ptMid = arPts.first();

		//如果很小的角度,直接连接
		double dAng = vt2.angleTo(vt1);
		if (dAng - PI / 18.0 < 1.e-3 || dAng - 0.94 * PI > 1.e-3 )
		{
			pPipe1->SetEndPoint(ptMid);
			pPipe2->SetStartPoint(ptMid);

			DELETE_PTR(pCrv1);
			DELETE_PTR(pCrv2);

			return NULL;
		}

		pPipe1->GetInterface(1,inf1);
		pPipe2->GetInterface(0,inf2);

		AecDbEwFitting* pElbow = AecPipeLineTool::CreateElbow(pPipe1->GetSpecialtyData(),inf1.vtDir.negate(),inf2.vtDir.negate(),ptMid,dRRato);
		if (pElbow != NULL)
		{
			pElbow->GetInterface(0,inf3);
			pElbow->GetInterface(1,inf4);

			if (inf3.vtDir.isParallelTo(inf1.vtDir) )
			{
				pPipe1->SetEndPoint(inf3.ptPos);
				pPipe2->SetStartPoint(inf4.ptPos);
			}
			else
			{
				pPipe1->SetEndPoint(inf4.ptPos);
				pPipe2->SetStartPoint(inf3.ptPos);
			}

			DELETE_PTR(pCrv1);
			DELETE_PTR(pCrv2);

			return pElbow;
		}
	}

	DELETE_PTR(pCrv1);
	DELETE_PTR(pCrv2);

	return NULL;
}

bool AecPipeLineTool::GetIntersectPoint2(AcDbCurve* pCrv1,AcDbCurve* pCrv2,AcGePoint3d& pt2,const AcGePlane& plan)
{
	if (pCrv1 == NULL || pCrv2 == NULL)
		return false;

	AcDbCurve* pProCrv1 = NULL;
	AcDbCurve* pProCrv2 = NULL;
	if (pCrv1 != NULL && pCrv2 != NULL)
	{
		pCrv1->getOrthoProjectedCurve(plan,pProCrv1);
		pCrv2->getOrthoProjectedCurve(plan,pProCrv2);

		if (pProCrv1 != NULL && pProCrv2 != NULL)
		{
			AcGePoint3dArray arPts;
			pProCrv1->intersectWith(pProCrv2,AcDb::kOnBothOperands,arPts);

			if (arPts.length() == 1)
			{
				DELETE_PTR(pProCrv1);
				DELETE_PTR(pProCrv2);

				pt2 = arPts.first();
				return true;
			}
			else
			{
				//不实际相交，计算出延长相交点,返回false
				pProCrv1->intersectWith(pProCrv2,AcDb::kExtendBoth,arPts);
				if (arPts.length() == 1)
				{
					DELETE_PTR(pProCrv1);
					DELETE_PTR(pProCrv2);

					pt2 = arPts.first();
					return false;
				}
			}
		}
	}
	return false;
}

bool AecPipeLineTool::GetIntersectPoint(AecDbEwPipe* pPipe1,AecDbEwPipe* pPipe2,AcGePoint3d& pt2)
{
	AecInterface inf0,inf2;
	pPipe1->GetInterface(0,inf0);
	pPipe2->GetInterface(1,inf2);

	AcGeVector3d vtNorm = inf0.vtDir.crossProduct(inf2.vtDir);
	AcGePlane plan;
	plan.set(inf0.ptPos,vtNorm);

	AcDbCurve* pCrv1 = pPipe1->GetBaseCurve();
	AcDbCurve* pCrv2 = pPipe2->GetBaseCurve();

	bool bRelt = GetIntersectPoint2(pCrv1,pCrv2,pt2,plan);
	if (!bRelt)
	{
		acutPrintf(_T("\n选择的两个对象没有交集,管线连接失败!"));
	}
	DELETE_PTR(pCrv1);
	DELETE_PTR(pCrv2);
	
	return bRelt;
}

bool AecPipeLineTool::ConnectPipe1(AecDbEwPipe* pPipe1,AecDbEwPipe* pPipe2,int nWeldType,AcDbVoidPtrArray& arPipePtrs,AcDbVoidPtrArray& arFittPtrs)
{
	if (pPipe1 == NULL || pPipe2 == NULL)
		return false;

	AecInterface inf0,inf2;
	pPipe1->GetInterface(0,inf0);
	pPipe2->GetInterface(1,inf2);
	AcGePoint3d ptInt,pt1,pt3;

	if (inf0.vtDir.isParallelTo(inf2.vtDir))//平行
	{
		//如果是共线
		AcGeVector3d vtDir02 = inf2.ptPos - inf0.ptPos;
		if (vtDir02.isParallelTo(inf0.vtDir))
		{
			//并且直径相同
			double dDn1 = 0.0,dDn2 = 0.0;
			pPipe1->GetSpecialtyData()->GetAt(PIPE_DN,dDn1);
			pPipe2->GetSpecialtyData()->GetAt(PIPE_DN,dDn2);

			if (fabs(dDn1 - dDn2) < 1.e-3)
			{
				//合成一根管子
				AecInterface inf1;
				pPipe1->GetInterface(1,inf1);

				AecInterface inf3;
				pPipe2->GetInterface(0,inf3);

				AcGePoint3dArray arPts;
				arPts.append(inf0.ptPos);
				arPts.append(inf1.ptPos);
				arPts.append(inf2.ptPos);
				arPts.append(inf3.ptPos);
					
				AcDbLine ln;
				ln.setStartPoint(inf0.ptPos);
				ln.setEndPoint(inf1.ptPos);
				SortPoints(arPts,&ln);

				pPipe1->SetStartPoint(arPts.first());
				pPipe1->SetEndPoint(arPts.last());

				pPipe2->GetSpecialtyData()->SetAt(_T("erase"),TRUE);
				
				return true;
			}
			else
			{
				return false;
			}
		}
		else
		{
			//取共有中点
			AecInterface inf1,inf3;
			pPipe1->GetInterface(1,inf1);
			pPipe2->GetInterface(0,inf3);

			AcDbLine ln(inf0.ptPos,inf1.ptPos);
			ln.getClosestPointTo(inf2.ptPos,pt1,Adesk::kTrue);
			ln.getClosestPointTo(inf3.ptPos,pt3,Adesk::kTrue);

			AcGePoint3dArray arPts;
			arPts.append(inf0.ptPos);
			arPts.append(pt1);
			arPts.append(pt3);
			arPts.append(inf1.ptPos);

			SortPoints(arPts,&ln);
			if (arPts.at(1).distanceTo(arPts.at(2)) < 1.e-1)
			{
				//重合
				return false;
			}
			ptInt = CoreTools::MidPt(arPts.at(1),arPts.at(2));
		}
	}
	else
	{
		double dDn1 = 0.0,dDn2 = 0.0,dt = 0.0;
		pPipe1->GetSpecialtyData()->GetAt(PIPE_DN,dDn1);
		pPipe2->GetSpecialtyData()->GetAt(PIPE_DN,dDn2);

		AecDbObjXDataMap* pMap1 = pPipe1->GetSpecialtyData();
		AecDbObjXDataMap* pMap2 = pPipe2->GetSpecialtyData();

		//取最小
		AecDbObjXDataMap* pMap = (dDn1 - dDn2 > 1.e-2) ? pMap2 : pMap1;

		if ( !GetIntersectPoint(pPipe1,pPipe2,ptInt) )
		{
			pPipe2->getClosestPointTo(ptInt,pt3,Adesk::kTrue);
			pPipe1->getClosestPointTo(ptInt,pt1,Adesk::kTrue);

			double dParam = 0.0;
			if (Acad::eOk == pPipe2->getParamAtPoint(pt3,dParam))//pipe2 上不延长,pipe1延长
			{
				
			}
			else//pipe2 延长,互换为 pipe1延长
			{
				AecDbEwPipe* pPipeTmp = pPipe1;
				pPipe1 = pPipe2;
				pPipe2 = pPipeTmp;

				AcGePoint3d ptTmp = pt1;
				pt1 = pt3;
				pt3 = ptTmp;
			}

			AcGeVector3d vtMaj = pPipe1->EndPoint() - pt1;
			vtMaj.normalize();

			AcGeVector3d vtMin = pt3 - pt1;
			vtMin.normalize();

			double dRRato = 1.5;
			pMap2->GetAt(PIPE_RATIO,dRRato);
			if (dRRato < 1.e-1)
			{
				dRRato = 1.5;
			}

			if (m_dRRato > 1.0)
				dRRato = m_dRRato;

			AecDbEwFitting* pElbow = CreateElbow(pMap,vtMaj,vtMin,pt1,dRRato);
			if (pElbow != NULL)
			{
				arFittPtrs.append(pElbow);

				AecInterface inf1,inf2;
				pElbow->GetInterface(0,inf1);
				pElbow->GetInterface(1,inf2);

				AcGePoint3d pt1,pt31;
				if (inf1.vtDir.isParallelTo(vtMaj))
				{
					pt1 = inf1.ptPos;
					pt31 = inf2.ptPos;
				}
				else
				{
					pt1 = inf2.ptPos;
					pt31 = inf1.ptPos;
				}

				AcGePoint3d ptEnd = pPipe1->EndPoint();
				AcGePoint3d ptSta = pPipe1->StartPoint();

				if (pt1.distanceTo(ptSta) < pt1.distanceTo(ptEnd))
				{
					pPipe1->SetStartPoint(pt1);
				}
				else
				{
					pPipe1->SetEndPoint(pt1);
				}

				AecDbEwPipe* pPipeNew = CreatePipe(pMap,pt3,pt31);
				if (pPipeNew != NULL)
				{
					arPipePtrs.append(pPipeNew);
				}
			}
			return true;
		}	
	}

	AecDbObjXDataMap* pMap2 = pPipe2->GetSpecialtyData();

	//if (nWeldType == 1)//焊接连接
	{
		//最小直径管
		pPipe2->getClosestPointTo(ptInt,pt3,Adesk::kTrue);
		pPipe1->getClosestPointTo(ptInt,pt1,Adesk::kTrue);

		//AecDbEwPipe* pPipeNew = CreatePipe(pMap2,pt2,pt3);

		AecDbEwPipe* pPipeOther = NULL;
		AecDbEwFitting* pNewTee = NULL;
		AecDbEwPipe* pPipeNew = CreatePipe(pMap2,pt1,pt3,pPipe1,pPipe2,nWeldType,pNewTee,pPipeOther);
		if (nWeldType == 1)
		{
			if (pPipeNew != NULL)
			{
				CopyPipeLayerAndLineTypeFromTo(pPipe1,pPipeNew);
				arPipePtrs.append(pPipeNew);
				return true;
			}
		}

		if (pPipeOther != NULL)
		{
			arPipePtrs.append(pPipeOther);
		}
		if (pNewTee != NULL)
		{
			arFittPtrs.append(pNewTee);
		}

		if (pPipeNew != NULL && pNewTee != NULL)
		{
			pPipeOther = NULL;
			pNewTee->GetInterface(2,inf2);
			pNewTee = NULL;
		
			AecDbEwPipe* pPipeNew2 = CreatePipe(pMap2,inf2.ptPos,pt3,pPipe1,pPipe2,nWeldType,pNewTee,pPipeOther);
			if (pPipeNew2 != NULL)
			{
				CopyPipeLayerAndLineTypeFromTo(pPipe1,pPipeNew2);
				arPipePtrs.append(pPipeNew2);
			}

			if (pPipeOther != NULL)
			{
				arPipePtrs.append(pPipeOther);
			}
			if (pNewTee != NULL)
			{
				arFittPtrs.append(pNewTee);
			}
		}
	}
	return true;
}

bool AecPipeLineTool::ConnectPipe2(AecDbEwPipe* pPipe1,AecDbEwPipe* pPipe2,int nWeldType,int nOffsetDir,double dOffset,AcDbVoidPtrArray& arPipePtrs,AcDbVoidPtrArray& arFittPtrs)
{
	if (pPipe1 == NULL || pPipe2 == NULL)
		return false;

	AecInterface inf0,inf2;
	pPipe1->GetInterface(0,inf0);
	pPipe2->GetInterface(1,inf2);

	AcGePoint3d pt2;
	pPipe2->getClosestPointTo(inf0.ptPos,pt2,Adesk::kTrue);

	if (pt2.distanceTo(inf0.ptPos) < 1.e-1)
	{
		acutPrintf(_T("\n两管距离太近!无法连接"));
		return false;
	}

	if (inf0.vtDir.isParallelTo(inf2.vtDir))//平行
	{
		//直接连接
		return ConnectPipe1(pPipe1,pPipe2,nWeldType,arPipePtrs,arFittPtrs);
	}
	else
	{
		//求交
		AcGePoint3d ptInt,pt1,pt2;
		if ( !GetIntersectPoint(pPipe1,pPipe2,ptInt) )
		{
			return false;
		}	

		pPipe1->getClosestPointTo(ptInt,pt1,Adesk::kTrue);
		pPipe2->getClosestPointTo(ptInt,pt2,Adesk::kTrue);

		AcGeVector3d vtZ = pt2 - pt1;
		AcGeVector3d vtZbk = vtZ;
		vtZ.normalize();

		AcGeVector3d vtMove = pPipe1->EndPoint() - pPipe1->StartPoint();
		vtMove.normalize();
		vtMove *= dOffset;

		int nDir = nOffsetDir == 0 ? 1 : -1;
		vtMove *= nDir;

		pt1 += vtMove;

		//if (nWeldType == 1) //焊接
		{
			AecDbObjXDataMap* pMap2 = pPipe2->GetSpecialtyData();

			//取曲率半径
			double dRRato = 1.5;
			pMap2->GetAt(PIPE_RATIO,dRRato);
			if (dRRato < 1.e-1)
			{
				dRRato = 1.5;
			}
			if (m_dRRato > 1.0)
				dRRato = m_dRRato;

			double dt = 0.0;
			double dDn = 0.0;
			double dDist = vtZbk.length();
			pMap2->GetAt(PIPE_DN,dDn);
			pMap2->GetAt(PIPE_THICK,dt);

			dDist -= dRRato * 0.5 * dDn;
			if ( dDist < 1.e-1)
			{
				//距离太小,只能直连
				return ConnectPipe1(pPipe1,pPipe2,nWeldType,arPipePtrs,arFittPtrs);
			}

			AcGePoint3d ptEnd = pt1 + vtZ * dDist;
			
			
			/*
			AecDbEwPipe* pPipeNew = CreatePipe(pMap2,pt1,ptEnd);
			if (pPipeNew != NULL)
			{
				arPipePtrs.append(pPipeNew);
			}*/


			AecDbEwPipe* pPipeOther = NULL;
			AecDbEwFitting* pNewTee = NULL;
			AecDbEwPipe* pPipeNew = CreatePipe(pMap2,pt1,ptEnd,pPipe1,pPipe2,nWeldType,pNewTee,pPipeOther);
			if (pPipeNew != NULL)
			{
				CopyPipeLayerAndLineTypeFromTo(pPipe1,pPipeNew);
				arPipePtrs.append(pPipeNew);
			}
			if (pPipeOther != NULL)
			{
				arPipePtrs.append(pPipeOther);
			}
			if (pNewTee != NULL)
			{
				arFittPtrs.append(pNewTee);
			}


			//创建弯头
			AcGePoint3d ptE = pt1 + vtZbk;
			AcGePoint3d ptE1;
			pPipe2->getClosestPointTo(ptE,ptE1,Adesk::kTrue);
			AcGeVector3d vtMaj = ptE1 - ptE;
			vtMaj.normalize();

			AecDbEwFitting* pElbow = CreateElbow(pMap2,vtMaj,vtZ.negate(),ptE,dRRato);
			if (pElbow != NULL)
			{
				arFittPtrs.append(pElbow);
			}

			ptEnd = ptE + vtMaj * dRRato * 0.5 * dDn;
			
			
			/*pPipeNew = CreatePipe(pMap2,ptE1,ptEnd);
			if (pPipeNew != NULL)
			{
				arPipePtrs.append(pPipeNew);
			}*/

			pPipeOther = NULL;
			pNewTee = NULL;
			pPipeNew = CreatePipe(pMap2,ptE1,ptEnd,pPipe1,pPipe2,nWeldType,pNewTee,pPipeOther);
			if (pPipeNew != NULL)
			{
				CopyPipeLayerAndLineTypeFromTo(pPipe1,pPipeNew);
				arPipePtrs.append(pPipeNew);
			}
			if (pPipeOther != NULL)
			{
				arPipePtrs.append(pPipeOther);
			}
			if (pNewTee != NULL)
			{
				arFittPtrs.append(pNewTee);
			}

		}
	}
	return true;
}

bool AecPipeLineTool::ConnectPipe3(AecDbEwPipe* pPipe1,AecDbEwPipe* pPipe2,int nWeldType,double dZSWeepAngle,int nOffsetDir,double dOffset,AcDbVoidPtrArray& arPipePtrs,AcDbVoidPtrArray& arFittPtrs)
{
	if (pPipe1 == NULL || pPipe2 == NULL)
		return false;

	AecInterface inf0,inf2;
	pPipe1->GetInterface(0,inf0);
	pPipe2->GetInterface(1,inf2);

	AcGePoint3d pt2;
	pPipe2->getClosestPointTo(inf0.ptPos,pt2,Adesk::kTrue);

	if (pt2.distanceTo(inf0.ptPos) < 1.e-1)
	{
		acutPrintf(_T("\n两管距离太近!无法连接"));
		return false;
	}

	if (inf0.vtDir.isParallelTo(inf2.vtDir))//平行
	{
		//直接连接
		return ConnectPipe1(pPipe1,pPipe2,nWeldType,arPipePtrs,arFittPtrs);
	}
	else
	{
		//求交
		AcGePoint3d ptInt,pt1,pt2;
		if ( !GetIntersectPoint(pPipe1,pPipe2,ptInt) )
		{
			return false;
		}

		pPipe1->getClosestPointTo(ptInt,pt1,Adesk::kTrue);
		pPipe2->getClosestPointTo(ptInt,pt2,Adesk::kTrue);

		AcGeVector3d vtZ = pt2 - pt1;
		AcGeVector3d vtMove = pPipe1->EndPoint() - pPipe1->StartPoint();
		vtMove.normalize();
		vtMove *= dOffset;

		int nDir = nOffsetDir == 0 ? 1 : -1;
		vtMove *= nDir;

		AcGePoint3d ptFr = pt1 + vtMove;

		//弯头中心点
		AcGePoint3d ptMid = ptFr + 0.5 * vtZ;

		AcGePoint3d pt22;
		pPipe2->getClosestPointTo(ptMid,pt22,Adesk::kTrue);

		double dDn1 = 0.0,dDn2 = 0.0,dt = 0.0;
		pPipe1->GetSpecialtyData()->GetAt(PIPE_DN,dDn1);
		pPipe2->GetSpecialtyData()->GetAt(PIPE_DN,dDn2);

		AecDbObjXDataMap* pMap1 = pPipe1->GetSpecialtyData();
		AecDbObjXDataMap* pMap2 = pPipe2->GetSpecialtyData();

		//取最小
		AecDbObjXDataMap* pMap = (dDn1 - dDn2 > 1.e-2) ? pMap2 : pMap1;

		//取曲率半径
		double dRRato = 1.5;
		pMap->GetAt(PIPE_RATIO,dRRato);
		if (dRRato < 1.e-1)
		{
			dRRato = 1.5;
		}
		if (m_dRRato > 1.0)
			dRRato = m_dRRato;

		AcGeVector3d vtMin = pt22 - ptMid;
		AecDbEwFitting* pElbow = CreateElbow(pMap,-vtZ,vtMin,ptMid,dRRato);
		if (pElbow != NULL)
		{
			arFittPtrs.append(pElbow);

			//创建两个直管
			AecInterface inf1,inf3;
			pElbow->GetInterface(0,inf1);
			pElbow->GetInterface(1,inf3);

			if (inf1.vtDir.isParallelTo(vtZ))
			{
				/*AecDbEwPipe* pPipeNew = CreatePipe(pMap,ptFr,inf1.ptPos);
				if (pPipeNew != NULL)
				{
					arPipePtrs.append(pPipeNew);
				}*/

				AecDbEwPipe* pPipeOther = NULL;
				AecDbEwFitting* pNewTee = NULL;
				AecDbEwPipe* pPipeNew = CreatePipe(pMap,ptFr,inf1.ptPos,pPipe1,pPipe2,nWeldType,pNewTee,pPipeOther);
				if (pPipeNew != NULL)
				{
					CopyPipeLayerAndLineTypeFromTo(pPipe1,pPipeNew);
					arPipePtrs.append(pPipeNew);
				}
				if (pPipeOther != NULL)
				{
					arPipePtrs.append(pPipeOther);
				}
				if (pNewTee != NULL)
				{
					arFittPtrs.append(pNewTee);
				}


				/*pPipeNew = CreatePipe(pMap,inf3.ptPos,pt22);
				if (pPipeNew != NULL)
				{
					arPipePtrs.append(pPipeNew);
				}*/

				pPipeOther = NULL;
				pPipeNew = NULL;
				pNewTee = NULL;
				pPipeNew = CreatePipe(pMap,inf3.ptPos,pt22,pPipe1,pPipe2,nWeldType,pNewTee,pPipeOther);
				if (pPipeNew != NULL)
				{
					CopyPipeLayerAndLineTypeFromTo(pPipe1,pPipeNew);
					arPipePtrs.append(pPipeNew);
				}
				if (pPipeOther != NULL)
				{
					arPipePtrs.append(pPipeOther);
				}
				if (pNewTee != NULL)
				{
					arFittPtrs.append(pNewTee);
				}
			}
			else
			{
				/*AecDbEwPipe* pPipeNew = CreatePipe(pMap,ptFr,inf3.ptPos);
				if (pPipeNew != NULL)
				{
					arPipePtrs.append(pPipeNew);
				}
				*/

				AecDbEwPipe* pPipeOther = NULL;
				AecDbEwFitting* pNewTee = NULL;
				AecDbEwPipe* pPipeNew = CreatePipe(pMap,ptFr,inf3.ptPos,pPipe1,pPipe2,nWeldType,pNewTee,pPipeOther);
				if (pPipeNew != NULL)
				{
					CopyPipeLayerAndLineTypeFromTo(pPipe1,pPipeNew);
					arPipePtrs.append(pPipeNew);
				}
				if (pPipeOther != NULL)
				{
					arPipePtrs.append(pPipeOther);
				}
				if (pNewTee != NULL)
				{
					arFittPtrs.append(pNewTee);
				}


				/*
				pPipeNew = CreatePipe(pMap,inf1.ptPos,pt22);
				if (pPipeNew != NULL)
				{
					arPipePtrs.append(pPipeNew);
				}*/


				pPipeOther = NULL;
				pPipeNew = NULL;
				pNewTee = NULL;

				pPipeNew = CreatePipe(pMap,inf1.ptPos,pt22,pPipe1,pPipe2,nWeldType,pNewTee,pPipeOther);
				if (pPipeNew != NULL)
				{
					CopyPipeLayerAndLineTypeFromTo(pPipe1,pPipeNew);
					arPipePtrs.append(pPipeNew);
				}
				if (pPipeOther != NULL)
				{
					arPipePtrs.append(pPipeOther);
				}
				if (pNewTee != NULL)
				{
					arFittPtrs.append(pNewTee);
				}

			}
		}
	}
	return true;
}

bool AecPipeLineTool::ConnectPipe4(AecDbEwPipe* pPipe1,AecDbEwPipe* pPipe2,int nWeldType,int nOffsetDir,double dOffset,double dTopSpace,AcDbVoidPtrArray& arPipePtrs,AcDbVoidPtrArray& arFittPtrs)
{

	if (pPipe1 == NULL || pPipe2 == NULL)
		return false;

	AecInterface inf0,inf2;
	pPipe1->GetInterface(0,inf0);
	pPipe2->GetInterface(1,inf2);

	AcGePoint3d pt2;
	pPipe2->getClosestPointTo(inf0.ptPos,pt2,Adesk::kTrue);

	if (pt2.distanceTo(inf0.ptPos) < 1.e-1)
	{
		acutPrintf(_T("\n两管距离太近!无法连接"));
		return false;
	}

	if (inf0.vtDir.isParallelTo(inf2.vtDir))//平行
	{
		//直接连接
		return ConnectPipe1(pPipe1,pPipe2,nWeldType,arPipePtrs,arFittPtrs);
	}
	else
	{
		double dDn1 = 0.0,dDn2 = 0.0,dt = 0.0;
		pPipe1->GetSpecialtyData()->GetAt(PIPE_DN,dDn1);
		pPipe2->GetSpecialtyData()->GetAt(PIPE_DN,dDn2);

		AecDbObjXDataMap* pMap1 = pPipe1->GetSpecialtyData();
		AecDbObjXDataMap* pMap2 = pPipe2->GetSpecialtyData();

		//取最小
		AecDbObjXDataMap* pMap = (dDn1 - dDn2 > 1.e-2) ? pMap2 : pMap1;

		//取曲率半径
		double dRRato = 1.5;
		pMap->GetAt(PIPE_RATIO,dRRato);
		if (dRRato < 1.e-1)
		{
			dRRato = 1.5;
		}
		if (m_dRRato > 1.0)
			dRRato = m_dRRato;

		AcGePoint3d pt00,pt11;
		pPipe1->getStartPoint(pt00);
		pPipe2->getStartPoint(pt11);

		//求交
		AcGePoint3d ptInt,pt1,pt2;
		if ( !GetIntersectPoint(pPipe1,pPipe2,ptInt) )
		{
			return false;
		}

		pPipe1->getClosestPointTo(ptInt,pt1,Adesk::kTrue);
		pPipe2->getClosestPointTo(ptInt,pt2,Adesk::kTrue);

		AcGeVector3d vtZ = pt2 - pt1;
		AcGeVector3d vtMove = pPipe1->EndPoint() - pPipe1->StartPoint();
		vtMove.normalize();
		vtMove *= dOffset;

		int nDir = nOffsetDir == 0 ? 1 : -1;
		vtMove *= nDir;

		AcGePoint3d ptFr = pt1 + vtMove;

		AcGeVector3d vtZn = vtZ;
		vtZn.normalize();

		AcGePoint3d ptTo = ptFr + vtZ;
		AcGePoint3d ptE;
		pPipe2->getClosestPointTo(ptTo,ptE);
		AcGeVector3d vtMin = ptE - ptTo;
		ptTo += vtZn * dTopSpace;

		//创建两个90弯头
		AcGePoint3d ptMid = ptTo;
		AcGeVector3d vtMaj = vtZn.negate();
		
		AecDbEwFitting* pElbow = CreateElbow(pMap,vtMaj,vtMin,ptMid,dRRato);
		if (pElbow != NULL)
		{
			//LEFT
			arFittPtrs.append(pElbow);

			AecInterface infE1,infE2;
			pElbow->GetInterface(0,infE1);
			pElbow->GetInterface(1,infE2);

			AcGePoint3d ptHSta;
			AcGePoint3d ptEnd;
			if (infE1.vtDir.isParallelTo(vtZn))
			{
				ptEnd = infE1.ptPos;
				ptHSta = infE2.ptPos;
			}
			else
			{
				ptEnd = infE2.ptPos;
				ptHSta = infE1.ptPos;
			}

			/*
			AecDbEwPipe* pPipe = CreatePipe(pMap,ptFr,ptEnd);
			if (pPipe != NULL)
			{
				arPipePtrs.append(pPipe);
			}*/

			AecDbEwPipe* pPipeOther = NULL;
			AecDbEwFitting* pNewTee = NULL;
			AecDbEwPipe* pPipeNew = CreatePipe(pMap,ptFr,ptEnd,pPipe1,pPipe2,nWeldType,pNewTee,pPipeOther);
			if (pPipeNew != NULL)
			{
				CopyPipeLayerAndLineTypeFromTo(pPipe1,pPipeNew);
				arPipePtrs.append(pPipeNew);
			}
			if (pPipeOther != NULL)
			{
				arPipePtrs.append(pPipeOther);
			}
			if (pNewTee != NULL)
			{
				arFittPtrs.append(pNewTee);
			}


			//Right
			vtZn.negate();
			AcGePoint3d ptMid2 = ptE + dTopSpace * vtZn;
			AcGeVector3d vtMaj2 = vtMin;
			vtMaj2.negate();
			AcGeVector3d vtMin2 = vtMaj;

			pElbow = CreateElbow(pMap,vtMaj2,vtMin2,ptMid2,dRRato);
			if (pElbow != NULL)
			{
				arFittPtrs.append(pElbow);

				//水平管子
				AcGePoint3d ptVSta;
				AcGePoint3d ptHEnd;
				pElbow->GetInterface(0,infE1);
				pElbow->GetInterface(1,infE2);

				if (infE1.vtDir.isParallelTo(vtZn))
				{
					ptHEnd = infE2.ptPos;
					ptVSta = infE1.ptPos;
				}
				else
				{
					ptHEnd = infE1.ptPos;
					ptVSta = infE2.ptPos;
				}

				pPipeNew = CreatePipe(pMap,ptHSta,ptHEnd);
				if (pPipeNew != NULL)
				{
					CopyPipeLayerAndLineTypeFromTo(pPipe1,pPipeNew);
					arPipePtrs.append(pPipeNew);
				}


				/*
				pPipe = CreatePipe(pMap,ptVSta,ptE);
				if (pPipe != NULL)
				{
					arPipePtrs.append(pPipe);
				}*/

				pPipeOther = NULL;
				pPipeNew = NULL;
				pNewTee = NULL;

				pPipeNew = CreatePipe(pMap,ptVSta,ptE,pPipe1,pPipe2,nWeldType,pNewTee,pPipeOther);
				if (pPipeNew != NULL)
				{
					CopyPipeLayerAndLineTypeFromTo(pPipe1,pPipeNew);
					arPipePtrs.append(pPipeNew);
				}
				if (pPipeOther != NULL)
				{
					arPipePtrs.append(pPipeOther);
				}
				if (pNewTee != NULL)
				{
					arFittPtrs.append(pNewTee);
				}
			}
		}
	}
	return true;
}

bool AecPipeLineTool::ConnectPipe(AecDbEwPipe* pPipe1,AecDbEwPipe* pPipe2,int nType,int nWeldType,int nOffsetDir,
								  double dOffset,double dTopSpace,double dZSWeepAngle,double dRRato,
								  AcDbVoidPtrArray& arPipePtrs,AcDbVoidPtrArray& arFittPtrs)
{
	if (pPipe1 == NULL || pPipe2 == NULL)
		return false;

	m_dRRato = dRRato;

	double dDn1 = 0.0,dDn2 = 0.0;
	pPipe1->GetSpecialtyData()->GetAt(PIPE_DN,dDn1);
	pPipe2->GetSpecialtyData()->GetAt(PIPE_DN,dDn2);

	AecDbEwPipe* pPipe11,* pPipe22 = NULL;
	pPipe11 = (dDn1 - dDn2 > -1.e-10) ? pPipe1 : pPipe2;
	pPipe22 = (pPipe11 == pPipe1) ? pPipe2 : pPipe1;

	bool bSuess = false;
	switch(nType)
	{
	case 0://立管直连
		{
			bSuess = ConnectPipe1(pPipe11,pPipe22,nWeldType,arPipePtrs,arFittPtrs);
			break;
		}
	case 1://侧向连接
		{
			bSuess = ConnectPipe2(pPipe11,pPipe22,nWeldType,nOffsetDir,dOffset,arPipePtrs,arFittPtrs);
			break;
		}
	case 2://斜弯连接
		{
			bSuess = ConnectPipe3(pPipe11,pPipe22,nWeldType,dZSWeepAngle,nOffsetDir,dOffset,arPipePtrs,arFittPtrs);
			break;
		}
	case 3://上弯连接
		{
			bSuess = ConnectPipe4(pPipe11,pPipe22,nWeldType,nOffsetDir,dOffset,dTopSpace,arPipePtrs,arFittPtrs);
			break;
		}
	default:
		break;
	}
	return bSuess ;
}

bool AecPipeLineTool::PipeExit(AecDbEwPipe* pPipeMaj,double dOD,double dDn,double dt,int nWeldType,const AecInterface& infTo,AcDbVoidPtrArray& arPipePtrs,AcDbVoidPtrArray& arFittPtrs)
{
	//测试infto
	AcDbXline* pRay = new AcDbXline;
	pRay->setBasePoint(infTo.ptPos);
	pRay->setUnitDir(infTo.vtDir);
	pRay->setColorIndex(1);
	/*AddToModelSpace(pRay,NULL,true);*/

	AecDbObjXDataMap* pMap = new AecDbObjXDataMap;
	pMap->CopyFrom(pPipeMaj->GetSpecialtyData());
	double dRato = 1.5;
	pPipeMaj->GetSpecialtyData()->GetAt(PIPE_RATIO,dRato);
	if (dRato < 1.0)
		dRato = 1.5;

	if (m_dRRato > 1.0)
		dRato = m_dRRato;

	pMap->SetAt(PIPE_DN,dDn);
	pMap->SetAt(PIPE_OD,dOD);
	pMap->SetAt(PIPE_THICK,dt);

	AcDbCurve* pCurve1 = pPipeMaj->GetBaseCurve();

	AecInterface inf0,inf2;
	pPipeMaj->GetInterface(0,inf0);
	pPipeMaj->GetInterface(1,inf2);

	AcGeVector3d vtNorm = infTo.vtDir.crossProduct(inf2.vtDir);
	AcGePlane plan;
	plan.set(inf0.ptPos,vtNorm);

	AcGePoint3d ptMid;
	AcGePoint3d ptInt;
	AcGeVector3d vtMaj,vtMin;
	AecDbEwFitting* pFitting = NULL;

	if (inf0.vtDir.isParallelTo(infTo.vtDir))//平行
	{
		pCurve1->getClosestPointTo(infTo.ptPos,ptInt,Adesk::kTrue);

		AcGeVector3d vtT = ptInt - infTo.ptPos;
		AcGeVector3d vtT2 = vtT.orthoProject(AcGeVector3d::kZAxis);

		//只处理平行XY面的特殊情况
		AcGeLine3d ln3d;
		ln3d.set(infTo.ptPos,infTo.vtDir);
		AcGeLine3d ln3d2;
		ln3d2.set(inf0.ptPos,inf0.vtDir);

		if (AcGePlane::kXYPlane.isParallelTo( ln3d ) &&
			AcGePlane::kXYPlane.isParallelTo( ln3d2))
		{
			vtMaj = vtT2;
			vtMin = infTo.vtDir;

			ptMid = infTo.ptPos - infTo.vtDir * dRato * 0.5 * dDn;
			pFitting = CreateElbow(pMap,vtMaj,vtMin,ptMid,dRato);
			if (pFitting != NULL)
			{
				arFittPtrs.append(pFitting);
			}

			AecInterface inf11,inf13,infT;
			pFitting->GetInterface(0,inf11);
			pFitting->GetInterface(1,inf13);
			
			AcDbXline xln;
			if (inf11.vtDir.isParallelTo(vtMaj))
			{
				xln.setBasePoint(inf11.ptPos);
			}
			else
			{
				xln.setBasePoint(inf13.ptPos);
				pFitting->GetInterface(1,inf11);
				pFitting->GetInterface(0,inf13);
			}
			xln.setUnitDir(vtMaj);

			AcGePoint3d ptMid2;
			pCurve1->getClosestPointTo(ptMid,ptMid2,Adesk::kTrue);

			AcGePoint3d ptMid3;
			xln.getClosestPointTo(ptMid2,ptMid3);

			//创建弯头
			vtMaj.negate();
			vtMin = ptMid2 - ptMid3;
			vtMin.normalize();

			pFitting = CreateElbow(pMap,vtMaj,vtMin,ptMid3,dRato);
			if (pFitting != NULL)
			{
				arFittPtrs.append(pFitting);
			}

			AecInterface inf21,inf23;
			pFitting->GetInterface(0,inf21);
			pFitting->GetInterface(1,inf23);

			if (inf21.vtDir.isParallelTo(inf11.vtDir))
			{
				AecDbEwPipe* pPipeNew2 = CreatePipe(pMap,inf21.ptPos,inf11.ptPos);
				if (pPipeNew2 != NULL)
				{
					CopyPipeLayerAndLineTypeFromTo(pPipeMaj,pPipeNew2);
					arPipePtrs.append(pPipeNew2);
				}

				pPipeNew2 = CreatePipe(pMap,inf23.ptPos,ptMid2);
				if (pPipeNew2 != NULL)
				{
					CopyPipeLayerAndLineTypeFromTo(pPipeMaj,pPipeNew2);
					arPipePtrs.append(pPipeNew2);
				}
			}
			else if(inf23.vtDir.isParallelTo(inf11.vtDir))
			{
				AecDbEwPipe* pPipeNew2 = CreatePipe(pMap,inf23.ptPos,inf11.ptPos);
				if (pPipeNew2 != NULL)
				{
					CopyPipeLayerAndLineTypeFromTo(pPipeMaj,pPipeNew2);
					arPipePtrs.append(pPipeNew2);
				}

				pPipeNew2 = CreatePipe(pMap,inf21.ptPos,ptMid2);
				if (pPipeNew2 != NULL)
				{
					CopyPipeLayerAndLineTypeFromTo(pPipeMaj,pPipeNew2);
					arPipePtrs.append(pPipeNew2);
				}
			}
			return true;
		}

		double dOffset = dRato * 2.0 * dDn;
		ptInt -= dOffset * infTo.vtDir;
	}
	else
	{
		if (!GetIntersectPoint2(pCurve1,pRay,ptInt,plan) )
		{
			return false;
		}
	}

	pRay->getClosestPointTo(ptInt,ptMid,Adesk::kTrue);

	AcGePoint3d ptFr;
	pPipeMaj->getClosestPointTo(ptInt,ptFr,Adesk::kTrue);

	//先创建一弯头
	
	vtMaj = ptFr - ptMid;
	vtMin = infTo.vtDir;
	pFitting = CreateElbow(pMap,vtMaj,vtMin,ptMid,dRato);
	if (pFitting != NULL)
	{
		arFittPtrs.append(pFitting);
	}

	AecInterface inf1,inf3;
	pFitting->GetInterface(0,inf1);
	pFitting->GetInterface(1,inf3);

	AcGePoint3d ptVFr = inf1.ptPos;
	AcGePoint3d ptTo = inf3.ptPos;
	if (inf1.vtDir.isParallelTo(vtMaj))
	{
		ptTo = inf1.ptPos;
		ptVFr = inf3.ptPos;
	}
	
	AecDbEwPipe* pPipeOther = NULL;
	AecDbEwFitting* pTee = NULL;
	AecDbEwPipe* pPipeNew = CreatePipe(pMap,ptTo,ptFr,pPipeMaj,NULL,nWeldType,pTee,pPipeOther);
	if (pPipeNew != NULL)
	{
		CopyPipeLayerAndLineTypeFromTo(pPipeMaj,pPipeNew);
		arPipePtrs.append(pPipeNew);
	}

	if (pPipeOther != NULL)
	{
		arPipePtrs.append(pPipeOther);
	}

	if (pTee != NULL)
	{
		arFittPtrs.append(pTee);
	}

	//创建竖管
	ptTo = infTo.ptPos;

	double dDis1 = ptTo.distanceTo(ptVFr);
	double dDis2 = ptMid.distanceTo(ptVFr);

	AcGeVector3d vt1 = ptTo - ptMid;
	AcGeVector3d vt2 = ptVFr - ptMid;
	if ( !vt1.isCodirectionalTo(vt2)  )
	{
		//elbow 改向
		int nPos = arFittPtrs.find(pFitting);
		if (nPos != -1)
		{
			arFittPtrs.removeAt(nPos);
			DELETE_PTR(pFitting);
		}

		vtMin.negate();
		pFitting = CreateElbow(pMap,vtMaj,vtMin,ptMid,dRato);
		if (pFitting != NULL)
		{
			arFittPtrs.append(pFitting);

			pFitting->GetInterface(0,inf1);
			pFitting->GetInterface(1,inf3);

			ptVFr = inf1.ptPos;
			if (inf1.vtDir.isParallelTo(vtMaj))
			{
				ptVFr = inf3.ptPos;
			}
		}
	}

	pPipeNew = CreatePipe(pMap,ptVFr,ptTo);
	if (pPipeNew != NULL)
	{
		CopyPipeLayerAndLineTypeFromTo(pPipeMaj,pPipeNew);
		arPipePtrs.append(pPipeNew);
	}
	
	DELETE_PTR(pCurve1);
	DELETE_PTR(pRay);
	DELETE_PTR(pMap);
	return !arPipePtrs.isEmpty();
}

bool AecPipeLineTool::UShapeAoid(AecDbEwPipe* pPipe,AcGeVector3d& vtOffset,double dFrom,double dL,double dVSpace,double dAngle,double dAngleB,AcDbVoidPtrArray& arPipePtrs,AcDbVoidPtrArray& arFittPtrs)
{
	if (pPipe == NULL) return false;

	double dLen = pPipe->EndPoint().distanceTo(pPipe->StartPoint());
	if (dFrom + dL - dLen > -1.e-10)
	{
		acutPrintf(_T("原管线避让超出总长,创建U型避让失败!"));
		return false;
	}
	
	AcGeVector3d vtPipe = pPipe->EndPoint() - pPipe->StartPoint();
	vtPipe.normalize();

	AcGePoint3d ptFr = pPipe->StartPoint() + vtPipe * dFrom;
	AcGePoint3d ptMid = ptFr + vtPipe * 0.5 * dL;

	AecDbEwPipe* pPipeNew = AecPipeLineTool::BreakPipe(pPipe,ptMid,dL);
	if (pPipeNew != NULL)
	{
		arPipePtrs.append(pPipeNew);
	}

	double dRAngle = dAngle * PI / 180.0;
	double dRAngleB = dAngleB * PI / 180.0;

	AcGeVector3d vtMaj = vtPipe;
	vtMaj.negate();

	AcGeVector3d vtMin = vtPipe;

	AcGeVector3d vtNorm = vtOffset.crossProduct(vtPipe);
	vtMin.rotateBy(-dRAngle,vtNorm);
	if (vtMin.dotProduct(vtOffset) < -1.e-10)
		vtMin.negate();

	double dRatio = 1.5;
	pPipe->GetSpecialtyData()->GetAt(PIPE_RATIO,dRatio);

	if (m_dRRato > 1.0)
		dRatio = m_dRRato;

	double dDN = 0.0;
	pPipe->GetSpecialtyData()->GetAt(PIPE_DN,dDN);

	double dR = dRatio * 0.5 * dDN;
	double dLx = dR * tan(dRAngle / 2.0);
	AcGePoint3d ptMidE = ptFr + vtPipe * dLx;

	AecDbObjXDataMap* pMap = pPipe->GetSpecialtyData();
	AecDbEwFitting* pElbow1 = CreateElbow(pMap,vtMaj,vtMin,ptMidE,dRatio);
	if (pElbow1 != NULL)
	{
		arFittPtrs.append(pElbow1);
	}

	vtOffset.normalize();
	AcGePoint3d ptMid2 = ptMid + vtOffset * dVSpace;

	AcDbXline xLn1;
	xLn1.setBasePoint(ptMid2);
	xLn1.setUnitDir(vtPipe);

	AcDbXline xln2;
	xln2.setBasePoint(ptMidE);
	xln2.setUnitDir(vtMin);

	AcGePoint3dArray arPts;
	xLn1.intersectWith(&xln2,AcDb::kOnBothOperands,arPts);

	if (!arPts.isEmpty())
	{
		AcGePoint3d ptMid3 = arPts.first();

		vtMaj = vtMin;
		vtMaj.negate();

		vtMin = vtPipe;
		vtMin.normalize();

		AecDbEwFitting* pElbow2 = CreateElbow(pMap,vtMaj,vtMin,ptMid3,dRatio);
		if (pElbow2 != NULL)
		{
			arFittPtrs.append(pElbow2);
		}

		AecInterface inf0,inf1;
		pElbow1->GetInterface(0,inf0);
		pElbow1->GetInterface(1,inf1);

		AcGePoint3d ptFr1 = inf0.ptPos;
		if (vtMaj.isParallelTo(inf1.vtDir))
			ptFr1 = inf1.ptPos;

		pElbow2->GetInterface(0,inf0);
		pElbow2->GetInterface(1,inf1);

		AcGePoint3d ptFr3 = inf1.ptPos;
		AcGePoint3d ptTo1 = inf0.ptPos;
		if (vtMaj.isParallelTo(inf1.vtDir))
		{
			ptTo1 = inf1.ptPos;
			ptFr3 = inf0.ptPos;
		}

		AecDbEwPipe* pPipeL = CreatePipe(pMap,ptFr1,ptTo1);
		if (pPipeL != NULL)
		{
			arPipePtrs.append(pPipeL);
		}

		//镜像
		if ( fabs(dAngle - dAngleB) < 1.e-3)
		{
			AcGeLine3d ln;
			ln.set(ptMid2,vtOffset);
			AcGeMatrix3d xformMirror;
			xformMirror.setToMirroring(ln);

			AecDbEwFitting* pElbowR1 = (AecDbEwFitting*)pElbow1->clone();
			if (pElbowR1 != NULL)
			{
				pElbowR1->TransformBy(xformMirror);
				arFittPtrs.append(pElbowR1);
			}

			AecDbEwFitting* pElbowR2 = (AecDbEwFitting*)pElbow2->clone();
			if (pElbowR2 != NULL)
			{
				pElbowR2->TransformBy(xformMirror);
				arFittPtrs.append(pElbowR2);
			}

			AecDbEwPipe* pPipeR = (AecDbEwPipe*)pPipeL->clone();
			if (pPipeR != NULL)
			{
				pPipeR->TransformBy(xformMirror);
				arPipePtrs.append(pPipeR);
			}

			//中间管子
			pElbow2->GetInterface(0,inf0);
			pElbow2->GetInterface(1,inf1);
			
			ptFr1 = inf0.ptPos;
			if (vtPipe.isParallelTo(inf1.vtDir))
			{
				ptFr1 = inf1.ptPos;
			}

			ptTo1 = ptFr1;
			ptTo1.transformBy(xformMirror);

			AecDbEwPipe* pPipeOff = CreatePipe(pMap,ptFr1,ptTo1);
			if (pPipeOff != NULL)
			{
				arPipePtrs.append(pPipeOff);
			}
		}
		else
		{
			AcGePoint3d ptMidE2 = ptMid + vtPipe * 0.5 * dL;
			dLx = dR * tan(dRAngleB / 2.0);

			AcGePoint3d ptFr2 = ptMidE2;
			ptMidE2 -= vtPipe * dLx;

			vtMin = vtPipe;
			vtMin.rotateBy(-PI+dRAngleB,vtNorm);
			if (vtMin.dotProduct(vtOffset) < -1.e-10)
				vtMin.negate();

			vtMaj = vtPipe;
			AecDbEwFitting* pElbow3 = CreateElbow(pMap,vtMaj,vtMin,ptMidE2,dRatio);
			if (pElbow3 != NULL)
			{
				arFittPtrs.append(pElbow3);
			}

			pElbow3->GetInterface(0,inf0);
			pElbow3->GetInterface(1,inf1);

			AcGePoint3d ptTmp;
			if (inf0.vtDir.isParallelTo(vtPipe))
			{
				vtMin = inf1.vtDir;	
				ptTmp = inf1.ptPos;
			}
			else
			{
				vtMin = inf0.vtDir;
				ptTmp = inf0.ptPos;
			}
			vtMin.negate();

			AcDbXline xl1;
			xl1.setBasePoint(ptFr3);
			xl1.setUnitDir(vtPipe);

			AcDbXline xl2;
			xl2.setBasePoint(ptTmp);
			xl2.setUnitDir(vtMin);

			arPts.removeAll();
			xl1.intersectWith(&xl2,AcDb::kOnBothOperands,arPts);

			if (!arPts.isEmpty())
			{
				AcGePoint3d ptMidE3 = arPts.first();

				AcDbCircle* pCir3 = new AcDbCircle(ptMidE3,AcGeVector3d::kZAxis,0.5);
				pCir3->setColorIndex(2);
				AddToModelSpace(pCir3,NULL,true);

				vtMaj = vtPipe;
				vtMaj.negate();

				AecDbEwFitting* pElbow4 = CreateElbow(pMap,vtMaj,vtMin,ptMidE3,dRatio);
				if (pElbow4 != NULL)
				{
					arFittPtrs.append(pElbow4);
				}

				pElbow4->GetInterface(0,inf0);
				pElbow4->GetInterface(1,inf1);

				AcGePoint3d ptTmpFr;
				AcGePoint3d ptTo2;
				if (inf0.vtDir.isParallelTo(vtMin))
				{
					ptTmpFr = inf0.ptPos;
					ptTo2 = inf1.ptPos;
				}
				else
				{
					ptTmpFr = inf1.ptPos;
					ptTo2 = inf0.ptPos;
				}

				AecDbEwPipe* pPipeL1 = CreatePipe(pMap,ptFr3,ptTo2);
				if (pPipeL1 != NULL)
				{
					arPipePtrs.append(pPipeL1);
				}

				AecDbEwPipe* pPipeL2 = CreatePipe(pMap,ptTmpFr,ptTmp);
				if (pPipeL2 != NULL)
				{
					arPipePtrs.append(pPipeL2);
				}
			}
		}
	}
	return !arPipePtrs.isEmpty();
}

void AecPipeLineTool::CopyPipeLayerAndLineTypeFromTo(AecDbEwPipe* pPipe1,AecDbEwPipe* pPipe2)
{
	if (pPipe1 == NULL || pPipe2 == NULL)
		return;

	pPipe2->SetSingleLayer(pPipe1->GetSingleLayer());
	pPipe2->SetDoubleLayer(pPipe1->GetDoubleLayer());

	pPipe2->setLayer(pPipe1->layerId());
	pPipe2->setLinetype(pPipe1->linetypeId());


}