envi-code/SourceCode/Code2026/PipelineSpecCmd/AecPipeLine.cpp

#include "StdAfx.h"
#include "PipelineTools.h"
#include "aecPipeLine.h"
#include "AecAngleWatch.h"
#include "AECStatusRecord.h"
#include "aecPipeJig.h"
#include "aecPipeSupport.h"
#include "KTModelLayoutXData.h"
#include "coretools.h"
#include "AecDbX3dPartEntity.h"
#include "KTCADUtilityEx.h"

extern CString IDCreate();

#define GRIP_CMD _T("PL_wpipeadd")

namespace
{
	AcDbObjectId GetConnectObject(const AecInterface &intf, const CArray<AecInterface> &arr)
	{
		for (int i = 0; i < arr.GetSize(); ++i)
		{
			const AecInterface &ff(arr[i]);
			if (intf.ptPos == ff.ptPos && intf.idOwner != ff.idOwner) return ff.idOwner;
		}
		return AcDbObjectId::kNull;
	}

	void setInfo2Ent(AecDbObjXDataMap &xData)
	{
		CString sys;
		if (!xData.GetAt(PIPE_SYS, sys)) return;

		int clr;
		double dw;
		AcDbObjectId idLt, idLy;
		
		clr = CoreTools::getColorByPipeSys(sys, true);
		idLy = CoreTools::getLyByPipeSys(sys, true);
		idLt = CoreTools::getLtByPipeSys(sys, true);
		dw = CoreTools::getLwByPipeSys(sys, true);

		xData.SetAt(PIPE_COLOR, clr);
		xData.SetAt(PIPE_LINETYPE, idLt);
		xData.SetAt(PIPE_LINEWIDTH, dw);
		xData.SetAt(PIPE_LINELAYER, idLy);


		clr = CoreTools::getColorByPipeSys(sys, false);
		idLy = CoreTools::getLyByPipeSys(sys, false);
		idLt = CoreTools::getLtByPipeSys(sys, false);
		dw = CoreTools::getLwByPipeSys(sys, false);

		xData.SetAt(PIPE_COLOR_OUT, clr);
		xData.SetAt(PIPE_LINETYPE_OUT, idLt);
		xData.SetAt(PIPE_LINEWIDTH_OUT, dw);
		xData.SetAt(PIPE_LINELAYER_OUT, idLy);
	}

	AcGePoint3d MidPoint(const AcGePoint3d &pt1, const AcGePoint3d &pt2)
	{
		return AcGePoint3d((pt1.x + pt2.x) / 2.0,
			(pt1.y + pt2.y) / 2.0,
			(pt1.z + pt2.z) / 2.0);
	}
}

TDbPipeLine::TDbPipeLine(TDbPipeJig* pJig)
{
	m_pAngleWatch = new AecAngleWatch;
	m_pPipeJig = pJig;
	m_pPipeParam = NULL;
	m_pCurPipeLine[0] = NULL;
	m_pCurPipeLine[1] = NULL;
	m_bStopCommand = FALSE;
	m_idStartDragFrom = AcDbObjectId::kNull;
	m_bWipeClip = false;

	KTModelLayoutXData::ReadModelXData(KT_PIPEINIT,m_xInitDataMap);
}

TDbPipeLine::~TDbPipeLine(void)
{
	if ( m_pAngleWatch != NULL)
		DELETE_PTR(m_pAngleWatch);
}

void TDbPipeLine::SetPipeParam(WPipe::PipeParam* pPipePar)
{
	m_pPipeParam = pPipePar;
}

WPipe::PipeParam* TDbPipeLine::GetPipeParam()
{
	return m_pPipeParam;
}

double TDbPipeLine::GetEndElevation() const
{
	return m_pPipeParam->m_dEl;
}

AecInterface* TDbPipeLine::GetLastInterface()
{
	int nLen = m_arHistoryIntfs.GetSize();
	if (nLen > 0)
	{
		AecInterface& intf = m_arHistoryIntfs[nLen - 1];
		return &intf;
	}
	return NULL;
}

void TDbPipeLine::SetInitDataMapPartFrom(AecDbObjXDataMap* pXDataMapSrc)
{
	double dMinSW = 0.0;
	pXDataMapSrc->GetAt(KEY_SINGLEW,dMinSW);

	double dOutSW = 0.0;
	pXDataMapSrc->GetAt(KEY_DBLINEW,dOutSW);

	double dWD = 0.0;
	pXDataMapSrc->GetAt(DOC_WELDDIA,dWD);

	int nCr = 0;
	pXDataMapSrc->GetAt(PIPE_COLOR,nCr);

	//如果是米单位
	struct resbuf rb;
	acedGetVar(_T("INSUNITS"), &rb);
	if (rb.resval.rint == AcDb::kUnitsMeters)
	{
		dMinSW *= 1000.0;//还原
		dOutSW *= 1000.0;//还原
		dWD *= 1000.0;//还原
	}

	double dScale = 1.0;
	CString sScale;
	m_xInitDataMap.GetAt(DOC_SCALE, sScale);		//出图比例
	int nPos = sScale.Find(_T(':'));
	if (nPos != -1)
	{
		dScale = _ttof(sScale.Mid(nPos + 1));
	}

	dMinSW /= dScale;
	m_xInitDataMap.SetAt(DOC_PLOTWIDTH,dMinSW);	//单线线宽

	dOutSW /= dScale;
	m_xInitDataMap.SetAt(DOC_DPLOTWIDTH,dOutSW);//外双线线宽

	dWD /= dScale;
	m_xInitDataMap.SetAt(DOC_WELDDIA, dWD);		//焊点直径

	m_xInitDataMap.SetAt(PIPE_COLOR,nCr);
}

void TDbPipeLine::setEApp(WPipe::EApp app)
{
	if (m_pPipeParam)
		m_pPipeParam->m_app = app;
}

WPipe::EApp TDbPipeLine::getEApp()
{
	if (m_pPipeParam)
		return m_pPipeParam->m_app;
	else
		return WPipe::eNoneApp;
}

double TDbPipeLine::GetAngWatchSp() const
{
	return m_pAngleWatch->GetAngWatchSp();
}

void TDbPipeLine::SetAngWatchSp(double nSp)
{
	m_pAngleWatch->SetAngWatchSp(nSp);
}

void TDbPipeLine::SetFittingLayer(AecDbEwFitting *pFitting, LPCTSTR pszSys)
{
	AcDbObjectId idCenLay, idOutLay, idSingle, idDash, idCen;
	//OLD
	//idCenLay = CoreTools::AecInitLayerEx(LAY_FITN_CENTER,m_pPipeParam->szSys,4,_T("Center2"),NULL);
	//idOutLay = CoreTools::AecInitLayerEx(LAY_FITN_OUTSIDE,m_pPipeParam->szSys,6,_T("Continuous"),NULL);
	//idSingle = CoreTools::AecInitLayerEx(LAY_FITN_SINGLE,m_pPipeParam->szSys,6,_T("Continuous"),NULL);

	idCenLay = CoreTools::getLyByPipeSys(pszSys, true);
	idOutLay = CoreTools::getLyByPipeSys(pszSys, false);
	idSingle = CoreTools::getLyByPipeSys(pszSys, true);

	AecDbObjXDataMap *pXDataMap = pFitting->GetSpecialtyData();
	pXDataMap->SetAt(PIPE_CENTLAY, idCenLay);
	pXDataMap->SetAt(PIPE_OUTDLAY, idOutLay);
	pXDataMap->SetAt(PIPE_SINGLAY, idSingle);
	pXDataMap->SetAt(PIPE_SYS, pszSys);

	idDash = PipelineTools::AecInitLayerEx(LAY_FITN_DASH, 8, _T("DASH"), NULL);
	pFitting->setLayer(idCenLay);

	pFitting->SetDashLayer(idDash);
	pFitting->SetCenterLayer(idCenLay);
	pFitting->SetSingleLayer(idCenLay);
	pFitting->SetDoubleLayer(idOutLay);

	setInfo2Ent(*pXDataMap);
}

void TDbPipeLine::SetPipeLayer(AecDbEwPipe *pWpipe, LPCTSTR pszSys)
{
	AcDbObjectId idCenLay, idOutLay, idSingle, idDash, idCen;

	AcDbObjectId innLy = CoreTools::getLyByPipeSys(pszSys, true);
	AcDbObjectId outLy = CoreTools::getLyByPipeSys(pszSys, false);
	pWpipe->GetSpecialtyData(AcDb::kForWrite)->SetAt(PIPE_LINELAYER, innLy);
	pWpipe->GetSpecialtyData(AcDb::kForWrite)->SetAt(PIPE_LINELAYER, outLy);

	idCenLay = innLy;
	idOutLay = outLy;
	idSingle = innLy;

	AecDbObjXDataMap *pXDataMap = pWpipe->GetSpecialtyData();
	pXDataMap->SetAt(PIPE_CENTLAY, idCenLay);
	pXDataMap->SetAt(PIPE_OUTDLAY, idOutLay);
	pXDataMap->SetAt(PIPE_SINGLAY, idSingle);
	pXDataMap->SetAt(PIPE_SYS, pszSys);

	// 管线实体的图层
	AcDbObjectId idPipeLayer(CoreTools::getLyForPipe(pszSys));
	if (idPipeLayer.isValid())
		pWpipe->setLayer(idPipeLayer);
	// end

	idDash = CoreTools::AecInitLayerEx(LAY_PIPE_DASH, pszSys, 8, _T("dash"), NULL);
	pWpipe->SetDashLayer(idDash);

	pWpipe->SetCenterLayer(idCenLay);
	pWpipe->SetSingleLayer(idCenLay);
	pWpipe->SetDoubleLayer(idOutLay);

	setInfo2Ent(*pXDataMap);
}

BOOL TDbPipeLine::AddPipeNode(AECStatusRecord* pRec,WPipe::PipeDraw ePipe)
{
	switch(ePipe)
	{
	case WPipe::eToPreView:
		{
			if (m_pCurPipeLine[0] == NULL)
				m_pCurPipeLine[0] = new AecDbEwPipe;

			AecDbEwPipe* pWpipe = (AecDbEwPipe*)m_pCurPipeLine[0];
			AecDbObjXDataMap* pXDataMap = pWpipe->GetSpecialtyData();
			FillConfigXDataMap(pXDataMap,m_pPipeParam);

			pWpipe->SetSection(m_pPipeParam->m_dD, m_pPipeParam->m_dThick);

			setInfo2Ent(*pXDataMap);

			//设置图层
			AcDbObjectId idCenLay,idOutLay,idSingle;
			if (!pXDataMap->GetAt(PIPE_CENTLAY,idCenLay))
			{
				//idCenLay = PipelineTools::getSysLayer(m_pPipeJig->GetAdoDb(),m_pPipeParam->szSys);
				//idCenLay = CoreTools::AecInitLayerEx(LAY_PIPE_CENTER,m_pPipeParam->szSys,4,_T("center2"),NULL);
				//idOutLay = CoreTools::AecInitLayerEx(LAY_PIPE_OUTSIDE,m_pPipeParam->szSys,7,_T("Continuous"),NULL);
				//idSingle = CoreTools::AecInitLayerEx(LAY_PIPE_SINGLE,m_pPipeParam->szSys,7,_T("Continuous"),NULL);

				//pXDataMap->SetAt(PIPE_CENTLAY,idCenLay);
				//pXDataMap->SetAt(PIPE_OUTDLAY,idOutLay);
				//pXDataMap->SetAt(PIPE_SINGLAY,idSingle);
			}

			AcGePoint3d ptGe,ptGe1,ptGe2;
			ptGe = m_pPipeJig->GetTailStatusRec()->GetAcquirePoint();
			ptGe1 = pRec->GetAcquirePoint();

			pWpipe->SetStartPoint( ptGe );
			pWpipe->SetEndPoint( ptGe1 );

			AcGeVector3d vtDir = AcGeVector3d::kXAxis;
			vtDir = m_pAngleWatch->m_vtDir;

			m_pAngleWatch->m_bFallInSnap = FALSE;
			m_pAngleWatch->snapWatch(ptGe,ptGe1,vtDir);
			pRec->SetAcquirePoint(ptGe1);
			m_pAngleWatch->m_bFallInSnap = TRUE;

			break;
		}
	case WPipe::eToCreate:
		{
			AcGePoint3d ptGe,ptGe1;
			ptGe1 = m_pPipeJig->GetTailStatusRec()->GetAcquirePoint();
			ptGe = pRec->GetAcquirePoint();

			//判断方向是否一致
			int nLen = m_arHistoryIntfs.GetSize();
			if (nLen == 0)
			{
				CreateWPipe(pRec,TRUE); //考虑首尾三通
			}
			else
			{
				AecInterface tInf = m_arHistoryIntfs[nLen - 1];
				AcGeVector3d vtDir1 = tInf.vtDir;

				AcGeVector3d vtDir2 = ptGe - ptGe1;
				vtDir2.normalize();vtDir1.normalize();

				double dAng = 0;
				bool bEx = false;

				int nLen = m_arHistoryIntfs.GetSize();
				if (nLen >= 0)
				{
					AcGePoint3d ptCur = pRec->GetAcquirePoint();
					AcGePoint3d ptGeM = m_pPipeJig->GetTailStatusRec()->GetAcquirePoint();

					AcGeVector3d vtMaj, vtMin;
					vtMaj = m_arHistoryIntfs[nLen - 1].vtDir;
					vtMin = ptCur - ptGeM;
					dAng = vtMin.angleTo(vtMaj);
					if (dAng < PI / 40.0)
					{
						bEx = true;
					}
				}

				if (vtDir2.isParallelTo(vtDir1) || bEx) //平行,和上次同向,连续画
				{
					ExtendLastWPipe(pRec);
				}
				else //添加弯头过渡
				{
					EFittingType type(eElbow);
					if (getEApp() == WPipe::eDuct)
						type = eDuctElbow;
					else if (getEApp() == WPipe::eBridge)
						type = eBridgeElbow;

					CreateElbowAndPipe(pRec, type);
					m_pPipeParam->m_dEl = pRec->GetAcquirePoint().z;//4-24
				}
			}

			AcGeVector3d vtDir = AcGeVector3d::kXAxis;
			vtDir = m_pAngleWatch->m_vtDir;
			ptGe1.z = m_pPipeParam->m_dEl;
			ptGe.z = m_pPipeParam->m_dEl;

			m_pAngleWatch->m_bFallInSnap = FALSE;
			m_pAngleWatch->snapWatch(ptGe1,ptGe,vtDir);
			m_pAngleWatch->m_bFallInSnap = TRUE;

			break;
		}
	default:
		break;
	}
	return TRUE;
}

BOOL TDbPipeLine::QuerySetProjectLevel(AecDbObjXDataMap *pXDataMap, WPipe::PipeParam *pParam, LPCTSTR pszFitName)
{
	CString sProject = _T("工业");
	pXDataMap->GetAt(DOC_PROJECT, sProject);

	CString sLevel;
	if (!pXDataMap->GetAt(PIPE_LEVEL, sLevel))
	{
		sLevel = pParam->szLevel;
	}

	int nTrade = 0;
	pXDataMap->GetAt(DOC_TRADE, nTrade);		//行业
	WPipe::Trade eTrade = (WPipe::Trade)nTrade;

	CString sSNO;
	//查询项目等级 管件
	if (!TDbPipeSupport::QueryFitSpecsNo(m_pPipeJig->GetAdoDb(), pParam->m_dDN, sSNO, eTrade, pszFitName, sProject, sLevel))
	{
		return FALSE;
	}

	//外径系列
	pXDataMap->SetAt(PIPE_OD_SN, sSNO);

	return TRUE;
}

AcDbObjectId TDbPipeLine::AddFitToModelSpace(AecDbEwFitting *pFitting, bool bIsSureAdd2MSp /*= true*/)
{
	AecDbObjXDataMap *pXDataMap = pFitting->GetSpecialtyData();

	CString sProject = _T("工业");;
	pXDataMap->GetAt(DOC_PROJECT, sProject);

	CString sLevel;
	pXDataMap->GetAt(PIPE_LEVEL, sLevel);

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

	double dPre = 1.6;
	pXDataMap->GetAt(PIPE_PRESSURE, dPre);

	CString sFitName;
	pFitting->GetFittingName(sFitName);

	AcGeVector3d vtOff(0, 0, 0);

	int nType = 0;
	pXDataMap->GetAt(KEY_RUNTIME, nType);
	EFittingType eType = (EFittingType)nType;
	
	/*
	* [项目名称] varchar(255), 
	  [等级名称] varchar(250), 
	  [类别] varchar(250), 
	  [类型] varchar(250), 
	  [公称直径] INTEGER, 
	  [材质] varchar(50), 
	  [表号] varchar(250), 
	  [标准号] varchar(250), 
	  [外径系列] varchar(255), 
	  [描述] varchar(255), 
	*/

	CString sSQL;
	sSQL.Format(_T("select [项目名称],[等级名称],[类别],[类型],[公称直径],[材质],[表号],[标准号],[外径系列],[描述] from AecSpecFit where [项目名称]='%s' and")
		_T(" [等级名称]='%s' and [类别]='管件' and [类型]='%s'")
		_T(" and [公称直径]=%d"), sProject, sLevel, sFitName, (int)(dDN+0.5));

	CString sInfo;
	CStringArray arValues;
	m_pPipeJig->GetAdoDb()->GetSelData(sSQL, arValues);
	if (arValues.GetSize() >= 11)
	{
		for (int i = 1; i <= 9; i++)//最后一个为描述
		{
			if (i == 1)
			{
				sInfo = arValues.GetAt(i);
			}
			else
			{
				sInfo += _T("^") + arValues.GetAt(i);
			}
		}

		//统计信息
		pXDataMap->SetAt(PIPE_MTOALL, sInfo);
	}

	int nTrade = 0;
	pXDataMap->GetAt(DOC_TRADE, nTrade);		//行业
	WPipe::Trade eTrade = (WPipe::Trade)nTrade;

	WPipe::FITSPEC fitSpec;
	memset(&fitSpec, 0, sizeof(WPipe::FITSPEC));

	int nConnectType = 0;
	pXDataMap->GetAt(PIPE_CONNECT, nConnectType);
	if (nConnectType == 3 || nConnectType == 5 || eType == eFlange )//法兰管件 需要加 加垫片 和 螺栓 螺母 信息
	{
		//查询 外径系列，表号，标准号，材质，描述
		if (TDbPipeSupport::QueryFitSpecInf(m_pPipeJig->GetAdoDb(), dDN, fitSpec, eTrade, sFitName, sProject, sLevel))
		{
			//外径系列
			pXDataMap->SetAt(PIPE_OD_SN, fitSpec.szODSN);

			pXDataMap->SetAt(PIPE_SHTNO, fitSpec.szShtNo);

			pXDataMap->SetAt(PIPE_STDNO, fitSpec.szStdNo);

			pXDataMap->SetAt(PIPE_MATERIAL, fitSpec.szMat);

			pXDataMap->SetAt(PIPE_DESCR, fitSpec.szDesc);
		}

		AcArray<AecInterface> arInfs;
		pFitting->GetInterface(arInfs);

		double dPre = 1.0;
		pXDataMap->GetAt(PIPE_PRESSURE, dPre);

		for (int i = 0;i < arInfs.length();i++)
		{
			AecInterface &inf = arInfs.at(i);

			//管嘴 垫片
			TDbPipeSupport::SetGasketData(m_pPipeJig->GetAdoDb(),i, inf.dSize1, dPre, sProject, sLevel, pXDataMap);

			//管嘴 螺栓,螺母
			TDbPipeSupport::SetBoltData(m_pPipeJig->GetAdoDb(),i, inf.dSize1, dPre, sProject, sLevel, pXDataMap);
		}
	} 

	AcDbObjectId id = AcDbObjectId::kNull;
	if (bIsSureAdd2MSp)
	{
		//卡箍
		if (nConnectType == 4 && eType != eFlange && eType != eWcap)
		{
			CString sSQL;
			AecInterface inf;
			for (int i = 0;i < pFitting->GetInterfaceCount();i++)
			{
				pFitting->GetInterface(i, inf);
				AddFlxJoin(pXDataMap, inf);
			}
		}
		id = CoreTools::AddToModelSpace(pFitting);
	}
	return id;
}

AcDbObjectId TDbPipeLine::AddFlxJoin(AecDbObjXDataMap *pXDataMap ,const AecInterface& inf)
{
	CString sProject = _T("工业");;
	pXDataMap->GetAt(DOC_PROJECT, sProject);

	CString sLevel;
	pXDataMap->GetAt(PIPE_LEVEL, sLevel);

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

	double dPre = 1.6;
	pXDataMap->GetAt(PIPE_PRESSURE, dPre);

	CString sSQL;

	sSQL.Format(_T("select [尺寸A],[尺寸B],[尺寸C],[型号],[标准号] from AecFlxJoin where [公称直径]=%d and [压力]>%.3f and [压力]<%.3f"),
		(int)(inf.dSize1 + 0.5), dPre - 0.01, dPre + 0.01);

	CStringArray arVals;
	m_pPipeJig->GetAdoDb()->GetSelData(sSQL, arVals);

	if (arVals.GetSize() >= 5)
	{
		AecDbEwFitting *pFit = new AecDbEwFitting;
		SetFittingLayer(pFit, m_pPipeParam->szSys);

		AecDbObjXDataMap *pXD = pFit->GetSpecialtyData();
		FillConfigXDataMap(pXD, m_pPipeParam);

		pXD->SetAt(KEY_RUNTIME, eFlxJoin);
		pXD->SetAt(KEY_MAJBR, inf.vtDir);
		pXD->SetAt(KEY_MID, inf.ptPos);

		pXD->SetAt(KEY_A, _ttof(arVals.GetAt(0)));
		pXD->SetAt(KEY_B, _ttof(arVals.GetAt(1)));
		pXD->SetAt(KEY_C, _ttof(arVals.GetAt(2)));
		pXD->SetAt(KEY_TYPE, arVals.GetAt(3));
		pXD->SetAt(PIPE_STDNO, arVals.GetAt(4));
		pXD->SetAt(PIPE_DN, inf.dSize1);

		return CoreTools::AddToModelSpace(pFit);
	}
	return AcDbObjectId::kNull;
}

static BOOL IsGSFMaterial(LPCTSTR pszMertial)
{
	CString sMertial = pszMertial;
	//目前只能按照材质判断
	if (sMertial.Find(_T("衬塑")) != -1 ||
		sMertial.Find(_T("SRPE")) != -1 ||
		sMertial.Find(_T("HG/T 20538")) != -1)
	{
		return TRUE;
	}
	return FALSE;
}

AcDbObjectId TDbPipeLine::AddPipeToModelSpace(AecDbEwPipe *pPipe)
{
	AecDbObjXDataMap *pXDataMap = pPipe->GetSpecialtyData();

	//法兰管截断为若干单根,保证后期出系统图正确显示法兰
	int nConnectType = 0;
	pXDataMap->GetAt(PIPE_CONNECT, nConnectType);
	if (nConnectType == 3 || nConnectType == 5)
	{
		if (pPipe->GetFlangeCount(FALSE) > 2)
		{
			AcDbVoidPtrArray arPipes;
			pPipe->GetBreakFlangePipes(arPipes);

			AcDbObjectId id;
			AecDbEwPipe *pPipeT = NULL;
			for (int i = 0;i < arPipes.length();i++)
			{
				pPipeT = (AecDbEwPipe *)arPipes.at(i);
				id = AddPipeToModelSpace(pPipeT);
			}
			return id;//Last
		}
	}
	
	CString sProject = _T("工业");;
	pXDataMap->GetAt(DOC_PROJECT, sProject);

	CString sLevel;
	pXDataMap->GetAt(PIPE_LEVEL, sLevel);

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

	int nTrade = 0;
	pXDataMap->GetAt(DOC_TRADE, nTrade);		//行业
	WPipe::Trade eTrade = (WPipe::Trade)nTrade;

	WPipe::PIPESPEC pipeSpec;
	memset(&pipeSpec, 0, sizeof(WPipe::PIPESPEC));

	//查询 外径系列，表号，标准号，材质，描述
	if (TDbPipeSupport::QueryPipeSpecInf(m_pPipeJig->GetAdoDb(), dDN, pipeSpec, eTrade, sProject, sLevel))
	{
		//外径系列
		pXDataMap->SetAt(PIPE_OD_SN, pipeSpec.szODSN);

		pXDataMap->SetAt(PIPE_SHTNO, pipeSpec.szShtNo);

		pXDataMap->SetAt(PIPE_STDNO, pipeSpec.szStdNo);

		pXDataMap->SetAt(PIPE_MATERIAL, pipeSpec.szMat);

		pXDataMap->SetAt(PIPE_DESCR, pipeSpec.szDesc);
	}

	if (nConnectType == 3 || nConnectType == 5)//法兰管件 需要加 加垫片 和 螺栓 螺母 信息
	{
		AcArray<AecInterface> arInfs;
		pPipe->GetInterface(arInfs);

		double dPre = 1.0;
		pXDataMap->GetAt(PIPE_PRESSURE, dPre);

		for (int i = 0; i < arInfs.length(); i++)
		{
			AecInterface &inf = arInfs.at(i);

			//管嘴 垫片
			TDbPipeSupport::SetGasketData(m_pPipeJig->GetAdoDb(), i, inf.dSize1, dPre, sProject, sLevel, pXDataMap);

			//管嘴 螺栓,螺母
			TDbPipeSupport::SetBoltData(m_pPipeJig->GetAdoDb(), i, inf.dSize1, dPre, sProject, sLevel, pXDataMap);
		}
	}

	AcDbObjectId id = CoreTools::AddToModelSpace(pPipe);
	return id;
}

//UPVC CPVC PVC-C PP-H (PE) HDPE
bool TDbPipeLine::IsPlasticsMat(WPipe::PipeParam *pParam, CString &sODNo)
{
	const CString sPlastic = _T("UPVC CPVC PVC-C PP-H (PE) PE100 HDPE");
	sODNo = pParam->szODSn;

	CStringArray arTxts;
	SplitStrintToArray(sPlastic, arTxts, _T(' '));

	CString sMat = pParam->szMertial;
	CString sMatFit = pParam->szMertialFit;
	CString sTxt;
	sMat.MakeUpper();
	sMatFit.MakeUpper();

	for (int i = 0; i < arTxts.GetSize(); i++)
	{
		sTxt = arTxts.GetAt(i);

		if (sMat.Find(sTxt) != -1 ||
			sMatFit.Find(sTxt) != -1)
		{
			return true;
		}
	}
	return false;
}

BOOL TDbPipeLine::AddReducer(AECStatusRecord* pCurStaRec,WPipe::PipeParam* pParam)
{
	AecDbEwFitting* pFitting = new AecDbEwFitting;
	AecDbObjXDataMap* pXDataMap = pFitting->GetSpecialtyData();
	pXDataMap->SetAt(PIPE_INTERFACEL4,m_pPipeParam->m_dInterfaceL3);//记下可能法兰管分段长度
	FillConfigXDataMap(pXDataMap,pParam);

	//查询设置项目等级
	if (!QuerySetProjectLevel(pXDataMap, pParam,_T("变径")))
		return FALSE;

	CString sProj = _T("工业");;
	pXDataMap->GetAt(DOC_PROJECT, sProj);

	CString sLevel;
	pXDataMap->GetAt(PIPE_LEVEL, sLevel);

	pXDataMap->SetAt(PIPE_CONNECT,pParam->m_nConnectType);
	if (pParam->m_nConnectType > 0)
	{
		double dFD = 0.0,dFL = 0.0;
		TDbPipeSupport::QueryInfFDFL(m_pPipeJig->GetAdoDb(),eReduce,pParam->m_nConnectType, m_pPipeParam->m_dDN,dFD,dFL, sProj,sLevel);
		pXDataMap->SetAt(PIPE_INTERFACED,dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL,dFL);

		dFD = 0.0,dFL = 0.0;
		TDbPipeSupport::QueryInfFDFL(m_pPipeJig->GetAdoDb(),eReduce,pParam->m_nConnectType, pParam->m_dDN,dFD,dFL,sProj,sLevel);
		pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);
	}

	pXDataMap->SetAt(KEY_FITSRV,KEY_FITWPIPE);

	if (m_pPipeParam->m_app == WPipe::eDuct)
		pXDataMap->SetAt(KEY_RUNTIME, eDuctReduce);
	else if (m_pPipeParam->m_app == WPipe::eBridge)
		pXDataMap->SetAt(KEY_RUNTIME, eBridgeReduce);
	else
		pXDataMap->SetAt(KEY_RUNTIME, eReduce);

	AcGeVector3d vtDir = AcGeVector3d::kXAxis;
	AecInterface* pIntf = GetLastInterface();
	if (pIntf != NULL)
	{
		vtDir = pIntf->vtDir;
	}
	AcGePoint3d ptSta = pIntf->ptPos;

	double dGast = 0.0;
	//上次是否是衬塑管
	if (IsGSFMaterial(pParam->szMertial))
	{
		dGast = GetLastInterface()->dGasket;
		dGast *= 0.5;
	}

	vtDir.normalize();
	ptSta += vtDir * dGast;

	pXDataMap->SetAt(KEY_MAJBR,vtDir);
	pXDataMap->SetAt(KEY_START,ptSta);
	pXDataMap->SetAt(KEY_Length,pParam->m_dInterfaceL3);

	pXDataMap->SetAt(PIPE_DN,m_pPipeParam->m_dDN);
	pXDataMap->SetAt(PIPE_OD,m_pPipeParam->m_dOD);

	pXDataMap->SetAt(PIPE_EDN,pParam->m_dDN);
	pXDataMap->SetAt(PIPE_EOD,pParam->m_dOD);

	double dPre = pParam->m_dPress;
	pXDataMap->SetAt(PID_PIPE_DPRESS,dPre);

	CString sODNo = pParam->szODSn;
	if (IsPlasticsMat(pParam, sODNo))
	{
		TDbPipeSupport::QueryPVCReducerData(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, pParam->m_dDN, pXDataMap, sODNo);
	}
	else
	{
		double dL = pParam->m_dInterfaceL3;//查询设置H,h1,h2
		pXDataMap->SetAt(KEY_OFFSET, pParam->m_vtECCen);
		TDbPipeSupport::QueryReduceData(m_pPipeJig->GetAdoDb(), pParam->m_nConnectType, m_pPipeParam->m_dDN, pParam->m_dDN, dL, pXDataMap, sODNo);
		
		pXDataMap->SetAt(KEY_Length, dL);
		pParam->m_dInterfaceL3 = dL;
	}

	vtDir.normalize();

	AcGePoint3d ptEnd = ptSta + pParam->m_dInterfaceL3 * vtDir;
	if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)//法兰连接
	{
		//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
		double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
		TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(),pParam->m_dDN,dPre,dWD,dWh,dThk,dN, sProj, sLevel);

		double dWD2 = 0.0,dWh2 = 0.0,dThk2 = 0.0,dN2 = 0.0;
		TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(),m_pPipeParam->m_dDN,dPre,dWD2,dWh2,dThk2,dN2, sProj, sLevel);

		//颈法兰焊接方式
		//ptSta += dWh * vtDir;

		//颈法兰焊接方式
		//ptSta += dWh * vtDir;

		if (sODNo.CompareNoCase(_T("S")) == 0 &&
			sODNo.CompareNoCase(_T("GSF")) != 0)
		{
			//已经含有 (dWh + dWh)
		}
		else
		{
			ptEnd += (dWh + dWh) * vtDir;
		}

		pXDataMap->SetAt(KEY_START,ptSta);

		pXDataMap->SetAt(PIPE_WN,dN);
		pXDataMap->SetAt(PIPE_WH, dWh);

		pXDataMap->SetAt(PIPE_WN2,dN2);
		pXDataMap->SetAt(PIPE_WH2, dWh2);

		//垫片
		TDbPipeSupport::SetGasketData(m_pPipeJig->GetAdoDb(), 0,m_pPipeParam->m_dDN, dPre, sProj, sLevel, pXDataMap);
		TDbPipeSupport::SetGasketData(m_pPipeJig->GetAdoDb(), 1,pParam->m_dDN, dPre, sProj, sLevel, pXDataMap);

		//螺栓
		TDbPipeSupport::SetBoltData(m_pPipeJig->GetAdoDb(), 0,m_pPipeParam->m_dDN, dPre, sProj, sLevel, pXDataMap);
		TDbPipeSupport::SetBoltData(m_pPipeJig->GetAdoDb(), 1,pParam->m_dDN, dPre, sProj, sLevel, pXDataMap);
	}

	//是否偏移
	double dOffset = (pParam->m_dD - m_pPipeParam->m_dD) / 2.0;

	AcGeLine3d ln3d(AcGePoint3d::kOrigin,vtDir);

	AcGeVector3d vtDirXY,vcTemp;
	AcGeVector3d vtOffset = AcGeVector3d::kIdentity;
	if (!pParam->m_vtECCen.isZeroLength())
	{
		if (pParam->m_vtECCen.isCodirectionalTo(AcGeVector3d::kYAxis)) //平管 向上,立管 向左
		{
			if (vtDir.isParallelTo(AcGeVector3d::kZAxis))//立管
			{
				vtOffset = -AcGeVector3d::kXAxis;
			}
			else
			{
				if (ln3d.isParallelTo(AcGePlane::kXYPlane))//平管
				{
					vtOffset = vtDir;
					vtOffset.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
				}
				else//斜管
				{
					vtDirXY = vtDir.orthoProject(AcGeVector3d::kZAxis);

					vtOffset = vtDirXY;
					vtOffset.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
				}
			}
		}
		else if (pParam->m_vtECCen.isCodirectionalTo(-AcGeVector3d::kYAxis)) //平管 向下 立管 向右
		{
			if (vtDir.isParallelTo(AcGeVector3d::kZAxis))//立管
			{
				vtOffset = AcGeVector3d::kXAxis;
			}
			else
			{
				if (ln3d.isParallelTo(AcGePlane::kXYPlane))//平管
				{
					vtOffset = vtDir;
					vtOffset.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
				}
				else//斜管
				{
					vtDirXY = vtDir.orthoProject(AcGeVector3d::kZAxis);

					vtOffset = vtDirXY;
					vtOffset.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
				}
			}
		}
		else if(pParam->m_vtECCen.isCodirectionalTo(AcGeVector3d::kZAxis)) //平管 前 立管 向前
		{
			if (vtDir.isParallelTo(AcGeVector3d::kZAxis))//立管
			{
				vtOffset = AcGeVector3d::kYAxis;
			}
			else
			{
				if (ln3d.isParallelTo(AcGePlane::kXYPlane))//平管
				{
					vtOffset = AcGeVector3d::kZAxis;
				}
				else//斜管
				{
					vtOffset = AcGeVector3d::kZAxis.orthoProject(vtDir);
				}
			}
		}
		else if(pParam->m_vtECCen.isCodirectionalTo(-AcGeVector3d::kZAxis)) //平管 后 立管 向后
		{
			if (vtDir.isParallelTo(AcGeVector3d::kZAxis))//立管
			{
				vtOffset = -AcGeVector3d::kYAxis;
			}
			else
			{
				if (ln3d.isParallelTo(AcGePlane::kXYPlane))//平管
				{
					vtOffset = -AcGeVector3d::kZAxis;
				}
				else//斜管
				{
					vtOffset = -AcGeVector3d::kZAxis.orthoProject(vtDir);
				}
			}
		}

		vtOffset.normalize();
		vtOffset *= dOffset;
	}
	ptEnd += vtOffset;
	pXDataMap->SetAt(KEY_END,ptEnd);

	AcGeVector3d vtNorm = AcGeVector3d::kZAxis;
	AcGeLine3d line(ptSta,ptEnd);
	if (AcGePlane::kXYPlane.isParallelTo(line))
	{
		vtNorm = AcGeVector3d::kZAxis;
	}
	else if (AcGePlane::kYZPlane.isParallelTo(line))
	{
		vtNorm = AcGeVector3d::kXAxis;
	}
	else if (AcGePlane::kZXPlane.isParallelTo(line))
	{
		vtNorm = AcGeVector3d::kYAxis;
	}

	pXDataMap->SetAt(KEY_NORMAL,vtNorm);
	pXDataMap->SetAt(KEY_OFFSET,vtOffset);

	//设置图层
	SetFittingLayer(pFitting, m_pPipeParam->szSys);

	setInfo2Ent(*pXDataMap);

	AecInterface intf;
	pFitting->GetInterface(1,intf);

	AcDbObjectId id = AddFitToModelSpace(pFitting);
	AddUserData(id,pXDataMap,5);

	intf.idOwner = id;
	PushInterface(intf);

	//更改标高

	//覆盖当前的param
	double dFD = 0.0;
	pXDataMap->GetAt(PIPE_INTERFACED2,dFD);

	PushPipeParam();
	double dInterfaceL3 = m_pPipeParam->m_dInterfaceL3;
	memcpy(m_pPipeParam,pParam,sizeof(WPipe::PipeParam));//回退
	m_pPipeParam->m_dInterfaceL3 = dInterfaceL3;
	m_pPipeParam->m_dEl = intf.ptPos.z;

	dFD = 0.0;
	double dFL = 0.0;
	TDbPipeSupport::QueryInfFDFL(m_pPipeJig->GetAdoDb(),eElbow,pParam->m_nConnectType,pParam->m_dDN,dFD,dFL,sProj,sLevel);
	m_pPipeParam->m_dInterfaceD = dFD;
	m_pPipeParam->m_dInterfaceL = dFL;

	pParam->m_dInterfaceD = dFD;
	pParam->m_dInterfaceL = dFL;

	//创建余下管子,并插入虚拟状态记录
	AECStatusRecord* pRecMid = new AECStatusRecord;
	pRecMid->CopyFrom(pCurStaRec);
	pRecMid->SetAcquirePoint(intf.ptPos);
	m_pPipeJig->PushBackStatusRec(pRecMid);
	pCurStaRec->SetAcquirePoint(intf.ptPos);

	return TRUE;
}

BOOL TDbPipeLine::AddReduceElbow(AECStatusRecord* pCurStaRec,WPipe::PipeParam* pParam,AcGeVector3d& vtMaj,AcGeVector3d& vtMin)
{
	AecDbEwFitting* pFitting = new AecDbEwFitting;
	AecDbObjXDataMap* pXDataMap = pFitting->GetSpecialtyData();
	pXDataMap->SetAt(PIPE_INTERFACEL4,m_pPipeParam->m_dInterfaceL3);//记下可能法兰管分段长度
	FillConfigXDataMap(pXDataMap,pParam);

	pXDataMap->SetAt(KEY_RUNTIME, eReduceElbow);

	pXDataMap->SetAt(KEY_MAJBR,vtMaj);
	pXDataMap->SetAt(KEY_MINBR,vtMin);

	AecInterface* pIntf = GetLastInterface();
	AcGePoint3d ptSta = pIntf->ptPos;

	CString sProj = _T("工业");;
	pXDataMap->GetAt(DOC_PROJECT, sProj);

	//如果是45度
	double dSweep = vtMin.angleTo(vtMaj);
	if (dSweep - PI / 2.0 > 1.e-3)
		dSweep -= PI / 2.0;

	AcGePoint3d ptMid;

	double dA = m_pPipeParam->m_dRRatio * __max(m_pPipeParam->m_dDN, pParam->m_dDN);
	if (m_pPipeParam->m_dInterfaceL3 > 1.e-6)
		dA = m_pPipeParam->m_dInterfaceL3;

	//如果是45度且是衬塑 特殊处理
	if (fabs(dSweep - 0.25 * PI) < 1.e-3)//45
	{
		if (IsGSFMaterial(m_pPipeParam->szMertial))
		{
			TDbPipeSupport::Query45ElbowL(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, pParam->m_dInterfaceL3, m_pPipeParam->m_dRRatio, m_pPipeParam->m_nConnectType, m_pPipeParam->szLevel, m_pPipeParam->szODSn, pXDataMap);

			pParam->m_dInterfaceL3 /= tan(PI / 8.0);
			pXDataMap->SetAt(KEY_Length, pParam->m_dInterfaceL3);

			double dAl = dA * tan(PI / 8.0);
			ptMid = ptSta + vtMaj * dAl;//vtMaj 向外
		}
	}
	else
	{
		double dDNL = __max(m_pPipeParam->m_dDN, pParam->m_dDN);
		double dDNs = __min(m_pPipeParam->m_dDN, pParam->m_dDN);
		if (TDbPipeSupport::QueryRElbowL(m_pPipeJig->GetAdoDb(), dDNL, dDNs, pParam->m_dInterfaceL3, m_pPipeParam->m_dRRatio, m_pPipeParam->m_nConnectType, m_pPipeParam->szLevel, pXDataMap))
			dA = pParam->m_dInterfaceL3;

		ptMid = ptSta + vtMaj * dA;//vtMaj 向外
	}
	
	vtMaj.normalize();vtMin.normalize();

	if (pParam->m_nConnectType > 0)
	{
		double dFD = 0.0, dFL = 0.0;
		TDbPipeSupport::QueryInfFDFL(m_pPipeJig->GetAdoDb(), eReduce, pParam->m_nConnectType, m_pPipeParam->m_dDN, dFD, dFL, sProj, m_pPipeParam->szLevel);
		pXDataMap->SetAt(PIPE_INTERFACED, dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL, dFL);

		dFD = 0.0, dFL = 0.0;
		TDbPipeSupport::QueryInfFDFL(m_pPipeJig->GetAdoDb(), eReduce, pParam->m_nConnectType,pParam->m_dDN, dFD, dFL, sProj, m_pPipeParam->szLevel);
		pXDataMap->SetAt(PIPE_INTERFACED2, dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL2, dFL);
	}

	if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)//法兰连接
	{
		//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
		double dWD = 0.0, dWh = 0.0, dThk = 0.0, dN = 0.0;
		TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, m_pPipeParam->m_dPress, dWD, dWh, dThk, dN, sProj, m_pPipeParam->szLevel);

		double dWD2 = 0.0, dWh2 = 0.0, dThk2 = 0.0, dN2 = 0.0;
		TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(), pParam->m_dDN, pParam->m_dPress, dWD2, dWh2, dThk2, dN2, sProj, m_pPipeParam->szLevel);

		//颈法兰焊接方式
		pXDataMap->SetAt(PIPE_WN, dN);
		pXDataMap->SetAt(PIPE_WN2, dN2);

		pXDataMap->SetAt(PIPE_WH, dWh);
		pXDataMap->SetAt(PIPE_WH2, dWh2);

		//垫片
		TDbPipeSupport::SetGasketData(m_pPipeJig->GetAdoDb(), 0, m_pPipeParam->m_dDN, m_pPipeParam->m_dPress, sProj, m_pPipeParam->szLevel, pXDataMap);
		TDbPipeSupport::SetGasketData(m_pPipeJig->GetAdoDb(), 1, pParam->m_dDN, pParam->m_dPress, sProj, pParam->szLevel, pXDataMap);

		//螺栓
		TDbPipeSupport::SetBoltData(m_pPipeJig->GetAdoDb(), 0, m_pPipeParam->m_dDN, m_pPipeParam->m_dPress, sProj, m_pPipeParam->szLevel, pXDataMap);
		TDbPipeSupport::SetBoltData(m_pPipeJig->GetAdoDb(), 1, pParam->m_dDN, pParam->m_dPress, sProj, pParam->szLevel, pXDataMap);
	}

	pXDataMap->SetAt(KEY_MID,ptMid);

	pXDataMap->SetAt(PIPE_DN,m_pPipeParam->m_dDN);
	pXDataMap->SetAt(PIPE_OD,m_pPipeParam->m_dOD);

	pXDataMap->SetAt(PIPE_EDN,pParam->m_dDN);
	pXDataMap->SetAt(PIPE_EOD,pParam->m_dOD);
	pXDataMap->SetAt(KEY_Length, pParam->m_dInterfaceL3);
	pXDataMap->SetAt(PIPE_ELBOWANG,dSweep);
	pXDataMap->SetAt(KEY_RadRatio, pParam->m_nRadioOn);

	double dPre = pParam->m_dPress;
	pXDataMap->SetAt(PID_PIPE_DPRESS,dPre);

	pXDataMap->SetAt(PIPE_RATIO, m_pPipeParam->m_dRRatio);
	pXDataMap->SetAt(PIPE_THICK, m_pPipeParam->m_dThick);

		//设置图层
	SetFittingLayer(pFitting, m_pPipeParam->szSys);

	setInfo2Ent(*pXDataMap);

	AecInterface intf;
	pFitting->GetInterface(1,intf);

	AcDbObjectId id = AddFitToModelSpace(pFitting);
	AddUserData(id,pXDataMap,5);

	//创建余下管子,并插入虚拟状态记录
	AECStatusRecord* pRecMid = new AECStatusRecord;
	pRecMid->CopyFrom(pCurStaRec);
	pRecMid->SetAcquirePoint(intf.ptPos);
	m_pPipeJig->PushBackStatusRec(pRecMid);
	pCurStaRec->SetAcquirePoint(intf.ptPos);

	return TRUE;
}

BOOL TDbPipeLine::ChangeEl(AECStatusRecord* pRec,double dNewEl,BOOL bCheckRec,
						   double dRedElPos,WPipe::PipeParam* pParamred)
{
	AcGeVector3d vtMaj,vtMin;
	AcGePoint3d ptMid,ptSta,ptEnd,ptGeT,ptLast;

	if (GetLastInterface() != NULL)
	{
		vtMaj = GetLastInterface()->vtDir;
		if (vtMaj.isParallelTo(AcGeVector3d::kZAxis))//上次是立管
		{
			AcDbEntity* pEnt = NULL;
			if (Acad::eOk == acdbOpenAcDbEntity(pEnt,GetLastInterface()->idOwner,AcDb::kForWrite))
			{
				AecDbEwPipe* pPipe = AecDbEwPipe::cast(pEnt);
				if (pPipe != NULL)//是管子
				{
					//延长
					ptEnd = pPipe->EndPoint();
					ptSta = pPipe->StartPoint();

					double dDis1 = fabs(dNewEl - ptSta.z);
					double dDis2 = fabs(dNewEl - ptEnd.z);

					//延长
					if (dDis1 < dDis2)//sta
					{	
						ptSta.z = dNewEl;
						pPipe->SetStartPoint(ptSta);
					}
					else//end
					{
						ptEnd.z = dNewEl;
						pPipe->SetEndPoint(ptEnd);
					}
				}

				AecDbEwFitting* pFitt = AecDbEwFitting::cast(pEnt);
				if (pFitt != NULL)
				{
					int nType = 0;
					pFitt->GetSpecialtyData()->GetAt(KEY_RUNTIME,nType);

					EFittingType eType = (EFittingType)nType;
					if (eType == eReduce)
					{
						//增加一段
						WPipe::PipeParam* pParamNew = pFitt->GetPipeParam(1);
						if (pParamNew != NULL)
						{
							/*if (fabs(GetLastInterface()->dSize1 - pParamNew->m_dDN) > 1.e-2)
							{
								pParamNew->m_dD = GetLastInterface()->dSize1;
								pFitt->GetSpecialtyData()->GetAt(PIPE_TDN,pParamNew->m_dDN);
								pFitt->GetSpecialtyData()->GetAt(PIPE_OD,pParamNew->m_dOD);
							}*/

							ptSta = GetLastInterface()->ptPos;
							ptEnd = ptSta;

							if (bCheckRec)//创建变径
							{
								if ( fabs(dRedElPos - ptEnd.z) > 1.e-1)
								{
									ptEnd.z = dRedElPos;
									CreatePipe(ptSta,ptEnd,pParamNew);
								}

								AECStatusRecord rs;
								ptEnd.z = dRedElPos;
								rs.SetAcquirePoint(ptEnd);
								AddReducer(&rs,pParamred);

								ptSta = GetLastInterface()->ptPos;
								ptEnd = ptSta;
								ptEnd.z = dNewEl;
								CreatePipe(ptSta,ptEnd,pParamNew);

								double dInterfaceL3 = m_pPipeParam->m_dInterfaceL3;
								memcpy(m_pPipeParam,pParamNew,sizeof(WPipe::PipeParam));
								m_pPipeParam->m_dEl = dNewEl;
								//继承法兰管分段
								m_pPipeParam->m_dInterfaceL3 = dInterfaceL3;
							}
							else
							{
								ptEnd.z = dNewEl;
								CreatePipe(ptSta,ptEnd,pParamNew);
								memcpy(m_pPipeParam,pParamNew,sizeof(WPipe::PipeParam));
							}
						}
					}
				}

				AecDbEwEquipment* pEqu = AecDbEwEquipment::cast(pEnt);
				if (pEqu != NULL)
				{
					// 从 m_pPipeParam->m_dEl -- dNewEl创建立管
					ptSta = GetLastInterface()->ptPos;
					ptEnd = ptSta;

					if (bCheckRec)//创建变径
					{
						if ( fabs(dRedElPos - ptEnd.z) > 1.e-1)
						{
							ptEnd.z = dRedElPos;
							CreatePipe(ptSta,ptEnd,m_pPipeParam);
						}

						AECStatusRecord rs;
						ptEnd.z = dRedElPos;
						rs.SetAcquirePoint(ptEnd);
						AddReducer(&rs,pParamred);

						ptSta = GetLastInterface()->ptPos;
						ptEnd = ptSta;
						ptEnd.z = dNewEl;
						CreatePipe(ptSta,ptEnd,pParamred);

						double dInterfaceL3 = m_pPipeParam->m_dInterfaceL3;
						memcpy(m_pPipeParam,pParamred,sizeof(WPipe::PipeParam));
						m_pPipeParam->m_dEl = dNewEl;
						//继承法兰管分段
						m_pPipeParam->m_dInterfaceL3 = dInterfaceL3;
					}
					else
					{
						ptSta = GetLastInterface()->ptPos;
						ptEnd = ptSta;
						ptEnd.z = dNewEl;
						CreatePipe(ptSta,ptEnd,m_pPipeParam);
					}
				}
				pEnt->close();
			}

			m_pPipeParam->m_dEl = dNewEl;

			//调整本次状态点
			pRec->SetAcquirePoint(ptEnd);

			return TRUE;
		}

		vtMaj.normalize();
		vtMin = AcGeVector3d::kZAxis;

		if (dNewEl - m_pPipeParam->m_dEl < 1.e-3)
		{
			vtMin = -AcGeVector3d::kZAxis;
		}
		CString sODNo = _T("A");

		//如果上段不是管子
		AcDbEntity* pEnt = NULL;
		if (Acad::eOk == acdbOpenAcDbEntity(pEnt,GetLastInterface()->idOwner,AcDb::kForWrite))
		{
			AecDbEwPipe* pPipe = AecDbEwPipe::cast(pEnt);
			if (pPipe == NULL)//不是管子
			{
				ptMid = GetLastInterface()->ptPos;
				AecDbObjXDataMap xd;

				if (IsPlasticsMat(m_pPipeParam, sODNo))
				{
					TDbPipeSupport::QueryPVCElbow(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, &xd, sODNo);

					double dL = 0;
					xd.GetAt(KEY_L, dL);
					ptMid += vtMaj * dL;
				}
				else
				{
					if (m_pPipeParam->m_nRadioOn)
					{
						ptMid += vtMaj * m_pPipeParam->m_dDN * m_pPipeParam->m_dRRatio;
					}
					else
					{
						double dLA = m_pPipeParam->m_dDN * m_pPipeParam->m_dRRatio;
						xd.SetAt(KEY_RadRatio, m_pPipeParam->m_nRadioOn);

						double dAng = 90.0;
						dAng = vtMin.angleTo(vtMaj);
						if (dAng - PI / 2.0 > 1.e-3)
							dAng -= PI / 2.0;

						xd.SetAt(PIPE_ELBOWANG, dAng);

						TDbPipeSupport::QueryElbowL(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, dLA, m_pPipeParam->m_dRRatio, m_pPipeParam->m_nConnectType, m_pPipeParam->szLevel,&xd);

						double dF = 0.0, dR = 0;
						xd.GetAt(_T("F"), dF);
						xd.GetAt(_T("R"), dR);
						if (dR > 1.e-3 && dF > 0)
						{
							ptMid += vtMaj * (dR + dF);
						}
						else
						{
							ptMid += vtMaj * dLA;
						}
					}
				}
			}
			else//改短上次管子
			{
				ptLast = GetLastInterface()->ptPos;

				double dThk = 0.0, dWh = 0.0;
				if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)//如果法兰管弯头
				{
					if (!vtMaj.isParallelTo(vtMin))//后续创建弯头
					{
						//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
						double dWD = 0.0,dN = 0.0;
						TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(),m_pPipeParam->m_dDN,m_pPipeParam->m_dPress,dWD,dWh,dThk,dN);
					}
					//如果法兰管弯头
					//则上次管子继续改短一个法兰高度
				}

				if (ptLast.distanceTo(pPipe->EndPoint()) < 1.e-3)
				{
					ptEnd = pPipe->EndPoint();
					ptMid = ptEnd;
					AecDbObjXDataMap xd;

					if (IsPlasticsMat(m_pPipeParam, sODNo))
					{
						TDbPipeSupport::QueryPVCElbow(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, &xd, sODNo);

						double dL = 0;
						xd.GetAt(KEY_L, dL);

						ptEnd -= vtMaj * dL;
					}
					else
					{
						if (vtMaj.isPerpendicularTo(vtMin))
						{
							if (m_pPipeParam->m_nRadioOn)
							{
								double dLA = m_pPipeParam->m_dDN * m_pPipeParam->m_dRRatio;
								xd.SetAt(KEY_RadRatio, m_pPipeParam->m_nRadioOn);

								double dAng = 90.0;
								dAng = vtMin.angleTo(vtMaj);
								if (dAng - PI / 2.0 > 1.e-3)
									dAng -= PI / 2.0;

								TDbPipeSupport::QueryElbowL(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, dLA, m_pPipeParam->m_dRRatio, m_pPipeParam->m_nConnectType, m_pPipeParam->szLevel,&xd);

								double dF = 0.0, dR = 0;
								xd.GetAt(_T("F"), dF);
								xd.GetAt(_T("R"), dR);
								if (dR > 1.e-3 && dF > 0)
								{
									if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)
									{
										ptEnd -= vtMaj * dLA;
									}
									else
									{
										ptEnd -= vtMaj * (dR + dF);
									}
								}
								else
								{
									if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)
									{
										ptEnd -= vtMaj * (dLA + dWh);
									}
									else
									{
										ptEnd -= vtMaj * dLA;
									}
								}
							}
							else
							{
								double dLA = m_pPipeParam->m_dDN * m_pPipeParam->m_dRRatio;
								if (_tcscmp(m_pPipeParam->szODSn, _T("S")) == 0 ||
									_tcscmp(m_pPipeParam->szODSn, _T("GSF")) == 0)
									ptEnd -= vtMaj * (dLA + dWh);
								else
									ptEnd -= vtMaj * dLA;
							}
						}
						else
						{
							double dSweepAngle = vtMin.angleTo(vtMaj);
							AcGePoint3d ptFr;
							AcDbArc *pArcElbow = KTCADUtilityEx::FormatArc(vtMaj, vtMin, ptMid, ptFr, dSweepAngle, m_pPipeParam->m_dD, m_pPipeParam->m_dRRatio);
							if (pArcElbow != NULL)//可以合成ARC
							{
								double dS = 0.0, dE = 0.0;
								pArcElbow->getStartParam(dS);
								pArcElbow->getEndParam(dE);

								AcGeVector3d vtS, vtE;
								pArcElbow->getFirstDeriv(dS, vtS);
								pArcElbow->getFirstDeriv(dE, vtE);

								if (vtS.isParallelTo(vtMaj))
								{
									pArcElbow->getStartPoint(ptEnd);
								}
								else
								{
									pArcElbow->getEndPoint(ptEnd);
								}
								delete pArcElbow;
							}
							else
							{
								acutPrintf(_T("\nFormatArc error! create elbow failed!"));
							}
						}
						ptGeT = pPipe->EndPoint();
					}

					pPipe->SetEndPoint(ptEnd);
				}
				else
				{
					vtMaj = pPipe->StartPoint() - pPipe->EndPoint();
					vtMaj.normalize();

					ptSta = pPipe->StartPoint();
					ptMid = ptSta;

					AecDbObjXDataMap xd;

					if (IsPlasticsMat(m_pPipeParam, sODNo))
					{
						TDbPipeSupport::QueryPVCElbow(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, &xd, sODNo);

						double dL = 0;
						xd.GetAt(KEY_L, dL);

						ptSta -= vtMaj * dL;
					}
					else
					{
						if (vtMaj.isPerpendicularTo(vtMin))
						{
							if (m_pPipeParam->m_nRadioOn)
							{
								double dLA = (m_pPipeParam->m_dDN * m_pPipeParam->m_dRRatio + dWh);
								xd.SetAt(KEY_RadRatio, m_pPipeParam->m_nRadioOn);

								double dAng = 90.0;
								dAng = vtMin.angleTo(vtMaj);
								if (dAng - PI / 2.0 > 1.e-3)
									dAng -= PI / 2.0;

								TDbPipeSupport::QueryElbowL(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, dLA, m_pPipeParam->m_dRRatio, m_pPipeParam->m_nConnectType, m_pPipeParam->szLevel,&xd);

								double dF = 0.0, dR = 0;
								xd.GetAt(_T("F"), dF);
								xd.GetAt(_T("R"), dR);
								if (dR > 1.e-3 && dF > 0)
								{
									if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)
									{
										ptSta -= vtMaj * dLA;
									}
									else
									{
										ptSta -= vtMaj * (dR + dF);
									}
								}
								else
								{
									if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)
									{
										ptSta -= vtMaj * (dLA+ dWh);
									}
									else
									{
										ptSta -= vtMaj * dLA;
									}
								}
							}
							else
							{
								double dLA = (m_pPipeParam->m_dDN * m_pPipeParam->m_dRRatio + dWh);
								if (_tcscmp(m_pPipeParam->szODSn, _T("S")) == 0 ||
									_tcscmp(m_pPipeParam->szODSn, _T("GSF")) == 0)
									ptSta -= vtMaj * (dLA + dWh);
								else
									ptSta -= vtMaj * dLA;
							}
						}
						else
						{
							double dSweepAngle = vtMin.angleTo(vtMaj);
							AcGePoint3d ptFr;
							AcDbArc *pArcElbow = KTCADUtilityEx::FormatArc(vtMaj, vtMin, ptMid, ptFr, dSweepAngle, m_pPipeParam->m_dD, m_pPipeParam->m_dRRatio);
							if (pArcElbow != NULL)//可以合成ARC
							{
								double dS = 0.0, dE = 0.0;
								pArcElbow->getStartParam(dS);
								pArcElbow->getEndParam(dE);

								AcGeVector3d vtS, vtE;
								pArcElbow->getFirstDeriv(dS, vtS);
								pArcElbow->getFirstDeriv(dE, vtE);

								if (vtS.isParallelTo(vtMaj))
								{
									pArcElbow->getStartPoint(ptSta);
								}
								else
								{
									pArcElbow->getEndPoint(ptSta);
								}
								delete pArcElbow;
							}
							else
							{
								acutPrintf(_T("\nFormatArc error! create elbow failed!"));
							}
						}

						ptGeT = pPipe->StartPoint();
					}

					pPipe->SetStartPoint(ptSta);
				}
			}
			pEnt->close();
		}
		
		//压入当前param
		PushPipeParam();

		//1. 如果方向不同创建弯头
		if (!vtMaj.isParallelTo(vtMin))
		{
			CreateElbow(vtMaj,ptMid,vtMin,m_pPipeParam);
		}

		//2. 创建立管
		if (bCheckRec)
		{
			AecInterface inf = m_arHistoryIntfs[m_arHistoryIntfs.GetSize() - 1];
			ptSta = inf.ptPos;

			//3.创建立管
			ptEnd = ptSta;
			ptEnd.z = dRedElPos;
			CreatePipe(ptSta,ptEnd,m_pPipeParam);

			//4.创建变径
			AECStatusRecord rs;
			rs.SetAcquirePoint(ptEnd);
			AddReducer(&rs,pParamred);

			//5. 余下部份创建立管
			int nDir = ( dNewEl - m_pPipeParam->m_dEl > 1.e-6) ? 1 : -1; 
			//ptEnd += nDir * AcGeVector3d::kZAxis * pParamred->m_dInterfaceL3;
			ptEnd = GetLastInterface()->ptPos;

			if ( nDir == 1 && fabs(ptEnd.z - dNewEl) > 1.e-3)
			{
				ptSta = ptEnd;
				ptEnd.z = dNewEl;

				if (ptSta.distanceTo(ptEnd) > 1.e-3)
					CreatePipe(ptSta,ptEnd,pParamred);

				double dInterfaceL3 = m_pPipeParam->m_dInterfaceL3;
				memcpy(m_pPipeParam,pParamred,sizeof(WPipe::PipeParam));
				m_pPipeParam->m_dEl = dNewEl;
				//继承法兰管分段
				m_pPipeParam->m_dInterfaceL3 = dInterfaceL3;

				//调整本次状态点
				pRec->SetAcquirePoint(ptEnd);
			}

			if (nDir == -1 && fabs(ptEnd.z - dNewEl) > 1.e-3)
			{
				ptSta = ptEnd;
				ptEnd.z = dNewEl;
				CreatePipe(ptSta,ptEnd,pParamred);

				double dInterfaceL3 = m_pPipeParam->m_dInterfaceL3;
				memcpy(m_pPipeParam,pParamred,sizeof(WPipe::PipeParam));
				m_pPipeParam->m_dEl = dNewEl;
				//继承法兰管分段
				m_pPipeParam->m_dInterfaceL3 = dInterfaceL3;

				//调整本次状态点
				pRec->SetAcquirePoint(ptEnd);
			}
		}
		else
		{
			//4. 创建管子
			AecInterface intf;
			intf = m_arHistoryIntfs[m_arHistoryIntfs.GetSize() - 1];

			ptSta = intf.ptPos;
			ptEnd = ptSta;
			ptEnd.z = dNewEl;

			CreatePipe(ptSta,ptEnd,m_pPipeParam);

			memcpy(m_pPipeParam,pParamred,sizeof(WPipe::PipeParam));
			m_pPipeParam->m_dEl = dNewEl;

			//调整本次状态点
			pRec->SetAcquirePoint(ptEnd);
		}
	}
	return TRUE;
}

BOOL TDbPipeLine::ChangeEl2(AECStatusRecord* pRec,AECStatusRecord* pRecLast,double dNewEl,BOOL bCheckRec,
						   double dRedElPos,WPipe::PipeParam* pParamred)
{
	ads_point pt[5];
	AcGePoint3d ptGe = pRecLast->GetAcquirePoint();
	double dSize = PixelToWcs(5);//5

	AcGePoint3d ptGeX[5];
	ptGeX[0] = ptGe;
	ptGeX[0] -= dSize * AcGeVector3d::kYAxis;
	ptGeX[0] -= dSize * AcGeVector3d::kXAxis;

	ptGeX[1] = ptGeX[0] + 2 * dSize * AcGeVector3d::kYAxis;
	ptGeX[2] = ptGeX[1] + 2 * dSize * AcGeVector3d::kXAxis;
	ptGeX[3] = ptGeX[0] + 2 * dSize * AcGeVector3d::kXAxis;
	ptGeX[4] = ptGeX[0];

	for (int i = 0;i < 5;i++)
	{
		acdbWcs2Ucs(asDblArray(ptGeX[i]),pt[i],false);
	}

	TCHAR szBuf[64];
	memset(szBuf,0,sizeof(szBuf));
	_tcscpy(szBuf, _T("AEC_EWPIPE"));

	struct resbuf rb;
	rb.restype = 0;
	rb.resval.rstring = szBuf;
	rb.rbnext = NULL; 

	struct resbuf* pointlist; 
	pointlist = acutBuildList(RTPOINT, pt[0], RTPOINT, pt[1], 
							  RTPOINT, pt[2], RTPOINT, pt[3], 0); 

	ads_name ss,ent;
	acedSSGet(_T("CP"),pointlist,NULL,&rb,ss);
	acutRelRb(pointlist);

	Adesk::Int32 lLen = 0;
	acedSSLength(ss,&lLen);

	WPipe::PipeParam wparamMain;
	memcpy(&wparamMain,m_pPipeParam,sizeof(WPipe::PipeParam));

	AcDbObjectId id;
	AcGePoint3d ptOn;
	if (lLen > 0)
	{
		acedSSName(ss,0,ent);

		acdbGetObjectId(id,ent);

		AcDbEntity* pEnt = NULL;
		if (Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead) )
		{
			AecDbEwPipe* pWPipe = AecDbEwPipe::cast(pEnt);
			if (pWPipe != NULL)
			{
				AecDbObjXDataMap* pXDataMap = pWPipe->GetSpecialtyData(AcDb::kForRead);
				TDbPipeSupport::XData2PipeParam(&wparamMain,pXDataMap);

				AcGePoint3d ptOn1 = pRec->GetAcquirePoint();
				AcDbLine ln(pWPipe->StartPoint(),pWPipe->EndPoint());
				ln.getClosestPointTo(ptOn1,ptOn);
				pRec->SetAcquirePoint(ptOn);
			}
			pEnt->close();
		}
	}
	acedSSFree(ss);

	bool bCreateTee = false;
	if ( (wparamMain.m_dDN - m_pPipeParam->m_dDN) > -1.e-6) //可能的创建三通,否则只创建立管
	{
		bCreateTee = true;
	}

	//创建立管
	AcGePoint3d ptSta,ptEnd;
	ptSta = pRec->GetAcquirePoint();

	if (bCreateTee)
	{
		AcGeVector3d vtMin = AcGeVector3d::kZAxis;
		if (dNewEl - ptSta.z < 1.e-3)
		{
			vtMin = -AcGeVector3d::kZAxis;
		}
		AcGePoint3d ptMid = pRec->GetAcquirePoint();
		double dL = 0.0,dB = 0.0;
		TDbPipeSupport::QueryTeeData(m_pPipeJig->GetAdoDb(),wparamMain.m_dDN,m_pPipeParam->m_dDN,dL,dB);

		if (m_pPipeParam->m_dInterfaceL > 1.e-3)//法兰管
		{
			dL += m_pPipeParam->m_dInterfaceL;
			dB += m_pPipeParam->m_dInterfaceL;

			if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)//法兰连接
			{
				//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
				double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
				TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(),m_pPipeParam->m_dDN,1.0,dWD,dWh,dThk,dN);

				//颈法兰焊接方式
				dL -= m_pPipeParam->m_dInterfaceL;
				dB -= m_pPipeParam->m_dInterfaceL;

				//颈法兰焊接方式
				CString sDNo = m_pPipeParam->szODSn;
				if (sDNo.CompareNoCase(_T("S")) != 0 &&
					sDNo.CompareNoCase(_T("GSF")) != 0)
				{
					dL += dWh;
					dB += dWh;
				}

			}
		}

		//创建三通
		AcDbEntity* pEnt = NULL;
		if (Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite) )
		{
			AecDbEwPipe* pWPipe = AecDbEwPipe::cast(pEnt);
			if (pWPipe != NULL)
			{
				//对方断为两个管子
				SplitWPipe(ptMid,dL,pWPipe);

				AddTee(pWPipe,dL,ptMid,dB,vtMin, &wparamMain);
				ptSta += vtMin * dB;
			}
			pEnt->close();
		}
	}

	//3.创建立管
	ptEnd = ptSta;

	//4.创建变径
	if (bCheckRec)
	{
		ptEnd.z = dRedElPos;
		CreatePipe(ptSta,ptEnd,m_pPipeParam);

		AECStatusRecord rs;
		rs.SetAcquirePoint(ptEnd);
		AddReducer(&rs,pParamred);
		
		//5. 余下部份创建立管
		int nDir = ( dNewEl - m_pPipeParam->m_dEl > 1.e-6) ? 1 : -1; 
		//ptEnd += nDir * AcGeVector3d::kZAxis * pParamred->m_dInterfaceL3;
		ptEnd = GetLastInterface()->ptPos;
		if ( nDir == 1 && ptEnd.z < dNewEl)
		{
			ptSta = ptEnd;
			ptEnd.z = dNewEl;
			CreatePipe(ptSta,ptEnd,pParamred);

			double dInterfaceL3 = m_pPipeParam->m_dInterfaceL3;
			memcpy(m_pPipeParam,pParamred,sizeof(WPipe::PipeParam));
			m_pPipeParam->m_dEl = dNewEl;
			m_pPipeParam->m_dInterfaceL3 = dInterfaceL3;


			//调整本次状态点
			pRec->SetAcquirePoint(ptEnd);
		}

		if (nDir == -1 && ptEnd.z > dNewEl)
		{
			ptSta = ptEnd;
			ptEnd.z = dNewEl;
			CreatePipe(ptSta,ptEnd,pParamred);

			double dInterfaceL3 = m_pPipeParam->m_dInterfaceL3;
			memcpy(m_pPipeParam,pParamred,sizeof(WPipe::PipeParam));
			m_pPipeParam->m_dEl = dNewEl;
			m_pPipeParam->m_dInterfaceL3 = dInterfaceL3;

			//调整本次状态点
			pRec->SetAcquirePoint(ptEnd);
		}

	}
	else
	{
		//4. 创建管子
		ptEnd.z = dNewEl;
		memcpy(m_pPipeParam,pParamred,sizeof(WPipe::PipeParam));
		CreatePipe(ptSta,ptEnd,m_pPipeParam);
		m_pPipeParam->m_dEl = dNewEl;

		//调整本次状态点
		pRec->SetAcquirePoint(ptEnd);
	}
	return TRUE;
}

BOOL TDbPipeLine::ChangeEl3(AECStatusRecord* pRec,AcGePoint3d& ptThis)
{
	double dNewEl = ptThis.z;
	AcGeVector3d vtMaj,vtMin;
	if (GetLastInterface() != NULL)
	{
		vtMaj = GetLastInterface()->vtDir;
		vtMaj.normalize();
		vtMin = ptThis - GetLastInterface()->ptPos;

		vtMaj.normalize();
		vtMin.normalize();

		AcGeVector3d vtMajN = vtMaj;
		vtMajN.negate();
		AcGeVector3d vtHalf = vtMin + vtMajN;
		vtHalf.normalize();

		double dA = vtHalf.angleTo(vtMaj);
		if ( (dA - PI / 2.0 ) >  1.e-10)
		{
			dA = PI - dA;
		}
		double dR = m_pPipeParam->m_dDN * m_pPipeParam->m_dRRatio;
		double dX = dR / tan(dA);

		AcGePoint3d ptMid,ptSta,ptEnd,ptGeT,ptLast;

		//如果上段不是管子
		AcDbObjectId idLast = GetLastInterface()->idOwner;
		AcDbEntity* pEnt = NULL;
		if (Acad::eOk == acdbOpenAcDbEntity(pEnt,idLast,AcDb::kForWrite))
		{
			AecDbEwPipe* pPipe = AecDbEwPipe::cast(pEnt);
			if (pPipe == NULL)//不是管子
			{
				ptMid = GetLastInterface()->ptPos;
				ptMid += vtMaj * dX;
			}
			else//改短上次管子
			{
				ptLast = GetLastInterface()->ptPos;
				if (ptLast.distanceTo(pPipe->EndPoint()) < 1.e-3)
				{
					ptEnd = pPipe->EndPoint();
					ptMid = ptEnd;
					ptEnd -= vtMaj * dX;

					ptGeT = pPipe->EndPoint();
					pPipe->SetEndPoint(ptEnd);
					ptLast = ptEnd;
				}
				else
				{
					vtMaj = pPipe->StartPoint() - pPipe->EndPoint();
					vtMaj.normalize();

					ptSta = pPipe->StartPoint();
					ptMid = ptSta;
					ptSta -= vtMaj * dX;

					ptGeT = pPipe->StartPoint();
					pPipe->SetStartPoint(ptSta);
					ptLast = ptSta;
				}
			}
			pEnt->close();
		}

		//压入当前param
		PushPipeParam();

		//1. 如果方向不同创建弯头
		if (!vtMaj.isParallelTo(vtMin))
		{
			CreateElbow(vtMaj,ptMid,vtMin,m_pPipeParam);

			if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)//法兰管
			{
				//再次调整管线末端,一个法兰厚度
				if (Acad::eOk == acdbOpenAcDbEntity(pEnt,idLast,AcDb::kForWrite))
				{
					AecDbEwPipe* pPipe = AecDbEwPipe::cast(pEnt);
					if (pPipe != NULL)
					{
						if (ptLast.distanceTo(pPipe->EndPoint()) < 1.e-3)
						{
							ptEnd = pPipe->EndPoint();
							ptEnd -= vtMaj * m_pPipeParam->m_dWh;
							pPipe->SetEndPoint(ptEnd);
						}
						else
						{
							ptSta = pPipe->StartPoint();
							ptSta -= vtMaj * m_pPipeParam->m_dWh;
							pPipe->SetStartPoint(ptSta);
						}
					}
					pEnt->close();
				}
			}
		}

		//2. 创建斜管

		AecInterface intf;
		intf = m_arHistoryIntfs[m_arHistoryIntfs.GetSize() - 1];

		ptSta = intf.ptPos;
		ptEnd = ptThis;

		CreatePipe(ptSta,ptEnd,m_pPipeParam);

		m_pPipeParam->m_dEl = dNewEl;

		//调整本次状态点
		pRec->SetAcquirePoint(ptEnd);
		return TRUE;
	}
	else//没有,创建一段斜管
	{
		if (pRec != NULL)
		{
			AECStatusRecord* pLast = m_pPipeJig->GetTailStatusRec();
			if (pLast != NULL)
			{
				AcGePoint3d ptSta = pLast->GetAcquirePoint();
				AcGePoint3d ptEnd = ptThis;

				CreatePipe(ptSta,ptEnd,m_pPipeParam);

				m_pPipeParam->m_dEl = dNewEl;

				//调整本次状态点
				pRec->SetAcquirePoint(ptEnd);
				return TRUE;
			}
		}
	}
	return FALSE;
}

BOOL TDbPipeLine::CreateWPipe(AECStatusRecord* pRec,BOOL bMaybeAddTee)
{
	AcGePoint3d ptGe,ptGe1;

	AecDbEwPipe* pWpipe = new AecDbEwPipe;
	AecDbObjXDataMap* pXDataMap = pWpipe->GetSpecialtyData();
	FillConfigXDataMap(pXDataMap,m_pPipeParam);


	// 根据 管线系统 设置相关信息

	AcDbObjectId innLy = CoreTools::getLyByPipeSys(m_pPipeParam->szSys, true);
	AcDbObjectId outLy = CoreTools::getLyByPipeSys(m_pPipeParam->szSys, false);

	// 管线实体的图层
	SetPipeLayer(pWpipe, m_pPipeParam->szSys);

	if (getEApp() == WPipe::eDuct || getEApp() == WPipe::eBridge)
		pWpipe->SetSection(m_pPipeParam->m_dW, m_pPipeParam->m_dH, m_pPipeParam->m_dThick);
	else
		pWpipe->SetSection(m_pPipeParam->m_dD, m_pPipeParam->m_dThick);

	ptGe = m_pPipeJig->GetTailStatusRec()->GetAcquirePoint();
	ptGe1 = pRec->GetAcquirePoint();

#ifndef _DEBUG_WAS_DEFINED
	acutPrintf(_T("\n%.3f-%.3f"), ptGe.x, ptGe.y);
	acutPrintf(_T("\n%.3f-%.3f"), ptGe1.x, ptGe1.y);
#endif

	pWpipe->SetStartPoint( ptGe );
	pWpipe->SetEndPoint( ptGe1 );
	AcGeVector3d vtDir = ptGe1 - ptGe;

	AecInterface intf;
	pWpipe->GetInterface(1, intf);

	//pWpipe->ReCreateByXDataMap();
	setInfo2Ent(*pXDataMap);
	AcDbObjectId id = AddPipeToModelSpace(pWpipe);
	AddUserData(id,pXDataMap,0);

	//记录接口到历史记录
	intf.ptPos = ptGe1;
	intf.vtDir = vtDir;
	intf.idOwner = id;
	PushInterface(intf);

	if (bMaybeAddTee) //开始端或末端考虑添加三通的可能性
	{
		//1. 可能的与其他管子在开始端合成三通
		MaybeAddTeeConnectToThis(ptGe,vtDir,id,0);

		//2. 可能的与其他管子在末端合成三通,从而结束命令
		if ( MaybeAddTeeConnectToThis(ptGe1,vtDir,id,1) )
		{
			//结束命令
			m_bStopCommand = TRUE;
		}

		//1.可能与其他的管子在中间端合成四通的可能性
		MaybeAddCrossConnectToThis(ptGe,ptGe1,id);
	}
	else //末端或中间部分添加三通或四通的可能性
	{
		//1.可能与其他的管子在中间端合成四通的可能性
		MaybeAddCrossConnectToThis(ptGe,ptGe1,id);

		//2. 可能的与其他管子在末端合成三通,从而结束命令
		if ( MaybeAddTeeConnectToThis(ptGe1,vtDir,id,1) )
		{
			//结束命令
			m_bStopCommand = TRUE;
		}
	}
	return TRUE;
}

BOOL TDbPipeLine::CreatePipe(AcGePoint3d ptSta,AcGePoint3d ptEnd,WPipe::PipeParam* pPipeParam)
{
	AecDbEwPipe* pWpipe = new AecDbEwPipe;
	AecDbObjXDataMap* pXDataMap = pWpipe->GetSpecialtyData();
	FillConfigXDataMap(pXDataMap,m_pPipeParam);

	if (getEApp() == WPipe::eDuct || getEApp() == WPipe::eBridge)
		pWpipe->SetSection(pPipeParam->m_dW, pPipeParam->m_dH, pPipeParam->m_dThick);
	else
		pWpipe->SetSection(pPipeParam->m_dD, pPipeParam->m_dThick);

	pXDataMap->SetAt(KEY_RUNTIME, ePipe);

	//设置图层
	SetPipeLayer(pWpipe, m_pPipeParam->szSys);

	pWpipe->SetStartPoint( ptSta );
	pWpipe->SetEndPoint( ptEnd );

	if ( fabs(ptSta.z - ptEnd.z) > 1.e-6)
	{
		pWpipe->GetSpecialtyData()->SetAt(KEY_DRAWGRAD,TRUE);
	}

	AecInterface intf;
	pWpipe->GetInterface(1, intf);

	//pWpipe->ReCreateByXDataMap();
	setInfo2Ent(*pXDataMap);
	AcDbObjectId id = AddPipeToModelSpace(pWpipe);
	AddUserData(id,pXDataMap,0);

	AcGeVector3d vtDir = ptEnd - ptSta;
	vtDir.normalize();

	//记录接口到历史记录
	intf.ptPos = ptEnd;
	intf.vtDir = vtDir;
	intf.idOwner = id;
	PushInterface(intf);

	return TRUE;
}

BOOL TDbPipeLine::CreatePipe(AcDbCurve *pCrv, WPipe::PipeParam *pPipeParam)
{
	if (pCrv == NULL)
		return FALSE;

	AecDbEwPipe *pWpipe = new AecDbEwPipe;
	AecDbObjXDataMap *pXDataMap = pWpipe->GetSpecialtyData();
	FillConfigXDataMap(pXDataMap, m_pPipeParam);

	if (getEApp() == WPipe::eDuct || getEApp() == WPipe::eBridge)
		pWpipe->SetSection(pPipeParam->m_dW, pPipeParam->m_dH, pPipeParam->m_dThick);
	else
		pWpipe->SetSection(pPipeParam->m_dD, pPipeParam->m_dThick);

	pXDataMap->SetAt(KEY_RUNTIME, ePipe);


	AcDbObjectId innLy = CoreTools::getLyByPipeSys(m_pPipeParam->szSys, true);
	AcDbObjectId outLy = CoreTools::getLyByPipeSys(m_pPipeParam->szSys, false);
	pWpipe->GetSpecialtyData(AcDb::kForWrite)->SetAt(PIPE_LINELAYER, innLy);
	pWpipe->GetSpecialtyData(AcDb::kForWrite)->SetAt(PIPE_LINELAYER, outLy);

	//设置图层
	AcDbObjectId idCenLay, idOutLay, idSingle, idDash, idCen;

	idCenLay = innLy;
	idOutLay = outLy;
	idSingle = innLy;

	pXDataMap->SetAt(PIPE_CENTLAY, idCenLay);
	pXDataMap->SetAt(PIPE_OUTDLAY, idOutLay);
	pXDataMap->SetAt(PIPE_SINGLAY, idSingle);

	// 管线实体的图层
	SetPipeLayer(pWpipe, m_pPipeParam->szSys);


	//pWpipe->SetStartPoint(ptSta);
	//pWpipe->SetEndPoint(ptEnd);
	pWpipe->SetBaseCurve(pCrv);

	//if (fabs(ptSta.z - ptEnd.z) > 1.e-6)
	//{
	//	pWpipe->GetSpecialtyData()->SetAt(KEY_DRAWGRAD, TRUE);
	//}

	AecInterface intf;
	pWpipe->GetInterface(1, intf);

	//pWpipe->ReCreateByXDataMap();
	setInfo2Ent(*pXDataMap);
	AcDbObjectId id = AddPipeToModelSpace(pWpipe);
	AddUserData(id, pXDataMap, 0);

	AcGeVector3d vtDir;
	double dS = 0;
	pCrv->getStartParam(dS);
	pCrv->getFirstDeriv(dS, vtDir);
	vtDir.normalize();

	AcGePoint3d ptEnd;
	pCrv->getEndPoint(ptEnd);

	//记录接口到历史记录
	intf.ptPos = ptEnd;
	intf.vtDir = vtDir;
	intf.idOwner = id;
	PushInterface(intf);

	return TRUE;
}

BOOL TDbPipeLine::ExtendLastWPipe(AECStatusRecord* pRec)
{
	int nLen = m_arHistoryIntfs.GetSize();
	if (nLen == 0)
		return FALSE;

	AecInterface& intf = m_arHistoryIntfs[nLen - 1];
	AcDbObjectId id = intf.idOwner;
	
	AcDbEntity* pEnt = NULL;
	if (Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite))
	{
		AecDbEwPipe* pDbWpipe = AecDbEwPipe::cast(pEnt);
		if (pDbWpipe != NULL)
		{
			AcGePoint3d ptGe = m_pPipeJig->GetTailStatusRec()->GetAcquirePoint();
			AcGePoint3d ptGe1 = pRec->GetAcquirePoint();
			AcGeVector3d vtThis = ptGe1 - ptGe;
			AcGePoint3d ptGeT;
			int nPos = 0;
			AcGeVector3d vt = pDbWpipe->EndPoint() - pDbWpipe->StartPoint();
			if (vtThis.isCodirectionalTo(vt))
			{
				ptGeT = pDbWpipe->EndPoint();
				pDbWpipe->SetEndPoint(pRec->GetAcquirePoint());
				nPos = 1;
			}
			else
			{
				ptGeT = pDbWpipe->StartPoint();
				pDbWpipe->SetStartPoint(pRec->GetAcquirePoint());
			}

			//先关闭
			pEnt->close();

			//1.可能与其他的管子在中间端合成四通的可能性
			MaybeAddCrossConnectToThis(ptGe,ptGe1,id);

			//2. 可能的与其他管子在末端合成三通,从而结束命令
			AcGeVector3d vtDir = ptGe1 - ptGe;
			if ( MaybeAddTeeConnectToThis(ptGe1,vtDir,id,nPos) )
			{
				//结束命令
				m_bStopCommand = TRUE;
			}
			intf.ptPos = pRec->GetAcquirePoint();
			PushInterface(intf,FALSE);
			return TRUE;
		}

		AecDbEwFitting* pDbFit = AecDbEwFitting::cast(pEnt);
		if (pDbFit != NULL) //上次是管件,本次创建管子
		{
			AecDbObjXDataMap* pXDataMap = pDbFit->GetSpecialtyData();
	
			int nVal = 0;
			pXDataMap->GetAt(KEY_RUNTIME,nVal);
			EFittingType eKind = (EFittingType)nVal;

			//可能的改上次弯头为三通,当方向不一致
			if (nVal == eElbow)
			{
				AcGeVector3d vtIntf = intf.vtDir;
				AcGePoint3d ptGe = m_pPipeJig->GetTailStatusRec()->GetAcquirePoint();
				AcGePoint3d ptGe1 = pRec->GetAcquirePoint();
				AcGeVector3d vtThis = ptGe1 - ptGe;

				if (vtThis.isParallelTo(vtIntf))
				{
					if (!vtThis.isCodirectionalTo(vtIntf)) // 反向,改弯头为三通
					{
						//判断弯头是否是90度弯头
						double dAng = 0.0;
						pXDataMap->GetAt(PIPE_ELBOWANG,dAng);

						if ( fabs( dAng - 90.0 ) < 1.e-6) //是90 度
						{
							//获取另一方向
							double dDn = 100.0;
							AcGeVector3d vt1,vt2;
							pXDataMap->GetAt(KEY_MAJBR,vt1);
							pXDataMap->GetAt(KEY_MINBR,vt2);
							pXDataMap->GetAt(PIPE_DN,dDn);

							AcGeVector3d vtMin;
							if (vt1.isParallelTo(vtIntf))   // 本位置
							{
								vtMin = vt2;
							}
							else
							{
								vtMin = vt1;
								vtMin.negate();
							}

							AcGePoint3d ptGeM;
							pXDataMap->GetAt(KEY_MID,ptGeM);
							ChangeElbowToTree(pDbFit,vtThis,ptGeM,vtMin,dDn,pRec);
						}
					}
				}
			}
			else if(nVal == eTee)
			{
				AcGeVector3d vtIntf = intf.vtDir;

				AcGePoint3d ptGe = m_pPipeJig->GetTailStatusRec()->GetAcquirePoint();
				AcGePoint3d ptGe1 = pRec->GetAcquirePoint();
				AcGeVector3d vtThis = ptGe1 - ptGe;

				AecInterface inf2,inf0;
				pDbFit->GetInterface(2,inf2);
				pDbFit->GetInterface(0,inf0);
				AcGeVector3d vtInf2 = inf2.vtDir;
				AcGeVector3d vtInf0 = inf0.vtDir;

				if (vtInf0.isPerpendicularTo(vtInf2)) //正十字三通
				{
					//如果是支管拉,才可能创建四通;
					if (vtThis.isParallelTo(vtIntf) && vtIntf.isParallelTo(vtInf2) )
					{
						if (!vtThis.isCodirectionalTo(vtIntf)) // 反向,改三通为四通
						{
							//直接改三通为四通
							ChangeTeeToCross(pDbFit,vtInf0,vtInf2,pRec);
						}
					}
				}
			}

			pEnt->close();
			return CreateWPipe(pRec);
		}

		AecDbEwEquipment* pWEqu = AecDbEwEquipment::cast(pEnt);
		if (pWEqu != NULL)
		{
			pEnt->close();
			return CreateWPipe(pRec);
		}
		pEnt->close();
		intf.ptPos = pRec->GetAcquirePoint();
		return TRUE;
	}
	return FALSE;
}

BOOL TDbPipeLine::CreateElbowAndPipe(AECStatusRecord* pRec, const EFittingType &type)
{
	int nLen = m_arHistoryIntfs.GetSize();
	if (nLen == 0)
		return FALSE;

	AecInterface intf;
	intf = m_arHistoryIntfs[nLen - 1];
	AcDbObjectId id = intf.idOwner;

	AecDbEwFitting* pFitting = new AecDbEwFitting;
	AecDbObjXDataMap* pXDataMap = pFitting->GetSpecialtyData();
	FillConfigXDataMap(pXDataMap,m_pPipeParam);

	CString sODNo = m_pPipeParam->szODSn;
	IsPlasticsMat(m_pPipeParam, sODNo);

	pXDataMap->SetAt(PIPE_CONNECT,m_pPipeParam->m_nConnectType);
	if (m_pPipeParam->m_nConnectType > 0)
	{
		double dFD = 0.0,dFL = 0.0;
		int nConnType = m_pPipeParam->m_nConnectType;
		if (nConnType == 4)	// 卡箍数据与承插一致
			nConnType = 1;
		TDbPipeSupport::QueryInfFDFL(m_pPipeJig->GetAdoDb(),eElbow,nConnType,m_pPipeParam->m_dDN,dFD,dFL);

		pXDataMap->SetAt(PIPE_INTERFACED,dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL,dFL);

		if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)
		{
			//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
			double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
			TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(),m_pPipeParam->m_dDN,m_pPipeParam->m_dPress,dWD,dWh,dThk,dN);
			m_pPipeParam->m_dWh = dWh;
			pXDataMap->SetAt(PIPE_WH, dWh);
			pXDataMap->SetAt(PIPE_WN,dN);
		}
	}

	pXDataMap->SetAt(KEY_FITSRV,KEY_FITWPIPE);

	if (getEApp() == WPipe::eDuct)
		pXDataMap->SetAt(KEY_RUNTIME, eDuctElbow);
	else if(getEApp() == WPipe::eBridge)
		pXDataMap->SetAt(KEY_RUNTIME, eBridgeElbow);
	else
		pXDataMap->SetAt(KEY_RUNTIME, eElbow);

	pXDataMap->SetAt(KEY_GRIPCMD, GRIP_CMD);

	if (getEApp() == WPipe::eDuct || getEApp() == WPipe::eBridge)
	{
		pXDataMap->SetAt(DUCT_W, m_pPipeParam->m_dW);
		pXDataMap->SetAt(DUCT_H, m_pPipeParam->m_dH);
		pXDataMap->SetAt(DUCT_THICK, m_pPipeParam->m_dThick);
		pXDataMap->SetAt(DUCT_W2, m_pPipeParam->m_dW);
		pXDataMap->SetAt(DUCT_H2, m_pPipeParam->m_dH);
		pXDataMap->SetAt(DUCT_THICK2, m_pPipeParam->m_dThick);
	}

	AcGePoint3d ptCur = pRec->GetAcquirePoint();
	AcGePoint3d ptGeM = m_pPipeJig->GetTailStatusRec()->GetAcquirePoint();

	AcGeVector3d vtMaj,vtMin;
	vtMaj = intf.vtDir;
	vtMin = ptCur - ptGeM;

	pXDataMap->SetAt(KEY_MAJBR,vtMaj);
	pXDataMap->SetAt(KEY_MINBR,vtMin);
	pXDataMap->SetAt(KEY_MID,ptGeM);

	//设置图层
	SetFittingLayer(pFitting, m_pPipeParam->szSys);
	
	double dAng = 90.0;
	dAng = vtMin.angleTo(vtMaj);
	if (dAng - PI / 2.0 > 1.e-3)
		dAng -= PI / 2.0;
	//dAng *= 180 / PI;

	pXDataMap->SetAt(PIPE_RATIO,m_pPipeParam->m_dRRatio);
	pXDataMap->SetAt(PIPE_ELBOWANG,dAng); //角度
	//pFitting->ReCreateByXDataMap();

	//查询设置项目等级
	if (!QuerySetProjectLevel(pXDataMap, m_pPipeParam, _T("弯头")))
		return FALSE;

	double dL = 0.0;
	if (IsPlasticsMat(m_pPipeParam, sODNo))
	{
		TDbPipeSupport::QueryPVCElbow(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, pXDataMap, sODNo);
	}
	else
	{
		TDbPipeSupport::QueryElbowL(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, dL, m_pPipeParam->m_dRRatio, m_pPipeParam->m_nConnectType, m_pPipeParam->szLevel,pXDataMap);
		pXDataMap->SetAt(KEY_Length, dL);
	}

	//改变上次intf 的末端点
	AecInterface intf0,intf1;
	pFitting->GetInterface(0,intf0);
	pFitting->GetInterface(1,intf1);
	AcGeVector3d vtMove = vtMaj;
	vtMove.normalize();
	AcGePoint3d ptGeT;

	AcGeVector3d vtPipe(0,0,0);
	AcDbEntity* pEnt = NULL;
	if (Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite))
	{
		// 如果上次是管子，则改变上次管子的终点
		AecDbEwPipe* pWPipe = AecDbEwPipe::cast(pEnt);
		if (pWPipe != NULL)
		{
			vtPipe = pWPipe->EndPoint() - pWPipe->StartPoint();
			if (intf0.vtDir.isParallelTo(vtPipe))
			{
				//距离那个点近, 则修改哪个点
				double dDis1 = ptGeM.distanceTo(pWPipe->StartPoint());
				double dDis2 = ptGeM.distanceTo(pWPipe->EndPoint());
				if (dDis1 <  dDis2)
				{
					ptGeT = pWPipe->StartPoint();
					pWPipe->SetStartPoint(intf0.ptPos);
				}
				else
				{
					ptGeT = pWPipe->EndPoint();
					pWPipe->SetEndPoint(intf0.ptPos);
				}
			}

			if (intf1.vtDir.isParallelTo(vtPipe))
			{
				//距离那个点近, 则修改哪个点
				double dDis1 = ptGeM.distanceTo(pWPipe->StartPoint());
				double dDis2 = ptGeM.distanceTo(pWPipe->EndPoint());
				if (dDis1 <  dDis2)
				{
					ptGeT = pWPipe->StartPoint();
					pWPipe->SetStartPoint(intf1.ptPos);
				}
				else
				{
					ptGeT = pWPipe->EndPoint();
					pWPipe->SetEndPoint(intf1.ptPos);
				}
			}
		}

		AecDbEwFitting* pDbFit = AecDbEwFitting::cast(pEnt);
		AecDbEwEquipment* pDbWEqu = AecDbEwEquipment::cast(pEnt);
		if (pDbFit != NULL || pDbWEqu != NULL) //如果是管件或设备元件,则加入的弯头需要调整M点,因为上次对象不可更改接口点
		{
			AcGeVector3d vtPipe = intf.vtDir;
			if (intf0.vtDir.isParallelTo(vtPipe))
			{
				vtMove = intf.ptPos - intf0.ptPos;
			}
			if (intf1.vtDir.isParallelTo(vtPipe))
			{
				vtMove = intf.ptPos - intf1.ptPos;
			}

			ptGeM += vtMove;
			pXDataMap->SetAt(KEY_MID,ptGeM);
			//pFitting->ReCreateByXDataMap();

			pFitting->GetInterface(0,intf0);
			pFitting->GetInterface(1,intf1);
		}
		pEnt->close();
	}

	//添加本次到数据库
	dAng *= 180.0;
	dAng /= PI;
	bool bFittingAdded = false;
	if (dAng - 1.0 > 1.e-3)
	{
		AcArray<AecInterface> arInfs;
		pFitting->GetInterface(arInfs);
		AddUserData(pFitting,pXDataMap,1,&arInfs);
		setInfo2Ent(*pXDataMap);
		id = AddFitToModelSpace(pFitting);
		AddUserData(id,pXDataMap,1);

		bFittingAdded = true;

		//绘制立管参考,建立关系,
		if (vtPipe.isParallelTo(AcGeVector3d::kZAxis))
		{
			if (Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite))
			{
				// 如果上次是管子，则改变上次管子的终点
				AecDbEwPipe* pWPipe = AecDbEwPipe::cast(pEnt);
				if (pWPipe != NULL)
				{
					TCHAR szHandle[33];
					memset(szHandle,0,sizeof(TCHAR) * 33);
					id.handle().getIntoAsciiBuffer(szHandle);
					pWPipe->GetSpecialtyData()->SetAt(PIPE_CONNECT,szHandle);
				}
				pEnt->close();
			}
		}
	}

	//创建余下的管子
	AcGePoint3d ptSta,ptEnd;
	if (intf0.vtDir.isParallelTo(vtMin))
	{
		ptSta = intf1.ptPos;
		ptEnd = intf0.ptPos;
	}
	if (intf1.vtDir.isParallelTo(vtMin))
	{
		ptSta = intf0.ptPos;
		ptEnd = intf1.ptPos;
	}

	//记录弯头末接口到历史记录
	intf.ptPos = ptEnd;
	intf.vtDir = vtMin;
	intf.idOwner = id;
	PushInterface(intf);

	ptGeT = pRec->GetAcquirePoint();
	ptGeT += vtMove;
	pRec->SetAcquirePoint(ptGeT);

	//校正
	AcGePoint3d ptTemp;
	AcDbLine ln;
	ln.setStartPoint(ptEnd);
	ptTemp = ptEnd + 1000.0 * vtMin;
	ln.setEndPoint(ptTemp);
	ln.getClosestPointTo(ptGeT,ptGeT,Adesk::kTrue);
	pRec->SetAcquirePoint(ptGeT);

	//创建余下管子,并插入虚拟状态记录
	AECStatusRecord* pRecMid = new AECStatusRecord;
	pRecMid->CopyFrom(pRec);
	pRecMid->SetAcquirePoint(ptEnd);
	m_pPipeJig->PushBackStatusRec(pRecMid);

	CreateWPipe(pRec);

	if ( !bFittingAdded )
	{
		delete pFitting;
	}
	return TRUE;
}

AcDbObjectId TDbPipeLine::CreateElbow(AcGeVector3d vtMaj
	,AcGePoint3d ptMid
	,AcGeVector3d vtMin
	,WPipe::PipeParam* pparam
	,BOOL bInsertBeforLast)
{
	if (pparam == NULL) pparam = m_pPipeParam;

	AecDbEwFitting* pFitting = new AecDbEwFitting;
	AecDbObjXDataMap* pXDataMap = pFitting->GetSpecialtyData();
	FillConfigXDataMap(pXDataMap, pparam);

	CString sODNo = m_pPipeParam->szODSn;
	IsPlasticsMat(m_pPipeParam, sODNo);

	CString sProj = _T("工业");;
	pXDataMap->GetAt(DOC_PROJECT, sProj);

	CString sLevel;
	pXDataMap->GetAt(PIPE_LEVEL, sLevel);

	if (pparam->m_nConnectType > 0)
	{
		double dFD = 0.0, dFL = 0.0;
		TDbPipeSupport::QueryInfFDFL(m_pPipeJig->GetAdoDb(), eElbow, pparam->m_nConnectType, pparam->m_dDN, dFD, dFL, sProj,pparam->szLevel);

		pparam->m_dInterfaceD = dFD;
		pparam->m_dInterfaceL = dFL;

		if (pparam->m_nConnectType == 3 || pparam->m_nConnectType == 5)
		{
			//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
			double dWD = 0.0, dWh = 0.0, dThk = 0.0, dN = 0.0;
			TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, m_pPipeParam->m_dPress, dWD, dWh, dThk, dN, sProj, pparam->szLevel);
			pparam->m_dWh = dWh;
			pparam->m_dWn = dN;
		}
	}

	pXDataMap->SetAt(KEY_FITSRV,KEY_FITWPIPE);
	if (pparam->m_app == WPipe::eDuct)
		pXDataMap->SetAt(KEY_RUNTIME,eDuctElbow);
	else if (pparam->m_app == WPipe::eBridge)
		pXDataMap->SetAt(KEY_RUNTIME,eBridgeElbow);
	else
		pXDataMap->SetAt(KEY_RUNTIME,eElbow);

	if (pparam->m_app == WPipe::eDuct || pparam->m_app == WPipe::eBridge)
	{
		pXDataMap->SetAt(DUCT_W, pparam->m_dW);
		pXDataMap->SetAt(DUCT_H, pparam->m_dH);
		pXDataMap->SetAt(DUCT_THICK, pparam->m_dThick);
		pXDataMap->SetAt(DUCT_W2, pparam->m_dW);
		pXDataMap->SetAt(DUCT_H2, pparam->m_dH);
		pXDataMap->SetAt(DUCT_THICK2, pparam->m_dThick);
	}

	pXDataMap->SetAt(PIPE_WH,pparam->m_dWh);
	pXDataMap->SetAt(PIPE_WN,pparam->m_dWn);

	pXDataMap->SetAt(KEY_MAJBR,vtMaj);
	pXDataMap->SetAt(KEY_MINBR,vtMin);
	pXDataMap->SetAt(KEY_MID,ptMid);
	pXDataMap->SetAt(KEY_GRIPCMD, GRIP_CMD);
	pXDataMap->SetAt(KEY_2DSTYLE, PipelineTools::isDoubleLine(m_pPipeParam->m_dDN) ? 2 : 1);

	//结构长度
	double dL = 0.0;
	TDbPipeSupport::QueryElbowL(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, dL, m_pPipeParam->m_dRRatio, m_pPipeParam->m_nConnectType, m_pPipeParam->szLevel,pXDataMap);
	pXDataMap->SetAt(KEY_Length, dL);

	if (IsPlasticsMat(pparam, sODNo))
	{
		TDbPipeSupport::QueryPVCElbow(m_pPipeJig->GetAdoDb(), pparam->m_dDN, pXDataMap, sODNo);
	}

	//查询设置项目等级
	if (!QuerySetProjectLevel(pXDataMap, pparam, _T("弯头")))
		return FALSE;

	dL = 0.0;
	if (IsPlasticsMat(m_pPipeParam, sODNo))
	{
		TDbPipeSupport::QueryPVCElbow(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, pXDataMap, sODNo);
	}
	else
	{
		TDbPipeSupport::QueryElbowL(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, dL, m_pPipeParam->m_dRRatio, m_pPipeParam->m_nConnectType, m_pPipeParam->szLevel,pXDataMap);
	}
	pXDataMap->SetAt(KEY_Length, dL);


	if (pparam->m_nConnectType == 3 || pparam->m_nConnectType == 5)
	{
		//垫片
		TDbPipeSupport::SetGasketData(m_pPipeJig->GetAdoDb(),0, m_pPipeParam->m_dDN, m_pPipeParam->m_dPress, sProj, sLevel, pXDataMap);

		//螺栓
		TDbPipeSupport::SetBoltData(m_pPipeJig->GetAdoDb(), 0,m_pPipeParam->m_dDN, m_pPipeParam->m_dPress, sProj, sLevel, pXDataMap);
	}

	//设置图层
	SetFittingLayer(pFitting, pparam->szSys);

	double dAng = PI / 2.0;
	dAng = vtMin.angleTo(vtMaj);
	if (dAng - PI / 2.0 > 1.e-3)
		dAng -= PI / 2.0;

	pXDataMap->SetAt(PIPE_RATIO, pparam->m_dRRatio);
	pXDataMap->SetAt(PIPE_ELBOWANG,dAng); //角度
	//pFitting->ReCreateByXDataMap();

	AecInterface intf0,intf1;
	pFitting->GetInterface(0,intf0);
	pFitting->GetInterface(1,intf1);

	m_intf0 = intf0;
	m_intf1 = intf1;

	//pFitting->ReCreateByXDataMap();

	//添加本次到数据库
	//至少弯头的角度>1度,否则不加
	dAng *= 180.0;
	dAng /= PI;

	AcDbObjectId id;
	bool bFittingAdded = false;
	if (dAng - 1.0 > 1.e-3)
	{
		AcArray<AecInterface> arInfs;
		pFitting->GetInterface(arInfs);
		AddUserData(pFitting,pXDataMap,1,&arInfs);
		setInfo2Ent(*pXDataMap);
		id = AddFitToModelSpace(pFitting);
		AddUserData(id,pXDataMap,1);
		bFittingAdded = true;
	}

	//记录接口到历史记录
	intf1.idOwner = id;
	if (m_pPipeJig != NULL) intf1.nType = m_pPipeJig->GetUndoGroupID();

	if (bInsertBeforLast)
	{
		if (m_arHistoryIntfs.GetSize() > 0)
		{
			AecInterface inf = m_arHistoryIntfs[m_arHistoryIntfs.GetSize() - 1];
			m_arHistoryIntfs.RemoveAt(m_arHistoryIntfs.GetSize() - 1);
			PushInterface(intf0);
			PushInterface(inf);
		}
		else
		{
			PushInterface(intf0);
		}
	}
	else
	{
		PushInterface(intf0);
	}
	if (!bFittingAdded)
	{
		delete pFitting;
	}
	return id;
}

void TDbPipeLine::AddUserData(AcDbObjectId id,AecDbObjXDataMap* pXDataMap,int nType)
{
	// 增加参数 [10/24/2016 Rex]
	if(!id.isNull())
	{
		AecDbObjXDataMap* pXTempDataMap  = new AecDbObjXDataMap();
		CMapStringToString mapData;

		if(pXTempDataMap->Read(id,_T("BIMEQUIP"),TRUE))
		{
			//用户数据USER0~999
			CString sKey,sVal;
			for (int i = 0;i < MAX_BIM_DATA_LEN;i++)
			{
				sKey.Format(_T("user%d"),i)	;
				if (pXDataMap->GetAt(sKey,sVal))
				{
					mapData.SetAt(sKey,sVal);
				}
				else
				{
					break;
				}
			}
		}

		CString sKey;
		CString sVal;
		for (int i = 0;i < MAX_BIM_DATA_LEN;i++)
		{
			sKey.Format(_T("user%d"),i)	;
			pXTempDataMap->RemoveAt(sKey);
		}
		for (POSITION ps = mapData.GetStartPosition();ps != NULL;)
		{
			mapData.GetNextAssoc(ps,sKey,sVal);

			if(sVal.Find(_T("物料描述")) != -1)
			{
				//nType == 0 Pipe,1 Elbow,2 Tee,3 Cross,4 Flange
				CString szTempKey = _T("");
				switch (nType)
				{
				case 1:
				case 2:
				case 3:
				case 4:
				case 5:
					{
						if(nType == 1)
							szTempKey = _T("弯头");
						else if(nType == 2)
							szTempKey = _T("三通");
						else if(nType == 3)
							szTempKey = _T("四通");
						else if(nType == 4)
							szTempKey = _T("法兰");
						else if(nType == 5)
							szTempKey = _T("变径");
						else
							szTempKey = _T("");
						CString szTemp;
						szTemp = sVal;
						int nIndex = szTemp.Find(_T("("));
						if(nIndex >= 0)
						{
							szTemp = szTemp.Mid(nIndex);
							szTempKey = _T("物料描述:") + szTempKey;
							szTemp = szTempKey + szTemp;
							sVal = szTemp;
						}
					}
					break;
				default:
					break;
				}
			}
			pXTempDataMap->SetAt(sKey,sVal);
		}
		//pXTempDataMap->SetAt(_T("user0"),_T("test:test"));
		if(pXTempDataMap->Write(id,_T("BIMEQUIP"),TRUE))
		{
			DELETE_PTR(pXTempDataMap);
			pXTempDataMap = NULL;
		}
	}

	//添加ObjectId 序列表
	m_arIdLast.append(id);

	int nEType = 0;
	pXDataMap->GetAt(KEY_RUNTIME,nEType);
	
	m_arETypeLast.append(nEType);
}

bool TDbPipeLine::HasWipeClip()
{
	return m_bWipeClip;
}

void TDbPipeLine::AddUserData(AecDbEwFitting* pFit,AecDbObjXDataMap* pXDataMap,int nType,AcArray<AecInterface>* parInfs)
{
	int nEType = 0;
	pXDataMap->GetAt(KEY_RUNTIME,nEType);

	if (nEType == eElbow && parInfs != NULL)//如果是弯头
	{
		//并且有一个接口上下
		bool bUpOrDown = false;
		for (int i = 0;i < parInfs->length();i++)
		{
			if ( parInfs->at(i).vtDir.isParallelTo(AcGeVector3d::kZAxis))
			{
				bUpOrDown = true;
				m_bWipeClip = true;
				break;
			}
		}

		//如果是上或者下
		if (bUpOrDown && !m_arETypeLast.isEmpty())
		{
			//找到前面一个弯头
			int nLast = m_arETypeLast.length() - 1;
			int nLastType = -1;

			while(nLast > -1)
			{
				//前次是elbow
				nLastType = m_arETypeLast.at(nLast);
				if (nLastType == eElbow)
				{
					AcDbObjectId idLastLast = m_arIdLast.at(nLast);
					TCHAR szHandle[33];
					memset(szHandle,0,sizeof(szHandle));
					idLastLast.handle().getIntoAsciiBuffer(szHandle);
					pXDataMap->SetAt(KEY_LASTHANDLE,szHandle);
					break;
				}
				nLast --;
			}
		}
	}
}

void TDbPipeLine::SetAngleWath(AcGePoint3d& ptCen,const AcGePoint3d& ptGeTo,const AcGeVector3d& vtDir)
{
	if (m_pAngleWatch != NULL)
	{
		m_pAngleWatch->SetAngleWath(ptCen,ptGeTo,vtDir);
	}
}

void TDbPipeLine::SwitchAutoSnapOrF8()
{
	if (m_pAngleWatch != NULL)
	{
		m_pAngleWatch->SwitchAutoSnapOrF8();
	}
}

void TDbPipeLine::MoveAngWatchPosition()
{
	//导航表盘
	if (m_pPipeJig->GetTailStatusRec() != NULL && 
		m_pPipeJig->GetTailStatusRec()->GetStatusType() >= AECStatusRecord::kAngle &&
		m_pPipeJig->GetTailStatusRec()->GetStatusType() <= AECStatusRecord::kPoint)
	{
		AcGePoint3d ptGe,ptGe1;
		ptGe = m_pPipeJig->GetTailStatusRec()->GetAcquirePoint();
		ptGe1 = m_pPipeJig->m_pCurStaRec->GetAcquirePoint();

		AcGeVector3d vtDir;
		vtDir = m_pAngleWatch->m_vtDir;
		AecInterface* pLast = GetLastInterface();
		if (pLast != NULL)
		{
			vtDir = pLast->vtDir;
		}
		m_pAngleWatch->SetAngleWath(ptGe,ptGe1,vtDir);
	}
}

void TDbPipeLine::AngWatchTo(const AcGePoint3d& ptGeTo)
{
	if (m_pAngleWatch != NULL)
	{
		m_pAngleWatch->m_ptGeTo = ptGeTo;
	}
}

BOOL TDbPipeLine::PipeFinished()
{
	return m_bStopCommand;
}

void TDbPipeLine::PopUpInterface(int nGroupID)
{
	while(m_arHistoryIntfs.GetSize() > 0)
	{
		if (m_arHistoryIntfs[m_arHistoryIntfs.GetSize() - 1].nType == nGroupID)
		{
			m_arHistoryIntfs.RemoveAt(m_arHistoryIntfs.GetSize() - 1);
		}
		else
		{
			break;
		}
	}
	
	//回退上次参数
	while (m_lstLastPipeParam.GetCount() > 0)
	{
		//回上次管道参数
		WPipe::PipeParam* pLast = (WPipe::PipeParam*)m_lstLastPipeParam.GetTail();
		if (pLast->m_nGroupID == nGroupID)
		{
			m_lstLastPipeParam.RemoveTail();
			DELETE_PTR(pLast);
		}
		else
		{
			memcpy(m_pPipeParam,pLast,sizeof(WPipe::PipeParam));
			break;
		}
	}
}

void TDbPipeLine::PushPipeParam()
{
	WPipe::PipeParam* pParam = new WPipe::PipeParam;
	memcpy(pParam,m_pPipeParam,sizeof(WPipe::PipeParam));
	pParam->m_nGroupID = m_pPipeJig->GetUndoGroupID();
	m_lstLastPipeParam.AddTail(pParam);
}

void TDbPipeLine::PushInterface(AecInterface& intf,BOOL bStartDragFromIt)
{
	m_arHistoryIntfs.Add(intf);
	if (bStartDragFromIt)//拖出的源对象
	{
		m_idStartDragFrom = intf.idOwner;
	}
}

Acad::ErrorStatus TDbPipeLine::Draw2d(AcGiDraw &mode) const
{
	if (m_pCurPipeLine[0] != NULL )
	{
		((TDbPipeLine*)(m_pCurPipeLine[0]))->Draw2d(mode);
	}
	if (m_pAngleWatch != NULL && m_pCurPipeLine[0] != NULL)
	{
		m_pAngleWatch->Draw2d(mode);
	}
	return Acad::eOk;
}

void TDbPipeLine::FillConfigXDataMap(AecDbObjXDataMap* pXDataMap,WPipe::PipeParam* pParam)
{
	if (pXDataMap != NULL && pParam != NULL)
	{
		pXDataMap->SetAt(PIPE_DRAWDIR,pParam->m_eD);		//绘制类型
		//pXDataMap->SetAt(KEY_2DSTYLE,1);	//双线
		pXDataMap->SetAt(KEY_2DSTYLE,PipelineTools::isDoubleLine(pParam->m_dDN) ? 2 : 1);
		pXDataMap->SetAt(KEY_SINGLE,0);
		pXDataMap->SetAt(PIPE_DN,pParam->m_dDN);
		pXDataMap->SetAt(PIPE_OD,pParam->m_dOD);
		pXDataMap->SetAt(PIPE_TDN,pParam->m_dDN);
		pXDataMap->SetAt(PIPE_TOD,pParam->m_dOD);
		pXDataMap->SetAt(PIPE_CONNECT,pParam->m_nConnectType);
		pXDataMap->SetAt(PIPE_COLOR,pParam->m_nPipeColor);
		if (pParam->m_eD == WPipe::eDN)
		{
			pXDataMap->SetAt(PIPE_D,pParam->m_dDN);
		}
		else if(pParam->m_eD == WPipe::eOD)
		{
			pXDataMap->SetAt(PIPE_D,pParam->m_dOD);
		}
		else if(pParam->m_eD == WPipe::eID)
		{
			pXDataMap->SetAt(PIPE_D,pParam->m_dOD - 2.0 * pParam->m_dThick);
		}
		pXDataMap->SetAt(PIPE_RATIO,pParam->m_dRRatio);
		pXDataMap->SetAt(KEY_RadRatio, pParam->m_nRadioOn);
		pXDataMap->SetAt(PIPE_PIPCMD, pParam->nPIPCmd);
		pXDataMap->SetAt(PIPE_RRADFLG, 1);
		pXDataMap->SetAt(PIPE_ODSN, pParam->szODSn);
		pXDataMap->SetAt(PIPE_SHTNO, pParam->szShtNo);
		pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);
		pXDataMap->SetAt(PIPE_MATERIAL,pParam->szMertial);
		pXDataMap->SetAt(PIPE_MATERIALFT,pParam->szMertialFit);
		pXDataMap->SetAt(PIPE_LEVEL,pParam->szLevel);
		pXDataMap->SetAt(PID_PIPE_DPRESS,pParam->m_dPress);

		pXDataMap->SetAt(PIPE_ELBOWFLG,FALSE);
		pXDataMap->SetAt(PIPE_BWELDDOT,FALSE);
		pXDataMap->SetAt(PIPE_ZONE,pParam->szZoneNo);
		pXDataMap->SetAt(PIPE_UNITNO, pParam->szUnitNo);
		pXDataMap->SetAt(PIPE_INSTHICK,10.0);
		pXDataMap->SetAt(PIPE_NO,pParam->szPipeno);
		pXDataMap->SetAt(KEY_NO, pParam->szNo);
		pXDataMap->SetAt(DOC_INSMATER,pParam->szInsMtr);
		pXDataMap->SetAt(PIPE_DESCR,pParam->szDescr);
		pXDataMap->SetAt(PIPE_SYS,pParam->szSys);
		pXDataMap->SetAt(PIPE_PIDD,100.0);//设置pid画法的直径
		pXDataMap->SetAt(PIPE_CONNECT,pParam->m_nConnectType);
		pXDataMap->SetAt(PIPE_INTERFACED,pParam->m_dInterfaceD);
		pXDataMap->SetAt(PIPE_INTERFACED2,pParam->m_dInterfaceD2);
		pXDataMap->SetAt(PIPE_INTERFACEL,pParam->m_dInterfaceL);
		pXDataMap->SetAt(PIPE_INTERFACEL2,pParam->m_dInterfaceL2);
		pXDataMap->SetAt(PIPE_INTERFACEL3,pParam->m_dInterfaceL3);
		pXDataMap->SetAt(PIPE_Z2DDRAW,pParam->m_bZPipe2DDraw);
		pXDataMap->SetAt(PIPE_EL, pParam->m_dEl);
		pXDataMap->SetAt(PIPE_FLANGF, pParam->m_szEndF);
		pXDataMap->SetAt(PIPE_GASKET, pParam->m_szGastInf);

		pXDataMap->SetAt(PIPE_EAPP, (int)pParam->m_app);
		if (pParam->m_app == WPipe::eDuct || pParam->m_app == WPipe::eBridge)
		{
			pXDataMap->SetAt(DUCT_W, pParam->m_dW);
			pXDataMap->SetAt(DUCT_H, pParam->m_dH);
			pXDataMap->SetAt(DUCT_THICK, pParam->m_dThick);
		}
	}
	FillInInitXDataMap(pXDataMap);
}

void TDbPipeLine::FillConfigXDataMap(AecDbObjXDataMap* pXDataMap,AecDbEwPipe* pWPipeSrc)
{
	//先整体复制
	AecDbObjXDataMap* pXDataMapSrc = pWPipeSrc->GetSpecialtyData();
	pXDataMap->CopyFrom(pXDataMapSrc);

	CString sGUID = IDCreate();
	pXDataMap->SetAt(KEY_NO,sGUID);

	//以下填满可能没有的KEY-DATA [必须项]
	int nEd(0);
	int nDir = 0;
	pXDataMapSrc->GetAt(PIPE_DRAWDIR,nDir);
	pXDataMap->SetAt(PIPE_DRAWDIR,nDir);
	nEd = nDir;

	nDir = 0;
	pXDataMapSrc->GetAt(KEY_2DSTYLE,nDir);
	pXDataMap->SetAt(KEY_2DSTYLE,nDir);

	nDir = 0;
	pXDataMapSrc->GetAt(KEY_SINGLE,nDir);
	pXDataMap->SetAt(KEY_SINGLE,nDir);

	nDir = 0;
	pXDataMapSrc->GetAt(PIPE_COLOR,nDir);
	pXDataMap->SetAt(PIPE_COLOR,nDir);

	double dDn(.0), dOd(.0);
	double dVal = 100.0;
	pXDataMapSrc->GetAt(PIPE_DN,dVal);
	pXDataMap->SetAt(PIPE_DN,dVal);
	dDn = dVal;

	dVal = 100.0;
	pXDataMapSrc->GetAt(PIPE_OD,dVal);
	pXDataMap->SetAt(PIPE_OD,dVal);
	dOd = dVal;

	// PIPE_D 必须存在
	dVal = .0;
	if (!pXDataMapSrc->GetAt(PIPE_D, dVal) || dVal < 1e-6)
	{
		if (nEd == WPipe::eDN)
			pXDataMap->SetAt(PIPE_D, dDn);
		else if (nEd == WPipe::eOD)
			pXDataMap->SetAt(PIPE_D, dOd);
		else
			pXDataMap->SetAt(PIPE_D, dDn);
	}


	pXDataMapSrc->GetAt(PIPE_TDN,dVal);
	pXDataMap->SetAt(PIPE_TDN,dVal);

	dVal = 100.0;
	pXDataMapSrc->GetAt(PIPE_TOD,dVal);
	pXDataMap->SetAt(PIPE_TOD,dVal);

	pXDataMapSrc->GetAt(PIPE_RATIO,dVal);
	pXDataMap->SetAt(PIPE_RATIO,dVal);

	dVal = 100.0;
	pXDataMapSrc->GetAt(PIPE_THICK,dVal);
	pXDataMap->SetAt(PIPE_THICK,dVal);

	CString sVal;
	pXDataMapSrc->GetAt(PIPE_MATERIAL,sVal);
	pXDataMap->SetAt(PIPE_MATERIAL,sVal);

	pXDataMapSrc->GetAt(PIPE_LEVEL,sVal);
	pXDataMap->SetAt(PIPE_LEVEL,sVal);

	dVal = 1.0;
	pXDataMapSrc->GetAt(PIPE_PRESSURE, dVal);
	pXDataMap->SetAt(PIPE_PRESSURE, dVal);

	pXDataMapSrc->GetAt(PIPE_MATERIALFT,sVal);
	pXDataMap->SetAt(PIPE_MATERIALFT,sVal);

	nDir = 0;
	pXDataMapSrc->GetAt(PIPE_ELBOWFLG,nDir);
	pXDataMap->SetAt(PIPE_ELBOWFLG,nDir);

	nDir = 0;
	pXDataMapSrc->GetAt(PIPE_BWELDDOT,nDir);
	pXDataMap->SetAt(PIPE_BWELDDOT,nDir);

	dVal = 1.0;
	pXDataMapSrc->GetAt(DOC_PLOTWIDTH,dVal);
	pXDataMap->SetAt(DOC_PLOTWIDTH,dVal);

	dVal = 1.0;
	pXDataMapSrc->GetAt(DOC_WELDDIA,dVal);
	pXDataMap->SetAt(DOC_WELDDIA,dVal);

	pXDataMapSrc->GetAt(PIPE_ZONE,sVal);
	pXDataMap->SetAt(PIPE_ZONE,sVal);

	dVal = 1.0;
	pXDataMapSrc->GetAt(PIPE_INSTHICK,dVal);
	pXDataMap->SetAt(PIPE_INSTHICK,dVal);

	pXDataMapSrc->GetAt(PIPE_NO,sVal);
	pXDataMap->SetAt(PIPE_NO,sVal);

	pXDataMapSrc->GetAt(DOC_INSMATER,sVal);
	pXDataMap->SetAt(DOC_INSMATER,sVal);

	pXDataMapSrc->GetAt(PIPE_DESCR,sVal);
	pXDataMap->SetAt(PIPE_DESCR,sVal);

	pXDataMapSrc->GetAt(PIPE_SYS,sVal);
	pXDataMap->SetAt(PIPE_SYS,sVal);

	pXDataMapSrc->GetAt(PIPE_PIDD,dVal);
	pXDataMap->SetAt(PIPE_PIDD,dVal);

	nDir = 0;
	pXDataMapSrc->GetAt(PIPE_CONNECT,nDir);
	pXDataMap->SetAt(PIPE_CONNECT,nDir);

	dVal = 0.0;
	pXDataMapSrc->GetAt(PIPE_INTERFACED,dVal);
	pXDataMap->SetAt(PIPE_INTERFACED,dVal);

	dVal = 0.0;
	pXDataMapSrc->GetAt(PIPE_INTERFACEL,dVal);
	pXDataMap->SetAt(PIPE_INTERFACEL,dVal);

	dVal = 0.0;
	pXDataMapSrc->GetAt(PIPE_INTERFACED2,dVal);
	pXDataMap->SetAt(PIPE_INTERFACED2,dVal);

	dVal = 0.0;
	pXDataMapSrc->GetAt(PIPE_INTERFACEL2,dVal);
	pXDataMap->SetAt(PIPE_INTERFACEL2,dVal);

	dVal = 0.0;
	pXDataMapSrc->GetAt(PIPE_INTERFACEL3,dVal);
	pXDataMap->SetAt(PIPE_INTERFACEL3,dVal);

	nDir = (int)WPipe::eNoneApp;
	pXDataMapSrc->GetAt(PIPE_EAPP, nDir);
	pXDataMap->SetAt(PIPE_EAPP, nDir);
	
	if ((WPipe::EApp)nDir == WPipe::eDuct || 
		(WPipe::EApp)nDir == WPipe::eBridge)
	{
		dVal = 0.0;
		pXDataMapSrc->GetAt(DUCT_W, dVal);
		pXDataMap->SetAt(DUCT_W, dVal);

		dVal = 0.0;
		pXDataMapSrc->GetAt(DUCT_H, dVal);
		pXDataMap->SetAt(DUCT_H, dVal);

		dVal = 0.0;
		pXDataMapSrc->GetAt(DUCT_THICK, dVal);
		pXDataMap->SetAt(DUCT_THICK, dVal);
	}

	FillInInitXDataMap(pXDataMap);
}

void TDbPipeLine::FillInInitXDataMap(AecDbObjXDataMap* pXDataMap)
{
	double dScale = 1.0;
	CString sScale;
	m_xInitDataMap.GetAt(DOC_SCALE, sScale);		//出图比例
	int nPos = sScale.Find(_T(':'));
	if (nPos != -1)
	{
		dScale = _ttof(sScale.Mid(nPos + 1));
	}

	//行业
	int nTrade = 0;
	m_xInitDataMap.GetAt(DOC_TRADE, nTrade);		//行业
	pXDataMap->SetAt(DOC_TRADE,nTrade);

	//项目
	CString sPro = _T("工业");;
	m_xInitDataMap.GetAt(DOC_PROJECT, sPro);
	pXDataMap->SetAt(DOC_PROJECT, sPro);

	double dMinDia = 0.0;//最小单线管道直径，弯头扣完使用
	m_xInitDataMap.GetAt(DOC_PIPEMINDIA,dMinDia);//最小单线管道直径

	double dMaxDia = 0.0;
	m_xInitDataMap.GetAt(DOC_PIPEMAXDIA,dMaxDia);//最小双线

	double d90ElbowDN = 60.0;
	m_xInitDataMap.GetAt(DOC_PERELBOWDIA,d90ElbowDN);//垂直弯头直径

	double dMaxDiaDrawScale = 1.5;
	m_xInitDataMap.GetAt(DOC_PIPEMAXDIASCALE,dMaxDiaDrawScale);			//最大管线直径

	BOOL bMaxDiaScale;
	m_xInitDataMap.GetAt(DOC_PIPEMAXDIASYES,bMaxDiaScale);//是否最大管线直径

	double dMinSW = 0.5;
	m_xInitDataMap.GetAt(DOC_PLOTWIDTH,dMinSW);	//单线线宽
						 
	double dOutSW = 0.0;
	m_xInitDataMap.GetAt(DOC_DPLOTWIDTH,dOutSW);//外双线线宽

	double dWD = 0.5;
	m_xInitDataMap.GetAt(DOC_WELDDIA, dWD);		//焊点直径

	//如果是米单位
	struct resbuf rb;
	acedGetVar(_T("INSUNITS"), &rb);
	if (rb.resval.rint == AcDb::kUnitsMeters)
	{
		dMinSW *= 0.001;
		dOutSW *= 0.001;
		dWD *= 0.001;
		dMinDia *= 0.001;
		dMaxDia *= 0.001;
	}

	pXDataMap->SetAt(KEY_SINGLEW,dScale * dMinSW);
	pXDataMap->SetAt(KEY_DBLINEW,dScale * dOutSW);
	pXDataMap->SetAt(DOC_WELDDIA,dScale * dWD);
	pXDataMap->SetAt(DOC_PIPEMINDIA,dMinDia);
	pXDataMap->SetAt(DOC_PIPEMAXDIA,dMaxDia);
	pXDataMap->SetAt(DOC_PIPEMAXDIASCALE,dMaxDiaDrawScale);
	pXDataMap->SetAt(DOC_PIPEMAXDIASYES,bMaxDiaScale);
	pXDataMap->SetAt(DOC_PERELBOWDIA,d90ElbowDN);//垂直弯头直径
}

void TDbPipeLine::XDataMapToPipeParam(const AecDbObjXDataMap* pXDataMapSrc,WPipe::PipeParam* pParamL)
{
	TDbPipeSupport::XData2PipeParam(pParamL,pXDataMapSrc);
}

void TDbPipeLine::PipeParamToXDataMap(const WPipe::PipeParam* pParamL,AecDbObjXDataMap* pXDataMapSrc)
{
	if (pParamL == NULL || pXDataMapSrc == NULL)
		return;
	//D
	pXDataMapSrc->SetAt(PIPE_D,pParamL->m_dD);

	//eD
	pXDataMapSrc->SetAt(PIPE_DRAWDIR,(int)pParamL->m_eD);

	//DN
	pXDataMapSrc->SetAt(PIPE_DN,pParamL->m_dDN);

	//OD
	pXDataMapSrc->SetAt(PIPE_OD,pParamL->m_dOD);

	//Thick
	pXDataMapSrc->SetAt(PIPE_THICK,pParamL->m_dThick);

	//补充风管壁厚
	pXDataMapSrc->SetAt(DUCT_THICK, pParamL->m_dThick);

	//EL
	//pXDataMapSrc->SetAt(PIPE_EL, pParamL->m_dEl);

	//Ratio
	pXDataMapSrc->SetAt(PIPE_RATIO,pParamL->m_dRRatio);

	//dW
	pXDataMapSrc->SetAt(DUCT_W, pParamL->m_dW);

	//dH
	pXDataMapSrc->SetAt(DUCT_H, pParamL->m_dH);

	//app
	pXDataMapSrc->SetAt(PIPE_EAPP, (int)pParamL->m_app);

	//nConnectType
	pXDataMapSrc->SetAt(PIPE_CONNECT,pParamL->m_nConnectType);

	//dInterfaceL
	pXDataMapSrc->SetAt(PIPE_INTERFACEL,pParamL->m_dInterfaceL);

	//dInterfaceD
	pXDataMapSrc->SetAt(PIPE_INTERFACED,pParamL->m_dInterfaceD);

	//dInterfaceD2
	pXDataMapSrc->SetAt(PIPE_INTERFACED2,pParamL->m_dInterfaceD2);

	//dInterfaceL2
	pXDataMapSrc->SetAt(PIPE_INTERFACEL2,pParamL->m_dInterfaceL2);

	pXDataMapSrc->SetAt(PIPE_FLANGF, pParamL->m_szEndF);
	pXDataMapSrc->SetAt(PIPE_GASKET, pParamL->m_szGastInf);

	//dInsThk
	pXDataMapSrc->SetAt(PIPE_INSTHICK,pParamL->m_dInsThk);

	//dInterfaceL3
	pXDataMapSrc->SetAt(PIPE_INTERFACEL3,pParamL->m_dInterfaceL3);

	//m_eRed
	//m_vtECCen
	//m_vtDir
	//m_eElBase

	//szPipeno
	pXDataMapSrc->SetAt(PIPE_NO,pParamL->szPipeno);

	//szMertial
	pXDataMapSrc->SetAt(PIPE_MATERIAL,pParamL->szMertial);

	//szMertialFit
	pXDataMapSrc->SetAt(PIPE_MATERIALFT,pParamL->szMertialFit);

	//szZoneNo
	pXDataMapSrc->SetAt(PIPE_ZONE,pParamL->szZoneNo);

	pXDataMapSrc->SetAt(KEY_NO, pParamL->szNo);

	//szInsMtr
	pXDataMapSrc->SetAt(DOC_INSMATER,pParamL->szInsMtr);

	//szDescr
	pXDataMapSrc->SetAt(PIPE_DESCR,pParamL->szDescr);

	//szSys
	pXDataMapSrc->SetAt(PIPE_SYS,pParamL->szSys);

	//m_nGroupID
	//?

	//LEVEL
	pXDataMapSrc->SetAt(PIPE_LEVEL,pParamL->szLevel);
	pXDataMapSrc->SetAt(PID_PIPE_DPRESS,pParamL->m_dPress);

	//szZone
	pXDataMapSrc->SetAt(PIPE_ZONE,pParamL->szZone);

	//szMedia
	pXDataMapSrc->SetAt(PIPE_MEDIA,pParamL->szMedia);

	//szNo
	pXDataMapSrc->SetAt(PIPE_NO,pParamL->szNo);

	//Spec
	pXDataMapSrc->SetAt(PIPE_SPEC,pParamL->szSpec);

	//LineNo
	pXDataMapSrc->SetAt(PIPE_LINENO,pParamL->szLineNo);

	//szInsTag
	pXDataMapSrc->SetAt(PIPE_INSTAG,pParamL->szInsTag);

	//szInsDim
	pXDataMapSrc->SetAt(DOC_INSDIM,pParamL->szInsDim);

	//szInsMateral
	pXDataMapSrc->SetAt(DOC_INSMATER,pParamL->szInsMateral);

	//szInsSpec
	pXDataMapSrc->SetAt(DOC_INSSPEC,pParamL->szInsSpec);

	//DOC_TRAMTOINF
	pXDataMapSrc->SetAt(DOC_TRAMTOINF,pParamL->szTraMtoInfo);

	//szTraDescr
	pXDataMapSrc->SetAt(DOC_TRADESCR,pParamL->szTraDescr);

	//szFitType
	pXDataMapSrc->SetAt(PIPE_FITTYPE,pParamL->szFitType);

	pXDataMapSrc->SetAt(PIPE_MTOALL,pParamL->szMtoInfo);
}

BOOL TDbPipeLine::MaybeAddTeeConnectToThis(AcGePoint3d& ptGe,AcGeVector3d& vtDir,AcDbObjectId id,int nPos)
{
	//以ptGe的,以管子公称直径为搜索
	ads_point pt[5];
	vtDir.normalize();
	AcGeVector3d vtV = vtDir;
	vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

	AcGePoint3d ptGeT = ptGe;
	ptGeT = ptGe + m_pPipeParam->m_dDN * 0.5 * vtDir;
	ptGeT += m_pPipeParam->m_dDN * 0.5 * vtV;

	AcGePoint3d ptGeX[5];
	ptGeX[0] = ptGeT;
	ptGeX[1] = ptGeX[0] - m_pPipeParam->m_dDN * vtDir;
	ptGeX[2] = ptGeX[1] - m_pPipeParam->m_dDN * vtV;
	ptGeX[3] = ptGeX[0] - m_pPipeParam->m_dDN * vtV;
	ptGeX[4] = ptGeX[0];
	for (int i = 0;i < 5;i++)
	{
		acdbWcs2Ucs(asDblArray(ptGeX[i]),pt[i],false);
	}

	TCHAR szBuf[64];
	memset(szBuf,0,sizeof(szBuf));
	_tcscpy(szBuf, _T("AEC_EWPIPE"));

	struct resbuf rb;
	rb.restype = 0;
	rb.resval.rstring = szBuf;
	rb.rbnext = NULL; 

	struct resbuf* pointlist; 
	pointlist = acutBuildList(RTPOINT, pt[0], RTPOINT, pt[1], 
							  RTPOINT, pt[2], RTPOINT, pt[3], 0); 

	ads_name ss,ent;
	acedSSGet(_T("CP"),pointlist,NULL,&rb,ss);
	acutRelRb(pointlist);

	Adesk::Int32 lLen = 0;
	acedSSLength(ss,&lLen);

	double dTemp = 0.0;
	CString sSQL,sTemp;
	AcDbObjectId idT;
	AcDbEntity* pEnt = NULL;
	AcGeVector3d vtPipe;
	AcGePoint3d ptMid,ptTemp1,ptTemp2;

	BOOL bModified = FALSE;
	for (long i = 0;i < lLen;i++)
	{
		acedSSName(ss,i,ent);
		acdbGetObjectId(idT,ent);

#ifdef ZWCAD
		if (id == idT) continue;
#endif

		if (Acad::eOk == acdbOpenAcDbEntity(pEnt,idT,AcDb::kForWrite))
		{
			AecDbEwPipe* pWPipe = AecDbEwPipe::cast(pEnt);
			if (pWPipe != NULL)
			{
				vtPipe = pWPipe->EndPoint() - pWPipe->StartPoint();
				vtPipe.normalize();
				if (!vtPipe.isParallelTo(vtDir))
				{
					//且两管子中心线能相交
					AcGeLine3d ln1(pWPipe->EndPoint(),vtPipe);
					AcGeLine3d ln2(ptGe,vtDir);

					double dDn = m_pPipeParam->m_dDN;
					pWPipe->GetSpecialtyData()->GetAt(PIPE_DN,dDn);

					if (ln1.intersectWith(ln2,ptMid))
					{
						double dL = 0.0,dS = 0.0;
						if ( TDbPipeSupport::QueryTeeData(m_pPipeJig->GetAdoDb(),dDn,m_pPipeParam->m_dDN,dL,dS) )
						{
							double dInterfaceL = 0.0;
							pWPipe->GetSpecialtyData()->GetAt(PIPE_INTERFACEL,dInterfaceL);
							if (dInterfaceL > 1.e-3)//法兰管
							{
								dL += dInterfaceL;
								dS += dInterfaceL;
							}

							if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)//法兰连接
							{
								//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
								double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
								TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(),m_pPipeParam->m_dDN,m_pPipeParam->m_dPress,dWD,dWh,dThk,dN);

								dL -= dInterfaceL;
								dS -= dInterfaceL;

								//颈法兰焊接方式
								CString sDNo = m_pPipeParam->szODSn;
								if (sDNo.CompareNoCase(_T("S")) != 0 &&
									sDNo.CompareNoCase(_T("GSF")) != 0)
								{
									dL += dWh;
									dS += dWh;
								}

							}

							//也可能加弯头,ptMid的两头有一在管子外
							ptTemp1 = ptMid + vtPipe * dL;
							ptTemp2 = ptMid - vtPipe * dL;

							AcGeLineSeg3d lineGe(pWPipe->StartPoint(),pWPipe->EndPoint());
							BOOL bAddTee = TRUE;
							if ( !lineGe.isOn(ptTemp1) || !lineGe.isOn(ptTemp2) )
							{
								if ( fabs(dDn - m_pPipeParam->m_dDN) < 1.e-3) //==DN
								{
									pEnt->close();
									bAddTee = FALSE;
									if ( AddElbow(idT,ptMid,id))
									{
										bModified = TRUE;
									}
									return bModified;
								}
								else// 只能加三通
								{
									bAddTee = TRUE;
								}
							}
							
							if (bAddTee)
							{
								//可能 焊接方式,加补强圈!!!，半管接头
								CString sLevel;
								pWPipe->GetAt(PIPE_LEVEL,sLevel);
								int nTStyle = TDbPipeSupport::QueryRPorHP(m_pPipeJig->GetAdoDb(), sLevel, dDn, m_pPipeParam->m_dDN);

								if (nTStyle <= 1)//0,1 RT T
								{
									//对方断为两个管子
									SplitWPipe(ptMid,dL,pWPipe);

									if (nPos == 1)
										vtDir.negate();

									//改变this管子的位置
									ptGe = ptMid + dS * vtDir;
									ModifyWPipe(ptGe,id,nPos);

									//添加三通,继承pWPipe属性
									AddTee(pWPipe,id,dL,ptMid,dS,vtDir);
								}
								else//焊接方式,加补强圈
								{
									TDbPipeLine::AddRPorHP(pWPipe,id,ptMid);
								}
							}
							bModified = TRUE;
						}
						else
						{
							//焊接方式,加补强圈,或半管接头
							TDbPipeLine::AddRPorHP(pWPipe,id,ptMid);
						}
						acedSSFree(ss);
						pEnt->close();
						return bModified;
					}
				}
				else //平行,是否可以融合
				{
					//规格相同, 且不是从夹点拖出的命令
					if (m_idStartDragFrom != id)
					{
						double dDn = 0.0;
						pWPipe->GetSpecialtyData()->GetAt(PIPE_DN,dDn);

						if (fabs(dDn - m_pPipeParam->m_dDN) < 1.e-3)//公称相同
						{
							if ( fabs(pWPipe->EndPoint().z - m_pPipeParam->m_dEl) < 1.e-3)//等标高
							{
								AcGePoint3d ptEnd = pWPipe->EndPoint();
								AcGePoint3d ptSta = pWPipe->StartPoint();
								if (!vtPipe.isCodirectionalTo(vtDir))
								{
									AcGePoint3d ptTemp = ptSta;
									ptSta = ptEnd;
									ptEnd = ptTemp;
								}

								//删除原来的管子
								pEnt->erase();

								//改变this管子的位置
								ModifyWPipe( nPos == 0 ? ptSta : ptEnd,id,nPos);

								bModified = TRUE;
							}
						}
					}
				}
			}
			pEnt->close();
		}
	}
	acedSSFree(ss);
	return bModified;
}

typedef struct Point_ID
{
	AcDbObjectId id;
	AcGePoint3d  ptInt;
	int			 nAddTeeOrCross;//0  Cross 1 Tee
	AcDbCurve*   pCurve;
}POINT_ID;

static bool ComparePointID(Point_ID& pt1,Point_ID& pt2)
{
	double dP1 = 0.0,dP2 = 0.0;
	pt1.pCurve->getParamAtPoint(pt1.ptInt,dP1);
	pt1.pCurve->getParamAtPoint(pt2.ptInt,dP2);

	if (dP1 - dP2 < 1.e-6)
	{
		return true;//up sort
	}
	return false;//down sort
}

static double GetPipeDoubleLineMaxD()
{
	AecDbObjXDataMap xDataMap;
	CString sDia(_T(""));
	double dMaD(.0);

	if (KTModelLayoutXData::ReadModelXData(EW_EARTHWORMINIT, xDataMap))
	{
		dMaD = 500;
		if (xDataMap.GetAt(DOC_PIPEMAXDIA, sDia))
			dMaD = _ttof(sDia);
		return AS_MUNIT(dMaD);
	}
	else if (KTModelLayoutXData::ReadModelXData(KT_PIPEINIT, xDataMap))
	{
		dMaD = 200.;
		xDataMap.GetAt(DOC_PIPEMAXDIA, dMaD);
		return dMaD;
	}
	return 100.;
}

BOOL TDbPipeLine::MaybeAddCrossConnectToThis(AcGePoint3d ptFr,AcGePoint3d ptTo,AcDbObjectId id)
{
	AcDbObjectId idLay1,idLay2;
	AcDbEntity* pEnt1 = NULL;
	if (Acad::eOk == acdbOpenAcDbEntity(pEnt1,id,AcDb::kForRead))
	{
		idLay1 = pEnt1->layerId();
		pEnt1->close();
	}
	else
	{
		return FALSE;
	}

	//等标高的情况下
	if (fabs(ptFr.z - ptTo.z) > 1.0)
	{
		return FALSE;
	}

	//id 的范围内选择实体,只考虑XY 面,其他三维单加四通
	AcGePoint3d ptGe[4];
	AcGeVector3d vtDir = ptTo - ptFr;
	AcGeVector3d vtV = vtDir;
	vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
	vtV.normalize();
	vtDir.normalize();

	//选择范围缩小, 至少长度超过四通的长度
	ptFr += m_pPipeParam->m_dD * 2.0 * vtDir;
	ptTo -= m_pPipeParam->m_dD * 2.0 * vtDir;

	ptGe[0] = ptFr;
	ptGe[0] += vtV * m_pPipeParam->m_dD * 0.8;
	ptGe[1] = ptTo;
	ptGe[1] += vtV * m_pPipeParam->m_dD * 0.8;
	ptGe[2] = ptGe[1] - vtV * 1.6 * m_pPipeParam->m_dD;
	ptGe[3] = ptGe[0] - vtV * 1.6 * m_pPipeParam->m_dD;

	ads_point pt[4];
	for (int i = 0;i < 4;i++)
	{
		acdbWcs2Ucs(asDblArray(ptGe[i]),pt[i],false);
	}

	TCHAR szBuf[64];
	memset(szBuf,0,sizeof(szBuf));
	_tcscpy(szBuf, _T("AEC_EWPIPE"));

	struct resbuf rb;
	rb.restype = 0;
	rb.resval.rstring = szBuf;
	rb.rbnext = NULL; 

	struct resbuf* pointlist = NULL; 
	pointlist = acutBuildList(RTPOINT, pt[0], RTPOINT, pt[1], 
							  RTPOINT, pt[2], RTPOINT, pt[3], 0); 

	ads_name ss,ent;
	acedSSGet(_T("CP"),pointlist,NULL,&rb,ss);
	acutRelRb(pointlist);

	Adesk::Int32 lLen = 0;
	acedSSLength(ss,&lLen);

	AcDbObjectId idT;
	AcDbEntity* pEnt = NULL;
	AcGeVector3d vtDir2;

	AcDbLine line;
	line.setStartPoint(ptFr);
	line.setEndPoint(ptTo);

	AcGeLineSeg3d line1;
	line1.set(ptFr,ptTo);

	AcGeLineSeg3d line2;
	double dDN = 0.0;
	int nStyleOther = 1;
	int nStyleThis = 1;
	std::vector<Point_ID> vtPtids;

	//交叉短线间距
	double dOffFrSta = 0,dBreakSpace = 0,dBrkSpBk = 0;
	m_xInitDataMap.GetAt(DOC_BREAKSPACE,dBreakSpace);
	double dScale = 1.0;
	CString sScale;
	m_xInitDataMap.GetAt(DOC_SCALE, sScale);		//出图比例
	int nPos = sScale.Find(_T(':'));
	if (nPos != -1)
	{
		dScale = _ttof(sScale.Mid(nPos + 1));
	}
	dBreakSpace *= dScale;
	dBrkSpBk = dBreakSpace;

	double dM = 0.0,dB = 0.0;
	for ( i = 0;i < lLen;i++)
	{
		acedSSName(ss,i,ent);
		acdbGetObjectId(idT,ent);

		if (Acad::eOk == acdbOpenAcDbEntity(pEnt,idT,AcDb::kForRead))
		{
			idLay2 = pEnt->layerId();
			if (idLay1 != idLay2)
			{
				pEnt->close();
				continue;
			}

			AecDbEwPipe* pWPipe = AecDbEwPipe::cast(pEnt);
			if (pWPipe != NULL)
			{
				pWPipe->GetSpecialtyData(AcDb::kForRead)->GetAt(PIPE_DN,dDN);

				//判断标高是否一致,方向是否垂直,且 公称直径一致??
				if ( fabs(pWPipe->EndPoint().z - ptTo.z) < 1.e-6 &&
					 fabs(m_pPipeParam->m_dDN - dDN) < 1.e-6)
				{
					vtDir2 = pWPipe->EndPoint() - pWPipe->StartPoint();
					if (vtDir2.isPerpendicularTo(vtDir))
					{
						line2.set(pWPipe->StartPoint(),pWPipe->EndPoint());
						Point_ID ptid;
						ptid.nAddTeeOrCross = 0;
						ptid.id = idT;
						ptid.pCurve = &line;

						if ( line1.intersectWith(line2,ptid.ptInt))
						{
							if (dM < 1.e-6)
							{
								//四通的主支 DN 相同
								if ( !TDbPipeSupport::QueryCrossData(m_pPipeJig->GetAdoDb(),m_pPipeParam->m_dDN,m_pPipeParam->m_dDN,dM,dB) )
								{
									pEnt->close();
									return FALSE;
								}

								if (m_pPipeParam->m_dInterfaceL > 1.e-3)//法兰管
								{
									dM += m_pPipeParam->m_dInterfaceL;
									dB += m_pPipeParam->m_dInterfaceL;
								}
							}

							//判断交点和本线的距离
							double dL1 = ptid.ptInt.distanceTo(pWPipe->StartPoint());
							double dL2 = ptid.ptInt.distanceTo(pWPipe->EndPoint());

							ptid.nAddTeeOrCross = 0;
							if (dL1 < dM || dL2 < dM)
							{
								//加三通的可能
								ptid.nAddTeeOrCross = 1;
							}
							vtPtids.push_back(ptid);
						}
					}
				}
				else
				{
					//否则单线管线添加遮挡
					if ( (pWPipe->EndPoint().z - ptTo.z) < -1.e-1)//对方标高小于本次标高
					{
						nStyleThis = 1;
						nStyleOther = 1;
						if (dDN - GetPipeDoubleLineMaxD() > 1.e-3)
						{
							nStyleOther = 2;
						}
						
						if (nStyleOther == 2)
						{
							dBreakSpace = dBrkSpBk + m_pPipeParam->m_dD;
						}
						
						AcDbLine ln2(pWPipe->StartPoint(),pWPipe->EndPoint());
						AcDbLine ln1(ptFr,ptTo);

						AcGePoint3dArray arIntPtrs;
						ln1.intersectWith(&ln2,AcDb::kOnBothOperands,AcGePlane::kXYPlane,arIntPtrs);

						//交点位置加遮挡打断符号
						if ( !arIntPtrs.isEmpty() )
						{
							pEnt->upgradeOpen();

							pWPipe->getClosestPointTo(arIntPtrs.first(),ptGe[0],Adesk::kFalse);
							dOffFrSta = ptGe[0].distanceTo(pWPipe->StartPoint());
							dOffFrSta -= 0.5 * dBreakSpace;//取中位置

							//真实距离负数为遮挡
							pWPipe->AddBrokenOpen(dOffFrSta,dBreakSpace,-m_pPipeParam->m_dD);

							pEnt->downgradeOpen();
						}
					}
				}
			}
			pEnt->close();
		}
	}

	//排序
	if (!vtPtids.empty())
	{
		std::sort(vtPtids.begin(),vtPtids.end(),ComparePointID);

		typedef std::vector<Point_ID>::iterator PIDIT;
		for (PIDIT it = vtPtids.begin();it != vtPtids.end();it++)
		{
			if ( (*it).nAddTeeOrCross == 0 )
			{
				AddCross( (*it).id,(*it).ptInt,id);
			}
			else
			{
				AddTee((*it).id,(*it).ptInt,id);
			}
		}
	}
	acedSSFree(ss);
	return FALSE;
}

BOOL TDbPipeLine::SplitWPipe(AcGePoint3d& ptMid,double dL,AecDbEwPipe* pWPipe,BOOL bEraseWhiletooShort)
{
	AcGePoint3d ptSta = pWPipe->StartPoint();
	AcGePoint3d ptEnd = pWPipe->EndPoint();
	AcGeVector3d vtDir = ptEnd - ptSta;
	vtDir.normalize();

	AecDbObjXDataMap* pXDataMapt = pWPipe->GetSpecialtyData();

	AcDbObjectId idCenLay,idOutLay,idSingle;
	pXDataMapt->GetAt(PIPE_CENTLAY,idCenLay);
	pXDataMapt->GetAt(PIPE_OUTDLAY,idOutLay);
	pXDataMapt->GetAt(PIPE_SINGLAY,idSingle);
	double dd;
	pXDataMapt->GetAt(PIPE_D, dd);

	AcGePoint3d ptTemp = ptMid - dL * vtDir;
	AcGeVector3d vtDir1 = ptTemp - ptSta;
	if (vtDir.isCodirectionalTo(vtDir1)) //同向,说明放得下L的 Tee
	{
		//新建管子
		//放得下L的 Tee 的情况,新建vtDir 方向的end端
		AecDbEwPipe* pWPipe1 = new AecDbEwPipe;
		AecDbObjXDataMap* pXDataMap = pWPipe1->GetSpecialtyData();
		FillConfigXDataMap(pXDataMap,pWPipe);
		//pWPipe1->RemoveBrokenOpen(-1);
		
		double dDn(.0), dThick(.0),dD(0.0);
		pXDataMap->GetAt(PIPE_TDN, dDn);
		pXDataMap->GetAt(PIPE_D,dD);
		pXDataMap->GetAt(PIPE_THICK, dThick);

		int app;
		pXDataMap->GetAt(PIPE_EAPP, app);
		if ((WPipe::EApp)app == WPipe::eDuct || (WPipe::EApp)app == WPipe::eBridge)
		{
			double dW(.0), dH(.0), dT(.0);
			pXDataMap->GetAt(DUCT_W, dW);
			pXDataMap->GetAt(DUCT_H, dH);
			pXDataMap->GetAt(DUCT_THICK, dT);
			pWPipe1->SetSection(dW, dH, dT);
		}
		else
		{
			if (dD < 1e-6)
			{
				int ed;
				dD = dDn;
				pXDataMapt->GetAt(PIPE_DRAWDIR, ed);
				if (ed == WPipe::eDN)
					pXDataMapt->GetAt(PIPE_DN, dD);
				else if (ed == WPipe::eOD)
					pXDataMapt->GetAt(PIPE_OD, dD);
				else
					pXDataMapt->GetAt(PIPE_DN, dD);
				pXDataMap->SetAt(PIPE_D, dD);
			}
			pWPipe1->SetSection(dD, dThick);
		}

		ptTemp = ptMid - dL * vtDir;
		pWPipe1->SetStartPoint(ptSta);
		pWPipe1->SetEndPoint(ptTemp);
		pWPipe1->setLayer(pWPipe->layerId());

		pXDataMap->SetAt(PIPE_CENTLAY,idCenLay);
		pXDataMap->SetAt(PIPE_OUTDLAY,idOutLay);
		pXDataMap->SetAt(PIPE_SINGLAY,idSingle);

		pWPipe1->SetDoubleLayer(pWPipe->GetDoubleLayer());
		pWPipe1->SetDoubleLineType(pWPipe->GetDoubleLineType());
		pWPipe1->SetSingleLayer(pWPipe->GetSingleLayer());
		pWPipe1->SetSingleLineType(pWPipe->GetSingleLineType());
		pWPipe1->SetDashLayer(pWPipe->GetDashLayer());
		pWPipe1->SetCenterLayer(pWPipe->GetCenterLayer());
		pWPipe1->setLayer(idOutLay);

		//套管,洞口
		//移除内部关联的套管，如果位置在其中
		RemoveHolePipe(pWPipe1);

		setInfo2Ent(*pXDataMap);
		AcDbObjectId id = AddPipeToModelSpace(pWPipe1);
		AddUserData(id,pXDataMap,0);

		//改变现有的管子的起点
		ptTemp = ptMid + dL * vtDir;
		pWPipe->SetStartPoint(ptTemp);

		//套管,洞口
		//移除内部关联的套管，如果位置在其中
		RemoveHolePipe(pWPipe);

		//删除断管符号
		//pWPipe->RemoveBrokenOpen(-1);

		return TRUE;
	}
	else //放不下，直接更改 start 或 end 腾出L位置
	{
		double dDis1 = ptMid.distanceTo(ptSta);
		double dDis2 = ptMid.distanceTo(ptEnd);

		if (dDis1 < dDis2 )//靠近sta
		{
			ptTemp = ptMid + dL * vtDir;
			vtDir1 = ptEnd - ptTemp;
			if (vtDir1.isCodirectionalTo(vtDir))
			{
				pWPipe->SetStartPoint(ptTemp);
				return TRUE;
			}
		}
		else//靠近 end
		{
			ptTemp = ptMid - dL * vtDir;
			vtDir1 = ptTemp - ptSta;
			if (vtDir1.isCodirectionalTo(vtDir))
			{
				pWPipe->SetEndPoint(ptTemp);
				return TRUE;
			}
		}

		//套管,洞口
		//移除内部关联的套管，如果位置在其中
		RemoveHolePipe(pWPipe);

		//删除断管符号
		//pWPipe->RemoveBrokenOpen(-1);
	}
	return FALSE;
}

void TDbPipeLine::RemoveHolePipe(AecDbEwPipe* pWPipe)
{
	AcGePoint3d ptS = pWPipe->StartPoint();
	AcGePoint3d ptE = pWPipe->EndPoint();
	AcGePoint3d ptOn;
	AcGeVector3d vt1,vt2;

	AecDbObjXDataMap* pXDatMap = pWPipe->GetSpecialtyData();
	if (pXDatMap == NULL)
		return;

	//关联的洞口和套管联动
	AecDbObjXDataMap::It it = pXDatMap->Begin();
	AecDbObjXDataMap::It end = pXDatMap->End();

	CString sKey;
	AecXData cVal;
	memset(&cVal,0,sizeof(AecXData));

	CStringArray arKeysRemove;
	AcDbObjectId idSrc,idCloned;
	for (; it != end;)
	{
		if (!pXDatMap->GetNext(it, sKey, cVal)) break;
		if (sKey.Find(_T("$H")) != -1 && cVal.nVt == VT_BSTR)//可能的实体句柄
		{
			AcDbHandle handle(cVal.pszVal);

			AcDbObjectId idHole;
			acdbCurDwg()->getAcDbObjectId(idHole,false,handle);

			AcDbEntity* pEnt = NULL;
			if (Acad::eOk == acdbOpenAcDbEntity(pEnt,idHole,AcDb::kForRead))
			{
				AecDbX3dPartEntity* pX3dPartEnt = AecDbX3dPartEntity::cast(pEnt);
				if (pX3dPartEnt != NULL)
				{
					ptOn = pX3dPartEnt->GetOrgPoint(true);

					vt1 = ptOn - ptS;
					vt2 = ptOn - ptE;

					//TEST
					//AcDbCircle* pCir = new AcDbCircle;
					//pCir->setCenter(ptOn);
					//pCir->setRadius(100.0);
					//AddFitToModelSpace(pCir);

					if (vt1.dotProduct(vt2) > 1.e-10)//同向
					{
					}
					else
					{
						arKeysRemove.Add(sKey);
					}
				}

				pEnt->close();
			}
		}
	}

	for (int i = 0;i < arKeysRemove.GetSize();i++)
	{
		pXDatMap->RemoveAt(arKeysRemove.GetAt(i));
		//acutPrintf(_T("\nRemove key %s"),arKeysRemove.GetAt(i));
	}
}

BOOL TDbPipeLine::ModifyWPipe(AcGePoint3d& ptGe,AcDbObjectId id,int nPos)
{
	AcDbEntity* pEnt = NULL;
	if (Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite))
	{
		AecDbEwPipe* pWPipe = AecDbEwPipe::cast(pEnt);
		if (pWPipe != NULL)
		{
			if (nPos == 0)
			{
				AcGePoint3d ptGeT;
				ptGeT = pWPipe->StartPoint();
				pWPipe->SetStartPoint(ptGe);
			}

			if (nPos == 1)
			{
				AcGePoint3d ptGeT;
				ptGeT = pWPipe->EndPoint();
				pWPipe->SetEndPoint(ptGe);
			}
		}
		pEnt->close();
	}
	return TRUE;
}

BOOL TDbPipeLine::ModifyWPipe(AcGePoint3d& ptGe,AecDbEwPipe* pWPipe,int nPos)
{
	if (pWPipe != NULL)
	{
		if (nPos == 0)
		{
			AcGePoint3d ptGeT;
			ptGeT = pWPipe->StartPoint();
			pWPipe->SetStartPoint(ptGe);
		}

		if (nPos == 1)
		{
			AcGePoint3d ptGeT;
			ptGeT = pWPipe->EndPoint();
			pWPipe->SetEndPoint(ptGe);
		}
		return TRUE;
	}
	return FALSE;
}

BOOL TDbPipeLine::AddTee(AecDbEwPipe *pWPipe, double dL, AcGePoint3d ptMid, double dB, AcGeVector3d vtMin, WPipe::PipeParam* pParmMain)
{
	if (pParmMain == NULL)
		return AddTee(pWPipe, dL, ptMid, dB, vtMin);

	AecDbEwFitting *pFitting = new AecDbEwFitting;
	AecDbObjXDataMap *pXDataMap = pFitting->GetSpecialtyData();
	FillConfigXDataMap(pXDataMap, m_pPipeParam);

	pXDataMap->SetAt(PIPE_CONNECT, m_pPipeParam->m_nConnectType);
	AecDbObjXDataMap *pXDataMapmaj = pWPipe->GetSpecialtyData();

	//查询设置项目等级
	if (!QuerySetProjectLevel(pXDataMap, m_pPipeParam, _T("三通")))
		return FALSE;

	CString sODNo = m_pPipeParam->szODSn;
	IsPlasticsMat(m_pPipeParam, sODNo);

	if (m_pPipeParam->m_nConnectType > 0)
	{
		double dFD = 0.0, dFL = 0.0;
		double dWD = 0.0, dWh = 0.0, dThk = 0.0, dN = 0.0;
		TDbPipeSupport::QueryInfFDFL(m_pPipeJig->GetAdoDb(), eTee, m_pPipeParam->m_nConnectType, m_pPipeParam->m_dDN, dFD, dFL);

		pXDataMap->SetAt(PIPE_INTERFACED2, dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL2, dFL);
		pXDataMap->SetAt(PIPE_INTERFACED, dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL, dFL);

		if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)
		{
			//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
			TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, m_pPipeParam->m_dPress, dWD, dWh, dThk, dN);
			pXDataMap->SetAt(PIPE_WH2, dWh);
			pXDataMap->SetAt(PIPE_WN2, dN);

			//垫片
			/*TDbPipeSupport::SetGasketData(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, m_pPipeParam->m_dPress, sProj, sLevel, pXDataMap);
			TDbPipeSupport::SetGasketData(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, dPre, sProj, sLevel, pXDataMap);

			//螺栓
			TDbPipeSupport::SetBoltData(m_pPipeJig->GetAdoDb(), pParam->m_dDN, dPre, sProj, sLevel, pXDataMap);
			TDbPipeSupport::SetBoltData(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, dPre, sProj, sLevel, pXDataMap);*/
		}

		double dDnMaj = pParmMain->m_dDN;
		//pXDataMapmaj->GetAt(PIPE_DN, dDnMaj);

		TDbPipeSupport::QueryInfFDFL(m_pPipeJig->GetAdoDb(), eTee, m_pPipeParam->m_nConnectType, dDnMaj, dFD, dFL);

		pXDataMap->SetAt(PIPE_INTERFACED, dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL, dFL);

		if (m_pPipeParam->m_nConnectType == 3)
		{
			//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
			TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(), dDnMaj, m_pPipeParam->m_dPress, dWD, dWh, dThk, dN);
			pXDataMap->SetAt(PIPE_WH, dWh);
			pXDataMap->SetAt(PIPE_WN, dN);
		}
	}

	pXDataMap->SetAt(KEY_FITSRV, KEY_FITWPIPE);
	if (m_pPipeParam->m_app == WPipe::eDuct)
		pXDataMap->SetAt(KEY_RUNTIME, eDuctTee);
	else if (m_pPipeParam->m_app == WPipe::eBridge)
		pXDataMap->SetAt(KEY_RUNTIME, eBridgeTee);
	else
		pXDataMap->SetAt(KEY_RUNTIME, eTee);

	AcGeVector3d vtMaj = pWPipe->EndPoint() - pWPipe->StartPoint();
	vtMaj.normalize();
	pXDataMap->SetAt(KEY_MAJBR, vtMaj);

	vtMin.normalize();
	pXDataMap->SetAt(KEY_MINBR, vtMin);
	pXDataMap->SetAt(KEY_GRIPCMD, GRIP_CMD);

	AcGeVector3d vtNro = vtMin.crossProduct(vtMaj);
	pXDataMap->SetAt(KEY_NORMAL, vtNro);

	pXDataMap->SetAt(KEY_MID, ptMid);

	double dDn = pParmMain->m_dDN;
	pXDataMapmaj->GetAt(PIPE_DN, dDn);
	pXDataMap->SetAt(PIPE_DN, dDn);

	double dOD = pParmMain->m_dOD;
	pXDataMapmaj->GetAt(PIPE_OD, dOD);
	pXDataMap->SetAt(PIPE_OD, dOD);

	double dTDn = m_pPipeParam->m_dDN;
	pXDataMap->SetAt(PIPE_TDN, dTDn);

	double dTOD = m_pPipeParam->m_dOD;
	pXDataMap->SetAt(PIPE_TOD, dTOD);

	pXDataMap->SetAt(PIPE_THICK, m_pPipeParam->m_dThick);

	pXDataMap->SetAt(KEY_L, dL * 2);
	pXDataMap->SetAt(KEY_T, dB);

	double dWidth = 1.0;
	pXDataMapmaj->GetAt(KEY_Width, dWidth);
	pXDataMap->SetAt(KEY_Width, dWidth);

	int nDir = 0;
	pXDataMapmaj->GetAt(PIPE_BWELDDOT, nDir);
	pXDataMap->SetAt(PIPE_BWELDDOT, nDir);

	nDir = 0;
	pXDataMapmaj->GetAt(PIPE_COLOR, nDir);
	pXDataMap->SetAt(PIPE_COLOR, nDir);

	pXDataMapmaj->GetAt(DOC_WELDDIA, dWidth);
	pXDataMap->SetAt(DOC_WELDDIA, dWidth);

	CString strTemp, sMaterial;
	pXDataMap->SetAt(KEY_TYPE, _T("GBTEE"));

	pXDataMapmaj->GetAt(PIPE_MATERIAL, sMaterial);
	pXDataMap->SetAt(PIPE_MATERIAL, sMaterial);

	pXDataMapmaj->GetAt(PIPE_MATERIALFT, sMaterial);
	pXDataMap->SetAt(PIPE_MATERIALFT, sMaterial);
	pXDataMap->SetAt(PIPE_SYS, m_pPipeParam->szSys);

	if (IsPlasticsMat(m_pPipeParam, sODNo))
	{
		TDbPipeSupport::QueryPVCTeeData(m_pPipeJig->GetAdoDb(), dDn, dTDn, pXDataMap, sODNo);
	}

	//设置图层
	SetFittingLayer(pFitting, m_pPipeParam->szSys);

	//pFitting->ReCreateByXDataMap();
	setInfo2Ent(*pXDataMap);
	AcDbObjectId id = AddFitToModelSpace(pFitting);
	AddUserData(id, pXDataMap, 2);

	return TRUE;
}

BOOL TDbPipeLine::AddTee(AecDbEwPipe* pWPipe,double dL,AcGePoint3d ptMid,double dB,AcGeVector3d vtMin)
{
	AecDbEwFitting* pFitting = new AecDbEwFitting;
	AecDbObjXDataMap* pXDataMap = pFitting->GetSpecialtyData();
	FillConfigXDataMap(pXDataMap,m_pPipeParam);

	pXDataMap->SetAt(PIPE_CONNECT,m_pPipeParam->m_nConnectType);
	AecDbObjXDataMap* pXDataMapmaj = pWPipe->GetSpecialtyData();

	CString sODNo = m_pPipeParam->szODSn;
	IsPlasticsMat(m_pPipeParam, sODNo);

	if (m_pPipeParam->m_nConnectType > 0)
	{
		double dFD = 0.0,dFL = 0.0;
		double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
		TDbPipeSupport::QueryInfFDFL(m_pPipeJig->GetAdoDb(),eTee,m_pPipeParam->m_nConnectType,m_pPipeParam->m_dDN,dFD,dFL);

		pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);
		pXDataMap->SetAt(PIPE_INTERFACED,dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL,dFL);

		if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)
		{
			//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
			TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(),m_pPipeParam->m_dDN,m_pPipeParam->m_dPress,dWD,dWh,dThk,dN);
			pXDataMap->SetAt(PIPE_WH2, dWh);
			pXDataMap->SetAt(PIPE_WN2,dN);
		}

		double dDnMaj = 0.0;
		pXDataMapmaj->GetAt(PIPE_DN,dDnMaj);

		TDbPipeSupport::QueryInfFDFL(m_pPipeJig->GetAdoDb(),eTee,m_pPipeParam->m_nConnectType,dDnMaj,dFD,dFL);

		pXDataMap->SetAt(PIPE_INTERFACED,dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL,dFL);

		if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)
		{
			//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
			TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(),dDnMaj,m_pPipeParam->m_dPress,dWD,dWh,dThk,dN);
			pXDataMap->SetAt(PIPE_WH, dWh);
			pXDataMap->SetAt(PIPE_WN,dN);
		}
	}

	pXDataMap->SetAt(KEY_FITSRV,KEY_FITWPIPE);
	if (m_pPipeParam->m_app == WPipe::eDuct)
		pXDataMap->SetAt(KEY_RUNTIME, eDuctTee);
	else if (m_pPipeParam->m_app == WPipe::eBridge)
		pXDataMap->SetAt(KEY_RUNTIME, eBridgeTee);
	else
		pXDataMap->SetAt(KEY_RUNTIME,eTee);

	AcGeVector3d vtMaj = pWPipe->EndPoint() - pWPipe->StartPoint();
	vtMaj.normalize();
	pXDataMap->SetAt(KEY_MAJBR,vtMaj);

	vtMin.normalize();
	pXDataMap->SetAt(KEY_MINBR,vtMin);
	pXDataMap->SetAt(KEY_GRIPCMD, GRIP_CMD);

	AcGeVector3d vtNro = vtMin.crossProduct(vtMaj);
	pXDataMap->SetAt(KEY_NORMAL,vtNro);

	pXDataMap->SetAt(KEY_MID,ptMid);

	double dDn = m_pPipeParam->m_dDN;
	pXDataMapmaj->GetAt(PIPE_DN,dDn);
	pXDataMap->SetAt(PIPE_DN,dDn);

	double dOD = m_pPipeParam->m_dOD;
	pXDataMapmaj->GetAt(PIPE_OD,dOD);
	pXDataMap->SetAt(PIPE_OD,dOD);

	double dTDn = m_pPipeParam->m_dDN;
	pXDataMapmaj->GetAt(PIPE_TDN,dTDn);
	pXDataMap->SetAt(PIPE_TDN,dTDn);

	double dTOD = m_pPipeParam->m_dOD;
	pXDataMapmaj->GetAt(PIPE_TOD,dTOD);
	pXDataMap->SetAt(PIPE_TOD,dTOD);

	pXDataMap->SetAt(PIPE_THICK,m_pPipeParam->m_dThick);

	pXDataMap->SetAt(KEY_L,dL * 2);
	pXDataMap->SetAt(KEY_T,dB);
	
	double dWidth = 1.0;
	pXDataMapmaj->GetAt(KEY_Width,dWidth);
	pXDataMap->SetAt(KEY_Width,dWidth);

	int nDir = 0;
	pXDataMapmaj->GetAt(PIPE_BWELDDOT,nDir);
	pXDataMap->SetAt(PIPE_BWELDDOT,nDir);

	nDir = 0;
	pXDataMapmaj->GetAt(PIPE_COLOR,nDir);
	pXDataMap->SetAt(PIPE_COLOR,nDir);

	pXDataMapmaj->GetAt(DOC_WELDDIA,dWidth);
	pXDataMap->SetAt(DOC_WELDDIA,dWidth);

	CString strTemp,sMaterial;
	pXDataMap->SetAt(KEY_TYPE,_T("GBTEE"));

	pXDataMapmaj->GetAt(PIPE_MATERIAL,sMaterial);
	pXDataMap->SetAt(PIPE_MATERIAL,sMaterial);

	pXDataMapmaj->GetAt(PIPE_MATERIALFT,sMaterial);
	pXDataMap->SetAt(PIPE_MATERIALFT,sMaterial);
	pXDataMap->SetAt(PIPE_SYS,m_pPipeParam->szSys);

	if (IsPlasticsMat(m_pPipeParam, sODNo))
	{
		TDbPipeSupport::QueryPVCTeeData(m_pPipeJig->GetAdoDb(), dDn, dTDn, pXDataMap, sODNo);
	}

	//设置图层
	SetFittingLayer(pFitting, m_pPipeParam->szSys);

	//pFitting->ReCreateByXDataMap();
	setInfo2Ent(*pXDataMap);
	AcDbObjectId id = AddFitToModelSpace(pFitting);
	AddUserData(id,pXDataMap,2);
	return TRUE;
}

BOOL TDbPipeLine::AddTee(AecDbEwPipe* pWPipeMaj,AecDbEwPipe* pPipeMin,double dL,AcGePoint3d ptMid,double dB,AcGeVector3d vtMin)
{
	AecDbEwFitting* pFitting = new AecDbEwFitting;
	AecDbObjXDataMap* pXDataMap = pFitting->GetSpecialtyData();
	FillConfigXDataMap(pXDataMap,m_pPipeParam);

	pXDataMap->SetAt(PIPE_CONNECT,m_pPipeParam->m_nConnectType);
	AecDbObjXDataMap* pXDataMapmaj = pWPipeMaj->GetSpecialtyData();
	AecDbObjXDataMap* pXDataMapmin = pPipeMin->GetSpecialtyData();
	
	CString sODNo = m_pPipeParam->szODSn;
	IsPlasticsMat(m_pPipeParam, sODNo);

	if (m_pPipeParam->m_nConnectType > 0)
	{
		double dFD = 0.0,dFL = 0.0;
		double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
		TDbPipeSupport::QueryInfFDFL(m_pPipeJig->GetAdoDb(),eTee,m_pPipeParam->m_nConnectType,m_pPipeParam->m_dDN,dFD,dFL);

		pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);
		pXDataMap->SetAt(PIPE_INTERFACED,dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL,dFL);

		if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)
		{
			//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
			TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(),m_pPipeParam->m_dDN,m_pPipeParam->m_dPress,dWD,dWh,dThk,dN);
			pXDataMap->SetAt(PIPE_WH2, dWh);
			pXDataMap->SetAt(PIPE_WN2,dN);
		}

		double dDnMaj = 0.0;
		pXDataMapmaj->GetAt(PIPE_DN,dDnMaj);

		TDbPipeSupport::QueryInfFDFL(m_pPipeJig->GetAdoDb(),eTee,m_pPipeParam->m_nConnectType,dDnMaj,dFD,dFL);

		pXDataMap->SetAt(PIPE_INTERFACED,dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL,dFL);

		if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)
		{
			//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
			TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(),dDnMaj,m_pPipeParam->m_dPress,dWD,dWh,dThk,dN);
			pXDataMap->SetAt(PIPE_WH, dWh);
			pXDataMap->SetAt(PIPE_WN,dN);
		}
	}

	pXDataMap->SetAt(KEY_FITSRV,KEY_FITWPIPE);
	if (m_pPipeParam->m_app == WPipe::eDuct)
		pXDataMap->SetAt(KEY_RUNTIME, eDuctTee);
	else if (m_pPipeParam->m_app == WPipe::eBridge)
		pXDataMap->SetAt(KEY_RUNTIME, eBridgeTee);
	else
		pXDataMap->SetAt(KEY_RUNTIME,eTee);

	AcGeVector3d vtMaj = pWPipeMaj->EndPoint() - pWPipeMaj->StartPoint();
	vtMaj.normalize();
	pXDataMap->SetAt(KEY_MAJBR,vtMaj);

	vtMin.normalize();
	pXDataMap->SetAt(KEY_MINBR,vtMin);
	pXDataMap->SetAt(KEY_GRIPCMD, GRIP_CMD);

	AcGeVector3d vtNro = vtMin.crossProduct(vtMaj);
	pXDataMap->SetAt(KEY_NORMAL,vtNro);

	pXDataMap->SetAt(KEY_MID,ptMid);

	double dDn = m_pPipeParam->m_dDN;
	pXDataMapmaj->GetAt(PIPE_DN,dDn);
	pXDataMap->SetAt(PIPE_DN,dDn);

	double dOD = m_pPipeParam->m_dOD;
	pXDataMapmaj->GetAt(PIPE_OD,dOD);
	pXDataMap->SetAt(PIPE_OD,dOD);

	double dTDn = m_pPipeParam->m_dDN;
	pXDataMapmin->GetAt(PIPE_TDN,dTDn);
	pXDataMap->SetAt(PIPE_TDN,dTDn);

	double dTOD = m_pPipeParam->m_dOD;
	pXDataMapmin->GetAt(PIPE_TOD,dTOD);
	pXDataMap->SetAt(PIPE_TOD,dTOD);

	pXDataMap->SetAt(PIPE_THICK,m_pPipeParam->m_dThick);

	pXDataMap->SetAt(KEY_L,dL * 2);
	pXDataMap->SetAt(KEY_T,dB);

	double dWidth = 1.0;
	pXDataMapmaj->GetAt(KEY_Width,dWidth);
	pXDataMap->SetAt(KEY_Width,dWidth);

	int nDir = 0;
	pXDataMapmaj->GetAt(PIPE_BWELDDOT,nDir);
	pXDataMap->SetAt(PIPE_BWELDDOT,nDir);

	nDir = 0;
	pXDataMapmaj->GetAt(PIPE_COLOR,nDir);
	pXDataMap->SetAt(PIPE_COLOR,nDir);

	pXDataMapmaj->GetAt(DOC_WELDDIA,dWidth);
	pXDataMap->SetAt(DOC_WELDDIA,dWidth);

	CString strTemp,sMaterial;
	pXDataMap->SetAt(KEY_TYPE,_T("GBTEE"));

	pXDataMapmaj->GetAt(PIPE_MATERIAL,sMaterial);
	pXDataMap->SetAt(PIPE_MATERIAL,sMaterial);

	pXDataMapmaj->GetAt(PIPE_MATERIALFT,sMaterial);
	pXDataMap->SetAt(PIPE_MATERIALFT,sMaterial);
	pXDataMap->SetAt(PIPE_SYS,m_pPipeParam->szSys);
	
	if (IsPlasticsMat(m_pPipeParam, sODNo))
	{
		TDbPipeSupport::QueryPVCTeeData(m_pPipeJig->GetAdoDb(), dDn, dTDn, pXDataMap, sODNo);
	}

	//设置图层
	SetFittingLayer(pFitting, m_pPipeParam->szSys);

	//pFitting->ReCreateByXDataMap();
	setInfo2Ent(*pXDataMap);
	AcDbObjectId id = AddFitToModelSpace(pFitting);
	AddUserData(id,pXDataMap,2);
	return TRUE;
}

BOOL TDbPipeLine::AddRPorHP(AecDbEwPipe* pWPipeMaj,AecDbEwPipe* pPipeMin,AcGePoint3d ptMid)
{
	double dDn = 0.0;
	pWPipeMaj->GetAt(PIPE_D,dDn);

	double ddn = 0.0;
	pPipeMin->GetAt(PIPE_D,ddn);

	CString sLevel;//等级
	pWPipeMaj->GetAt(PIPE_LEVEL,sLevel);

	double dOd = 0.0;
	pWPipeMaj->GetAt(PIPE_OD, dOd);

	double dTod = 0;
	pPipeMin->GetAt(PIPE_OD, dTod);

	EFittingType eType;
	AecDbObjXDataMap *pXDataMapmaj = pWPipeMaj->GetSpecialtyData();

	double dD = 0.0;
	pXDataMapmaj->GetAt(PIPE_D, dD);

	//调整
	AcGePoint3d ptE;
	AcGeVector3d vtMin = pPipeMin->EndPoint() - pPipeMin->StartPoint();
	AcGeVector3d vt = MidPoint(pPipeMin->EndPoint(), pPipeMin->StartPoint()) - ptMid;

	/*
	0 RT REDUCING TEE
	1 T EQUAL TEE
	2 H HALF COUPLING
	3 P BRANCH WELD
	4 RP REINFORCING PAD
	5 SO SOCKOLET
	6 W WELDOLET
	*/

	int nRporHP = TDbPipeSupport::QueryRPorHP(m_pPipeJig->GetAdoDb(),sLevel,dDn,ddn);
	if (nRporHP == 2 || nRporHP == 4)
	{
		if (nRporHP == 2) eType = eHP;
		if (nRporHP == 4) eType = eRP;
	}
	else if (nRporHP == 3 ||
			 nRporHP == 5 ||
			 nRporHP == 6) //焊接 或承插
	{
		if (vt.isCodirectionalTo(vtMin))
		{
			vt.normalize();
			vt *= (0.5 * dD);

			ptE = ptMid + vt;
			pPipeMin->SetStartPoint(ptE);
		}
		else
		{
			vt.normalize();
			vt *= (0.5 * dD);

			ptE = ptMid + vt;
			pPipeMin->SetEndPoint(ptE);
		}
		return FALSE;
	}

	//加入RP
	AecDbEwFitting* pFitting = new AecDbEwFitting;
	AecDbObjXDataMap* pXDataMap = pFitting->GetSpecialtyData();
	FillConfigXDataMap(pXDataMap,m_pPipeParam);

	pXDataMap->SetAt(KEY_RUNTIME,eType);
	pXDataMap->SetAt(PIPE_THICK, m_pPipeParam->m_dThick);

	double dD2 = 0,dh = 0.0;
	if (eType == eRP) //补强圈
	{
		TDbPipeSupport::QueryRP(m_pPipeJig->GetAdoDb(), ddn, pXDataMap);
		if (vt.isCodirectionalTo(vtMin))
		{
			vt.normalize();
			vt *= (0.5 * dD - dh);

			ptE = ptMid + vt;
			pPipeMin->SetStartPoint(ptE);
		}
		else
		{
			vt.normalize();
			vt *= (0.5 * dD - dh);

			ptE = ptMid + vt;
			pPipeMin->SetEndPoint(ptE);
		}
	}
	else if (eType == eHP) //半管接头
	{
		TDbPipeSupport::QueryHP(m_pPipeJig->GetAdoDb(), ddn, pXDataMap);
		pXDataMap->GetAt(KEY_L, dh);//长度
		pXDataMap->GetAt(PIPE_D, dD2);//外径

		if (vt.isCodirectionalTo(vtMin))
		{
			vt.normalize();
			vt *= (0.5 * dD + dh);

			ptE = ptMid + vt;
			pPipeMin->SetStartPoint(ptE);
		}
		else
		{
			vt.normalize();
			vt *= (0.5 * dD + dh - 0.25 * dD2);//大约

			ptE = ptMid + vt;
			pPipeMin->SetEndPoint(ptE);
		}
	}

	AcGeVector3d vtMaj = pWPipeMaj->EndPoint() - pWPipeMaj->StartPoint();
	
	vtMaj.normalize();
	pXDataMap->SetAt(KEY_MAJBR,vtMaj);

	vtMin.normalize();
	pXDataMap->SetAt(KEY_MINBR,vt);

	pXDataMap->SetAt(KEY_GRIPCMD, GRIP_CMD);

	AcGeVector3d vtNro = vtMin.crossProduct(vtMaj);
	pXDataMap->SetAt(KEY_NORMAL,vtNro);

	pXDataMap->SetAt(KEY_MID,ptMid);

	dDn = m_pPipeParam->m_dDN;
	pXDataMapmaj->GetAt(PIPE_DN,dDn);
	pXDataMap->SetAt(PIPE_DN,dDn);

	double dOD = m_pPipeParam->m_dOD;
	pXDataMapmaj->GetAt(PIPE_OD,dOD);
	pXDataMap->SetAt(PIPE_OD,dOD);

	double dTDn = m_pPipeParam->m_dDN;
	pPipeMin->GetAt(PIPE_TDN,dTDn);
	pXDataMap->SetAt(PIPE_TDN,dTDn);

	double dTOD = m_pPipeParam->m_dOD;
	pPipeMin->GetAt(PIPE_TOD,dTOD);
	pXDataMap->SetAt(PIPE_TOD,dTOD);

	double dWidth = 1.0;
	pXDataMapmaj->GetAt(KEY_Width,dWidth);
	pXDataMap->SetAt(KEY_Width,dWidth);

	int nDir = 0;
	pXDataMapmaj->GetAt(PIPE_BWELDDOT,nDir);
	pXDataMap->SetAt(PIPE_BWELDDOT,nDir);

	nDir = 0;
	pXDataMapmaj->GetAt(PIPE_COLOR,nDir);
	pXDataMap->SetAt(PIPE_COLOR,nDir);

	pXDataMapmaj->GetAt(DOC_WELDDIA,dWidth);
	pXDataMap->SetAt(DOC_WELDDIA,dWidth);

	CString strTemp,sMaterial;
	pXDataMap->SetAt(KEY_TYPE,_T("GBTEE"));

	pXDataMapmaj->GetAt(PIPE_MATERIAL,sMaterial);
	pXDataMap->SetAt(PIPE_MATERIAL,sMaterial);

	pXDataMapmaj->GetAt(PIPE_MATERIALFT,sMaterial);
	pXDataMap->SetAt(PIPE_MATERIALFT,sMaterial);
	pXDataMap->SetAt(PIPE_SYS,m_pPipeParam->szSys);

	//设置图层
	SetFittingLayer(pFitting, m_pPipeParam->szSys);

	//pFitting->ReCreateByXDataMap();
	setInfo2Ent(*pXDataMap);
	AcDbObjectId id = AddFitToModelSpace(pFitting);
	AddUserData(id,pXDataMap,2);

	return TRUE;
}

BOOL TDbPipeLine::AddRPorHP(AecDbEwPipe* pWPipeMaj,AcDbObjectId& idMin,AcGePoint3d ptMid)
{
	AcDbEntity* pEnt1 = NULL;
	if (Acad::eOk == acdbOpenAcDbEntity(pEnt1, idMin, AcDb::kForWrite))
	{
		AecDbEwPipe* pPipeMin = AecDbEwPipe::cast(pEnt1);
		if (pPipeMin != NULL)
		{
			AddRPorHP(pWPipeMaj,pPipeMin,ptMid);
		}
		pEnt1->close();
	}
	return TRUE;
}

BOOL TDbPipeLine::AddTee(AecDbEwPipe* pWPipeMaj,AcDbObjectId& idMin,double dL,AcGePoint3d ptMid,double dB,AcGeVector3d vtMin)
{
	AcDbEntity* pEnt1 = NULL;
	if (Acad::eOk == acdbOpenAcDbEntity(pEnt1, idMin, AcDb::kForWrite))
	{
		AecDbEwPipe* pPipeMin = AecDbEwPipe::cast(pEnt1);
		if (pPipeMin != NULL)
		{
			AddTee(pWPipeMaj,pPipeMin,dL,ptMid,dB,vtMin);
		}
		pEnt1->close();
	}
	return TRUE;
}

BOOL TDbPipeLine::AddTee(AecInterface& inf,AcGeVector3d& vtNorm, AcGeVector3d& vtMin,double dL, double dS)
{
	AecDbEwFitting* pFitting = new AecDbEwFitting;
	AecDbObjXDataMap* pXDataMap = pFitting->GetSpecialtyData();
	FillConfigXDataMap(pXDataMap,m_pPipeParam);

	pXDataMap->SetAt(PIPE_CONNECT,m_pPipeParam->m_nConnectType);
	if (m_pPipeParam->m_nConnectType > 0)
	{
		double dFD = 0.0,dFL = 0.0;
		TDbPipeSupport::QueryInfFDFL(m_pPipeJig->GetAdoDb(),eLateral,m_pPipeParam->m_nConnectType,m_pPipeParam->m_dDN,dFD,dFL);

		pXDataMap->SetAt(PIPE_INTERFACED,dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL,dFL);
		pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);

		if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)
		{
			//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
			double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
			TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(),m_pPipeParam->m_dDN,m_pPipeParam->m_dPress,dWD,dWh,dThk,dN);
			pXDataMap->SetAt(PIPE_WH2, dWh);
			pXDataMap->SetAt(PIPE_WN2,dN);
			pXDataMap->SetAt(PIPE_WH, dWh);
			pXDataMap->SetAt(PIPE_WN,dN);
		}
	}

	pXDataMap->SetAt(KEY_FITSRV,KEY_FITWPIPE);
	pXDataMap->SetAt(KEY_RUNTIME,eTee);

	AcGeVector3d vtMaj = inf.vtDir;
	vtMaj.normalize();
	pXDataMap->SetAt(KEY_MAJBR,vtMaj);

	vtMin.normalize();
	pXDataMap->SetAt(KEY_MINBR,vtMin);
	pXDataMap->SetAt(KEY_GRIPCMD, GRIP_CMD);

	AcGeVector3d vtNro = vtMin.crossProduct(vtMaj);
	pXDataMap->SetAt(KEY_NORMAL,vtNro);

	AcGePoint3d ptMid;
	ptMid = inf.ptPos + vtMaj * dL;

	pXDataMap->SetAt(KEY_MID,ptMid);

	double dDn = m_pPipeParam->m_dDN;
	pXDataMap->SetAt(PIPE_DN,dDn);

	double dOD = m_pPipeParam->m_dOD;
	pXDataMap->SetAt(PIPE_OD,dOD);

	pXDataMap->SetAt(PIPE_TDN,inf.dSize1);
	pXDataMap->SetAt(PIPE_TOD,inf.dSize2);

	pXDataMap->SetAt(PIPE_THICK,m_pPipeParam->m_dThick);

	pXDataMap->SetAt(KEY_L,dL * 2);
	pXDataMap->SetAt(KEY_T,dS);

	double dWidth = 1.0;
	pXDataMap->SetAt(KEY_Width,dWidth);

	int nDir = 0;
	pXDataMap->SetAt(PIPE_BWELDDOT,nDir);

	nDir = 0;
	m_xInitDataMap.GetAt(PIPE_COLOR,nDir);
	pXDataMap->SetAt(PIPE_COLOR,nDir);

	pXDataMap->SetAt(DOC_WELDDIA,dWidth);

	CString strTemp,sMaterial;
	pXDataMap->SetAt(KEY_TYPE,_T("GBTEE"));

	pXDataMap->SetAt(PIPE_MATERIAL,sMaterial);

	pXDataMap->SetAt(PIPE_MATERIALFT,sMaterial);
	pXDataMap->SetAt(PIPE_SYS,m_pPipeParam->szSys);

	//设置图层
	SetFittingLayer(pFitting, m_pPipeParam->szSys);

	//pFitting->ReCreateByXDataMap();
	setInfo2Ent(*pXDataMap);
	AcDbObjectId id = AddFitToModelSpace(pFitting);
	AddUserData(id,pXDataMap,2);
	return TRUE;
}

BOOL TDbPipeLine::AddLTee(AecInterface& inf,AcGeVector3d& vtBr,double dE,double dM,double dB,double dInsL,double dInfD)
{
	AecDbEwFitting* pFitting = new AecDbEwFitting;
	AecDbObjXDataMap* pXDataMap = pFitting->GetSpecialtyData();
	FillConfigXDataMap(pXDataMap,m_pPipeParam);

	pXDataMap->SetAt(PIPE_CONNECT,m_pPipeParam->m_nConnectType);
	if (m_pPipeParam->m_nConnectType > 0)
	{
		double dFD = 0.0,dFL = 0.0;
		TDbPipeSupport::QueryInfFDFL(m_pPipeJig->GetAdoDb(),eLateral,m_pPipeParam->m_nConnectType,m_pPipeParam->m_dDN,dFD,dFL);

		pXDataMap->SetAt(PIPE_INTERFACED,dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL,dFL);
		pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);

		if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)
		{
			//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
			double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
			TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(),m_pPipeParam->m_dDN,m_pPipeParam->m_dPress,dWD,dWh,dThk,dN);
			pXDataMap->SetAt(PIPE_WH2, dWh);
			pXDataMap->SetAt(PIPE_WN2,dN);
			pXDataMap->SetAt(PIPE_WH, dWh);
			pXDataMap->SetAt(PIPE_WN,dN);
		}
	}

	pXDataMap->SetAt(KEY_FITSRV,KEY_FITWPIPE);
	pXDataMap->SetAt(KEY_RUNTIME,eLateral);

	AcGeVector3d vtMaj = inf.vtDir;
	pXDataMap->SetAt(KEY_MAJBR,vtMaj);
	pXDataMap->SetAt(KEY_MINBR,vtBr);

	AcGeVector3d vtNormal = vtBr.crossProduct(vtMaj);
	pXDataMap->SetAt(KEY_NORMAL,vtNormal);

	vtMaj.normalize();
	AcGePoint3d ptMid = inf.ptPos + vtMaj * dE;
	pXDataMap->SetAt(KEY_MID,ptMid);

	pXDataMap->SetAt(PIPE_DRAWDIR,m_pPipeParam->m_eD);
	pXDataMap->SetAt(KEY_2DSTYLE,PipelineTools::isDoubleLine(m_pPipeParam->m_dDN) ? 2 : 1);
	pXDataMap->SetAt(PIPE_DN,m_pPipeParam->m_dDN);
	pXDataMap->SetAt(PIPE_OD,m_pPipeParam->m_dOD);
	pXDataMap->SetAt(PIPE_TDN,m_pPipeParam->m_dDN);
	pXDataMap->SetAt(PIPE_TOD,m_pPipeParam->m_dOD);
	pXDataMap->SetAt(PIPE_THICK,m_pPipeParam->m_dThick);
	pXDataMap->SetAt(PIPE_E,dE);
	pXDataMap->SetAt(PIPE_M,dM);
	pXDataMap->SetAt(PIPE_B,dB);
	pXDataMap->SetAt(KEY_GRIPCMD, GRIP_CMD);
	pXDataMap->SetAt(PIPE_COLOR,m_pPipeParam->m_nPipeColor);

	//设置图层
	SetFittingLayer(pFitting, m_pPipeParam->szSys);

	//pFitting->ReCreateByXDataMap();
	setInfo2Ent(*pXDataMap);
	AcDbObjectId id = AddFitToModelSpace(pFitting);
	AddUserData(id,pXDataMap,2);
	return TRUE;
}

BOOL TDbPipeLine::AddYTee(AecInterface& inf,AcGeVector3d& vtNormal,double dM,double dB,double dInsL,double dInfD)
{
	AecDbEwFitting* pFitting = new AecDbEwFitting;
	AecDbObjXDataMap* pXDataMap = pFitting->GetSpecialtyData();
	FillConfigXDataMap(pXDataMap,m_pPipeParam);

	pXDataMap->SetAt(PIPE_CONNECT,m_pPipeParam->m_nConnectType);
	if (m_pPipeParam->m_nConnectType > 0)
	{
		double dFD = 0.0,dFL = 0.0;
		TDbPipeSupport::QueryInfFDFL(m_pPipeJig->GetAdoDb(),eWye,m_pPipeParam->m_nConnectType,m_pPipeParam->m_dDN,dFD,dFL);

		pXDataMap->SetAt(PIPE_INTERFACED,dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL,dFL);

		pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
		pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);

		if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)
		{
			//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
			double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
			TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(),m_pPipeParam->m_dDN,m_pPipeParam->m_dPress,dWD,dWh,dThk,dN);
			pXDataMap->SetAt(PIPE_WH2, dWh);
			pXDataMap->SetAt(PIPE_WN2,dN);
			pXDataMap->SetAt(PIPE_WH, dWh);
			pXDataMap->SetAt(PIPE_WN,dN);
		}
	}

	pXDataMap->SetAt(KEY_FITSRV,KEY_FITWPIPE);
	pXDataMap->SetAt(KEY_RUNTIME,eWye);

	AcGeVector3d vtMaj = inf.vtDir;
	pXDataMap->SetAt(KEY_MAJBR,vtMaj);

	AcGeLine3d ln(AcGePoint3d::kOrigin,vtMaj);
	if (AcGePlane::kXYPlane.isParallelTo(ln))
	{
		vtNormal = AcGeVector3d::kZAxis;
	}
	else if (AcGePlane::kXYPlane.isPerpendicularTo(ln))
	{
		vtNormal = AcGeVector3d::kXAxis;
	}
	pXDataMap->SetAt(KEY_NORMAL,vtNormal);

	vtMaj.normalize();
	AcGePoint3d ptMid = inf.ptPos + vtMaj * dM;
	pXDataMap->SetAt(KEY_MID,ptMid);

	pXDataMap->SetAt(PIPE_DRAWDIR,m_pPipeParam->m_eD);
	pXDataMap->SetAt(KEY_2DSTYLE, PipelineTools::isDoubleLine(m_pPipeParam->m_dDN) ? 2 : 1);
	pXDataMap->SetAt(PIPE_DN,m_pPipeParam->m_dDN);
	pXDataMap->SetAt(PIPE_OD,m_pPipeParam->m_dOD);
	pXDataMap->SetAt(PIPE_TDN,m_pPipeParam->m_dDN);
	pXDataMap->SetAt(PIPE_TOD,m_pPipeParam->m_dOD);
	pXDataMap->SetAt(PIPE_THICK,m_pPipeParam->m_dThick);
	pXDataMap->SetAt(PIPE_M,dM);
	pXDataMap->SetAt(PIPE_B,dB);
	pXDataMap->SetAt(KEY_GRIPCMD, GRIP_CMD);
	pXDataMap->SetAt(PIPE_COLOR,m_pPipeParam->m_nPipeColor);

	//设置图层
	SetFittingLayer(pFitting, m_pPipeParam->szSys);

	//pFitting->ReCreateByXDataMap();
	setInfo2Ent(*pXDataMap);
	AcDbObjectId id = AddFitToModelSpace(pFitting);
	AddUserData(id,pXDataMap,2);
	return TRUE;
}

BOOL TDbPipeLine::AddCap(AecInterface& inf,AcGeVector3d& vtNormal,double dL)
{
	AecDbEwFitting* pFitting = new AecDbEwFitting;
	AecDbObjXDataMap* pXDataMap = pFitting->GetSpecialtyData();
	FillConfigXDataMap(pXDataMap,m_pPipeParam);

	pXDataMap->SetAt(KEY_FITSRV,KEY_FITWPIPE);
	pXDataMap->SetAt(KEY_RUNTIME,eWcap);

	AcGeVector3d vtMaj = inf.vtDir;
	pXDataMap->SetAt(KEY_MAJBR,vtMaj);

	AcGeLine3d ln(AcGePoint3d::kOrigin,vtMaj);
	if (AcGePlane::kXYPlane.isParallelTo(ln))
	{
		vtNormal = AcGeVector3d::kZAxis;
	}
	else if (AcGePlane::kXYPlane.isPerpendicularTo(ln))
	{
		vtNormal = AcGeVector3d::kXAxis;
	}
	pXDataMap->SetAt(KEY_NORMAL,vtNormal);

	vtMaj.normalize();

	pXDataMap->SetAt(PIPE_DRAWDIR,m_pPipeParam->m_eD);
	pXDataMap->SetAt(KEY_2DSTYLE, PipelineTools::isDoubleLine(m_pPipeParam->m_dDN) ? 2 : 1);
	pXDataMap->SetAt(KEY_START,inf.ptPos);
	pXDataMap->SetAt(PIPE_DN,m_pPipeParam->m_dDN);
	pXDataMap->SetAt(PIPE_OD,m_pPipeParam->m_dOD);
	pXDataMap->SetAt(PIPE_TDN,m_pPipeParam->m_dDN);
	pXDataMap->SetAt(PIPE_TOD,m_pPipeParam->m_dOD);
	pXDataMap->SetAt(PIPE_THICK,m_pPipeParam->m_dThick);
	pXDataMap->SetAt(KEY_L,dL);
	pXDataMap->SetAt(KEY_GRIPCMD, GRIP_CMD);
	pXDataMap->SetAt(PIPE_COLOR,m_pPipeParam->m_nPipeColor);

	//设置图层
	SetFittingLayer(pFitting, m_pPipeParam->szSys);

	//pFitting->ReCreateByXDataMap();
	setInfo2Ent(*pXDataMap);
	AcDbObjectId id = AddFitToModelSpace(pFitting);
	AddUserData(id,pXDataMap,6);
	return TRUE;
}

BOOL TDbPipeLine::AddCross( AcDbObjectId id1,AcGePoint3d& ptInt,AcDbObjectId idThis,WPipe::PipeParam* pParamT/* = NULL*/)
{
	AecDbEwPipe* pWPipe = NULL;
	double dL = 0.0,dB = 0.0,dTDn = 0.0,dTOD = 0.0;
	AcGeVector3d vtMaj,vtMin;

	CString sDNo = m_pPipeParam->szODSn;
	IsPlasticsMat(m_pPipeParam, sDNo);

	if (pParamT == NULL)
		pParamT = m_pPipeParam;

	if ( TDbPipeSupport::QueryCrossData(m_pPipeJig->GetAdoDb(),m_pPipeParam->m_dDN,m_pPipeParam->m_dDN,dL,dB) )
	{
		if (m_pPipeParam->m_dInterfaceL > 1.e-3)//法兰管
		{
			dL += m_pPipeParam->m_dInterfaceL;
			dB += m_pPipeParam->m_dInterfaceL;
		}

		if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)//法兰连接
		{
			//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
			double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
			TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(),m_pPipeParam->m_dDN,m_pPipeParam->m_dPress,dWD,dWh,dThk,dN);

			dL -= m_pPipeParam->m_dInterfaceL;
			dB -= m_pPipeParam->m_dInterfaceL;

			//颈法兰焊接方式
			if (sDNo.CompareNoCase(_T("S")) != 0 &&
				sDNo.CompareNoCase(_T("GSF")) != 0)
			{
				dL += dWh;
				dB += dWh;
			}
		}

		if (pParamT != NULL)
		{
			dL = 0.0,dB = 0.0;
			if ( TDbPipeSupport::QueryCrossData(m_pPipeJig->GetAdoDb(),m_pPipeParam->m_dDN,pParamT->m_dDN,dL,dB) )
			{
				if (m_pPipeParam->m_dInterfaceL > 1.e-3)//法兰管
				{
					dL += m_pPipeParam->m_dInterfaceL;
					dB += pParamT->m_dInterfaceL;
				}

				if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)//法兰连接
				{
					//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
					double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
					TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(),pParamT->m_dDN,m_pPipeParam->m_dPress,dWD,dWh,dThk,dN);

					dL -= m_pPipeParam->m_dInterfaceL;
					dB -= pParamT->m_dInterfaceL;

					//颈法兰焊接方式
					if (sDNo.CompareNoCase(_T("S")) != 0 &&
						sDNo.CompareNoCase(_T("GSF")) != 0)
					{
						dL += dWh;
						dB += dWh;
					}
				}
			}
		}

		//idThis 支管分割为两部分
		AcDbEntity* pEnt2 = NULL;
		if ( Acad::eOk == acdbOpenAcDbEntity(pEnt2,idThis,AcDb::kForWrite))
		{
			pWPipe = AecDbEwPipe::cast(pEnt2);
			if (pWPipe != NULL)
			{
				pWPipe->GetSpecialtyData(AcDb::kForWrite)->GetAt(PIPE_TDN,dTDn);
				pWPipe->GetSpecialtyData(AcDb::kForWrite)->GetAt(PIPE_TOD,dTOD);
				vtMin = pWPipe->EndPoint() - pWPipe->StartPoint();

				AcGeLineSeg3d ln(pWPipe->StartPoint(),pWPipe->EndPoint());
				if (ln.isOn(ptInt)) //落在管子上,两管线相交
				{
					if ( !SplitWPipe(ptInt,dB,pWPipe,FALSE) )
					{
						//太短,放不下四通
						pEnt2->close();
						return FALSE;
					}
				}
				else //不落在管子上,两管线延长相交, 外部加四通命令调用
				{
					vtMin.normalize();
					double dDis1 = ptInt.distanceTo(pWPipe->StartPoint());
					double dDis2 = ptInt.distanceTo(pWPipe->EndPoint());

					if (dDis1 < dDis2)//距离sta近
					{
						pWPipe->SetStartPoint(ptInt + vtMin * dB);
					}
					else
					{
						pWPipe->SetEndPoint(ptInt - vtMin * dB);
					}
				}
			}
			pEnt2->close();
		}	
		
		// id1 主管分割为两部分
		AcDbEntity* pEnt1 = NULL;
		if ( Acad::eOk == acdbOpenAcDbEntity(pEnt1,id1,AcDb::kForWrite))
		{
			pWPipe = AecDbEwPipe::cast(pEnt1);
			if (pWPipe != NULL)
			{
				vtMaj = pWPipe->EndPoint() - pWPipe->StartPoint();

				AcGeLineSeg3d ln(pWPipe->StartPoint(),pWPipe->EndPoint());
				if (ln.isOn(ptInt)) //落在管子上,两管线相交
				{
					SplitWPipe(ptInt,dL,pWPipe,TRUE);
				}
				else //不落在管子上,两管线延长相交, 外部加四通命令调用
				{
					vtMaj.normalize();
					double dDis1 = ptInt.distanceTo(pWPipe->StartPoint());
					double dDis2 = ptInt.distanceTo(pWPipe->EndPoint());

					if (dDis1 < dDis2)//距离sta近
					{
						pWPipe->SetStartPoint(ptInt + vtMaj * dL);
					}
					else
					{
						pWPipe->SetEndPoint(ptInt - vtMaj * dL);
					}
				}
			}
			pEnt1->close();
		}

		//加入四通
		AcGeVector3d vtNro = vtMin.crossProduct(vtMaj);

		AecDbEwFitting* pFitting = new AecDbEwFitting;
		AecDbObjXDataMap* pXDataMap = pFitting->GetSpecialtyData();
		
		FillConfigXDataMap(pXDataMap,m_pPipeParam);

		if (pParamT != NULL)
		{
			dTDn = pParamT->m_dDN;
			dTOD = pParamT->m_dOD;
		}

		pXDataMap->SetAt(PIPE_CONNECT,m_pPipeParam->m_nConnectType);
		if (m_pPipeParam->m_nConnectType > 0)
		{
			double dFD = 0.0,dFL = 0.0;
			TDbPipeSupport::QueryInfFDFL(m_pPipeJig->GetAdoDb(),eCross,m_pPipeParam->m_nConnectType,m_pPipeParam->m_dDN,dFD,dFL);

			pXDataMap->SetAt(PIPE_INTERFACED,dFD);
			pXDataMap->SetAt(PIPE_INTERFACEL,dFL);

			pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
			pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);

			if (pParamT != NULL)
			{
				TDbPipeSupport::QueryInfFDFL(m_pPipeJig->GetAdoDb(),eCross,m_pPipeParam->m_nConnectType,pParamT->m_dDN,dFD,dFL);
				pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
				pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);
			}

			if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)
			{
				//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
				double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
				TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(),m_pPipeParam->m_dDN,m_pPipeParam->m_dPress,dWD,dWh,dThk,dN);

				pXDataMap->SetAt(PIPE_WH, dWh);
				pXDataMap->SetAt(PIPE_WN,dN);

				pXDataMap->SetAt(PIPE_WH2, dWh);
				pXDataMap->SetAt(PIPE_WN2,dN);

				if (pParamT != NULL)
				{
					TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(),pParamT->m_dDN,m_pPipeParam->m_dPress,dWD,dWh,dThk,dN);

					pXDataMap->SetAt(PIPE_WH2, dWh);
					pXDataMap->SetAt(PIPE_WN2,dN);

				}
			}
		}

		pXDataMap->SetAt(KEY_FITSRV,KEY_FITWPIPE);
		if (m_pPipeParam->m_app == WPipe::eDuct)
			pXDataMap->SetAt(KEY_RUNTIME, eDuctCross);
		else if (m_pPipeParam->m_app == WPipe::eBridge)
			pXDataMap->SetAt(KEY_RUNTIME, eBridgeCross);
		else
			pXDataMap->SetAt(KEY_RUNTIME, eCross);

		pXDataMap->SetAt(KEY_MAJBR,vtMaj);
		pXDataMap->SetAt(KEY_MINBR,vtMin);//

		vtNro = vtMaj.crossProduct(vtMin);//
		pXDataMap->SetAt(KEY_NORMAL,vtNro);

		pXDataMap->SetAt(KEY_MID,ptInt);
		pXDataMap->SetAt(KEY_L,dL * 2);
		pXDataMap->SetAt(KEY_T,dB * 2);

		pXDataMap->SetAt(PIPE_TDN,dTDn);
		pXDataMap->SetAt(PIPE_TOD,dTOD);

		pXDataMap->SetAt(KEY_Width,2.0);
		pXDataMap->SetAt(PIPE_BWELDDOT,0);
		pXDataMap->SetAt(PIPE_SYS,m_pPipeParam->szSys);

		CString sODNo = m_pPipeParam->szODSn;
		if (IsPlasticsMat(m_pPipeParam, sODNo))
		{
			TDbPipeSupport::QueryPVCCrossData(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, dTDn, pXDataMap, sODNo);
		}

		//设置图层
		SetFittingLayer(pFitting, m_pPipeParam->szSys);
		
		//pFitting->ReCreateByXDataMap();
		setInfo2Ent(*pXDataMap);
		AcDbObjectId id = AddFitToModelSpace(pFitting);
		AddUserData(id,pXDataMap,3);
		return TRUE;
	}
	return FALSE;
}

BOOL TDbPipeLine::AddTee(AcDbObjectId id1,AcGePoint3d& ptInt,AcDbObjectId idThis)
{
	AecDbEwPipe* pWPipe = NULL;
	double dL = 0.0,dB = 0.0,dTDn,dTOD;
	AcGeVector3d vtMaj,vtMin,vtNorm;

	if ( TDbPipeSupport::QueryTeeData(m_pPipeJig->GetAdoDb(),m_pPipeParam->m_dDN,m_pPipeParam->m_dDN,dL,dB) )
	{
		if (m_pPipeParam->m_dInterfaceL > 1.e-3)//法兰管
		{
			dL += m_pPipeParam->m_dInterfaceL;
			dB += m_pPipeParam->m_dInterfaceL;
		}

		if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)//法兰连接
		{
			//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
			double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
			TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(),m_pPipeParam->m_dDN,m_pPipeParam->m_dPress,dWD,dWh,dThk,dN);

			dL -= m_pPipeParam->m_dInterfaceL;
			dB -= m_pPipeParam->m_dInterfaceL;

			//颈法兰焊接方式
			CString sDNo = m_pPipeParam->szODSn;
			if (sDNo.CompareNoCase(_T("S")) != 0 &&
				sDNo.CompareNoCase(_T("GSF")) != 0)
			{
				dL += dWh;
				dB += dWh;		
			}

		}


		// id1管子接近ptInt点 缩短
		WPipe::PipeParam* pParm2 = NULL;
		AcDbEntity* pEnt1 = NULL;
		if ( Acad::eOk == acdbOpenAcDbEntity(pEnt1,id1,AcDb::kForWrite))
		{
			pWPipe = AecDbEwPipe::cast(pEnt1);
			if (pWPipe != NULL)
			{
				pParm2 = pWPipe->GetPipeParam();

				if ( ( pParm2->m_dDN - m_pPipeParam->m_dDN) < 1.e-2 )//分支管子小于主管
				{
					vtMin = pWPipe->EndPoint() - pWPipe->StartPoint();
					vtMin.normalize();

					double dDis1 = ptInt.distanceTo(pWPipe->StartPoint());
					double dDis2 = ptInt.distanceTo(pWPipe->EndPoint());

					if (dDis1 < dDis2)//距离sta近
					{
						pWPipe->SetStartPoint(ptInt + vtMin * dB);
					}
					else
					{
						pWPipe->SetEndPoint(ptInt - vtMin * dB);
						vtMin.negate();
					}
				}
			}
			pEnt1->close();
		}

		//idThis 管分割为两部分
		if ( (pParm2->m_dDN - m_pPipeParam->m_dDN) < 1.e-2) //分支管子小于主管
		{
			AcDbEntity* pEnt2 = NULL;
			if ( Acad::eOk == acdbOpenAcDbEntity(pEnt2,idThis,AcDb::kForWrite))
			{
				pWPipe = AecDbEwPipe::cast(pEnt2);
				if (pWPipe != NULL)
				{
					pWPipe->GetSpecialtyData(AcDb::kForWrite)->GetAt(PIPE_TDN,dTDn);
					pWPipe->GetSpecialtyData(AcDb::kForWrite)->GetAt(PIPE_TOD,dTOD);
					vtMaj = pWPipe->EndPoint() - pWPipe->StartPoint();

					AcGeLineSeg3d ln(pWPipe->StartPoint(),pWPipe->EndPoint());
					if (ln.isOn(ptInt)) //落在管子上,两管线相交
					{
						if ( !SplitWPipe(ptInt,dB,pWPipe,FALSE) )
						{
							//太短,放不下四通
							pEnt2->close();
							delete pParm2;
							return FALSE;
						}
					}
				}
				pEnt2->close();
			}	
		}
		
		if ( (pParm2->m_dDN - m_pPipeParam->m_dDN) < 1.e-2) //分支管子小于主管
		{
			//加入Tee
			vtMaj.normalize();
			vtMin.normalize();

			AecInterface inf;
			inf.ptPos = ptInt - vtMaj * dL;
			inf.vtDir = vtMaj;
			inf.dSize1 = pParm2->m_dDN;
			inf.dSize2 = pParm2->m_dOD;
			vtNorm = vtMin.crossProduct(vtMaj);
			
			return AddTee(inf,vtNorm,vtMin,dL,dB);
		}
	}
	else //焊接方式，加补强圈
	{

	}
	return FALSE;
}

BOOL TDbPipeLine::AddElbow(AcDbObjectId id1,AcGePoint3d& ptGe,AcDbObjectId idThis)
{
	AecDbEwPipe* pWPipe1 = NULL;
	AecDbEwPipe* pWPipe2 = NULL;
	AcDbEntity* pEnt1 = NULL;
	AcDbEntity* pEnt2 = NULL;
	BOOL bSuccess = FALSE;

	if (Acad::eOk == acdbOpenAcDbEntity(pEnt1,id1,AcDb::kForWrite))
	{
		if (Acad::eOk == acdbOpenAcDbEntity(pEnt2,idThis,AcDb::kForWrite))
		{
			pWPipe1 = AecDbEwPipe::cast(pEnt1);
			pWPipe2 = AecDbEwPipe::cast(pEnt2);

			if (pWPipe1 != NULL && pWPipe2 != NULL)
			{
				AcGeLine3d ln1(pWPipe1->StartPoint(),pWPipe1->EndPoint());
				AcGeLine3d ln2(pWPipe2->StartPoint(),pWPipe2->EndPoint());

				AcGePoint3d ptMid = ptGe;
				if ( ln1.intersectWith(ln2,ptMid) )
				{
					ptGe = ptMid;//??
				}
				else
				{
					pEnt1->close();
					pEnt2->close();
					return FALSE;
				}

				WPipe::PipeParam param1,param2;
				AecDbObjXDataMap* pXDatamap1 = NULL;
				AecDbObjXDataMap* pXDatamap2 = NULL;
				pXDatamap1 = pWPipe1->GetSpecialtyData();
				pXDatamap2 = pWPipe2->GetSpecialtyData();

				TDbPipeSupport::XData2PipeParam(&param1,pXDatamap1);
				TDbPipeSupport::XData2PipeParam(&param2,pXDatamap2);

				int npos1 = 1,npos2 = 1;
				AcGeVector3d vtMaj,vtMin;
				double dDis1 = ptMid.distanceTo(pWPipe1->EndPoint());
				double dDis2 = ptMid.distanceTo(pWPipe1->StartPoint());
				vtMaj = pWPipe1->EndPoint() - pWPipe1->StartPoint();//默认靠近 end
				if (dDis1 > dDis2)
				{
					vtMaj = pWPipe1->StartPoint() - pWPipe1->EndPoint();//靠近 sta
					npos1 = 0;
				}
				vtMaj.normalize();
				
				dDis1 = ptMid.distanceTo(pWPipe2->EndPoint());
				dDis2 = ptMid.distanceTo(pWPipe2->StartPoint());

				vtMin = pWPipe2->EndPoint() - pWPipe2->StartPoint();//默认靠近 end
				if (dDis1 > dDis2)
				{
					vtMin = pWPipe2->StartPoint() - pWPipe2->EndPoint();//靠近 sta
					npos2 = 0;
				}
				vtMin.normalize();
				vtMin.negate();

				if ( fabs(param1.m_dDN - param2.m_dDN) < 1.e-3)
				{
					//创建弯头,是插入到当前管子的接口记录的前面
					AcDbObjectId id = CreateElbow(vtMaj,ptMid,vtMin,&param1,TRUE);

					//获取万头接口,改变边的管子
					AcDbEntity* pEnt3 = NULL;
					if (Acad::eOk == acdbOpenAcDbEntity(pEnt3,id,AcDb::kForRead))
					{
						AecDbEwFitting* pFit = AecDbEwFitting::cast(pEnt3);
						if (pFit != NULL)
						{
							AecInterface inf1,inf2;
							pFit->GetInterface(0,inf1);
							pFit->GetInterface(1,inf2);

							AcGeVector3d vtPipe = pWPipe1->EndPoint() - pWPipe1->StartPoint();
							if (npos1 == 0)//改sta
								pWPipe1->SetStartPoint(inf2.ptPos);
							else
								pWPipe1->SetEndPoint(inf2.ptPos);

							if (npos2 == 0)
								pWPipe2->SetStartPoint(inf1.ptPos);
							else
								pWPipe2->SetEndPoint(inf1.ptPos);
						}
						pEnt3->close();
					}
				}
				bSuccess = TRUE;
			}
			pEnt2->close();
		}
		pEnt1->close();
	}
	return bSuccess;
}

BOOL TDbPipeLine::ChangeElbowToTree(AecDbEwFitting* pDbFit,AcGeVector3d vtMaj,AcGePoint3d ptGeM,AcGeVector3d vtMin,
									double dDn,AECStatusRecord* pCurRec)
{
	//查询 Tee 数据
	WPipe::PipeParam param;
	AecDbObjXDataMap* pXDataMapmaj = pDbFit->GetSpecialtyData();
	TDbPipeSupport::XData2PipeParam(&param,pXDataMapmaj);

	double dL = 0.0,dS = 0.0;
	if ( TDbPipeSupport::QueryTeeData( m_pPipeJig->GetAdoDb(), dDn,dDn,dL,dS) )
	{
		double dInterfaceL = 0.0;
		pXDataMapmaj->GetAt(PIPE_INTERFACEL,dInterfaceL);
		if (dInterfaceL > 1.e-3)//法兰管
		{
			dL += dInterfaceL;
			dS += dInterfaceL;
		}

		AecInterface intf1,intf2;
		pDbFit->GetInterface(0,intf1);
		pDbFit->GetInterface(1,intf2);

		//创建三通
		AecDbEwFitting* pFitting = new AecDbEwFitting;
		AecDbObjXDataMap* pXDataMap = pFitting->GetSpecialtyData();
		FillConfigXDataMap(pXDataMap,m_pPipeParam);

		pXDataMap->SetAt(KEY_FITSRV,KEY_FITWPIPE);

		if (m_pPipeParam->m_app == WPipe::eDuct)
			pXDataMap->SetAt(KEY_RUNTIME, eDuctTee);
		else if (m_pPipeParam->m_app == WPipe::eBridge)
			pXDataMap->SetAt(KEY_RUNTIME, eBridgeTee);
		else
			pXDataMap->SetAt(KEY_RUNTIME, eTee);

		vtMaj.normalize();
		pXDataMap->SetAt(KEY_MAJBR,vtMaj);

		vtMin.normalize();
		pXDataMap->SetAt(KEY_MINBR,vtMin);

		AcGeVector3d vtNro = vtMin.crossProduct(vtMaj);
		pXDataMap->SetAt(KEY_NORMAL,vtNro);

		pXDataMap->SetAt(KEY_MID,ptGeM);

		pXDataMapmaj->GetAt(PIPE_DN,dDn);
		pXDataMap->SetAt(PIPE_DN,dDn);

		pXDataMap->SetAt(PIPE_OD,param.m_dOD);

		pXDataMap->SetAt(PIPE_TDN,dDn);
		pXDataMap->SetAt(PIPE_TOD,param.m_dOD);

		pXDataMap->SetAt(PIPE_THICK,param.m_dThick);
		pXDataMap->SetAt(KEY_L,dL);
		pXDataMap->SetAt(KEY_T,dS);

		double dWidth = 1.0;
		pXDataMapmaj->GetAt(KEY_Width,dWidth);
		pXDataMap->SetAt(KEY_Width,dWidth);

		int nDir = 0;
		pXDataMapmaj->GetAt(PIPE_BWELDDOT,nDir);
		pXDataMap->SetAt(PIPE_BWELDDOT,nDir);

		pXDataMapmaj->GetAt(DOC_WELDDIA,dWidth);
		pXDataMap->SetAt(DOC_WELDDIA,dWidth);

		CString strTemp,sMaterial;
		pXDataMap->SetAt(KEY_TYPE,_T("GBTEE"));

		pXDataMapmaj->GetAt(PIPE_MATERIAL,sMaterial);
		pXDataMap->SetAt(PIPE_MATERIAL,sMaterial);

		pXDataMapmaj->GetAt(PIPE_MATERIALFT,sMaterial);
		pXDataMap->SetAt(PIPE_MATERIALFT,sMaterial);

		if (m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5)
		{
			pXDataMapmaj->GetAt(PIPE_INTERFACEL,dWidth);
			pXDataMap->SetAt(PIPE_INTERFACEL,dWidth);

			pXDataMapmaj->GetAt(PIPE_INTERFACED,dWidth);
			pXDataMap->SetAt(PIPE_INTERFACED,dWidth);
		}

		//设置图层
		SetFittingLayer(pFitting, param.szSys);

		//pFitting->ReCreateByXDataMap();

		//可能的几种修改，更改弯头两头的管子的位置
		AcGePoint3d ptGe;
		if (intf1.vtDir.isParallelTo(vtMin))
		{
			ptGe = ptGeM + dS * vtMin;
			ModifyPipeOfElbow(GetConnectObject(intf1, m_arHistoryIntfs),intf1.ptPos,ptGe);
		}

		if (intf2.vtDir.isParallelTo(vtMin))
		{
			ptGe = ptGeM + dS * vtMin;
			ModifyPipeOfElbow(GetConnectObject(intf2, m_arHistoryIntfs),intf2.ptPos,ptGe);
		}

		if (intf1.vtDir.isParallelTo(vtMaj))
		{
			ptGe = ptGeM - dL * vtMaj;
			ModifyPipeOfElbow(GetConnectObject(intf1, m_arHistoryIntfs),intf1.ptPos,ptGe);
		}

		if (intf2.vtDir.isParallelTo(vtMaj))
		{
			ptGe = ptGeM - dL * vtMaj;//反向
			ModifyPipeOfElbow(GetConnectObject(intf2, m_arHistoryIntfs),intf2.ptPos,ptGe);
		}

		//替换pdbfit
		pDbFit->erase();

		setInfo2Ent(*pXDataMap);
		AcDbObjectId id = AddFitToModelSpace(pFitting);
		AddUserData(id,pXDataMapmaj,2);
		//
		AECStatusRecord* pRecMid = new AECStatusRecord;
		pRecMid->CopyFrom(pCurRec);
		ptGe = ptGeM + vtMaj * dL;
		pRecMid->SetAcquirePoint(ptGe);
		m_pPipeJig->PushBackStatusRec(pRecMid);

		return TRUE;
	}
	else//焊接方式，加补强圈
	{
		
	}
	return FALSE;
}

BOOL TDbPipeLine::ChangeTeeToCross(AecDbEwFitting* pDbFit,AcGeVector3d& vtMaj,AcGeVector3d& vtMin,AECStatusRecord* pCurRec)
{
	CString sDNo = m_pPipeParam->szODSn;
	IsPlasticsMat(m_pPipeParam, sDNo);

	double dL = 0.0,dB = 0.0;
	TDbPipeSupport::QueryCrossData(m_pPipeJig->GetAdoDb(),m_pPipeParam->m_dDN,m_pPipeParam->m_dDN,dL,dB);

	AecDbObjXDataMap* pXDataMap = pDbFit->GetSpecialtyData();

	double dInterfaceL = 0.0;
	pXDataMap->GetAt(PIPE_INTERFACEL,dInterfaceL);
	if (dInterfaceL > 1.e-3)//法兰管
	{
		dL += dInterfaceL;
		dB += dInterfaceL;
	}

	if (m_pPipeParam->m_app == WPipe::eDuct)
		pXDataMap->SetAt(KEY_RUNTIME, eDuctCross);
	else if (m_pPipeParam->m_app == WPipe::eBridge)
		pXDataMap->SetAt(KEY_RUNTIME, eBridgeCross);
	else
		pXDataMap->SetAt(KEY_RUNTIME, eCross);

	pXDataMap->SetAt(KEY_MAJBR,vtMaj);
	pXDataMap->SetAt(KEY_MINBR,vtMin);//

	AcGeVector3d vtNro = vtMaj.crossProduct(vtMin);//
	pXDataMap->SetAt(KEY_NORMAL,vtNro);

	pXDataMap->SetAt(KEY_L,dL);
	pXDataMap->SetAt(KEY_T,dB);

	pXDataMap->SetAt(PIPE_TDN,m_pPipeParam->m_dDN);
	pXDataMap->SetAt(PIPE_TOD,m_pPipeParam->m_dOD);

	AcGePoint3d ptMid;
	pXDataMap->GetAt(KEY_MID,ptMid);
	//pDbFit->ReCreateByXDataMap();
	
	if (IsPlasticsMat(m_pPipeParam, sDNo))
	{
		TDbPipeSupport::QueryPVCCrossData(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, m_pPipeParam->m_dDN, pXDataMap, sDNo);
	}

	vtMin.normalize();
	AcGePoint3d ptGe = ptMid - vtMin * dB;

	AECStatusRecord* pRecMid = new AECStatusRecord;
	pRecMid->CopyFrom(pCurRec);
	pRecMid->SetAcquirePoint(ptGe);
	m_pPipeJig->PushBackStatusRec(pRecMid);

	return TRUE;
}

void TDbPipeLine::ModifyPipeOfElbow(AcDbObjectId id,AcGePoint3d ptOld,AcGePoint3d ptNew)
{
	AcDbEntity* pEnt = NULL;
	if (Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite))
	{
		AecDbEwPipe* pPipe = AecDbEwPipe::cast(pEnt);
		if (pPipe != NULL)
		{
			AcGePoint3d ptGeT;
			AcGeVector3d vtPipe = pPipe->EndPoint() - pPipe->StartPoint();

			if ( pPipe->EndPoint().distanceTo(ptOld) < 1.e-3)
			{
				ptGeT = pPipe->EndPoint();
				pPipe->SetEndPoint(ptNew);
			}

			if (pPipe->StartPoint().distanceTo(ptOld) < 1.e-3)
			{
				ptGeT = pPipe->StartPoint();
				pPipe->SetStartPoint(ptNew);
			}
		}
		pEnt->close();
	}
}

BOOL TDbPipeLine::Add2Flange(AcGePoint3d& ptMid,double dSpaceHalf,double dPressure,AcGeVector3d& vtDir,CStringArray& arValuesG, CString& sEndF1, CString & sEndF2)
{
	if (m_pPipeJig == NULL)
		return FALSE;

	//[法兰外径],[法兰厚度],[法兰高度]
	double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
	TDbPipeSupport::QueryFlangData(m_pPipeJig->GetAdoDb(),m_pPipeParam->m_dDN,dPressure,dWD,dWh,dThk,dN);

	dThk = dWh;//默认一律不带颈

	AcGePoint3d ptGe1 = ptMid + vtDir * dSpaceHalf;
	AcGeVector3d vtMaj = vtDir;
	vtMaj.negate();
	Add1Flange(ptGe1,vtMaj,dWD,dWh,dThk,dN,arValuesG,sEndF1);

	ptGe1 = ptMid - vtDir * dSpaceHalf;
	vtMaj = vtDir;
	Add1Flange(ptGe1,vtMaj,dWD,dWh,dThk,dN,arValuesG,sEndF2);

	return TRUE;
}

BOOL TDbPipeLine::Add2Flange(AcGePoint3d &ptMid, double dWD, double dWh, double dSpaceHalf,double dThk, double dN, AcGeVector3d &vtDir,CStringArray &arValuesG, CString &sEndF1, CString &sEndF2)
{
	AcGePoint3d ptGe1 = ptMid + vtDir * dSpaceHalf;
	AcGeVector3d vtMaj = vtDir;
	vtMaj.negate();
	Add1Flange(ptGe1, vtMaj, dWD, dWh, dThk, dN, arValuesG,sEndF1);

	ptGe1 = ptMid - vtDir * dSpaceHalf;
	vtMaj = vtDir;
	Add1Flange(ptGe1, vtMaj, dWD, dWh, dThk, dN, arValuesG,sEndF2);

	return TRUE;
}

BOOL TDbPipeLine::Add1Flange(AcGePoint3d ptSta,AcGeVector3d vtMaj,double dWD,double dWh,double dThk,double dN,
							 CStringArray& arValuesG,CString& sEndF,BOOL bIsMangBan/* = false*/)
{
	AecDbEwFitting* pFlange = new AecDbEwFitting;
	AecDbObjXDataMap* pXDataMapF = pFlange->GetSpecialtyData();
	FillConfigXDataMap(pXDataMapF,m_pPipeParam);

	pXDataMapF->SetAt(KEY_FITSRV,KEY_FITWPIPE);
	pXDataMapF->SetAt(KEY_RUNTIME,eFlange);
	pXDataMapF->SetAt(KEY_MAJBR,vtMaj);
	pXDataMapF->SetAt(KEY_NORMAL,AcGeVector3d::kZAxis);
	pXDataMapF->SetAt(PIPE_DRAWDIR,m_pPipeParam->m_eD);		//绘制类型
	//pXDataMapF->SetAt(KEY_2DSTYLE,1);	//单线
	pXDataMapF->SetAt(KEY_2DSTYLE, PipelineTools::isDoubleLine(dN) ? 2 : 1);
	pXDataMapF->SetAt(PIPE_DN,m_pPipeParam->m_dDN);
	pXDataMapF->SetAt(PIPE_N,dN);
	pXDataMapF->SetAt(PIPE_OD,m_pPipeParam->m_dOD);
	pXDataMapF->SetAt(PIPE_WD,dWD);	//发兰盘外径
	pXDataMapF->SetAt(PIPE_WTHICK,dWh);	//大盘面厚度
	pXDataMapF->SetAt(PIPE_THICK, dWh);//总厚
	pXDataMapF->SetAt(KEY_START,ptSta);
	pXDataMapF->SetAt(KEY_GRIPCMD, GRIP_CMD);
	pXDataMapF->SetAt(PIPE_SYS,m_pPipeParam->szSys);
	pXDataMapF->SetAt(PIPE_FLANGF, sEndF);

	//市政法兰不带颈画法
	pXDataMapF->SetAt(KEY_FLANGNECK,(m_pPipeParam->m_nConnectType == 3 || m_pPipeParam->m_nConnectType == 5) ? FALSE : TRUE);

	//盲板不带颈
	if (bIsMangBan)
	{
		pXDataMapF->SetAt(KEY_FLANGNECK,FALSE);
	}

	//根据等级->法兰标准号
	TDbPipeSupport::QueryFlangSpec(m_pPipeJig->GetAdoDb(), m_pPipeParam->m_dDN, m_pPipeParam->m_dPress,m_pPipeParam->szLevel, pXDataMapF);

	//垫片
	/*
	(0,_T("公称直径"),LVCFMT_LEFT,100,80);
	(1,_T("材质"),LVCFMT_LEFT,100,80);
	(2,_T("压力"),LVCFMT_LEFT,50,50);
	(3,_T("垫片厚度"),LVCFMT_LEFT,50,50);
	(4,_T("描述"),LVCFMT_LEFT,200,200);
	*/

	if (arValuesG.GetCount() > 4)
	{
		pXDataMapF->SetAt(PIPE_GASKETM, arValuesG.GetAt(1));
		pXDataMapF->SetAt(PIPE_PRESSURE, _ttof(arValuesG.GetAt(2)));
		pXDataMapF->SetAt(PIPE_GASKET, _ttof(arValuesG.GetAt(3)));
		pXDataMapF->SetAt(PIPE_GASKETDSC, arValuesG.GetAt(4));
	}
	pXDataMapF->SetAt(KEY_FLANGSLAB,bIsMangBan);

	//设置图层
	SetFittingLayer(pFlange, m_pPipeParam->szSys);
	
	setInfo2Ent(*pXDataMapF);
	AcDbObjectId id = AddFitToModelSpace(pFlange);
	AddUserData(id,pXDataMapF,4);
	m_idTemp = id;
	return TRUE;
}

double TDbPipeLine::PixelToWcs(int nPixel)
{
	ads_point ptScreenSize;
	double nViewSize;
	struct resbuf rb1,rb2;
	acedGetVar(_T("ScreenSize"), &rb1);
	acedGetVar(_T("ViewSize"), &rb2);
	nViewSize = rb2.resval.rreal;
	ads_point_set(rb1.resval.rpoint,ptScreenSize);

	if (ptScreenSize[1] < 1.0E-6 || nViewSize < 1.0E-6)
		return 0.0;

	double hight = (nViewSize / ptScreenSize[Y]) * nPixel;
	return hight;
}

//8字盲板
BOOL TDbPipeLine::AddSBFlange(CString& sLevel,double dDn,AcGePoint3d &ptOn,const AcGeVector3d& vtMaj,BOOL bIsMB)
{
	AecDbEwFitting *pFitting = new AecDbEwFitting;
	AecDbObjXDataMap *pXDataMap = pFitting->GetSpecialtyData();
	FillConfigXDataMap(pXDataMap, m_pPipeParam);

	//先到等级中查询
	double dPress = 1.0;
	if (!TDbPipeSupport::QuerySBFSpec(m_pPipeJig->GetAdoDb(), sLevel, dDn, pXDataMap))
	{
		delete pFitting;
		acutPrintf(_T("\n没有查询到公称直径%d 等级%s的八字盲板等级记录!"), (int)(dDn + 0.5), sLevel);
		return FALSE;
	}

	//盲板表
	pXDataMap->GetAt(PID_PIPE_DPRESS,dPress);
	if ( !TDbPipeSupport::QuerySBFlange(m_pPipeJig->GetAdoDb(),dDn, dPress, pXDataMap))
	{
		delete pFitting;
		acutPrintf(_T("\n没有查询到公称直径%d 压力%.1f 八字盲板数据!创建失败!"),(int)(dDn+0.5),dPress);
		return FALSE;
	}
	
	//TDbPipeSupport::QueryGasketData(pDb, dDn,sLevel, pXDataMap);

	//m_mapSpecXData.GetAt(PIPE_GASKET, dGasket);
	pXDataMap->SetAt(PIPE_GASKET, 1.5);

	double dThk = 0.0;
	pXDataMap->GetAt(PIPE_THICK, dThk);//总厚

	pXDataMap->SetAt(KEY_FITSRV, KEY_FITWPIPE);
	pXDataMap->SetAt(KEY_RUNTIME, eSPB);
	pXDataMap->SetAt(KEY_KIND, bIsMB);

	AcGeVector3d vtMin = vtMaj.perpVector();
	AcGeLine3d ln(AcGePoint3d(100,100,100),vtMaj);
	if (ln.isParallelTo(AcGePlane::kXYPlane))
	{
		vtMin = vtMaj;
		vtMin.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
	}

	pXDataMap->SetAt(KEY_MAJBR, vtMaj);
	pXDataMap->SetAt(KEY_MINBR, vtMin);
	pXDataMap->SetAt(KEY_MID, ptOn);

	pXDataMap->SetAt(PIPE_GASKET, 0.0);
	pXDataMap->SetAt(KEY_2DSTYLE, 1);

	CString sPro = _T("工业");
	pXDataMap->GetAt(DOC_PROJECT, sPro);
	//管嘴 垫片
	TDbPipeSupport::SetGasketData(m_pPipeJig->GetAdoDb(), 0, dDn, dPress, sPro, sLevel, pXDataMap);

	//设置图层
	SetFittingLayer(pFitting, m_pPipeParam->szSys);

	setInfo2Ent(*pXDataMap);
	AcDbObjectId id = AddFitToModelSpace(pFitting);
	AddUserData(id, pXDataMap, 4);
	m_idTemp = id;

	return TRUE;
}